@remotion/webcodecs 4.0.229 → 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.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/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,9 +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, 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;
@@ -16,7 +16,6 @@ export type ConvertMediaState = {
     expectedOutputDurationInMs: number | null;
     overallProgress: number | null;
 };
-export type ConvertMediaContainer = 'webm';
 export type ConvertMediaResult = {
     save: () => Promise<Blob>;
     remove: () => Promise<void>;
@@ -31,11 +30,11 @@ export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src,
     container: ConvertMediaContainer;
     onVideoFrame?: ConvertMediaOnVideoFrame;
     onMediaStateUpdate?: ConvertMediaOnMediaStateUpdate;
-    videoCodec: ConvertMediaVideoCodec;
-    audioCodec: ConvertMediaAudioCodec;
+    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

@@ -19,13 +19,10 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
     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)();
@@ -56,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;
@@ -72,6 +72,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
                 onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate(convertMediaState);
             }
         },
+        logLevel,
     });
     const onVideoTrack = (0, on_video_track_1.makeVideoTrackHandler)({
         state,
@@ -80,14 +81,14 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         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,
@@ -97,6 +98,7 @@ const convertMedia = async function ({ src, onVideoFrame, onMediaStateUpdate: on
         container,
     });
     (0, media_parser_1.parseMedia)({
+        logLevel,
         src,
         onVideoTrack,
         onAudioTrack,

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;