Update converters/audio_converter.py

converters/audio_converter.py

@@ -1,99 +1,130 @@
 import os
+import shutil
 from pathlib import Path
 from typing import Callable, Dict, Any
-import traceback
 
-# Setup ffmpeg for pydub
-import shutil
+# Setup FFmpeg
+ffmpeg_path = shutil.which("ffmpeg") or shutil.which("ffmpeg.exe")
 
-ffmpeg_path = shutil.which('ffmpeg') or shutil.which('ffmpeg.exe')
 if ffmpeg_path:
     os.environ["FFMPEG_BINARY"] = ffmpeg_path
 
-try:
-    from pydub import AudioSegment
-
-    PYDUB_AVAILABLE = True
-except ImportError:
-    PYDUB_AVAILABLE = False
-    print("pydub not installed. Audio conversion will not work.")
+from pydub import AudioSegment
 
 
 class AudioConverter:
-    def __init__(self):
-        pass
 
-    def convert(self, input_path: str, output_path: str,
-                options: Dict[str, Any], progress_callback: Callable = None) -> bool:
-        """Convert audio files"""
-        try:
-            if not PYDUB_AVAILABLE:
-                print("pydub library not available")
-                return False
+    SUPPORTED_FORMATS = {
+        ".mp3",
+        ".wav",
+        ".flac",
+        ".ogg",
+        ".aac",
+        ".m4a",
+        ".wma"
+    }
+
+    def convert(
+        self,
+        input_path: str,
+        output_path: str,
+        options: Dict[str, Any] | None = None,
+        progress_callback: Callable | None = None
+    ) -> bool:
+
+        options = options or {}
 
-            self._update_progress(progress_callback, 10)
+        try:
+            self._update(progress_callback, 10)
 
-            # Check if input file exists
+            # Check input file
             if not os.path.exists(input_path):
-                print(f"Input file not found: {input_path}")
-                return False
+                raise FileNotFoundError(f"Input file not found: {input_path}")
+
+            input_ext = Path(input_path).suffix.lower()
+            output_ext = Path(output_path).suffix.lower()
+
+            # Validate formats
+            if input_ext not in self.SUPPORTED_FORMATS:
+                raise ValueError(f"Unsupported input format: {input_ext}")
+
+            if output_ext not in self.SUPPORTED_FORMATS:
+                raise ValueError(f"Unsupported output format: {output_ext}")
+
+            # Create output folder
+            Path(output_path).parent.mkdir(
+                parents=True,
+                exist_ok=True
+            )
 
             # Load audio
             audio = AudioSegment.from_file(input_path)
 
-            self._update_progress(progress_callback, 40)
+            self._update(progress_callback, 35)
 
-            # Apply AI enhancement if requested
-            if options.get("ai_enhancement", False):
-                audio = self.enhance_audio(audio)
+            # Trim audio
+            start = int(options.get("start_ms", 0))
+            end = int(options.get("end_ms", len(audio)))
 
-            self._update_progress(progress_callback, 60)
+            if start < 0:
+                start = 0
 
-            # Get quality settings
-            quality_settings = options.get("quality_settings", {})
-            bitrate = quality_settings.get("audio", "192k")
+            if end > len(audio):
+                end = len(audio)
 
-            # Create output directory
-            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+            audio = audio[start:end]
 
-            # Export to desired format
-            output_ext = Path(output_path).suffix.lower()
+            self._update(progress_callback, 55)
+
+            # Normalize safely
+            if options.get("normalize", True):
 
-            export_params = {
-                '.mp3': {'format': 'mp3', 'bitrate': bitrate},
-                '.wav': {'format': 'wav'},
-                '.ogg': {'format': 'ogg', 'bitrate': bitrate},
-                '.m4a': {'format': 'mp4', 'bitrate': bitrate},
-                '.flac': {'format': 'flac'}
-            }
+                # Prevent silent audio crash
+                if audio.dBFS != float("-inf"):
 
-            if output_ext in export_params:
-                audio.export(output_path, **export_params[output_ext])
-            else:
-                audio.export(output_path)
+                    target_dbfs = options.get("target_dbfs", -20.0)
 
-            self._update_progress(progress_callback, 100)
+                    change = target_dbfs - audio.dBFS
+
+                    audio = audio.apply_gain(change)
+
+            self._update(progress_callback, 75)
+
+            # Bitrate
+            bitrate = options.get("bitrate", "192k")
+
+            # Export format
+            export_format = output_ext.replace(".", "")
+
+            export_args = {}
+
+            # WAV does not use bitrate
+            if export_format != "wav":
+                export_args["bitrate"] = bitrate
+
+            # AAC handling
+            if export_format == "aac":
+                export_format = "adts"
+
+            # Export audio
+            audio.export(
+                output_path,
+                format=export_format,
+                **export_args
+            )
+
+            self._update(progress_callback, 100)
 
-            print(f"✓ Successfully converted: {os.path.basename(input_path)} → {output_ext}")
             return True
 
         except Exception as e:
-            print(f"Audio conversion error for {input_path}: {str(e)}")
-            traceback.print_exc()
+            print(f"Audio conversion error: {e}")
             return False
 
-    def _update_progress(self, callback, value):
-        """Safely update progress"""
-        if callback is not None:
-            try:
-                callback(value)
-            except Exception:
-                pass
+    def _update(self, callback, value):
 
-    def enhance_audio(self, audio):
-        """Basic audio enhancement"""
         try:
-            audio = audio.normalize()
-            return audio
-        except:
-            return audio
+            if callback:
+                callback(value)
+        except Exception as e:
+            print(f"Progress callback error: {e}")