Update app.py

app.py

@@ -6,10 +6,13 @@ import subprocess
 import gradio as gr
 from tqdm import tqdm
 from datetime import datetime
-from pydub import AudioSegment
-from moviepy import VideoFileClip
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from threading import Thread
+import multiprocessing
 from PIL import Image
-
+import shutil
+import platform
+import json
 
 # ----------------------- Internationalization -----------------------
 from i18n_local import en, ru, es, fr, de, it, ja, ko, ar, hi, tr
@@ -18,8 +21,365 @@ i18n = gr.I18n(
     ja=ja, ko=ko, ar=ar, hi=hi, tr=tr
 )
 
+# ----------------------- Performance Settings -----------------------
+MAX_WORKERS = multiprocessing.cpu_count()
+CHUNK_SIZE = 1024 * 1024 * 10  # 10MB chunks for streaming
+
+# ----------------------- Hardware Acceleration Detection -----------------------
+def detect_hardware_acceleration():
+    """Determines the available methods for hardware acceleration."""
+    accelerations = {
+        'nvidia': False,
+        'intel': False,
+        'amd': False,
+        'videotoolbox': False  # macOS
+    }
+
+    try:
+        result = subprocess.run(['ffmpeg', '-hide_banner', '-hwaccels'], 
+                              capture_output=True, text=True)
+        output = result.stdout.lower()
+        
+        if 'cuda' in output or 'nvenc' in output:
+            accelerations['nvidia'] = True
+        if 'qsv' in output or 'vaapi' in output:
+            accelerations['intel'] = True
+        if 'amf' in output:
+            accelerations['amd'] = True
+        if 'videotoolbox' in output:
+            accelerations['videotoolbox'] = True
+    except:
+        pass
+
+    return accelerations
+
+HARDWARE_ACCEL = detect_hardware_acceleration()
+
+# ----------------------- FFmpeg Optimized Utils -----------------------
+def get_optimal_ffmpeg_params(input_file, output_file, conversion_type="audio", use_hw=True):
+    """Returns the optimal FFmpeg parameters for conversion."""
+    params = []
+    
+    # Basic parameters for acceleration
+    params.extend(['-hide_banner', '-y', '-loglevel', 'error', '-stats'])
+    
+    # Hardware acceleration (if available and enabled)
+    if use_hw and conversion_type == "video":
+        if HARDWARE_ACCEL['nvidia']:
+            params.extend(['-hwaccel', 'cuda', '-hwaccel_output_format', 'cuda'])
+        elif HARDWARE_ACCEL['intel']:
+            params.extend(['-hwaccel', 'qsv'])
+        elif HARDWARE_ACCEL['videotoolbox'] and platform.system() == 'Darwin':
+            params.extend(['-hwaccel', 'videotoolbox'])
+    
+    params.extend(['-i', input_file])
+    
+    # Optimization by Conversion Type
+    if conversion_type == "audio":
+        ext = os.path.splitext(output_file)[1].lower()[1:]
+        if ext == 'mp3':
+            params.extend(['-codec:a', 'libmp3lame', '-q:a', '2', '-threads', str(MAX_WORKERS)])
+        elif ext == 'aac' or ext == 'm4a':
+            params.extend(['-codec:a', 'aac', '-b:a', '192k', '-threads', str(MAX_WORKERS)])
+        elif ext == 'opus':
+            params.extend(['-codec:a', 'libopus', '-b:a', '128k', '-threads', str(MAX_WORKERS)])
+        elif ext == 'flac':
+            params.extend(['-codec:a', 'flac', '-compression_level', '5', '-threads', str(MAX_WORKERS)])
+        else:
+            params.extend(['-threads', str(MAX_WORKERS)])
+            
+    elif conversion_type == "video":
+        ext = os.path.splitext(output_file)[1].lower()[1:]
+        
+        # Use of hardware codecs
+        if use_hw and HARDWARE_ACCEL['nvidia']:
+            params.extend(['-c:v', 'h264_nvenc', '-preset', 'p4', '-tune', 'hq', '-rc', 'vbr', '-cq', '23'])
+        elif use_hw and HARDWARE_ACCEL['intel']:
+            params.extend(['-c:v', 'h264_qsv', '-preset', 'faster', '-global_quality', '23'])
+        elif use_hw and HARDWARE_ACCEL['videotoolbox'] and platform.system() == 'Darwin':
+            params.extend(['-c:v', 'h264_videotoolbox', '-b:v', '5000k'])
+        else:
+            # CPU optimization
+            params.extend(['-c:v', 'libx264', '-preset', 'faster', '-crf', '23', '-threads', str(MAX_WORKERS)])
+        
+        # Copy audio without transcoding (faster)
+        params.extend(['-c:a', 'copy'])
+        
+    elif conversion_type == "video_to_audio":
+        # Extracting only the audio track
+        params.extend(['-vn'])  # Turn off video
+        ext = os.path.splitext(output_file)[1].lower()[1:]
+        if ext == 'mp3':
+            params.extend(['-codec:a', 'libmp3lame', '-q:a', '2'])
+        elif ext == 'aac' or ext == 'm4a':
+            params.extend(['-codec:a', 'aac', '-b:a', '192k'])
+        else:
+            params.extend(['-codec:a', 'copy'])  # Try copying without transcoding
+        
+        params.extend(['-threads', str(MAX_WORKERS)])
+    
+    # Оптимизация для больших файлов
+    params.extend(['-max_muxing_queue_size', '9999'])
+    
+    params.append(output_file)
+    return params
+
+def run_ffmpeg_with_progress(params, duration=None):
+    """Launches FFmpeg with a progress indicator."""
+    try:
+        process = subprocess.Popen(
+            ['ffmpeg'] + params,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=True
+        )
+        
+        for line in process.stderr:
+            if 'time=' in line:
+                print('.', end='', flush=True)
+        
+        process.wait()
+        if process.returncode != 0:
+            raise Exception(f"FFmpeg failed with return code {process.returncode}")
+        
+        return True
+    except Exception as e:
+        print(f"FFmpeg error: {e}")
+        return False
+
+# ----------------------- Optimized Conversion Functions -----------------------
+def convert_audio_ffmpeg(input_file, output_file, output_ext):
+    """Fast audio conversion using a direct FFmpeg call."""
+    params = get_optimal_ffmpeg_params(input_file, output_file, "audio")
+    return run_ffmpeg_with_progress(params)
+
+def convert_video_ffmpeg(input_file, output_file, conversion_type):
+    """Fast video conversion using a direct FFmpeg call."""
+    conv_type = "video_to_audio" if conversion_type == "Video to Audio" else "video"
+    params = get_optimal_ffmpeg_params(input_file, output_file, conv_type)
+    return run_ffmpeg_with_progress(params)
+
+def merge_audio_files_ffmpeg(input_files, output_file, gap_duration):
+    """Efficiently merge audio files using FFmpeg."""
+    list_file = f"concat_list_{uuid.uuid4().hex}.txt"
+    
+    try:
+        with open(list_file, 'w') as f:
+            for i, file in enumerate(input_files):
+                f.write(f"file '{os.path.abspath(file)}'\n")
+                if i < len(input_files) - 1 and gap_duration > 0:
+                    f.write(f"file 'silence.wav'\n")
+        
+        # Create a silent file if needed
+        if gap_duration > 0:
+            silence_params = [
+                '-f', 'lavfi',
+                '-i', f'anullsrc=duration={gap_duration/1000}:sample_rate=44100',
+                '-t', str(gap_duration/1000),
+                'silence.wav'
+            ]
+            subprocess.run(['ffmpeg', '-y'] + silence_params, check=True, capture_output=True)
+        
+        # We are merging files
+        params = [
+            '-f', 'concat',
+            '-safe', '0',
+            '-i', list_file,
+            '-c', 'copy',
+            '-threads', str(MAX_WORKERS),
+            output_file
+        ]
+        
+        return run_ffmpeg_with_progress(params)
+    
+    finally:
+        if os.path.exists(list_file):
+            os.remove(list_file)
+        if os.path.exists('silence.wav'):
+            os.remove('silence.wav')
+
+# ----------------------- Parallel Processing -----------------------
+def process_file_parallel(args):
+    """Function for parallel file processing."""
+    input_file, output_path, file_type, output_ext = args
+    
+    try:
+        if file_type == "audio":
+            success = convert_audio_ffmpeg(input_file, output_path, output_ext)
+        elif file_type == "image":
+            success = convert_image_optimized(input_file, output_path, output_ext)
+        else:
+            success = False
+        
+        return output_path if success else None
+    except Exception as e:
+        print(f"Error processing {input_file}: {e}")
+        return None
+
+def convert_image_optimized(input_file, output_path, output_ext):
+    """Optimized image conversion"""
+    try:
+        pil_fmt = pil_format_for_ext(output_ext)
+        if not pil_fmt:
+            return False
+        
+        with Image.open(input_file) as img:
+            if pil_fmt.upper() == "JPEG":
+                img = img.convert("RGB")
+                img.save(output_path, format=pil_fmt, quality=90, optimize=True)
+            elif pil_fmt.upper() == "PNG":
+                img.save(output_path, format=pil_fmt, optimize=True, compress_level=6)
+            else:
+                img.save(output_path, format=pil_fmt)
+        
+        return True
+    except Exception as e:
+        print(f"Image conversion error: {e}")
+        return False
+
+# ----------------------- Main Processing Functions -----------------------
+def process_audio_files_optimized(files, output_ext, merge_files, gap_duration, progress=gr.Progress(track_tqdm=True)):
+    """Optimized audio file processing"""
+    if not files:
+        raise gr.Error("Please upload at least one audio file!")
+    
+    session_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + str(uuid.uuid4())[:8]
+    os.makedirs(session_id, exist_ok=True)
+    
+    print(f"\nStarting optimized audio session: {session_id}")
+    print(f"Files to convert: {len(files)} to .{output_ext}")
+    
+    file_paths = [f if isinstance(f, str) else f.name for f in files]
+    
+    if merge_files:
+        merged_output_path = os.path.join(session_id, f"merged_output.{output_ext}")
+        
+        temp_files = []
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            tasks = []
+            for i, file_path in enumerate(file_paths):
+                temp_output = os.path.join(session_id, f"temp_{i}.{output_ext}")
+                tasks.append(executor.submit(convert_audio_ffmpeg, file_path, temp_output, output_ext))
+            
+            for future in tqdm(tasks, desc="Converting files"):
+                result = future.result()
+                if result:
+                    temp_files.append(result)
+        
+        if merge_audio_files_ffmpeg(temp_files, merged_output_path, gap_duration):
+            for temp_file in temp_files:
+                try:
+                    os.remove(temp_file)
+                except:
+                    pass
+            return merged_output_path
+        else:
+            raise gr.Error("Failed to merge audio files")
+    
+    else:
+        output_files = []
+        
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            tasks = []
+            for file_path in file_paths:
+                base_name = os.path.splitext(os.path.basename(file_path))[0]
+                output_filename = f"{base_name}.{output_ext}"
+                output_path = os.path.join(session_id, output_filename)
+                tasks.append((file_path, output_path, "audio", output_ext))
+            
+            results = list(tqdm(
+                executor.map(process_file_parallel, tasks),
+                total=len(tasks),
+                desc="Converting audio files"
+            ))
+            
+            output_files = [r for r in results if r is not None]
+        
+        if not output_files:
+            raise gr.Error("No files were successfully converted")
+        
+        if len(output_files) > 1:
+            print("Creating ZIP archive...")
+            zip_filename = create_zip_optimized(output_files, session_id)
+            return zip_filename
+        
+        return output_files[0]
+
+def process_image_files_optimized(files, output_ext, progress=gr.Progress(track_tqdm=True)):
+    """Optimized image processing"""
+    if not files:
+        raise gr.Error("Please upload at least one image!")
+    
+    session_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + str(uuid.uuid4())[:8]
+    os.makedirs(session_id, exist_ok=True)
+    
+    print(f"\nStarting optimized image session: {session_id}")
+    print(f"Files to convert: {len(files)} to .{output_ext}")
+    
+    file_paths = [f if isinstance(f, str) else f.name for f in files]
+    output_files = []
 
-# ----------------------- FFmpeg utils -----------------------
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        tasks = []
+        for file_path in file_paths:
+            base_name = os.path.splitext(os.path.basename(file_path))[0]
+            output_filename = f"{base_name}.{output_ext}"
+            output_path = os.path.join(session_id, output_filename)
+            tasks.append((file_path, output_path, "image", output_ext))
+        
+        results = list(tqdm(
+            executor.map(process_file_parallel, tasks),
+            total=len(tasks),
+            desc="Converting images"
+        ))
+        
+        output_files = [r for r in results if r is not None]
+    
+    if not output_files:
+        raise gr.Error("No images were successfully converted")
+    
+    if len(output_files) > 1:
+        print("Creating ZIP archive...")
+        zip_filename = create_zip_optimized(output_files, session_id)
+        return zip_filename
+    
+    return output_files[0]
+
+def process_video_optimized(input_video, conversion_type, output_ext, progress=gr.Progress(track_tqdm=True)):
+    """Optimized video processing"""
+    if not input_video:
+        raise gr.Error("Please upload a video file!")
+    
+    session_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + str(uuid.uuid4())[:8]
+    os.makedirs(session_id, exist_ok=True)
+    
+    input_path = input_video if isinstance(input_video, str) else input_video.name
+    base_name = os.path.splitext(os.path.basename(input_path))[0]
+    output_filename = f"{base_name}_converted.{output_ext}"
+    output_path = os.path.join(session_id, output_filename)
+    
+    print(f"\nStarting optimized video session: {session_id}")
+    print(f"Conversion type: {conversion_type}, Output: .{output_ext}")
+    
+    success = convert_video_ffmpeg(input_path, output_path, conversion_type)
+    
+    if success:
+        print("Video processing complete!")
+        return output_path
+    else:
+        raise gr.Error("Video processing failed")
+
+def create_zip_optimized(files_to_zip, session_id):
+    """Optimized ZIP archive creation"""
+    zip_filename = f"{session_id}.zip"
+
+    with zipfile.ZipFile(zip_filename, 'w', compression=zipfile.ZIP_DEFLATED, compresslevel=1) as zipf:
+        for file in tqdm(files_to_zip, desc="Creating ZIP archive"):
+            zipf.write(file, os.path.basename(file))
+    
+    return zip_filename
+
+# ----------------------- Keep original helper functions -----------------------
 def _run_ffmpeg(args):
     try:
         res = subprocess.run(["ffmpeg", *args], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
@@ -28,16 +388,11 @@ def _run_ffmpeg(args):
         return None
 
 def ffmpeg_writable_formats():
-    """
-    Returns a set of FFmpeg format names (including aliases) available for writing (E flag).
-    Example: {'mp4', 'mov', 'm4a', '3gp', 'matroska', 'webm', ...}
-    """
     out = _run_ffmpeg(["-hide_banner", "-v", "error", "-formats"])
     if not out:
         return set()
     fmts = set()
     for line in out.splitlines():
-        # lines look like: " DE matroska,webm   Matroska / WebM"
         if re.match(r"^\s*[D\s]*E\s+", line):
             m = re.search(r"^\s*[D\s]*E\s+([^\s]+)", line)
             if not m:
@@ -48,21 +403,17 @@ def ffmpeg_writable_formats():
     return fmts
 
 def ffmpeg_audio_encoders():
-    """
-    Returns a set of available audio encoders, e.g. {'aac','libmp3lame','libopus',...}
-    """
     out = _run_ffmpeg(["-hide_banner", "-v", "error", "-encoders"])
     if not out:
         return set()
     enc = set()
     for line in out.splitlines():
-        # lines look like: " A..... libmp3lame  MP3 (MPEG audio layer 3) (codec mp3)"
         m = re.match(r"^\s*A\S*\s+([^\s]+)", line)
         if m:
             enc.add(m.group(1).strip())
     return enc
 
-# Extension -> FFmpeg container mapping (curated, common ones)
+# Extension mappings
 AUDIO_EXT_TO_FFMPEG_FORMAT = {
     "mp3": "mp3",
     "wav": "wav",
@@ -70,8 +421,8 @@ AUDIO_EXT_TO_FFMPEG_FORMAT = {
     "flac": "flac",
     "ogg": "ogg",
     "oga": "ogg",
-    "opus": "ogg",   # ogg container; needs libopus
-    "spx": "ogg",    # ogg container; needs libspeex
+    "opus": "ogg",
+    "spx": "ogg",
     "aac": "adts",
     "m4a": "mp4",
     "m4b": "mp4",
@@ -90,12 +441,10 @@ AUDIO_EXT_TO_FFMPEG_FORMAT = {
     "mka": "matroska",
 }
 
-# Some extensions require specific encoders
 AUDIO_REQUIRED_CODECS = {
     "mp3": ["libmp3lame"],
     "opus": ["libopus"],
     "spx": ["libspeex"],
-    # others rely on FFmpeg defaults
 }
 
 VIDEO_EXT_TO_FFMPEG_FORMAT = {
@@ -130,7 +479,6 @@ def available_audio_extensions():
         if req and not any(r in encoders for r in req):
             continue
         exts.append(ext)
-    # fallback if ffmpeg is missing or query failed
     if not exts:
         exts = ["mp3", "wav", "flac", "ogg", "aac", "m4a", "aiff", "wma", "opus"]
     return sorted(set(exts))
@@ -142,13 +490,10 @@ def available_video_extensions():
         exts = ["mp4", "mkv", "avi", "mov", "webm", "flv", "mpeg", "mpg", "ts"]
     return sorted(set(exts))
 
-# ----------------------- Pillow utils (images) -----------------------
 def available_image_extensions():
-    # All registered extensions Pillow knows how to save (best-effort)
-    ext2fmt = Image.registered_extensions()  # {".jpg":"JPEG", ...}
+    ext2fmt = Image.registered_extensions()
     save_ok = set(getattr(Image, "SAVE", {}).keys()) or set()
     if not save_ok:
-        # If SAVE registry is unavailable, assume registered formats are savable
         save_ok = set(ext2fmt.values())
     exts = []
     for ext, fmt in ext2fmt.items():
@@ -186,169 +531,6 @@ def pil_format_for_ext(ext):
     }
     return fallback.get(ext, None)
 
-
-# ---------- AUDIO PROCESSING ----------
-def convert_audio(input_files, output_ext, session_id, merge_files, gap_duration):
-    """Convert/merge audio into the selected format (by extension)."""
-    output_files = []
-    merged_audio = AudioSegment.silent(duration=0)
-    os.makedirs(session_id, exist_ok=True)
-
-    ff_format = AUDIO_EXT_TO_FFMPEG_FORMAT.get(output_ext, output_ext)
-    codec = None
-    if output_ext == "opus":
-        codec = "libopus"
-    elif output_ext == "spx":
-        codec = "libspeex"
-
-    for input_file in tqdm(input_files, desc="Converting audio files"):
-        file_path = input_file if isinstance(input_file, str) else input_file.name
-        audio = AudioSegment.from_file(file_path)
-
-        base_name = os.path.splitext(os.path.basename(file_path))[0]
-        output_filename = f"{base_name}.{output_ext}"
-        output_path = os.path.join(session_id, output_filename)
-
-        audio.export(output_path, format=ff_format, codec=codec)
-
-        if merge_files:
-            merged_audio += audio + AudioSegment.silent(duration=gap_duration)
-        else:
-            output_files.append(output_path)
-
-    if merge_files:
-        merged_output_path = os.path.join(session_id, f"merged_output.{output_ext}")
-        merged_audio.export(merged_output_path, format=ff_format, codec=codec)
-        return [merged_output_path]
-
-    return output_files
-
-
-# ---------- IMAGE PROCESSING ----------
-def convert_images(input_files, output_ext, session_id):
-    """Simple image format conversion."""
-    os.makedirs(session_id, exist_ok=True)
-    output_files = []
-
-    pil_fmt = pil_format_for_ext(output_ext)
-    if not pil_fmt:
-        raise gr.Error(f"Pillow cannot save to format: {output_ext}")
-
-    for input_file in tqdm(input_files, desc="Converting images"):
-        file_path = input_file if isinstance(input_file, str) else input_file.name
-        base_name = os.path.splitext(os.path.basename(file_path))[0]
-        output_filename = f"{base_name}.{output_ext}"
-        output_path = os.path.join(session_id, output_filename)
-
-        with Image.open(file_path) as img:
-            img.load()
-            # For JPEG ensure RGB mode
-            if pil_fmt.upper() == "JPEG":
-                img = img.convert("RGB")
-            img.save(output_path, format=pil_fmt)
-
-        output_files.append(output_path)
-
-    return output_files
-
-
-# ---------- ZIP CREATION ----------
-def create_zip(files_to_zip, session_id):
-    zip_filename = f"{session_id}.zip"
-    with zipfile.ZipFile(zip_filename, 'w') as zipf:
-        for file in tqdm(files_to_zip, desc="Creating ZIP archive"):
-            zipf.write(file, os.path.basename(file))
-    return zip_filename
-
-
-# ---------- AUDIO HANDLER ----------
-def process_audio_files(files, output_ext, merge_files, gap_duration, progress=gr.Progress(track_tqdm=True)):
-    if not files:
-        raise gr.Error("Please upload at least one audio file!")
-
-    session_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + str(uuid.uuid4())[:8]
-    print(f"\nStarting audio session: {session_id}")
-    print(f"Files to convert: {len(files)} to .{output_ext}")
-
-    output_files = convert_audio(files, output_ext, session_id, merge_files, gap_duration)
-
-    if len(output_files) > 1:
-        print("Creating ZIP archive...")
-        zip_filename = create_zip(output_files, session_id)
-        return zip_filename
-
-    return output_files[0]
-
-
-# ---------- IMAGE HANDLER ----------
-def process_image_files(files, output_ext, progress=gr.Progress(track_tqdm=True)):
-    if not files:
-        raise gr.Error("Please upload at least one image!")
-
-    session_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + str(uuid.uuid4())[:8]
-    print(f"\nStarting image session: {session_id}")
-    print(f"Files to convert: {len(files)} to .{output_ext}")
-
-    output_files = convert_images(files, output_ext, session_id)
-
-    if len(output_files) > 1:
-        print("Creating ZIP archive...")
-        zip_filename = create_zip(output_files, session_id)
-        return zip_filename
-
-    return output_files[0]
-
-
-# ---------- VIDEO HANDLER ----------
-def process_video(input_video, conversion_type, output_ext, progress=gr.Progress(track_tqdm=True)):
-    if not input_video:
-        raise gr.Error("Please upload a video file!")
-
-    session_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + str(uuid.uuid4())[:8]
-    os.makedirs(session_id, exist_ok=True)
-
-    input_path = input_video if isinstance(input_video, str) else input_video.name
-    base_name = os.path.splitext(os.path.basename(input_path))[0]
-    output_filename = f"{base_name}_converted.{output_ext}"
-    output_path = os.path.join(session_id, output_filename)
-
-    print(f"\nStarting video session: {session_id}")
-    print(f"Conversion type: {conversion_type}, Output: .{output_ext}")
-
-    try:
-        clip = VideoFileClip(input_path)
-
-        if conversion_type == "Video to Video":
-            # Let MoviePy use its defaults; for some containers (e.g. webm) this may require specific codecs
-            clip.write_videofile(output_path, logger=None)
-
-        elif conversion_type == "Video to Audio":
-            if clip.audio is None:
-                raise gr.Error("The uploaded video does not contain an audio track.")
-            audio_clip = clip.audio
-
-            audio_codec = None
-            if output_ext == "opus":
-                if "libopus" in ffmpeg_audio_encoders():
-                    audio_codec = "libopus"
-            elif output_ext == "spx":
-                if "libspeex" in ffmpeg_audio_encoders():
-                    audio_codec = "libspeex"
-
-            audio_clip.write_audiofile(output_path, logger=None, codec=audio_codec)
-            audio_clip.close()
-
-        clip.close()
-
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        raise gr.Error(f"Processing error: {e}")
-
-    print("Video processing complete!")
-    return output_path
-
-
-# ---------- FORMAT CHOICES ----------
 def update_format_choices(conversion_type):
     if conversion_type == "Video to Video":
         vf = available_video_extensions()
@@ -359,8 +541,7 @@ def update_format_choices(conversion_type):
         value = "mp3" if "mp3" in af else (af[0] if af else None)
         return gr.Dropdown(choices=af, value=value, label="Output Audio Format")
 
-
-# ---------- UI ----------
+# ----------------------- UI with optimized handlers -----------------------
 AUDIO_FORMATS = available_audio_extensions()
 VIDEO_FORMATS = available_video_extensions()
 IMAGE_FORMATS = available_image_extensions()
@@ -386,7 +567,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             audio_output_file = gr.File(label=i18n("download_result"))
 
             audio_submit_button.click(
-                fn=process_audio_files,
+                fn=process_audio_files_optimized,
                 inputs=[audio_file_input, audio_format_choice, merge_files_checkbox, gap_slider],
                 outputs=audio_output_file
             )
@@ -406,7 +587,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             image_output_file = gr.File(label=i18n("download_result"))
 
             image_submit_button.click(
-                fn=process_image_files,
+                fn=process_image_files_optimized,
                 inputs=[image_file_input, image_format_choice],
                 outputs=image_output_file
             )
@@ -441,10 +622,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             )
 
             video_submit_button.click(
-                fn=process_video,
+                fn=process_video_optimized,
                 inputs=[video_input, conversion_type_radio, video_format_dropdown],
                 outputs=video_output_file
             )
 
 if __name__ == "__main__":
-    demo.launch(i18n=i18n, debug=True)
+    demo.launch(i18n=i18n, debug=True)