@remotion/renderer 4.0.227 → 4.0.229

package/dist/assets/download-map.d.ts

@@ -33,9 +33,6 @@ export type DownloadMap = {
     stitchFrames: string;
     assetDir: string;
     compositingDir: string;
-    compositorCache: {
-        [key: string]: string;
-    };
     preventCleanup: () => void;
     allowCleanup: () => void;
     isPreventedFromCleanup: () => boolean;

package/dist/assets/download-map.js

@@ -61,7 +61,6 @@ const makeDownloadMap = () => {
         audioPreprocessing: makeAndReturn(dir, 'remotion-audio-preprocessing'),
         stitchFrames: makeAndReturn(dir, 'remotion-stitch-temp-dir'),
         compositingDir: makeAndReturn(dir, 'remotion-compositing-temp-dir'),
-        compositorCache: {},
         emitter: new offthread_video_server_1.OffthreadVideoServerEmitter(),
         preventCleanup: () => {
             prevented = true;

package/dist/client.d.ts

@@ -1,12 +1,14 @@
 export { AvailableOptions, TypeOfOption } from './options';
+export { HardwareAccelerationOption } from './options/hardware-acceleration';
 export declare const BrowserSafeApis: {
     getFileExtensionFromCodec: <T extends import("./codec").Codec>(codec: T, audioCodec: import("./options/audio-codec").AudioCodec | null) => import("./file-extensions").FileExtension;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "h264-ts", "gif"];
     validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
-    getDefaultCrfForCodec: (codec: import("./codec").Codec) => number;
+    getDefaultCrfForCodec: (codec: import("./codec").Codec) => number | null;
     getValidCrfRanges: (codec: import("./codec").Codec) => [number, number];
     proResProfileOptions: readonly ["4444-xq", "4444", "hq", "standard", "light", "proxy"];
     x264PresetOptions: readonly ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow", "placebo"];
+    hardwareAccelerationOptions: readonly ["disable", "if-possible", "required"];
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader", "vulkan", "angle-egl"];
     validPixelFormatsForCodec: (codec: import("./codec").Codec) => readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"] | ("yuv420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le")[];
@@ -392,7 +394,7 @@ export declare const BrowserSafeApis: {
         webhookCustomDataOption: {
             name: string;
             cliFlag: "webhook-custom-data";
-            description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
+            description: (type: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
             ssrName: "customData";
             docLink: string;
             type: Record<string, unknown> | null;
@@ -805,7 +807,7 @@ export declare const BrowserSafeApis: {
         metadataOption: {
             name: string;
             cliFlag: "metadata";
-            description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
+            description: (mode: "ssr" | "cli") => import("react/jsx-runtime").JSX.Element;
             docLink: string;
             type: import("./options/metadata").Metadata;
             getValue: ({ commandLine }: {
@@ -819,6 +821,21 @@ export declare const BrowserSafeApis: {
             setConfig: (newMetadata: import("./options/metadata").Metadata) => void;
             ssrName: string;
         };
+        hardwareAccelerationOption: {
+            name: string;
+            cliFlag: "hardware-acceleration";
+            description: () => string;
+            ssrName: string;
+            docLink: string;
+            type: import("./options/hardware-acceleration").HardwareAccelerationOption;
+            getValue: ({ commandLine }: {
+                commandLine: Record<string, unknown>;
+            }) => {
+                source: string;
+                value: "disable" | "if-possible" | "required";
+            };
+            setConfig: (value: import("./options/hardware-acceleration").HardwareAccelerationOption) => void;
+        };
     };
     validColorSpaces: readonly ["default", "bt709", "bt2020-ncl"];
     optionsMap: {
@@ -1136,6 +1153,21 @@ export declare const BrowserSafeApis: {
                 getValue: () => never;
                 setConfig: () => never;
             };
+            readonly hardwareAcceleration: {
+                name: string;
+                cliFlag: "hardware-acceleration";
+                description: () => string;
+                ssrName: string;
+                docLink: string;
+                type: import("./options/hardware-acceleration").HardwareAccelerationOption;
+                getValue: ({ commandLine }: {
+                    commandLine: Record<string, unknown>;
+                }) => {
+                    source: string;
+                    value: "disable" | "if-possible" | "required";
+                };
+                setConfig: (value: import("./options/hardware-acceleration").HardwareAccelerationOption) => void;
+            };
         };
         readonly stitchFramesToVideo: {
             readonly separateAudioTo: {
@@ -1156,6 +1188,21 @@ export declare const BrowserSafeApis: {
                 ssrName: string;
                 type: string | null;
             };
+            readonly hardwareAcceleration: {
+                name: string;
+                cliFlag: "hardware-acceleration";
+                description: () => string;
+                ssrName: string;
+                docLink: string;
+                type: import("./options/hardware-acceleration").HardwareAccelerationOption;
+                getValue: ({ commandLine }: {
+                    commandLine: Record<string, unknown>;
+                }) => {
+                    source: string;
+                    value: "disable" | "if-possible" | "required";
+                };
+                setConfig: (value: import("./options/hardware-acceleration").HardwareAccelerationOption) => void;
+            };
         };
         readonly renderStill: {
             readonly offthreadVideoCacheSizeInBytes: {

package/dist/client.js

@@ -14,6 +14,7 @@ const options_1 = require("./options");
 const audio_codec_1 = require("./options/audio-codec");
 const color_space_1 = require("./options/color-space");
 const gl_1 = require("./options/gl");
+const hardware_acceleration_1 = require("./options/hardware-acceleration");
 const options_map_1 = require("./options/options-map");
 const video_codec_1 = require("./options/video-codec");
 const x264_preset_1 = require("./options/x264-preset");
@@ -28,6 +29,7 @@ exports.BrowserSafeApis = {
     getValidCrfRanges: crf_1.getValidCrfRanges,
     proResProfileOptions: prores_profile_1.proResProfileOptions,
     x264PresetOptions: x264_preset_1.x264PresetOptions,
+    hardwareAccelerationOptions: hardware_acceleration_1.hardwareAccelerationOptions,
     validPixelFormats: pixel_format_1.validPixelFormats,
     validOpenGlRenderers: gl_1.validOpenGlRenderers,
     validPixelFormatsForCodec: pixel_format_1.validPixelFormatsForCodec,

package/dist/compositor/compose.d.ts

@@ -1,24 +1,4 @@
-import type { DownloadMap } from '../assets/download-map';
 import type { LogLevel } from '../log-level';
-import type { Compositor } from './compositor';
-import type { CompositorCommand, CompositorCommandSerialized, CompositorImageFormat, Layer } from './payloads';
-type CompositorInput = {
-    height: number;
-    width: number;
-    layers: Layer[];
-    imageFormat: CompositorImageFormat;
-};
-type ComposeInput = CompositorInput & {
-    output: string;
-    compositor: Compositor;
-};
+import type { CompositorCommand, CompositorCommandSerialized } from './payloads';
 export declare const serializeCommand: <Type extends keyof CompositorCommand>(command: Type, params: CompositorCommand[Type]) => CompositorCommandSerialized<Type>;
-export declare const composeWithoutCache: ({ height, width, layers, output, imageFormat, compositor, }: CompositorInput & {
-    output: string;
-    compositor: Compositor;
-}) => Promise<void>;
-export declare const compose: ({ height, width, layers, output, downloadMap, imageFormat, compositor, }: ComposeInput & {
-    downloadMap: DownloadMap;
-}) => Promise<void>;
 export declare const callCompositor: (payload: string, indent: boolean, logLevel: LogLevel, binariesDirectory: string | null) => Promise<void>;
-export {};

package/dist/compositor/compose.js

@@ -3,17 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callCompositor = exports.compose = exports.composeWithoutCache = exports.serializeCommand = void 0;
+exports.callCompositor = exports.serializeCommand = void 0;
 const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const get_executable_path_1 = require("./get-executable-path");
 const make_file_executable_1 = require("./make-file-executable");
 const make_nonce_1 = require("./make-nonce");
-const getCompositorHash = ({ ...input }) => {
-    return (0, node_crypto_1.createHash)('sha256').update(JSON.stringify(input)).digest('base64');
-};
 const serializeCommand = (command, params) => {
     return {
         nonce: (0, make_nonce_1.makeNonce)(),
@@ -24,33 +19,6 @@ const serializeCommand = (command, params) => {
     };
 };
 exports.serializeCommand = serializeCommand;
-const composeWithoutCache = async ({ height, width, layers, output, imageFormat, compositor, }) => {
-    await compositor.executeCommand('Compose', {
-        height,
-        width,
-        layers,
-        output,
-        output_format: imageFormat,
-    });
-};
-exports.composeWithoutCache = composeWithoutCache;
-const compose = async ({ height, width, layers, output, downloadMap, imageFormat, compositor, }) => {
-    const hash = getCompositorHash({ height, width, layers, imageFormat });
-    if (downloadMap.compositorCache[hash]) {
-        await (0, promises_1.copyFile)(downloadMap.compositorCache[hash], output);
-        return;
-    }
-    await (0, exports.composeWithoutCache)({
-        compositor,
-        height,
-        imageFormat,
-        layers,
-        output,
-        width,
-    });
-    downloadMap.compositorCache[hash] = output;
-};
-exports.compose = compose;
 const callCompositor = (payload, indent, logLevel, binariesDirectory) => {
     return new Promise((resolve, reject) => {
         const execPath = (0, get_executable_path_1.getExecutablePath)({

package/dist/compositor/payloads.d.ts

@@ -1,31 +1,3 @@
-export type Layer = {
-    type: 'PngImage';
-    params: {
-        src: string;
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-} | {
-    type: 'JpgImage';
-    params: {
-        src: string;
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-} | {
-    type: 'Solid';
-    params: {
-        fill: [number, number, number, number];
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-};
 export type CompositorImageFormat = 'Png' | 'Jpeg';
 export type VideoMetadata = {
     fps: number;
@@ -53,13 +25,6 @@ export type GetSilentPartsResponse = GetSilentPartsResponseRust & {
     audibleParts: SilentParts;
 };
 export type CompositorCommand = {
-    Compose: {
-        output: string;
-        width: number;
-        height: number;
-        layers: Layer[];
-        output_format: CompositorImageFormat;
-    };
     ExtractFrame: {
         src: string;
         original_src: string;

package/dist/crf.d.ts

@@ -1,11 +1,13 @@
+import type { HardwareAccelerationOption } from './client';
 import type { Codec } from './codec';
 export type Crf = number | undefined;
-export declare const getDefaultCrfForCodec: (codec: Codec) => number;
+export declare const getDefaultCrfForCodec: (codec: Codec) => number | null;
 export declare const getValidCrfRanges: (codec: Codec) => [number, number];
-export declare const validateQualitySettings: ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, }: {
+export declare const validateQualitySettings: ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }: {
     crf: unknown;
     codec: Codec;
     videoBitrate: string | null;
     encodingMaxRate: string | null;
     encodingBufferSize: string | null;
+    hardwareAcceleration: HardwareAccelerationOption;
 }) => string[];

package/dist/crf.js

@@ -7,13 +7,13 @@ const defaultCrfMap = {
     h265: 23,
     vp8: 9,
     vp9: 28,
-    prores: 0,
-    gif: 0,
+    prores: null,
+    gif: null,
     'h264-mkv': 18,
     'h264-ts': 18,
-    aac: 0,
-    mp3: 0,
-    wav: 0,
+    aac: null,
+    mp3: null,
+    wav: null,
 };
 const getDefaultCrfForCodec = (codec) => {
     const val = defaultCrfMap[codec];
@@ -44,10 +44,13 @@ const getValidCrfRanges = (codec) => {
     return val;
 };
 exports.getValidCrfRanges = getValidCrfRanges;
-const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, }) => {
+const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }) => {
     if (crf && videoBitrate) {
         throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
     }
+    if (crf && hardwareAcceleration === 'required') {
+        throw new Error('"crf" option is not supported with hardware acceleration');
+    }
     if (encodingMaxRate && !encodingBufferSize) {
         throw new Error('"encodingMaxRate" can not be set without also setting "encodingBufferSize".');
     }
@@ -68,6 +71,9 @@ const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, en
     }
     if (crf === null || typeof crf === 'undefined') {
         const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
+        if (actualCrf === null) {
+            return [...bufSizeArray, ...maxRateArray];
+        }
         return ['-crf', String(actualCrf), ...bufSizeArray, ...maxRateArray];
     }
     if (typeof crf !== 'number') {

package/dist/ffmpeg-args.d.ts

@@ -1,8 +1,10 @@
+import type { HardwareAccelerationOption } from './client';
 import type { Codec } from './codec';
+import type { LogLevel } from './log-level';
 import { type ColorSpace } from './options/color-space';
 import type { X264Preset } from './options/x264-preset';
 import type { PixelFormat } from './pixel-format';
-export declare const generateFfmpegArgs: ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, colorSpace, }: {
+export declare const generateFfmpegArgs: ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, colorSpace, hardwareAcceleration, indent, logLevel, }: {
     hasPreencoded: boolean;
     proResProfileName: string | null;
     pixelFormat: PixelFormat;
@@ -13,4 +15,7 @@ export declare const generateFfmpegArgs: ({ hasPreencoded, proResProfileName, pi
     encodingMaxRate: string | null;
     encodingBufferSize: string | null;
     colorSpace: ColorSpace | null;
+    hardwareAcceleration: HardwareAccelerationOption;
+    indent: boolean;
+    logLevel: LogLevel;
 }) => string[][];

package/dist/ffmpeg-args.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFfmpegArgs = void 0;
 const crf_1 = require("./crf");
 const get_codec_name_1 = require("./get-codec-name");
+const logger_1 = require("./logger");
 const color_space_1 = require("./options/color-space");
 const truthy_1 = require("./truthy");
-const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, }) => {
+const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }) => {
     if (hasPreencoded || codec === 'gif') {
         return [];
     }
@@ -22,14 +23,21 @@ const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat,
             codec,
             encodingMaxRate,
             encodingBufferSize,
+            hardwareAcceleration,
         }),
     ].filter(truthy_1.truthy);
 };
-const generateFfmpegArgs = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, colorSpace, }) => {
-    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
-    if (encoderName === null) {
-        throw new TypeError('encoderName is null: ' + JSON.stringify(codec));
+const generateFfmpegArgs = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, colorSpace, hardwareAcceleration, indent, logLevel, }) => {
+    const encoderSettings = (0, get_codec_name_1.getCodecName)(codec, hardwareAcceleration === 'required' ||
+        hardwareAcceleration === 'if-possible');
+    if (encoderSettings === null) {
+        throw new TypeError(`encoderSettings is null: ${JSON.stringify(codec)} (hwaccel = ${hardwareAcceleration})`);
     }
+    const { encoderName, hardwareAccelerated } = encoderSettings;
+    if (!hardwareAccelerated && hardwareAcceleration === 'required') {
+        throw new Error(`Codec ${codec} does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+    }
+    logger_1.Log.verbose({ indent, logLevel, tag: 'stitchFramesToVideo()' }, `Encoder: ${encoderName}, hardware accelerated: ${hardwareAccelerated}`);
     const resolvedColorSpace = colorSpace !== null && colorSpace !== void 0 ? colorSpace : color_space_1.DEFAULT_COLOR_SPACE;
     const colorSpaceOptions = resolvedColorSpace === 'bt709'
         ? [
@@ -74,6 +82,7 @@ const generateFfmpegArgs = ({ hasPreencoded, proResProfileName, pixelFormat, x26
             encodingMaxRate,
             encodingBufferSize,
             x264Preset,
+            hardwareAcceleration,
         }),
     ].filter(truthy_1.truthy);
 };

package/dist/get-codec-name.d.ts

@@ -1,2 +1,6 @@
 import type { Codec } from './codec';
-export declare const getCodecName: (codec: Codec) => string | null;
+export type CodecSettings = {
+    encoderName: string;
+    hardwareAccelerated: boolean;
+};
+export declare const getCodecName: (codec: Codec, preferredHwAcceleration: boolean) => CodecSettings | null;

package/dist/get-codec-name.js

@@ -1,20 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCodecName = void 0;
-const map = {
-    h264: 'libx264',
-    h265: 'libx265',
-    vp8: 'libvpx',
-    vp9: 'libvpx-vp9',
-    prores: 'prores_ks',
-    gif: 'gif',
-    mp3: null,
-    aac: null,
-    wav: null,
-    'h264-mkv': 'libx264',
-    'h264-ts': 'libx264',
-};
-const getCodecName = (codec) => {
-    return map[codec];
+const getCodecName = (codec, preferredHwAcceleration) => {
+    if (codec === 'prores') {
+        if (preferredHwAcceleration && process.platform === 'darwin') {
+            return { encoderName: 'prores_videotoolbox', hardwareAccelerated: true };
+        }
+        return { encoderName: 'prores_ks', hardwareAccelerated: false };
+    }
+    if (codec === 'h264') {
+        return { encoderName: 'libx264', hardwareAccelerated: false };
+    }
+    if (codec === 'h265') {
+        return { encoderName: 'libx265', hardwareAccelerated: false };
+    }
+    if (codec === 'vp8') {
+        return { encoderName: 'libvpx', hardwareAccelerated: false };
+    }
+    if (codec === 'vp9') {
+        return { encoderName: 'libvpx-vp9', hardwareAccelerated: false };
+    }
+    if (codec === 'gif') {
+        return { encoderName: 'gif', hardwareAccelerated: false };
+    }
+    if (codec === 'mp3') {
+        return null;
+    }
+    if (codec === 'aac') {
+        return null;
+    }
+    if (codec === 'wav') {
+        return null;
+    }
+    if (codec === 'h264-mkv') {
+        return { encoderName: 'libx264', hardwareAccelerated: false };
+    }
+    if (codec === 'h264-ts') {
+        return { encoderName: 'libx264', hardwareAccelerated: false };
+    }
+    throw new Error(`Could not get codec for ${codec}`);
 };
 exports.getCodecName = getCodecName;

package/dist/index.d.ts

@@ -139,7 +139,7 @@ export declare const RenderInternals: {
     validPixelFormats: readonly ["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"];
     DEFAULT_BROWSER: "chrome";
     validateFrameRange: (frameRange: import("./frame-range").FrameRange | null) => void;
-    DEFAULT_OPENGL_RENDERER: "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
+    DEFAULT_OPENGL_RENDERER: "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
     validateOpenGlRenderer: (option: unknown) => import("./options/gl").OpenGlRenderer | null;
     validCodecs: readonly ["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "h264-ts", "gif"];
     DEFAULT_PIXEL_FORMAT: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
@@ -352,8 +352,8 @@ export declare const RenderInternals: {
     }) => execa.ExecaChildProcess<string>;
     validStillImageFormats: readonly ["png", "jpeg", "pdf", "webp"];
     validVideoImageFormats: readonly ["png", "jpeg", "none"];
-    DEFAULT_STILL_IMAGE_FORMAT: "png" | "jpeg" | "pdf" | "webp";
-    DEFAULT_VIDEO_IMAGE_FORMAT: "png" | "jpeg" | "none";
+    DEFAULT_STILL_IMAGE_FORMAT: "jpeg" | "png" | "webp" | "pdf";
+    DEFAULT_VIDEO_IMAGE_FORMAT: "none" | "jpeg" | "png";
     DEFAULT_JPEG_QUALITY: number;
     chalk: {
         enabled: () => boolean;
@@ -408,12 +408,12 @@ export declare const RenderInternals: {
     Log: {
         verbose: (options: import("./logger").LogOptions & {
             tag?: string;
-        }, ...args: Parameters<typeof console.log>) => void;
-        info: (options: import("./logger").LogOptions, ...args: Parameters<typeof console.log>) => void;
-        warn: (options: import("./logger").LogOptions, ...args: Parameters<typeof console.log>) => void;
+        }, ...args: Parameters<typeof console.log>) => boolean | void;
+        info: (options: import("./logger").LogOptions, ...args: Parameters<typeof console.log>) => boolean | void;
+        warn: (options: import("./logger").LogOptions, ...args: Parameters<typeof console.log>) => boolean | void;
         error: (options: import("./logger").LogOptions & {
             tag?: string;
-        }, ...args: Parameters<typeof console.log>) => void;
+        }, ...args: Parameters<typeof console.log>) => boolean | void;
     };
     INDENT_TOKEN: string;
     isColorSupported: () => boolean;
@@ -955,39 +955,5 @@ export declare const RenderInternals: {
             setConfig: () => never;
         };
     }>) => Promise<import("./ensure-browser").BrowserStatus>;
-    exampleVideos: {
-        bigBuckBunny: string;
-        transparentWebm: string;
-        framerWithoutFileExtension: string;
-        corrupted: string;
-        customDar: string;
-        screenrecording: string;
-        nofps: string;
-        variablefps: string;
-        zerotimestamp: string;
-        webcam: string;
-        iphonevideo: string;
-        av1: string;
-        framer24fps: string;
-        music: string;
-        notavideo: string;
-        notafile: string;
-        transparentwithdar: string;
-        prores: string;
-        iphonehevc: string;
-        matroskaPcm16: string;
-        mp4withmp3: string;
-        av1bbb: string;
-        av1mp4: string;
-        av1mp4WithColr: string;
-        vp8Vorbis: string;
-        vp9: string;
-        stretchedVp8: string;
-        matroskaMp3: string;
-        matroskaH265Aac: string;
-        opusWebm: string;
-        avi: string;
-        opus51Webm: string;
-    };
     printUsefulErrorMessage: (err: Error, logLevel: import("./log-level").LogLevel, indent: boolean) => void;
 };

package/dist/index.js

@@ -113,7 +113,6 @@ const browser_instances_1 = require("./browser-instances");
 const codec_supports_media_1 = require("./codec-supports-media");
 const make_file_executable_1 = require("./compositor/make-file-executable");
 const ensure_browser_2 = require("./ensure-browser");
-const example_videos_1 = require("./example-videos");
 const audio_codec_1 = require("./options/audio-codec");
 const print_useful_error_message_1 = require("./print-useful-error-message");
 const render_has_audio_1 = require("./render-has-audio");
@@ -205,7 +204,6 @@ exports.RenderInternals = {
     codecSupportsMedia: codec_supports_media_1.codecSupportsMedia,
     toMegabytes: to_megabytes_1.toMegabytes,
     internalEnsureBrowser: ensure_browser_2.internalEnsureBrowser,
-    exampleVideos: example_videos_1.exampleVideos,
     printUsefulErrorMessage: print_useful_error_message_1.printUsefulErrorMessage,
 };
 // Warn of potential performance issues with Apple Silicon (M1 chip under Rosetta)

package/dist/logger.d.ts

@@ -10,9 +10,9 @@ type VerboseLogOptions = LogOptions & {
 export declare const verboseTag: (str: string) => string;
 export declare const secondverboseTag: (str: string) => string;
 export declare const Log: {
-    verbose: (options: VerboseLogOptions, ...args: Parameters<typeof console.log>) => void;
-    info: (options: LogOptions, ...args: Parameters<typeof console.log>) => void;
-    warn: (options: LogOptions, ...args: Parameters<typeof console.log>) => void;
-    error: (options: VerboseLogOptions, ...args: Parameters<typeof console.log>) => void;
+    verbose: (options: VerboseLogOptions, ...args: Parameters<typeof console.log>) => boolean | void;
+    info: (options: LogOptions, ...args: Parameters<typeof console.log>) => boolean | void;
+    warn: (options: LogOptions, ...args: Parameters<typeof console.log>) => boolean | void;
+    error: (options: VerboseLogOptions, ...args: Parameters<typeof console.log>) => boolean | void;
 };
 export {};

package/dist/logger.js

@@ -20,6 +20,10 @@ exports.Log = {
     verbose: (options, ...args) => {
         (0, repro_1.writeInRepro)('verbose', ...args);
         if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'verbose')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
             return console.log(...[
                 options.indent ? exports.INDENT_TOKEN : null,
                 options.tag ? (0, exports.verboseTag)(options.tag) : null,
@@ -31,12 +35,22 @@ exports.Log = {
     info: (options, ...args) => {
         (0, repro_1.writeInRepro)('info', ...args);
         if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'info')) {
-            return console.log(...[options.indent ? exports.INDENT_TOKEN : null].filter(truthy_1.truthy).concat(args));
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
+            return console.log(...[options.indent ? exports.INDENT_TOKEN : null]
+                .filter(truthy_1.truthy)
+                .concat(args !== null && args !== void 0 ? args : []));
         }
     },
     warn: (options, ...args) => {
         (0, repro_1.writeInRepro)('warn', ...args);
         if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'warn')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
             return console.warn(...[options.indent ? chalk_1.chalk.yellow(exports.INDENT_TOKEN) : null]
                 .filter(truthy_1.truthy)
                 .concat(args.map((a) => chalk_1.chalk.yellow(a))));
@@ -45,6 +59,10 @@ exports.Log = {
     error: (options, ...args) => {
         (0, repro_1.writeInRepro)('error', ...args);
         if ((0, log_level_1.isEqualOrBelowLogLevel)(options.logLevel, 'error')) {
+            if (args.length === 0) {
+                // Lambda will print "undefined" otherwise
+                return process.stdout.write('\n');
+            }
             return console.error(...[
                 options.indent ? exports.INDENT_TOKEN : null,
                 options.tag ? (0, exports.verboseTag)(options.tag) : null,

package/dist/options/gl.d.ts

@@ -1,7 +1,7 @@
 export declare const validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader", "vulkan", "angle-egl"];
 export type OpenGlRenderer = (typeof validOpenGlRenderers)[number];
 export declare const DEFAULT_OPENGL_RENDERER: OpenGlRenderer | null;
-export declare const getChromiumOpenGlRenderer: () => "swangle" | "angle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
+export declare const getChromiumOpenGlRenderer: () => "angle" | "swangle" | "egl" | "swiftshader" | "vulkan" | "angle-egl" | null;
 export declare const setChromiumOpenGlRenderer: (renderer: OpenGlRenderer) => void;
 export declare const glOption: {
     cliFlag: "gl";

package/dist/options/hardware-acceleration.d.ts

@@ -0,0 +1,18 @@
+export declare const hardwareAccelerationOptions: readonly ["disable", "if-possible", "required"];
+export type HardwareAccelerationOption = (typeof hardwareAccelerationOptions)[number];
+export declare const getHardwareAcceleration: () => "disable" | "if-possible" | "required" | null;
+export declare const hardwareAccelerationOption: {
+    name: string;
+    cliFlag: "hardware-acceleration";
+    description: () => string;
+    ssrName: string;
+    docLink: string;
+    type: HardwareAccelerationOption;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: "disable" | "if-possible" | "required";
+    };
+    setConfig: (value: HardwareAccelerationOption) => void;
+};