@remotion/webcodecs 4.0.229 → 4.0.231

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/arraybuffer-to-uint8-array.d.ts

@@ -0,0 +1 @@
+export declare const arrayBufferToUint8Array: (buffer: ArrayBuffer | null) => Uint8Array | null;

package/dist/arraybuffer-to-uint8-array.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayBufferToUint8Array = void 0;
+const arrayBufferToUint8Array = (buffer) => {
+    return buffer ? new Uint8Array(buffer) : null;
+};
+exports.arrayBufferToUint8Array = arrayBufferToUint8Array;

package/dist/audio-decoder.d.ts

@@ -1,6 +1,6 @@
-import type { AudioSample, LogLevel } from '@remotion/media-parser';
+import type { AudioOrVideoSample, LogLevel } from '@remotion/media-parser';
 export type WebCodecsAudioDecoder = {
-    processSample: (audioSample: AudioSample) => Promise<void>;
+    processSample: (audioSample: AudioOrVideoSample) => Promise<void>;
     waitForFinish: () => Promise<void>;
     close: () => void;
     flush: () => Promise<void>;

package/dist/audio-encoder-config.js

@@ -1,12 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioEncoderConfig = void 0;
+const getCodecString = (audioCodec) => {
+    if (audioCodec === 'opus') {
+        return 'opus';
+    }
+    if (audioCodec === 'aac') {
+        return 'mp4a.40.02';
+    }
+    throw new Error(`Unsupported audio codec: ${audioCodec}`);
+};
 const getAudioEncoderConfig = async (config) => {
+    const actualConfig = {
+        ...config,
+        codec: getCodecString(config.codec),
+    };
     if (typeof AudioEncoder === 'undefined') {
         return null;
     }
-    if ((await AudioEncoder.isConfigSupported(config)).supported) {
-        return config;
+    if ((await AudioEncoder.isConfigSupported(actualConfig)).supported) {
+        return actualConfig;
     }
     return null;
 };

package/dist/audio-encoder.d.ts

@@ -6,11 +6,12 @@ export type WebCodecsAudioEncoder = {
     close: () => void;
     flush: () => Promise<void>;
 };
-export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, }: {
+export declare const createAudioEncoder: ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }: {
     onChunk: (chunk: EncodedAudioChunk) => Promise<void>;
     onError: (error: DOMException) => void;
     codec: ConvertMediaAudioCodec;
     signal: AbortSignal;
     config: AudioEncoderConfig;
     logLevel: LogLevel;
+    onNewAudioSampleRate: (sampleRate: number) => void;
 }) => WebCodecsAudioEncoder;

package/dist/audio-encoder.js

@@ -2,7 +2,7 @@
 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, }) => {
+const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEncoderConfig, logLevel, onNewAudioSampleRate, }) => {
     if (signal.aborted) {
         throw new Error('Not creating audio encoder, already aborted');
     }
@@ -42,19 +42,31 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
         close();
     };
     signal.addEventListener('abort', onAbort);
-    if (codec !== 'opus') {
-        throw new Error('Only `codec: "opus"` is supported currently');
+    if (codec !== 'opus' && codec !== 'aac') {
+        throw new Error('Only `codec: "opus"` and `codec: "aac"` is supported currently');
     }
-    encoder.configure(audioEncoderConfig);
+    const wantedSampleRate = audioEncoderConfig.sampleRate;
     const encodeFrame = async (audioData) => {
         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;
         }
+        if (encoder.state === 'unconfigured') {
+            if (audioData.sampleRate === wantedSampleRate) {
+                encoder.configure(audioEncoderConfig);
+            }
+            else {
+                encoder.configure({
+                    ...audioEncoderConfig,
+                    sampleRate: audioData.sampleRate,
+                });
+                onNewAudioSampleRate(audioData.sampleRate);
+            }
+        }
         encoder.encode(audioData);
         ioSynchronizer.inputItem(audioData.timestamp, true);
     };

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,8 +1,6 @@
 import type { MediaParserAudioCodec } from '@remotion/media-parser';
-import type { ConvertMediaAudioCodec } from './codec-id';
-import type { ConvertMediaContainer } from './convert-media';
-export declare const canCopyAudioTrack: ({ inputCodec, outputCodec, container, }: {
+import type { ConvertMediaContainer } from './codec-id';
+export declare const canCopyAudioTrack: ({ inputCodec, container, }: {
     inputCodec: MediaParserAudioCodec;
-    outputCodec: ConvertMediaAudioCodec;
     container: ConvertMediaContainer;
 }) => boolean;

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

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyAudioTrack = void 0;
-const canCopyAudioTrack = ({ inputCodec, outputCodec, container, }) => {
-    if (outputCodec === 'opus') {
-        return inputCodec === 'opus' && container === 'webm';
+const canCopyAudioTrack = ({ inputCodec, container, }) => {
+    if (container === 'webm') {
+        return inputCodec === 'opus';
     }
-    throw new Error(`Unhandled codec: ${outputCodec}`);
+    if (container === 'mp4') {
+        return inputCodec === 'aac';
+    }
+    throw new Error(`Unhandled codec: ${container}`);
 };
 exports.canCopyAudioTrack = canCopyAudioTrack;

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

@@ -1,8 +1,6 @@
 import type { MediaParserVideoCodec } from '@remotion/media-parser';
-import type { ConvertMediaVideoCodec } from './codec-id';
-import type { ConvertMediaContainer } from './convert-media';
-export declare const canCopyVideoTrack: ({ inputCodec, outputCodec, container, }: {
+import type { ConvertMediaContainer } from './codec-id';
+export declare const canCopyVideoTrack: ({ inputCodec, container, }: {
     inputCodec: MediaParserVideoCodec;
-    outputCodec: ConvertMediaVideoCodec;
     container: ConvertMediaContainer;
 }) => boolean;

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canCopyVideoTrack = void 0;
-const canCopyVideoTrack = ({ inputCodec, outputCodec, container, }) => {
-    if (outputCodec === 'vp8') {
-        return inputCodec === 'vp8' && container === 'webm';
+const canCopyVideoTrack = ({ inputCodec, container, }) => {
+    if (container === 'webm') {
+        return inputCodec === 'vp8' || inputCodec === 'vp9';
     }
-    if (outputCodec === 'vp9') {
-        return inputCodec === 'vp9' && container === 'webm';
+    if (container === 'mp4') {
+        return inputCodec === 'h264' || inputCodec === 'h265';
     }
-    throw new Error(`Unhandled codec: ${outputCodec}`);
+    throw new Error(`Unhandled codec: ${container}`);
 };
 exports.canCopyVideoTrack = canCopyVideoTrack;

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

@@ -4,12 +4,7 @@ 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)({
-        codec: track.codec,
-        numberOfChannels: track.numberOfChannels,
-        sampleRate: track.sampleRate,
-        description: track.description,
-    });
+    const audioDecoderConfig = await (0, audio_decoder_config_1.getAudioDecoderConfig)(track);
     const audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
         codec: audioCodec,
         numberOfChannels: track.numberOfChannels,

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

@@ -8,6 +8,7 @@ const canReencodeVideoTrack = async ({ videoCodec, track, }) => {
         codec: videoCodec,
         height: track.displayAspectHeight,
         width: track.displayAspectWidth,
+        fps: track.fps,
     });
     const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);
     return Boolean(videoDecoderConfig && videoEncoderConfig);

package/dist/choose-correct-avc1-profile.d.ts

@@ -0,0 +1,5 @@
+export declare const chooseCorrectAvc1Profile: ({ width, height, fps, }: {
+    width: number;
+    height: number;
+    fps: number | null;
+}) => string;

package/dist/choose-correct-avc1-profile.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseCorrectAvc1Profile = void 0;
+const chooseCorrectAvc1Profile = ({ width, height, fps, }) => {
+    // 0x42 = Baseline profile
+    // 0x4D = Main profile
+    // 0x58 = Extended profile
+    // 0x64 = High profile
+    // According to Wikipedia, 0x64 is the most widely supported profile.
+    // So we always choose 0x64.
+    /**
+      Ignoring lower levels of <720p, let's only support Players that can play 720p and above.
+      •	Level 3.1 = 1F (hex) -> 1,280×720@30.0 (5)
+      •	Level 3.2 = 20 (hex) -> 1,280×1,024@42.2 (4)
+      •	Level 4.0 = 28 (hex) -> 2,048×1,024@30.0 (4)
+      •	Level 4.1 = 29 (hex) -> 2,048×1,024@30.0 (4)
+      •	Level 4.2 = 2A (hex) -> 2,048×1,080@60.0 (4)
+      •	Level 5.0 = 32 (hex) -> 3,672×1,536@26.7 (5)
+      •	Level 5.1 = 33 (hex) -> 4,096×2,304@26.7 (5)
+      •	Level 5.2 = 34 (hex) -> 4,096×2,304@56.3 (5)
+      •	Level 6.0 = 3C (hex) -> 8,192×4,320@30.2 (5)
+      •	Level 6.1 = 3D (hex) -> 8,192×4,320@60.4 (5)
+      •	Level 6.2 = 3E (hex) -> 8,192×4,320@120.8 (5)
+   */
+    const profiles = [
+        { level: '3.1', hex: '1F', width: 1280, height: 720, fps: 30.0 },
+        { level: '3.2', hex: '20', width: 1280, height: 1024, fps: 42.2 },
+        { level: '4.0', hex: '28', width: 2048, height: 1024, fps: 30.0 },
+        { level: '4.1', hex: '29', width: 2048, height: 1024, fps: 30.0 },
+        { level: '4.2', hex: '2A', width: 2048, height: 1080, fps: 60.0 },
+        { level: '5.0', hex: '32', width: 3672, height: 1536, fps: 26.7 },
+        { level: '5.1', hex: '33', width: 4096, height: 2304, fps: 26.7 },
+        { level: '5.2', hex: '34', width: 4096, height: 2304, fps: 56.3 },
+        { level: '6.0', hex: '3C', width: 8192, height: 4320, fps: 30.2 },
+        { level: '6.1', hex: '3D', width: 8192, height: 4320, fps: 60.4 },
+        { level: '6.2', hex: '3E', width: 8192, height: 4320, fps: 120.8 },
+    ];
+    const profile = profiles.find((p) => {
+        if (width > p.width) {
+            return false;
+        }
+        if (height > p.height) {
+            return false;
+        }
+        // if has no fps, use 60 as a conservative fallback
+        const fallbackFps = fps !== null && fps !== void 0 ? fps : 60;
+        return fallbackFps <= p.fps;
+    });
+    if (!profile) {
+        throw new Error(`No suitable AVC1 profile found for ${width}x${height}@${fps}fps`);
+    }
+    return `avc1.6400${profile.hex}`;
+};
+exports.chooseCorrectAvc1Profile = chooseCorrectAvc1Profile;

package/dist/codec-id.d.ts

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

package/dist/codec-id.js

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

package/dist/convert-encoded-chunk.d.ts

@@ -1,2 +1,3 @@
 import type { AudioOrVideoSample } from '@remotion/media-parser';
-export declare const convertEncodedChunk: (chunk: EncodedAudioChunk | EncodedVideoChunk) => AudioOrVideoSample;
+export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;
+export declare const convertEncodedChunk: (chunk: EncodedAudioChunk | EncodedVideoChunk, trackId: number) => AudioOrVideoSample;

package/dist/convert-encoded-chunk.js

@@ -1,7 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertEncodedChunk = void 0;
-const convertEncodedChunk = (chunk) => {
+exports.convertEncodedChunk = exports.combineUint8Arrays = void 0;
+const combineUint8Arrays = (arrays) => {
+    if (arrays.length === 0) {
+        return new Uint8Array([]);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
+    let totalLength = 0;
+    for (const array of arrays) {
+        totalLength += array.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+};
+exports.combineUint8Arrays = combineUint8Arrays;
+const convertEncodedChunk = (chunk, trackId) => {
     var _a;
     const arr = new Uint8Array(chunk.byteLength);
     chunk.copyTo(arr);
@@ -10,6 +30,9 @@ const convertEncodedChunk = (chunk) => {
         duration: (_a = chunk.duration) !== null && _a !== void 0 ? _a : undefined,
         timestamp: chunk.timestamp,
         type: chunk.type,
+        cts: chunk.timestamp,
+        dts: chunk.timestamp,
+        trackId,
     };
 };
 exports.convertEncodedChunk = convertEncodedChunk;

package/dist/convert-media.d.ts

@@ -3,10 +3,10 @@
  * 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, ConvertMediaVideoCodec } from './codec-id';
-import { type ResolveAudioActionFn } from './resolve-audio-action';
-import { type ResolveVideoActionFn } from './resolve-video-action';
-export type ConvertMediaState = {
+import type { ConvertMediaAudioCodec, ConvertMediaContainer, ConvertMediaVideoCodec } from './codec-id';
+import { type ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
+import { type ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
+export type ConvertMediaProgress = {
     decodedVideoFrames: number;
     decodedAudioFrames: number;
     encodedVideoFrames: number;
@@ -16,27 +16,28 @@ export type ConvertMediaState = {
     expectedOutputDurationInMs: number | null;
     overallProgress: number | null;
 };
-export type ConvertMediaContainer = 'webm';
 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;
-    videoCodec: ConvertMediaVideoCodec;
-    audioCodec: ConvertMediaAudioCodec;
+    onProgress?: ConvertMediaOnProgress;
+    videoCodec?: ConvertMediaVideoCodec;
+    audioCodec?: ConvertMediaAudioCodec;
     signal?: AbortSignal;
-    onAudioTrack?: ResolveAudioActionFn;
-    onVideoTrack?: ResolveVideoActionFn;
+    onAudioTrack?: ConvertMediaOnAudioTrackHandler;
+    onVideoTrack?: ConvertMediaOnVideoTrackHandler;
     reader?: ParseMediaOptions<F>["reader"];
     logLevel?: LogLevel;
     writer?: WriterInterface;
+    progressIntervalInMs?: number;
 } & ParseMediaDynamicOptions<F>) => Promise<ConvertMediaResult>;

package/dist/convert-media.js

@@ -12,20 +12,20 @@ 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 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') {
-        return Promise.reject(new TypeError('Only `to: "webm"` is supported currently'));
+    if (container !== 'webm' && container !== 'mp4') {
+        return Promise.reject(new TypeError('Only `to: "webm"` and `to: "mp4"` is supported currently'));
     }
-    if (audioCodec !== 'opus') {
-        return Promise.reject(new TypeError('Only `audioCodec: "opus"` is supported currently'));
-    }
-    if (videoCodec !== 'vp8' && videoCodec !== 'vp9') {
+    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)();
@@ -40,63 +40,67 @@ 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 state = await media_parser_1.MediaParserInternals.createMedia({
+    const creator = container === 'webm'
+        ? media_parser_1.MediaParserInternals.createMatroskaMedia
+        : media_parser_1.MediaParserInternals.createIsoBaseMedia;
+    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,
-        videoCodec,
+        defaultVideoCodec: videoCodec !== null && videoCodec !== void 0 ? videoCodec : null,
         onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : null,
         logLevel,
         container,
     });
     const onAudioTrack = (0, on_audio_track_1.makeAudioTrackHandler)({
         abortConversion,
-        audioCodec,
+        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,
         container,
     });
     (0, media_parser_1.parseMedia)({
+        logLevel,
         src,
         onVideoTrack,
         onAudioTrack,
@@ -108,6 +112,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         reader,
         ...more,
         onDurationInSeconds: (durationInSeconds) => {
+            var _a;
             if (durationInSeconds === null) {
                 return null;
             }
@@ -116,22 +121,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 './codec-id';
+export declare const needsToCorrectVideoFrame: ({ videoFrame, outputCodec, }: {
+    videoFrame: VideoFrame;
+    outputCodec: ConvertMediaVideoCodec;
+}) => boolean;
+export declare const convertToCorrectVideoFrame: ({ videoFrame, outputCodec, }: {
+    videoFrame: VideoFrame;
+    outputCodec: ConvertMediaVideoCodec;
+}) => VideoFrame;