@remotion/renderer 4.1.0-alpha4 → 4.1.0-alpha7

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

@@ -1,191 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractFrameFromVideo = exports.getLastFrameOfVideo = void 0;
-const execa_1 = __importDefault(require("execa"));
-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);
-const getLastFrameOfVideoFastUnlimited = async (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, 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 (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}ms`;
-    const [stdErr, stdoutBuffer] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
-        actualOffset,
-        ffmpegExecutable,
-        imageFormat: options.imageFormat,
-        needsResize: options.needsResize,
-        remotionRoot: options.remotionRoot,
-        specialVCodecForTransparency: options.specialVCodecForTransparency,
-        src,
-    });
-    const isEmpty = stdErr.includes('Output file is empty');
-    if (isEmpty) {
-        const unlimited = await getLastFrameOfVideoFastUnlimited({
-            ffmpegExecutable,
-            // 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;
-    }
-    return stdoutBuffer;
-};
-const getLastFrameOfVideo = async (options) => {
-    const result = await lastFrameLimit(getLastFrameOfVideoFastUnlimited, options);
-    (0, last_frame_from_video_cache_1.setLastFrameInCache)(options, result);
-    return result;
-};
-exports.getLastFrameOfVideo = getLastFrameOfVideo;
-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)(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) {
-        throw new Error('unexpectedly did not get stderr');
-    }
-    if (!stdout) {
-        throw new Error('unexpectedly did not get stdout');
-    }
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    const stderrStringProm = 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('utf8')));
-    });
-    const stdoutBuffer = 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 [stderrStr, stdOut] = await Promise.all([
-        stderrStringProm,
-        stdoutBuffer,
-    ]);
-    if (stderrStr.includes('Output file is empty')) {
-        (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 = (0, perf_1.startPerfMeasure)('extract-frame');
-    const res = await mainLimit(extractFrameFromVideoFn, options);
-    (0, perf_1.stopPerfMeasure)(perf);
-    return res;
-};
-exports.extractFrameFromVideo = extractFrameFromVideo;

package/dist/ffmpeg-executable.d.ts

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

package/dist/ffmpeg-executable.js

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

package/dist/ffmpeg-flags.d.ts

@@ -1,31 +0,0 @@
-import type { FfmpegExecutable } from './ffmpeg-executable';
-export type FfmpegVersion = [number, number, number] | null;
-export declare const getFfmpegBuildInfo: (options: {
-    ffmpegExecutable: string | null;
-    remotionRoot: string;
-}) => Promise<string>;
-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';
-    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;

package/dist/ffmpeg-flags.js

@@ -1,245 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.warnAboutFfmpegVersion = exports.getBinaryDownloadUrl = exports.getExecutableBinary = exports.lambdaFfmpegPaths = exports.downloadBinary = exports.getFfmpegVersion = exports.parseFfmpegVersion = exports.ffmpegHasFeature = exports.ffmpegInNodeModules = exports.getFfmpegBuildInfo = void 0;
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const BrowserFetcher_1 = require("./browser/BrowserFetcher");
-const validate_ffmpeg_1 = require("./validate-ffmpeg");
-let buildConfig = null;
-const listeners = {};
-const isDownloading = {};
-const getFfmpegBuildInfo = async (options) => {
-    if (buildConfig !== null) {
-        return buildConfig;
-    }
-    const data = await (0, execa_1.default)(await (0, exports.getExecutableBinary)(options.ffmpegExecutable, options.remotionRoot, 'ffmpeg'), ['-buildconf'], {
-        reject: false,
-    });
-    buildConfig = data.stderr;
-    return buildConfig;
-};
-exports.getFfmpegBuildInfo = getFfmpegBuildInfo;
-const getFfmpegFolderName = (remotionRoot) => {
-    return path_1.default.resolve(remotionRoot, 'node_modules/.ffmpeg');
-};
-const binaryPrefix = { ffmpeg: 'ffmpeg-', ffprobe: 'ffprobe-' };
-const randomFfmpegRuntimeId = String(Math.random()).replace('0.', '');
-const ffmpegInNodeModules = (remotionRoot, binary) => {
-    const folderName = getFfmpegFolderName(remotionRoot);
-    if (!fs_1.default.existsSync(folderName)) {
-        fs_1.default.mkdirSync(folderName, {
-            recursive: true,
-        });
-    }
-    // Check if a version of FFMPEG is already installed.
-    // To qualify, it must have the expected file size
-    // to avoid finding binaries that are still being downloaded
-    // A random ID is being assigned to the download to avoid conflicts when multiple Remotion processes are running
-    const ffmpegInstalled = fs_1.default.readdirSync(folderName).find((filename) => {
-        if (!filename.startsWith(binaryPrefix[binary])) {
-            return false;
-        }
-        const dlUrl = (0, exports.getBinaryDownloadUrl)(binary);
-        if (!dlUrl) {
-            return false;
-        }
-        const expectedLength = dlUrl.contentLength;
-        if (fs_1.default.statSync(path_1.default.join(folderName, filename)).size === expectedLength) {
-            return true;
-        }
-        return false;
-    });
-    if (ffmpegInstalled) {
-        return path_1.default.join(folderName, ffmpegInstalled);
-    }
-    return null;
-};
-exports.ffmpegInNodeModules = ffmpegInNodeModules;
-const getFfmpegAbsolutePath = (remotionRoot, binary) => {
-    const folderName = getFfmpegFolderName(remotionRoot);
-    if (!fs_1.default.existsSync(folderName)) {
-        fs_1.default.mkdirSync(folderName);
-    }
-    if (os_1.default.platform() === 'win32') {
-        return path_1.default.resolve(folderName, `${binaryPrefix[binary]}${randomFfmpegRuntimeId}.exe`);
-    }
-    return path_1.default.resolve(folderName, `${binaryPrefix[binary]}${randomFfmpegRuntimeId}`);
-};
-const ffmpegHasFeature = async ({ ffmpegExecutable, feature, remotionRoot, }) => {
-    if (ffmpegExecutable && !(0, validate_ffmpeg_1.customExecutableExists)(ffmpegExecutable)) {
-        return false;
-    }
-    if (!(0, validate_ffmpeg_1.binaryExists)('ffmpeg')) {
-        return false;
-    }
-    const config = await (0, exports.getFfmpegBuildInfo)({ ffmpegExecutable, remotionRoot });
-    return config.includes(feature);
-};
-exports.ffmpegHasFeature = ffmpegHasFeature;
-const parseFfmpegVersion = (buildconf) => {
-    var _a;
-    const match = buildconf.match(/ffmpeg version ([0-9]+).([0-9]+)(?:.([0-9]+))?/);
-    if (!match) {
-        return null;
-    }
-    return [Number(match[1]), Number(match[2]), Number((_a = match[3]) !== null && _a !== void 0 ? _a : 0)];
-};
-exports.parseFfmpegVersion = parseFfmpegVersion;
-const getFfmpegVersion = async (options) => {
-    const buildInfo = await (0, exports.getFfmpegBuildInfo)({
-        ffmpegExecutable: options.ffmpegExecutable,
-        remotionRoot: options.remotionRoot,
-    });
-    return (0, exports.parseFfmpegVersion)(buildInfo);
-};
-exports.getFfmpegVersion = getFfmpegVersion;
-const waitForFfmpegToBeDownloaded = (url) => {
-    return new Promise((resolve) => {
-        if (!listeners[url]) {
-            listeners[url] = [];
-        }
-        listeners[url].push((src) => resolve(src));
-    });
-};
-const onProgress = (downloadedBytes, totalBytesToDownload, binary) => {
-    console.log('Downloading ', binary, `${toMegabytes(downloadedBytes)}/${toMegabytes(totalBytesToDownload)}`);
-};
-const downloadBinary = async (remotionRoot, url, binary) => {
-    const destinationPath = getFfmpegAbsolutePath(remotionRoot, binary);
-    const onProgressCallback = (downloadedBytes, _totalBytes) => {
-        onProgress(downloadedBytes, _totalBytes, binary);
-    };
-    isDownloading[url] = true;
-    const totalBytes = await (0, BrowserFetcher_1._downloadFile)(url, destinationPath, onProgressCallback);
-    onProgress(totalBytes, totalBytes, binary);
-    if (os_1.default.platform() !== 'win32') {
-        fs_1.default.chmodSync(destinationPath, '777');
-    }
-    isDownloading[url] = false;
-    if (!listeners[url]) {
-        listeners[url] = [];
-    }
-    listeners[url].forEach((listener) => listener(destinationPath));
-    listeners[url] = [];
-    return destinationPath;
-};
-exports.downloadBinary = downloadBinary;
-exports.lambdaFfmpegPaths = {
-    ffmpeg: '/opt/bin/ffmpeg',
-    ffprobe: '/opt/bin/ffprobe',
-};
-const getExecutableBinary = (ffmpegExecutable, remotionRoot, binary) => {
-    if (fs_1.default.existsSync(exports.lambdaFfmpegPaths[binary])) {
-        return exports.lambdaFfmpegPaths[binary];
-    }
-    if (ffmpegExecutable && (0, validate_ffmpeg_1.customExecutableExists)(ffmpegExecutable)) {
-        return ffmpegExecutable;
-    }
-    if ((0, validate_ffmpeg_1.binaryExists)(binary)) {
-        return binary;
-    }
-    const dlUrl = (0, exports.getBinaryDownloadUrl)(binary);
-    if (dlUrl && isDownloading[dlUrl.url]) {
-        return waitForFfmpegToBeDownloaded(dlUrl.url);
-    }
-    const inNodeMod = (0, exports.ffmpegInNodeModules)(remotionRoot, binary);
-    if (inNodeMod) {
-        return inNodeMod;
-    }
-    if (!dlUrl) {
-        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.`);
-    }
-    return (0, exports.downloadBinary)(remotionRoot, dlUrl.url, binary);
-};
-exports.getExecutableBinary = getExecutableBinary;
-function toMegabytes(bytes) {
-    const mb = bytes / 1024 / 1024;
-    return `${Math.round(mb * 10) / 10} Mb`;
-}
-const getBinaryDownloadUrl = (binary) => {
-    if (os_1.default.platform() === 'win32' && process.arch === 'x64') {
-        return binary === 'ffmpeg'
-            ? {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-win-x86.exe',
-                contentLength: 127531008,
-            }
-            : {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-win-x86.exe',
-                contentLength: 127425536,
-            };
-    }
-    if (os_1.default.platform() === 'darwin' && process.arch === 'arm64') {
-        return binary === 'ffmpeg'
-            ? {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-macos-arm64',
-                contentLength: 42093320,
-            }
-            : {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-macos-arm64-v2',
-                contentLength: 46690008,
-            };
-    }
-    if (os_1.default.platform() === 'darwin' && process.arch === 'x64') {
-        return binary === 'ffmpeg'
-            ? {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-macos-x86',
-                contentLength: 78380700,
-            }
-            : {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-macos-x86',
-                contentLength: 77364284,
-            };
-    }
-    if (os_1.default.platform() === 'linux' && process.arch === 'x64') {
-        return binary === 'ffmpeg'
-            ? {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffmpeg-linux-amd64',
-                contentLength: 78502560,
-            }
-            : {
-                url: 'https://remotion-ffmpeg-binaries.s3.eu-central-1.amazonaws.com/ffprobe-linux-amd64',
-                contentLength: 78400704,
-            };
-    }
-    return null;
-};
-exports.getBinaryDownloadUrl = getBinaryDownloadUrl;
-const printMessage = (ffmpegVersion) => {
-    console.warn('⚠️Old FFMPEG version detected: ' + ffmpegVersion.join('.'));
-    console.warn('   You need at least version 4.1.0.');
-    console.warn('   Upgrade FFMPEG to get rid of this warning.');
-};
-const printBuildConfMessage = () => {
-    console.error('⚠️  Unsupported FFMPEG version detected.');
-    console.error("   Your version doesn't support the -buildconf flag");
-    console.error('   Audio will not be supported and you may experience other issues.');
-    console.error('   Upgrade FFMPEG to at least v4.1.0 to get rid of this warning.');
-};
-const warnAboutFfmpegVersion = ({ ffmpegVersion, buildConf, }) => {
-    if (buildConf === null) {
-        printBuildConfMessage();
-        return;
-    }
-    if (ffmpegVersion === null) {
-        return null;
-    }
-    const [major, minor] = ffmpegVersion;
-    // 3.x and below definitely is too old
-    if (major < 4) {
-        printMessage(ffmpegVersion);
-        return;
-    }
-    // 5.x will be all good
-    if (major > 4) {
-        return;
-    }
-    if (minor < 1) {
-        printMessage(ffmpegVersion);
-    }
-};
-exports.warnAboutFfmpegVersion = warnAboutFfmpegVersion;

package/dist/frame-to-ffmpeg-timestamp.d.ts

@@ -1 +0,0 @@
-export declare const frameToFfmpegTimestamp: (time: number) => string;

package/dist/frame-to-ffmpeg-timestamp.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.frameToFfmpegTimestamp = void 0;
-const frameToFfmpegTimestamp = (time) => {
-    // We ceil because FFMPEG seeks to the closest frame BEFORE the position
-    return (Math.ceil(time * 1000000) / 1000).toFixed(3) + 'ms';
-};
-exports.frameToFfmpegTimestamp = frameToFfmpegTimestamp;

package/dist/get-can-extract-frames-fast.d.ts

@@ -1,14 +0,0 @@
-import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const ACCEPTABLE_OFFSET_THRESHOLD = 50;
-/**
- * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
- * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
- */
-export declare const getCanExtractFramesFast: ({ src, ffmpegExecutable, ffprobeExecutable, }: {
-    src: string;
-    ffmpegExecutable?: FfmpegExecutable | undefined;
-    ffprobeExecutable?: FfmpegExecutable | undefined;
-}) => Promise<{
-    canExtractFramesFast: boolean;
-    shouldReencode: boolean;
-}>;

package/dist/get-can-extract-frames-fast.js

@@ -1,71 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCanExtractFramesFast = exports.ACCEPTABLE_OFFSET_THRESHOLD = void 0;
-const fs_1 = __importDefault(require("fs"));
-const get_video_stream_duration_1 = require("./assets/get-video-stream-duration");
-const ensure_presentation_timestamp_1 = require("./ensure-presentation-timestamp");
-const find_closest_package_json_1 = require("./find-closest-package-json");
-const get_video_info_1 = require("./get-video-info");
-const try_to_extract_frame_of_video_fast_1 = require("./try-to-extract-frame-of-video-fast");
-exports.ACCEPTABLE_OFFSET_THRESHOLD = 50;
-/**
- * @description Probes whether frames of a video can be efficiently extracted when using <OffthreadVideo>.
- * @see [Documentation](https://www.remotion.dev/docs/renderer/get-can-extract-frames-fast)
- */
-const getCanExtractFramesFast = async ({ src, ffmpegExecutable, ffprobeExecutable, }) => {
-    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
-    const out = await (0, ensure_presentation_timestamp_1.ensurePresentationTimestampWithoutCache)({
-        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
-        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
-        remotionRoot,
-        src,
-    });
-    const { specialVcodecForTransparency: specialVcodec } = await (0, get_video_info_1.getVideoInfoUncached)({
-        src: out,
-        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
-        remotionRoot,
-    });
-    if (specialVcodec === 'vp8') {
-        fs_1.default.unlinkSync(out);
-        return {
-            canExtractFramesFast: false,
-            shouldReencode: false,
-        };
-    }
-    const { duration } = await (0, get_video_stream_duration_1.getVideoStreamDurationwithoutCache)({
-        ffprobeExecutable: ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : null,
-        remotionRoot,
-        src: out,
-    });
-    if (duration === null) {
-        fs_1.default.unlinkSync(out);
-        throw new Error(`Could not determine the duration of ${src} using FFMPEG. The file is not supported.`);
-    }
-    const actualOffset = `${duration * 1000 - exports.ACCEPTABLE_OFFSET_THRESHOLD}ms`;
-    const [stdErr] = await (0, try_to_extract_frame_of_video_fast_1.tryToExtractFrameOfVideoFast)({
-        actualOffset,
-        ffmpegExecutable: ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : null,
-        imageFormat: 'jpeg',
-        // Intentionally leaving needsResize as null, because we don't need to resize
-        needsResize: null,
-        remotionRoot,
-        specialVCodecForTransparency: specialVcodec,
-        src: out,
-    });
-    fs_1.default.unlinkSync(out);
-    const isEmpty = stdErr.includes('Output file is empty');
-    if (isEmpty) {
-        return {
-            canExtractFramesFast: false,
-            shouldReencode: true,
-        };
-    }
-    return {
-        canExtractFramesFast: true,
-        shouldReencode: false,
-    };
-};
-exports.getCanExtractFramesFast = getCanExtractFramesFast;

package/dist/get-frame-of-video-slow.d.ts

@@ -1,17 +0,0 @@
-import type { OffthreadVideoImageFormat } from 'remotion';
-import type { SpecialVCodecForTransparency } from './assets/download-map';
-import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const getFrameOfVideoSlow: ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }: {
-    ffmpegExecutable: FfmpegExecutable;
-    src: string;
-    duration: number;
-    imageFormat: OffthreadVideoImageFormat;
-    specialVCodecForTransparency: SpecialVCodecForTransparency;
-    needsResize: [
-        number,
-        number
-    ] | null;
-    offset: number;
-    fps: number | null;
-    remotionRoot: string;
-}) => Promise<Buffer>;

package/dist/get-frame-of-video-slow.js

@@ -1,72 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFrameOfVideoSlow = void 0;
-// 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 execa_1 = __importDefault(require("execa"));
-const determine_resize_params_1 = require("./determine-resize-params");
-const determine_vcodec_ffmpeg_flags_1 = require("./determine-vcodec-ffmpeg-flags");
-const ffmpeg_flags_1 = require("./ffmpeg-flags");
-const truthy_1 = require("./truthy");
-const getFrameOfVideoSlow = async ({ src, duration, ffmpegExecutable, imageFormat, specialVCodecForTransparency, needsResize, offset, fps, remotionRoot, }) => {
-    console.warn(`\nUsing a slow method to extract the frame at ${duration}ms of ${src}. See https://remotion.dev/docs/slow-method-to-extract-frame for advice`);
-    const actualOffset = `-${duration * 1000 - offset}ms`;
-    const command = [
-        '-itsoffset',
-        actualOffset,
-        ...(0, determine_vcodec_ffmpeg_flags_1.determineVcodecFfmpegFlags)(specialVCodecForTransparency),
-        '-i',
-        src,
-        '-frames:v',
-        '1',
-        '-c:v',
-        imageFormat === 'jpeg' ? 'mjpeg' : 'png',
-        '-f',
-        'image2pipe',
-        ...(0, determine_resize_params_1.determineResizeParams)(needsResize),
-        '-',
-    ].filter(truthy_1.truthy);
-    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, '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) {
-        if (offset > 70) {
-            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 (0, exports.getFrameOfVideoSlow)({
-            ffmpegExecutable,
-            duration,
-            // Decrement in 10ms increments, or 1 frame (e.g. fps = 25 --> 40ms)
-            offset: offset + (fps === null ? 10 : 1000 / fps),
-            src,
-            imageFormat,
-            specialVCodecForTransparency,
-            needsResize,
-            fps,
-            remotionRoot,
-        });
-    }
-    return stdoutBuffer;
-};
-exports.getFrameOfVideoSlow = getFrameOfVideoSlow;

package/dist/get-video-info.d.ts

@@ -1,8 +0,0 @@
-import type { DownloadMap, Vp9Result } from './assets/download-map';
-import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare function getVideoInfoUncached({ src, ffprobeExecutable, remotionRoot, }: {
-    src: string;
-    ffprobeExecutable: FfmpegExecutable;
-    remotionRoot: string;
-}): Promise<Vp9Result>;
-export declare const getVideoInfo: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<Vp9Result>;