@remotion/renderer 3.3.41 → 3.3.42

package/client.d.ts

@@ -0,0 +1 @@
+export * from './dist/client';

package/client.js

@@ -0,0 +1 @@
+module.exports = require('./dist/client');

package/dist/audio-codec.d.ts

@@ -0,0 +1,27 @@
+import type { Codec } from './codec';
+export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+export declare type AudioCodec = typeof validAudioCodecs[number];
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["aac", "pcm-16"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+export declare const audioCodecNames: readonly ["pcm_s16le", "aac", "libmp3lame", "libopus"];
+export declare type FfmpegAudioCodecName = typeof audioCodecNames[number];
+export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: AudioCodec) => FfmpegAudioCodecName;
+export declare const defaultAudioCodecs: {
+    [key in Codec]: {
+        [k in 'compressed' | 'lossless']: typeof supportedAudioCodecs[key][number] | null;
+    };
+};
+export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {
+    codec: Codec;
+    preferLossless: boolean;
+}) => AudioCodec | null;

package/dist/audio-codec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.audioCodecNames = exports.supportedAudioCodecs = exports.validAudioCodecs = void 0;
+exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['aac', 'pcm-16'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+const _satisfies = exports.supportedAudioCodecs;
+if (_satisfies) {
+    // Just for type checking
+}
+exports.audioCodecNames = [
+    'pcm_s16le',
+    'aac',
+    'libmp3lame',
+    'libopus',
+];
+const mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === 'aac') {
+        return 'aac';
+    }
+    if (audioCodec === 'mp3') {
+        return 'libmp3lame';
+    }
+    if (audioCodec === 'opus') {
+        return 'libopus';
+    }
+    if (audioCodec === 'pcm-16') {
+        return 'pcm_s16le';
+    }
+    throw new Error('unknown audio codec: ' + audioCodec);
+};
+exports.mapAudioCodecToFfmpegAudioCodecName = mapAudioCodecToFfmpegAudioCodecName;
+exports.defaultAudioCodecs = {
+    'h264-mkv': {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    aac: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    gif: {
+        lossless: null,
+        compressed: null,
+    },
+    h264: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    h265: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    mp3: {
+        lossless: 'pcm-16',
+        compressed: 'mp3',
+    },
+    prores: {
+        lossless: 'pcm-16',
+        // V4.0: Make pcm the default
+        compressed: 'aac',
+    },
+    vp8: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    vp9: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    wav: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+};
+const getDefaultAudioCodec = ({ codec, preferLossless, }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? 'lossless' : 'compressed'];
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;

package/dist/client.d.ts

@@ -1,10 +1,178 @@
 export declare const BrowserSafeApis: {
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => "mp3" | "aac" | "wav" | "gif" | "mp4" | "mkv" | "mov" | "webm";
+    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
     getDefaultCrfForCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => number;
     getValidCrfRanges: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => [number, number];
     isAudioCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif" | undefined) => boolean;
-    proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    supportedAudioCodecs: {
+        readonly h264: readonly ["aac", "pcm-16"];
+        readonly 'h264-mkv': readonly ["pcm-16"];
+        readonly aac: readonly ["aac", "pcm-16"];
+        readonly gif: readonly [];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        readonly prores: readonly ["pcm-16", "aac"];
+        readonly vp8: readonly ["opus", "pcm-16"];
+        readonly vp9: readonly ["opus", "pcm-16"];
+        readonly wav: readonly ["pcm-16"];
+    };
+    defaultFileExtensionMap: {
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {};
+        };
+    };
+    defaultAudioCodecs: {
+        h264: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        h265: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        vp8: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        vp9: {
+            compressed: "pcm-16" | "opus" | null;
+            lossless: "pcm-16" | "opus" | null;
+        };
+        mp3: {
+            compressed: "mp3" | "pcm-16" | null;
+            lossless: "mp3" | "pcm-16" | null;
+        };
+        aac: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        wav: {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        prores: {
+            compressed: "aac" | "pcm-16" | null;
+            lossless: "aac" | "pcm-16" | null;
+        };
+        "h264-mkv": {
+            compressed: "pcm-16" | null;
+            lossless: "pcm-16" | null;
+        };
+        gif: {
+            compressed: null;
+            lossless: null;
+        };
+    };
 };

package/dist/client.js

@@ -1,19 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BrowserSafeApis = void 0;
+const audio_codec_1 = require("./audio-codec");
 const codec_1 = require("./codec");
 const crf_1 = require("./crf");
+const file_extensions_1 = require("./file-extensions");
 const get_extension_from_codec_1 = require("./get-extension-from-codec");
 const is_audio_codec_1 = require("./is-audio-codec");
 const pixel_format_1 = require("./pixel-format");
-const prores_profile_1 = require("./prores-profile");
 exports.BrowserSafeApis = {
     getFileExtensionFromCodec: get_extension_from_codec_1.getFileExtensionFromCodec,
     validCodecs: codec_1.validCodecs,
     getDefaultCrfForCodec: crf_1.getDefaultCrfForCodec,
     getValidCrfRanges: crf_1.getValidCrfRanges,
     isAudioCodec: is_audio_codec_1.isAudioCodec,
-    proResProfileOptions: prores_profile_1.proResProfileOptions,
     validPixelFormats: pixel_format_1.validPixelFormats,
     DEFAULT_PIXEL_FORMAT: pixel_format_1.DEFAULT_PIXEL_FORMAT,
+    supportedAudioCodecs: file_extensions_1.supportedAudioCodecs,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    defaultAudioCodecs: audio_codec_1.defaultAudioCodecs,
 };

package/dist/combine-videos.d.ts

@@ -1,3 +1,4 @@
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
 import type { FfmpegExecutable } from './ffmpeg-executable';
 declare type Options = {
@@ -11,6 +12,7 @@ declare type Options = {
     numberOfGifLoops: number | null;
     remotionRoot: string;
     ffmpegExecutable: FfmpegExecutable;
+    audioCodec: AudioCodec | null;
 };
 export declare const combineVideos: (options: Options) => Promise<void>;
 export {};

package/dist/combine-videos.js

@@ -8,17 +8,18 @@ exports.combineVideos = void 0;
 const execa_1 = __importDefault(require("execa"));
 const fs_1 = require("fs");
 const path_1 = require("path");
+const audio_codec_1 = require("./audio-codec");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
-const get_audio_codec_name_1 = require("./get-audio-codec-name");
 const is_audio_codec_1 = require("./is-audio-codec");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const truthy_1 = require("./truthy");
 const combineVideos = async (options) => {
     var _a;
-    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, } = options;
+    const { files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, ffmpegExecutable, remotionRoot, audioCodec, } = options;
     const fileList = files.map((p) => `file '${p}'`).join('\n');
     const fileListTxt = (0, path_1.join)(filelistDir, 'files.txt');
     (0, fs_1.writeFileSync)(fileListTxt, fileList);
+    const resolvedAudioCodec = audioCodec !== null && audioCodec !== void 0 ? audioCodec : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: false });
     try {
         const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-r',
@@ -37,8 +38,10 @@ const combineVideos = async (options) => {
                     : '-1',
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : '-c:v',
             (0, is_audio_codec_1.isAudioCodec)(codec) ? null : codec === 'gif' ? 'gif' : 'copy',
-            '-c:a',
-            (0, get_audio_codec_name_1.getAudioCodecName)(codec),
+            resolvedAudioCodec ? '-c:a' : null,
+            resolvedAudioCodec
+                ? (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec)
+                : null,
             // Set max bitrate up to 512kbps, will choose lower if that's too much
             '-b:a',
             '512K',

package/dist/file-extensions.d.ts

@@ -0,0 +1,25 @@
+import type { Codec } from './codec';
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16"];
+    readonly 'h264-mkv': readonly ["pcm-16"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["pcm-16", "aac"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+export declare type FileExtension = 'aac' | '3gp' | 'm4a' | 'm4b' | 'mpg' | 'mpeg' | 'mkv' | 'mp4' | 'gif' | 'hevc' | 'mp3' | 'mov' | 'mxf' | 'wav' | 'webm';
+export declare const defaultFileExtensionMap: {
+    [key in Codec]: {
+        default: FileExtension;
+        forAudioCodec: {
+            [k in typeof supportedAudioCodecs[key][number]]: {
+                possible: FileExtension[];
+                default: FileExtension;
+            };
+        };
+    };
+};

package/dist/file-extensions.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileExtensionMap = exports.supportedAudioCodecs = void 0;
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16'],
+    'h264-mkv': ['pcm-16'],
+    aac: ['aac', 'pcm-16'],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['pcm-16', 'aac'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+exports.defaultFileExtensionMap = {
+    'h264-mkv': {
+        default: 'mkv',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    aac: {
+        default: 'aac',
+        forAudioCodec: {
+            aac: {
+                possible: ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'],
+                default: 'aac',
+            },
+            'pcm-16': {
+                possible: ['wav'],
+                default: 'wav',
+            },
+        },
+    },
+    gif: {
+        default: 'gif',
+        forAudioCodec: {},
+    },
+    h264: {
+        default: 'mp4',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            aac: { possible: ['mp4', 'mkv'], default: 'mp4' },
+        },
+    },
+    h265: {
+        default: 'mp4',
+        forAudioCodec: {
+            aac: { possible: ['mp4', 'mkv', 'hevc'], default: 'mp4' },
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    mp3: {
+        default: 'mp3',
+        forAudioCodec: {
+            mp3: { possible: ['mp3'], default: 'mp3' },
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+    prores: {
+        default: 'mov',
+        forAudioCodec: {
+            aac: { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+            'pcm-16': { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+        },
+    },
+    vp8: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    vp9: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    wav: {
+        default: 'wav',
+        forAudioCodec: {
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+};

package/dist/get-extension-from-codec.d.ts

@@ -1,2 +1,6 @@
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
-export declare const getFileExtensionFromCodec: (codec: Codec) => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+import type { FileExtension } from './file-extensions';
+export declare const getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: AudioCodec | null) => FileExtension;
+export declare const makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+export declare const defaultCodecsForFileExtension: Record<FileExtension, Codec>;

package/dist/get-extension-from-codec.js

@@ -1,35 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFileExtensionFromCodec = void 0;
+exports.defaultCodecsForFileExtension = exports.makeFileExtensionMap = exports.getFileExtensionFromCodec = void 0;
 const codec_1 = require("./codec");
-const getFileExtensionFromCodec = (codec) => {
+const file_extensions_1 = require("./file-extensions");
+const getFileExtensionFromCodec = (codec, audioCodec) => {
     if (!codec_1.validCodecs.includes(codec)) {
         throw new Error(`Codec must be one of the following: ${codec_1.validCodecs.join(', ')}, but got ${codec}`);
     }
-    switch (codec) {
-        case 'aac':
-            return 'aac';
-        case 'h264':
-            return 'mp4';
-        // The chunks will be rendered as mkv, but the final output will still be MP4
-        case 'h264-mkv':
-            return 'mkv';
-        case 'h265':
-            return 'mp4';
-        case 'mp3':
-            return 'mp3';
-        case 'prores':
-            return 'mov';
-        case 'vp8':
-            return 'webm';
-        case 'vp9':
-            return 'webm';
-        case 'gif':
-            return 'gif';
-        case 'wav':
-            return 'wav';
-        default:
-            throw new Error("Don't know which file extension to use for codec " + codec);
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    if (audioCodec === null) {
+        return map.default;
     }
+    const typedAudioCodec = audioCodec;
+    if (!(typedAudioCodec in map.forAudioCodec)) {
+        throw new Error(`Audio codec ${typedAudioCodec} is not supported for codec ${codec}`);
+    }
+    return map.forAudioCodec[audioCodec]
+        .default;
 };
 exports.getFileExtensionFromCodec = getFileExtensionFromCodec;
+const makeFileExtensionMap = () => {
+    const map = {};
+    Object.keys(file_extensions_1.defaultFileExtensionMap).forEach((_codec) => {
+        const codec = _codec;
+        const fileExtMap = file_extensions_1.defaultFileExtensionMap[codec];
+        const audioCodecs = Object.keys(fileExtMap.forAudioCodec);
+        const possibleExtensionsForAudioCodec = audioCodecs.map((audioCodec) => fileExtMap.forAudioCodec[audioCodec].possible);
+        const allPossibleExtensions = [
+            fileExtMap.default,
+            ...possibleExtensionsForAudioCodec.flat(1),
+        ];
+        for (const extension of allPossibleExtensions) {
+            if (!map[extension]) {
+                map[extension] = [];
+            }
+            if (!map[extension].includes(codec)) {
+                map[extension].push(codec);
+            }
+        }
+    });
+    return map;
+};
+exports.makeFileExtensionMap = makeFileExtensionMap;
+exports.defaultCodecsForFileExtension = {
+    '3gp': 'aac',
+    aac: 'aac',
+    gif: 'gif',
+    hevc: 'h265',
+    m4a: 'aac',
+    m4b: 'aac',
+    mkv: 'h264-mkv',
+    mov: 'prores',
+    mp3: 'mp3',
+    mp4: 'h264',
+    mpeg: 'aac',
+    mpg: 'aac',
+    mxf: 'prores',
+    wav: 'wav',
+    webm: 'vp8',
+};

package/dist/guess-extension-for-media.d.ts

@@ -2,4 +2,4 @@ export declare const guessExtensionForVideo: ({ src, remotionRoot, ffprobeBinary
     src: string;
     remotionRoot: string;
     ffprobeBinary: string | null;
-}) => Promise<"mp3" | "wav" | "webm" | "mp4">;
+}) => Promise<"mp3" | "wav" | "mp4" | "webm">;

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import { mimeContentType, mimeLookup } from './mime-types';
 import * as perf from './perf';
 export type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 export type { DownloadMap } from './assets/download-map';
+export { AudioCodec } from './audio-codec';
 export { Browser } from './browser';
 export { BrowserExecutable } from './browser-executable';
 export { BrowserLog } from './browser-log';
@@ -15,6 +16,7 @@ export { ErrorWithStackFrame } from './error-handling/handle-javascript-exceptio
 export { FfmpegExecutable } from './ffmpeg-executable';
 export { FfmpegVersion } from './ffmpeg-flags';
 export type { FfmpegOverrideFn } from './ffmpeg-override';
+export { FileExtension } from './file-extensions';
 export { FrameRange } from './frame-range';
 export { getCanExtractFramesFast } from './get-can-extract-frames-fast';
 export { getCompositions } from './get-compositions';
@@ -60,7 +62,7 @@ export declare const RenderInternals: {
         scale: number;
         codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
     }) => void;
-    getFileExtensionFromCodec: (codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif") => "mp3" | "aac" | "wav" | "gif" | "webm" | "mp4" | "mov" | "mkv";
+    getFileExtensionFromCodec: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">(codec: T, audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null) => import("./file-extensions").FileExtension;
     tmpDir: (str: string) => string;
     deleteDirectory: (directory: string) => Promise<void>;
     isServeUrl: (potentialUrl: string) => boolean;
@@ -155,5 +157,140 @@ export declare const RenderInternals: {
         numberOfGifLoops: number | null;
         remotionRoot: string;
         ffmpegExecutable: import("./ffmpeg-executable").FfmpegExecutable;
+        audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
     }) => Promise<void>;
+    getDefaultAudioCodec: ({ codec, preferLossless, }: {
+        codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+        preferLossless: boolean;
+    }) => "mp3" | "aac" | "pcm-16" | "opus" | null;
+    validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+    defaultFileExtensionMap: {
+        h264: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        h265: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp8: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        vp9: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                opus: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        mp3: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                mp3: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        aac: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        wav: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        prores: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                aac: {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        "h264-mkv": {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {
+                "pcm-16": {
+                    possible: import("./file-extensions").FileExtension[];
+                    default: import("./file-extensions").FileExtension;
+                };
+            };
+        };
+        gif: {
+            default: import("./file-extensions").FileExtension;
+            forAudioCodec: {};
+        };
+    };
+    supportedAudioCodecs: {
+        readonly h264: readonly ["aac", "pcm-16"];
+        readonly 'h264-mkv': readonly ["pcm-16"];
+        readonly aac: readonly ["aac", "pcm-16"];
+        readonly gif: readonly [];
+        readonly h265: readonly ["aac", "pcm-16"];
+        readonly mp3: readonly ["mp3", "pcm-16"];
+        readonly prores: readonly ["pcm-16", "aac"];
+        readonly vp8: readonly ["opus", "pcm-16"];
+        readonly vp9: readonly ["opus", "pcm-16"];
+        readonly wav: readonly ["pcm-16"];
+    };
+    makeFileExtensionMap: () => Record<string, ("h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif")[]>;
+    defaultCodecsForFileExtension: Record<import("./file-extensions").FileExtension, "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">;
 };

package/dist/index.js

@@ -30,6 +30,7 @@ exports.RenderInternals = exports.validateOutputFilename = exports.stitchFramesT
 const execa_1 = __importDefault(require("execa"));
 const download_file_1 = require("./assets/download-file");
 const download_map_1 = require("./assets/download-map");
+const audio_codec_1 = require("./audio-codec");
 const browser_1 = require("./browser");
 const TimeoutSettings_1 = require("./browser/TimeoutSettings");
 const can_use_parallel_encoding_1 = require("./can-use-parallel-encoding");
@@ -42,6 +43,7 @@ const ensure_output_directory_1 = require("./ensure-output-directory");
 const symbolicate_error_1 = require("./error-handling/symbolicate-error");
 const symbolicateable_error_1 = require("./error-handling/symbolicateable-error");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const file_extensions_1 = require("./file-extensions");
 const find_closest_package_json_1 = require("./find-closest-package-json");
 const frame_range_1 = require("./frame-range");
 const get_concurrency_1 = require("./get-concurrency");
@@ -153,6 +155,12 @@ exports.RenderInternals = {
     validateBitrate: validate_videobitrate_1.validateBitrate,
     getFfmpegVersion: ffmpeg_flags_1.getFfmpegVersion,
     combineVideos: combine_videos_1.combineVideos,
+    getDefaultAudioCodec: audio_codec_1.getDefaultAudioCodec,
+    validAudioCodecs: audio_codec_1.validAudioCodecs,
+    defaultFileExtensionMap: file_extensions_1.defaultFileExtensionMap,
+    supportedAudioCodecs: file_extensions_1.supportedAudioCodecs,
+    makeFileExtensionMap: get_extension_from_codec_1.makeFileExtensionMap,
+    defaultCodecsForFileExtension: get_extension_from_codec_1.defaultCodecsForFileExtension,
 };
 // Warn of potential performance issues with Apple Silicon (M1 chip under Rosetta)
 (0, check_apple_silicon_1.checkNodeVersionAndWarnAboutRosetta)();

package/dist/render-media.d.ts

@@ -2,6 +2,7 @@
 import type { SmallTCompMetadata } from 'remotion';
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { DownloadMap } from './assets/download-map';
+import type { AudioCodec } from './audio-codec';
 import type { BrowserExecutable } from './browser-executable';
 import type { BrowserLog } from './browser-log';
 import type { Browser as PuppeteerBrowser } from './browser/Browser';
@@ -63,6 +64,10 @@ export declare type RenderMediaOptions = {
      * @deprecated Only for Remotion internal usage
      */
     downloadMap?: DownloadMap;
+    /**
+     * @deprecated Only for Remotion internal usage
+     */
+    preferLossless?: boolean;
     muted?: boolean;
     enforceAudioTrack?: boolean;
     ffmpegOverride?: FfmpegOverrideFn;
@@ -70,6 +75,7 @@ export declare type RenderMediaOptions = {
     videoBitrate?: string | null;
     onSlowestFrames?: OnSlowestFrames;
     disallowParallelEncoding?: boolean;
+    audioCodec?: AudioCodec | null;
 } & ServeUrlOrWebpackBundle & ConcurrencyOrParallelism;
 declare type ConcurrencyOrParallelism = {
     concurrency?: number | string | null;
@@ -84,5 +90,5 @@ declare type ConcurrencyOrParallelism = {
  * @description Render a video from a composition
  * @link https://www.remotion.dev/docs/renderer/render-media
  */
-export declare const renderMedia: ({ proResProfile, crf, composition, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, onSlowestFrames, ...options }: RenderMediaOptions) => Promise<Buffer | null>;
+export declare const renderMedia: ({ proResProfile, crf, composition, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, onSlowestFrames, audioCodec, ...options }: RenderMediaOptions) => Promise<Buffer | null>;
 export {};

package/dist/render-media.js

@@ -55,8 +55,8 @@ const getConcurrency = (others) => {
  * @description Render a video from a composition
  * @link https://www.remotion.dev/docs/renderer/render-media
  */
-const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, onSlowestFrames, ...options }) => {
-    var _a, _b, _c, _d;
+const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprobeExecutable, inputProps, pixelFormat, codec, envVariables, frameRange, puppeteerInstance, outputLocation, onProgress, overwrite, onDownload, dumpBrowserLogs, onBrowserLog, onStart, timeoutInMilliseconds, chromiumOptions, scale, browserExecutable, port, cancelSignal, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, onSlowestFrames, audioCodec, ...options }) => {
+    var _a, _b, _c, _d, _e;
     const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
     (0, validate_ffmpeg_1.validateFfmpeg)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null, remotionRoot, 'ffmpeg');
     (0, quality_1.validateQuality)(options.quality);
@@ -69,7 +69,12 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
     });
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     if (outputLocation) {
-        (0, validate_output_filename_1.validateOutputFilename)(codec, (0, get_extension_of_filename_1.getExtensionOfFilename)(outputLocation));
+        (0, validate_output_filename_1.validateOutputFilename)({
+            codec,
+            audioCodec: audioCodec !== null && audioCodec !== void 0 ? audioCodec : null,
+            extension: (0, get_extension_of_filename_1.getExtensionOfFilename)(outputLocation),
+            preferLossless: (_a = options.preferLossless) !== null && _a !== void 0 ? _a : false,
+        });
     }
     const absoluteOutputLocation = outputLocation
         ? path_1.default.resolve(process.cwd(), outputLocation)
@@ -77,9 +82,9 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
     (0, validate_scale_1.validateScale)(scale);
     const concurrency = getConcurrency(options);
     (0, validate_ffmpeg_override_1.validateFfmpegOverride)(ffmpegOverride);
-    const everyNthFrame = (_a = options.everyNthFrame) !== null && _a !== void 0 ? _a : 1;
+    const everyNthFrame = (_b = options.everyNthFrame) !== null && _b !== void 0 ? _b : 1;
     (0, validate_every_nth_frame_1.validateEveryNthFrame)(everyNthFrame, codec);
-    const numberOfGifLoops = (_b = options.numberOfGifLoops) !== null && _b !== void 0 ? _b : null;
+    const numberOfGifLoops = (_c = options.numberOfGifLoops) !== null && _c !== void 0 ? _c : null;
     const serveUrl = (0, legacy_webpack_config_1.getServeUrlWithFallback)(options);
     let stitchStage = 'encoding';
     let stitcherFfmpeg;
@@ -90,7 +95,7 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
     let encodedDoneIn = null;
     let cancelled = false;
     const renderStart = Date.now();
-    const downloadMap = (_c = options.downloadMap) !== null && _c !== void 0 ? _c : (0, download_map_1.makeDownloadMap)();
+    const downloadMap = (_d = options.downloadMap) !== null && _d !== void 0 ? _d : (0, download_map_1.makeDownloadMap)();
     const { estimatedUsage, freeMemory, hasEnoughMemory } = (0, prestitcher_memory_usage_1.shouldUseParallelEncoding)({
         height: composition.height,
         width: composition.width,
@@ -111,11 +116,11 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
     }
     const imageFormat = (0, is_audio_codec_1.isAudioCodec)(codec)
         ? 'none'
-        : (_d = options.imageFormat) !== null && _d !== void 0 ? _d : 'jpeg';
+        : (_e = options.imageFormat) !== null && _e !== void 0 ? _e : 'jpeg';
     const quality = imageFormat === 'jpeg' ? options.quality : undefined;
     (0, image_format_1.validateSelectedPixelFormatAndImageFormatCombination)(pixelFormat, imageFormat);
     const preEncodedFileLocation = parallelEncoding
-        ? path_1.default.join(downloadMap.preEncode, 'pre-encode.' + (0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec))
+        ? path_1.default.join(downloadMap.preEncode, 'pre-encode.' + (0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, audioCodec !== null && audioCodec !== void 0 ? audioCodec : null))
         : null;
     const outputDir = parallelEncoding
         ? null
@@ -270,6 +275,7 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
         return Promise.all([renderFramesReturn, waitForPrestitcherIfNecessary()]);
     })
         .then(([{ assetsInfo }]) => {
+        var _a;
         renderedDoneIn = Date.now() - renderStart;
         callUpdate();
         if (absoluteOutputLocation) {
@@ -285,6 +291,7 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
                 internalOptions: {
                     preEncodedFileLocation,
                     imageFormat,
+                    preferLossless: (_a = options.preferLossless) !== null && _a !== void 0 ? _a : false,
                 },
                 force: overwrite !== null && overwrite !== void 0 ? overwrite : overwrite_1.DEFAULT_OVERWRITE,
                 pixelFormat,
@@ -309,6 +316,7 @@ const renderMedia = ({ proResProfile, crf, composition, ffmpegExecutable, ffprob
                 ffmpegOverride,
                 audioBitrate,
                 videoBitrate,
+                audioCodec: audioCodec !== null && audioCodec !== void 0 ? audioCodec : null,
             }),
             stitchStart,
         ]);

package/dist/stitch-frames-to-video.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
 import type { RenderAssetInfo } from './assets/download-map';
+import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
 import type { FfmpegExecutable } from './ffmpeg-executable';
 import type { FfmpegOverrideFn } from './ffmpeg-override';
@@ -20,6 +21,7 @@ export declare type StitcherOptions = {
     pixelFormat?: PixelFormat;
     numberOfGifLoops?: number | null;
     codec?: Codec;
+    audioCodec?: AudioCodec | null;
     crf?: number | null;
     onProgress?: (progress: number) => void;
     onDownload?: RenderMediaOnDownload;
@@ -32,6 +34,7 @@ export declare type StitcherOptions = {
     internalOptions?: {
         preEncodedFileLocation: string | null;
         imageFormat: ImageFormat;
+        preferLossless: boolean;
     };
     muted?: boolean;
     enforceAudioTrack?: boolean;

package/dist/stitch-frames-to-video.js

@@ -34,6 +34,7 @@ const remotion_1 = require("remotion");
 const calculate_asset_positions_1 = require("./assets/calculate-asset-positions");
 const convert_assets_to_file_urls_1 = require("./assets/convert-assets-to-file-urls");
 const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const audio_codec_1 = require("./audio-codec");
 const codec_1 = require("./codec");
 const codec_supports_media_1 = require("./codec-supports-media");
 const convert_number_of_gif_loops_to_ffmpeg_1 = require("./convert-number-of-gif-loops-to-ffmpeg");
@@ -41,7 +42,6 @@ const crf_1 = require("./crf");
 const delete_directory_1 = require("./delete-directory");
 const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const find_closest_package_json_1 = require("./find-closest-package-json");
-const get_audio_codec_name_1 = require("./get-audio-codec-name");
 const get_codec_name_1 = require("./get-codec-name");
 const get_extension_from_codec_1 = require("./get-extension-from-codec");
 const get_prores_profile_name_1 = require("./get-prores-profile-name");
@@ -109,7 +109,7 @@ const getAssetsData = async ({ assets, onDownload, fps, expectedFrames, verbose,
     return outName;
 };
 const spawnFfmpeg = async (options, remotionRoot) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
     remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
     remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
     const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : codec_1.DEFAULT_CODEC;
@@ -129,12 +129,8 @@ const spawnFfmpeg = async (options, remotionRoot) => {
     const pixelFormat = (_b = options.pixelFormat) !== null && _b !== void 0 ? _b : pixel_format_1.DEFAULT_PIXEL_FORMAT;
     await (0, validate_ffmpeg_1.validateFfmpeg)((_c = options.ffmpegExecutable) !== null && _c !== void 0 ? _c : null, remotionRoot, 'ffmpeg');
     const encoderName = (0, get_codec_name_1.getCodecName)(codec);
-    const audioCodecName = (0, get_audio_codec_name_1.getAudioCodecName)(codec);
     const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
     const mediaSupport = (0, codec_supports_media_1.codecSupportsMedia)(codec);
-    const tempFile = options.outputLocation
-        ? null
-        : path_1.default.join(options.assetsInfo.downloadMap.stitchFrames, `out.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec)}`);
     const shouldRenderAudio = mediaSupport.audio &&
         (options.assetsInfo.assets.flat(1).length > 0 ||
             options.enforceAudioTrack) &&
@@ -143,10 +139,17 @@ const spawnFfmpeg = async (options, remotionRoot) => {
     if (!shouldRenderAudio && !shouldRenderVideo) {
         throw new Error('The output format has neither audio nor video. This can happen if you are rendering an audio codec and the output file has no audio or the muted flag was passed.');
     }
+    // Explanation: https://github.com/remotion-dev/remotion/issues/1647
+    const resolvedAudioCodec = ((_d = options.internalOptions) === null || _d === void 0 ? void 0 : _d.preferLossless)
+        ? (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: true })
+        : (_e = options.audioCodec) !== null && _e !== void 0 ? _e : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: false });
+    const tempFile = options.outputLocation
+        ? null
+        : path_1.default.join(options.assetsInfo.downloadMap.stitchFrames, `out.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, resolvedAudioCodec)}`);
     if (options.verbose) {
-        console.log('[verbose] ffmpeg', (_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : 'ffmpeg in PATH');
+        console.log('[verbose] ffmpeg', (_f = options.ffmpegExecutable) !== null && _f !== void 0 ? _f : 'ffmpeg in PATH');
         console.log('[verbose] encoder', encoderName);
-        console.log('[verbose] audioCodec', audioCodecName);
+        console.log('[verbose] audioCodec', resolvedAudioCodec);
         console.log('[verbose] pixelFormat', pixelFormat);
         if (options.ffmpegOverride) {
             console.log('[verbose] ffmpegOverride', options.ffmpegOverride);
@@ -174,34 +177,34 @@ const spawnFfmpeg = async (options, remotionRoot) => {
             onDownload: options.onDownload,
             fps: options.fps,
             expectedFrames,
-            verbose: (_e = options.verbose) !== null && _e !== void 0 ? _e : false,
-            ffmpegExecutable: (_f = options.ffmpegExecutable) !== null && _f !== void 0 ? _f : null,
-            ffprobeExecutable: (_g = options.ffprobeExecutable) !== null && _g !== void 0 ? _g : null,
+            verbose: (_g = options.verbose) !== null && _g !== void 0 ? _g : false,
+            ffmpegExecutable: (_h = options.ffmpegExecutable) !== null && _h !== void 0 ? _h : null,
+            ffprobeExecutable: (_j = options.ffprobeExecutable) !== null && _j !== void 0 ? _j : null,
             onProgress: (prog) => updateProgress(prog, 0),
             downloadMap: options.assetsInfo.downloadMap,
             remotionRoot,
         })
         : null;
     if (mediaSupport.audio && !mediaSupport.video) {
-        if (!audioCodecName) {
+        if (!resolvedAudioCodec) {
             throw new TypeError('exporting audio but has no audio codec name. Report this in the Remotion repo.');
         }
-        const ffmpegTask = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_h = options.ffmpegExecutable) !== null && _h !== void 0 ? _h : null, remotionRoot, 'ffmpeg'), [
+        const ffmpegTask = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_k = options.ffmpegExecutable) !== null && _k !== void 0 ? _k : null, remotionRoot, 'ffmpeg'), [
             '-i',
             audio,
             '-c:a',
-            audioCodecName,
+            (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec),
             // Set bitrate up to 320k, for aac it might effectively be lower
             '-b:a',
-            (_j = options.audioBitrate) !== null && _j !== void 0 ? _j : '320k',
+            (_l = options.audioBitrate) !== null && _l !== void 0 ? _l : '320k',
             options.force ? '-y' : null,
-            (_k = options.outputLocation) !== null && _k !== void 0 ? _k : tempFile,
+            (_m = options.outputLocation) !== null && _m !== void 0 ? _m : tempFile,
         ].filter(remotion_1.Internals.truthy));
-        (_l = options.cancelSignal) === null || _l === void 0 ? void 0 : _l.call(options, () => {
+        (_o = options.cancelSignal) === null || _o === void 0 ? void 0 : _o.call(options, () => {
             ffmpegTask.kill();
         });
         await ffmpegTask;
-        (_m = options.onProgress) === null || _m === void 0 ? void 0 : _m.call(options, expectedFrames);
+        (_p = options.onProgress) === null || _p === void 0 ? void 0 : _p.call(options, expectedFrames);
         if (audio) {
             await (0, delete_directory_1.deleteDirectory)(path_1.default.dirname(audio));
         }
@@ -226,8 +229,8 @@ const spawnFfmpeg = async (options, remotionRoot) => {
     }
     const ffmpegArgs = [
         ['-r', String(options.fps)],
-        ...(((_o = options.internalOptions) === null || _o === void 0 ? void 0 : _o.preEncodedFileLocation)
-            ? [['-i', (_p = options.internalOptions) === null || _p === void 0 ? void 0 : _p.preEncodedFileLocation]]
+        ...(((_q = options.internalOptions) === null || _q === void 0 ? void 0 : _q.preEncodedFileLocation)
+            ? [['-i', (_r = options.internalOptions) === null || _r === void 0 ? void 0 : _r.preEncodedFileLocation]]
             : [
                 ['-f', 'image2'],
                 ['-s', `${options.width}x${options.height}`],
@@ -235,16 +238,16 @@ const spawnFfmpeg = async (options, remotionRoot) => {
                 ['-i', options.assetsInfo.imageSequenceName],
             ]),
         audio ? ['-i', audio] : null,
-        ((_q = options.numberOfGifLoops) !== null && _q !== void 0 ? _q : null) === null
+        ((_s = options.numberOfGifLoops) !== null && _s !== void 0 ? _s : null) === null
             ? null
             : [
                 '-loop',
-                (0, convert_number_of_gif_loops_to_ffmpeg_1.convertNumberOfGifLoopsToFfmpegSyntax)((_r = options.numberOfGifLoops) !== null && _r !== void 0 ? _r : null),
+                (0, convert_number_of_gif_loops_to_ffmpeg_1.convertNumberOfGifLoopsToFfmpegSyntax)((_t = options.numberOfGifLoops) !== null && _t !== void 0 ? _t : null),
             ],
         // -c:v is the same as -vcodec as -codec:video
         // and specified the video codec.
         ['-c:v', encoderName],
-        ...(((_s = options.internalOptions) === null || _s === void 0 ? void 0 : _s.preEncodedFileLocation)
+        ...(((_u = options.internalOptions) === null || _u === void 0 ? void 0 : _u.preEncodedFileLocation)
             ? []
             : [
                 proResProfileName ? ['-profile:v', proResProfileName] : null,
@@ -259,9 +262,11 @@ const spawnFfmpeg = async (options, remotionRoot) => {
                 }),
             ]),
         codec === 'h264' ? ['-movflags', 'faststart'] : null,
-        audioCodecName ? ['-c:a', audioCodecName] : null,
+        resolvedAudioCodec
+            ? ['-c:a', (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec)]
+            : null,
         // Set max bitrate up to 1024kbps, will choose lower if that's too much
-        audioCodecName ? ['-b:a', options.audioBitrate || '512K'] : null,
+        resolvedAudioCodec ? ['-b:a', options.audioBitrate || '512K'] : null,
         // Ignore metadata that may come from remote media
         ['-map_metadata', '-1'],
         [
@@ -270,7 +275,7 @@ const spawnFfmpeg = async (options, remotionRoot) => {
                 [`Made with Remotion`, packageJson ? packageJson.version : null].join(' '),
         ],
         options.force ? '-y' : null,
-        (_t = options.outputLocation) !== null && _t !== void 0 ? _t : tempFile,
+        (_v = options.outputLocation) !== null && _v !== void 0 ? _v : tempFile,
     ];
     if (options.verbose) {
         console.log('Generated FFMPEG command:');
@@ -284,15 +289,15 @@ const spawnFfmpeg = async (options, remotionRoot) => {
         console.log('Generated final FFMPEG command:');
         console.log(finalFfmpegString);
     }
-    const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_u = options.ffmpegExecutable) !== null && _u !== void 0 ? _u : null, remotionRoot, 'ffmpeg'), finalFfmpegString, {
+    const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_w = options.ffmpegExecutable) !== null && _w !== void 0 ? _w : null, remotionRoot, 'ffmpeg'), finalFfmpegString, {
         cwd: options.dir,
     });
-    (_v = options.cancelSignal) === null || _v === void 0 ? void 0 : _v.call(options, () => {
+    (_x = options.cancelSignal) === null || _x === void 0 ? void 0 : _x.call(options, () => {
         task.kill();
     });
     let ffmpegOutput = '';
     let isFinished = false;
-    (_w = task.stderr) === null || _w === void 0 ? void 0 : _w.on('data', (data) => {
+    (_y = task.stderr) === null || _y === void 0 ? void 0 : _y.on('data', (data) => {
         var _a;
         const str = data.toString();
         ffmpegOutput += str;

package/dist/validate-output-filename.d.ts

@@ -1,2 +1,7 @@
-import type { Codec } from './codec';
-export declare const validateOutputFilename: (codec: Codec, extension: string | null) => void;
+import type { AudioCodec } from './audio-codec';
+export declare const validateOutputFilename: <T extends "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif">({ codec, audioCodec, extension, preferLossless, }: {
+    codec: T;
+    audioCodec: AudioCodec | null;
+    extension: string;
+    preferLossless: boolean;
+}) => void;

package/dist/validate-output-filename.js

@@ -1,57 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOutputFilename = void 0;
-const validateOutputFilename = (codec, extension) => {
-    if (codec === 'h264') {
-        if (extension !== 'mp4' && extension !== 'mkv') {
-            throw new TypeError('When using the H264 codec, the output filename must end in .mp4 or .mkv.');
-        }
-    }
-    if (codec === 'h264-mkv') {
-        if (extension !== 'mkv') {
-            throw new TypeError('When using the "h264-mkv" codec, the output filename must end in ".mkv".');
-        }
-    }
-    if (codec === 'h265') {
-        if (extension !== 'mp4' && extension !== 'hevc') {
-            throw new TypeError('When using H265 codec, the output filename must end in .mp4 or .hevc.');
-        }
-    }
-    if (codec === 'vp8' || codec === 'vp9') {
-        if (extension !== 'webm') {
-            throw new TypeError(`When using the ${codec.toUpperCase()} codec, the output filename must end in .webm.`);
-        }
-    }
-    if (codec === 'prores') {
-        const allowedProResExtensions = ['mov', 'mkv', 'mxf'];
-        if (!extension || !allowedProResExtensions.includes(extension)) {
-            throw new TypeError(`When using the 'prores' codec, the output must end in one of those extensions: ${allowedProResExtensions
-                .map((a) => `.${a}`)
-                .join(', ')}`);
-        }
-    }
-    if (codec === 'mp3') {
-        if (extension !== 'mp3') {
-            throw new TypeError("When using the 'mp3' codec, the output must end in .mp3");
-        }
-    }
-    if (codec === 'aac') {
-        const allowedAacExtensions = ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'];
-        if (!extension || !allowedAacExtensions.includes(extension)) {
-            throw new TypeError(`When using the 'aac' codec, the output must end in one of those extensions: ${allowedAacExtensions
-                .map((a) => `.${a}`)
-                .join(', ')}`);
-        }
-    }
-    if (codec === 'wav') {
-        if (extension !== 'wav') {
-            throw new TypeError("When using the 'wav' codec, the output location must end in .wav.");
-        }
-    }
-    if (codec === 'gif') {
-        if (extension !== 'gif') {
-            throw new TypeError('When using the GIF codec, the output filename must end in .gif.');
-        }
+const audio_codec_1 = require("./audio-codec");
+const file_extensions_1 = require("./file-extensions");
+const validateOutputFilename = ({ codec, audioCodec, extension, preferLossless, }) => {
+    if (!file_extensions_1.defaultFileExtensionMap[codec]) {
+        throw new TypeError(`The codec "${codec}" is not supported. Supported codecs are: ${Object.keys(file_extensions_1.defaultFileExtensionMap).join(', ')}`);
+    }
+    const map = file_extensions_1.defaultFileExtensionMap[codec];
+    const resolvedAudioCodec = audioCodec !== null && audioCodec !== void 0 ? audioCodec : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless });
+    if (resolvedAudioCodec === null) {
+        if (extension !== map.default) {
+            throw new TypeError(`When using the ${codec} codec, the output filename must end in .${map.default}.`);
+        }
+        return;
+    }
+    if (!(resolvedAudioCodec in map.forAudioCodec)) {
+        throw new Error(`Audio codec ${resolvedAudioCodec} is not supported for codec ${codec}`);
+    }
+    const acceptableExtensions = map.forAudioCodec[resolvedAudioCodec].possible;
+    if (!acceptableExtensions.includes(extension)) {
+        throw new TypeError(`When using the ${codec} codec with the ${resolvedAudioCodec} audio codec, the output filename must end in one of the following: ${acceptableExtensions.join(', ')}.`);
     }
 };
 exports.validateOutputFilename = validateOutputFilename;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/renderer",
-	"version": "3.3.41",
+	"version": "3.3.42",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -24,7 +24,7 @@
 	"dependencies": {
 		"execa": "5.1.1",
 		"extract-zip": "2.0.1",
-		"remotion": "3.3.41",
+		"remotion": "3.3.42",
 		"source-map": "^0.8.0-beta.0",
 		"ws": "8.7.0"
 	},
@@ -49,13 +49,13 @@
 		"vitest": "0.24.3"
 	},
 	"optionalDependencies": {
-		"@remotion/compositor-darwin-arm64": "3.3.41",
-		"@remotion/compositor-darwin-x64": "3.3.41",
-		"@remotion/compositor-linux-arm64-gnu": "3.3.41",
-		"@remotion/compositor-linux-arm64-musl": "3.3.41",
-		"@remotion/compositor-linux-x64-gnu": "3.3.41",
-		"@remotion/compositor-linux-x64-musl": "3.3.41",
-		"@remotion/compositor-win32-x64-msvc": "3.3.41"
+		"@remotion/compositor-darwin-arm64": "3.3.42",
+		"@remotion/compositor-darwin-x64": "3.3.42",
+		"@remotion/compositor-linux-arm64-gnu": "3.3.42",
+		"@remotion/compositor-linux-arm64-musl": "3.3.42",
+		"@remotion/compositor-linux-x64-gnu": "3.3.42",
+		"@remotion/compositor-linux-x64-musl": "3.3.42",
+		"@remotion/compositor-win32-x64-msvc": "3.3.42"
 	},
 	"keywords": [
 		"remotion",
@@ -67,5 +67,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "8e408247d151ac824864acf357782f10c89ed5f5"
+	"gitHead": "bfb8098300fb75d4c27220eead954c2dc8e5b4ce"
 }