add hardware encoding to ffmpeg, binary choice

tests/ffmpeg.ts

@@ -0,0 +1,65 @@
+import ffmpeg from 'fluent-ffmpeg';
+import ffmpegInstaller from '@ffmpeg-installer/ffmpeg';
+import ffprobeInstaller from '@ffprobe-installer/ffprobe';
+import which from 'which';
+
+const getExecutablePath = (envVar: string, executable: string, installer: { path: string }) => {
+  if (process.env[envVar]) {
+    return process.env[envVar];
+  }
+
+  try {
+    return which.sync(executable);
+  } catch (error) {
+    return installer.path;
+  }
+};
+
+const ffmpegPath = getExecutablePath('EB_FFMPEG_PATH', 'ffmpeg', ffmpegInstaller);
+const ffprobePath = getExecutablePath('EB_FFPROBE_PATH', 'ffprobe', ffprobeInstaller);
+
+console.log(`Using ffmpeg from path: ${ffmpegPath}`);
+console.log(`Using ffprobe from path: ${ffprobePath}`);
+
+ffmpeg.setFfmpegPath(ffmpegPath!);
+ffmpeg.setFfprobePath(ffprobePath!);
+
+export enum EncodingType {
+  CPU = 'libx264',
+  NVIDIA = 'h264_nvenc',
+  AMD = 'h264_vmf',
+  INTEL = 'h264_qsv',
+  APPLE = 'h264_videotoolbox',
+}
+
+export const generateTestVideo = async (encodingType: EncodingType): Promise<void> => {
+  console.log(`Generating test video using ${encodingType}...`);
+
+  const startTime = Date.now();
+
+  const outputOptions = [
+    '-vf', 'scale=-2:720',
+    '-c:v', encodingType,
+  ];
+
+  return new Promise<void>((resolve, reject) => {
+    ffmpeg()
+      .input('test.mp4')
+      .inputFormat('mp4')
+      .outputOptions(outputOptions)
+      .output(`720p-test-${encodingType}.mp4`)
+      .on('end', () => {
+        console.log(`720p copy complete using ${encodingType}, took ${Date.now() - startTime}ms to complete`);
+        resolve();
+      })
+      .on('error', (e) => reject(new Error(e)))
+      .run();
+  });
+};
+
+// Test commands (uncomment to use)
+// generateTestVideo(EncodingType.CPU).catch(console.error);
+// generateTestVideo(EncodingType.AMD).catch(console.error);
+// generateTestVideo(EncodingType.INTEL).catch(console.error);
+// generateTestVideo(EncodingType.NVIDIA).catch(console.error);
+// generateTestVideo(EncodingType.APPLE).catch(console.error);

tests/test.ts

@@ -0,0 +1,56 @@
+import readline from 'readline';
+import { generateTestVideo, EncodingType } from "./ffmpeg";
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+const questionAsync = (query: string) => {
+  return new Promise<string>(resolve => {
+    rl.question(query, resolve);
+  });
+};
+
+const main = async () => {
+  console.log("Testing software encoder: ");
+  await generateTestVideo(EncodingType.CPU).catch(console.error);
+
+  const answer = await questionAsync('Would you like to test other hardware encoders? (yes/no): ');
+
+  if (answer.toLowerCase() === 'yes') {
+    const encoder = await questionAsync('Which hardware encoder would you like to test? (INTEL/NVIDIA/AMD/APPLE): ');
+    let selectedEncoder: EncodingType;
+
+    switch (encoder.toUpperCase()) {
+      case 'INTEL':
+        selectedEncoder = EncodingType.INTEL;
+        break;
+      case 'NVIDIA':
+        selectedEncoder = EncodingType.NVIDIA;
+        break;
+      case 'AMD':
+        selectedEncoder = EncodingType.AMD;
+        break;
+      case 'APPLE':
+        selectedEncoder = EncodingType.APPLE;
+        break;
+      default:
+        console.log('Invalid choice. Exiting.');
+        rl.close();
+        return;
+    }
+
+    console.log(`Testing ${selectedEncoder} encoder:`);
+    await generateTestVideo(selectedEncoder).catch(console.error);
+  } else {
+    console.log("Exiting.");
+  }
+  
+  rl.close();
+};
+
+main().catch(err => {
+  console.error("An error occurred:", err);
+  rl.close();
+});