@remotion/webcodecs 4.0.228 → 4.0.230

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-config.js

@@ -5,6 +5,9 @@ const getAudioDecoderConfig = async (config) => {
     if (typeof AudioDecoder === 'undefined') {
         return null;
     }
+    if (typeof EncodedAudioChunk === 'undefined') {
+        return null;
+    }
     if ((await AudioDecoder.isConfigSupported(config)).supported) {
         return config;
     }

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,10 +42,10 @@ 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;
@@ -55,6 +55,18 @@ const createAudioEncoder = ({ onChunk, onError, codec, signal, config: audioEnco
         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/calculate-progress.d.ts

@@ -1,4 +1,4 @@
-export declare const calculateProgress: ({ millisecondsWritten, expectedOutputMilliseconds, }: {
+export declare const calculateProgress: ({ millisecondsWritten, expectedOutputDurationInMs, }: {
     millisecondsWritten: number;
-    expectedOutputMilliseconds: number | null;
+    expectedOutputDurationInMs: number | null;
 }) => number | null;

package/dist/calculate-progress.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateProgress = void 0;
-const calculateProgress = ({ millisecondsWritten, expectedOutputMilliseconds, }) => {
-    if (expectedOutputMilliseconds === null) {
+const calculateProgress = ({ millisecondsWritten, expectedOutputDurationInMs, }) => {
+    if (expectedOutputDurationInMs === null) {
         return null;
     }
-    return millisecondsWritten / expectedOutputMilliseconds;
+    return millisecondsWritten / expectedOutputDurationInMs;
 };
 exports.calculateProgress = calculateProgress;

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

@@ -0,0 +1,6 @@
+import type { MediaParserAudioCodec } from '@remotion/media-parser';
+import type { ConvertMediaContainer } from './codec-id';
+export declare const canCopyAudioTrack: ({ inputCodec, container, }: {
+    inputCodec: MediaParserAudioCodec;
+    container: ConvertMediaContainer;
+}) => boolean;

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+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 audioEncoderConfig = await (0, audio_encoder_config_1.getAudioEncoderConfig)({
+        codec: audioCodec,
+        numberOfChannels: track.numberOfChannels,
+        sampleRate: track.sampleRate,
+        bitrate,
+    });
+    return Boolean(audioDecoderConfig && audioEncoderConfig);
+};
+exports.canReencodeAudioTrack = canReencodeAudioTrack;

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

@@ -0,0 +1,6 @@
+import type { VideoTrack } from '@remotion/media-parser';
+import type { ConvertMediaVideoCodec } from './codec-id';
+export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
+    videoCodec: ConvertMediaVideoCodec;
+    track: VideoTrack;
+}) => Promise<boolean>;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canReencodeVideoTrack = void 0;
+const video_decoder_config_1 = require("./video-decoder-config");
+const video_encoder_config_1 = require("./video-encoder-config");
+const canReencodeVideoTrack = async ({ videoCodec, track, }) => {
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        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);
+};
+exports.canReencodeVideoTrack = canReencodeVideoTrack;

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,2 +1,10 @@
-export type ConvertMediaVideoCodec = 'vp8' | 'vp9';
-export type ConvertMediaAudioCodec = 'opus';
+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];
+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,2 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+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;
+// 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

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

package/dist/convert-encoded-chunk.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+    return {
+        data: arr,
+        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

@@ -1,7 +1,11 @@
+/**
+ * Copyright (c) 2024 Remotion AG
+ * 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';
+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 ConvertMediaState = {
     decodedVideoFrames: number;
     decodedAudioFrames: number;
@@ -9,24 +13,28 @@ export type ConvertMediaState = {
     encodedAudioFrames: number;
     bytesWritten: number;
     millisecondsWritten: number;
-    expectedOutputMilliseconds: number | null;
+    expectedOutputDurationInMs: number | null;
     overallProgress: number | null;
 };
-export type ConvertMediaTo = 'webm';
 export type ConvertMediaResult = {
-    save: () => Promise<File>;
+    save: () => Promise<Blob>;
     remove: () => Promise<void>;
 };
-export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, ...more }: {
+export type ConvertMediaOnMediaStateUpdate = (state: ConvertMediaState) => 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 }: {
     src: ParseMediaOptions<F>["src"];
-    to: ConvertMediaTo;
-    onVideoFrame?: (inputFrame: VideoFrame, track: VideoTrack) => Promise<void>;
-    onMediaStateUpdate?: (state: ConvertMediaState) => void;
-    videoCodec: ConvertMediaVideoCodec;
-    audioCodec: ConvertMediaAudioCodec;
+    container: ConvertMediaContainer;
+    onVideoFrame?: ConvertMediaOnVideoFrame;
+    onMediaStateUpdate?: ConvertMediaOnMediaStateUpdate;
+    videoCodec?: ConvertMediaVideoCodec;
+    audioCodec?: ConvertMediaAudioCodec;
     signal?: AbortSignal;
-    onAudioTrack?: ResolveAudioActionFn;
-    onVideoTrack?: ResolveVideoActionFn;
+    onAudioTrack?: ConvertMediaOnAudioTrackHandler;
+    onVideoTrack?: ConvertMediaOnVideoTrackHandler;
     reader?: ParseMediaOptions<F>["reader"];
     logLevel?: LogLevel;
     writer?: WriterInterface;

package/dist/convert-media.js

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ * Copyright (c) 2024 Remotion AG
+ * For licensing, see: https://remotion.dev/docs/webcodecs#license
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -10,20 +14,15 @@ const calculate_progress_1 = require("./calculate-progress");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const on_audio_track_1 = require("./on-audio-track");
 const on_video_track_1 = require("./on-video-track");
-const resolve_audio_action_1 = require("./resolve-audio-action");
-const resolve_video_action_1 = require("./resolve-video-action");
 const with_resolvers_1 = require("./with-resolvers");
-const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, to, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, ...more }) {
+const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: onMediaStateDoNoCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, ...more }) {
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
     }
-    if (to !== '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)();
@@ -45,7 +44,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         encodedAudioFrames: 0,
         bytesWritten: 0,
         millisecondsWritten: 0,
-        expectedOutputMilliseconds: null,
+        expectedOutputDurationInMs: null,
         overallProgress: 0,
     };
     const onMediaStateUpdate = (newState) => {
@@ -54,7 +53,10 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         }
         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 state = await creator({
         writer: await (0, auto_select_writer_1.autoSelectWriter)(writer, logLevel),
         onBytesProgress: (bytesWritten) => {
             convertMediaState.bytesWritten = bytesWritten;
@@ -65,11 +67,12 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
                 convertMediaState.millisecondsWritten = millisecondsWritten;
                 convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
                     millisecondsWritten: convertMediaState.millisecondsWritten,
-                    expectedOutputMilliseconds: convertMediaState.expectedOutputMilliseconds,
+                    expectedOutputDurationInMs: convertMediaState.expectedOutputDurationInMs,
                 });
                 onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
             }
         },
+        logLevel,
     });
     const onVideoTrack = (0, on_video_track_1.makeVideoTrackHandler)({
         state,
@@ -78,22 +81,24 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         abortConversion,
         convertMediaState,
         controller,
-        videoCodec,
-        onVideoTrack: userVideoResolver !== null && userVideoResolver !== void 0 ? userVideoResolver : resolve_video_action_1.defaultResolveVideoAction,
+        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,
         state,
-        onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : resolve_audio_action_1.defaultResolveAudioAction,
-        bitrate: 128000,
+        onAudioTrack: userAudioResolver !== null && userAudioResolver !== void 0 ? userAudioResolver : null,
         logLevel,
+        container,
     });
     (0, media_parser_1.parseMedia)({
+        logLevel,
         src,
         onVideoTrack,
         onAudioTrack,
@@ -112,11 +117,11 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
             if (casted.onDurationInSeconds) {
                 casted.onDurationInSeconds(durationInSeconds);
             }
-            const expectedOutputMilliseconds = durationInSeconds * 1000;
-            convertMediaState.expectedOutputMilliseconds = expectedOutputMilliseconds;
+            const expectedOutputDurationInMs = durationInSeconds * 1000;
+            convertMediaState.expectedOutputDurationInMs = expectedOutputDurationInMs;
             convertMediaState.overallProgress = (0, calculate_progress_1.calculateProgress)({
                 millisecondsWritten: convertMediaState.millisecondsWritten,
-                expectedOutputMilliseconds,
+                expectedOutputDurationInMs,
             });
             onMediaStateUpdate(convertMediaState);
         },

package/dist/default-on-audio-track-handler.d.ts

@@ -0,0 +1,2 @@
+import type { ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
+export declare const defaultOnAudioTrackHandler: ConvertMediaOnAudioTrackHandler;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOnAudioTrackHandler = void 0;
+const media_parser_1 = require("@remotion/media-parser");
+const can_copy_audio_track_1 = require("./can-copy-audio-track");
+const can_reencode_audio_track_1 = require("./can-reencode-audio-track");
+const get_default_audio_codec_1 = require("./get-default-audio-codec");
+const DEFAULT_BITRATE = 128000;
+const defaultOnAudioTrackHandler = async ({ track, defaultAudioCodec, logLevel, container, }) => {
+    const bitrate = DEFAULT_BITRATE;
+    const canCopy = (0, can_copy_audio_track_1.canCopyAudioTrack)({
+        inputCodec: track.codecWithoutConfig,
+        container,
+    });
+    if (canCopy) {
+        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can copy track, therefore copying`);
+        return Promise.resolve({ type: 'copy' });
+    }
+    const audioCodec = defaultAudioCodec !== null && defaultAudioCodec !== void 0 ? defaultAudioCodec : (0, get_default_audio_codec_1.getDefaultAudioCodec)({ container });
+    const canReencode = await (0, can_reencode_audio_track_1.canReencodeAudioTrack)({
+        audioCodec,
+        track,
+        bitrate,
+    });
+    if (canReencode) {
+        media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (audio): Cannot copy, but re-encode, therefore re-encoding`);
+        return Promise.resolve({
+            type: 'reencode',
+            bitrate,
+            audioCodec,
+        });
+    }
+    media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (audio): Can neither re-encode nor copy, failing render`);
+    return Promise.resolve({ type: 'fail' });
+};
+exports.defaultOnAudioTrackHandler = defaultOnAudioTrackHandler;

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

@@ -0,0 +1,2 @@
+import type { ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
+export declare const defaultOnVideoTrackHandler: ConvertMediaOnVideoTrackHandler;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOnVideoTrackHandler = void 0;
+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 canCopy = (0, can_copy_video_track_1.canCopyVideoTrack)({
+        inputCodec: track.codecWithoutConfig,
+        container,
+    });
+    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 });
+    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 });
+    }
+    media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Can neither copy nor re-encode, therefore failing`);
+    return Promise.resolve({ type: 'fail' });
+};
+exports.defaultOnVideoTrackHandler = defaultOnVideoTrackHandler;