feat: Implement GPU optimization for FFmpeg commands and enhance filter conversion

app.py

@@ -139,6 +139,8 @@ Key requirements:
     - If the user asks for waveform visualization make sure to set the mode to `line` with and the use the full width of the video. Also concatenate the audio into a single channel.
     - For image sequences: Use -framerate and pattern matching (like 'img%d.jpg') when possible, falling back to individual image processing with -loop 1 and appropriate filters only when necessary.
     - When showing file operations or commands, always use explicit paths and filenames without wildcards - avoid using asterisk (*) or glob patterns. Instead, use specific numbered sequences (like %d), explicit file lists, or show the full filename.
+    - GPU optimization will be handled automatically - use standard CPU filter names (scale, overlay, etc.) and they will be converted to GPU equivalents when possible
+    - Prefer using standard codecs like libx264 or libx265 - GPU acceleration for decoding will be added automatically
 
 Remember: Simpler is better. Only use advanced ffmpeg features if absolutely necessary for the requested output.
 """,
@@ -229,12 +231,80 @@ YOUR RESPONSE:
 @spaces.GPU(duration=120)
 def execute_ffmpeg_command(args, temp_dir, output_file_path):
     """Execute FFmpeg command with GPU acceleration"""
-    final_command = args + ["-y", output_file_path]
+    # Add GPU acceleration options if not already present
+    optimized_args = optimize_ffmpeg_for_gpu(args)
+    final_command = optimized_args + ["-y", output_file_path]
     print(f"\n=== EXECUTING FFMPEG COMMAND ===\nffmpeg {' '.join(final_command[1:])}\n")
     subprocess.run(final_command, cwd=temp_dir)
     return output_file_path
 
 
+def optimize_ffmpeg_for_gpu(args):
+    """Optimize FFmpeg command for GPU acceleration without NVENC"""
+    optimized = ["ffmpeg"]
+    
+    # Add hardware acceleration for decoding
+    if "-hwaccel" not in args:
+        optimized.extend(["-hwaccel", "cuda"])
+    
+    # Add CUDA device selection (use GPU 0 by default)
+    if "-hwaccel_device" not in args:
+        optimized.extend(["-hwaccel_device", "0"])
+    
+    # Add pixel format for CUDA processing
+    cuda_filters_needed = any("-vf" in str(arg) or "-filter_complex" in str(arg) for arg in args)
+    
+    # Add the rest of the original arguments (skip the first 'ffmpeg')
+    for i, arg in enumerate(args[1:], 1):
+        if arg == "-c:v" and i < len(args) - 1:
+            # Use GPU-accelerated codecs when available
+            next_arg = args[i + 1]
+            if next_arg == "libx264":
+                optimized.extend(["-c:v", "h264_cuvid" if cuda_filters_needed else "libx264"])
+                continue
+            elif next_arg == "libx265":
+                optimized.extend(["-c:v", "hevc_cuvid" if cuda_filters_needed else "libx265"])
+                continue
+        
+        # Convert CPU filters to GPU equivalents where possible
+        if arg == "-vf" and i < len(args) - 1:
+            gpu_filter = convert_filters_to_gpu(args[i + 1])
+            optimized.extend(["-vf", gpu_filter])
+            continue
+        elif arg == "-filter_complex" and i < len(args) - 1:
+            gpu_filter = convert_filters_to_gpu(args[i + 1])
+            optimized.extend(["-filter_complex", gpu_filter])
+            continue
+            
+        optimized.append(arg)
+    
+    return optimized
+
+
+def convert_filters_to_gpu(filter_string):
+    """Convert CPU filters to GPU-accelerated equivalents"""
+    # Common filter conversions for CUDA
+    gpu_filters = {
+        'scale=': 'scale_cuda=',
+        'overlay=': 'overlay_cuda=',
+        'transpose=': 'transpose_cuda=',
+        'crop=': 'crop_cuda=',
+        'pad=': 'pad_cuda=',
+        'format=yuv420p': 'format=nv12',  # Better GPU format
+    }
+    
+    gpu_filter = filter_string
+    for cpu_filter, gpu_equivalent in gpu_filters.items():
+        if cpu_filter in gpu_filter:
+            gpu_filter = gpu_filter.replace(cpu_filter, gpu_equivalent)
+    
+    # Add format conversion for GPU processing
+    if 'cuda' in gpu_filter and 'format=' not in gpu_filter:
+        gpu_filter = f"format=nv12,{gpu_filter},format=yuv420p"
+    
+    return gpu_filter
+
+
 def compose_video(
     prompt: str,
     files: list = None,