@remotion/renderer 4.0.0-alpha.4 → 4.0.0-audio-mixing.4

package/dist/stitch-frames-to-video.js

@@ -1,38 +1,65 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stitchFramesToVideo = exports.spawnFfmpeg = void 0;
 const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const promises_1 = require("fs/promises");
+const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const remotion_1 = require("remotion");
 const calculate_asset_positions_1 = require("./assets/calculate-asset-positions");
 const convert_assets_to_file_urls_1 = require("./assets/convert-assets-to-file-urls");
 const download_and_map_assets_to_file_1 = require("./assets/download-and-map-assets-to-file");
+const audio_codec_1 = require("./audio-codec");
 const codec_1 = require("./codec");
 const codec_supports_media_1 = require("./codec-supports-media");
 const convert_number_of_gif_loops_to_ffmpeg_1 = require("./convert-number-of-gif-loops-to-ffmpeg");
 const crf_1 = require("./crf");
 const delete_directory_1 = require("./delete-directory");
-const get_audio_codec_name_1 = require("./get-audio-codec-name");
+const ffmpeg_flags_1 = require("./ffmpeg-flags");
+const find_closest_package_json_1 = require("./find-closest-package-json");
 const get_codec_name_1 = require("./get-codec-name");
 const get_extension_from_codec_1 = require("./get-extension-from-codec");
 const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const make_cancel_signal_1 = require("./make-cancel-signal");
 const merge_audio_track_1 = require("./merge-audio-track");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const pixel_format_1 = require("./pixel-format");
 const preprocess_audio_track_1 = require("./preprocess-audio-track");
+const prores_profile_1 = require("./prores-profile");
 const truthy_1 = require("./truthy");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
 const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const validate_videobitrate_1 = require("./validate-videobitrate");
 const packageJsonPath = path_1.default.join(__dirname, '..', 'package.json');
 const packageJson = fs_1.default.existsSync(packageJsonPath)
     ? JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
     : null;
-const getAssetsData = async ({ assets, onDownload, fps, expectedFrames, verbose, ffmpegExecutable, ffprobeExecutable, onProgress, downloadMap, }) => {
+const getAssetsData = async ({ assets, onDownload, fps, expectedFrames, verbose, ffmpegExecutable, ffprobeExecutable, onProgress, downloadMap, remotionRoot, }) => {
     const fileUrlAssets = await (0, convert_assets_to_file_urls_1.convertAssetsToFileUrls)({
         assets,
         onDownload: onDownload !== null && onDownload !== void 0 ? onDownload : (() => () => undefined),
@@ -57,6 +84,7 @@ const getAssetsData = async ({ assets, onDownload, fps, expectedFrames, verbose,
             expectedFrames,
             fps,
             downloadMap,
+            remotionRoot,
         });
         preprocessProgress[index] = 1;
         updateProgress();
@@ -69,16 +97,17 @@ const getAssetsData = async ({ assets, onDownload, fps, expectedFrames, verbose,
         outName,
         numberOfSeconds: Number((expectedFrames / fps).toFixed(3)),
         downloadMap,
+        remotionRoot,
     });
-    (0, delete_directory_1.deleteDirectory)(downloadMap.audioMixing);
     onProgress(1);
+    (0, delete_directory_1.deleteDirectory)(downloadMap.audioMixing);
     preprocessed.forEach((p) => {
         (0, delete_directory_1.deleteDirectory)(p);
     });
     return outName;
 };
-const spawnFfmpeg = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+const spawnFfmpeg = async (options, remotionRoot) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
     remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
     remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
     const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : codec_1.DEFAULT_CODEC;
@@ -88,31 +117,51 @@ const spawnFfmpeg = async (options) => {
         codec,
         scale: 1,
     });
+    (0, prores_profile_1.validateSelectedCodecAndProResCombination)({
+        codec,
+        proResProfile: options.proResProfile,
+    });
+    (0, validate_videobitrate_1.validateBitrate)(options.audioBitrate, 'audioBitrate');
+    (0, validate_videobitrate_1.validateBitrate)(options.videoBitrate, 'videoBitrate');
     remotion_1.Internals.validateFps(options.fps, 'in `stitchFramesToVideo()`', false);
-    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : (0, crf_1.getDefaultCrfForCodec)(codec);
-    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : pixel_format_1.DEFAULT_PIXEL_FORMAT;
-    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const pixelFormat = (_b = options.pixelFormat) !== null && _b !== void 0 ? _b : pixel_format_1.DEFAULT_PIXEL_FORMAT;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_c = options.ffmpegExecutable) !== null && _c !== void 0 ? _c : null, remotionRoot, 'ffmpeg');
     const encoderName = (0, get_codec_name_1.getCodecName)(codec);
-    const audioCodecName = (0, get_audio_codec_name_1.getAudioCodecName)(codec);
     const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
     const mediaSupport = (0, codec_supports_media_1.codecSupportsMedia)(codec);
-    const supportsCrf = encoderName && codec !== 'prores';
+    const shouldRenderAudio = mediaSupport.audio &&
+        (options.assetsInfo.assets.flat(1).length > 0 ||
+            options.enforceAudioTrack) &&
+        !options.muted;
+    const shouldRenderVideo = mediaSupport.video;
+    if (!shouldRenderAudio && !shouldRenderVideo) {
+        throw new Error('The output format has neither audio nor video. This can happen if you are rendering an audio codec and the output file has no audio or the muted flag was passed.');
+    }
+    // Explanation: https://github.com/remotion-dev/remotion/issues/1647
+    const resolvedAudioCodec = ((_d = options.internalOptions) === null || _d === void 0 ? void 0 : _d.preferLossless)
+        ? (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: true })
+        : (_e = options.audioCodec) !== null && _e !== void 0 ? _e : (0, audio_codec_1.getDefaultAudioCodec)({ codec, preferLossless: false });
     const tempFile = options.outputLocation
         ? null
-        : path_1.default.join(options.assetsInfo.downloadMap.stitchFrames, `out.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, 'final')}`);
+        : path_1.default.join(options.assetsInfo.downloadMap.stitchFrames, `out.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, resolvedAudioCodec)}`);
     if (options.verbose) {
-        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
+        console.log('[verbose] ffmpeg', (_f = options.ffmpegExecutable) !== null && _f !== void 0 ? _f : 'ffmpeg in PATH');
         console.log('[verbose] encoder', encoderName);
-        console.log('[verbose] audioCodec', audioCodecName);
+        console.log('[verbose] audioCodec', resolvedAudioCodec);
         console.log('[verbose] pixelFormat', pixelFormat);
-        if (supportsCrf) {
-            console.log('[verbose] crf', crf);
+        if (options.ffmpegOverride) {
+            console.log('[verbose] ffmpegOverride', options.ffmpegOverride);
         }
         console.log('[verbose] codec', codec);
-        console.log('[verbose] isAudioOnly', mediaSupport.audio && !mediaSupport.video);
+        console.log('[verbose] shouldRenderAudio', shouldRenderAudio);
+        console.log('[verbose] shouldRenderVideo', shouldRenderVideo);
         console.log('[verbose] proResProfileName', proResProfileName);
     }
-    (0, crf_1.validateSelectedCrfAndCodecCombination)(crf, codec);
+    (0, crf_1.validateQualitySettings)({
+        crf: options.crf,
+        codec,
+        videoBitrate: options.videoBitrate,
+    });
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     const expectedFrames = options.assetsInfo.assets.length;
     const updateProgress = (preStitchProgress, muxProgress) => {
@@ -120,45 +169,47 @@ const spawnFfmpeg = async (options) => {
         const totalFrameProgress = 0.5 * preStitchProgress * expectedFrames + muxProgress * 0.5;
         (_a = options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, Math.round(totalFrameProgress));
     };
-    const audio = mediaSupport.audio
+    const audio = shouldRenderAudio
         ? await getAssetsData({
             assets: options.assetsInfo.assets,
             onDownload: options.onDownload,
             fps: options.fps,
             expectedFrames,
-            verbose: (_f = options.verbose) !== null && _f !== void 0 ? _f : false,
-            ffmpegExecutable: (_g = options.ffmpegExecutable) !== null && _g !== void 0 ? _g : null,
-            ffprobeExecutable: (_h = options.ffprobeExecutable) !== null && _h !== void 0 ? _h : null,
+            verbose: (_g = options.verbose) !== null && _g !== void 0 ? _g : false,
+            ffmpegExecutable: (_h = options.ffmpegExecutable) !== null && _h !== void 0 ? _h : null,
+            ffprobeExecutable: (_j = options.ffprobeExecutable) !== null && _j !== void 0 ? _j : null,
             onProgress: (prog) => updateProgress(prog, 0),
             downloadMap: options.assetsInfo.downloadMap,
+            remotionRoot,
         })
         : null;
     if (mediaSupport.audio && !mediaSupport.video) {
-        if (!audioCodecName) {
+        if (!resolvedAudioCodec) {
             throw new TypeError('exporting audio but has no audio codec name. Report this in the Remotion repo.');
         }
-        const ffmpegTask = (0, execa_1.default)('ffmpeg', [
+        const ffmpegTask = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_k = options.ffmpegExecutable) !== null && _k !== void 0 ? _k : null, remotionRoot, 'ffmpeg'), [
             '-i',
             audio,
             '-c:a',
-            audioCodecName,
+            (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec),
             // Set bitrate up to 320k, for aac it might effectively be lower
             '-b:a',
-            '320k',
+            (_l = options.audioBitrate) !== null && _l !== void 0 ? _l : '320k',
             options.force ? '-y' : null,
-            (_j = options.outputLocation) !== null && _j !== void 0 ? _j : tempFile,
+            (_m = options.outputLocation) !== null && _m !== void 0 ? _m : tempFile,
         ].filter(remotion_1.Internals.truthy));
-        (_k = options.cancelSignal) === null || _k === void 0 ? void 0 : _k.call(options, () => {
+        (_o = options.cancelSignal) === null || _o === void 0 ? void 0 : _o.call(options, () => {
             ffmpegTask.kill();
         });
         await ffmpegTask;
-        (_l = options.onProgress) === null || _l === void 0 ? void 0 : _l.call(options, expectedFrames);
+        (_p = options.onProgress) === null || _p === void 0 ? void 0 : _p.call(options, expectedFrames);
         if (audio) {
-            await (0, delete_directory_1.deleteDirectory)(path_1.default.dirname(audio));
+            (0, delete_directory_1.deleteDirectory)(path_1.default.dirname(audio));
         }
         const file = await new Promise((resolve, reject) => {
             if (tempFile) {
-                (0, promises_1.readFile)(tempFile)
+                fs_1.promises
+                    .readFile(tempFile)
                     .then((f) => {
                     return resolve(f);
                 })
@@ -168,7 +219,7 @@ const spawnFfmpeg = async (options) => {
                 resolve(null);
             }
         });
-        await (0, delete_directory_1.deleteDirectory)(options.assetsInfo.downloadMap.stitchFrames);
+        (0, delete_directory_1.deleteDirectory)(options.assetsInfo.downloadMap.stitchFrames);
         return {
             getLogs: () => '',
             task: Promise.resolve(file),
@@ -176,8 +227,8 @@ const spawnFfmpeg = async (options) => {
     }
     const ffmpegArgs = [
         ['-r', String(options.fps)],
-        ...(((_m = options.internalOptions) === null || _m === void 0 ? void 0 : _m.preEncodedFileLocation)
-            ? [['-i', (_o = options.internalOptions) === null || _o === void 0 ? void 0 : _o.preEncodedFileLocation]]
+        ...(((_q = options.internalOptions) === null || _q === void 0 ? void 0 : _q.preEncodedFileLocation)
+            ? [['-i', (_r = options.internalOptions) === null || _r === void 0 ? void 0 : _r.preEncodedFileLocation]]
             : [
                 ['-f', 'image2'],
                 ['-s', `${options.width}x${options.height}`],
@@ -185,30 +236,35 @@ const spawnFfmpeg = async (options) => {
                 ['-i', options.assetsInfo.imageSequenceName],
             ]),
         audio ? ['-i', audio] : null,
-        ((_p = options.numberOfGifLoops) !== null && _p !== void 0 ? _p : null) === null
+        ((_s = options.numberOfGifLoops) !== null && _s !== void 0 ? _s : null) === null
             ? null
             : [
                 '-loop',
-                (0, convert_number_of_gif_loops_to_ffmpeg_1.convertNumberOfGifLoopsToFfmpegSyntax)((_q = options.numberOfGifLoops) !== null && _q !== void 0 ? _q : null),
+                (0, convert_number_of_gif_loops_to_ffmpeg_1.convertNumberOfGifLoopsToFfmpegSyntax)((_t = options.numberOfGifLoops) !== null && _t !== void 0 ? _t : null),
             ],
         // -c:v is the same as -vcodec as -codec:video
         // and specified the video codec.
         ['-c:v', encoderName],
-        ...(((_r = options.internalOptions) === null || _r === void 0 ? void 0 : _r.preEncodedFileLocation)
+        ...(((_u = options.internalOptions) === null || _u === void 0 ? void 0 : _u.preEncodedFileLocation)
             ? []
             : [
                 proResProfileName ? ['-profile:v', proResProfileName] : null,
-                supportsCrf ? ['-crf', String(crf)] : null,
                 ['-pix_fmt', pixelFormat],
                 // Without explicitly disabling auto-alt-ref,
                 // transparent WebM generation doesn't work
                 pixelFormat === 'yuva420p' ? ['-auto-alt-ref', '0'] : null,
-                ['-b:v', '1M'],
+                ...(0, crf_1.validateQualitySettings)({
+                    crf: options.crf,
+                    videoBitrate: options.videoBitrate,
+                    codec,
+                }),
             ]),
         codec === 'h264' ? ['-movflags', 'faststart'] : null,
-        audioCodecName ? ['-c:a', audioCodecName] : null,
+        resolvedAudioCodec
+            ? ['-c:a', (0, audio_codec_1.mapAudioCodecToFfmpegAudioCodecName)(resolvedAudioCodec)]
+            : null,
         // Set max bitrate up to 1024kbps, will choose lower if that's too much
-        audioCodecName ? ['-b:a', '512K'] : null,
+        resolvedAudioCodec ? ['-b:a', options.audioBitrate || '512K'] : null,
         // Ignore metadata that may come from remote media
         ['-map_metadata', '-1'],
         [
@@ -217,22 +273,29 @@ const spawnFfmpeg = async (options) => {
                 [`Made with Remotion`, packageJson ? packageJson.version : null].join(' '),
         ],
         options.force ? '-y' : null,
-        (_s = options.outputLocation) !== null && _s !== void 0 ? _s : tempFile,
+        (_v = options.outputLocation) !== null && _v !== void 0 ? _v : tempFile,
     ];
     if (options.verbose) {
         console.log('Generated FFMPEG command:');
         console.log(ffmpegArgs);
     }
     const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
-    const task = (0, execa_1.default)((_t = options.ffmpegExecutable) !== null && _t !== void 0 ? _t : 'ffmpeg', ffmpegString, {
+    const finalFfmpegString = options.ffmpegOverride
+        ? options.ffmpegOverride({ type: 'stitcher', args: ffmpegString })
+        : ffmpegString;
+    if (options.verbose && options.ffmpegOverride) {
+        console.log('Generated final FFMPEG command:');
+        console.log(finalFfmpegString);
+    }
+    const task = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)((_w = options.ffmpegExecutable) !== null && _w !== void 0 ? _w : null, remotionRoot, 'ffmpeg'), finalFfmpegString, {
         cwd: options.dir,
     });
-    (_u = options.cancelSignal) === null || _u === void 0 ? void 0 : _u.call(options, () => {
+    (_x = options.cancelSignal) === null || _x === void 0 ? void 0 : _x.call(options, () => {
         task.kill();
     });
     let ffmpegOutput = '';
     let isFinished = false;
-    (_v = task.stderr) === null || _v === void 0 ? void 0 : _v.on('data', (data) => {
+    (_y = task.stderr) === null || _y === void 0 ? void 0 : _y.on('data', (data) => {
         var _a;
         const str = data.toString();
         ffmpegOutput += str;
@@ -261,7 +324,8 @@ const spawnFfmpeg = async (options) => {
                 (0, delete_directory_1.deleteDirectory)(options.assetsInfo.downloadMap.stitchFrames);
                 return null;
             }
-            return (0, promises_1.readFile)(tempFile)
+            return fs_1.promises
+                .readFile(tempFile)
                 .then((file) => {
                 return Promise.all([
                     file,
@@ -275,8 +339,13 @@ const spawnFfmpeg = async (options) => {
     };
 };
 exports.spawnFfmpeg = spawnFfmpeg;
+/**
+ * @description Takes a series of images and audio information generated by renderFrames() and encodes it to a video.
+ * @see [Documentation](https://www.remotion.dev/docs/renderer/stitch-frames-to-video)
+ */
 const stitchFramesToVideo = async (options) => {
-    const { task, getLogs } = await (0, exports.spawnFfmpeg)(options);
+    const remotionRoot = (0, find_closest_package_json_1.findRemotionRoot)();
+    const { task, getLogs } = await (0, exports.spawnFfmpeg)(options, remotionRoot);
     const happyPath = task.catch(() => {
         throw new Error(getLogs());
     });
@@ -285,7 +354,7 @@ const stitchFramesToVideo = async (options) => {
         new Promise((_resolve, reject) => {
             var _a;
             (_a = options.cancelSignal) === null || _a === void 0 ? void 0 : _a.call(options, () => {
-                reject(new Error('stitchFramesToVideo() got cancelled'));
+                reject(new Error(make_cancel_signal_1.cancelErrorMessages.stitchFramesToVideo));
             });
         }),
     ]);

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

@@ -1,5 +1,5 @@
 import type { AssetVolume } from './assets/types';
-export declare const stringifyFfmpegFilter: ({ trimLeft, trimRight, channels, startInVideo, volume, fps, playbackRate, durationInFrames, assetDuration, }: {
+export declare const stringifyFfmpegFilter: ({ trimLeft, trimRight, channels, startInVideo, volume, fps, playbackRate, durationInFrames, assetDuration, allowAmplificationDuringRender, }: {
     trimLeft: number;
     trimRight: number;
     channels: number;
@@ -9,4 +9,5 @@ export declare const stringifyFfmpegFilter: ({ trimLeft, trimRight, channels, st
     durationInFrames: number;
     playbackRate: number;
     assetDuration: number | null;
+    allowAmplificationDuringRender: boolean;
 }) => string | null;

package/dist/stringify-ffmpeg-filter.js

@@ -5,7 +5,7 @@ const calculate_atempo_1 = require("./assets/calculate-atempo");
 const ffmpeg_volume_expression_1 = require("./assets/ffmpeg-volume-expression");
 const sample_rate_1 = require("./sample-rate");
 const truthy_1 = require("./truthy");
-const stringifyFfmpegFilter = ({ trimLeft, trimRight, channels, startInVideo, volume, fps, playbackRate, durationInFrames, assetDuration, }) => {
+const stringifyFfmpegFilter = ({ trimLeft, trimRight, channels, startInVideo, volume, fps, playbackRate, durationInFrames, assetDuration, allowAmplificationDuringRender, }) => {
     const startInVideoSeconds = startInVideo / fps;
     if (assetDuration && trimLeft >= assetDuration) {
         return null;
@@ -14,13 +14,15 @@ const stringifyFfmpegFilter = ({ trimLeft, trimRight, channels, startInVideo, vo
         volume,
         fps,
         trimLeft,
+        allowAmplificationDuringRender,
     });
     // Avoid setting filters if possible, as combining them can create noise
     const chunkLength = durationInFrames / fps;
     const actualTrimRight = assetDuration
         ? Math.min(trimRight, assetDuration)
         : trimRight;
-    const padAtEnd = chunkLength - (actualTrimRight - trimLeft) - startInVideoSeconds;
+    const audibleDuration = (actualTrimRight - trimLeft) / playbackRate;
+    const padAtEnd = chunkLength - audibleDuration - startInVideoSeconds;
     return (`[0:a]` +
         [
             `aformat=sample_fmts=s32:sample_rates=${sample_rate_1.DEFAULT_SAMPLE_RATE}`,

package/dist/take-frame-and-compose.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import type { TAsset } from 'remotion';
+import type { DownloadMap } from './assets/download-map';
+import type { Page } from './browser/BrowserPage';
+import type { ImageFormat } from './image-format';
+export declare const takeFrameAndCompose: ({ freePage, imageFormat, quality, frame, width, height, output, scale, downloadMap, wantsBuffer, }: {
+    freePage: Page;
+    imageFormat: ImageFormat;
+    quality: number | undefined;
+    frame: number;
+    height: number;
+    width: number;
+    output: string | null;
+    scale: number;
+    downloadMap: DownloadMap;
+    wantsBuffer: boolean;
+}) => Promise<{
+    buffer: Buffer | null;
+    collectedAssets: TAsset[];
+}>;

package/dist/take-frame-and-compose.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeFrameAndCompose = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compose_1 = require("./compositor/compose");
+const provide_screenshot_1 = require("./provide-screenshot");
+const puppeteer_evaluate_1 = require("./puppeteer-evaluate");
+const truthy_1 = require("./truthy");
+const takeFrameAndCompose = async ({ freePage, imageFormat, quality, frame, width, height, output, scale, downloadMap, wantsBuffer, }) => {
+    var _a;
+    const [clipRegion, collectedAssets] = await Promise.all([
+        (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+            pageFunction: () => {
+                if (typeof window.remotion_getClipRegion === 'undefined') {
+                    return null;
+                }
+                return window.remotion_getClipRegion();
+            },
+            args: [],
+            frame,
+            page: freePage,
+        }),
+        (0, puppeteer_evaluate_1.puppeteerEvaluateWithCatch)({
+            pageFunction: () => {
+                return window.remotion_collectAssets();
+            },
+            args: [],
+            frame,
+            page: freePage,
+        }),
+    ]);
+    if (imageFormat === 'none') {
+        return { buffer: null, collectedAssets };
+    }
+    const needsComposing = clipRegion === null
+        ? null
+        : {
+            tmpFile: path_1.default.join(downloadMap.compositingDir, `${frame}.${imageFormat}`),
+            finalOutfie: output !== null && output !== void 0 ? output : path_1.default.join(downloadMap.compositingDir, `${frame}-final.${imageFormat}`),
+            clipRegion: clipRegion,
+        };
+    if (clipRegion !== 'hide') {
+        const shouldMakeBuffer = wantsBuffer && !needsComposing;
+        const buf = await (0, provide_screenshot_1.provideScreenshot)({
+            page: freePage,
+            imageFormat,
+            quality,
+            options: {
+                frame,
+                output: shouldMakeBuffer ? null : (_a = needsComposing === null || needsComposing === void 0 ? void 0 : needsComposing.tmpFile) !== null && _a !== void 0 ? _a : output,
+            },
+            height,
+            width,
+            clipRegion,
+        });
+        if (shouldMakeBuffer) {
+            return { buffer: buf, collectedAssets };
+        }
+    }
+    if (needsComposing) {
+        await (0, compose_1.compose)({
+            height: height * scale,
+            width: width * scale,
+            layers: [
+                needsComposing.clipRegion === 'hide'
+                    ? null
+                    : {
+                        type: imageFormat === 'jpeg'
+                            ? 'JpgImage'
+                            : 'PngImage',
+                        params: {
+                            height: needsComposing.clipRegion.height * scale,
+                            width: needsComposing.clipRegion.width * scale,
+                            src: needsComposing.tmpFile,
+                            x: needsComposing.clipRegion.x * scale,
+                            y: needsComposing.clipRegion.y * scale,
+                        },
+                    },
+            ].filter(truthy_1.truthy),
+            output: needsComposing.finalOutfie,
+            downloadMap,
+            imageFormat: imageFormat === 'jpeg' ? 'Jpeg' : 'Png',
+        });
+        if (wantsBuffer) {
+            const buffer = await fs_1.default.promises.readFile(needsComposing.finalOutfie);
+            await fs_1.default.promises.unlink(needsComposing.finalOutfie);
+            return { buffer, collectedAssets };
+        }
+    }
+    return { buffer: null, collectedAssets };
+};
+exports.takeFrameAndCompose = takeFrameAndCompose;

package/dist/try-to-extract-frame-of-video-fast.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { OffthreadVideoImageFormat } from 'remotion';
+import type { NeedsResize, SpecialVCodecForTransparency } from './assets/download-map';
+import type { FfmpegExecutable } from './ffmpeg-executable';
+export declare const tryToExtractFrameOfVideoFast: ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }: {
+    ffmpegExecutable: FfmpegExecutable;
+    remotionRoot: string;
+    imageFormat: OffthreadVideoImageFormat;
+    needsResize: NeedsResize;
+    src: string;
+    specialVCodecForTransparency: SpecialVCodecForTransparency;
+    actualOffset: string;
+}) => Promise<readonly [string, Buffer]>;

package/dist/try-to-extract-frame-of-video-fast.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryToExtractFrameOfVideoFast = void 0;
+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 tryToExtractFrameOfVideoFast = async ({ ffmpegExecutable, remotionRoot, specialVCodecForTransparency, imageFormat, needsResize, src, actualOffset, }) => {
+    const { stdout, stderr } = (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffmpegExecutable, remotionRoot, 'ffmpeg'), [
+        '-ss',
+        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));
+    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]);
+    return [stdErr, stdoutBuffer];
+};
+exports.tryToExtractFrameOfVideoFast = tryToExtractFrameOfVideoFast;

package/dist/validate-concurrency.js

@@ -8,17 +8,22 @@ const validateConcurrency = (value, setting) => {
     if (value === null) {
         return;
     }
-    if (typeof value !== 'number') {
-        throw new Error(setting + ' must be a number but is ' + value);
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        throw new Error(setting + ' must a number or a string but is ' + value);
     }
-    if (value % 1 !== 0) {
-        throw new Error(setting + ' must be an integer, but is ' + value);
+    if (typeof value === 'number') {
+        if (value % 1 !== 0) {
+            throw new Error(setting + ' must be an integer, but is ' + value);
+        }
+        if (value < 1) {
+            throw new Error(setting + ' must be at least 1, but is ' + value);
+        }
+        if (value > require('os').cpus().length) {
+            throw new Error(`${setting} is set higher than the amount of CPU cores available. Available CPU cores: ${require('os').cpus().length}, value set: ${value}`);
+        }
     }
-    if (value < 1) {
-        throw new Error(setting + ' must be at least 1, but is ' + value);
-    }
-    if (value > require('os').cpus().length) {
-        throw new Error(`${setting} is set higher than the amount of CPU cores available. Available CPU cores: ${require('os').cpus().length}, value set: ${value}`);
+    else if (!/^\d+(\.\d+)?%$/.test(value)) {
+        throw new Error(`${setting} must be a number or percentage, but is ${JSON.stringify(value)}`);
     }
 };
 exports.validateConcurrency = validateConcurrency;

package/dist/validate-every-nth-frame.d.ts

@@ -1 +1,2 @@
-export declare const validateEveryNthFrame: (everyNthFrame: unknown) => void;
+import type { Codec } from './codec';
+export declare const validateEveryNthFrame: (everyNthFrame: unknown, codec: Codec) => 1 | undefined;