Update converters/video_converter.py

converters/video_converter.py

@@ -5,13 +5,17 @@ from typing import Callable, Dict, Any
 import shutil
 import traceback
 
-# Find ffmpeg
-ffmpeg_path = shutil.which('ffmpeg') or shutil.which('ffmpeg.exe')
+
+# Find FFmpeg
+ffmpeg_path = shutil.which("ffmpeg") or shutil.which("ffmpeg.exe")
+
 if not ffmpeg_path:
+
     common_paths = [
         r"C:\ffmpeg\bin\ffmpeg.exe",
         r"C:\Program Files\ffmpeg\bin\ffmpeg.exe",
     ]
+
     for path in common_paths:
         if os.path.exists(path):
             ffmpeg_path = path
@@ -19,84 +23,220 @@ if not ffmpeg_path:
 
 
 class VideoConverter:
+
+    SUPPORTED_FORMATS = {
+        ".mp4",
+        ".avi",
+        ".mkv",
+        ".mov",
+        ".webm",
+        ".gif"
+    }
+
     def __init__(self):
+
         self.ffmpeg_available = self._check_ffmpeg()
 
     def _check_ffmpeg(self):
-        """Check if ffmpeg is installed"""
+
         if not ffmpeg_path or not os.path.exists(ffmpeg_path):
-            print("⚠ FFmpeg not found. Video conversion will not work.")
+
+            print("⚠ FFmpeg not found")
+
             return False
+
         return True
 
-    def convert(self, input_path: str, output_path: str,
-                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
-        """Convert video files using ffmpeg"""
+    def convert(
+        self,
+        input_path: str,
+        output_path: str,
+        options: Dict[str, Any] | None = None,
+        progress_callback: Callable = None
+    ) -> bool:
+
+        options = options or {}
+
         try:
+
             if not self.ffmpeg_available:
-                print("FFmpeg not available for video conversion")
+                print("FFmpeg not available")
                 return False
 
             self._update_progress(progress_callback, 10)
 
-            # Check input file
+            # Validate input
             if not os.path.exists(input_path):
-                print(f"Input file not found: {input_path}")
-                return False
+                raise FileNotFoundError(input_path)
 
-            # Build ffmpeg command
-            cmd = [ffmpeg_path, '-i', input_path, '-y']
+            input_ext = Path(input_path).suffix.lower()
+            output_ext = Path(output_path).suffix.lower()
 
-            # Add quality settings
-            quality_settings = options.get("quality_settings", {})
-            crf_value = quality_settings.get("video", "23")
+            if output_ext not in self.SUPPORTED_FORMATS:
+                raise ValueError(
+                    f"Unsupported format: {output_ext}"
+                )
 
-            # Output format specific settings
-            output_ext = Path(output_path).suffix.lower()
+            # Create output directory
+            Path(output_path).parent.mkdir(
+                parents=True,
+                exist_ok=True
+            )
+
+            self._update_progress(progress_callback, 20)
+
+            # Quality settings
+            quality_settings = options.get(
+                "quality_settings",
+                {}
+            )
+
+            crf_value = str(
+                quality_settings.get("video", "23")
+            )
+
+            # Base command
+            cmd = [
+                ffmpeg_path,
+                "-y",
+                "-i",
+                input_path
+            ]
+
+            # Video filters
+            video_filters = []
+
+            # AI enhancement
+            if options.get("ai_enhancement", False):
 
-            format_settings = {
-                '.mp4': ['-c:v', 'libx264', '-preset', 'medium', '-crf', crf_value, '-c:a', 'aac', '-b:a', '128k'],
-                '.avi': ['-c:v', 'libxvid', '-q:v', '4', '-c:a', 'mp3', '-b:a', '192k'],
-                '.mkv': ['-c:v', 'libx264', '-crf', crf_value, '-c:a', 'aac'],
-                '.mov': ['-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-c:a', 'aac'],
-                '.webm': ['-c:v', 'libvpx-vp9', '-crf', crf_value, '-b:v', '0', '-c:a', 'libopus'],
-                '.gif': ['-vf', 'fps=10,scale=320:-1:flags=lanczos', '-c:v', 'gif']
-            }
+                video_filters.append(
+                    "unsharp=5:5:1.0:5:5:0.0"
+                )
 
-            if output_ext in format_settings:
-                cmd.extend(format_settings[output_ext])
+            # Format settings
+            if output_ext == ".mp4":
 
-            # Add AI enhancement
-            if options.get("ai_enhancement", False):
-                cmd.extend(['-vf', 'unsharp=5:5:1.0:5:5:0.0'])
+                cmd.extend([
+                    "-c:v", "libx264",
+                    "-preset", "medium",
+                    "-crf", crf_value,
+                    "-c:a", "aac",
+                    "-b:a", "128k"
+                ])
 
-            # Create output directory
-            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
-            cmd.append(output_path)
+            elif output_ext == ".avi":
+
+                cmd.extend([
+                    "-c:v", "libxvid",
+                    "-q:v", "4",
+                    "-c:a", "mp3",
+                    "-b:a", "192k"
+                ])
+
+            elif output_ext == ".mkv":
+
+                cmd.extend([
+                    "-c:v", "libx264",
+                    "-crf", crf_value,
+                    "-c:a", "aac"
+                ])
+
+            elif output_ext == ".mov":
+
+                cmd.extend([
+                    "-c:v", "libx264",
+                    "-pix_fmt", "yuv420p",
+                    "-c:a", "aac"
+                ])
+
+            elif output_ext == ".webm":
+
+                cmd.extend([
+                    "-c:v", "libvpx-vp9",
+                    "-crf", crf_value,
+                    "-b:v", "0",
+                    "-c:a", "libopus"
+                ])
+
+            elif output_ext == ".gif":
+
+                video_filters.append(
+                    "fps=10,scale=320:-1:flags=lanczos"
+                )
+
+                cmd.extend([
+                    "-loop", "0"
+                ])
+
+            # Apply filters safely
+            if video_filters:
+
+                cmd.extend([
+                    "-vf",
+                    ",".join(video_filters)
+                ])
 
             self._update_progress(progress_callback, 50)
 
+            # Output path
+            cmd.append(output_path)
+
             # Run ffmpeg
-            result = subprocess.run(cmd, capture_output=True, text=True)
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=600
+            )
 
-            self._update_progress(progress_callback, 100)
+            self._update_progress(progress_callback, 90)
+
+            if result.returncode != 0:
+
+                print("FFmpeg Error:")
+                print(result.stderr[:500])
 
-            if result.returncode == 0:
-                print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
-                return True
-            else:
-                print(f"FFmpeg error: {result.stderr[:200]}")
                 return False
 
+            self._update_progress(progress_callback, 100)
+
+            print(
+                f"✓ Converted: "
+                f"{os.path.basename(input_path)} "
+                f"→ {output_ext}"
+            )
+
+            return True
+
+        except subprocess.TimeoutExpired:
+
+            print("Video conversion timed out")
+
+            return False
+
         except Exception as e:
-            print(f"Video conversion error for {input_path}: {str(e)}")
+
+            print(
+                f"Video conversion error: {e}"
+            )
+
             traceback.print_exc()
+
             return False
 
-    def _update_progress(self, callback, value):
-        """Safely update progress"""
-        if callback is not None:
-            try:
+    def _update_progress(
+        self,
+        callback,
+        value
+    ):
+
+        try:
+
+            if callback:
                 callback(value)
-            except Exception:
-                pass
+
+        except Exception as e:
+
+            print(
+                f"Progress callback error: {e}"
+            )