Update app.py

app.py

@@ -6,13 +6,9 @@ import subprocess
 import gradio as gr
 from tqdm import tqdm
 from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
-from threading import Thread
+from concurrent.futures import ThreadPoolExecutor
 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
@@ -21,166 +17,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
+# ----------------------- HuggingFace Spaces Settings -----------------------
+MAX_WORKERS = min(2, multiprocessing.cpu_count())  # Limited CPU on HF Spaces
+CHUNK_SIZE = 1024 * 1024 * 5  # 5MB chunks
+
+def check_ffmpeg_installation():
+    """Check FFmpeg installation and available codecs"""
+    try:
+        result = subprocess.run(
+            ['ffmpeg', '-version'],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        print("FFmpeg version info:")
+        print(result.stdout.split('\n')[0])
+        
+        result = subprocess.run(
+            ['ffmpeg', '-hide_banner', '-codecs'],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        
+        important_codecs = ['libx264', 'libmp3lame', 'aac', 'libvpx-vp9', 'libopus']
+        available = []
+        for codec in important_codecs:
+            if codec in result.stdout:
+                available.append(codec)
+        
+        print(f"Available important codecs: {', '.join(available)}")
+        return True
+        
+    except Exception as e:
+        print(f"FFmpeg check failed: {e}")
+        return False
+
+# ----------------------- FFmpeg utils -----------------------
+def _run_ffmpeg(args):
+    try:
+        res = subprocess.run(["ffmpeg", *args], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        return res.stdout
+    except Exception:
+        return None
+
+def ffmpeg_writable_formats():
+    """Returns a set of FFmpeg format names (including aliases) available for writing (E flag)."""
+    out = _run_ffmpeg(["-hide_banner", "-v", "error", "-formats"])
+    if not out:
+        return set()
+    fmts = set()
+    for line in out.splitlines():
+        if re.match(r"^\s*[D\s]*E\s+", line):
+            m = re.search(r"^\s*[D\s]*E\s+([^\s]+)", line)
+            if not m:
+                continue
+            names = m.group(1)
+            for name in names.split(","):
+                fmts.add(name.strip())
+    return fmts
+
+def ffmpeg_audio_encoders():
+    """Returns a set of available audio encoders."""
+    out = _run_ffmpeg(["-hide_banner", "-v", "error", "-encoders"])
+    if not out:
+        return set()
+    enc = set()
+    for line in out.splitlines():
+        m = re.match(r"^\s*A\S*\s+([^\s]+)", line)
+        if m:
+            enc.add(m.group(1).strip())
+    return enc
+
+# Extension -> FFmpeg container mapping (full list)
+AUDIO_EXT_TO_FFMPEG_FORMAT = {
+    "mp3": "mp3",
+    "wav": "wav",
+    "w64": "w64",
+    "flac": "flac",
+    "ogg": "ogg",
+    "oga": "ogg",
+    "opus": "ogg",
+    "spx": "ogg",
+    "aac": "adts",
+    "m4a": "mp4",
+    "m4b": "mp4",
+    "m4r": "mp4",
+    "ac3": "ac3",
+    "aiff": "aiff",
+    "aif": "aiff",
+    "aifc": "aiff",
+    "caf": "caf",
+    "au": "au",
+    "amr": "amr",
+    "dts": "dts",
+    "mp2": "mp2",
+    "wma": "asf",
+    "wv": "wv",
+    "mka": "matroska",
+}
+
+AUDIO_REQUIRED_CODECS = {
+    "mp3": ["libmp3lame"],
+    "opus": ["libopus"],
+    "spx": ["libspeex"],
+}
+
+VIDEO_EXT_TO_FFMPEG_FORMAT = {
+    "mp4": "mp4",
+    "m4v": "mp4",
+    "mov": "mov",
+    "avi": "avi",
+    "mkv": "matroska",
+    "webm": "webm",
+    "flv": "flv",
+    "ogv": "ogg",
+    "mpeg": "mpeg",
+    "mpg": "mpeg",
+    "ts": "mpegts",
+    "m2ts": "mpegts",
+    "mxf": "mxf",
+    "3gp": "3gp",
+    "3g2": "3g2",
+    "asf": "asf",
+    "wmv": "asf",
+    "vob": "vob",
+}
+
+def available_audio_extensions():
+    writable = ffmpeg_writable_formats()
+    encoders = ffmpeg_audio_encoders()
+    exts = []
+    for ext, ffmt in AUDIO_EXT_TO_FFMPEG_FORMAT.items():
+        if ffmt not in writable:
+            continue
+        req = AUDIO_REQUIRED_CODECS.get(ext)
+        if req and not any(r in encoders for r in req):
+            continue
+        exts.append(ext)
+    if not exts:
+        exts = ["mp3", "wav", "flac", "ogg", "aac", "m4a", "aiff", "wma", "opus"]
+    return sorted(set(exts))
+
+def available_video_extensions():
+    writable = ffmpeg_writable_formats()
+    exts = [ext for ext, ffmt in VIDEO_EXT_TO_FFMPEG_FORMAT.items() if ffmt in writable]
+    if not exts:
+        exts = ["mp4", "mkv", "avi", "mov", "webm", "flv", "mpeg", "mpg", "ts"]
+    return sorted(set(exts))
+
+def available_image_extensions():
+    ext2fmt = Image.registered_extensions()
+    save_ok = set(getattr(Image, "SAVE", {}).keys()) or set()
+    if not save_ok:
+        save_ok = set(ext2fmt.values())
+    exts = []
+    for ext, fmt in ext2fmt.items():
+        if fmt in save_ok:
+            e = ext.lstrip(".").lower()
+            exts.append(e)
+    if not exts:
+        exts = ["png", "jpg", "jpeg", "webp", "bmp", "tiff", "gif", "ico", "ppm", "pgm", "pbm", "pnm", "tga", "xbm", "xpm", "pdf", "eps"]
+    return sorted(set(exts))
+
+def pil_format_for_ext(ext):
+    ext = ext.lower().strip(".")
+    for k, v in Image.registered_extensions().items():
+        if k.lstrip(".").lower() == ext:
+            return v
+    fallback = {
+        "jpg": "JPEG",
+        "jpeg": "JPEG",
+        "png": "PNG",
+        "webp": "WEBP",
+        "bmp": "BMP",
+        "tiff": "TIFF",
+        "tif": "TIFF",
+        "gif": "GIF",
+        "ico": "ICO",
+        "ppm": "PPM",
+        "pgm": "PPM",
+        "pbm": "PPM",
+        "pnm": "PPM",
+        "tga": "TGA",
+        "xbm": "XBM",
+        "xpm": "XPM",
+        "pdf": "PDF",
+        "eps": "EPS",
     }
+    return fallback.get(ext, None)
 
+# ----------------------- Optimized FFmpeg Processing -----------------------
+def run_ffmpeg_with_progress(params):
+    """Run FFmpeg with progress display"""
     try:
-        result = subprocess.run(['ffmpeg', '-hide_banner', '-hwaccels'], 
-                              capture_output=True, text=True)
-        output = result.stdout.lower()
+        process = subprocess.Popen(
+            ['ffmpeg'] + params,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            bufsize=1
+        )
+        
+        output = []
+        for line in process.stdout:
+            output.append(line)
+            if 'time=' in line:
+                print('.', end='', flush=True)
+        
+        process.wait()
+        
+        if process.returncode != 0:
+            error_output = ''.join(output[-50:])
+            print(f"FFmpeg error output:\n{error_output}")
+            return False
         
-        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."""
+        return True
+        
+    except Exception as e:
+        print(f"FFmpeg exception: {e}")
+        return False
+
+def get_optimal_ffmpeg_params(input_file, output_file, conversion_type="audio"):
+    """Get 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(['-hide_banner', '-y'])
     params.extend(['-i', input_file])
     
-    # Optimization by Conversion Type
+    ext = os.path.splitext(output_file)[1].lower()[1:]
+    
     if conversion_type == "audio":
-        ext = os.path.splitext(output_file)[1].lower()[1:]
+        ff_format = AUDIO_EXT_TO_FFMPEG_FORMAT.get(ext, ext)
+        
         if ext == 'mp3':
-            params.extend(['-codec:a', 'libmp3lame', '-q:a', '2', '-threads', str(MAX_WORKERS)])
+            params.extend(['-codec:a', 'libmp3lame', '-q:a', '2'])
         elif ext == 'aac' or ext == 'm4a':
-            params.extend(['-codec:a', 'aac', '-b:a', '192k', '-threads', str(MAX_WORKERS)])
+            params.extend(['-codec:a', 'aac', '-b:a', '192k'])
         elif ext == 'opus':
-            params.extend(['-codec:a', 'libopus', '-b:a', '128k', '-threads', str(MAX_WORKERS)])
+            encoders = ffmpeg_audio_encoders()
+            if 'libopus' in encoders:
+                params.extend(['-codec:a', 'libopus', '-b:a', '128k'])
+            else:
+                params.extend(['-codec:a', 'libvorbis', '-b:a', '128k'])
+        elif ext == 'spx':
+            if 'libspeex' in ffmpeg_audio_encoders():
+                params.extend(['-codec:a', 'libspeex'])
         elif ext == 'flac':
-            params.extend(['-codec:a', 'flac', '-compression_level', '5', '-threads', str(MAX_WORKERS)])
-        else:
-            params.extend(['-threads', str(MAX_WORKERS)])
+            params.extend(['-codec:a', 'flac', '-compression_level', '5'])
+        elif ext == 'wav':
+            params.extend(['-codec:a', 'pcm_s16le'])
+        
+        # Format specification if needed
+        if ff_format != ext:
+            params.extend(['-f', ff_format])
+        
+        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'])
+        if ext in ['mp4', 'm4v', 'mov']:
+            params.extend(['-codec:v', 'libx264'])
+            params.extend(['-preset', 'veryfast'])
+            params.extend(['-crf', '23'])
+            params.extend(['-codec:a', 'aac', '-b:a', '192k'])
+            params.extend(['-movflags', '+faststart'])
+        elif ext == 'webm':
+            params.extend(['-codec:v', 'libvpx-vp9'])
+            params.extend(['-crf', '30', '-b:v', '0'])
+            params.extend(['-codec:a', 'libopus', '-b:a', '128k'])
+        elif ext == 'avi':
+            params.extend(['-codec:v', 'libx264'])
+            params.extend(['-preset', 'veryfast'])
+            params.extend(['-crf', '23'])
+            params.extend(['-codec:a', 'mp3', '-b:a', '192k'])
+        elif ext == 'mkv':
+            params.extend(['-codec:v', 'libx264'])
+            params.extend(['-preset', 'veryfast'])
+            params.extend(['-crf', '23'])
+            params.extend(['-codec:a', 'aac', '-b:a', '192k'])
+        elif ext == 'flv':
+            params.extend(['-codec:v', 'flv1'])
+            params.extend(['-codec:a', 'mp3', '-ar', '44100'])
         else:
-            # CPU optimization
-            params.extend(['-c:v', 'libx264', '-preset', 'faster', '-crf', '23', '-threads', str(MAX_WORKERS)])
+            params.extend(['-codec:v', 'libx264'])
+            params.extend(['-preset', 'veryfast'])
+            params.extend(['-crf', '23'])
+            params.extend(['-codec:a', 'copy'])
         
-        # Copy audio without transcoding (faster)
-        params.extend(['-c:a', 'copy'])
+        params.extend(['-threads', str(MAX_WORKERS)])
         
     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:]
+        params.extend(['-vn'])
+        
+        ff_format = AUDIO_EXT_TO_FFMPEG_FORMAT.get(ext, ext)
+        
         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'])
+        elif ext == 'flac':
+            params.extend(['-codec:a', 'flac', '-compression_level', '5'])
+        elif ext == 'wav':
+            params.extend(['-codec:a', 'pcm_s16le'])
+        elif ext == 'opus':
+            encoders = ffmpeg_audio_encoders()
+            if 'libopus' in encoders:
+                params.extend(['-codec:a', 'libopus', '-b:a', '128k'])
+            else:
+                params.extend(['-codec:a', 'libvorbis', '-b:a', '128k'])
         else:
-            params.extend(['-codec:a', 'copy'])  # Try copying without transcoding
+            params.extend(['-codec:a', 'copy'])
+        
+        # Format specification if needed
+        if ff_format != ext:
+            params.extend(['-f', ff_format])
         
         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."""
+    """Fast audio conversion via direct FFmpeg call"""
+    if not os.path.exists(input_file):
+        print(f"Input file does not exist: {input_file}")
+        return False
+    
+    output_dir = os.path.dirname(output_file)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+    
     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."""
+    """Fast video conversion via direct FFmpeg call"""
     conv_type = "video_to_audio" if conversion_type == "Video to Audio" else "video"
+    
+    if not os.path.exists(input_file):
+        print(f"Input file does not exist: {input_file}")
+        return False
+    
+    output_dir = os.path.dirname(output_file)
+    if output_dir and not os.path.exists(output_dir):
+        os.makedirs(output_dir, exist_ok=True)
+    
     params = get_optimal_ffmpeg_params(input_file, output_file, conv_type)
+    print(f"FFmpeg command: ffmpeg {' '.join(params)}")
+    
     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"
+    """Fast audio merging via FFmpeg"""
+    list_file = f"concat_{uuid.uuid4().hex}.txt"
     
     try:
         with open(list_file, 'w') as f:
-            for i, file in enumerate(input_files):
+            for file in 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',
@@ -191,80 +386,81 @@ def merge_audio_files_ffmpeg(input_files, output_file, gap_duration):
         ]
         
         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 convert_image_pillow(input_file, output_path, output_ext):
+    """Optimized image conversion"""
+    try:
+        pil_format = pil_format_for_ext(output_ext)
+        if not pil_format:
+            return False
+        
+        with Image.open(input_file) as img:
+            if pil_format == "JPEG":
+                img = img.convert("RGB")
+                img.save(output_path, format=pil_format, quality=90, optimize=True)
+            elif pil_format == "PNG":
+                img.save(output_path, format=pil_format, optimize=True, compress_level=6)
+            else:
+                img.save(output_path, format=pil_format)
+        
+        return True
+    except Exception as e:
+        print(f"Image conversion error: {e}")
+        return False
+
 def process_file_parallel(args):
-    """Function for parallel file processing."""
+    """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)
+            success = convert_image_pillow(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
+def create_zip(files_to_zip, session_id):
+    """Create ZIP archive"""
+    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"):
+            zipf.write(file, os.path.basename(file))
+    return zip_filename
 
 # ----------------------- 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"""
+def process_audio_files(files, output_ext, merge_files, gap_duration, progress=gr.Progress(track_tqdm=True)):
+    """Process audio files"""
     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]
+    session_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
     os.makedirs(session_id, exist_ok=True)
     
-    print(f"\nStarting optimized audio session: {session_id}")
+    print(f"\nStarting audio session: {session_id}")
     print(f"Files to convert: {len(files)} to .{output_ext}")
+    print(f"Using {MAX_WORKERS} threads")
     
     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}")
+        merged_output_path = os.path.join(session_id, f"merged.{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)
+        for i, file_path in enumerate(tqdm(file_paths, desc="Converting")):
+            temp_output = os.path.join(session_id, f"temp_{i}.{output_ext}")
+            if convert_audio_ffmpeg(file_path, temp_output, output_ext):
+                temp_files.append(temp_output)
+        
+        if not temp_files:
+            raise gr.Error("No files were successfully converted")
         
         if merge_audio_files_ffmpeg(temp_files, merged_output_path, gap_duration):
             for temp_file in temp_files:
@@ -283,14 +479,13 @@ def process_audio_files_optimized(files, output_ext, merge_files, gap_duration,
             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)
+                output_path = os.path.join(session_id, f"{base_name}.{output_ext}")
                 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"
+                desc="Converting"
             ))
             
             output_files = [r for r in results if r is not None]
@@ -299,38 +494,36 @@ def process_audio_files_optimized(files, output_ext, merge_files, gap_duration,
             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 create_zip(output_files, session_id)
         
         return output_files[0]
 
-def process_image_files_optimized(files, output_ext, progress=gr.Progress(track_tqdm=True)):
-    """Optimized image processing"""
+def process_image_files(files, output_ext, progress=gr.Progress(track_tqdm=True)):
+    """Process image files"""
     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]
+    session_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}"
     os.makedirs(session_id, exist_ok=True)
     
-    print(f"\nStarting optimized image session: {session_id}")
+    print(f"\nStarting image session: {session_id}")
     print(f"Files to convert: {len(files)} to .{output_ext}")
+    print(f"Using {MAX_WORKERS} threads")
     
     file_paths = [f if isinstance(f, str) else f.name for f in files]
     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)
+            output_path = os.path.join(session_id, f"{base_name}.{output_ext}")
             tasks.append((file_path, output_path, "image", output_ext))
         
         results = list(tqdm(
             executor.map(process_file_parallel, tasks),
             total=len(tasks),
-            desc="Converting images"
+            desc="Converting"
         ))
         
         output_files = [r for r in results if r is not None]
@@ -339,26 +532,23 @@ def process_image_files_optimized(files, output_ext, progress=gr.Progress(track_
         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 create_zip(output_files, session_id)
     
     return output_files[0]
 
-def process_video_optimized(input_video, conversion_type, output_ext, progress=gr.Progress(track_tqdm=True)):
-    """Optimized video processing"""
+def process_video(input_video, conversion_type, output_ext, progress=gr.Progress(track_tqdm=True)):
+    """Process video file"""
     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]
+    session_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[: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)
+    output_path = os.path.join(session_id, f"{base_name}.{output_ext}")
     
-    print(f"\nStarting optimized video session: {session_id}")
+    print(f"\nStarting video session: {session_id}")
     print(f"Conversion type: {conversion_type}, Output: .{output_ext}")
     
     success = convert_video_ffmpeg(input_path, output_path, conversion_type)
@@ -367,171 +557,10 @@ def process_video_optimized(input_video, conversion_type, output_ext, progress=g
         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)
-        return res.stdout
-    except Exception:
-        return None
-
-def ffmpeg_writable_formats():
-    out = _run_ffmpeg(["-hide_banner", "-v", "error", "-formats"])
-    if not out:
-        return set()
-    fmts = set()
-    for line in out.splitlines():
-        if re.match(r"^\s*[D\s]*E\s+", line):
-            m = re.search(r"^\s*[D\s]*E\s+([^\s]+)", line)
-            if not m:
-                continue
-            names = m.group(1)
-            for name in names.split(","):
-                fmts.add(name.strip())
-    return fmts
-
-def ffmpeg_audio_encoders():
-    out = _run_ffmpeg(["-hide_banner", "-v", "error", "-encoders"])
-    if not out:
-        return set()
-    enc = set()
-    for line in out.splitlines():
-        m = re.match(r"^\s*A\S*\s+([^\s]+)", line)
-        if m:
-            enc.add(m.group(1).strip())
-    return enc
-
-# Extension mappings
-AUDIO_EXT_TO_FFMPEG_FORMAT = {
-    "mp3": "mp3",
-    "wav": "wav",
-    "w64": "w64",
-    "flac": "flac",
-    "ogg": "ogg",
-    "oga": "ogg",
-    "opus": "ogg",
-    "spx": "ogg",
-    "aac": "adts",
-    "m4a": "mp4",
-    "m4b": "mp4",
-    "m4r": "mp4",
-    "ac3": "ac3",
-    "aiff": "aiff",
-    "aif": "aiff",
-    "aifc": "aiff",
-    "caf": "caf",
-    "au": "au",
-    "amr": "amr",
-    "dts": "dts",
-    "mp2": "mp2",
-    "wma": "asf",
-    "wv": "wv",
-    "mka": "matroska",
-}
-
-AUDIO_REQUIRED_CODECS = {
-    "mp3": ["libmp3lame"],
-    "opus": ["libopus"],
-    "spx": ["libspeex"],
-}
-
-VIDEO_EXT_TO_FFMPEG_FORMAT = {
-    "mp4": "mp4",
-    "m4v": "mp4",
-    "mov": "mov",
-    "avi": "avi",
-    "mkv": "matroska",
-    "webm": "webm",
-    "flv": "flv",
-    "ogv": "ogg",
-    "mpeg": "mpeg",
-    "mpg": "mpeg",
-    "ts": "mpegts",
-    "m2ts": "mpegts",
-    "mxf": "mxf",
-    "3gp": "3gp",
-    "3g2": "3g2",
-    "asf": "asf",
-    "wmv": "asf",
-    "vob": "vob",
-}
-
-def available_audio_extensions():
-    writable = ffmpeg_writable_formats()
-    encoders = ffmpeg_audio_encoders()
-    exts = []
-    for ext, ffmt in AUDIO_EXT_TO_FFMPEG_FORMAT.items():
-        if ffmt not in writable:
-            continue
-        req = AUDIO_REQUIRED_CODECS.get(ext)
-        if req and not any(r in encoders for r in req):
-            continue
-        exts.append(ext)
-    if not exts:
-        exts = ["mp3", "wav", "flac", "ogg", "aac", "m4a", "aiff", "wma", "opus"]
-    return sorted(set(exts))
-
-def available_video_extensions():
-    writable = ffmpeg_writable_formats()
-    exts = [ext for ext, ffmt in VIDEO_EXT_TO_FFMPEG_FORMAT.items() if ffmt in writable]
-    if not exts:
-        exts = ["mp4", "mkv", "avi", "mov", "webm", "flv", "mpeg", "mpg", "ts"]
-    return sorted(set(exts))
-
-def available_image_extensions():
-    ext2fmt = Image.registered_extensions()
-    save_ok = set(getattr(Image, "SAVE", {}).keys()) or set()
-    if not save_ok:
-        save_ok = set(ext2fmt.values())
-    exts = []
-    for ext, fmt in ext2fmt.items():
-        if fmt in save_ok:
-            e = ext.lstrip(".").lower()
-            exts.append(e)
-    if not exts:
-        exts = ["png", "jpg", "jpeg", "webp", "bmp", "tiff", "gif", "ico", "ppm", "pgm", "pbm", "pnm", "tga", "xbm", "xpm", "pdf", "eps"]
-    return sorted(set(exts))
-
-def pil_format_for_ext(ext):
-    ext = ext.lower().strip(".")
-    for k, v in Image.registered_extensions().items():
-        if k.lstrip(".").lower() == ext:
-            return v
-    fallback = {
-        "jpg": "JPEG",
-        "jpeg": "JPEG",
-        "png": "PNG",
-        "webp": "WEBP",
-        "bmp": "BMP",
-        "tiff": "TIFF",
-        "tif": "TIFF",
-        "gif": "GIF",
-        "ico": "ICO",
-        "ppm": "PPM",
-        "pgm": "PPM",
-        "pbm": "PPM",
-        "pnm": "PPM",
-        "tga": "TGA",
-        "xbm": "XBM",
-        "xpm": "XPM",
-        "pdf": "PDF",
-        "eps": "EPS",
-    }
-    return fallback.get(ext, None)
+        raise gr.Error("Video processing failed. Please check the file format and try again.")
 
 def update_format_choices(conversion_type):
+    """Update format dropdown based on conversion type"""
     if conversion_type == "Video to Video":
         vf = available_video_extensions()
         value = "mp4" if "mp4" in vf else (vf[0] if vf else None)
@@ -541,13 +570,20 @@ 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 with optimized handlers -----------------------
+# ----------------------- UI -----------------------
 AUDIO_FORMATS = available_audio_extensions()
 VIDEO_FORMATS = available_video_extensions()
 IMAGE_FORMATS = available_image_extensions()
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.HTML(i18n("title_app"))
+    
+    # System info
+    gr.HTML(f"""
+        <div style='text-align: center; color: #666; margin-bottom: 1rem;'>
+            <p>CPU cores: {multiprocessing.cpu_count()} | Using {MAX_WORKERS} threads</p>
+        </div>
+    """)
 
     with gr.Tabs():
         # AUDIO TAB
@@ -561,13 +597,19 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     default_audio = "mp3" if "mp3" in AUDIO_FORMATS else (AUDIO_FORMATS[0] if AUDIO_FORMATS else None)
                     audio_format_choice = gr.Dropdown(choices=AUDIO_FORMATS, label=i18n("label_audio_format_choice"), value=default_audio)
                     merge_files_checkbox = gr.Checkbox(label=i18n("label_merge_files_checkbox"))
-                    gap_slider = gr.Slider(minimum=0, maximum=5000, step=100, value=500, label=i18n("label_gap_slider"))
+                    gap_slider = gr.Slider(minimum=0, maximum=5000, step=100, value=500, label=i18n("label_gap_slider"), visible=False)
 
             audio_submit_button = gr.Button(i18n("сonvert"), variant="primary")
             audio_output_file = gr.File(label=i18n("download_result"))
+            
+            merge_files_checkbox.change(
+                lambda x: gr.update(visible=x),
+                inputs=merge_files_checkbox,
+                outputs=gap_slider
+            )
 
             audio_submit_button.click(
-                fn=process_audio_files_optimized,
+                fn=process_audio_files,
                 inputs=[audio_file_input, audio_format_choice, merge_files_checkbox, gap_slider],
                 outputs=audio_output_file
             )
@@ -587,7 +629,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_optimized,
+                fn=process_image_files,
                 inputs=[image_file_input, image_format_choice],
                 outputs=image_output_file
             )
@@ -622,10 +664,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             )
 
             video_submit_button.click(
-                fn=process_video_optimized,
+                fn=process_video,
                 inputs=[video_input, conversion_type_radio, video_format_dropdown],
                 outputs=video_output_file
             )
 
 if __name__ == "__main__":
+    check_ffmpeg_installation()
     demo.queue().launch(i18n=i18n, debug=True, show_error=True)