@remotion/webcodecs 4.0.230 → 4.0.232

package/README.md

@@ -15,4 +15,15 @@ Remove the `^` character from the version number to use the exact version.
  
 ## Usage
  
-This is an internal package and has no documentation.
+See the [documentation](https://remotion.dev/webcodecs) for more information.
+
+## License
+This package is licensed under the [/docs/license](Remotion 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.
+In a future version of `@remotion/webcodecs`, this package will also require the purchase of a newly created "WebCodecs Conversion Seat". [Get in touch](https://remotion.dev/contact) with us if you are planning to use this package.
+
+**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.

package/dist/audio-decoder.js

@@ -62,11 +62,17 @@ 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();
+            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 { 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,5 @@ export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, con
     config: AudioEncoderConfig;
     logLevel: LogLevel;
     onNewAudioSampleRate: (sampleRate: number) => void;
-}) => WebCodecsAudioEncoder;
+};
+export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }: AudioEncoderInit) => WebCodecsAudioEncoder;

package/dist/audio-encoder.js

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

package/dist/browser-quirks.d.ts

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

package/dist/browser-quirks.js

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

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,5 +1,5 @@
 import type { MediaParserVideoCodec } from '@remotion/media-parser';
-import type { ConvertMediaContainer } from './codec-id';
+import type { ConvertMediaContainer } from './get-available-containers';
 export declare const canCopyVideoTrack: ({ inputCodec, container, }: {
     inputCodec: MediaParserVideoCodec;
     container: ConvertMediaContainer;

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

@@ -6,7 +6,10 @@ const canCopyVideoTrack = ({ inputCodec, container, }) => {
         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,5 +1,5 @@
 import type { AudioTrack } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
+import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 export declare const canReencodeAudioTrack: ({ track, audioCodec, bitrate, }: {
     track: AudioTrack;
     audioCodec: ConvertMediaAudioCodec;

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

@@ -5,6 +5,9 @@ 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);
+    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,10 +3,12 @@
  * 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 ConvertMediaState = {
+export type ConvertMediaProgress = {
     decodedVideoFrames: number;
     decodedAudioFrames: number;
     encodedVideoFrames: number;
@@ -19,17 +21,18 @@ export type ConvertMediaState = {
 export type ConvertMediaResult = {
     save: () => Promise<Blob>;
     remove: () => Promise<void>;
+    finalState: ConvertMediaProgress;
 };
-export type ConvertMediaOnMediaStateUpdate = (state: ConvertMediaState) => void;
+export type ConvertMediaOnProgress = (state: ConvertMediaProgress) => void;
 export type ConvertMediaOnVideoFrame = (options: {
     frame: VideoFrame;
     track: VideoTrack;
 }) => Promise<VideoFrame> | VideoFrame;
-export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, ...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, ...more }: {
     src: ParseMediaOptions<F>["src"];
     container: ConvertMediaContainer;
     onVideoFrame?: ConvertMediaOnVideoFrame;
-    onMediaStateUpdate?: ConvertMediaOnMediaStateUpdate;
+    onProgress?: ConvertMediaOnProgress;
     videoCodec?: ConvertMediaVideoCodec;
     audioCodec?: ConvertMediaAudioCodec;
     signal?: AbortSignal;
@@ -38,4 +41,5 @@ export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src,
     reader?: ParseMediaOptions<F>["reader"];
     logLevel?: LogLevel;
     writer?: WriterInterface;
+    progressIntervalInMs?: number;
 } & ParseMediaDynamicOptions<F>) => Promise<ConvertMediaResult>;

package/dist/convert-media.js

@@ -12,15 +12,19 @@ const media_parser_1 = require("@remotion/media-parser");
 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 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, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, ...more }) {
+const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, ...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'));
@@ -37,49 +41,47 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         abortConversion(new error_cause_1.default('Conversion aborted by user'));
     };
     userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.addEventListener('abort', onUserAbort);
-    const convertMediaState = {
-        decodedAudioFrames: 0,
-        decodedVideoFrames: 0,
-        encodedVideoFrames: 0,
-        encodedAudioFrames: 0,
-        bytesWritten: 0,
-        millisecondsWritten: 0,
-        expectedOutputDurationInMs: null,
-        overallProgress: 0,
-    };
-    const onMediaStateUpdate = (newState) => {
-        if (controller.signal.aborted) {
-            return;
-        }
-        onMediaStateDoNoCallDirectly === null || onMediaStateDoNoCallDirectly === void 0 ? void 0 : onMediaStateDoNoCallDirectly(newState);
-    };
-    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 state = await creator({
+        filename: (0, generate_output_filename_1.generateOutputFilename)(src, container),
         writer: await (0, auto_select_writer_1.autoSelectWriter)(writer, logLevel),
         onBytesProgress: (bytesWritten) => {
-            convertMediaState.bytesWritten = bytesWritten;
-            onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
+            var _a;
+            (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, (prevState) => {
+                return {
+                    ...prevState,
+                    bytesWritten,
+                };
+            });
         },
         onMillisecondsProgress: (millisecondsWritten) => {
-            if (millisecondsWritten > convertMediaState.millisecondsWritten) {
-                convertMediaState.millisecondsWritten = millisecondsWritten;
-                convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
-                    millisecondsWritten: convertMediaState.millisecondsWritten,
-                    expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs,
-                });
-                onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
-            }
+            var _a;
+            (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, (prevState) => {
+                if (millisecondsWritten > prevState.millisecondsWritten) {
+                    return {
+                        ...prevState,
+                        millisecondsWritten,
+                        overallProgress: (0, calculate_progress_1.calculateProgress)({
+                            millisecondsWritten: prevState.millisecondsWritten,
+                            expectedOutputDurationInMs: prevState.expectedOutputDurationInMs,
+                        }),
+                    };
+                }
+                return prevState;
+            });
         },
         logLevel,
     });
     const onVideoTrack = (0, on_video_track_1.makeVideoTrackHandler)({
         state,
         onVideoFrame: onVideoFrame !== null && onVideoFrame !== void 0 ? onVideoFrame : null,
-        onMediaStateUpdate: onMediaStateUpdate !== null && onMediaStateUpdate !== void 0 ? onMediaStateUpdate : null,
+        onMediaStateUpdate: (_a = throttledState.update) !== null && _a !== void 0 ? _a : null,
         abortConversion,
-        convertMediaState,
         controller,
         defaultVideoCodec: videoCodec !== null && videoCodec !== void 0 ? videoCodec : null,
         onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : null,
@@ -90,8 +92,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         abortConversion,
         defaultAudioCodec: audioCodec !== null && audioCodec !== void 0 ? audioCodec : null,
         controller,
-        convertMediaState,
-        onMediaStateUpdate: onMediaStateUpdate !== null && onMediaStateUpdate !== void 0 ? onMediaStateUpdate : null,
+        onMediaStateUpdate: (_b = throttledState.update) !== null && _b !== void 0 ? _b : null,
         state,
         onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : null,
         logLevel,
@@ -110,6 +111,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         reader,
         ...more,
         onDurationInSeconds: (durationInSeconds) => {
+            var _a;
             if (durationInSeconds === null) {
                 return null;
             }
@@ -118,22 +120,33 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
                 casted.onDurationInSeconds(durationInSeconds);
             }
             const expectedOutputDurationInMs = durationInSeconds * 1000;
-            convertMediaState.expectedOutputDurationInMs = expectedOutputDurationInMs;
-            convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
-                millisecondsWritten: convertMediaState.millisecondsWritten,
-                expectedOutputDurationInMs,
+            (_a = throttledState.update) === null || _a === void 0 ? void 0 : _a.call(throttledState, (prevState) => {
+                return {
+                    ...prevState,
+                    expectedOutputDurationInMs,
+                    overallProgress: (0, calculate_progress_1.calculateProgress)({
+                        millisecondsWritten: prevState.millisecondsWritten,
+                        expectedOutputDurationInMs,
+                    }),
+                };
             });
-            onMediaStateUpdate(convertMediaState);
         },
     })
         .then(() => {
         return state.waitForFinish();
     })
         .then(() => {
-        resolve({ save: state.save, remove: state.remove });
+        resolve({
+            save: state.save,
+            remove: state.remove,
+            finalState: throttledState.get(),
+        });
     })
         .catch((err) => {
         reject(err);
+    })
+        .finally(() => {
+        throttledState.stopAndGetLastProgress();
     });
     return getPromiseToImmediatelyReturn().finally(() => {
         userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.removeEventListener('abort', onUserAbort);

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

@@ -0,0 +1,9 @@
+import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+export declare const needsToCorrectVideoFrame: ({ videoFrame, outputCodec, }: {
+    videoFrame: VideoFrame;
+    outputCodec: ConvertMediaVideoCodec;
+}) => boolean;
+export declare const convertToCorrectVideoFrame: ({ videoFrame, outputCodec, }: {
+    videoFrame: VideoFrame;
+    outputCodec: ConvertMediaVideoCodec;
+}) => VideoFrame;

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

@@ -0,0 +1,32 @@
+"use strict";
+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;
+    }
+    return (0, browser_quirks_1.isFirefox)() && videoFrame.format === 'BGRX' && outputCodec === 'h264';
+};
+exports.needsToCorrectVideoFrame = needsToCorrectVideoFrame;
+const convertToCorrectVideoFrame = ({ videoFrame, outputCodec, }) => {
+    if (!(0, exports.needsToCorrectVideoFrame)({ videoFrame, outputCodec })) {
+        return videoFrame;
+    }
+    const canvas = new OffscreenCanvas(videoFrame.displayWidth, videoFrame.displayHeight);
+    canvas.width = videoFrame.displayWidth;
+    canvas.height = videoFrame.displayHeight;
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Could not get 2d context');
+    }
+    ctx.drawImage(videoFrame, 0, 0);
+    return new VideoFrame(canvas, {
+        displayHeight: videoFrame.displayHeight,
+        displayWidth: videoFrame.displayWidth,
+        duration: videoFrame.duration,
+        timestamp: videoFrame.timestamp,
+    });
+};
+exports.convertToCorrectVideoFrame = convertToCorrectVideoFrame;

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

@@ -15,6 +15,10 @@ const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel,
         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,