Add file out

server-plugins/split-render.js

@@ -3,6 +3,7 @@ import fs from 'fs'
 import { Plugin } from './plugin.js';
 import { exec } from 'child_process'
 import _path from 'path';
+import { PerformanceRecorder } from 'common-utils';
 
 export class SplitRenderPlugin extends Plugin {
   constructor(name, options) {
@@ -19,69 +20,109 @@ export class SplitRenderPlugin extends Plugin {
     return new Promise((resolve, reject) => {
       let ffmpegCommand = ''
       let outFile = outFiles.find(f => f.includes('.webm')) || outFiles.find(f => f.includes('.mp4')) || outFiles.find(f => f.includes('.mov'));
-      if (outFile) {
-        let inputFiles = [];
-        let sceneIndex = 0;
-
-        originalManuscript.transcript.forEach(scene => {
-          let durationInSeconds = scene.durationInSeconds
-          scene.mediaAbsPaths = _.cloneDeep(scene._mediaAbsPaths)
-          delete scene._mediaAbsPaths
-
-          for (let i = 0; i < scene.mediaAbsPaths.length; i++) {
-            const { path, type, dimensions, durationSec } = scene.mediaAbsPaths[i];
-            const { width, height } = dimensions;
-            if (type === 'video') {
-              // Clip the video to scene duration if it's longer
-              const clipDuration = Math.min(durationSec, durationInSeconds);
-              let fileName = _path.basename(path);
-              let publicFilePath = `public/${fileName}`;
-              inputFiles.push(`-ss 0 -t ${clipDuration} -i "${publicFilePath}"`);
-            }
+      if (outFile && fs.existsSync(outFile)) {
+        let perf = new PerformanceRecorder()
+        // First, get the overlay video duration to use as master duration
+        const getVideoDuration = `ffprobe -v quiet -show_entries format=duration -of csv=p=0 "${outFile}"`;
+        exec(getVideoDuration, (error, stdout, stderr) => {
+          if (error) {
+            console.error(`Error getting overlay duration: ${error.message}`);
+            reject(error);
+            return;
           }
-          sceneIndex++;
-        });
 
-        // Add the front overlay video (transparent webm) - this controls the final duration
-        inputFiles.push(`-i "${outFile}"`);
-
-        if (inputFiles.length > 1) {
-          // Build the ffmpeg command
-          const inputPart = inputFiles.join(' ');
-          const frontVideoIndex = inputFiles.length - 1; // Last input is the front video (master duration)
-          const backVideoIndex = 0; // First input is the back video
-
-          // Create filter complex for overlay with transparency
-          const filterComplex = `"[${frontVideoIndex}:v]colorkey=0x000000:0.08:0.02[fg];[${backVideoIndex}:v][fg]overlay=0:0:format=auto"`;
-
-          // Remove -shortest so the output duration matches the overlay video (outFile)
-          ffmpegCommand = `ffmpeg ${inputPart} -filter_complex ${filterComplex} -c:v libx264 -pix_fmt yuv420p final_${jobId}.mp4`;
-        }
-        else {
-          resolve('No input files to process. Skipping split-render post process');
-          return
-        }
-
-        //run ffmpeg command 
-        if (ffmpegCommand) {
-          console.log('Running ffmpeg command:', ffmpegCommand);
-          exec(ffmpegCommand, (error, stdout, stderr) => {
-            if (error) {
-              console.error(`Error: ${error.message}`);
-              reject(error);
-              return;
-            }
-            if (stderr) {
-              console.error(`Error: ${stderr}`);
-              reject(new Error(stderr));
-              return;
+          const overlayDuration = parseFloat(stdout.trim());
+          console.log(`Overlay duration: ${overlayDuration} seconds`);
+
+          let inputFiles = [];
+          let sceneIndex = 0;
+
+          originalManuscript.transcript.forEach(scene => {
+            let durationInSeconds = scene.durationInSeconds
+            scene.mediaAbsPaths = _.cloneDeep(scene._mediaAbsPaths)
+            delete scene._mediaAbsPaths
+
+            for (let i = 0; i < scene.mediaAbsPaths.length; i++) {
+              const { path, type, dimensions, durationSec } = scene.mediaAbsPaths[i];
+              const { width, height } = dimensions;
+              if (type === 'video') {
+                // Clip the video to the minimum of scene duration, file duration, or overlay duration
+                const clipDuration = Math.min(durationSec, durationInSeconds, overlayDuration);
+                let fileName = _path.basename(path);
+                let publicFilePath = `public/${fileName}`;
+                inputFiles.push(`-ss 0 -t ${clipDuration} -i "${publicFilePath}"`);
+              }
             }
-            console.log(`Output: ${stdout}`);
-            resolve(stdout);
+            sceneIndex++;
           });
-        } else {
-          resolve('No ffmpeg command generated');
-        }
+
+          // Add the front overlay video (transparent webm) - this controls the final duration
+          inputFiles.push(`-ss 0 -t ${overlayDuration} -i "${outFile}"`);
+          const finalOutFile = `out/final_${jobId}.mp4`
+
+          if (inputFiles.length > 1) {
+            // Build the ffmpeg command
+            const inputPart = inputFiles.join(' ');
+            const frontVideoIndex = inputFiles.length - 1; // Last input is the front video (master duration)
+            const backVideoIndex = 0; // First input is the back video
+
+            // Create filter complex for overlay with transparency
+            const filterComplex = `"[${frontVideoIndex}:v]colorkey=0x000000:0.08:0.02[fg];[${backVideoIndex}:v][fg]overlay=0:0:format=auto"`;
+
+            // Remove -shortest so the output duration matches the overlay video (outFile)
+            ffmpegCommand = `ffmpeg ${inputPart} -filter_complex ${filterComplex} -c:v libx264 -pix_fmt yuv420p ${finalOutFile}`;
+          }
+          else {
+            resolve('No input files to process. Skipping split-render post process');
+            return
+          }
+
+          //run ffmpeg command 
+          if (ffmpegCommand) {
+            console.log('Running ffmpeg command:', ffmpegCommand);
+
+            const { spawn } = require('child_process');
+            const ffmpegProcess = spawn('ffmpeg', ffmpegCommand.split(' ').slice(1), { stdio: 'pipe' });
+
+            let stdoutData = '';
+            let stderrData = '';
+
+            // Stream stdout in real-time
+            ffmpegProcess.stdout.on('data', (data) => {
+              const output = data.toString();
+              console.log('[FFmpeg stdout]:', output);
+              stdoutData += output;
+            });
+
+            // Stream stderr in real-time (FFmpeg outputs progress info to stderr)
+            ffmpegProcess.stderr.on('data', (data) => {
+              const output = data.toString();
+              console.log('[FFmpeg stderr]:', output);
+              stderrData += output;
+            });
+
+            ffmpegProcess.on('close', (code) => {
+              if (code === 0) {
+                fs.renameSync(outFile, 'raw_' + outFile)
+                fs.renameSync(finalOutFile, outFile)
+                console.log('FFmpeg process completed successfully, took ', perf.elapsedString());
+                resolve(stdoutData || 'FFmpeg completed successfully');
+              } else {
+                const fullErrorLog = `FFmpeg process exited with code ${code}\n\nSTDOUT:\n${stdoutData}\n\nSTDERR:\n${stderrData}`;
+                console.error('FFmpeg failed:', fullErrorLog);
+                reject(new Error(fullErrorLog));
+              }
+            });
+
+            ffmpegProcess.on('error', (error) => {
+              const fullErrorLog = `FFmpeg spawn error: ${error.message}\n\nSTDOUT:\n${stdoutData}\n\nSTDERR:\n${stderrData}`;
+              console.error('FFmpeg spawn error:', fullErrorLog);
+              reject(new Error(fullErrorLog));
+            });
+          } else {
+            resolve('No ffmpeg command generated');
+          }
+        });
       } else {
         resolve('No output file found');
       }