Skip to content

🎥 Make videos programmatically with React

4.2 KB
Raw Blame
import {execFileSync} from 'node:child_process';
import path from 'path';
import type {OnLog} from './browser/BrowserPage';
import type {Codec} from './codec';
import {getExecutablePath} from './compositor/get-executable-path';
import {getExplicitEnv} from './compositor/get-explicit-env';
import {makeFileExecutableIfItIsNot} from './compositor/make-file-executable';
import {
	getCodecName,
	hasSpecifiedUnsupportedHardwareQualifySettings,
} from './get-codec-name';
import type {LogLevel} from './log-level';
import {Log} from './logger';
import type {HardwareAccelerationOption} from './options/hardware-acceleration';

/**
 * Probes FFmpeg to check if a specific encoder is available.
 * Returns true if the encoder is supported, false otherwise.
 */
export const probeEncoderAvailability = ({
	encoderName,
	binariesDirectory,
	indent,
	logLevel,
}: {
	encoderName: string;
	binariesDirectory: string | null;
	indent: boolean;
	logLevel: LogLevel;
}): boolean => {
	try {
		const executablePath = getExecutablePath({
			type: 'ffmpeg',
			indent,
			logLevel,
			binariesDirectory,
		});
		makeFileExecutableIfItIsNot(executablePath);

		const cwd = path.dirname(executablePath);
		const result = execFileSync(executablePath, ['-encoders'], {
			encoding: 'utf-8',
			env: 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) {
			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;
	}
};

/**
 * 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 const resolveHardwareAcceleration = ({
	codec,
	hardwareAcceleration,
	binariesDirectory,
	indent,
	logLevel,
	crf,
	encodingMaxRate,
	encodingBufferSize,
	onLog,
}: {
	codec: Codec;
	hardwareAcceleration: HardwareAccelerationOption;
	binariesDirectory: string | null;
	indent: boolean;
	logLevel: LogLevel;
	crf: unknown;
	encodingMaxRate: string | null;
	encodingBufferSize: string | null;
	onLog: OnLog | null;
}): HardwareAccelerationOption => {
	if (hardwareAcceleration === 'disable') {
		return 'disable';
	}

	const preferred = getCodecName({
		codec,
		hardwareAcceleration,
		crf,
		encodingMaxRate,
		encodingBufferSize,
		logLevel,
		indent,
		onLog,
	});

	// Audio codecs return null, no probing needed
	if (preferred === null) {
		return hardwareAcceleration;
	}

	// Only probe if getCodecName selected a hardware-accelerated encoder
	if (!preferred.hardwareAccelerated) {
		if (
			hardwareAcceleration === 'if-possible' &&
			hasSpecifiedUnsupportedHardwareQualifySettings({
				crf,
				encodingMaxRate,
				encodingBufferSize,
			})
		) {
			return 'disable';
		}

		return hardwareAcceleration;
	}

	const encoderAvailable = probeEncoderAvailability({
		encoderName: preferred.encoderName,
		binariesDirectory,
		indent,
		logLevel,
	});

	if (encoderAvailable) {
		return hardwareAcceleration;
	}

	// Encoder not available in FFmpeg
	if (hardwareAcceleration === 'if-possible') {
		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".`,
	);
};