@remotion/renderer 4.0.278 → 4.0.279

package/dist/assets/calculate-asset-positions.js

@@ -45,7 +45,6 @@ const calculateAssetPositions = (frames) => {
                     trimLeft: asset.mediaFrame,
                     volume: [],
                     playbackRate: asset.playbackRate,
-                    allowAmplificationDuringRender: asset.allowAmplificationDuringRender,
                     toneFrequency: asset.toneFrequency,
                     audioStartFrame: asset.audioStartFrame,
                 });

package/dist/assets/ffmpeg-volume-expression.d.ts

@@ -4,10 +4,9 @@ type FfmpegVolumeExpression = {
     eval: FfmpegEval;
     value: string;
 };
-export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, allowAmplificationDuringRender, }: {
+export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, }: {
     volume: AssetVolume;
     trimLeft: number;
     fps: number;
-    allowAmplificationDuringRender: boolean;
 }) => FfmpegVolumeExpression;
 export {};

package/dist/assets/ffmpeg-volume-expression.js

@@ -43,14 +43,13 @@ const ffmpegBuildVolumeExpression = ({ arr, delay, fps, }) => {
     const [volume, frames] = first;
     return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression({ arr: rest, delay, fps }));
 };
-const ffmpegVolumeExpression = ({ volume, fps, trimLeft, allowAmplificationDuringRender, }) => {
-    const maxVolume = allowAmplificationDuringRender ? Infinity : 1;
+const ffmpegVolumeExpression = ({ volume, fps, trimLeft, }) => {
     // If it's a static volume, we return it and tell
     // FFMPEG it only has to evaluate it once
     if (typeof volume === 'number') {
         return {
             eval: 'once',
-            value: String(Math.min(maxVolume, volume)),
+            value: String(volume),
         };
     }
     if ([...new Set(volume)].length === 1) {
@@ -58,7 +57,6 @@ const ffmpegVolumeExpression = ({ volume, fps, trimLeft, allowAmplificationDurin
             volume: volume[0],
             fps,
             trimLeft,
-            allowAmplificationDuringRender,
         });
     }
     // A 1 sec video with frames 0-29 would mean that
@@ -73,7 +71,7 @@ const ffmpegVolumeExpression = ({ volume, fps, trimLeft, allowAmplificationDurin
     const volumeMap = {};
     paddedVolume.forEach((baseVolume, frame) => {
         // Adjust volume based on how many other tracks have not yet finished
-        const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(Math.min(maxVolume, baseVolume));
+        const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(baseVolume);
         if (!volumeMap[actualVolume]) {
             volumeMap[actualVolume] = [];
         }

package/dist/assets/types.d.ts

@@ -6,7 +6,6 @@ export type UnsafeAsset = Omit<AudioOrVideoAsset, 'frame' | 'id' | 'volume' | 'm
     volume: number[];
     id: string;
     playbackRate: number;
-    allowAmplificationDuringRender: boolean;
     toneFrequency: number | null;
 };
 export type AssetVolume = number | number[];

package/dist/can-concat-seamlessly.d.ts

@@ -0,0 +1,4 @@
+import type { Codec } from './codec';
+import type { AudioCodec } from './options/audio-codec';
+export declare const canConcatAudioSeamlessly: (audioCodec: AudioCodec | null, chunkDurationInFrames: number) => boolean;
+export declare const canConcatVideoSeamlessly: (codec: Codec) => codec is "h264";

package/dist/can-concat-seamlessly.js

@@ -0,0 +1,17 @@
+"use strict";
+// Cannot do WAV yet, because currently assumes AAC in+outpoint
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canConcatVideoSeamlessly = exports.canConcatAudioSeamlessly = void 0;
+const canConcatAudioSeamlessly = (audioCodec, chunkDurationInFrames) => {
+    // Rendering a chunk that is too small generates too much overhead
+    // and is currently buggy
+    if (chunkDurationInFrames <= 4) {
+        return false;
+    }
+    return audioCodec === 'aac';
+};
+exports.canConcatAudioSeamlessly = canConcatAudioSeamlessly;
+const canConcatVideoSeamlessly = (codec) => {
+    return codec === 'h264';
+};
+exports.canConcatVideoSeamlessly = canConcatVideoSeamlessly;

package/dist/client.d.ts

@@ -412,7 +412,7 @@ export declare const BrowserSafeApis: {
         webhookCustomDataOption: {
             name: string;
             cliFlag: "webhook-custom-data";
-            description: (type: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+            description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
             ssrName: "customData";
             docLink: string;
             type: Record<string, unknown> | null;
@@ -825,7 +825,7 @@ export declare const BrowserSafeApis: {
         metadataOption: {
             name: string;
             cliFlag: "metadata";
-            description: (mode: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
+            description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
             docLink: string;
             type: import("./options/metadata").Metadata;
             getValue: ({ commandLine }: {

package/dist/combine-chunks.d.ts

@@ -0,0 +1,39 @@
+import type { Codec } from './codec';
+import type { FrameRange } from './frame-range';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+import type { AudioCodec } from './options/audio-codec';
+type MandatoryCombineChunksOptions = {
+    outputLocation: string;
+    audioFiles: string[];
+    codec: Codec;
+    videoFiles: string[];
+    fps: number;
+    framesPerChunk: number;
+    preferLossless: boolean;
+    compositionDurationInFrames: number;
+};
+type CombineChunksProgress = {
+    totalProgress: number;
+    frames: number;
+};
+export type CombineChunksOnProgress = (options: CombineChunksProgress) => void;
+type OptionalCombineChunksOptions = {
+    onProgress: CombineChunksOnProgress;
+    audioBitrate: string | null;
+    numberOfGifLoops: number | null;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    audioCodec: AudioCodec | null;
+    cancelSignal: CancelSignal | undefined;
+    metadata: Record<string, string> | null;
+    frameRange: FrameRange | null;
+    everyNthFrame: number;
+};
+type AllCombineChunksOptions = MandatoryCombineChunksOptions & OptionalCombineChunksOptions;
+export type CombineChunksOptions = MandatoryCombineChunksOptions & Partial<OptionalCombineChunksOptions>;
+export declare const internalCombineChunks: ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, }: AllCombineChunksOptions & {
+    indent: boolean;
+}) => Promise<void>;
+export declare const combineChunks: (options: CombineChunksOptions) => Promise<void>;
+export {};

package/dist/{combine-videos.js → combine-chunks.js}

@@ -1,17 +1,21 @@
 "use strict";
 // Combine multiple video chunks, useful for decentralized rendering
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.combineChunks = void 0;
+exports.combineChunks = exports.internalCombineChunks = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const can_concat_seamlessly_1 = require("./can-concat-seamlessly");
 const combine_audio_1 = require("./combine-audio");
 const combine_video_streams_1 = require("./combine-video-streams");
 const combine_video_streams_seamlessly_1 = require("./combine-video-streams-seamlessly");
+const get_duration_from_frame_range_1 = require("./get-duration-from-frame-range");
 const get_extension_from_codec_1 = require("./get-extension-from-codec");
+const get_frame_to_render_1 = require("./get-frame-to-render");
 const is_audio_codec_1 = require("./is-audio-codec");
 const logger_1 = require("./logger");
 const mux_video_and_audio_1 = require("./mux-video-and-audio");
 const audio_codec_1 = require("./options/audio-codec");
+const tmp_dir_1 = require("./tmp-dir");
 const truthy_1 = require("./truthy");
 const codecSupportsFastStart = {
     'h264-mkv': false,
@@ -26,17 +30,28 @@ const codecSupportsFastStart = {
     vp9: false,
     wav: false,
 };
-const combineChunks = async ({ files, filelistDir, output, onProgress, numberOfFrames, codec, fps, numberOfGifLoops, resolvedAudioCodec, audioBitrate, indent, logLevel, chunkDurationInSeconds, binariesDirectory, cancelSignal, seamlessAudio, seamlessVideo, muted, metadata, }) => {
-    const shouldCreateAudio = resolvedAudioCodec !== null && !muted;
+const REMOTION_FILELIST_TOKEN = 'remotion-filelist';
+const internalCombineChunks = async ({ outputLocation: output, onProgress, codec, fps, numberOfGifLoops, audioBitrate, indent, logLevel, binariesDirectory, cancelSignal, metadata, audioFiles, videoFiles, framesPerChunk, audioCodec, preferLossless, everyNthFrame, frameRange, compositionDurationInFrames, }) => {
+    const filelistDir = (0, tmp_dir_1.tmpDir)(REMOTION_FILELIST_TOKEN);
     const shouldCreateVideo = !(0, is_audio_codec_1.isAudioCodec)(codec);
+    const resolvedAudioCodec = (0, audio_codec_1.resolveAudioCodec)({
+        setting: audioCodec,
+        codec,
+        preferLossless,
+        separateAudioTo: null,
+    });
+    const shouldCreateAudio = resolvedAudioCodec !== null && audioFiles.length > 0;
+    const seamlessVideo = (0, can_concat_seamlessly_1.canConcatVideoSeamlessly)(codec);
+    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(resolvedAudioCodec, framesPerChunk);
+    const realFrameRange = (0, get_frame_to_render_1.getRealFrameRange)(compositionDurationInFrames, frameRange);
+    const numberOfFrames = (0, get_duration_from_frame_range_1.getFramesToRender)(realFrameRange, everyNthFrame).length;
     const videoOutput = shouldCreateVideo
         ? (0, node_path_1.join)(filelistDir, `video.${(0, get_extension_from_codec_1.getFileExtensionFromCodec)(codec, resolvedAudioCodec)}`)
         : null;
     const audioOutput = shouldCreateAudio
         ? (0, node_path_1.join)(filelistDir, `audio.${(0, audio_codec_1.getExtensionFromAudioCodec)(resolvedAudioCodec)}`)
         : null;
-    const audioFiles = files.filter((f) => f.endsWith('audio'));
-    const videoFiles = files.filter((f) => f.endsWith('video'));
+    const chunkDurationInSeconds = framesPerChunk / fps;
     let concatenatedAudio = 0;
     let concatenatedVideo = 0;
     let muxing = 0;
@@ -45,7 +60,10 @@ const combineChunks = async ({ files, filelistDir, output, onProgress, numberOfF
             (shouldCreateVideo ? numberOfFrames : 0) +
             numberOfFrames;
         const actualProgress = concatenatedAudio + concatenatedVideo + muxing;
-        onProgress((actualProgress / totalFrames) * numberOfFrames);
+        onProgress({
+            frames: (actualProgress / totalFrames) * numberOfFrames,
+            totalProgress: actualProgress / totalFrames,
+        });
     };
     logger_1.Log.verbose({ indent, logLevel }, `Combining chunks, audio = ${shouldCreateAudio === false
         ? 'no'
@@ -117,7 +135,7 @@ const combineChunks = async ({ files, filelistDir, output, onProgress, numberOfF
             addFaststart: codecSupportsFastStart[codec],
             metadata,
         });
-        onProgress(numberOfFrames);
+        onProgress({ totalProgress: 1, frames: numberOfFrames });
         (0, node_fs_1.rmSync)(filelistDir, { recursive: true });
     }
     catch (err) {
@@ -125,4 +143,29 @@ const combineChunks = async ({ files, filelistDir, output, onProgress, numberOfF
         throw err;
     }
 };
+exports.internalCombineChunks = internalCombineChunks;
+const combineChunks = (options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    return (0, exports.internalCombineChunks)({
+        audioBitrate: (_a = options.audioBitrate) !== null && _a !== void 0 ? _a : null,
+        numberOfGifLoops: (_b = options.numberOfGifLoops) !== null && _b !== void 0 ? _b : null,
+        indent: false,
+        logLevel: (_c = options.logLevel) !== null && _c !== void 0 ? _c : 'info',
+        binariesDirectory: (_d = options.binariesDirectory) !== null && _d !== void 0 ? _d : null,
+        cancelSignal: options.cancelSignal,
+        metadata: (_e = options.metadata) !== null && _e !== void 0 ? _e : null,
+        audioCodec: (_f = options.audioCodec) !== null && _f !== void 0 ? _f : null,
+        preferLossless: options.preferLossless,
+        audioFiles: options.audioFiles,
+        codec: options.codec,
+        fps: options.fps,
+        framesPerChunk: options.framesPerChunk,
+        outputLocation: options.outputLocation,
+        onProgress: (_g = options.onProgress) !== null && _g !== void 0 ? _g : (() => { }),
+        videoFiles: options.videoFiles,
+        everyNthFrame: (_h = options.everyNthFrame) !== null && _h !== void 0 ? _h : 1,
+        frameRange: (_j = options.frameRange) !== null && _j !== void 0 ? _j : null,
+        compositionDurationInFrames: options.compositionDurationInFrames,
+    });
+};
 exports.combineChunks = combineChunks;

package/dist/esm/error-handling.mjs

@@ -321,6 +321,14 @@ var printUsefulErrorMessage = (err, logLevel, indent) => {
     Log.info({ indent, logLevel }, "\uD83D\uDCA1 On Lambda, one reason this could happen is that Chrome is rejecting an asset to be loaded when it is running low on disk space.");
     Log.info({ indent, logLevel }, "Try increasing the disk size of your Lambda function.");
   }
+  if (err.message.includes("Invalid value specified for cpu")) {
+    Log.info({ indent, logLevel });
+    Log.info({ indent, logLevel }, "\uD83D\uDCA1 This error indicates that your GCP account does have a limit. Try setting `--maxInstances=5` / `maxInstances: 5` when deploying this service.");
+    Log.info({
+      indent,
+      logLevel
+    });
+  }
 };
 
 // src/wrap-with-error-handling.ts