@remotion/renderer 4.0.0-lambda.1 → 4.0.0-newpathfunctions.13

package/dist/ensure-presentation-timestamp.js

@@ -3,35 +3,41 @@ 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 promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
-const ensureFileHasPresentationTimestamp = {};
+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 ensurePresentationTimestamps = async (src) => {
-    if (ensureFileHasPresentationTimestamp[src] === 'encoding') {
-        return new Promise((resolve) => {
-            callbacks.push({
-                src,
-                fn: () => resolve,
-            });
-        });
-    }
-    if (ensureFileHasPresentationTimestamp[src] === 'done') {
-        return;
-    }
-    ensureFileHasPresentationTimestamp[src] = 'encoding';
+const getTemporaryOutputName = async ({ src, remotionRoot, ffprobeBinary, }) => {
     const parts = src.split(path_1.default.sep);
-    const output = parts
+    // 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,
+            remotionRoot,
+            ffprobeBinary,
+        });
+    return parts
         .map((p, i) => {
         if (i === parts.length - 1) {
-            return `pts-${p}`;
+            return [`pts-${p}`, extraExtension].filter(truthy_1.truthy).join('.');
         }
         return p;
     })
         .join(path_1.default.sep);
-    await (0, execa_1.default)('ffmpeg', [
+};
+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',
@@ -43,15 +49,40 @@ const ensurePresentationTimestamps = async (src) => {
         output,
         '-y',
     ]);
-    await (0, promises_1.unlink)(src);
-    await (0, promises_1.rename)(output, src);
+    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) => {
+            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' };
+    const output = await (0, exports.ensurePresentationTimestampWithoutCache)({
+        ffmpegExecutable,
+        ffprobeExecutable,
+        remotionRoot,
+        src,
+    });
     callbacks = callbacks.filter((c) => {
         if (c.src === src) {
-            c.fn();
+            c.fn(output);
             return false;
         }
         return true;
     });
-    ensureFileHasPresentationTimestamp[src] = 'done';
+    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

@@ -1,11 +1,16 @@
-import { FfmpegExecutable } from 'remotion';
-import { LastFrameOptions } from './last-frame-from-video-cache';
+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;
+    remotionRoot: string;
 };
 export declare const extractFrameFromVideo: (options: Options) => Promise<Buffer>;
 export {};

package/dist/extract-frame-from-video.js

@@ -5,119 +5,71 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
 const execa_1 = __importDefault(require("execa"));
-const remotion_1 = require("remotion");
-const get_audio_channels_1 = require("./assets/get-audio-channels");
+const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
+const determine_resize_params_1 = require("./determine-resize-params");
+const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
 const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
 const frame_to_ffmpeg_timestamp_1 = require("./frame-to-ffmpeg-timestamp");
+const get_can_extract_frames_fast_1 = require("./get-can-extract-frames-fast");
+const get_frame_of_video_slow_1 = require("./get-frame-of-video-slow");
+const get_video_info_1 = require("./get-video-info");
 const is_beyond_last_frame_1 = require("./is-beyond-last-frame");
 const last_frame_from_video_cache_1 = require("./last-frame-from-video-cache");
 const p_limit_1 = require("./p-limit");
+const perf_1 = require("./perf");
+const truthy_1 = require("./truthy");
+const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
 const lastFrameLimit = (0, p_limit_1.pLimit)(1);
 const mainLimit = (0, p_limit_1.pLimit)(5);
-// Uses no seeking, therefore the whole video has to be decoded. This is a last resort and should only happen
-// if the video is corrupted
-const getLastFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, }) => {
-    console.warn(`\nUsing a slow method to determine the last frame of ${src}. The render can be sped up by re-encoding the video properly.`);
-    const actualOffset = `-${duration * 1000}ms`;
-    const command = [
-        '-itsoffset',
-        actualOffset,
-        '-i',
-        src,
-        '-frames:v',
-        '1',
-        '-f',
-        'image2pipe',
-        '-',
-    ];
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', command);
-    if (!stderr) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stderrChunks = [];
-    const stdoutChunks = [];
-    const stdErrString = new Promise((resolve, reject) => {
-        stderr.on('data', (d) => stderrChunks.push(d));
-        stderr.on('error', (err) => reject(err));
-        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
-    });
-    const stdoutChunk = new Promise((resolve, reject) => {
-        stdout.on('data', (d) => stdoutChunks.push(d));
-        stdout.on('error', (err) => reject(err));
-        stdout.on('end', () => resolve(Buffer.concat(stdoutChunks)));
-    });
-    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
-    const isEmpty = stdErr.includes('Output file is empty');
-    if (isEmpty) {
-        throw new Error(`Could not get last frame of ${src}. Tried to seek to the end using the command "ffmpeg ${command.join(' ')}" but got no frame. Most likely this video is corrupted.`);
-    }
-    return stdoutBuffer;
-};
 const getLastFrameOfVideoFastUnlimited = async (options) => {
-    const { ffmpegExecutable, ffprobeExecutable, offset, src } = options;
+    const { ffmpegExecutable, ffprobeExecutable, offset, src, downloadMap } = options;
     const fromCache = (0, last_frame_from_video_cache_1.getLastFrameFromCache)({ ...options, offset: 0 });
     if (fromCache) {
         return fromCache;
     }
-    const { duration } = await (0, get_audio_channels_1.getAudioChannelsAndDuration)(src, ffprobeExecutable);
+    const { duration, fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable, options.remotionRoot);
     if (duration === null) {
         throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
     }
-    if (offset > 40) {
-        const last = await getLastFrameOfVideoSlow({
+    if (options.specialVCodecForTransparency === 'vp8' ||
+        offset > get_can_extract_frames_fast_1.ACCEPTABLE_OFFSET_THRESHOLD) {
+        const last = await (0, get_frame_of_video_slow_1.getFrameOfVideoSlow)({
             duration,
             ffmpegExecutable,
             src,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
+            offset: offset - 1000 / (fps === null ? 10 : fps),
+            fps,
+            remotionRoot: options.remotionRoot,
         });
         return last;
     }
-    const actualOffset = `${duration * 1000 - offset - 10}ms`;
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
-        '-ss',
+    const actualOffset = `${duration * 1000 - offset}ms`;
+    const [stdErr, stdoutBuffer] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
         actualOffset,
-        '-i',
+        ffmpegExecutable,
+        imageFormat: options.imageFormat,
+        needsResize: options.needsResize,
+        remotionRoot: options.remotionRoot,
+        specialVCodecForTransparency: options.specialVCodecForTransparency,
         src,
-        '-frames:v',
-        '1',
-        '-f',
-        'image2pipe',
-        '-',
-    ]);
-    if (!stderr) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stderrChunks = [];
-    const stdoutChunks = [];
-    const stdErrString = new Promise((resolve, reject) => {
-        stderr.on('data', (d) => stderrChunks.push(d));
-        stderr.on('error', (err) => reject(err));
-        stderr.on('end', () => resolve(Buffer.concat(stderrChunks).toString('utf-8')));
-    });
-    const stdoutChunk = new Promise((resolve, reject) => {
-        stdout.on('data', (d) => {
-            stdoutChunks.push(d);
-        });
-        stdout.on('error', (err) => {
-            reject(err);
-        });
-        stdout.on('end', () => {
-            resolve(Buffer.concat(stdoutChunks));
-        });
     });
-    const [stdErr, stdoutBuffer] = await Promise.all([stdErrString, stdoutChunk]);
     const isEmpty = stdErr.includes('Output file is empty');
     if (isEmpty) {
         const unlimited = await getLastFrameOfVideoFastUnlimited({
             ffmpegExecutable,
-            offset: offset + 10,
+            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
+            offset: offset + (fps === null ? 10 : 1000 / fps),
             src,
             ffprobeExecutable,
+            imageFormat: options.imageFormat,
+            specialVCodecForTransparency: options.specialVCodecForTransparency,
+            needsResize: options.needsResize,
+            downloadMap: options.downloadMap,
+            remotionRoot: options.remotionRoot,
         });
         return unlimited;
     }
@@ -129,29 +81,61 @@ const getLastFrameOfVideo = async (options) => {
     return result;
 };
 exports.getLastFrameOfVideo = getLastFrameOfVideo;
-const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExecutable, }) => {
-    await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)(src);
-    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(src, time)) {
+const extractFrameFromVideoFn = async ({ time, ffmpegExecutable, ffprobeExecutable, imageFormat, downloadMap, remotionRoot, ...options }) => {
+    // We make a new copy of the video only for video because the conversion may affect
+    // audio rendering, so we work with 2 different files
+    const src = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestamps)({
+        downloadMap,
+        src: options.src,
+        remotionRoot,
+        ffmpegExecutable,
+        ffprobeExecutable,
+    });
+    const { specialVcodecForTransparency: specialVcodec, needsResize } = await (0, get_video_info_1.getVideoInfo)(downloadMap, src, ffprobeExecutable, remotionRoot);
+    if (specialVcodec === 'vp8') {
+        const { fps } = await (0, get_video_stream_duration_1.getVideoStreamDuration)(downloadMap, src, ffprobeExecutable, remotionRoot);
+        return (0, get_frame_of_video_slow_1.getFrameOfVideoSlow)({
+            ffmpegExecutable,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            src,
+            duration: time,
+            needsResize,
+            offset: 0,
+            fps,
+            remotionRoot,
+        });
+    }
+    if ((0, is_beyond_last_frame_1.isBeyondLastFrame)(downloadMap, src, time)) {
         const lastFrame = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
             offset: 0,
             src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
+            downloadMap,
+            remotionRoot,
         });
         return lastFrame;
     }
     const ffmpegTimestamp = (0, frame_to_ffmpeg_timestamp_1.frameToFfmpegTimestamp)(time);
-    const { stdout, stderr } = (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
         '-ss',
         ffmpegTimestamp,
+        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVcodec),
         '-i',
         src,
         '-frames:v',
         '1',
         '-f',
         'image2pipe',
+        '-vcodec',
+        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
+        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
         '-',
-    ], {
+    ].filter(truthy_1.truthy), {
         buffer: false,
     });
     if (!stderr) {
@@ -177,21 +161,31 @@ const extractFrameFromVideoFn = async ({ time, src, ffmpegExecutable, ffprobeExe
         stdoutBuffer,
     ]);
     if (stderrStr.includes('Output file is empty')) {
-        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(src, time);
+        (0, is_beyond_last_frame_1.markAsBeyondLastFrame)(downloadMap, src, time);
         const last = await (0, exports.getLastFrameOfVideo)({
             ffmpegExecutable,
             ffprobeExecutable,
             offset: 0,
             src,
+            imageFormat,
+            specialVCodecForTransparency: specialVcodec,
+            needsResize,
+            downloadMap,
+            remotionRoot,
         });
         return last;
     }
+    if (stdOut.length === 0) {
+        console.log('FFMPEG Logs:');
+        console.log(stderrStr);
+        throw new Error("Couldn't extract frame from video - FFMPEG did not return any data. Check logs to see more information");
+    }
     return stdOut;
 };
 const extractFrameFromVideo = async (options) => {
-    const perf = remotion_1.Internals.perf.startPerfMeasure('extract-frame');
+    const perf = (0, perf_1.startPerfMeasure)('extract-frame');
     const res = await mainLimit(extractFrameFromVideoFn, options);
-    remotion_1.Internals.perf.stopPerfMeasure(perf);
+    (0, perf_1.stopPerfMeasure)(perf);
     return res;
 };
 exports.extractFrameFromVideo = extractFrameFromVideo;

package/dist/ffmpeg-executable.d.ts

@@ -0,0 +1 @@
+export declare type FfmpegExecutable = string | null;

package/dist/ffmpeg-executable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ffmpeg-filter-file.d.ts

@@ -1,4 +1,5 @@
-export declare const makeFfmpegFilterFile: (complexFilter: string) => Promise<{
+import type { DownloadMap } from './assets/download-map';
+export declare const makeFfmpegFilterFile: (complexFilter: string, downloadMap: DownloadMap) => Promise<{
     file: string;
     cleanup: () => void;
 }>;

package/dist/ffmpeg-filter-file.js

@@ -8,16 +8,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeFfmpegFilterFile = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const delete_directory_1 = require("./delete-directory");
-const tmp_dir_1 = require("./tmp-dir");
-const makeFfmpegFilterFile = async (complexFilter) => {
-    const tempPath = (0, tmp_dir_1.tmpDir)('remotion-complex-filter');
-    const filterFile = path_1.default.join(tempPath, 'complex-filter.txt');
+const makeFfmpegFilterFile = async (complexFilter, downloadMap) => {
+    const random = Math.random().toString().replace('.', '');
+    const filterFile = path_1.default.join(downloadMap.complexFilter, 'complex-filter-' + random + '.txt');
     await fs_1.default.promises.writeFile(filterFile, complexFilter);
     return {
         file: filterFile,
         cleanup: () => {
-            (0, delete_directory_1.deleteDirectory)(filterFile);
+            fs_1.default.unlinkSync(filterFile);
         },
     };
 };

package/dist/ffmpeg-flags.d.ts

@@ -1,13 +1,31 @@
+import type { FfmpegExecutable } from './ffmpeg-executable';
 export declare type FfmpegVersion = [number, number, number] | null;
 export declare const getFfmpegBuildInfo: (options: {
     ffmpegExecutable: string | null;
+    remotionRoot: string;
 }) => Promise<string>;
-export declare const ffmpegHasFeature: ({ ffmpegExecutable, feature, isLambda, }: {
+export declare const ffmpegInNodeModules: (remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => string | null;
+export declare const ffmpegHasFeature: ({ ffmpegExecutable, feature, remotionRoot, }: {
     ffmpegExecutable: string | null;
     feature: 'enable-gpl' | 'enable-libx265' | 'enable-libvpx';
-    isLambda: boolean;
+    remotionRoot: string;
 }) => Promise<boolean>;
 export declare const parseFfmpegVersion: (buildconf: string) => FfmpegVersion;
 export declare const getFfmpegVersion: (options: {
     ffmpegExecutable: string | null;
+    remotionRoot: string;
 }) => Promise<FfmpegVersion>;
+export declare const downloadBinary: (remotionRoot: string, url: string, binary: 'ffmpeg' | 'ffprobe') => Promise<string>;
+export declare const lambdaFfmpegPaths: {
+    readonly ffmpeg: "/opt/bin/ffmpeg";
+    readonly ffprobe: "/opt/bin/ffprobe";
+};
+export declare const getExecutableBinary: (ffmpegExecutable: FfmpegExecutable, remotionRoot: string, binary: 'ffmpeg' | 'ffprobe') => string | Promise<string>;
+export declare const getBinaryDownloadUrl: (binary: 'ffmpeg' | 'ffprobe') => {
+    url: string;
+    contentLength: number;
+} | null;
+export declare const warnAboutFfmpegVersion: ({ ffmpegVersion, buildConf, }: {
+    ffmpegVersion: FfmpegVersion;
+    buildConf: string | null;
+}) => null | undefined;