Update server.js

server.js

@@ -1,8 +1,8 @@
 import express from 'express';
 import cors from 'cors';
 import { bundle } from '@remotion/bundler';
-import { renderMedia, selectComposition } from '@remotion/renderer';
-import { readFile, mkdir, rm } from 'fs/promises';
+import { renderFrames, stitchFramesToVideo } from '@remotion/renderer';
+import { readFile, mkdir, rm, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join, dirname } from 'path';
 import { randomUUID } from 'crypto';
@@ -27,7 +27,7 @@ app.get('/', (req, res) => {
     res.json({ 
         status: 'ok', 
         service: 'FacelessFlowAI Video Renderer',
-        note: 'Using system FFmpeg for hardware acceleration'
+        note: 'Custom rendering pipeline with NVENC'
     });
 });
 
@@ -74,54 +74,138 @@ async function getCachedBundle() {
     }
 }
 
-// Check which FFmpeg encoders are available
-async function getAvailableEncoders() {
-    try {
-        const { execSync } = await import('child_process');
-        const output = execSync('ffmpeg -encoders 2>&1', { encoding: 'utf8' });
-        
-        const encoders = {
-            nvenc: output.includes('h264_nvenc'),
-            libx264: output.includes('libx264'),
-            systemFfmpeg: !output.includes('remotion'), // Check if it's system FFmpeg
-        };
-        
-        console.log('[FFmpeg] Available encoders:', encoders);
-        return encoders;
-    } catch (error) {
-        console.log('[FFmpeg] Could not check encoders:', error.message);
-        return { nvenc: false, libx264: true, systemFfmpeg: false };
-    }
-}
-
-// Force use of system FFmpeg
-async function useSystemFFmpeg() {
+// Custom video stitching with system FFmpeg
+async function stitchFramesWithNVENC(frameDir, fps, outputPath, width = 1920, height = 1080) {
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    
     try {
-        const { execSync } = await import('child_process');
+        console.log('[NVENC] Starting hardware encoding with system FFmpeg');
         
-        // Get system FFmpeg path
-        const ffmpegPath = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
-        console.log(`[FFmpeg] System FFmpeg found at: ${ffmpegPath}`);
+        // First, check if NVENC is available
+        const { stdout: encoderCheck } = await execAsync('ffmpeg -encoders 2>&1 | grep -i nvenc');
+        const hasNVENC = encoderCheck.includes('h264_nvenc');
         
-        // Check if it has NVENC
-        const encoders = execSync(`${ffmpegPath} -encoders 2>&1 | grep -i nvenc`, { encoding: 'utf8' });
-        const hasNvenc = encoders.includes('h264_nvenc');
+        if (hasNVENC) {
+            console.log('[NVENC] Using hardware encoding');
+            
+            // Build FFmpeg command for NVENC
+            const ffmpegCmd = [
+                'ffmpeg',
+                '-y', // Overwrite output
+                '-framerate', String(fps),
+                '-i', `${frameDir}/%d.png`, // Input frames
+                '-c:v', 'h264_nvenc', // NVENC encoder
+                '-preset', 'p1', // Fastest quality preset
+                '-cq', '20', // Constant quality
+                '-movflags', '+faststart',
+                '-pix_fmt', 'yuv420p',
+                '-vf', `scale=${width}:${height}:flags=lanczos`,
+                '-c:a', 'aac',
+                '-b:a', '192k',
+                outputPath
+            ].join(' ');
+            
+            console.log(`[NVENC] Command: ${ffmpegCmd}`);
+            
+            const { stdout, stderr } = await execAsync(ffmpegCmd, { maxBuffer: 1024 * 1024 * 50 });
+            console.log('[NVENC] Encoding completed');
+            
+        } else {
+            console.log('[NVENC] Falling back to software encoding');
+            
+            // Fallback to software encoding
+            const ffmpegCmd = [
+                'ffmpeg',
+                '-y',
+                '-framerate', String(fps),
+                '-i', `${frameDir}/%d.png`,
+                '-c:v', 'libx264',
+                '-preset', 'fast',
+                '-crf', '23',
+                '-movflags', '+faststart',
+                '-pix_fmt', 'yuv420p',
+                '-vf', `scale=${width}:${height}:flags=lanczos`,
+                '-c:a', 'aac',
+                '-b:a', '192k',
+                outputPath
+            ].join(' ');
+            
+            const { stdout, stderr } = await execAsync(ffmpegCmd, { maxBuffer: 1024 * 1024 * 50 });
+            console.log('[Software] Encoding completed');
+        }
         
-        console.log(`[FFmpeg] System FFmpeg has NVENC: ${hasNvenc}`);
+        return true;
         
-        return {
-            path: ffmpegPath,
-            hasNvenc: hasNvenc
-        };
     } catch (error) {
-        console.log('[FFmpeg] Using default FFmpeg');
-        return {
-            path: 'ffmpeg',
-            hasNvenc: false
-        };
+        console.error('[Encoding] Error:', error.message);
+        throw error;
     }
 }
 
+// Custom render pipeline
+async function customRender(composition, bundleLocation, scenes, settings, outputPath) {
+    const startTime = Date.now();
+    
+    console.log('[Custom Render] Starting frame rendering...');
+    
+    // Step 1: Render frames
+    const frameDir = join(tmpdir(), `frames-${randomUUID()}`);
+    await mkdir(frameDir, { recursive: true });
+    
+    const renderStart = Date.now();
+    
+    await renderFrames({
+        config: composition,
+        serveUrl: bundleLocation,
+        onStart: ({ frameCount }) => {
+            console.log(`[Frames] Rendering ${frameCount} frames`);
+        },
+        onFrameUpdate: ({ renderedFrames, encodedFrames }) => {
+            const percent = Math.round((renderedFrames / composition.durationInFrames) * 100);
+            const elapsed = (Date.now() - renderStart) / 1000;
+            const fps = elapsed > 0 ? Math.round(renderedFrames / elapsed) : 0;
+            console.log(`[Frames] ${percent}% | FPS: ${fps} | Rendered: ${renderedFrames}/${composition.durationInFrames}`);
+        },
+        outputDir: frameDir,
+        inputProps: { scenes, settings },
+        imageFormat: 'png',
+        compositionId: composition.id,
+        concurrency: 6,
+        chromiumOptions: {
+            executablePath: '/usr/bin/google-chrome-stable',
+            args: ['--no-sandbox', '--disable-dev-shm-usage']
+        },
+    });
+    
+    const frameTime = Date.now() - renderStart;
+    console.log(`[Frames] Completed in ${Math.round(frameTime / 1000)}s`);
+    
+    // Step 2: Stitch frames with NVENC
+    console.log('[Custom Render] Stitching frames to video...');
+    const stitchStart = Date.now();
+    
+    await stitchFramesWithNVENC(
+        frameDir,
+        composition.fps,
+        outputPath,
+        composition.width,
+        composition.height
+    );
+    
+    const stitchTime = Date.now() - stitchStart;
+    console.log(`[Stitching] Completed in ${Math.round(stitchTime / 1000)}s`);
+    
+    // Step 3: Cleanup frames
+    await rm(frameDir, { recursive: true, force: true });
+    
+    const totalTime = Date.now() - startTime;
+    console.log(`[Custom Render] Total time: ${Math.round(totalTime / 1000)}s`);
+    
+    return totalTime;
+}
+
 // Render endpoint
 app.post('/render', async (req, res) => {
     const { projectId, scenes, settings } = req.body;
@@ -145,7 +229,8 @@ app.post('/render', async (req, res) => {
     // 1. Respond immediately
     res.json({ 
         success: true, 
-        message: 'Rendering started in background'
+        message: 'Rendering started in background',
+        note: 'Using custom render pipeline with hardware acceleration'
     });
 
     // 2. Start Background Process
@@ -158,19 +243,17 @@ app.post('/render', async (req, res) => {
             const bundleLocation = await getCachedBundle();
             console.log('[Bundle] Bundle ready');
 
-            // Get system FFmpeg info
-            const ffmpegInfo = await useSystemFFmpeg();
-            console.log(`[FFmpeg] Using: ${ffmpegInfo.path}, NVENC: ${ffmpegInfo.hasNvenc}`);
-
-            const composition = await selectComposition({
-                serveUrl: bundleLocation,
-                id: 'Main',
-                inputProps: { scenes, settings },
-                chromiumOptions: {
-                    executablePath: '/usr/bin/google-chrome-stable',
-                    args: ['--no-sandbox', '--disable-dev-shm-usage']
-                },
-            });
+            const composition = await import('@remotion/renderer').then(mod => 
+                mod.selectComposition({
+                    serveUrl: bundleLocation,
+                    id: 'Main',
+                    inputProps: { scenes, settings },
+                    chromiumOptions: {
+                        executablePath: '/usr/bin/google-chrome-stable',
+                        args: ['--no-sandbox', '--disable-dev-shm-usage']
+                    },
+                })
+            );
             
             console.log(`[Composition] Loaded: ${composition.durationInFrames} frames at ${composition.fps}fps`);
 
@@ -178,64 +261,16 @@ app.post('/render', async (req, res) => {
             await mkdir(tempDir, { recursive: true });
             const outputPath = join(tempDir, 'output.mp4');
 
-            console.log('[Render] Starting video rendering...');
+            console.log('[Render] Starting custom render pipeline...');
             
-            await renderMedia({
+            const renderTime = await customRender(
                 composition,
-                serveUrl: bundleLocation,
-                codec: 'h264',
-                pixelFormat: 'yuv420p',
-                outputLocation: outputPath,
-                imageFormat: 'jpeg',
-                jpegQuality: 80,
-                inputProps: { scenes, settings },
-                chromiumOptions: {
-                    executablePath: '/usr/bin/google-chrome-stable',
-                    args: ['--no-sandbox', '--disable-dev-shm-usage']
-                },
-                concurrency: 6,
-                disallowParallelEncoding: false,
-                onProgress: ({ progress }) => {
-                    console.log(`[Progress] ${Math.round(progress * 100)}%`);
-                },
-                ffmpegOverride: (ff) => {
-                    console.log('[FFmpeg] Overriding FFmpeg path to use system FFmpeg');
-                    
-                    // Force use of system FFmpeg
-                    const newArgs = [
-                        ffmpegInfo.path, // Use system FFmpeg instead of Remotion's
-                        ...ff.args.slice(1) // Skip the first argument (which is the path)
-                    ];
-                    
-                    // Add NVENC settings if available
-                    if (ffmpegInfo.hasNvenc) {
-                        console.log('[FFmpeg] Adding NVENC settings');
-                        // Find where to insert video encoder settings
-                        const videoIndex = newArgs.findIndex(arg => arg === '-c:v' || arg === '-vcodec');
-                        
-                        if (videoIndex !== -1 && newArgs[videoIndex + 1] === 'libx264') {
-                            // Replace libx264 with h264_nvenc
-                            newArgs[videoIndex + 1] = 'h264_nvenc';
-                            
-                            // Add NVENC-specific settings AFTER the output file
-                            const outputIndex = newArgs.findIndex(arg => arg === outputPath);
-                            if (outputIndex !== -1) {
-                                // Insert NVENC settings before output
-                                newArgs.splice(outputIndex, 0, 
-                                    '-preset', 'p1',
-                                    '-cq', '23'
-                                );
-                            }
-                        }
-                    }
-                    
-                    return newArgs;
-                },
-                audioBitrate: '192k',
-                videoBitrate: '8M',
-            });
-
-            const renderTime = Date.now() - startTime;
+                bundleLocation,
+                scenes,
+                settings,
+                outputPath
+            );
+
             console.log(`[Render] Completed in ${Math.round(renderTime / 1000)}s`);
 
             console.log(`[Upload] Reading video file...`);
@@ -272,8 +307,7 @@ app.post('/render', async (req, res) => {
                     status: 'done',
                     video_url: publicUrl,
                     render_time: renderTime,
-                    rendered_at: new Date().toISOString(),
-                    encoding_method: ffmpegInfo.hasNvenc ? 'NVENC' : 'libx264'
+                    rendered_at: new Date().toISOString()
                 })
                 .eq('id', projectId);
 
@@ -306,70 +340,18 @@ app.post('/render', async (req, res) => {
 // Status endpoint
 app.get('/status', async (req, res) => {
     const os = await import('os');
-    const { execSync } = await import('child_process');
-    
-    let ffmpegInfo = {};
-    try {
-        const ffmpegPath = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
-        const version = execSync(`${ffmpegPath} -version 2>&1 | head -1`, { encoding: 'utf8' }).trim();
-        const encoders = execSync(`${ffmpegPath} -encoders 2>&1`, { encoding: 'utf8' });
-        
-        ffmpegInfo = {
-            path: ffmpegPath,
-            version: version,
-            has_nvenc: encoders.includes('h264_nvenc'),
-            is_system: !version.includes('remotion')
-        };
-    } catch (error) {
-        ffmpegInfo = { error: error.message };
-    }
     
     res.json({
         status: 'running',
         cpu_cores: os.cpus().length,
         total_memory: Math.round(os.totalmem() / (1024 * 1024 * 1024)) + 'GB',
         free_memory: Math.round(os.freemem() / (1024 * 1024 * 1024)) + 'GB',
-        ffmpeg: ffmpegInfo,
         bundle_cached: cachedBundle !== null,
-        uptime: Math.round(process.uptime()) + 's'
+        uptime: Math.round(process.uptime()) + 's',
+        render_method: 'Custom pipeline with hardware acceleration'
     });
 });
 
-// Direct FFmpeg test
-app.get('/test-ffmpeg', async (req, res) => {
-    try {
-        const { execSync } = await import('child_process');
-        
-        // Test 1: Which FFmpeg
-        const whichFfmpeg = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
-        
-        // Test 2: Version
-        const version = execSync(`${whichFfmpeg} -version 2>&1 | head -5`, { encoding: 'utf8' }).trim();
-        
-        // Test 3: Encoders
-        const encoders = execSync(`${whichFfmpeg} -encoders 2>&1 | grep -E "(h264_nvenc|libx264)"`, { encoding: 'utf8' }).trim();
-        
-        // Test 4: Direct NVENC test
-        let nvencTest = 'Not tested';
-        try {
-            execSync(`${whichFfmpeg} -f lavfi -i testsrc=duration=0.5:size=128x72:rate=1 -c:v h264_nvenc -y /tmp/test.mp4 2>&1`, { stdio: 'pipe' });
-            nvencTest = 'Success';
-        } catch (error) {
-            nvencTest = `Failed: ${error.message.substring(0, 100)}`;
-        }
-        
-        res.json({
-            ffmpeg_path: whichFfmpeg,
-            version: version,
-            available_encoders: encoders,
-            nvenc_test: nvencTest,
-            using_system_ffmpeg: !version.includes('remotion')
-        });
-    } catch (error) {
-        res.status(500).json({ error: error.message });
-    }
-});
-
 // Start server
 app.listen(PORT, async () => {
     console.log(`🎬 FacelessFlowAI Renderer running on port ${PORT}`);
@@ -378,33 +360,10 @@ app.listen(PORT, async () => {
     console.log(`💾 Memory: ${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`);
     console.log(`⚡ CPU Cores: ${os.cpus().length}`);
     
-    // Check FFmpeg
-    try {
-        const { execSync } = await import('child_process');
-        const ffmpegPath = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
-        const version = execSync(`${ffmpegPath} -version 2>&1 | head -1`, { encoding: 'utf8' }).trim();
-        console.log(`📹 FFmpeg: ${version}`);
-        
-        if (version.includes('remotion')) {
-            console.log('⚠️  Using Remotion FFmpeg (no NVENC)');
-        } else {
-            console.log('✅ Using system FFmpeg');
-            
-            // Check NVENC
-            try {
-                const nvenc = execSync(`${ffmpegPath} -encoders 2>&1 | grep -i nvenc`, { encoding: 'utf8' });
-                console.log(`⚡ NVENC: Available`);
-            } catch {
-                console.log('⚡ NVENC: Not in system FFmpeg');
-            }
-        }
-    } catch (error) {
-        console.log('📹 FFmpeg: Not found');
-    }
-    
     console.log('--- Configuration ---');
-    console.log('FFMPEG: Forcing system FFmpeg for hardware acceleration');
-    console.log('ENCODING: Auto-detect best available');
+    console.log('RENDER: Custom pipeline (renderFrames + FFmpeg)');
+    console.log('ENCODING: Hardware NVENC when available');
+    console.log('FRAMES: PNG format for quality');
     console.log('---------------------');
     
     // Auto-warmup