@remotion/webcodecs 4.0.231 → 4.0.233

package/README.md

@@ -18,7 +18,7 @@ Remove the `^` character from the version number to use the exact version.
 See the [documentation](https://remotion.dev/webcodecs) for more information.
 
 ## License
-This package is licensed under the [/docs/license](Remotion License).
+This package is licensed under the [Remotion License](/docs/license).
 We consider a team of 4 or more people a "company".
 
 **For "companies"**: A Remotion Company license needs to be obtained to use this package.
@@ -26,4 +26,4 @@ In a future version of `@remotion/webcodecs`, this package will also require the
 
 **For individuals and teams up to 3**: You can use this package for free.
 
-This is a short, non-binding explanation of our license. See the [https://remotion.dev/docs/license](License) itself for more details.
+This is a short, non-binding explanation of our license. See the [License](https://remotion.dev/docs/license) itself for more details.

package/dist/audio-decoder-config.d.ts

@@ -1 +1,2 @@
-export declare const getAudioDecoderConfig: (config: AudioDecoderConfig) => Promise<AudioDecoderConfig | null>;
+import type { LogLevel } from './log';
+export declare const getAudioDecoderConfig: (config: AudioDecoderConfig, logLevel: LogLevel) => Promise<AudioDecoderConfig | null>;

package/dist/audio-decoder-config.js

@@ -1,15 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioDecoderConfig = void 0;
-const getAudioDecoderConfig = async (config) => {
+const browser_quirks_1 = require("./browser-quirks");
+const log_1 = require("./log");
+const overrideBrowserQuirks = ({ config, logLevel, }) => {
+    const bytes = config.description;
+    if (!bytes) {
+        return config;
+    }
+    if (bytes[0] === 18 && bytes[1] === 8) {
+        // riverside_use_cursor_.mp4
+        if ((0, browser_quirks_1.isFirefox)()) {
+            return {
+                ...config,
+                codec: 'mp4a.40.2',
+                description: bytes,
+            };
+        }
+        if (!(0, browser_quirks_1.isChrome)()) {
+            return config;
+        }
+        log_1.Log.warn(logLevel, 'Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330');
+        return {
+            ...config,
+            description: new Uint8Array([18, 16]),
+        };
+    }
+    if (bytes.byteLength === 2 && bytes[0] === 17 && bytes[1] === 136) {
+        log_1.Log.warn(logLevel, 'Chrome has a bug and might not be able to decode this audio. It will be fixed, see: https://issues.chromium.org/issues/360083330');
+        return {
+            ...config,
+            description: new Uint8Array([18, 144]),
+        };
+    }
+    return config;
+};
+const getAudioDecoderConfig = async (config, logLevel) => {
+    if (config.codec === 'pcm-s16') {
+        return config;
+    }
     if (typeof AudioDecoder === 'undefined') {
         return null;
     }
     if (typeof EncodedAudioChunk === 'undefined') {
         return null;
     }
-    if ((await AudioDecoder.isConfigSupported(config)).supported) {
-        return config;
+    const realConfig = overrideBrowserQuirks({
+        config,
+        logLevel,
+    });
+    if ((await AudioDecoder.isConfigSupported(realConfig)).supported) {
+        return realConfig;
     }
     return null;
 };

package/dist/audio-decoder.d.ts

@@ -1,14 +1,17 @@
-import type { AudioOrVideoSample, LogLevel } from '@remotion/media-parser';
+import type { AudioOrVideoSample, AudioTrack, LogLevel, ProgressTracker } from '@remotion/media-parser';
 export type WebCodecsAudioDecoder = {
     processSample: (audioSample: AudioOrVideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;
 };
-export declare const createAudioDecoder: ({ onFrame, onError, signal, config, logLevel, }: {
+export type CreateAudioDecoderInit = {
     onFrame: (frame: AudioData) => Promise<void>;
     onError: (error: DOMException) => void;
     signal: AbortSignal;
     config: AudioDecoderConfig;
     logLevel: LogLevel;
-}) => WebCodecsAudioDecoder;
+    track: AudioTrack;
+    progressTracker: ProgressTracker;
+};
+export declare const createAudioDecoder: ({ onFrame, onError, signal, config, logLevel, track, progressTracker, }: CreateAudioDecoderInit) => WebCodecsAudioDecoder;

package/dist/audio-decoder.js

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAudioDecoder = void 0;
+const get_wave_audio_decoder_1 = require("./get-wave-audio-decoder");
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
-const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, }) => {
+const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, track, progressTracker, }) => {
     if (signal.aborted) {
         throw new Error('Not creating audio decoder, already aborted');
     }
-    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Audio decoder');
+    if (config.codec === 'pcm-s16') {
+        return (0, get_wave_audio_decoder_1.getWaveAudioDecoder)({ onFrame, track });
+    }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
+        logLevel,
+        label: 'Audio decoder',
+        progress: progressTracker,
+    });
     let outputQueue = Promise.resolve();
     const audioDecoder = new AudioDecoder({
         output(inputFrame) {
@@ -53,7 +61,11 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, }) =>
         if (audioDecoder.state === 'closed') {
             return;
         }
-        await ioSynchronizer.waitFor({ unemitted: 100, _unprocessed: 2 });
+        await ioSynchronizer.waitFor({
+            unemitted: 20,
+            _unprocessed: 20,
+            minimumProgress: audioSample.timestamp - 10000000,
+        });
         // Don't flush, it messes up the audio
         const chunk = new EncodedAudioChunk(audioSample);
         audioDecoder.decode(chunk);
@@ -62,11 +74,21 @@ const createAudioDecoder = ({ onFrame, onError, signal, config, logLevel, }) =>
     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;
         },
         waitForFinish: async () => {
-            await audioDecoder.flush();
+            // Firefox might throw "Needs to be configured first"
+            try {
+                await audioDecoder.flush();
+            }
+            catch (_a) { }
+            await queue;
             await ioSynchronizer.waitForFinish();
             await outputQueue;
         },

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

@@ -1 +1,4 @@
-export declare const getAudioEncoderConfig: (config: AudioEncoderConfig) => Promise<AudioEncoderConfig | null>;
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+export declare const getAudioEncoderConfig: (config: AudioEncoderConfig & {
+    codec: ConvertMediaAudioCodec;
+}) => Promise<AudioEncoderConfig | null>;

package/dist/audio-encoder-config.js

@@ -8,6 +8,9 @@ const getCodecString = (audioCodec) => {
     if (audioCodec === 'aac') {
         return 'mp4a.40.02';
     }
+    if (audioCodec === 'wav') {
+        return 'wav-should-not-to-into-audio-encoder';
+    }
     throw new Error(`Unsupported audio codec: ${audioCodec}`);
 };
 const getAudioEncoderConfig = async (config) => {
@@ -15,6 +18,9 @@ const getAudioEncoderConfig = async (config) => {
         ...config,
         codec: getCodecString(config.codec),
     };
+    if (config.codec === 'wav') {
+        return actualConfig;
+    }
     if (typeof AudioEncoder === 'undefined') {
         return null;
     }

package/dist/audio-encoder.d.ts

@@ -1,12 +1,12 @@
-import type { LogLevel } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
+import type { LogLevel, ProgressTracker } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 export type WebCodecsAudioEncoder = {
     encodeFrame: (audioData: AudioData) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;
 };
-export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }: {
+export type AudioEncoderInit = {
     onChunk: (chunk: EncodedAudioChunk) => Promise<void>;
     onError: (error: DOMException) => void;
     codec: ConvertMediaAudioCodec;
@@ -14,4 +14,6 @@ export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, con
     config: AudioEncoderConfig;
     logLevel: LogLevel;
     onNewAudioSampleRate: (sampleRate: number) => void;
-}) => WebCodecsAudioEncoder;
+    progressTracker: ProgressTracker;
+};
+export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, progressTracker, }: AudioEncoderInit) => WebCodecsAudioEncoder;

package/dist/audio-encoder.js

@@ -2,11 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAudioEncoder = void 0;
 const io_synchronizer_1 = require("./io-manager/io-synchronizer");
-const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }) => {
+const wav_audio_encoder_1 = require("./wav-audio-encoder");
+const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, progressTracker, }) => {
     if (signal.aborted) {
         throw new Error('Not creating audio encoder, already aborted');
     }
-    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)(logLevel, 'Audio encoder');
+    if (codec === 'wav') {
+        return (0, wav_audio_encoder_1.getWaveAudioEncoder)({ onChunk, signal });
+    }
+    const ioSynchronizer = (0, io_synchronizer_1.makeIoSynchronizer)({
+        logLevel,
+        label: 'Audio encoder',
+        progress: progressTracker,
+    });
     let prom = Promise.resolve();
     const encoder = new AudioEncoder({
         output: (chunk) => {
@@ -50,7 +58,11 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
         if (encoder.state === 'closed') {
             return;
         }
-        await ioSynchronizer.waitFor({ unemitted: 20, _unprocessed: 20 });
+        await ioSynchronizer.waitFor({
+            unemitted: 20,
+            _unprocessed: 20,
+            minimumProgress: audioData.timestamp - 10000000,
+        });
         // @ts-expect-error - can have changed in the meanwhile
         if (encoder.state === 'closed') {
             return;

package/dist/browser-quirks.d.ts

@@ -1,2 +1,3 @@
 export declare const isFirefox: () => boolean;
 export declare const isSafari: () => boolean;
+export declare const isChrome: () => boolean;

package/dist/browser-quirks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSafari = exports.isFirefox = void 0;
+exports.isChrome = exports.isSafari = exports.isFirefox = void 0;
 const isFirefox = () => {
     return navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
 };
@@ -9,3 +9,7 @@ const isSafari = () => {
     return /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
 };
 exports.isSafari = isSafari;
+const isChrome = () => {
+    return navigator.userAgent.toLowerCase().indexOf('chrome') > -1;
+};
+exports.isChrome = isChrome;

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

@@ -1,5 +1,5 @@
 import type { MediaParserAudioCodec } from '@remotion/media-parser';
-import type { ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const canCopyAudioTrack: ({ inputCodec, container, }: {
     inputCodec: MediaParserAudioCodec;
     container: ConvertMediaContainer;

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

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

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

@@ -1,6 +1,8 @@
 import type { MediaParserVideoCodec } from '@remotion/media-parser';
-import type { ConvertMediaContainer } from './codec-id';
-export declare const canCopyVideoTrack: ({ inputCodec, container, }: {
+import type { ConvertMediaContainer } from './get-available-containers';
+export declare const canCopyVideoTrack: ({ inputCodec, container, inputRotation, rotationToApply, }: {
     inputCodec: MediaParserVideoCodec;
+    inputRotation: number;
+    rotationToApply: number;
     container: ConvertMediaContainer;
 }) => boolean;

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

@@ -1,12 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyVideoTrack = void 0;
-const canCopyVideoTrack = ({ inputCodec, container, }) => {
+const rotate_video_frame_1 = require("./rotate-video-frame");
+const canCopyVideoTrack = ({ inputCodec, container, inputRotation, rotationToApply, }) => {
+    if ((0, rotate_video_frame_1.normalizeVideoRotation)(inputRotation) !==
+        (0, rotate_video_frame_1.normalizeVideoRotation)(rotationToApply)) {
+        return false;
+    }
     if (container === 'webm') {
         return inputCodec === 'vp8' || inputCodec === 'vp9';
     }
     if (container === 'mp4') {
-        return inputCodec === 'h264' || inputCodec === 'h265';
+        return inputCodec === 'h264';
+    }
+    if (container === 'wav') {
+        return false;
     }
     throw new Error(`Unhandled codec: ${container}`);
 };

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

@@ -1,7 +1,8 @@
-import type { AudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
-export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
+import type { AudioTrack, LogLevel } from '@remotion/media-parser';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, logLevel, }: {
     track: AudioTrack;
     audioCodec: ConvertMediaAudioCodec;
     bitrate: number;
+    logLevel?: LogLevel;
 }) => Promise<boolean>;

package/dist/can-reencode-audio-track.js

@@ -3,8 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.canReencodeAudioTrack = void 0;
 const audio_decoder_config_1 = require("./audio-decoder-config");
 const audio_encoder_config_1 = require("./audio-encoder-config");
-const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, }) => {
-    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)(track);
+const canReencodeAudioTrack = async ({ track, audioCodec, bitrate, logLevel = 'info', }) => {
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)(track, logLevel);
+    if (audioCodec === 'wav' && audioDecoderConfig) {
+        return true;
+    }
     const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
         codec: audioCodec,
         numberOfChannels: track.numberOfChannels,

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

@@ -1,5 +1,5 @@
 import type { VideoTrack } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
     videoCodec: ConvertMediaVideoCodec;
     track: VideoTrack;

package/dist/codec-id.d.ts

@@ -1,10 +1,10 @@
-declare const availableContainers: readonly ["webm", "mp4"];
+declare const availableContainers: readonly ["webm", "mp4", "wav"];
 export type ConvertMediaContainer = (typeof availableContainers)[number];
 export declare const getAvailableContainers: () => readonly ConvertMediaContainer[];
 declare const availableVideoCodecs: readonly ["vp8", "vp9", "h264"];
 export type ConvertMediaVideoCodec = (typeof availableVideoCodecs)[number];
 export declare const getAvailableVideoCodecs: (container: ConvertMediaContainer) => ConvertMediaVideoCodec[];
-declare const availableAudioCodecs: readonly ["opus", "aac"];
+declare const availableAudioCodecs: readonly ["opus", "aac", "wav"];
 export declare const getAvailableAudioCodecs: (container: ConvertMediaContainer) => ConvertMediaAudioCodec[];
 export type ConvertMediaAudioCodec = (typeof availableAudioCodecs)[number];
 export {};

package/dist/codec-id.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAvailableAudioCodecs = exports.getAvailableVideoCodecs = exports.getAvailableContainers = void 0;
-const availableContainers = ['webm', 'mp4'];
+const availableContainers = ['webm', 'mp4', 'wav'];
 const getAvailableContainers = () => {
     return availableContainers;
 };
@@ -15,11 +15,14 @@ const getAvailableVideoCodecs = (container) => {
     if (container === 'webm') {
         return ['vp8', 'vp9'];
     }
+    if (container === 'wav') {
+        return [];
+    }
     throw new Error(`Unsupported container: ${container}`);
 };
 exports.getAvailableVideoCodecs = getAvailableVideoCodecs;
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-const availableAudioCodecs = ['opus', 'aac'];
+const availableAudioCodecs = ['opus', 'aac', 'wav'];
 const getAvailableAudioCodecs = (container) => {
     if (container === 'mp4') {
         return ['aac'];
@@ -27,6 +30,9 @@ const getAvailableAudioCodecs = (container) => {
     if (container === 'webm') {
         return ['opus'];
     }
+    if (container === 'wav') {
+        return ['wav'];
+    }
     throw new Error(`Unsupported container: ${container}`);
 };
 exports.getAvailableAudioCodecs = getAvailableAudioCodecs;

package/dist/convert-media.d.ts

@@ -3,7 +3,9 @@
  * For licensing, see: https://remotion.dev/docs/webcodecs#license
  */
 import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack, WriterInterface } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec, ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
+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';
 export type ConvertMediaProgress = {
@@ -26,7 +28,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, ...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, ...more }: {
     src: ParseMediaOptions<F>["src"];
     container: ConvertMediaContainer;
     onVideoFrame?: ConvertMediaOnVideoFrame;
@@ -40,4 +42,5 @@ export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src,
     logLevel?: LogLevel;
     writer?: WriterInterface;
     progressIntervalInMs?: number;
+    rotate?: number;
 } & ParseMediaDynamicOptions<F>) => Promise<ConvertMediaResult>;

package/dist/convert-media.js

@@ -15,20 +15,20 @@ const error_cause_1 = __importDefault(require("./error-cause"));
 const generate_output_filename_1 = require("./generate-output-filename");
 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 throttled_state_update_1 = require("./throttled-state-update");
-const with_resolvers_1 = require("./with-resolvers");
-const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, ...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, ...more }) {
     var _a, _b;
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
     }
-    if (container !== 'webm' && container !== 'mp4') {
-        return Promise.reject(new TypeError('Only `to: "webm"` and `to: "mp4"` is supported currently'));
+    if (container !== 'webm' && container !== 'mp4' && container !== 'wav') {
+        return Promise.reject(new TypeError('Only `to: "webm"`, `to: "mp4"` and `to: "wav"` is supported currently'));
     }
     if (videoCodec && videoCodec !== 'vp8' && videoCodec !== 'vp9') {
         return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
     }
-    const { resolve, reject, getPromiseToImmediatelyReturn } = (0, with_resolvers_1.withResolversAndWaitForReturn)();
+    const { resolve, reject, getPromiseToImmediatelyReturn } = media_parser_1.MediaParserInternals.withResolversAndWaitForReturn();
     const controller = new AbortController();
     const abortConversion = (errCause) => {
         reject(errCause);
@@ -40,14 +40,13 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         abortConversion(new error_cause_1.default('Conversion aborted by user'));
     };
     userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.addEventListener('abort', onUserAbort);
-    const creator = container === 'webm'
-        ? media_parser_1.MediaParserInternals.createMatroskaMedia
-        : media_parser_1.MediaParserInternals.createIsoBaseMedia;
+    const creator = (0, select_container_creator_1.selectContainerCreator)(container);
     const throttledState = (0, throttled_state_update_1.throttledStateUpdate)({
         updateFn: onProgressDoNotCallDirectly !== null && onProgressDoNotCallDirectly !== void 0 ? onProgressDoNotCallDirectly : null,
         everyMilliseconds: progressIntervalInMs !== null && progressIntervalInMs !== void 0 ? progressIntervalInMs : 100,
         signal: controller.signal,
     });
+    const progressTracker = media_parser_1.MediaParserInternals.makeProgressTracker();
     const state = await creator({
         filename: (0, generate_output_filename_1.generateOutputFilename)(src, container),
         writer: await (0, auto_select_writer_1.autoSelectWriter)(writer, logLevel),
@@ -77,6 +76,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
             });
         },
         logLevel,
+        progressTracker,
     });
     const onVideoTrack = (0, on_video_track_1.makeVideoTrackHandler)({
         state,
@@ -88,6 +88,8 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : null,
         logLevel,
         container,
+        rotate: rotate !== null && rotate !== void 0 ? rotate : 0,
+        progress: progressTracker,
     });
     const onAudioTrack = (0, on_audio_track_1.makeAudioTrackHandler)({
         abortConversion,
@@ -98,6 +100,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : null,
         logLevel,
         container,
+        progressTracker,
     });
     (0, media_parser_1.parseMedia)({
         logLevel,

package/dist/convert-to-correct-videoframe.d.ts

@@ -1,4 +1,4 @@
-import type { ConvertMediaVideoCodec } from './codec-id';
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
 export declare const needsToCorrectVideoFrame: ({ videoFrame, outputCodec, }: {
     videoFrame: VideoFrame;
     outputCodec: ConvertMediaVideoCodec;

package/dist/convert-to-correct-videoframe.js

@@ -3,6 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToCorrectVideoFrame = exports.needsToCorrectVideoFrame = void 0;
 const browser_quirks_1 = require("./browser-quirks");
 const needsToCorrectVideoFrame = ({ videoFrame, outputCodec, }) => {
+    // On Chrome when dropping a vertical iPhone video
+    if (videoFrame.format === null) {
+        return true;
+    }
+    // copy8f9178c2-e8ab-4538-9591-f8336602e49b-3mp4 - HDR videos
+    if (videoFrame.format === 'I420P10') {
+        return true;
+    }
     return (0, browser_quirks_1.isFirefox)() && videoFrame.format === 'BGRX' && outputCodec === 'h264';
 };
 exports.needsToCorrectVideoFrame = needsToCorrectVideoFrame;

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

@@ -5,23 +5,33 @@ const media_parser_1 = require("@remotion/media-parser");
 const can_copy_video_track_1 = require("./can-copy-video-track");
 const can_reencode_video_track_1 = require("./can-reencode-video-track");
 const get_default_video_codec_1 = require("./get-default-video-codec");
-const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel, container, }) => {
+const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel, container, rotate, }) => {
     const canCopy = (0, can_copy_video_track_1.canCopyVideoTrack)({
         inputCodec: track.codecWithoutConfig,
         container,
+        inputRotation: track.rotation,
+        rotationToApply: rotate,
     });
     if (canCopy) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Can copy, therefore copying`);
         return Promise.resolve({ type: 'copy' });
     }
     const videoCodec = defaultVideoCodec !== null && defaultVideoCodec !== void 0 ? defaultVideoCodec : (0, get_default_video_codec_1.getDefaultVideoCodec)({ container });
+    if (videoCodec === null) {
+        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): No default video codec, therefore dropping`);
+        return Promise.resolve({ type: 'drop' });
+    }
     const canReencode = await (0, can_reencode_video_track_1.canReencodeVideoTrack)({
         videoCodec,
         track,
     });
     if (canReencode) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
-        return Promise.resolve({ type: 'reencode', videoCodec });
+        return Promise.resolve({
+            type: 'reencode',
+            videoCodec,
+            rotation: rotate - track.rotation,
+        });
     }
     media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
     return Promise.resolve({ type: 'fail' });