@remotion/renderer 4.0.0-alpha.4 → 4.0.0-alpha10

package/dist/crf.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSelectedCrfAndCodecCombination = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
+exports.validateQualitySettings = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
 const is_audio_codec_1 = require("./is-audio-codec");
 const getDefaultCrfForCodec = (codec) => {
     if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
@@ -9,7 +9,7 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'h264' || codec === 'h264-mkv') {
         return 18; // FFMPEG default 23
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return 23; // FFMPEG default 28
     }
     if (codec === 'vp8') {
@@ -21,6 +21,9 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'prores') {
         return 0;
     }
+    if (codec === 'gif') {
+        return 0;
+    }
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
@@ -31,10 +34,13 @@ const getValidCrfRanges = (codec) => {
     if (codec === 'prores') {
         return [0, 0];
     }
+    if (codec === 'gif') {
+        return [0, 0];
+    }
     if (codec === 'h264' || codec === 'h264-mkv') {
         return [1, 51];
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return [0, 51];
     }
     if (codec === 'vp8') {
@@ -46,19 +52,46 @@ const getValidCrfRanges = (codec) => {
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getValidCrfRanges = getValidCrfRanges;
-const validateSelectedCrfAndCodecCombination = (crf, codec) => {
-    if (crf === null) {
-        return;
+const validateQualitySettings = ({ codec, crf, videoBitrate, }) => {
+    if (crf && videoBitrate) {
+        throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
+    }
+    if (videoBitrate) {
+        if (codec === 'prores') {
+            console.warn('ProRes does not support videoBitrate. Ignoring.');
+            return [];
+        }
+        if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+            console.warn(`${codec} does not support videoBitrate. Ignoring.`);
+            return [];
+        }
+        return ['-b:v', videoBitrate];
+    }
+    if (crf === null || typeof crf === 'undefined') {
+        const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
+        return ['-crf', String(actualCrf)];
     }
     if (typeof crf !== 'number') {
         throw new TypeError('Expected CRF to be a number, but is ' + JSON.stringify(crf));
     }
     const range = (0, exports.getValidCrfRanges)(codec);
     if (crf === 0 && (codec === 'h264' || codec === 'h264-mkv')) {
-        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably want. Set CRF to a higher value to fix this error.");
+        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably do not want. Set CRF to a higher value to fix this error.");
     }
     if (crf < range[0] || crf > range[1]) {
+        if (range[0] === 0 && range[1] === 0) {
+            throw new TypeError(`The "${codec}" codec does not support the --crf option.`);
+        }
         throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
     }
+    if (codec === 'prores') {
+        console.warn('ProRes does not support the "crf" option. Ignoring.');
+        return [];
+    }
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        console.warn(`${codec} does not support the "crf" option. Ignoring.`);
+        return [];
+    }
+    return ['-crf', String(crf)];
 };
-exports.validateSelectedCrfAndCodecCombination = validateSelectedCrfAndCodecCombination;
+exports.validateQualitySettings = validateQualitySettings;

package/dist/cycle-browser-tabs.d.ts

@@ -1,7 +1,4 @@
-import type { openBrowser } from './open-browser';
-declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
-declare type Browser = Await<ReturnType<typeof openBrowser>>;
-export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {
+import type { BrowserReplacer } from './replace-browser';
+export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number) => {
     stopCycling: () => void;
 };
-export {};

package/dist/cycle-browser-tabs.js

@@ -13,24 +13,24 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
+                .getBrowser()
                 .pages()
                 .then((pages) => {
-                var _a;
                 if (pages.length === 0) {
                     return;
                 }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                if (!(currentPage === null || currentPage === void 0 ? void 0 : currentPage.closed) &&
                     !stopped &&
                     (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
-                .then(() => {
+                .catch((err) => console.log(err))
+                .finally(() => {
                 set();
-            })
-                .catch((err) => console.log(err));
+            });
         }, 200);
     };
     set();

package/dist/delete-directory.d.ts

@@ -1 +1 @@
-export declare const deleteDirectory: (directory: string) => Promise<void>;
+export declare const deleteDirectory: (directory: string) => void;

package/dist/delete-directory.js

@@ -1,32 +1,58 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteDirectory = void 0;
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
+const node_fs_1 = __importStar(require("node:fs"));
 const is_serve_url_1 = require("./is-serve-url");
-const deleteDirectory = async (directory) => {
-    var _a;
+const deleteDirectory = (directory) => {
     if ((0, is_serve_url_1.isServeUrl)(directory)) {
         return;
     }
-    if (process.platform === 'win32') {
-        // We use del before to remove all files inside the directories otherwise
-        // rmdir will throw an error.
-        await (0, execa_1.default)('cmd', ['/c', 'del', '/f', '/s', '/q', directory]);
+    if (!(0, node_fs_1.existsSync)(directory)) {
+        return;
+    }
+    // Working around a bug with NodeJS 16 on Windows:
+    // If a subdirectory is already deleted, it will fail with EPERM
+    // even with force: true and recursive and maxRetries set higher.
+    // This is even with the fixWinEPERMSync function being called by Node.JS.
+    // This is a workaround for this issue.
+    let retries = 2;
+    while (retries >= 0) {
         try {
-            await (0, execa_1.default)('cmd', ['/c', 'rmdir', '/s', '/q', directory]);
+            node_fs_1.default.rmSync(directory, {
+                maxRetries: 2,
+                recursive: true,
+                force: true,
+                retryDelay: 100,
+            });
         }
         catch (err) {
-            // Is not a directory
+            retries--;
+            continue;
         }
-    }
-    else {
-        await ((_a = fs_1.default.promises.rm) !== null && _a !== void 0 ? _a : fs_1.default.promises.rmdir)(directory, {
-            recursive: true,
-        });
+        break;
     }
 };
 exports.deleteDirectory = deleteDirectory;

package/dist/determine-resize-params.d.ts

@@ -0,0 +1 @@
+export declare const determineResizeParams: (needsResize: [number, number] | null) => string[];

package/dist/determine-resize-params.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineResizeParams = void 0;
+const determineResizeParams = (needsResize) => {
+    if (needsResize === null) {
+        return [];
+    }
+    return ['-s', `${needsResize[0]}x${needsResize[1]}`];
+};
+exports.determineResizeParams = determineResizeParams;

package/dist/determine-vcodec-ffmpeg-flags.d.ts

@@ -0,0 +1,2 @@
+import type { SpecialVCodecForTransparency } from './assets/download-map';
+export declare const determineVcodecFfmpegFlags: (vcodecFlag: SpecialVCodecForTransparency) => string[];

package/dist/determine-vcodec-ffmpeg-flags.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineVcodecFfmpegFlags = void 0;
+const truthy_1 = require("./truthy");
+const determineVcodecFfmpegFlags = (vcodecFlag) => {
+    return [
+        vcodecFlag === 'vp9' ? '-vcodec' : null,
+        vcodecFlag === 'vp9' ? 'libvpx-vp9' : null,
+        vcodecFlag === 'vp8' ? '-vcodec' : null,
+        vcodecFlag === 'vp8' ? 'libvpx' : null,
+    ].filter(truthy_1.truthy);
+};
+exports.determineVcodecFfmpegFlags = determineVcodecFfmpegFlags;

package/dist/does-have-m2-bug.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from './codec';
+import type { PixelFormat } from './pixel-format';
+export declare const warnAboutM2Bug: (codec: Codec | null, pixelFormat: PixelFormat | null) => void;

package/dist/does-have-m2-bug.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnAboutM2Bug = void 0;
+const node_os_1 = require("node:os");
+const warnAboutM2Bug = (codec, pixelFormat) => {
+    const isM2 = (0, node_os_1.cpus)().find((c) => c.model.includes('Apple M2'));
+    if (codec === 'prores' && pixelFormat === 'yuv422p10le' && isM2) {
+        console.warn();
+        console.warn('⚠️ Known issue: Apple M2 CPUs currently suffer from a bug where transparent ProRes videos have flickering. https://github.com/remotion-dev/remotion/issues/1929');
+    }
+};
+exports.warnAboutM2Bug = warnAboutM2Bug;

package/dist/ensure-ffmpeg.d.ts

@@ -0,0 +1,18 @@
+export declare type EnsureFfmpegOptions = {
+    remotionRoot?: string;
+};
+declare type Result = {
+    result: 'found-in-path' | 'found-in-node-modules' | 'installed';
+    wasAlreadyInstalled: boolean;
+};
+/**
+ * @description Checks if the ffmpeg binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffmpeg)
+ */
+export declare const ensureFfmpeg: (options?: EnsureFfmpegOptions) => Promise<Result>;
+/**
+ * @description Checks if the ffprobe binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffprobe)
+ */
+export declare const ensureFfprobe: (options?: EnsureFfmpegOptions) => Promise<Result>;
+export {};

package/dist/ensure-ffmpeg.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFfprobe = exports.ensureFfmpeg = void 0;
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const ensureFfmpegOrFfprobe = async (binary, options) => {
+    var _a;
+    const exists = (0, validate_ffmpeg_1.binaryExists)(binary);
+    const remotionRoot = (_a = options === null || options === void 0 ? void 0 : options.remotionRoot) !== null && _a !== void 0 ? _a : process.cwd();
+    if (exists) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if (process.platform === 'linux' && (0, fs_1.existsSync)(ffmpeg_flags_1.lambdaFfmpegPaths[binary])) {
+        return {
+            wasAlreadyInstalled: true,
+            result: 'found-in-path',
+        };
+    }
+    if ((0, ffmpeg_flags_1.ffmpegInNodeModules)(remotionRoot, binary)) {
+        return {
+            result: 'found-in-node-modules',
+            wasAlreadyInstalled: true,
+        };
+    }
+    const binaryUrl = (0, ffmpeg_flags_1.getBinaryDownloadUrl)(binary);
+    if (binaryUrl) {
+        await (0, ffmpeg_flags_1.downloadBinary)(remotionRoot, binaryUrl.url, binary);
+        return {
+            result: 'installed',
+            wasAlreadyInstalled: false,
+        };
+    }
+    throw new Error(`${binary} could not be installed automatically. Your architecture and OS combination (os = ${os_1.default.platform()}, arch = ${process.arch}) is not supported. Please install ${binary} manually and add "${binary}" to your PATH.`);
+};
+/**
+ * @description Checks if the ffmpeg binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffmpeg)
+ */
+const ensureFfmpeg = (options) => {
+    return ensureFfmpegOrFfprobe('ffmpeg', options);
+};
+exports.ensureFfmpeg = ensureFfmpeg;
+/**
+ * @description Checks if the ffprobe binary is installed and if it is not, downloads it and puts it into your node_modules folder.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/ensure-ffprobe)
+ */
+const ensureFfprobe = (options) => {
+    return ensureFfmpegOrFfprobe('ffprobe', options);
+};
+exports.ensureFfprobe = ensureFfprobe;

package/dist/ensure-output-directory.js

@@ -4,12 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureOutputDirectory = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
 const ensureOutputDirectory = (outputLocation) => {
-    const dirName = path_1.default.dirname(outputLocation);
-    if (!fs_1.default.existsSync(dirName)) {
-        fs_1.default.mkdirSync(dirName, {
+    const dirName = node_path_1.default.dirname(outputLocation);
+    if (!node_fs_1.default.existsSync(dirName)) {
+        node_fs_1.default.mkdirSync(dirName, {
             recursive: true,
         });
     }

package/dist/ensure-presentation-timestamp.d.ts

@@ -1,2 +1,15 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const ensurePresentationTimestamps: (downloadMap: DownloadMap, src: string) => Promise<string>;
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const ensurePresentationTimestampWithoutCache: ({ src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
+    src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+}) => Promise<string>;
+export declare const ensurePresentationTimestamps: ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }: {
+    downloadMap: DownloadMap;
+    src: string;
+    remotionRoot: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+}) => Promise<string>;

package/dist/ensure-presentation-timestamp.js

@@ -3,19 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensurePresentationTimestamps = void 0;
+exports.ensurePresentationTimestamps = exports.ensurePresentationTimestampWithoutCache = void 0;
 const execa_1 = __importDefault(require("execa"));
 const path_1 = __importDefault(require("path"));
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const guess_extension_for_media_1 = require("./guess-extension-for-media");
 const truthy_1 = require("./truthy");
 let callbacks = [];
-const getTemporaryOutputName = async (src) => {
+const getTemporaryOutputName = async ({ src, remotionRoot, ffprobeBinary, }) => {
     const parts = src.split(path_1.default.sep);
     // If there is no file extension for the video, then we need to temporarily add an extension
     const lastPart = parts[parts.length - 1];
     const extraExtension = lastPart.includes('.')
         ? null
-        : await (0, guess_extension_for_media_1.guessExtensionForVideo)(src);
+        : await (0, guess_extension_for_media_1.guessExtensionForVideo)({
+            src,
+            remotionRoot,
+            ffprobeBinary,
+        });
     return parts
         .map((p, i) => {
         if (i === parts.length - 1) {
@@ -25,7 +30,29 @@ const getTemporaryOutputName = async (src) => {
     })
         .join(path_1.default.sep);
 };
-const ensurePresentationTimestamps = async (downloadMap, src) => {
+const ensurePresentationTimestampWithoutCache = async ({ src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
+    // If there is no file extension for the video, then we need to tempoa
+    const output = await getTemporaryOutputName({
+        src,
+        remotionRoot,
+        ffprobeBinary: ffprobeExecutable,
+    });
+    await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        '-i',
+        src,
+        '-fflags',
+        '+genpts+igndts',
+        '-vcodec',
+        'copy',
+        '-acodec',
+        'copy',
+        output,
+        '-y',
+    ]);
+    return output;
+};
+exports.ensurePresentationTimestampWithoutCache = ensurePresentationTimestampWithoutCache;
+const ensurePresentationTimestamps = async ({ downloadMap, src, remotionRoot, ffmpegExecutable, ffprobeExecutable, }) => {
     const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
     if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
         return new Promise((resolve) => {
@@ -39,20 +66,12 @@ const ensurePresentationTimestamps = async (downloadMap, src) => {
         return elem.src;
     }
     downloadMap.ensureFileHasPresentationTimestamp[src] = { type: 'encoding' };
-    // If there is no file extension for the video, then we need to tempoa
-    const output = await getTemporaryOutputName(src);
-    await (0, execa_1.default)('ffmpeg', [
-        '-i',
+    const output = await (0, exports.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable,
+        ffprobeExecutable,
+        remotionRoot,
         src,
-        '-fflags',
-        '+genpts+igndts',
-        '-vcodec',
-        'copy',
-        '-acodec',
-        'copy',
-        output,
-        '-y',
-    ]);
+    });
     callbacks = callbacks.filter((c) => {
         if (c.src === src) {
             c.fn(output);

package/dist/error-handling/handle-javascript-exception.js

@@ -16,6 +16,9 @@ exports.ErrorWithStackFrame = ErrorWithStackFrame;
 const cleanUpErrorMessage = (exception) => {
     var _a, _b, _c, _d;
     let errorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
+    if (!errorMessage) {
+        return null;
+    }
     const errorType = (_b = exception.exceptionDetails.exception) === null || _b === void 0 ? void 0 : _b.className;
     const prefix = `${errorType}: `;
     if (errorMessage.startsWith(prefix)) {
@@ -46,6 +49,13 @@ const handleJavascriptException = ({ page, onError, frame, }) => {
         var _a, _b, _c;
         const rawErrorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
         const cleanErrorMessage = cleanUpErrorMessage(exception);
+        if (!cleanErrorMessage) {
+            console.error(exception);
+            const err = new Error(rawErrorMessage);
+            err.stack = rawErrorMessage;
+            onError(err);
+            return;
+        }
         if (!exception.exceptionDetails.stackTrace) {
             const err = new Error(removeDelayRenderStack(cleanErrorMessage));
             err.stack = rawErrorMessage;

package/dist/error-handling/symbolicate-error.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.symbolicateError = void 0;
 const symbolicate_stacktrace_1 = require("../symbolicate-stacktrace");
+const truthy_1 = require("../truthy");
 const handle_javascript_exception_1 = require("./handle-javascript-exception");
 const symbolicateError = async (symbolicateableError) => {
     const { delayRenderCall, stackFrame } = symbolicateableError;
     const [mainErrorFrames, delayRenderFrames] = await Promise.all([
         stackFrame ? (0, symbolicate_stacktrace_1.symbolicateStackTrace)(stackFrame) : null,
         delayRenderCall ? (0, symbolicate_stacktrace_1.symbolicateStackTrace)(delayRenderCall) : null,
-    ]);
+    ].filter(truthy_1.truthy));
     const symbolicatedErr = new handle_javascript_exception_1.ErrorWithStackFrame({
         message: symbolicateableError.message,
         symbolicatedStackFrames: mainErrorFrames,

package/dist/extract-frame-from-video.d.ts

@@ -10,6 +10,7 @@ declare type Options = {
     ffprobeExecutable: FfmpegExecutable;
     imageFormat: OffthreadVideoImageFormat;
     downloadMap: DownloadMap;
+    remotionRoot: string;
 };
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};