@remotion/renderer 4.0.0-oops.3 → 4.0.0-prefetch.11

package/dist/compress-assets.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Since audio or video can be base64-encoded, those can be really long strings.
+ * Since we track the `src` property for every frame, Node.JS can run out of memory easily. Instead of duplicating the src for every frame, we save memory by replacing the full base 64 encoded data with a string `same-as-[asset-id]-[frame]` referencing a previous asset with the same src.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAssetCompressed = exports.compressAsset = void 0;
+const compressAsset = (previousAssets, newAsset) => {
+    if (newAsset.src.length < 400) {
+        return newAsset;
+    }
+    const assetWithSameSrc = previousAssets.find((a) => a.src === newAsset.src);
+    if (!assetWithSameSrc) {
+        return newAsset;
+    }
+    return {
+        ...newAsset,
+        src: `same-as-${assetWithSameSrc.id}-${assetWithSameSrc.frame}`,
+    };
+};
+exports.compressAsset = compressAsset;
+const isAssetCompressed = (src) => {
+    return src.startsWith('same-as');
+};
+exports.isAssetCompressed = isAssetCompressed;

package/dist/convert-number-of-gif-loops-to-ffmpeg.d.ts

@@ -0,0 +1 @@
+export declare const convertNumberOfGifLoopsToFfmpegSyntax: (loops: number | null) => string;

package/dist/convert-number-of-gif-loops-to-ffmpeg.js

@@ -0,0 +1,17 @@
+"use strict";
+// https://superuser.com/questions/1607099/how-to-control-gif-loop-settings-in-ffmpeg
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNumberOfGifLoopsToFfmpegSyntax = void 0;
+const convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
+    // Infinite loop
+    if (loops === null) {
+        return '0';
+    }
+    // No loops
+    if (loops === 0) {
+        return '-1';
+    }
+    // N amount of loops
+    return String(loops);
+};
+exports.convertNumberOfGifLoopsToFfmpegSyntax = convertNumberOfGifLoopsToFfmpegSyntax;

package/dist/convert-to-pcm.d.ts

@@ -1,4 +1,4 @@
-import { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const convertToPcm: ({ ffmpegExecutable, input, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     input: string;

package/dist/create-ffmpeg-complex-filter.d.ts

@@ -1,4 +1,5 @@
-export declare const createFfmpegComplexFilter: (filters: number) => Promise<{
+import type { DownloadMap } from './assets/download-map';
+export declare const createFfmpegComplexFilter: (filters: number, downloadMap: DownloadMap) => Promise<{
     complexFilterFlag: [string, string] | null;
     cleanup: () => void;
 }>;

package/dist/create-ffmpeg-complex-filter.js

@@ -1,23 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegComplexFilter = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
-const tmp_dir_1 = require("./tmp-dir");
-const createFfmpegComplexFilter = async (filters) => {
+const createFfmpegComplexFilter = async (filters, downloadMap) => {
     if (filters === 0) {
         return { complexFilterFlag: null, cleanup: () => undefined };
     }
     const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)(filters);
-    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter);
-    const tempPath = (0, tmp_dir_1.tmpDir)('remotion-complex-filter-script');
-    const filterFile = path_1.default.join(tempPath, 'complex-filter.txt');
-    await fs_1.default.promises.writeFile(filterFile, complexFilter);
+    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter, downloadMap);
     return {
         complexFilterFlag: ['-filter_complex_script', file],
         cleanup,

package/dist/create-ffmpeg-merge-filter.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegMergeFilter = void 0;
-const remotion_1 = require("remotion");
+const truthy_1 = require("./truthy");
 const createFfmpegMergeFilter = (inputs) => {
     const leftChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 0 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     const rightChannel = new Array(inputs * 2)
         .fill(true)
         .map((_, i) => (i % 2 === 1 ? `c${i}` : null))
-        .filter(remotion_1.Internals.truthy)
+        .filter(truthy_1.truthy)
         .join('+');
     return `[0:a][1:a]amerge=inputs=${inputs},pan=stereo|c0=${leftChannel}|c1=${rightChannel}[a]`;
 };

package/dist/create-silent-audio.d.ts

@@ -1,4 +1,4 @@
-import { FfmpegExecutable } from 'remotion';
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
     ffmpegExecutable: FfmpegExecutable;
     numberOfSeconds: number;

package/dist/crf.d.ts

@@ -0,0 +1,5 @@
+import type { Codec } from './codec';
+export declare type Crf = number | undefined;
+export declare const getDefaultCrfForCodec: (codec: Codec) => number;
+export declare const getValidCrfRanges: (codec: Codec) => [number, number];
+export declare const validateSelectedCrfAndCodecCombination: (crf: unknown, codec: Codec) => void;

package/dist/crf.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelectedCrfAndCodecCombination = 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)) {
+        return 0;
+    }
+    if (codec === 'h264' || codec === 'h264-mkv') {
+        return 18; // FFMPEG default 23
+    }
+    if (codec === 'h265' || codec === 'gif') {
+        return 23; // FFMPEG default 28
+    }
+    if (codec === 'vp8') {
+        return 9; // FFMPEG default 10
+    }
+    if (codec === 'vp9') {
+        return 28; // FFMPEG recommendation 31
+    }
+    if (codec === 'prores') {
+        return 0;
+    }
+    throw new TypeError(`Got unexpected codec "${codec}"`);
+};
+exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
+const getValidCrfRanges = (codec) => {
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        return [0, 0];
+    }
+    if (codec === 'prores') {
+        return [0, 0];
+    }
+    if (codec === 'h264' || codec === 'h264-mkv') {
+        return [1, 51];
+    }
+    if (codec === 'h265' || codec === 'gif') {
+        return [0, 51];
+    }
+    if (codec === 'vp8') {
+        return [4, 63];
+    }
+    if (codec === 'vp9') {
+        return [0, 63];
+    }
+    throw new TypeError(`Got unexpected codec "${codec}"`);
+};
+exports.getValidCrfRanges = getValidCrfRanges;
+const validateSelectedCrfAndCodecCombination = (crf, codec) => {
+    if (crf === null) {
+        return;
+    }
+    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.");
+    }
+    if (crf < range[0] || crf > range[1]) {
+        throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
+    }
+};
+exports.validateSelectedCrfAndCodecCombination = validateSelectedCrfAndCodecCombination;

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

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

package/dist/cycle-browser-tabs.js

@@ -2,17 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cycleBrowserTabs = void 0;
 const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
+    if (concurrency <= 1) {
+        return {
+            stopCycling: () => undefined,
+        };
+    }
     let interval = null;
     let i = 0;
+    let stopped = false;
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
                 .pages()
                 .then((pages) => {
-                var _a, _b;
+                var _a;
+                if (pages.length === 0) {
+                    return;
+                }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_b = (_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) !== null && _b !== void 0 ? _b : true)) {
+                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                    !stopped &&
+                    (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
@@ -28,6 +39,7 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
             if (!interval) {
                 return;
             }
+            stopped = true;
             return clearInterval(interval);
         },
     };

package/dist/delay-render-embedded-stack.d.ts

@@ -1,2 +1,2 @@
-import { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from './parse-browser-error-stack';
 export declare const parseDelayRenderEmbeddedStack: (message: string) => UnsymbolicatedStackFrame[] | null;

package/dist/ensure-frames-in-order.d.ts

@@ -1,4 +1,4 @@
-export declare const ensureFramesInOrder: (frameRange: [number, number]) => {
+export declare const ensureFramesInOrder: (framesToRender: number[]) => {
     waitForRightTimeOfFrameToBeInserted: (frameToBe: number) => Promise<void>;
     setFrameToStitch: (f: number) => void;
     waitForFinish: () => Promise<void>;

package/dist/ensure-frames-in-order.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureFramesInOrder = void 0;
-const ensureFramesInOrder = (frameRange) => {
-    let [frameToStitch, finalFrame] = frameRange;
+const ensureFramesInOrder = (framesToRender) => {
+    let [frameToStitch] = framesToRender;
+    const finalFrame = framesToRender[framesToRender.length - 1];
     let waiters = [];
     const resolveWaiters = () => {
         for (const waiter of waiters.slice(0)) {

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

@@ -0,0 +1,2 @@
+import type { DownloadMap } from './assets/download-map';
+export declare const ensurePresentationTimestamps: (downloadMap: DownloadMap, src: string) => Promise<string>;

package/dist/ensure-presentation-timestamp.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePresentationTimestamps = void 0;
+const execa_1 = __importDefault(require("execa"));
+const path_1 = __importDefault(require("path"));
+const guess_extension_for_media_1 = require("./guess-extension-for-media");
+const truthy_1 = require("./truthy");
+let callbacks = [];
+const getTemporaryOutputName = async (src) => {
+    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);
+    return parts
+        .map((p, i) => {
+        if (i === parts.length - 1) {
+            return [`pts-${p}`, extraExtension].filter(truthy_1.truthy).join('.');
+        }
+        return p;
+    })
+        .join(path_1.default.sep);
+};
+const ensurePresentationTimestamps = async (downloadMap, src) => {
+    const elem = downloadMap.ensureFileHasPresentationTimestamp[src];
+    if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'encoding') {
+        return new Promise((resolve) => {
+            callbacks.push({
+                src,
+                fn: (newSrc) => resolve(newSrc),
+            });
+        });
+    }
+    if ((elem === null || elem === void 0 ? void 0 : elem.type) === 'done') {
+        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',
+        src,
+        '-fflags',
+        '+genpts+igndts',
+        '-vcodec',
+        'copy',
+        '-acodec',
+        'copy',
+        output,
+        '-y',
+    ]);
+    callbacks = callbacks.filter((c) => {
+        if (c.src === src) {
+            c.fn(output);
+            return false;
+        }
+        return true;
+    });
+    downloadMap.ensureFileHasPresentationTimestamp[src] = {
+        type: 'done',
+        src: output,
+    };
+    return output;
+};
+exports.ensurePresentationTimestamps = ensurePresentationTimestamps;

package/dist/error-handling/handle-javascript-exception.d.ts

@@ -1,5 +1,5 @@
-import { Page } from 'puppeteer-core';
-import { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
+import type { Page } from '../browser/BrowserPage';
+import type { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
 export declare class ErrorWithStackFrame extends Error {
     symbolicatedStackFrames: SymbolicatedStackFrame[] | null;
     frame: number | null;

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

@@ -41,8 +41,8 @@ const callFrameToStackFrame = (callFrame) => {
     };
 };
 const handleJavascriptException = ({ page, onError, frame, }) => {
-    const client = page._client;
-    const handler = async (exception) => {
+    const client = page._client();
+    const handler = (exception) => {
         var _a, _b, _c;
         const rawErrorMessage = (_a = exception.exceptionDetails.exception) === null || _a === void 0 ? void 0 : _a.description;
         const cleanErrorMessage = cleanUpErrorMessage(exception);
@@ -55,8 +55,7 @@ const handleJavascriptException = ({ page, onError, frame, }) => {
         const errorType = (_b = exception.exceptionDetails.exception) === null || _b === void 0 ? void 0 : _b.className;
         const symbolicatedErr = new symbolicateable_error_1.SymbolicateableError({
             message: removeDelayRenderStack(cleanErrorMessage),
-            stackFrame: exception.exceptionDetails.stackTrace
-                .callFrames.map((f) => callFrameToStackFrame(f)),
+            stackFrame: exception.exceptionDetails.stackTrace.callFrames.map((f) => callFrameToStackFrame(f)),
             frame,
             name: errorType,
             stack: (_c = exception.exceptionDetails.exception) === null || _c === void 0 ? void 0 : _c.description,

package/dist/error-handling/symbolicate-error.d.ts

@@ -1,3 +1,3 @@
 import { ErrorWithStackFrame } from './handle-javascript-exception';
-import { SymbolicateableError } from './symbolicateable-error';
+import type { SymbolicateableError } from './symbolicateable-error';
 export declare const symbolicateError: (symbolicateableError: SymbolicateableError) => Promise<ErrorWithStackFrame>;

package/dist/error-handling/symbolicateable-error.d.ts

@@ -1,7 +1,7 @@
 /**
  * A symbolicateable error is an error that can be symolicated by fetching the original sources. By throwing a symbolicateable error, Remotion CLI will attempt to symplicate it
  */
-import { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
+import type { UnsymbolicatedStackFrame } from '../parse-browser-error-stack';
 export declare class SymbolicateableError extends Error {
     stackFrame: UnsymbolicatedStackFrame[] | null;
     delayRenderCall: UnsymbolicatedStackFrame[] | null;

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

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+import type { LastFrameOptions } from './last-frame-from-video-cache';
+export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;
+declare type Options = {
+    time: number;
+    src: string;
+    ffmpegExecutable: FfmpegExecutable;
+    ffprobeExecutable: FfmpegExecutable;
+    imageFormat: OffthreadVideoImageFormat;
+    downloadMap: DownloadMap;
+};
+export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
+export {};