@remotion/cli 4.0.0-alpha.4 → 4.0.0-alpha4

package/dist/get-cli-options.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCliOptions = exports.getAndValidateAbsoluteOutputFile = void 0;
+exports.getCliOptions = exports.getAndValidateAbsoluteOutputFile = exports.getFinalCodec = exports.validateFfmpegCanUseCodec = void 0;
 const renderer_1 = require("@remotion/renderer");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -11,9 +11,8 @@ const config_1 = require("./config");
 const get_env_1 = require("./get-env");
 const get_final_output_codec_1 = require("./get-final-output-codec");
 const get_input_props_1 = require("./get-input-props");
-const image_formats_1 = require("./image-formats");
 const log_1 = require("./log");
-const user_passed_output_location_1 = require("./user-passed-output-location");
+const parse_command_line_1 = require("./parse-command-line");
 const getAndValidateFrameRange = () => {
     const frameRange = config_1.ConfigInternals.getRange();
     if (typeof frameRange === 'number') {
@@ -23,21 +22,13 @@ const getAndValidateFrameRange = () => {
     }
     return frameRange;
 };
-const getFinalCodec = async (options) => {
-    const userCodec = config_1.ConfigInternals.getOutputCodecOrUndefined();
-    const codec = (0, get_final_output_codec_1.getFinalOutputCodec)({
-        codec: userCodec,
-        fileExtension: options.isLambda
-            ? null
-            : renderer_1.RenderInternals.getExtensionOfFilename((0, user_passed_output_location_1.getUserPassedOutputLocation)()),
-        emitWarning: true,
-    });
+const validateFfmpegCanUseCodec = async (codec, remotionRoot) => {
     const ffmpegExecutable = config_1.ConfigInternals.getCustomFfmpegExecutable();
     if (codec === 'vp8' &&
         !(await renderer_1.RenderInternals.ffmpegHasFeature({
             feature: 'enable-libvpx',
-            isLambda: options.isLambda,
             ffmpegExecutable,
+            remotionRoot,
         }))) {
         log_1.Log.error("The Vp8 codec has been selected, but your FFMPEG binary wasn't compiled with the --enable-lipvpx flag.");
         log_1.Log.error('This does not work, please switch out your FFMPEG binary or choose a different codec.');
@@ -45,8 +36,8 @@ const getFinalCodec = async (options) => {
     if (codec === 'h265' &&
         !(await renderer_1.RenderInternals.ffmpegHasFeature({
             feature: 'enable-gpl',
-            isLambda: options.isLambda,
             ffmpegExecutable,
+            remotionRoot,
         }))) {
         log_1.Log.error("The H265 codec has been selected, but your FFMPEG binary wasn't compiled with the --enable-gpl flag.");
         log_1.Log.error('This does not work, please recompile your FFMPEG binary with --enable-gpl --enable-libx265 or choose a different codec.');
@@ -54,14 +45,25 @@ const getFinalCodec = async (options) => {
     if (codec === 'h265' &&
         !(await renderer_1.RenderInternals.ffmpegHasFeature({
             feature: 'enable-libx265',
-            isLambda: options.isLambda,
             ffmpegExecutable,
+            remotionRoot,
         }))) {
         log_1.Log.error("The H265 codec has been selected, but your FFMPEG binary wasn't compiled with the --enable-libx265 flag.");
         log_1.Log.error('This does not work, please recompile your FFMPEG binary with --enable-gpl --enable-libx265 or choose a different codec.');
     }
-    return codec;
 };
+exports.validateFfmpegCanUseCodec = validateFfmpegCanUseCodec;
+const getFinalCodec = (options) => {
+    var _a;
+    const { codec, reason } = (0, get_final_output_codec_1.getFinalOutputCodec)({
+        cliFlag: parse_command_line_1.parsedCli.codec,
+        configFile: (_a = config_1.ConfigInternals.getOutputCodecOrUndefined()) !== null && _a !== void 0 ? _a : null,
+        downloadName: options.downloadName,
+        outName: options.outName,
+    });
+    return { codec, reason };
+};
+exports.getFinalCodec = getFinalCodec;
 const getBrowser = () => { var _a; return (_a = config_1.ConfigInternals.getBrowser()) !== null && _a !== void 0 ? _a : renderer_1.RenderInternals.DEFAULT_BROWSER; };
 const getAndValidateAbsoluteOutputFile = (relativeOutputLocation, overwrite) => {
     const absoluteOutputFile = path_1.default.resolve(process.cwd(), relativeOutputLocation);
@@ -72,38 +74,24 @@ const getAndValidateAbsoluteOutputFile = (relativeOutputLocation, overwrite) =>
     return absoluteOutputFile;
 };
 exports.getAndValidateAbsoluteOutputFile = getAndValidateAbsoluteOutputFile;
-const getAndValidateShouldOutputImageSequence = async ({ frameRange, isLambda, }) => {
+const getAndValidateShouldOutputImageSequence = async ({ frameRange, isLambda, remotionRoot, }) => {
     const shouldOutputImageSequence = config_1.ConfigInternals.getShouldOutputImageSequence(frameRange);
     // When parsing options locally, we don't need FFMPEG because the render will happen on Lambda
     if (!shouldOutputImageSequence && !isLambda) {
-        await renderer_1.RenderInternals.validateFfmpeg(config_1.ConfigInternals.getCustomFfmpegExecutable());
+        await renderer_1.RenderInternals.validateFfmpeg(config_1.ConfigInternals.getCustomFfmpegExecutable(), remotionRoot, 'ffmpeg');
     }
     return shouldOutputImageSequence;
 };
-const getAndValidateCrf = (shouldOutputImageSequence, codec) => {
+const getCrf = (shouldOutputImageSequence) => {
     const crf = shouldOutputImageSequence
         ? null
-        : config_1.ConfigInternals.getActualCrf(codec);
-    if (crf !== null) {
-        renderer_1.RenderInternals.validateSelectedCrfAndCodecCombination(crf, codec);
-    }
+        : config_1.ConfigInternals.getCrfOrUndefined();
     return crf;
 };
-const getAndValidatePixelFormat = (codec) => {
-    const pixelFormat = config_1.ConfigInternals.getPixelFormat();
-    renderer_1.RenderInternals.validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
-    return pixelFormat;
-};
-const getAndValidateProResProfile = (actualCodec) => {
+const getProResProfile = () => {
     const proResProfile = config_1.ConfigInternals.getProResProfile();
-    renderer_1.RenderInternals.validateSelectedCodecAndProResCombination(actualCodec, proResProfile);
     return proResProfile;
 };
-const getAndValidateImageFormat = ({ shouldOutputImageSequence, codec, pixelFormat, }) => {
-    const imageFormat = (0, image_formats_1.getImageFormat)(shouldOutputImageSequence ? undefined : codec);
-    renderer_1.RenderInternals.validateSelectedPixelFormatAndImageFormatCombination(pixelFormat, imageFormat);
-    return imageFormat;
-};
 const getAndValidateBrowser = async (browserExecutable) => {
     const browser = getBrowser();
     try {
@@ -119,26 +107,20 @@ const getAndValidateBrowser = async (browserExecutable) => {
 const getCliOptions = async (options) => {
     var _a;
     const frameRange = getAndValidateFrameRange();
-    const codec = options.type === 'get-compositions'
-        ? 'h264'
-        : await getFinalCodec({
-            isLambda: options.isLambda,
-        });
     const shouldOutputImageSequence = options.type === 'still'
         ? true
         : await getAndValidateShouldOutputImageSequence({
             frameRange,
             isLambda: options.isLambda,
+            remotionRoot: options.remotionRoot,
         });
-    const overwrite = config_1.ConfigInternals.getShouldOverwrite();
-    const crf = getAndValidateCrf(shouldOutputImageSequence, codec);
-    const pixelFormat = getAndValidatePixelFormat(codec);
-    const imageFormat = getAndValidateImageFormat({
-        shouldOutputImageSequence,
-        codec,
-        pixelFormat,
+    const overwrite = config_1.ConfigInternals.getShouldOverwrite({
+        defaultValue: !options.isLambda,
     });
-    const proResProfile = getAndValidateProResProfile(codec);
+    const crf = getCrf(shouldOutputImageSequence);
+    const videoBitrate = config_1.ConfigInternals.getVideoBitrate();
+    const pixelFormat = config_1.ConfigInternals.getPixelFormat();
+    const proResProfile = getProResProfile();
     const browserExecutable = config_1.ConfigInternals.getBrowserExecutable();
     const ffmpegExecutable = config_1.ConfigInternals.getCustomFfmpegExecutable();
     const ffprobeExecutable = config_1.ConfigInternals.getCustomFfprobeExecutable();
@@ -149,24 +131,25 @@ const getCliOptions = async (options) => {
         ignoreCertificateErrors: config_1.ConfigInternals.getIgnoreCertificateErrors(),
         headless: config_1.ConfigInternals.getChromiumHeadlessMode(),
         gl: (_a = config_1.ConfigInternals.getChromiumOpenGlRenderer()) !== null && _a !== void 0 ? _a : renderer_1.RenderInternals.DEFAULT_OPENGL_RENDERER,
+        userAgent: config_1.ConfigInternals.getChromiumUserAgent(),
     };
-    const everyNthFrame = config_1.ConfigInternals.getAndValidateEveryNthFrame(codec);
-    const numberOfGifLoops = config_1.ConfigInternals.getAndValidateNumberOfGifLoops(codec);
-    const parallelism = config_1.ConfigInternals.getConcurrency();
-    renderer_1.RenderInternals.validateConcurrency(parallelism, 'concurrency');
+    const everyNthFrame = config_1.ConfigInternals.getEveryNthFrame();
+    const numberOfGifLoops = config_1.ConfigInternals.getNumberOfGifLoops();
+    const concurrency = config_1.ConfigInternals.getConcurrency();
+    const height = config_1.ConfigInternals.getHeight();
+    const width = config_1.ConfigInternals.getWidth();
+    renderer_1.RenderInternals.validateConcurrency(concurrency, 'concurrency');
     return {
         puppeteerTimeout: config_1.ConfigInternals.getCurrentPuppeteerTimeout(),
-        parallelism,
+        concurrency,
         frameRange,
         shouldOutputImageSequence,
-        codec,
         inputProps: (0, get_input_props_1.getInputProps)(() => undefined),
-        envVariables: await (0, get_env_1.getEnvironmentVariables)(),
+        envVariables: await (0, get_env_1.getEnvironmentVariables)(() => undefined),
         quality: config_1.ConfigInternals.getQuality(),
         browser: await getAndValidateBrowser(browserExecutable),
         crf,
         pixelFormat,
-        imageFormat,
         proResProfile,
         everyNthFrame,
         numberOfGifLoops,
@@ -179,6 +162,14 @@ const getCliOptions = async (options) => {
         chromiumOptions,
         overwrite,
         port: port !== null && port !== void 0 ? port : null,
+        muted: config_1.ConfigInternals.getMuted(),
+        enforceAudioTrack: config_1.ConfigInternals.getEnforceAudioTrack(),
+        publicDir: config_1.ConfigInternals.getPublicDir(),
+        ffmpegOverride: config_1.ConfigInternals.getFfmpegOverrideFunction(),
+        audioBitrate: config_1.ConfigInternals.getAudioBitrate(),
+        videoBitrate,
+        height,
+        width,
     };
 };
 exports.getCliOptions = getCliOptions;

package/dist/get-composition-id.d.ts

@@ -1 +1,7 @@
-export declare const getCompositionId: () => string;
+import type { TCompMetadata } from 'remotion';
+export declare const getCompositionId: (validCompositions: TCompMetadata[], args: string[]) => Promise<{
+    compositionId: string;
+    reason: string;
+    config: TCompMetadata;
+    argsAfterComposition: string[];
+}>;

package/dist/get-composition-id.js

@@ -2,13 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCompositionId = void 0;
 const log_1 = require("./log");
-const parse_command_line_1 = require("./parse-command-line");
-const getCompositionId = () => {
-    if (!parse_command_line_1.parsedCli._[2]) {
-        log_1.Log.error('Composition ID not passed.');
-        log_1.Log.error('Pass an extra argument <composition-id>.');
-        process.exit(1);
+const select_composition_1 = require("./select-composition");
+const getCompositionId = async (validCompositions, args) => {
+    const [compName, ...remainingArgs] = args;
+    if (compName) {
+        const config = validCompositions.find((c) => c.id === compName);
+        if (!config) {
+            throw new Error(`Cannot find composition with ID "${compName}". Available composition: ${validCompositions
+                .map((c) => c.id)
+                .join(', ')}`);
+        }
+        return {
+            compositionId: compName,
+            reason: 'Passed as argument',
+            config,
+            argsAfterComposition: remainingArgs,
+        };
     }
-    return parse_command_line_1.parsedCli._[2];
+    if (!process.env.CI) {
+        const { compositionId, reason } = await (0, select_composition_1.selectComposition)(validCompositions);
+        if (compositionId && typeof compositionId === 'string') {
+            return {
+                compositionId,
+                reason,
+                config: validCompositions.find((c) => c.id === compositionId),
+                argsAfterComposition: args,
+            };
+        }
+    }
+    log_1.Log.error('Composition ID not passed.');
+    log_1.Log.error('Pass an extra argument <composition-id>.');
+    process.exit(1);
 };
 exports.getCompositionId = getCompositionId;

package/dist/get-composition-with-dimension-override.d.ts

@@ -0,0 +1,12 @@
+import type { TCompMetadata } from 'remotion';
+export declare const getCompositionWithDimensionOverride: ({ validCompositions, height, width, args, }: {
+    validCompositions: TCompMetadata[];
+    height: number | null;
+    width: number | null;
+    args: string[];
+}) => Promise<{
+    compositionId: string;
+    reason: string;
+    config: TCompMetadata;
+    argsAfterComposition: string[];
+}>;

package/dist/get-composition-with-dimension-override.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositionWithDimensionOverride = void 0;
+const get_composition_id_1 = require("./get-composition-id");
+const getCompositionWithDimensionOverride = async ({ validCompositions, height, width, args, }) => {
+    const returnValue = await (0, get_composition_id_1.getCompositionId)(validCompositions, args);
+    return {
+        ...returnValue,
+        config: {
+            ...returnValue.config,
+            height: height !== null && height !== void 0 ? height : returnValue.config.height,
+            width: width !== null && width !== void 0 ? width : returnValue.config.width,
+        },
+    };
+};
+exports.getCompositionWithDimensionOverride = getCompositionWithDimensionOverride;

package/dist/get-env.d.ts

@@ -1 +1 @@
-export declare const getEnvironmentVariables: () => Promise<Record<string, string>>;
+export declare const getEnvironmentVariables: (onUpdate: (newProps: Record<string, string>) => void) => Promise<Record<string, string>>;

package/dist/get-env.js

@@ -4,11 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnvironmentVariables = void 0;
+const renderer_1 = require("@remotion/renderer");
 const dotenv_1 = __importDefault(require("dotenv"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const chalk_1 = require("./chalk");
 const config_1 = require("./config");
-const find_closest_package_json_1 = require("./find-closest-package-json");
 const log_1 = require("./log");
 const parse_command_line_1 = require("./parse-command-line");
 function getProcessEnv() {
@@ -19,9 +20,54 @@ function getProcessEnv() {
     }
     return env;
 }
-const getEnvForEnvFile = async (processEnv, envFile) => {
+const watchEnvFile = ({ processEnv, envFile, onUpdate, existedBefore, }) => {
+    const listener = async () => {
+        try {
+            const file = await fs_1.default.promises.readFile(envFile, 'utf-8');
+            onUpdate({
+                ...processEnv,
+                ...dotenv_1.default.parse(file),
+            });
+            if (existedBefore) {
+                log_1.Log.info(chalk_1.chalk.blueBright(`Updated env file ${envFile}`));
+            }
+            else {
+                log_1.Log.info(chalk_1.chalk.blueBright(`Added env file ${envFile}`));
+            }
+            fs_1.default.unwatchFile(envFile, listener);
+            watchEnvFile({
+                envFile,
+                existedBefore: true,
+                onUpdate,
+                processEnv,
+            });
+        }
+        catch (err) {
+            // No error message if user did not have a .env file from the beginning
+            if (!existedBefore && !fs_1.default.existsSync(envFile)) {
+                return;
+            }
+            if (fs_1.default.existsSync(envFile) && existedBefore) {
+                log_1.Log.error(`${envFile} update failed with error ${err}`);
+            }
+            else {
+                log_1.Log.warn(`${envFile} was deleted.`);
+                fs_1.default.unwatchFile(envFile, listener);
+                watchEnvFile({
+                    envFile,
+                    existedBefore: false,
+                    onUpdate,
+                    processEnv,
+                });
+            }
+        }
+    };
+    fs_1.default.watchFile(envFile, { interval: 100 }, listener);
+};
+const getEnvForEnvFile = async (processEnv, envFile, onUpdate) => {
     try {
         const envFileData = await fs_1.default.promises.readFile(envFile);
+        watchEnvFile({ processEnv, envFile, onUpdate, existedBefore: true });
         return {
             ...processEnv,
             ...dotenv_1.default.parse(envFileData),
@@ -33,7 +79,7 @@ const getEnvForEnvFile = async (processEnv, envFile) => {
         process.exit(1);
     }
 };
-const getEnvironmentVariables = () => {
+const getEnvironmentVariables = (onUpdate) => {
     const processEnv = getProcessEnv();
     if (parse_command_line_1.parsedCli['env-file']) {
         const envFile = path_1.default.resolve(process.cwd(), parse_command_line_1.parsedCli['env-file']);
@@ -43,24 +89,30 @@ const getEnvironmentVariables = () => {
             log_1.Log.error('Check that your path is correct and try again.');
             process.exit(1);
         }
-        return getEnvForEnvFile(processEnv, envFile);
+        return getEnvForEnvFile(processEnv, envFile, onUpdate);
     }
-    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
+    const remotionRoot = renderer_1.RenderInternals.findRemotionRoot();
     const configFileSetting = config_1.ConfigInternals.getDotEnvLocation();
     if (configFileSetting) {
         const envFile = path_1.default.resolve(remotionRoot, configFileSetting);
         if (!fs_1.default.existsSync(envFile)) {
-            log_1.Log.error('You specifed a custom .env file using `Config.Rendering.setDotEnvLocation()` in the config file but it could not be found');
+            log_1.Log.error('You specified a custom .env file using `Config.setDotEnvLocation()` in the config file but it could not be found');
             log_1.Log.error('We looked for the file at:', envFile);
             log_1.Log.error('Check that your path is correct and try again.');
             process.exit(1);
         }
-        return getEnvForEnvFile(processEnv, envFile);
+        return getEnvForEnvFile(processEnv, envFile, onUpdate);
     }
     const defaultEnvFile = path_1.default.resolve(remotionRoot, '.env');
     if (!fs_1.default.existsSync(defaultEnvFile)) {
+        watchEnvFile({
+            processEnv,
+            envFile: defaultEnvFile,
+            onUpdate,
+            existedBefore: false,
+        });
         return Promise.resolve(processEnv);
     }
-    return getEnvForEnvFile(processEnv, defaultEnvFile);
+    return getEnvForEnvFile(processEnv, defaultEnvFile, onUpdate);
 };
 exports.getEnvironmentVariables = getEnvironmentVariables;

package/dist/get-filename.d.ts

@@ -1,7 +1,6 @@
-import type { Codec } from '@remotion/renderer';
-export declare const getOutputFilename: ({ codec, imageSequence, compositionName, defaultExtension, }: {
-    codec: Codec;
+export declare const getOutputFilename: ({ imageSequence, compositionName, defaultExtension, args, }: {
     imageSequence: boolean;
     compositionName: string;
     defaultExtension: string;
+    args: string[];
 }) => string;

package/dist/get-filename.js

@@ -4,12 +4,14 @@ exports.getOutputFilename = void 0;
 const renderer_1 = require("@remotion/renderer");
 const log_1 = require("./log");
 const user_passed_output_location_1 = require("./user-passed-output-location");
-const getOutputFilename = ({ codec, imageSequence, compositionName, defaultExtension, }) => {
-    let filename = (0, user_passed_output_location_1.getOutputLocation)({
+const getOutputFilename = ({ imageSequence, compositionName, defaultExtension, args, }) => {
+    const filename = (0, user_passed_output_location_1.getOutputLocation)({
         compositionId: compositionName,
         defaultExtension,
+        args,
+        type: imageSequence ? 'sequence' : 'asset',
     });
-    let extension = renderer_1.RenderInternals.getExtensionOfFilename(filename);
+    const extension = renderer_1.RenderInternals.getExtensionOfFilename(filename);
     if (imageSequence) {
         if (extension !== null) {
             log_1.Log.error('The output directory of the image sequence cannot have an extension. Got: ' +
@@ -19,26 +21,8 @@ const getOutputFilename = ({ codec, imageSequence, compositionName, defaultExten
         return filename;
     }
     if (extension === null && !imageSequence) {
-        if (codec === 'h264' || codec === 'h265') {
-            log_1.Log.warn('No file extension specified, adding .mp4 automatically.');
-            filename += '.mp4';
-            extension = 'mp4';
-        }
-        if (codec === 'h264-mkv') {
-            log_1.Log.warn('No file extension specified, adding .mkv automatically.');
-            filename += '.mkv';
-            extension = 'mkv';
-        }
-        if (codec === 'vp8' || codec === 'vp9') {
-            log_1.Log.warn('No file extension specified, adding .webm automatically.');
-            filename += '.webm';
-            extension = 'webm';
-        }
-        if (codec === 'prores') {
-            log_1.Log.warn('No file extension specified, adding .mov automatically.');
-            filename += '.mov';
-            extension = 'mov';
-        }
+        log_1.Log.warn(`No file extension specified, adding ${defaultExtension} automatically.`);
+        return `${filename}.${defaultExtension}`;
     }
     return filename;
 };

package/dist/get-final-output-codec.d.ts

@@ -1,6 +1,10 @@
 import type { Codec, CodecOrUndefined } from '@remotion/renderer';
-export declare const getFinalOutputCodec: ({ codec: inputCodec, fileExtension, emitWarning, }: {
-    codec: CodecOrUndefined;
-    fileExtension: string | null;
-    emitWarning: boolean;
-}) => Codec;
+export declare const getFinalOutputCodec: ({ cliFlag, configFile, downloadName, outName, }: {
+    cliFlag: CodecOrUndefined;
+    outName: string | null;
+    downloadName: string | null;
+    configFile: Codec | null;
+}) => {
+    codec: Codec;
+    reason: string;
+};

package/dist/get-final-output-codec.js

@@ -2,62 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFinalOutputCodec = void 0;
 const renderer_1 = require("@remotion/renderer");
-const log_1 = require("./log");
-const getFinalOutputCodec = ({ codec: inputCodec, fileExtension, emitWarning, }) => {
-    if (inputCodec === undefined && fileExtension === 'webm') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .webm extension, using the VP8 encoder. Use --codec=vp9 to use the Vp9 encoder.');
-        }
-        return 'vp8';
-    }
-    if (inputCodec === undefined && fileExtension === 'hevc') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .hevc extension, using the H265 encoder.');
-        }
-        return 'h265';
-    }
-    if (inputCodec === undefined && fileExtension === 'mp3') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .mp3 extension, using the MP3 encoder.');
-        }
-        return 'mp3';
-    }
-    if (inputCodec === undefined && fileExtension === 'mov') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .mov extension, using the Apple ProRes encoder.');
-        }
-        return 'prores';
-    }
-    if (inputCodec === undefined && fileExtension === 'wav') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .wav extension, using the WAV encoder.');
-        }
-        return 'wav';
-    }
-    if (inputCodec === undefined && fileExtension === 'aac') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .aac extension, using the AAC encoder.');
-        }
-        return 'aac';
-    }
-    if (inputCodec === undefined && fileExtension === 'm4a') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .m4a extension, using the AAC encoder.');
-        }
-        return 'aac';
-    }
-    if (inputCodec === undefined && fileExtension === 'mkv') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .mkv extension, using the H264 encoder and WAV audio format.');
-        }
-        return 'h264-mkv';
-    }
-    if (inputCodec === undefined && fileExtension === 'gif') {
-        if (emitWarning) {
-            log_1.Log.info('You have specified a .gif extension, rendering a GIF');
-        }
-        return 'gif';
-    }
-    return inputCodec !== null && inputCodec !== void 0 ? inputCodec : renderer_1.RenderInternals.DEFAULT_CODEC;
+const deriveCodecsFromFilename = (extension) => {
+    var _a, _b;
+    if (extension === null) {
+        return { possible: [], default: null };
+    }
+    return {
+        default: (_a = renderer_1.RenderInternals.defaultCodecsForFileExtension[extension]) !== null && _a !== void 0 ? _a : null,
+        possible: (_b = renderer_1.RenderInternals.makeFileExtensionMap()[extension]) !== null && _b !== void 0 ? _b : [],
+    };
+};
+const getFinalOutputCodec = ({ cliFlag, configFile, downloadName, outName, }) => {
+    const downloadNameExtension = renderer_1.RenderInternals.getExtensionOfFilename(downloadName);
+    const outNameExtension = renderer_1.RenderInternals.getExtensionOfFilename(outName);
+    const derivedDownloadCodecs = deriveCodecsFromFilename(downloadNameExtension);
+    const derivedOutNameCodecs = deriveCodecsFromFilename(outNameExtension);
+    if (derivedDownloadCodecs.possible.length > 0 &&
+        derivedOutNameCodecs.possible.length > 0 &&
+        derivedDownloadCodecs.possible.join('') !==
+            derivedOutNameCodecs.possible.join('')) {
+        throw new TypeError(`The download name is ${downloadName} but the output name is ${outName}. The file extensions must match`);
+    }
+    if (cliFlag) {
+        if (derivedDownloadCodecs.possible.length > 0 &&
+            derivedDownloadCodecs.possible.indexOf(cliFlag) === -1) {
+            throw new TypeError(`The download name is ${downloadName} but --codec=${cliFlag} was passed. The download name implies a codec of ${derivedDownloadCodecs.possible.join(' or ')} which does not align with the --codec flag.`);
+        }
+        if (derivedOutNameCodecs.possible.length > 0 &&
+            derivedOutNameCodecs.possible.indexOf(cliFlag) === -1) {
+            throw new TypeError(`The out name is ${outName} but --codec=${cliFlag} was passed. The out name implies a codec of ${derivedOutNameCodecs.possible.join(' or ')} which does not align with the --codec flag.`);
+        }
+        return { codec: cliFlag, reason: 'from --codec flag' };
+    }
+    if (derivedDownloadCodecs.possible.length > 0) {
+        return {
+            codec: derivedDownloadCodecs.default,
+            reason: 'derived from download name',
+        };
+    }
+    if (derivedOutNameCodecs.possible.length > 0) {
+        return {
+            codec: derivedOutNameCodecs.default,
+            reason: 'derived from out name',
+        };
+    }
+    if (configFile) {
+        return {
+            codec: configFile,
+            reason: 'Config file',
+        };
+    }
+    return { codec: renderer_1.RenderInternals.DEFAULT_CODEC, reason: 'default' };
 };
 exports.getFinalOutputCodec = getFinalOutputCodec;

package/dist/get-input-props.d.ts

@@ -1 +1,5 @@
+/**
+ * @description You can retrieve inputs that you pass in, from the command line using --props, or the inputProps parameter if you're using the Node.js API
+ * @see [Documentation](https://www.remotion.dev/docs/get-input-props)
+ */
 export declare const getInputProps: (onUpdate: (newProps: object) => void) => object;

package/dist/get-input-props.js

@@ -9,6 +9,10 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const log_1 = require("./log");
 const parse_command_line_1 = require("./parse-command-line");
+/**
+ * @description You can retrieve inputs that you pass in, from the command line using --props, or the inputProps parameter if you're using the Node.js API
+ * @see [Documentation](https://www.remotion.dev/docs/get-input-props)
+ */
 const getInputProps = (onUpdate) => {
     if (!parse_command_line_1.parsedCli.props) {
         return {};

package/dist/get-network-address.d.ts

@@ -0,0 +1 @@
+export declare const getNetworkAddress: () => string | undefined;