@remotion/renderer 4.0.255 → 4.0.256

package/dist/render-frame-with-option-to-reject.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFrameWithOptionToReject = void 0;
+const path_1 = __importDefault(require("path"));
+const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const compress_assets_1 = require("./compress-assets");
+const handle_javascript_exception_1 = require("./error-handling/handle-javascript-exception");
+const filter_asset_types_1 = require("./filter-asset-types");
+const get_frame_padded_index_1 = require("./get-frame-padded-index");
+const logger_1 = require("./logger");
+const perf_1 = require("./perf");
+const seek_to_frame_1 = require("./seek-to-frame");
+const take_frame_1 = require("./take-frame");
+const truthy_1 = require("./truthy");
+const renderFrameWithOptionToReject = async ({ reject, width, height, compId, attempt, stoppedSignal, indent, logLevel, timeoutInMilliseconds, outputDir, onFrameBuffer, imageFormat, onError, lastFrame, jpegQuality, frameDir, scale, countType, assets, framesToRender, onArtifact, onDownload, downloadMap, binariesDirectory, cancelSignal, framesRenderedObj, onFrameUpdate, frame, page, }) => {
+    const startTime = performance.now();
+    const index = framesToRender.indexOf(frame);
+    const assetsOnly = index === -1;
+    if (stoppedSignal.stopped) {
+        return Promise.reject(new Error('Render was stopped'));
+    }
+    const errorCallbackOnFrame = (err) => {
+        reject(err);
+    };
+    const cleanupPageError = (0, handle_javascript_exception_1.handleJavascriptException)({
+        page,
+        onError: errorCallbackOnFrame,
+        frame,
+    });
+    page.on('error', errorCallbackOnFrame);
+    const startSeeking = Date.now();
+    await (0, seek_to_frame_1.seekToFrame)({
+        frame,
+        page,
+        composition: compId,
+        timeoutInMilliseconds,
+        indent,
+        logLevel,
+        attempt,
+    });
+    const timeToSeek = Date.now() - startSeeking;
+    if (timeToSeek > 1000) {
+        logger_1.Log.verbose({ indent, logLevel }, `Seeking to frame ${frame} took ${timeToSeek}ms`);
+    }
+    if (!outputDir && !onFrameBuffer && imageFormat !== 'none') {
+        throw new Error('Called renderFrames() without specifying either `outputDir` or `onFrameBuffer`');
+    }
+    if (outputDir && onFrameBuffer && imageFormat !== 'none') {
+        throw new Error('Pass either `outputDir` or `onFrameBuffer` to renderFrames(), not both.');
+    }
+    const id = (0, perf_1.startPerfMeasure)('save');
+    const { buffer, collectedAssets } = await (0, take_frame_1.takeFrame)({
+        frame,
+        freePage: page,
+        height,
+        imageFormat: assetsOnly ? 'none' : imageFormat,
+        output: index === null
+            ? null
+            : path_1.default.join(frameDir, (0, get_frame_padded_index_1.getFrameOutputFileName)({
+                frame,
+                imageFormat,
+                index,
+                countType,
+                lastFrame,
+                totalFrames: framesToRender.length,
+            })),
+        jpegQuality,
+        width,
+        scale,
+        wantsBuffer: Boolean(onFrameBuffer),
+        timeoutInMilliseconds,
+    });
+    if (onFrameBuffer && !assetsOnly) {
+        if (!buffer) {
+            throw new Error('unexpected null buffer');
+        }
+        onFrameBuffer(buffer, frame);
+    }
+    (0, perf_1.stopPerfMeasure)(id);
+    const onlyAvailableAssets = assets.filter(truthy_1.truthy);
+    const previousAudioRenderAssets = onlyAvailableAssets
+        .map((a) => a.audioAndVideoAssets)
+        .flat(2);
+    const previousArtifactAssets = onlyAvailableAssets
+        .map((a) => a.artifactAssets)
+        .flat(2);
+    const audioAndVideoAssets = (0, filter_asset_types_1.onlyAudioAndVideoAssets)(collectedAssets);
+    const artifactAssets = (0, filter_asset_types_1.onlyArtifact)(collectedAssets);
+    for (const artifact of artifactAssets) {
+        for (const previousArtifact of previousArtifactAssets) {
+            if (artifact.filename === previousArtifact.filename) {
+                return Promise.reject(new Error(`An artifact with output "${artifact.filename}" was already registered at frame ${previousArtifact.frame}, but now registered again at frame ${artifact.frame}. Artifacts must have unique names. https://remotion.dev/docs/artifacts`));
+            }
+        }
+        onArtifact === null || onArtifact === void 0 ? void 0 : onArtifact(artifact);
+    }
+    const compressedAssets = audioAndVideoAssets.map((asset) => {
+        return (0, compress_assets_1.compressAsset)(previousAudioRenderAssets, asset);
+    });
+    assets.push({
+        audioAndVideoAssets: compressedAssets,
+        frame,
+        artifactAssets: artifactAssets.map((a) => {
+            return {
+                frame: a.frame,
+                filename: a.filename,
+            };
+        }),
+    });
+    for (const renderAsset of compressedAssets) {
+        (0, download_and_map_assets_to_file_1.downloadAndMapAssetsToFileUrl)({
+            renderAsset,
+            onDownload,
+            downloadMap,
+            indent,
+            logLevel,
+            binariesDirectory,
+            cancelSignalForAudioAnalysis: cancelSignal,
+            shouldAnalyzeAudioImmediately: true,
+        }).catch((err) => {
+            const truncateWithEllipsis = renderAsset.src.substring(0, 1000) +
+                (renderAsset.src.length > 1000 ? '...' : '');
+            onError(new Error(`Error while downloading ${truncateWithEllipsis}: ${err.stack}`));
+        });
+    }
+    cleanupPageError();
+    page.off('error', errorCallbackOnFrame);
+    if (!assetsOnly) {
+        framesRenderedObj.count++;
+        onFrameUpdate === null || onFrameUpdate === void 0 ? void 0 : onFrameUpdate(framesRenderedObj.count, frame, performance.now() - startTime);
+    }
+};
+exports.renderFrameWithOptionToReject = renderFrameWithOptionToReject;

package/dist/render-frame.d.ts

@@ -0,0 +1,43 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { RenderMediaOnDownload } from './assets/download-and-map-assets-to-file';
+import type { DownloadMap } from './assets/download-map';
+import type { Page } from './browser/BrowserPage';
+import type { CountType } from './get-frame-padded-index';
+import type { VideoImageFormat } from './image-format';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { NextFrameToRender } from './next-frame-to-render';
+import type { FrameAndAssets, OnArtifact } from './render-frames';
+export declare const renderFrame: ({ attempt, binariesDirectory, cancelSignal, imageFormat, indent, logLevel, assets, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, scale, composition, onError, outputDir, stoppedSignal, timeoutInMilliseconds, lastFrame, onFrameBuffer, onFrameUpdate, framesRenderedObj, frame, page, }: {
+    attempt: number;
+    indent: boolean;
+    logLevel: LogLevel;
+    imageFormat: VideoImageFormat;
+    cancelSignal: CancelSignal | undefined;
+    binariesDirectory: string | null;
+    jpegQuality: number;
+    frameDir: string;
+    scale: number;
+    countType: CountType;
+    assets: FrameAndAssets[];
+    framesToRender: number[];
+    onArtifact: OnArtifact | null;
+    onDownload: RenderMediaOnDownload | null;
+    downloadMap: DownloadMap;
+    composition: Omit<VideoConfig, "defaultProps" | "props">;
+    onError: (err: Error) => void;
+    stoppedSignal: {
+        stopped: boolean;
+    };
+    timeoutInMilliseconds: number;
+    outputDir: string | null;
+    onFrameBuffer: null | ((buffer: Buffer, frame: number) => void) | undefined;
+    lastFrame: number;
+    onFrameUpdate: null | ((framesRendered: number, frameIndex: number, timeToRenderInMilliseconds: number) => void);
+    framesRenderedObj: {
+        count: number;
+    };
+    nextFrameToRender: NextFrameToRender;
+    frame: number;
+    page: Page;
+}) => Promise<void>;

package/dist/render-frame.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFrame = void 0;
+const render_frame_with_option_to_reject_1 = require("./render-frame-with-option-to-reject");
+const renderFrame = ({ attempt, binariesDirectory, cancelSignal, imageFormat, indent, logLevel, assets, countType, downloadMap, frameDir, framesToRender, jpegQuality, onArtifact, onDownload, scale, composition, onError, outputDir, stoppedSignal, timeoutInMilliseconds, lastFrame, onFrameBuffer, onFrameUpdate, framesRenderedObj, frame, page, }) => {
+    return new Promise((resolve, reject) => {
+        (0, render_frame_with_option_to_reject_1.renderFrameWithOptionToReject)({
+            reject,
+            width: composition.width,
+            height: composition.height,
+            compId: composition.id,
+            attempt,
+            indent,
+            logLevel,
+            stoppedSignal,
+            timeoutInMilliseconds,
+            imageFormat,
+            onFrameBuffer,
+            outputDir,
+            assets,
+            binariesDirectory,
+            cancelSignal,
+            countType,
+            downloadMap,
+            frameDir,
+            framesToRender,
+            jpegQuality,
+            lastFrame,
+            onArtifact,
+            onDownload,
+            onError,
+            scale,
+            framesRenderedObj,
+            onFrameUpdate,
+            frame,
+            page,
+        })
+            .then(() => {
+            resolve();
+        })
+            .catch((err) => {
+            reject(err);
+        });
+    });
+};
+exports.renderFrame = renderFrame;