@remotion/renderer 4.0.483 → 4.0.485

package/dist/crf.d.ts

@@ -1,11 +1,12 @@
 export type Crf = number | undefined;
 export declare const getDefaultCrfForCodec: (codec: "aac" | "av1" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => number | null;
 export declare const getValidCrfRanges: (codec: "aac" | "av1" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav") => [number, number];
-export declare const validateQualitySettings: ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }: {
+export declare const validateQualitySettings: ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, hardwareAccelerated, }: {
     crf: unknown;
     codec: "aac" | "av1" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
     videoBitrate: string | null;
     encodingMaxRate: string | null;
     encodingBufferSize: string | null;
     hardwareAcceleration: "disable" | "if-possible" | "required";
+    hardwareAccelerated: boolean;
 }) => string[];

package/dist/crf.js

@@ -46,11 +46,15 @@ const getValidCrfRanges = (codec) => {
     return val;
 };
 exports.getValidCrfRanges = getValidCrfRanges;
-const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }) => {
-    if (crf && videoBitrate) {
+const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, hardwareAccelerated, }) => {
+    const hasExplicitCrf = crf !== null && typeof crf !== 'undefined';
+    if (hasExplicitCrf && videoBitrate) {
         throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
     }
-    if (crf && hardwareAcceleration === 'required') {
+    if (hasExplicitCrf && hardwareAcceleration === 'required') {
+        throw new Error('"crf" option is not supported with hardware acceleration');
+    }
+    if (hasExplicitCrf && hardwareAccelerated) {
         throw new Error('"crf" option is not supported with hardware acceleration');
     }
     if (encodingMaxRate && !encodingBufferSize) {
@@ -72,6 +76,9 @@ const validateQualitySettings = ({ codec, crf, videoBitrate, encodingMaxRate, en
         return ['-b:v', videoBitrate, ...bufSizeArray, ...maxRateArray];
     }
     if (crf === null || typeof crf === 'undefined') {
+        if (hardwareAccelerated) {
+            return [...bufSizeArray, ...maxRateArray];
+        }
         const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
         if (actualCrf === null) {
             return [...bufSizeArray, ...maxRateArray];

package/dist/esm/index.mjs

@@ -21265,7 +21265,7 @@ var renderFrames = (options2) => {
 // src/render-media.ts
 import fs18 from "node:fs";
 import os9 from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 import { LicensingInternals } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals15 } from "remotion/no-react";
 
@@ -21318,12 +21318,17 @@ var validateQualitySettings = ({
   videoBitrate,
   encodingMaxRate,
   encodingBufferSize,
-  hardwareAcceleration
+  hardwareAcceleration,
+  hardwareAccelerated
 }) => {
-  if (crf && videoBitrate) {
+  const hasExplicitCrf = crf !== null && typeof crf !== "undefined";
+  if (hasExplicitCrf && videoBitrate) {
     throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
   }
-  if (crf && hardwareAcceleration === "required") {
+  if (hasExplicitCrf && hardwareAcceleration === "required") {
+    throw new Error('"crf" option is not supported with hardware acceleration');
+  }
+  if (hasExplicitCrf && hardwareAccelerated) {
     throw new Error('"crf" option is not supported with hardware acceleration');
   }
   if (encodingMaxRate && !encodingBufferSize) {
@@ -21343,6 +21348,9 @@ var validateQualitySettings = ({
     return ["-b:v", videoBitrate, ...bufSizeArray, ...maxRateArray];
   }
   if (crf === null || typeof crf === "undefined") {
+    if (hardwareAccelerated) {
+      return [...bufSizeArray, ...maxRateArray];
+    }
     const actualCrf = getDefaultCrfForCodec(codec);
     if (actualCrf === null) {
       return [...bufSizeArray, ...maxRateArray];
@@ -21558,6 +21566,11 @@ var getCodecName = ({
     if (preferredHwAcceleration && process.platform === "darwin" && !unsupportedQualityOption) {
       return { encoderName: "prores_videotoolbox", hardwareAccelerated: true };
     }
+    if (preferredHwAcceleration && process.platform !== "darwin" && !unsupportedQualityOption) {
+      if (hardwareAcceleration === "required") {
+        throw new Error(`Codec "prores" does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+      }
+    }
     warnAboutDisabledHardwareAcceleration();
     return { encoderName: "prores_ks", hardwareAccelerated: false };
   }
@@ -21565,6 +21578,9 @@ var getCodecName = ({
     if (preferredHwAcceleration && process.platform === "darwin" && !unsupportedQualityOption) {
       return { encoderName: "h264_videotoolbox", hardwareAccelerated: true };
     }
+    if (preferredHwAcceleration && (process.platform === "linux" || process.platform === "win32") && !unsupportedQualityOption) {
+      return { encoderName: "h264_nvenc", hardwareAccelerated: true };
+    }
     warnAboutDisabledHardwareAcceleration();
     return { encoderName: "libx264", hardwareAccelerated: false };
   }
@@ -21572,6 +21588,9 @@ var getCodecName = ({
     if (preferredHwAcceleration && process.platform === "darwin" && !unsupportedQualityOption) {
       return { encoderName: "hevc_videotoolbox", hardwareAccelerated: true };
     }
+    if (preferredHwAcceleration && (process.platform === "linux" || process.platform === "win32") && !unsupportedQualityOption) {
+      return { encoderName: "hevc_nvenc", hardwareAccelerated: true };
+    }
     warnAboutDisabledHardwareAcceleration();
     return { encoderName: "libx265", hardwareAccelerated: false };
   }
@@ -21598,9 +21617,15 @@ var getCodecName = ({
     return null;
   }
   if (codec === "h264-mkv") {
+    if (hardwareAcceleration === "required") {
+      throw new Error(`Codec "h264-mkv" does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+    }
     return { encoderName: "libx264", hardwareAccelerated: false };
   }
   if (codec === "h264-ts") {
+    if (hardwareAcceleration === "required") {
+      throw new Error(`Codec "h264-ts" does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+    }
     return { encoderName: "libx264", hardwareAccelerated: false };
   }
   throw new Error(`Could not get codec for ${codec}`);
@@ -21618,7 +21643,8 @@ var firstEncodingStepOnly = ({
   videoBitrate,
   encodingMaxRate,
   encodingBufferSize,
-  hardwareAcceleration
+  hardwareAcceleration,
+  hardwareAccelerated
 }) => {
   if (hasPreencoded || codec === "gif") {
     return [];
@@ -21637,7 +21663,8 @@ var firstEncodingStepOnly = ({
       codec,
       encodingMaxRate,
       encodingBufferSize,
-      hardwareAcceleration
+      hardwareAcceleration,
+      hardwareAccelerated
     })
   ].filter(truthy);
 };
@@ -21706,7 +21733,8 @@ var generateFfmpegArgs = ({
       encodingBufferSize,
       x264Preset,
       gopSize,
-      hardwareAcceleration
+      hardwareAcceleration,
+      hardwareAccelerated
     })
   ].filter(truthy);
 };
@@ -21734,6 +21762,86 @@ var getProResProfileName = (codec, proResProfile) => {
   }
 };
 
+// src/probe-encoder.ts
+import { execFileSync } from "node:child_process";
+import path23 from "path";
+var probeEncoderAvailability = ({
+  encoderName,
+  binariesDirectory,
+  indent,
+  logLevel
+}) => {
+  try {
+    const executablePath = getExecutablePath({
+      type: "ffmpeg",
+      indent,
+      logLevel,
+      binariesDirectory
+    });
+    makeFileExecutableIfItIsNot(executablePath);
+    const cwd = path23.dirname(executablePath);
+    const result = execFileSync(executablePath, ["-encoders"], {
+      encoding: "utf-8",
+      env: getExplicitEnv(cwd),
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e4
+    });
+    const escaped = encoderName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const encoderRegex = new RegExp(`\\b${escaped}\\b`);
+    const hasEncoder = encoderRegex.test(result);
+    if (!hasEncoder) {
+      Log.verbose({ indent, logLevel, tag: "probeEncoderAvailability()" }, `Encoder "${encoderName}" not found in FFmpeg build. Falling back to software encoding.`);
+    }
+    return hasEncoder;
+  } catch (err) {
+    Log.verbose({ indent, logLevel, tag: "probeEncoderAvailability()" }, `Failed to probe FFmpeg for encoder "${encoderName}": ${err}. Falling back to software encoding.`);
+    return false;
+  }
+};
+var resolveHardwareAcceleration = ({
+  codec,
+  hardwareAcceleration,
+  binariesDirectory,
+  indent,
+  logLevel,
+  crf,
+  encodingMaxRate,
+  encodingBufferSize
+}) => {
+  if (hardwareAcceleration === "disable") {
+    return "disable";
+  }
+  const preferred = getCodecName({
+    codec,
+    hardwareAcceleration,
+    crf,
+    encodingMaxRate,
+    encodingBufferSize,
+    logLevel,
+    indent
+  });
+  if (preferred === null) {
+    return hardwareAcceleration;
+  }
+  if (!preferred.hardwareAccelerated) {
+    return hardwareAcceleration;
+  }
+  const encoderAvailable = probeEncoderAvailability({
+    encoderName: preferred.encoderName,
+    binariesDirectory,
+    indent,
+    logLevel
+  });
+  if (encoderAvailable) {
+    return hardwareAcceleration;
+  }
+  if (hardwareAcceleration === "if-possible") {
+    Log.verbose({ indent, logLevel, tag: "resolveHardwareAcceleration()" }, `Hardware encoder "${preferred.encoderName}" not available. Falling back to software encoding.`);
+    return "disable";
+  }
+  throw new Error(`Hardware encoder "${preferred.encoderName}" is not available in your FFmpeg build. ` + `Install an FFmpeg with ${preferred.encoderName} support, or use "if-possible" mode instead of "required".`);
+};
+
 // src/validate-even-dimensions-with-codec.ts
 var validateEvenDimensionsWithCodec = ({
   width,
@@ -21794,6 +21902,16 @@ var prespawnFfmpeg = (options2) => {
   const pixelFormat = options2.pixelFormat ?? DEFAULT_PIXEL_FORMAT;
   const proResProfileName = getProResProfileName(codec, options2.proResProfile);
   validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
+  const resolvedHardwareAcceleration = resolveHardwareAcceleration({
+    codec,
+    hardwareAcceleration: options2.hardwareAcceleration,
+    binariesDirectory: options2.binariesDirectory,
+    indent: options2.indent,
+    logLevel: options2.logLevel,
+    crf: options2.crf,
+    encodingMaxRate: options2.encodingMaxRate,
+    encodingBufferSize: options2.encodingBufferSize
+  });
   const ffmpegArgs = [
     ["-r", options2.fps],
     ...[
@@ -21814,7 +21932,7 @@ var prespawnFfmpeg = (options2) => {
       encodingMaxRate: options2.encodingMaxRate,
       encodingBufferSize: options2.encodingBufferSize,
       colorSpace: options2.colorSpace,
-      hardwareAcceleration: options2.hardwareAcceleration,
+      hardwareAcceleration: resolvedHardwareAcceleration,
       indent: options2.indent,
       logLevel: options2.logLevel
     }),
@@ -21916,7 +22034,7 @@ var validateSelectedCodecAndProResCombination = ({
 
 // src/stitch-frames-to-video.ts
 import { cpSync as cpSync2, promises as promises3, rmSync as rmSync4 } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 
 // src/convert-number-of-gif-loops-to-ffmpeg.ts
 var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
@@ -21930,7 +22048,7 @@ var convertNumberOfGifLoopsToFfmpegSyntax = (loops) => {
 };
 
 // src/create-audio.ts
-import path25 from "path";
+import path26 from "path";
 
 // src/resolve-asset-src.ts
 import url from "node:url";
@@ -22131,7 +22249,7 @@ var compressAudio = async ({
 };
 
 // src/merge-audio-track.ts
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/chunk.ts
 var chunk2 = (input, size) => {
@@ -22163,7 +22281,7 @@ var createFfmpegMergeFilter = ({
 
 // src/ffmpeg-filter-file.ts
 import fs17, { existsSync as existsSync5 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 var makeFfmpegFilterFile = (complexFilter, downloadMap) => {
   if (complexFilter.filter === null) {
     return {
@@ -22177,7 +22295,7 @@ var makeFfmpegFilterFile = (complexFilter, downloadMap) => {
 };
 var makeFfmpegFilterFileStr = async (complexFilter, downloadMap) => {
   const random2 = Math.random().toString().replace(".", "");
-  const filterFile = path23.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
+  const filterFile = path24.join(downloadMap.complexFilter, "complex-filter-" + random2 + ".txt");
   if (!existsSync5(downloadMap.complexFilter)) {
     fs17.mkdirSync(downloadMap.complexFilter, { recursive: true });
   }
@@ -22287,7 +22405,7 @@ var mergeAudioTrackUnlimited = async ({
         onProgress(combinedProgress);
       };
       const chunkNames = await Promise.all(chunked.map(async (chunkFiles, i) => {
-        const chunkOutname = path24.join(tempPath, `chunk-${i}.wav`);
+        const chunkOutname = path25.join(tempPath, `chunk-${i}.wav`);
         await mergeAudioTrack({
           files: chunkFiles,
           chunkLengthInSeconds,
@@ -22749,7 +22867,7 @@ var createAudio = async ({
     onProgress(totalProgress);
   };
   const audioTracks = await Promise.all(assetPositions.map(async (asset, index) => {
-    const filterFile = path25.join(downloadMap.audioMixing, `${index}.wav`);
+    const filterFile = path26.join(downloadMap.audioMixing, `${index}.wav`);
     const result = await preprocessAudioTrack({
       outName: filterFile,
       asset,
@@ -22793,9 +22911,9 @@ var createAudio = async ({
       }
     }))
   ];
-  const merged = path25.join(downloadMap.audioPreprocessing, "merged.wav");
+  const merged = path26.join(downloadMap.audioPreprocessing, "merged.wav");
   const extension = getExtensionFromAudioCodec(audioCodec);
-  const outName = path25.join(downloadMap.audioPreprocessing, `audio.${extension}`);
+  const outName = path26.join(downloadMap.audioPreprocessing, `audio.${extension}`);
   await mergeAudioTrack({
     files: preprocessed,
     outName: merged,
@@ -22975,7 +23093,7 @@ var innerStitchFramesToVideo = async ({
     setting: audioCodecSetting,
     separateAudioTo
   });
-  const tempFile = outputLocation ? null : path26.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
+  const tempFile = outputLocation ? null : path27.join(assetsInfo.downloadMap.stitchFrames, `out.${getFileExtensionFromCodec(codec, resolvedAudioCodec)}`);
   Log.verbose({
     indent,
     logLevel,
@@ -23007,7 +23125,8 @@ var innerStitchFramesToVideo = async ({
     videoBitrate,
     encodingMaxRate: maxRate,
     encodingBufferSize: bufferSize,
-    hardwareAcceleration
+    hardwareAcceleration,
+    hardwareAccelerated: false
   });
   validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
   const updateProgress = (muxProgress) => {
@@ -23050,7 +23169,7 @@ var innerStitchFramesToVideo = async ({
     }
     cpSync2(audio, outputLocation ?? tempFile);
     onProgress?.(Math.round(assetsInfo.chunkLengthInSeconds * fps));
-    deleteDirectory(path26.dirname(audio));
+    deleteDirectory(path27.dirname(audio));
     const file = await new Promise((resolve2, reject) => {
       if (tempFile) {
         promises3.readFile(tempFile).then((f) => {
@@ -23064,6 +23183,16 @@ var innerStitchFramesToVideo = async ({
     assetsInfo.downloadMap.allowCleanup();
     return Promise.resolve(file);
   }
+  const resolvedHardwareAcceleration = resolveHardwareAcceleration({
+    codec,
+    hardwareAcceleration,
+    binariesDirectory,
+    indent: indent ?? false,
+    logLevel,
+    crf,
+    encodingMaxRate: maxRate,
+    encodingBufferSize: bufferSize
+  });
   const ffmpegArgs = [
     ...preEncodedFileLocation ? [["-i", preEncodedFileLocation]] : [
       ["-r", String(fps)],
@@ -23087,7 +23216,7 @@ var innerStitchFramesToVideo = async ({
       x264Preset,
       gopSize,
       colorSpace,
-      hardwareAcceleration,
+      hardwareAcceleration: resolvedHardwareAcceleration,
       indent,
       logLevel
     }),
@@ -23140,7 +23269,7 @@ var innerStitchFramesToVideo = async ({
     if (!audio) {
       throw new Error(`\`separateAudioTo\` was set to ${JSON.stringify(separateAudioTo)}, but this render included no audio`);
     }
-    const finalDestination = path26.resolve(remotionRoot, separateAudioTo);
+    const finalDestination = path27.resolve(remotionRoot, separateAudioTo);
     cpSync2(audio, finalDestination);
     rmSync4(audio);
   }
@@ -23448,7 +23577,8 @@ var internalRenderMediaRaw = ({
     videoBitrate,
     encodingMaxRate,
     encodingBufferSize,
-    hardwareAcceleration
+    hardwareAcceleration,
+    hardwareAccelerated: false
   });
   validateGopSize(gopSize);
   validateBitrate(audioBitrate, "audioBitrate");
@@ -23473,7 +23603,7 @@ var internalRenderMediaRaw = ({
       separateAudioTo
     });
   }
-  const absoluteOutputLocation = outputLocation ? path27.resolve(process.cwd(), outputLocation) : null;
+  const absoluteOutputLocation = outputLocation ? path28.resolve(process.cwd(), outputLocation) : null;
   validateScale(scale);
   validateFfmpegOverride(ffmpegOverride);
   validateEveryNthFrame(everyNthFrame);
@@ -23539,8 +23669,8 @@ var internalRenderMediaRaw = ({
   }
   const imageFormat = isAudioCodec(codec) ? "none" : provisionalImageFormat ?? compositionWithPossibleUnevenDimensions.defaultVideoImageFormat ?? DEFAULT_VIDEO_IMAGE_FORMAT;
   validateSelectedPixelFormatAndImageFormatCombination(pixelFormat, imageFormat);
-  const workingDir = fs18.mkdtempSync(path27.join(os9.tmpdir(), "react-motion-render"));
-  const preEncodedFileLocation = parallelEncoding ? path27.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
+  const workingDir = fs18.mkdtempSync(path28.join(os9.tmpdir(), "react-motion-render"));
+  const preEncodedFileLocation = parallelEncoding ? path28.join(workingDir, "pre-encode." + getFileExtensionFromCodec(codec, audioCodec)) : null;
   if (onCtrlCExit && workingDir) {
     onCtrlCExit(`Delete ${workingDir}`, () => deleteDirectory(workingDir));
   }
@@ -23871,7 +24001,7 @@ var internalRenderMediaRaw = ({
       reject(err);
     }).finally(() => {
       if (preEncodedFileLocation !== null && fs18.existsSync(preEncodedFileLocation)) {
-        deleteDirectory(path27.dirname(preEncodedFileLocation));
+        deleteDirectory(path28.dirname(preEncodedFileLocation));
       }
       if (workingDir && fs18.existsSync(workingDir)) {
         deleteDirectory(workingDir);
@@ -24045,7 +24175,7 @@ var renderMedia = ({
 
 // src/render-still.ts
 import fs19, { statSync as statSync2 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 import { LicensingInternals as LicensingInternals2 } from "@remotion/licensing";
 import { NoReactInternals as NoReactInternals16 } from "remotion/no-react";
 var innerRenderStill = async ({
@@ -24096,7 +24226,7 @@ var innerRenderStill = async ({
   });
   validatePuppeteerTimeout(timeoutInMilliseconds);
   validateScale(scale);
-  output = typeof output === "string" ? path28.resolve(process.cwd(), output) : null;
+  output = typeof output === "string" ? path29.resolve(process.cwd(), output) : null;
   validateJpegQuality(jpegQuality);
   if (output) {
     if (fs19.existsSync(output)) {

package/dist/ffmpeg-args.js

@@ -7,7 +7,7 @@ const logger_1 = require("./logger");
 const color_space_1 = require("./options/color-space");
 const gop_size_1 = require("./options/gop-size");
 const truthy_1 = require("./truthy");
-const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, gopSize, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, }) => {
+const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat, x264Preset, gopSize, codec, crf, videoBitrate, encodingMaxRate, encodingBufferSize, hardwareAcceleration, hardwareAccelerated, }) => {
     if (hasPreencoded || codec === 'gif') {
         return [];
     }
@@ -30,6 +30,7 @@ const firstEncodingStepOnly = ({ hasPreencoded, proResProfileName, pixelFormat,
             encodingMaxRate,
             encodingBufferSize,
             hardwareAcceleration,
+            hardwareAccelerated,
         }),
     ].filter(truthy_1.truthy);
 };
@@ -97,6 +98,7 @@ const generateFfmpegArgs = ({ hasPreencoded, proResProfileName, pixelFormat, x26
             x264Preset,
             gopSize,
             hardwareAcceleration,
+            hardwareAccelerated,
         }),
     ].filter(truthy_1.truthy);
 };

package/dist/get-codec-name.js

@@ -37,6 +37,13 @@ const getCodecName = ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwar
             !unsupportedQualityOption) {
             return { encoderName: 'prores_videotoolbox', hardwareAccelerated: true };
         }
+        if (preferredHwAcceleration &&
+            process.platform !== 'darwin' &&
+            !unsupportedQualityOption) {
+            if (hardwareAcceleration === 'required') {
+                throw new Error(`Codec "prores" does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+            }
+        }
         warnAboutDisabledHardwareAcceleration();
         return { encoderName: 'prores_ks', hardwareAccelerated: false };
     }
@@ -46,6 +53,12 @@ const getCodecName = ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwar
             !unsupportedQualityOption) {
             return { encoderName: 'h264_videotoolbox', hardwareAccelerated: true };
         }
+        // NVENC for Linux/Windows
+        if (preferredHwAcceleration &&
+            (process.platform === 'linux' || process.platform === 'win32') &&
+            !unsupportedQualityOption) {
+            return { encoderName: 'h264_nvenc', hardwareAccelerated: true };
+        }
         warnAboutDisabledHardwareAcceleration();
         return { encoderName: 'libx264', hardwareAccelerated: false };
     }
@@ -55,6 +68,12 @@ const getCodecName = ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwar
             !unsupportedQualityOption) {
             return { encoderName: 'hevc_videotoolbox', hardwareAccelerated: true };
         }
+        // NVENC for Linux/Windows
+        if (preferredHwAcceleration &&
+            (process.platform === 'linux' || process.platform === 'win32') &&
+            !unsupportedQualityOption) {
+            return { encoderName: 'hevc_nvenc', hardwareAccelerated: true };
+        }
         warnAboutDisabledHardwareAcceleration();
         return { encoderName: 'libx265', hardwareAccelerated: false };
     }
@@ -81,9 +100,15 @@ const getCodecName = ({ codec, encodingMaxRate, encodingBufferSize, crf, hardwar
         return null;
     }
     if (codec === 'h264-mkv') {
+        if (hardwareAcceleration === 'required') {
+            throw new Error(`Codec "h264-mkv" does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+        }
         return { encoderName: 'libx264', hardwareAccelerated: false };
     }
     if (codec === 'h264-ts') {
+        if (hardwareAcceleration === 'required') {
+            throw new Error(`Codec "h264-ts" does not support hardware acceleration on ${process.platform}, but "hardwareAcceleration" is set to "required"`);
+        }
         return { encoderName: 'libx264', hardwareAccelerated: false };
     }
     throw new Error(`Could not get codec for ${codec}`);

package/dist/prespawn-ffmpeg.js

@@ -8,6 +8,7 @@ const get_prores_profile_name_1 = require("./get-prores-profile-name");
 const logger_1 = require("./logger");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const pixel_format_1 = require("./pixel-format");
+const probe_encoder_1 = require("./probe-encoder");
 const validate_1 = require("./validate");
 const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
 const prespawnFfmpeg = (options) => {
@@ -29,6 +30,16 @@ const prespawnFfmpeg = (options) => {
     const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : pixel_format_1.DEFAULT_PIXEL_FORMAT;
     const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
+    const resolvedHardwareAcceleration = (0, probe_encoder_1.resolveHardwareAcceleration)({
+        codec,
+        hardwareAcceleration: options.hardwareAcceleration,
+        binariesDirectory: options.binariesDirectory,
+        indent: options.indent,
+        logLevel: options.logLevel,
+        crf: options.crf,
+        encodingMaxRate: options.encodingMaxRate,
+        encodingBufferSize: options.encodingBufferSize,
+    });
     const ffmpegArgs = [
         ['-r', options.fps],
         ...[
@@ -51,7 +62,7 @@ const prespawnFfmpeg = (options) => {
             encodingMaxRate: options.encodingMaxRate,
             encodingBufferSize: options.encodingBufferSize,
             colorSpace: options.colorSpace,
-            hardwareAcceleration: options.hardwareAcceleration,
+            hardwareAcceleration: resolvedHardwareAcceleration,
             indent: options.indent,
             logLevel: options.logLevel,
         }),

package/dist/probe-encoder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Probes FFmpeg to check if a specific encoder is available.
+ * Returns true if the encoder is supported, false otherwise.
+ */
+export declare const probeEncoderAvailability: ({ encoderName, binariesDirectory, indent, logLevel, }: {
+    encoderName: string;
+    binariesDirectory: string | null;
+    indent: boolean;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+}) => boolean;
+/**
+ * Resolves the effective hardware acceleration setting by probing FFmpeg
+ * for encoder availability. If the preferred hw encoder is not available:
+ * - `if-possible` mode: falls back to software encoding
+ * - `required` mode: throws a clear error
+ */
+export declare const resolveHardwareAcceleration: ({ codec, hardwareAcceleration, binariesDirectory, indent, logLevel, crf, encodingMaxRate, encodingBufferSize, }: {
+    codec: "aac" | "av1" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
+    hardwareAcceleration: "disable" | "if-possible" | "required";
+    binariesDirectory: string | null;
+    indent: boolean;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    crf: unknown;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+}) => "disable" | "if-possible" | "required";

package/dist/probe-encoder.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHardwareAcceleration = exports.probeEncoderAvailability = void 0;
+const node_child_process_1 = require("node:child_process");
+const path_1 = __importDefault(require("path"));
+const get_executable_path_1 = require("./compositor/get-executable-path");
+const get_explicit_env_1 = require("./compositor/get-explicit-env");
+const make_file_executable_1 = require("./compositor/make-file-executable");
+const get_codec_name_1 = require("./get-codec-name");
+const logger_1 = require("./logger");
+/**
+ * Probes FFmpeg to check if a specific encoder is available.
+ * Returns true if the encoder is supported, false otherwise.
+ */
+const probeEncoderAvailability = ({ encoderName, binariesDirectory, indent, logLevel, }) => {
+    try {
+        const executablePath = (0, get_executable_path_1.getExecutablePath)({
+            type: 'ffmpeg',
+            indent,
+            logLevel,
+            binariesDirectory,
+        });
+        (0, make_file_executable_1.makeFileExecutableIfItIsNot)(executablePath);
+        const cwd = path_1.default.dirname(executablePath);
+        const result = (0, node_child_process_1.execFileSync)(executablePath, ['-encoders'], {
+            encoding: 'utf-8',
+            env: (0, get_explicit_env_1.getExplicitEnv)(cwd),
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 10000,
+        });
+        // FFmpeg -encoders output format: " V..... encoder_name"
+        // Escape regex metacharacters and use word-boundary to avoid false positives
+        const escaped = encoderName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const encoderRegex = new RegExp(`\\b${escaped}\\b`);
+        const hasEncoder = encoderRegex.test(result);
+        if (!hasEncoder) {
+            logger_1.Log.verbose({ indent, logLevel, tag: 'probeEncoderAvailability()' }, `Encoder "${encoderName}" not found in FFmpeg build. Falling back to software encoding.`);
+        }
+        return hasEncoder;
+    }
+    catch (err) {
+        logger_1.Log.verbose({ indent, logLevel, tag: 'probeEncoderAvailability()' }, `Failed to probe FFmpeg for encoder "${encoderName}": ${err}. Falling back to software encoding.`);
+        return false;
+    }
+};
+exports.probeEncoderAvailability = probeEncoderAvailability;
+/**
+ * Resolves the effective hardware acceleration setting by probing FFmpeg
+ * for encoder availability. If the preferred hw encoder is not available:
+ * - `if-possible` mode: falls back to software encoding
+ * - `required` mode: throws a clear error
+ */
+const resolveHardwareAcceleration = ({ codec, hardwareAcceleration, binariesDirectory, indent, logLevel, crf, encodingMaxRate, encodingBufferSize, }) => {
+    if (hardwareAcceleration === 'disable') {
+        return 'disable';
+    }
+    const preferred = (0, get_codec_name_1.getCodecName)({
+        codec,
+        hardwareAcceleration,
+        crf,
+        encodingMaxRate,
+        encodingBufferSize,
+        logLevel,
+        indent,
+    });
+    // Audio codecs return null, no probing needed
+    if (preferred === null) {
+        return hardwareAcceleration;
+    }
+    // Only probe if getCodecName selected a hardware-accelerated encoder
+    if (!preferred.hardwareAccelerated) {
+        return hardwareAcceleration;
+    }
+    const encoderAvailable = (0, exports.probeEncoderAvailability)({
+        encoderName: preferred.encoderName,
+        binariesDirectory,
+        indent,
+        logLevel,
+    });
+    if (encoderAvailable) {
+        return hardwareAcceleration;
+    }
+    // Encoder not available in FFmpeg
+    if (hardwareAcceleration === 'if-possible') {
+        logger_1.Log.verbose({ indent, logLevel, tag: 'resolveHardwareAcceleration()' }, `Hardware encoder "${preferred.encoderName}" not available. Falling back to software encoding.`);
+        return 'disable';
+    }
+    // hardwareAcceleration === 'required'
+    throw new Error(`Hardware encoder "${preferred.encoderName}" is not available in your FFmpeg build. ` +
+        `Install an FFmpeg with ${preferred.encoderName} support, or use "if-possible" mode instead of "required".`);
+};
+exports.resolveHardwareAcceleration = resolveHardwareAcceleration;

package/dist/render-media.js

@@ -78,6 +78,7 @@ const internalRenderMediaRaw = ({ proResProfile, x264Preset, gopSize, crf, compo
         encodingMaxRate,
         encodingBufferSize,
         hardwareAcceleration,
+        hardwareAccelerated: false,
     });
     (0, gop_size_1.validateGopSize)(gopSize);
     (0, validate_videobitrate_1.validateBitrate)(audioBitrate, 'audioBitrate');

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

@@ -26,6 +26,7 @@ const color_space_1 = require("./options/color-space");
 const gop_size_1 = require("./options/gop-size");
 const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
 const pixel_format_1 = require("./pixel-format");
+const probe_encoder_1 = require("./probe-encoder");
 const prores_profile_1 = require("./prores-profile");
 const render_has_audio_1 = require("./render-has-audio");
 const validate_1 = require("./validate");
@@ -113,6 +114,7 @@ const innerStitchFramesToVideo = async ({ assetsInfo, audioBitrate, audioCodec:
         encodingMaxRate: maxRate,
         encodingBufferSize: bufferSize,
         hardwareAcceleration,
+        hardwareAccelerated: false,
     });
     (0, pixel_format_1.validateSelectedPixelFormatAndCodecCombination)(pixelFormat, codec);
     const updateProgress = (muxProgress) => {
@@ -176,6 +178,16 @@ const innerStitchFramesToVideo = async ({ assetsInfo, audioBitrate, audioCodec:
         assetsInfo.downloadMap.allowCleanup();
         return Promise.resolve(file);
     }
+    const resolvedHardwareAcceleration = (0, probe_encoder_1.resolveHardwareAcceleration)({
+        codec,
+        hardwareAcceleration,
+        binariesDirectory,
+        indent: indent !== null && indent !== void 0 ? indent : false,
+        logLevel,
+        crf,
+        encodingMaxRate: maxRate,
+        encodingBufferSize: bufferSize,
+    });
     const ffmpegArgs = [
         ...(preEncodedFileLocation
             ? [['-i', preEncodedFileLocation]]
@@ -205,7 +217,7 @@ const innerStitchFramesToVideo = async ({ assetsInfo, audioBitrate, audioCodec:
             x264Preset,
             gopSize,
             colorSpace,
-            hardwareAcceleration,
+            hardwareAcceleration: resolvedHardwareAcceleration,
             indent,
             logLevel,
         }),

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/renderer"
 	},
 	"name": "@remotion/renderer",
-	"version": "4.0.483",
+	"version": "4.0.485",
 	"description": "Render Remotion videos using Node.js or Bun",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -22,11 +22,11 @@
 	},
 	"dependencies": {
 		"execa": "5.1.1",
-		"remotion": "4.0.483",
-		"@remotion/streaming": "4.0.483",
+		"remotion": "4.0.485",
+		"@remotion/streaming": "4.0.485",
 		"source-map": "0.8.0-beta.0",
 		"ws": "8.21.0",
-		"@remotion/licensing": "4.0.483"
+		"@remotion/licensing": "4.0.485"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
@@ -40,19 +40,19 @@
 		"react-dom": "19.2.3",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1",
 		"@types/ws": "8.5.10",
-		"@remotion/example-videos": "4.0.483",
-		"@remotion/eslint-config-internal": "4.0.483",
+		"@remotion/example-videos": "4.0.485",
+		"@remotion/eslint-config-internal": "4.0.485",
 		"eslint": "9.19.0",
 		"@types/node": "20.12.14"
 	},
 	"optionalDependencies": {
-		"@remotion/compositor-darwin-arm64": "4.0.483",
-		"@remotion/compositor-darwin-x64": "4.0.483",
-		"@remotion/compositor-linux-arm64-gnu": "4.0.483",
-		"@remotion/compositor-linux-arm64-musl": "4.0.483",
-		"@remotion/compositor-linux-x64-gnu": "4.0.483",
-		"@remotion/compositor-linux-x64-musl": "4.0.483",
-		"@remotion/compositor-win32-x64-msvc": "4.0.483"
+		"@remotion/compositor-darwin-arm64": "4.0.485",
+		"@remotion/compositor-darwin-x64": "4.0.485",
+		"@remotion/compositor-linux-arm64-gnu": "4.0.485",
+		"@remotion/compositor-linux-arm64-musl": "4.0.485",
+		"@remotion/compositor-linux-x64-gnu": "4.0.485",
+		"@remotion/compositor-linux-x64-musl": "4.0.485",
+		"@remotion/compositor-win32-x64-msvc": "4.0.485"
 	},
 	"keywords": [
 		"remotion",