Update server.js

server.js

@@ -27,7 +27,7 @@ app.get('/', (req, res) => {
     res.json({ 
         status: 'ok', 
         service: 'FacelessFlowAI Video Renderer',
-        note: 'Auto-detect best encoding method'
+        note: 'Using system FFmpeg for hardware acceleration'
     });
 });
 
@@ -74,164 +74,55 @@ async function getCachedBundle() {
     }
 }
 
-// Test NVENC with simple command
-async function testNvencCompatibility() {
+// Check which FFmpeg encoders are available
+async function getAvailableEncoders() {
     try {
         const { execSync } = await import('child_process');
-        // Simple test command
-        const testCommand = 'ffmpeg -f lavfi -i testsrc=duration=1:size=128x72:rate=1 -c:v h264_nvenc -f null - 2>&1';
-        execSync(testCommand, { stdio: 'pipe', timeout: 5000 });
-        console.log('[NVENC Test] Basic encoding works');
-        return true;
+        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('[NVENC Test] Basic encoding failed:', error.message);
-        return false;
+        console.log('[FFmpeg] Could not check encoders:', error.message);
+        return { nvenc: false, libx264: true, systemFfmpeg: false };
     }
 }
 
-// Render with fallback mechanism
-async function renderWithFallback(composition, bundleLocation, scenes, settings, outputPath) {
-    const startTime = Date.now();
-    
-    // Try NVENC first
-    console.log('[Render] Attempt 1: Trying NVENC hardware encoding...');
+// Force use of system FFmpeg
+async function useSystemFFmpeg() {
     try {
-        await renderMedia({
-            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, renderedFrames }) => {
-                const percent = Math.round(progress * 100);
-                const elapsed = (Date.now() - startTime) / 1000;
-                const fps = elapsed > 0 ? Math.round(renderedFrames / elapsed) : 0;
-                console.log(`[NVENC Progress] ${percent}% | FPS: ${fps}`);
-            },
-            ffmpegOverride: ({ args }) => {
-                console.log('[NVENC] Using simplified NVENC settings');
-                // SIMPLIFIED NVENC SETTINGS - most compatible
-                return [
-                    ...args,
-                    '-c:v', 'h264_nvenc',
-                    '-preset', 'default',  // Most compatible preset
-                    '-cq', '23',           // Standard quality
-                    '-movflags', '+faststart',
-                    '-c:a', 'aac',
-                    '-b:a', '192k',
-                ];
-            },
-            audioBitrate: '192k',
-            videoBitrate: '8M',
-        });
+        const { execSync } = await import('child_process');
         
-        console.log(`[NVENC Success] Completed in ${Math.round((Date.now() - startTime) / 1000)}s`);
-        return 'nvenc';
+        // Get system FFmpeg path
+        const ffmpegPath = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
+        console.log(`[FFmpeg] System FFmpeg found at: ${ffmpegPath}`);
         
-    } catch (nvencError) {
-        console.log(`[NVENC Failed] ${nvencError.message}`);
+        // Check if it has NVENC
+        const encoders = execSync(`${ffmpegPath} -encoders 2>&1 | grep -i nvenc`, { encoding: 'utf8' });
+        const hasNvenc = encoders.includes('h264_nvenc');
         
-        // Try even simpler NVENC
-        console.log('[Render] Attempt 2: Trying minimal NVENC settings...');
-        try {
-            await renderMedia({
-                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: 4,
-                disallowParallelEncoding: true, // More stable
-                onProgress: ({ progress }) => {
-                    console.log(`[NVENC2 Progress] ${Math.round(progress * 100)}%`);
-                },
-                ffmpegOverride: ({ args }) => {
-                    console.log('[NVENC2] Using minimal NVENC settings');
-                    // MINIMAL NVENC SETTINGS
-                    return [
-                        ...args,
-                        '-c:v', 'h264_nvenc',
-                        '-preset', 'p1',
-                        '-movflags', '+faststart',
-                        '-c:a', 'aac',
-                        '-b:a', '192k',
-                    ];
-                },
-                audioBitrate: '192k',
-                videoBitrate: '4M',
-            });
-            
-            console.log(`[NVENC2 Success] Completed in ${Math.round((Date.now() - startTime) / 1000)}s`);
-            return 'nvenc_minimal';
-            
-        } catch (nvenc2Error) {
-            console.log(`[NVENC2 Failed] ${nvenc2Error.message}`);
-            
-            // Fallback to software encoding
-            console.log('[Render] Attempt 3: Falling back to software encoding...');
-            try {
-                await renderMedia({
-                    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: 4,
-                    disallowParallelEncoding: true,
-                    onProgress: ({ progress }) => {
-                        console.log(`[CPU Progress] ${Math.round(progress * 100)}%`);
-                    },
-                    ffmpegOverride: ({ args }) => {
-                        console.log('[CPU] Using software encoding');
-                        return [
-                            ...args,
-                            '-c:v', 'libx264',
-                            '-preset', 'fast',
-                            '-crf', '23',
-                            '-movflags', '+faststart',
-                            '-c:a', 'aac',
-                            '-b:a', '192k',
-                        ];
-                    },
-                    audioBitrate: '192k',
-                    videoBitrate: '4M',
-                });
-                
-                console.log(`[CPU Success] Completed in ${Math.round((Date.now() - startTime) / 1000)}s`);
-                return 'cpu';
-                
-            } catch (cpuError) {
-                console.log(`[CPU Failed] ${cpuError.message}`);
-                throw new Error(`All encoding methods failed. Last error: ${cpuError.message}`);
-            }
-        }
+        console.log(`[FFmpeg] System FFmpeg has NVENC: ${hasNvenc}`);
+        
+        return {
+            path: ffmpegPath,
+            hasNvenc: hasNvenc
+        };
+    } catch (error) {
+        console.log('[FFmpeg] Using default FFmpeg');
+        return {
+            path: 'ffmpeg',
+            hasNvenc: false
+        };
     }
 }
 
-// Render endpoint with intelligent fallback
+// Render endpoint
 app.post('/render', async (req, res) => {
     const { projectId, scenes, settings } = req.body;
 
@@ -254,8 +145,7 @@ app.post('/render', async (req, res) => {
     // 1. Respond immediately
     res.json({ 
         success: true, 
-        message: 'Rendering started in background',
-        note: 'Using intelligent encoding detection'
+        message: 'Rendering started in background'
     });
 
     // 2. Start Background Process
@@ -268,6 +158,10 @@ 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',
@@ -284,22 +178,65 @@ app.post('/render', async (req, res) => {
             await mkdir(tempDir, { recursive: true });
             const outputPath = join(tempDir, 'output.mp4');
 
-            console.log('[Render] Starting intelligent rendering...');
+            console.log('[Render] Starting video rendering...');
             
-            // Test NVENC compatibility first
-            const nvencCompatible = await testNvencCompatibility();
-            console.log(`[Compatibility] NVENC compatible: ${nvencCompatible}`);
-            
-            const encodingMethod = await renderWithFallback(
-                composition, 
-                bundleLocation, 
-                scenes, 
-                settings, 
-                outputPath
-            );
+            await renderMedia({
+                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 totalTime = Date.now() - startTime;
-            console.log(`[Render] Completed in ${Math.round(totalTime / 1000)}s using ${encodingMethod}`);
+            const renderTime = Date.now() - startTime;
+            console.log(`[Render] Completed in ${Math.round(renderTime / 1000)}s`);
 
             console.log(`[Upload] Reading video file...`);
             const videoBuffer = await readFile(outputPath);
@@ -334,9 +271,9 @@ app.post('/render', async (req, res) => {
                 .update({
                     status: 'done',
                     video_url: publicUrl,
-                    render_time: totalTime,
+                    render_time: renderTime,
                     rendered_at: new Date().toISOString(),
-                    encoding_method: encodingMethod
+                    encoding_method: ffmpegInfo.hasNvenc ? 'NVENC' : 'libx264'
                 })
                 .eq('id', projectId);
 
@@ -369,15 +306,22 @@ 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');
     
-    // Test NVENC compatibility
-    let nvencStatus = 'Unknown';
+    let ffmpegInfo = {};
     try {
-        const { execSync } = await import('child_process');
-        execSync('ffmpeg -encoders 2>/dev/null | grep -i nvenc', { stdio: 'pipe' });
-        nvencStatus = 'Detected (needs test)';
-    } catch {
-        nvencStatus = 'Not detected';
+        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({
@@ -385,59 +329,42 @@ app.get('/status', async (req, res) => {
         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',
-        nvenc: nvencStatus,
+        ffmpeg: ffmpegInfo,
         bundle_cached: cachedBundle !== null,
-        uptime: Math.round(process.uptime()) + 's',
-        strategy: 'Intelligent fallback (NVENC → CPU)'
+        uptime: Math.round(process.uptime()) + 's'
     });
 });
 
-// Enhanced NVENC test
-app.get('/test-nvenc-full', async (req, res) => {
+// Direct FFmpeg test
+app.get('/test-ffmpeg', async (req, res) => {
     try {
         const { execSync } = await import('child_process');
-        const fs = await import('fs');
         
-        const tests = [];
+        // Test 1: Which FFmpeg
+        const whichFfmpeg = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
         
-        // Test 1: Check if NVENC encoder exists
-        try {
-            const encoders = execSync('ffmpeg -encoders 2>/dev/null | grep -i nvenc', { encoding: 'utf8' });
-            tests.push({ test: 'NVENC encoders exist', result: 'PASS', details: encoders.trim() });
-        } catch {
-            tests.push({ test: 'NVENC encoders exist', result: 'FAIL', details: 'Not found' });
-        }
-        
-        // Test 2: Try simple encoding
-        try {
-            execSync('ffmpeg -f lavfi -i testsrc=duration=0.1:size=64x36:rate=1 -c:v h264_nvenc -f null - 2>&1', { stdio: 'pipe' });
-            tests.push({ test: 'Simple NVENC encode', result: 'PASS', details: 'Works' });
-        } catch (error) {
-            tests.push({ test: 'Simple NVENC encode', result: 'FAIL', details: error.message.substring(0, 100) });
-        }
+        // Test 2: Version
+        const version = execSync(`${whichFfmpeg} -version 2>&1 | head -5`, { encoding: 'utf8' }).trim();
         
-        // Test 3: Try with CQ parameter
-        try {
-            execSync('ffmpeg -f lavfi -i testsrc=duration=0.1:size=64x36:rate=1 -c:v h264_nvenc -cq 23 -f null - 2>&1', { stdio: 'pipe' });
-            tests.push({ test: 'NVENC with CQ', result: 'PASS', details: 'Works' });
-        } catch (error) {
-            tests.push({ test: 'NVENC with CQ', result: 'FAIL', details: error.message.substring(0, 100) });
-        }
+        // Test 3: Encoders
+        const encoders = execSync(`${whichFfmpeg} -encoders 2>&1 | grep -E "(h264_nvenc|libx264)"`, { encoding: 'utf8' }).trim();
         
-        // Test 4: Try with preset
+        // Test 4: Direct NVENC test
+        let nvencTest = 'Not tested';
         try {
-            execSync('ffmpeg -f lavfi -i testsrc=duration=0.1:size=64x36:rate=1 -c:v h264_nvenc -preset p1 -f null - 2>&1', { stdio: 'pipe' });
-            tests.push({ test: 'NVENC with preset', result: 'PASS', details: 'Works' });
+            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) {
-            tests.push({ test: 'NVENC with preset', result: 'FAIL', details: error.message.substring(0, 100) });
+            nvencTest = `Failed: ${error.message.substring(0, 100)}`;
         }
         
         res.json({
-            hardware: 'L4 GPU Tests',
-            tests: tests,
-            summary: `${tests.filter(t => t.result === 'PASS').length}/${tests.length} tests passed`
+            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 });
     }
@@ -451,10 +378,33 @@ 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('STRATEGY: Intelligent fallback (NVENC → CPU)');
-    console.log('CONCURRENCY: Adaptive');
-    console.log('QUALITY: Adaptive');
+    console.log('FFMPEG: Forcing system FFmpeg for hardware acceleration');
+    console.log('ENCODING: Auto-detect best available');
     console.log('---------------------');
     
     // Auto-warmup