@remotion/renderer 4.0.0-lambda.1 → 4.0.0-newpathfunctions.13

package/dist/assets/download-map.js

@@ -0,0 +1,77 @@
+"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.cleanDownloadMap = exports.makeDownloadMap = void 0;
+const fs_1 = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const delete_directory_1 = require("../delete-directory");
+const tmp_dir_1 = require("../tmp-dir");
+const makeAndReturn = (dir, name) => {
+    const p = path_1.default.join(dir, name);
+    (0, fs_1.mkdirSync)(p);
+    return p;
+};
+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 makeDownloadMap = () => {
+    const dir = (0, tmp_dir_1.tmpDir)(packageJson
+        ? `remotion-v${packageJson.version.replace(/\./g, '-')}-assets`
+        : 'remotion-assets');
+    return {
+        isDownloadingMap: {},
+        hasBeenDownloadedMap: {},
+        listeners: {},
+        lastFrameMap: {},
+        isBeyondLastFrameMap: {},
+        ensureFileHasPresentationTimestamp: {},
+        isVp9VideoCache: {},
+        videoDurationResultCache: {},
+        durationOfAssetCache: {},
+        id: String(Math.random()),
+        assetDir: dir,
+        downloadDir: makeAndReturn(dir, 'remotion-assets-dir'),
+        complexFilter: makeAndReturn(dir, 'remotion-complex-filter'),
+        preEncode: makeAndReturn(dir, 'pre-encode'),
+        audioMixing: makeAndReturn(dir, 'remotion-audio-mixing'),
+        audioPreprocessing: makeAndReturn(dir, 'remotion-audio-preprocessing'),
+        stitchFrames: makeAndReturn(dir, 'remotion-stitch-temp-dir'),
+        compositingDir: makeAndReturn(dir, 'remotion-compositing-temp-dir'),
+        compositorCache: {},
+    };
+};
+exports.makeDownloadMap = makeDownloadMap;
+const cleanDownloadMap = async (downloadMap) => {
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.downloadDir);
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.complexFilter);
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.compositingDir);
+    // Assets dir must be last since the others are contained
+    await (0, delete_directory_1.deleteDirectory)(downloadMap.assetDir);
+};
+exports.cleanDownloadMap = cleanDownloadMap;

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

@@ -1,13 +1,13 @@
-import { AssetVolume } from './types';
+import type { AssetVolume } from './types';
 declare type FfmpegEval = 'once' | 'frame';
 declare type FfmpegVolumeExpression = {
     eval: FfmpegEval;
     value: string;
 };
-export declare const ffmpegVolumeExpression: ({ volume, startInVideo, fps, trimLeft, }: {
+export declare const ffmpegVolumeExpression: ({ volume, fps, trimLeft, allowAmplificationDuringRender, }: {
     volume: AssetVolume;
-    startInVideo: number;
     trimLeft: number;
     fps: number;
+    allowAmplificationDuringRender: boolean;
 }) => FfmpegVolumeExpression;
 export {};

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

@@ -43,21 +43,22 @@ const ffmpegBuildVolumeExpression = (arr, delay, fps) => {
     const [volume, frames] = first;
     return ffmpegIfOrElse(ffmpegIsOneOfFrames({ frames, trimLeft: delay, fps }), String(volume), ffmpegBuildVolumeExpression(rest, delay, fps));
 };
-const ffmpegVolumeExpression = ({ volume, startInVideo, fps, trimLeft, }) => {
+const ffmpegVolumeExpression = ({ volume, fps, trimLeft, allowAmplificationDuringRender, }) => {
+    const maxVolume = allowAmplificationDuringRender ? Infinity : 1;
     // 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(1, volume)),
+            value: String(Math.min(maxVolume, volume)),
         };
     }
     if ([...new Set(volume)].length === 1) {
         return (0, exports.ffmpegVolumeExpression)({
             volume: volume[0],
-            startInVideo,
             fps,
             trimLeft,
+            allowAmplificationDuringRender,
         });
     }
     // A 1 sec video with frames 0-29 would mean that
@@ -72,11 +73,11 @@ const ffmpegVolumeExpression = ({ volume, startInVideo, fps, trimLeft, }) => {
     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(1, baseVolume));
+        const actualVolume = (0, round_volume_to_avoid_stack_overflow_1.roundVolumeToAvoidStackOverflow)(Math.min(maxVolume, baseVolume));
         if (!volumeMap[actualVolume]) {
             volumeMap[actualVolume] = [];
         }
-        volumeMap[actualVolume].push(frame + startInVideo);
+        volumeMap[actualVolume].push(frame);
     });
     // Sort the map so that the most common volume is last
     // this is going to be the else statement so the expression is short

package/dist/assets/flatten-volume-array.d.ts

@@ -1,3 +1,3 @@
-import { AssetVolume, MediaAsset } from './types';
+import type { AssetVolume, MediaAsset } from './types';
 export declare const flattenVolumeArray: (volume: AssetVolume) => AssetVolume;
 export declare const convertAssetToFlattenedVolume: (asset: MediaAsset) => MediaAsset;

package/dist/assets/get-audio-channels.d.ts

@@ -1,7 +1,3 @@
-import { FfmpegExecutable } from 'remotion';
-declare type Result = {
-    channels: number;
-    duration: number | null;
-};
-export declare const getAudioChannelsAndDuration: (src: string, ffprobeExecutable: FfmpegExecutable) => Promise<Result>;
-export {};
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { AudioChannelsAndDurationResultCache, DownloadMap } from './download-map';
+export declare const getAudioChannelsAndDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<AudioChannelsAndDurationResultCache>;

package/dist/assets/get-audio-channels.js

@@ -5,12 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioChannelsAndDuration = void 0;
 const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("../ffmpeg-flags");
 const p_limit_1 = require("../p-limit");
-const durationOfAssetCache = {};
 const limit = (0, p_limit_1.pLimit)(1);
-async function getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable) {
-    if (durationOfAssetCache[src]) {
-        return durationOfAssetCache[src];
+async function getAudioChannelsAndDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.durationOfAssetCache[src]) {
+        return downloadMap.durationOfAssetCache[src];
     }
     const args = [
         ['-v', 'error'],
@@ -20,17 +20,17 @@ async function getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable) {
     ]
         .reduce((acc, val) => acc.concat(val), [])
         .filter(Boolean);
-    const task = await (0, execa_1.default)(ffprobeExecutable !== null && ffprobeExecutable !== void 0 ? ffprobeExecutable : 'ffprobe', args);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
     const channels = task.stdout.match(/channels=([0-9]+)/);
     const duration = task.stdout.match(/duration=([0-9.]+)/);
     const result = {
         channels: channels ? parseInt(channels[1], 10) : 0,
         duration: duration ? parseFloat(duration[1]) : null,
     };
-    durationOfAssetCache[src] = result;
+    downloadMap.durationOfAssetCache[src] = result;
     return result;
 }
-const getAudioChannelsAndDuration = (src, ffprobeExecutable) => {
-    return limit(() => getAudioChannelsAndDurationUnlimited(src, ffprobeExecutable));
+const getAudioChannelsAndDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getAudioChannelsAndDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
 };
 exports.getAudioChannelsAndDuration = getAudioChannelsAndDuration;

package/dist/assets/get-video-stream-duration.d.ts

@@ -0,0 +1,9 @@
+import type { FfmpegExecutable } from '../ffmpeg-executable';
+import type { DownloadMap, VideoDurationResult } from './download-map';
+export declare const parseVideoStreamDuration: (stdout: string) => VideoDurationResult;
+export declare function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }: {
+    src: string;
+    ffprobeExecutable: FfmpegExecutable;
+    remotionRoot: string;
+}): Promise<VideoDurationResult>;
+export declare const getVideoStreamDuration: (downloadMap: DownloadMap, src: string, ffprobeExecutable: FfmpegExecutable, remotionRoot: string) => Promise<VideoDurationResult>;

package/dist/assets/get-video-stream-duration.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoStreamDuration = exports.getVideoStreamDurationwithoutCache = exports.parseVideoStreamDuration = void 0;
+const execa_1 = __importDefault(require("execa"));
+const ffmpeg_flags_1 = require("../ffmpeg-flags");
+const p_limit_1 = require("../p-limit");
+const limit = (0, p_limit_1.pLimit)(1);
+const parseAlternativeDuration = (stdout) => {
+    const webmDuration = stdout.match(/TAG:DURATION=([0-9.]+):([0-9.]+):([0-9.]+)/);
+    if (!webmDuration) {
+        return null;
+    }
+    const [, hours, minutes, seconds] = webmDuration;
+    const hoursAsNumber = Number(hours);
+    if (Number.isNaN(hoursAsNumber)) {
+        return null;
+    }
+    const minutesAsNumber = Number(minutes);
+    if (Number.isNaN(minutesAsNumber)) {
+        return null;
+    }
+    const secondsAsNumber = Number(seconds);
+    if (Number.isNaN(secondsAsNumber)) {
+        return null;
+    }
+    return secondsAsNumber + minutesAsNumber * 60 + hoursAsNumber * 3600;
+};
+const parseVideoStreamDuration = (stdout) => {
+    const duration = stdout.match(/duration=([0-9.]+)/);
+    const alternativeDuration = parseAlternativeDuration(stdout);
+    const fps = stdout.match(/r_frame_rate=([0-9.]+)\/([0-9.]+)/);
+    const result = {
+        duration: duration ? parseFloat(duration[1]) : alternativeDuration,
+        fps: fps ? parseInt(fps[1], 10) / parseInt(fps[2], 10) : null,
+    };
+    return result;
+};
+exports.parseVideoStreamDuration = parseVideoStreamDuration;
+async function getVideoStreamDurationwithoutCache({ src, ffprobeExecutable, remotionRoot, }) {
+    const args = [
+        ['-v', 'error'],
+        ['-select_streams', 'v:0'],
+        ['-show_entries', 'stream'],
+        [src],
+    ]
+        .reduce((acc, val) => acc.concat(val), [])
+        .filter(Boolean);
+    const task = await (0, execa_1.default)(await (0, ffmpeg_flags_1.getExecutableBinary)(ffprobeExecutable, remotionRoot, 'ffprobe'), args);
+    const result = (0, exports.parseVideoStreamDuration)(task.stdout);
+    return result;
+}
+exports.getVideoStreamDurationwithoutCache = getVideoStreamDurationwithoutCache;
+async function getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot) {
+    if (downloadMap.videoDurationResultCache[src]) {
+        return downloadMap.videoDurationResultCache[src];
+    }
+    const result = await getVideoStreamDurationwithoutCache({
+        src,
+        ffprobeExecutable,
+        remotionRoot,
+    });
+    downloadMap.videoDurationResultCache[src] = result;
+    return result;
+}
+const getVideoStreamDuration = (downloadMap, src, ffprobeExecutable, remotionRoot) => {
+    return limit(() => getVideoStreamDurationUnlimited(downloadMap, src, ffprobeExecutable, remotionRoot));
+};
+exports.getVideoStreamDuration = getVideoStreamDuration;

package/dist/assets/read-file.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readFile = void 0;
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
+const redirect_status_codes_1 = require("../redirect-status-codes");
 const getClient = (url) => {
     if (url.startsWith('https://')) {
         return https_1.default.get;
@@ -29,7 +30,7 @@ const readFile = async (url, redirectsSoFar = 0) => {
         throw new Error(`Too many redirects while downloading ${url}`);
     }
     const file = await readFileWithoutRedirect(url);
-    if (file.statusCode === 302 || file.statusCode === 301) {
+    if (redirect_status_codes_1.redirectStatusCodes.includes(file.statusCode)) {
         if (!file.headers.location) {
             throw new Error(`Received a status code ${file.statusCode} but no "Location" header while calling ${file.headers.location}`);
         }

package/dist/assets/types.d.ts

@@ -1,4 +1,4 @@
-import { TAsset } from 'remotion';
+import type { TAsset } from 'remotion';
 export declare type UnsafeAsset = Omit<TAsset, 'frame' | 'id' | 'volume' | 'mediaFrame'> & {
     startInVideo: number;
     duration: number | null;
@@ -6,6 +6,7 @@ export declare type UnsafeAsset = Omit<TAsset, 'frame' | 'id' | 'volume' | 'medi
     volume: number[];
     id: string;
     playbackRate: number;
+    allowAmplificationDuringRender: boolean;
 };
 export declare type AssetVolume = number | number[];
 export declare type MediaAsset = Omit<UnsafeAsset, 'duration' | 'volume'> & {

package/dist/browser/Browser.d.ts

@@ -13,165 +13,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/// <reference types="node" />
-import { ChildProcess } from 'child_process';
-import { Connection } from './Connection';
+import type { Page } from './BrowserPage';
+import type { Connection } from './Connection';
 import { EventEmitter } from './EventEmitter';
-import { Page } from './Page';
-import { Viewport } from './PuppeteerViewport';
+import type { Viewport } from './PuppeteerViewport';
 import { Target } from './Target';
-interface BrowserContextOptions {
-    /**
-     * Proxy server with optional port to use for all requests.
-     * Username and password can be set in `Page.authenticate`.
-     */
-    proxyServer?: string;
-    /**
-     * Bypass the proxy for the given semi-colon-separated list of hosts.
-     */
-    proxyBypassList?: string[];
-}
 declare type BrowserCloseCallback = () => Promise<void> | void;
 interface WaitForTargetOptions {
-    /**
-     * Maximum wait time in milliseconds. Pass `0` to disable the timeout.
-     * @defaultValue 30 seconds.
-     */
     timeout?: number;
 }
+export declare const enum BrowserEmittedEvents {
+    TargetChanged = "targetchanged",
+    TargetCreated = "targetcreated",
+    Closed = "closed",
+    ClosedSilent = "closed-silent"
+}
 export declare class Browser extends EventEmitter {
     #private;
-    static _create({ connection, contextIds, defaultViewport, process, closeCallback, }: {
+    static _create({ connection, contextIds, defaultViewport, closeCallback, }: {
         connection: Connection;
         contextIds: string[];
         defaultViewport: Viewport;
-        process?: ChildProcess;
         closeCallback?: BrowserCloseCallback;
     }): Promise<Browser>;
+    connection: Connection;
     get _targets(): Map<string, Target>;
-    constructor(connection: Connection, contextIds: string[], defaultViewport: Viewport, process?: ChildProcess, closeCallback?: BrowserCloseCallback);
-    /**
-     * The spawned browser process. Returns `null` if the browser instance was created with
-     * {@link Puppeteer.connect}.
-     */
-    process(): ChildProcess | null;
-    /**
-     * Creates a new incognito browser context. This won't share cookies/cache with other
-     * browser contexts.
-     *
-     * @example
-     * ```js
-     * (async () => {
-     *  const browser = await puppeteer.launch();
-     *   // Create a new incognito browser context.
-     *   const context = await browser.createIncognitoBrowserContext();
-     *   // Create a new page in a pristine context.
-     *   const page = await context.newPage();
-     *   // Do stuff
-     *   await page.goto('https://example.com');
-     * })();
-     * ```
-     */
-    createIncognitoBrowserContext(options?: BrowserContextOptions): Promise<BrowserContext>;
-    /**
-     * Returns an array of all open browser contexts. In a newly created browser, this will
-     * return a single instance of {@link BrowserContext}.
-     */
+    constructor(connection: Connection, contextIds: string[], defaultViewport: Viewport, closeCallback?: BrowserCloseCallback);
     browserContexts(): BrowserContext[];
-    /**
-     * Returns the default browser context. The default browser context cannot be closed.
-     */
-    defaultBrowserContext(): BrowserContext;
-    _disposeContext(contextId?: string): Promise<void>;
-    /**
-     * The browser websocket endpoint which can be used as an argument to
-     * {@link Puppeteer.connect}.
-     *
-     * @returns The Browser websocket url.
-     *
-     * @remarks
-     *
-     * The format is `ws://${host}:${port}/devtools/browser/<id>`.
-     *
-     * You can find the `webSocketDebuggerUrl` from `http://${host}:${port}/json/version`.
-     * Learn more about the
-     * {@link https://chromedevtools.github.io/devtools-protocol | devtools protocol} and
-     * the {@link
-     * https://chromedevtools.github.io/devtools-protocol/#how-do-i-access-the-browser-target
-     * | browser endpoint}.
-     */
-    wsEndpoint(): string;
-    /**
-     * Promise which resolves to a new {@link Page} object. The Page is created in
-     * a default browser context.
-     */
     newPage(): Promise<Page>;
     _createPageInContext(contextId?: string): Promise<Page>;
-    /**
-     * All active targets inside the Browser. In case of multiple browser contexts, returns
-     * an array with all the targets in all browser contexts.
-     */
     targets(): Target[];
-    /**
-     * The target associated with the browser.
-     */
-    target(): Target;
-    /**
-     * Searches for a target in all browser contexts.
-     *
-     * @param predicate - A function to be run for every target.
-     * @returns The first target found that matches the `predicate` function.
-     *
-     * @example
-     *
-     * An example of finding a target for a page opened via `window.open`:
-     * ```js
-     * await page.evaluate(() => window.open('https://www.example.com/'));
-     * const newWindowTarget = await browser.waitForTarget(target => target.url() === 'https://www.example.com/');
-     * ```
-     */
     waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
-    /**
-     * An array of all open pages inside the Browser.
-     *
-     * @remarks
-     *
-     * In case of multiple browser contexts, returns an array with all the pages in all
-     * browser contexts. Non-visible pages, such as `"background_page"`, will not be listed
-     * here. You can find them using {@link Target.page}.
-     */
     pages(): Promise<Page[]>;
-    /**
-     * A string representing the browser name and version.
-     *
-     * @remarks
-     *
-     * For headless Chromium, this is similar to `HeadlessChrome/61.0.3153.0`. For
-     * non-headless, this is similar to `Chrome/61.0.3153.0`.
-     *
-     * The format of browser.version() might change with future releases of Chromium.
-     */
-    version(): Promise<string>;
-    /**
-     * The browser's original user agent. Pages can override the browser user agent with
-     * {@link Page.setUserAgent}.
-     */
-    userAgent(): Promise<string>;
-    /**
-     * Closes Chromium and all of its pages (if any were opened). The {@link Browser} object
-     * itself is considered to be disposed and cannot be used anymore.
-     */
-    close(): Promise<void>;
-    /**
-     * Disconnects Puppeteer from the browser, but leaves the Chromium process running.
-     * After calling `disconnect`, the {@link Browser} object is considered disposed and
-     * cannot be used anymore.
-     */
+    close(silent: boolean): Promise<void>;
     disconnect(): void;
-    /**
-     * Indicates that the browser is connected.
-     */
-    isConnected(): boolean;
 }
 export declare class BrowserContext extends EventEmitter {
     #private;
@@ -181,29 +56,7 @@ export declare class BrowserContext extends EventEmitter {
         timeout?: number;
     }): Promise<Target>;
     pages(): Promise<Page[]>;
-    /**
-     * Returns whether BrowserContext is incognito.
-     * The default browser context is the only non-incognito browser context.
-     *
-     * @remarks
-     * The default browser context cannot be closed.
-     */
-    isIncognito(): boolean;
-    /**
-     * Creates a new page in the browser context.
-     */
     newPage(): Promise<Page>;
-    /**
-     * The browser this browser context belongs to.
-     */
     browser(): Browser;
-    /**
-     * Closes the browser context. All the targets that belong to the browser context
-     * will be closed.
-     *
-     * @remarks
-     * Only incognito browser contexts can be closed.
-     */
-    close(): Promise<void>;
 }
 export {};