@remotion/renderer 4.0.0-alpha13 → 4.0.0-alpha14

package/dist/browser/should-log-message.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChromeLogLocation = exports.formatChromeMessage = exports.parseBrowserLogMessage = exports.shouldLogBrowserMessage = void 0;
+const shouldLogBrowserMessage = (message) => {
+    // Not relevant for the user
+    if (message.startsWith('DevTools listening on')) {
+        return false;
+    }
+    // Noisy but harmless warning
+    if (message.includes('Failed to send GpuControl.CreateCommandBuffer')) {
+        return false;
+    }
+    return true;
+};
+exports.shouldLogBrowserMessage = shouldLogBrowserMessage;
+const parseBrowserLogMessage = (input) => {
+    const format = /^\[([0-9]{4})\/([0-9]{6})\.([0-9]{6}):([A-Z]+):(.*)\(([0-9]+)\)\](.*)/;
+    const match = input.match(format);
+    if (!match) {
+        return null;
+    }
+    const date = match[1];
+    const day = parseInt(date.slice(0, 2), 10);
+    const month = parseInt(date.slice(2, 4), 10);
+    const time = match[2];
+    const hour = parseInt(time.slice(0, 2), 10);
+    const minute = parseInt(time.slice(2, 4), 10);
+    const seconds = parseInt(time.slice(4, 6), 10);
+    const microseconds = parseInt(match[3], 10);
+    const level = match[4];
+    const location = match[5];
+    const lineNumber = parseInt(match[6], 10);
+    const message = match[7].trim();
+    return {
+        day,
+        month,
+        hour,
+        minute,
+        seconds,
+        microseconds,
+        level,
+        location,
+        lineNumber,
+        message,
+    };
+};
+exports.parseBrowserLogMessage = parseBrowserLogMessage;
+const formatChromeMessage = (input) => {
+    const parsed = (0, exports.parseBrowserLogMessage)(input);
+    if (!parsed) {
+        return { output: input, tag: 'chrome' };
+    }
+    const { location, lineNumber, message } = parsed;
+    // Don't print console.log's, these are handled through the WebSocket
+    if (location === 'CONSOLE') {
+        return null;
+    }
+    return { output: `${location}:${lineNumber}: ${message}`, tag: 'chrome' };
+};
+exports.formatChromeMessage = formatChromeMessage;
+const parseChromeLogLocation = (message) => {
+    const regex = /(.*), source: (.*) \(([0-9]+)\)/;
+    const match = message.match(regex);
+    if (!match) {
+        return null;
+    }
+    return {
+        lineNumber: parseInt(match[3], 10),
+        location: match[2],
+    };
+};
+exports.parseChromeLogLocation = parseChromeLogLocation;

package/dist/browser-executable.d.ts

@@ -1 +1 @@
-export declare type BrowserExecutable = string | null;
+export type BrowserExecutable = string | null;

package/dist/browser-log.d.ts

@@ -1,5 +1,5 @@
 import type { ConsoleMessageLocation, ConsoleMessageType } from './browser/ConsoleMessage';
-export declare type BrowserLog = {
+export type BrowserLog = {
     text: string;
     stackTrace: ConsoleMessageLocation[];
     type: ConsoleMessageType;

package/dist/browser.d.ts

@@ -1,2 +1,2 @@
-export declare type Browser = 'chrome' | 'firefox';
+export type Browser = 'chrome' | 'firefox';
 export declare const DEFAULT_BROWSER: Browser;

package/dist/calculate-sar-dar-pixels.d.ts

@@ -0,0 +1,9 @@
+export declare const calculateDisplayVideoSize: ({ darX, darY, x, y, }: {
+    x: number;
+    y: number;
+    darX: number;
+    darY: number;
+}) => {
+    width: number;
+    height: number;
+};

package/dist/calculate-sar-dar-pixels.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://superuser.com/questions/907933/correct-aspect-ratio-without-re-encoding-video-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDisplayVideoSize = void 0;
+const calculateDisplayVideoSize = ({ darX, darY, x, y, }) => {
+    // We know two equations:
+    //   newWidth / newHeight = darX / darY
+    // and:
+    //   x * y = (newWidth * newHeight)
+    // I solved it then on pen and paper and simplified the formula:
+    const dimensions = x * y;
+    const newWidth = Math.sqrt(dimensions * (darX / darY));
+    const newHeight = dimensions / newWidth;
+    return {
+        height: Math.round(newHeight),
+        width: Math.round(newWidth),
+    };
+};
+exports.calculateDisplayVideoSize = calculateDisplayVideoSize;

package/dist/chalk/index.d.ts

@@ -1,17 +1,17 @@
-declare type Style = {
+type Style = {
     codes: [number, number];
     name: string;
     wrap?: (input: string, newline: boolean) => string;
 };
-declare type Method = (str: string) => string;
-declare type Colors = {
+type Method = (str: string) => string;
+type Colors = {
     enabled: boolean;
     visible: boolean;
     styles: Record<string, Style>;
     keys: Record<string, string[]>;
     alias?: (name: string, col: string) => void;
 };
-declare type ColorsWithMethods = Colors & {
+type ColorsWithMethods = Colors & {
     reset: Method;
     bold: Method;
     dim: Method;

package/dist/codec-supports-media.d.ts

@@ -1,5 +1,5 @@
 import type { Codec } from './codec';
-declare type MediaSupport = {
+type MediaSupport = {
     video: boolean;
     audio: boolean;
 };

package/dist/codec.d.ts

@@ -1,4 +1,4 @@
 export declare const validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"];
-export declare type Codec = typeof validCodecs[number];
-export declare type CodecOrUndefined = Codec | undefined;
+export type Codec = typeof validCodecs[number];
+export type CodecOrUndefined = Codec | undefined;
 export declare const DEFAULT_CODEC: Codec;

package/dist/combine-videos.d.ts

@@ -1,6 +1,6 @@
 import type { AudioCodec } from './audio-codec';
 import type { Codec } from './codec';
-declare type Options = {
+type Options = {
     files: string[];
     filelistDir: string;
     output: string;

package/dist/compositor/compose.d.ts

@@ -1,17 +1,26 @@
 import type { DownloadMap } from '../assets/download-map';
 import type { Compositor } from './compositor';
 import type { CompositorCommand, CompositorCommandSerialized, CompositorImageFormat, Layer } from './payloads';
-declare type CompositorInput = {
+type CompositorInput = {
     height: number;
     width: number;
     layers: Layer[];
     imageFormat: CompositorImageFormat;
 };
+type ComposeInput = CompositorInput & {
+    output: string;
+    compositor: Compositor;
+};
 export declare const serializeCommand: <Type extends keyof CompositorCommand>(command: Type, params: CompositorCommand[Type]) => CompositorCommandSerialized<Type>;
+export declare const composeWithoutCache: ({ height, width, layers, output, imageFormat, compositor, }: CompositorInput & {
+    output: string;
+    compositor: Compositor;
+}) => Promise<void>;
 export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, compositor, }: CompositorInput & {
-    downloadMap: DownloadMap;
     output: string;
     compositor: Compositor;
+} & {
+    downloadMap: DownloadMap;
 }) => Promise<void>;
 export declare const callCompositor: (payload: string) => Promise<void>;
 export {};

package/dist/compositor/compose.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callCompositor = exports.compose = exports.serializeCommand = void 0;
+exports.callCompositor = exports.compose = exports.composeWithoutCache = exports.serializeCommand = void 0;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -21,18 +21,29 @@ const serializeCommand = (command, params) => {
     };
 };
 exports.serializeCommand = serializeCommand;
+const composeWithoutCache = async ({ height, width, layers, output, imageFormat, compositor, }) => {
+    await compositor.executeCommand('Compose', {
+        height,
+        width,
+        layers,
+        output,
+        output_format: imageFormat,
+    });
+};
+exports.composeWithoutCache = composeWithoutCache;
 const compose = async ({ height, width, layers, output, downloadMap, imageFormat, compositor, }) => {
     const hash = getCompositorHash({ height, width, layers, imageFormat });
     if (downloadMap.compositorCache[hash]) {
         await (0, promises_1.copyFile)(downloadMap.compositorCache[hash], output);
         return;
     }
-    await compositor.executeCommand('Compose', {
+    await (0, exports.composeWithoutCache)({
+        compositor,
         height,
-        width,
+        imageFormat,
         layers,
         output,
-        output_format: imageFormat,
+        width,
     });
     downloadMap.compositorCache[hash] = output;
 };

package/dist/compositor/compositor.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { CompositorCommand } from './payloads';
-export declare type Compositor = {
+export type Compositor = {
     finishCommands: () => void;
     executeCommand: <T extends keyof CompositorCommand>(type: T, payload: CompositorCommand[T]) => Promise<Buffer>;
     waitForDone: () => Promise<void>;

package/dist/compositor/compositor.js

@@ -45,7 +45,7 @@ const startCompositor = (type, payload, indent) => {
     const waiters = new Map();
     const onMessage = (statusType, nonce, data) => {
         if (nonce === '0') {
-            logger_1.Log.verboseAdvanced({ indent, logLevel: (0, logger_1.getLogLevel)(), tag: 'COMPOSITOR' }, data.toString('utf8'));
+            logger_1.Log.verboseAdvanced({ indent, logLevel: (0, logger_1.getLogLevel)(), tag: 'compositor' }, data.toString('utf8'));
         }
         if (waiters.has(nonce)) {
             if (statusType === 'error') {

package/dist/compositor/payloads.d.ts

@@ -1,4 +1,4 @@
-export declare type Layer = {
+export type Layer = {
     type: 'PngImage';
     params: {
         src: string;
@@ -26,8 +26,8 @@ export declare type Layer = {
         height: number;
     };
 };
-export declare type CompositorImageFormat = 'Png' | 'Jpeg';
-export declare type CompositorCommand = {
+export type CompositorImageFormat = 'Png' | 'Jpeg';
+export type CompositorCommand = {
     Compose: {
         output: string;
         width: number;
@@ -55,14 +55,14 @@ export declare type CompositorCommand = {
         percent_of_memory: number;
     };
 };
-export declare type CompositorCommandSerialized<T extends keyof CompositorCommand> = {
+export type CompositorCommandSerialized<T extends keyof CompositorCommand> = {
     nonce: string;
     payload: {
         type: T;
         params: CompositorCommand[T];
     };
 };
-export declare type ErrorPayload = {
+export type ErrorPayload = {
     error: string;
     backtrace: string;
 };

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

@@ -4,6 +4,9 @@ export declare const createFfmpegComplexFilter: ({ filters, downloadMap, }: {
     filters: PreprocessedAudioTrack[];
     downloadMap: DownloadMap;
 }) => Promise<{
-    complexFilterFlag: [string, string] | null;
+    complexFilterFlag: [
+        string,
+        string
+    ] | null;
     cleanup: () => void;
 }>;

package/dist/crf.d.ts

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

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/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-presentation-timestamp.d.ts

@@ -0,0 +1,15 @@
+import type { DownloadMap } from './assets/download-map';
+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

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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, 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,
+            remotionRoot,
+            ffprobeBinary,
+        });
+    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 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) => {
+            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(output);
+            return false;
+        }
+        return true;
+    });
+    downloadMap.ensureFileHasPresentationTimestamp[src] = {
+        type: 'done',
+        src: output,
+    };
+    return output;
+};
+exports.ensurePresentationTimestamps = ensurePresentationTimestamps;

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

@@ -7,8 +7,10 @@ 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,
+        stackFrame ? (0, symbolicate_stacktrace_1.symbolicateStackTraceFromRemoteFrames)(stackFrame) : null,
+        delayRenderCall
+            ? (0, symbolicate_stacktrace_1.symbolicateStackTraceFromRemoteFrames)(delayRenderCall)
+            : null,
     ].filter(truthy_1.truthy));
     const symbolicatedErr = new handle_javascript_exception_1.ErrorWithStackFrame({
         message: symbolicateableError.message,

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

@@ -0,0 +1,16 @@
+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 {};