Update app.py

app.py

@@ -11,7 +11,7 @@ from urllib.parse import urlparse, unquote
 try:
     import requests
 except ImportError:
-    print("Error: Falta instalar 'requests'. Ejecuta: pip install requests")
+    print("Error: Falta instalar 'requests'")
 
 # --- Configuración Global ---
 subprocess.run(["git", "config", "--global", "user.email", "bot@codeberg.org"], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
@@ -91,7 +91,6 @@ def create_master_m3u8(output_dir, video_streams, audio_playlists):
 # --- Funciones de Subida ---
 
 def upload_to_codeberg(output_dir, repo_name, codeberg_token, username, batch_size, stream_format, logs):
-    """Sube archivos a Codeberg via Git"""
     try:
         msg, logs = log_generator("📦 Creando repositorio en Codeberg...", logs)
         yield msg, logs, None
@@ -102,12 +101,7 @@ def upload_to_codeberg(output_dir, repo_name, codeberg_token, username, batch_si
         
         try:
             r = requests.post(url_api, headers=headers, json=data, timeout=30)
-            if r.status_code not in [200, 201, 409]:
-                msg, logs = log_generator(f"⚠️ API Codeberg: {r.text[:100]}", logs)
-                yield msg, logs, None
-        except Exception as e:
-            msg, logs = log_generator(f"⚠️ Error API: {str(e)}", logs)
-            yield msg, logs, None
+        except: pass
         
         repo_url = f"https://codeberg.org/{username}/{repo_name}"
         git_dir = str(output_dir)
@@ -130,16 +124,20 @@ def upload_to_codeberg(output_dir, repo_name, codeberg_token, username, batch_si
         if manifest_files:
             subprocess.run(['git', 'add'] + manifest_files, cwd=git_dir, check=True)
             subprocess.run(['git', 'commit', '-m', 'Add manifests'], cwd=git_dir, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            subprocess.run(['git', 'push', '-f', 'origin', 'HEAD:main'], cwd=git_dir, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=600)
+            try:
+                subprocess.run(['git', 'push', '-f', 'origin', 'HEAD:main'], cwd=git_dir, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=600)
+            except: pass
         
-        msg, logs = log_generator(f"⬆️ Subiendo {len(seg_files)} segmentos a Codeberg...", logs)
+        msg, logs = log_generator(f"⬆️ Subiendo {len(seg_files)} segmentos...", logs)
         yield msg, logs, None
         
         for i in range(0, len(seg_files), batch_size):
             batch = seg_files[i:i+batch_size]
             subprocess.run(['git', 'add'] + batch, cwd=git_dir, check=True)
             subprocess.run(['git', 'commit', '-m', f'Batch {i}'], cwd=git_dir, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-            subprocess.run(['git', 'push', '-f', 'origin', 'HEAD:main'], cwd=git_dir, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=600)
+            try:
+                subprocess.run(['git', 'push', '-f', 'origin', 'HEAD:main'], cwd=git_dir, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=600)
+            except: pass
         
         final_url = f"{repo_url}/raw/branch/main/{manifest_name}"
         msg, logs = log_generator(f"✅ Codeberg: {final_url}", logs)
@@ -150,16 +148,11 @@ def upload_to_codeberg(output_dir, repo_name, codeberg_token, username, batch_si
         yield msg, logs, None
 
 def upload_to_cloudflare_pages(output_dir, project_name, cf_token, cf_account_id, stream_format, logs):
-    """Sube archivos directamente a Cloudflare Pages"""
     try:
-        msg, logs = log_generator("☁️ Preparando subida a Cloudflare Pages...", logs)
+        msg, logs = log_generator("☁️ Subiendo a Cloudflare Pages...", logs)
         yield msg, logs, None
         
-        headers = {
-            "Authorization": f"Bearer {cf_token}",
-            "Content-Type": "application/json"
-        }
-        
+        headers = {"Authorization": f"Bearer {cf_token}"}
         project_url = f"https://api.cloudflare.com/client/v4/accounts/{cf_account_id}/pages/projects"
         
         try:
@@ -167,24 +160,10 @@ def upload_to_cloudflare_pages(output_dir, project_name, cf_token, cf_account_id
             if r.status_code == 200:
                 projects = r.json().get('result', [])
                 exists = any(p['name'] == project_name for p in projects)
-                
                 if not exists:
-                    msg, logs = log_generator(f"📦 Creando proyecto: {project_name}", logs)
-                    yield msg, logs, None
-                    
-                    project_data = {
-                        "name": project_name,
-                        "production_branch": "main"
-                    }
-                    r = requests.post(project_url, headers=headers, json=project_data, timeout=30)
-                    if r.status_code not in [200, 201]:
-                        raise Exception(f"Error creando proyecto: {r.text[:200]}")
-        except Exception as e:
-            msg, logs = log_generator(f"⚠️ {str(e)}", logs)
-            yield msg, logs, None
-        
-        msg, logs = log_generator("📦 Comprimiendo archivos...", logs)
-        yield msg, logs, None
+                    project_data = {"name": project_name, "production_branch": "main"}
+                    requests.post(project_url, headers=headers, json=project_data, timeout=30)
+        except: pass
         
         zip_path = output_dir.parent / f"{project_name}.zip"
         with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
@@ -192,381 +171,265 @@ def upload_to_cloudflare_pages(output_dir, project_name, cf_token, cf_account_id
                 if file.is_file():
                     zipf.write(file, file.name)
         
-        msg, logs = log_generator("⬆️ Subiendo a Cloudflare Pages...", logs)
-        yield msg, logs, None
-        
         deploy_url = f"{project_url}/{project_name}/deployments"
         
         with open(zip_path, 'rb') as f:
             files_upload = {'file': (f'{project_name}.zip', f, 'application/zip')}
-            headers_upload = {"Authorization": f"Bearer {cf_token}"}
-            
-            r = requests.post(deploy_url, headers=headers_upload, files=files_upload, timeout=300)
+            r = requests.post(deploy_url, headers={"Authorization": f"Bearer {cf_token}"}, files=files_upload, timeout=300)
             
             if r.status_code in [200, 201]:
                 result = r.json().get('result', {})
                 cf_url = result.get('url', f"https://{project_name}.pages.dev")
                 manifest_name = "manifest.mpd" if stream_format == "DASH (MPD)" else "master.m3u8"
                 final_url = f"{cf_url}/{manifest_name}"
-                msg, logs = log_generator(f"✅ Cloudflare Pages: {final_url}", logs)
+                msg, logs = log_generator(f"✅ Cloudflare: {final_url}", logs)
                 yield msg, logs, final_url
-                
                 zip_path.unlink()
             else:
-                raise Exception(f"Error en deployment: {r.status_code} - {r.text[:200]}")
+                raise Exception(f"Error: {r.status_code}")
                 
     except Exception as e:
         msg, logs = log_generator(f"❌ Error Cloudflare: {str(e)}", logs)
         yield msg, logs, None
 
-# --- Lógica de Procesamiento Principal ---
+# --- Procesamiento Principal ---
 
-def process_video(
-    codeberg_token, cf_token, cf_account_id, input_file, input_urls, 
-    conversion_option, stream_format, batch_size_vid, delete_local,
-    upload_codeberg_flag, upload_cloudflare_flag,
-    progress=gr.Progress()
-):
-    logs = ["🚀 Iniciando proceso..."]
-    
-    if not upload_codeberg_flag and not upload_cloudflare_flag:
-        logs.append("❌ Selecciona al menos un destino (Codeberg o Cloudflare)")
-        yield "\n".join(logs), logs, ""
-        return
+def process_video(file_input, url_input, codeberg_token, cf_token, cf_account_id, 
+                  conversion_mode, stream_format, upload_codeberg_flag, upload_cloudflare_flag,
+                  batch_size, delete_local, progress=gr.Progress()):
     
-    if upload_codeberg_flag and not codeberg_token:
-        logs.append("❌ Se requiere Token de Codeberg")
-        yield "\n".join(logs), logs, ""
-        return
+    logs = ["🚀 Iniciando conversión..."]
     
-    if upload_cloudflare_flag and (not cf_token or not cf_account_id):
-        logs.append("❌ Se requiere Token y Account ID de Cloudflare")
-        yield "\n".join(logs), logs, ""
-        return
-    
-    username = None
-    if upload_codeberg_flag:
-        headers_cb = {"Authorization": f"token {codeberg_token}"}
-        try:
-            user_resp = requests.get("https://codeberg.org/api/v1/user", headers=headers_cb, timeout=10)
-            if user_resp.status_code != 200:
-                raise Exception("❌ Token de Codeberg inválido")
-            username = user_resp.json().get('login')
-            logs.append(f"👤 Usuario Codeberg: {username}")
-            yield "\n".join(logs), logs, ""
-        except Exception as e:
-            logs.append(str(e))
-            yield "\n".join(logs), logs, ""
-            return
-    
-    sources = []
-    if input_file:
-        files_list = input_file if isinstance(input_file, list) else [input_file]
-        for f in files_list: 
-            if f is not None: sources.append({"type": "file", "value": f.name})
-    
-    if input_urls:
-        for line in input_urls.split('\n'):
-            url = line.strip()
-            if url: sources.append({"type": "url", "value": url})
-    
-    if not sources:
-        logs.append("⚠️ Agrega archivos o URLs para procesar")
-        yield "\n".join(logs), logs, ""
-        return
-    
-    total_sources = len(sources)
-    final_links = []
-    
-    for idx, source in enumerate(sources):
-        try:
-            is_file = source['type'] == 'file'
-            source_val = source['value']
-            base_name = Path(source_val).stem if is_file else get_filename_from_url(source_val)
-            
-            msg, logs = log_generator(f"\n📹 [{idx+1}/{total_sources}] Procesando: {base_name}", logs)
-            yield msg, logs, ""
-            
-            repo_name = clean_for_repo(base_name)
-            folder_name = clean_for_folder(base_name) + f"_{stream_format.lower().replace(' ', '_')}"
-            output_dir = Path.cwd() / folder_name
-            
-            if output_dir.exists():
-                shutil.rmtree(output_dir)
-            output_dir.mkdir(exist_ok=True)
-            
-            msg, logs = log_generator("🔍 Detectando streams de audio...", logs)
-            yield msg, logs, ""
-            
+    try:
+        # Validar entrada
+        source = None
+        is_url = False
+        
+        if file_input:
+            source = file_input.name
+        elif url_input:
+            source = url_input
+            is_url = True
+        else:
+            return "\n".join(logs + ["❌ Selecciona archivo o URL"]), "Error"
+        
+        # Validar destinos
+        if not upload_codeberg_flag and not upload_cloudflare_flag:
+            return "\n".join(logs + ["❌ Selecciona al menos un destino"]), "Error"
+        
+        if upload_codeberg_flag and not codeberg_token:
+            return "\n".join(logs + ["❌ Se requiere Token de Codeberg"]), "Error"
+        
+        if upload_cloudflare_flag and (not cf_token or not cf_account_id):
+            return "\n".join(logs + ["❌ Se requiere Token y Account ID de Cloudflare"]), "Error"
+        
+        # Validar usuario Codeberg
+        username = None
+        if upload_codeberg_flag:
+            headers_cb = {"Authorization": f"token {codeberg_token}"}
             try:
-                audio_tracks = detect_audio_streams(source_val)
-            except:
-                audio_tracks = []
-
-            if not audio_tracks:
-                msg, logs = log_generator("⚠️ No se detectaron streams, usando track 0", logs)
-                yield msg, logs, ""
-                audio_tracks = [{'index': 0, 'language': 'und', 'title': 'Audio', 'codec': 'unknown'}]
-            
-            audio_tracks = prioritize_audio_tracks(audio_tracks)
-            
-            # --- Conversión FFmpeg (CÓDIGO COMPLETO IGUAL QUE ANTES) ---
-            if stream_format == "HLS (M3U8)":
-                audio_playlists = []
-                msg, logs = log_generator("🎵 Procesando audio (HLS)...", logs)
-                yield msg, logs, ""
-                
-                for i, track in enumerate(audio_tracks):
-                    try:
-                        audio_file = output_dir / f"audio_{i}.m3u8"
-                        seg_audio = output_dir / f"audio_{i}_%03d.ts"
-                        
-                        if conversion_option == "Opción 1: Copy Video + Copy Audio":
-                            audio_params = ['-c:a', 'copy']
-                        elif conversion_option == "Opción 2: Copy Video + MP3 Audio":
-                            audio_params = ['-c:a', 'libmp3lame', '-b:a', '192k', '-ar', '48000']
-                        else:
-                            audio_params = ['-c:a', 'aac', '-b:a', '128k']
-
-                        cmd_audio = ['ffmpeg', '-i', source_val, '-map', f"0:{track['index']}"] + audio_params + ['-hls_time', '10', '-hls_list_size', '0', '-hls_segment_filename', str(seg_audio), str(audio_file), '-y', '-loglevel', 'warning']
-                        subprocess.run(cmd_audio, capture_output=True, text=True, timeout=3600)
-                        audio_playlists.append({'file': f"audio_{i}.m3u8", 'language': track['language'], 'title': track['title'], 'is_default': i == 0})
-                    except Exception as e:
-                        msg, logs = log_generator(f"  ❌ Error Audio {i+1}: {str(e)}", logs)
-                        yield msg, logs, ""
-                
-                if not audio_playlists: 
-                    raise Exception("No se pudo codificar audio")
-                    
-                video_streams = []
-                msg, logs = log_generator("🎬 Procesando video...", logs)
-                yield msg, logs, ""
-                
-                if conversion_option in ["Opción 1: Copy Video + Copy Audio", "Opción 2: Copy Video + MP3 Audio"]:
-                    video_file_1080 = output_dir / "video_1080p.m3u8"
-                    seg_video_1080 = output_dir / "video_1080p_%03d.ts"
-                    cmd_video = ['ffmpeg', '-i', source_val, '-map', '0:v', '-c:v', 'copy', '-an', '-hls_time', '10', '-hls_list_size', '0', '-hls_segment_filename', str(seg_video_1080), str(video_file_1080), '-y', '-loglevel', 'warning']
-                    subprocess.run(cmd_video, capture_output=True, text=True, timeout=7200)
-                    
-                    video_file_720 = output_dir / "video_720p.m3u8"
-                    shutil.copy(video_file_1080, video_file_720)
-                    for ts_file in output_dir.glob("video_1080p_*.ts"):
-                        shutil.copy(ts_file, output_dir / ts_file.name.replace("1080p", "720p"))
-                        
-                    video_streams.append({'file': 'video_1080p.m3u8', 'resolution': '1920x1080', 'bandwidth': 5000000, 'codecs': 'avc1.640028'})
-                    video_streams.append({'file': 'video_720p.m3u8', 'resolution': '1280x720', 'bandwidth': 3000000, 'codecs': 'avc1.640028'})
-                
-                elif conversion_option == "Opción 3: Multi-Res (1080p + 720p) H.264":
-                    res_list = [
-                        {'label': '1080p', 'scale': 'scale=-2:1080', 'br': '5000k', 'res': '1920x1080'}, 
-                        {'label': '720p', 'scale': 'scale=-2:720', 'br': '2800k', 'res': '1280x720'}
-                    ]
-                    for res_config in res_list:
-                        msg, logs = log_generator(f"  🔄 Renderizando {res_config['label']}...", logs)
-                        yield msg, logs, ""
-                        video_file = output_dir / f"video_{res_config['label']}.m3u8"
-                        seg_video = output_dir / f"video_{res_config['label']}_%03d.ts"
-                        cmd_video = ['ffmpeg', '-i', source_val, '-map', '0:v', '-an', '-c:v', 'libx264', '-preset', 'medium', '-crf', '20', '-vf', res_config['scale'], '-b:v', res_config['br'], '-maxrate', res_config['br'], '-bufsize', str(int(res_config['br'].replace('k',''))*2) + 'k', '-pix_fmt', 'yuv420p', '-hls_time', '10', '-hls_list_size', '0', '-hls_segment_filename', str(seg_video), str(video_file), '-y', '-loglevel', 'warning']
-                        subprocess.run(cmd_video, capture_output=True, text=True, timeout=7200)
-                        video_streams.append({'file': f"video_{res_config['label']}.m3u8", 'resolution': res_config['res'], 'bandwidth': int(res_config['br'].replace('k', '000')) + 192000, 'codecs': 'avc1.640028'})
-
-                elif conversion_option == "Opción 4: Multi-Res (4K + 1080p + 720p) H.264":
-                    res_list = [
-                        {'label': '4K', 'scale': 'scale=-2:2160', 'br': '15000k', 'res': '3840x2160'}, 
-                        {'label': '1080p', 'scale': 'scale=-2:1080', 'br': '5000k', 'res': '1920x1080'}, 
-                        {'label': '720p', 'scale': 'scale=-2:720', 'br': '2800k', 'res': '1280x720'}
-                    ]
-                    for res_config in res_list:
-                        msg, logs = log_generator(f"  🔄 Renderizando {res_config['label']}...", logs)
-                        yield msg, logs, ""
-                        video_file = output_dir / f"video_{res_config['label']}.m3u8"
-                        seg_video = output_dir / f"video_{res_config['label']}_%03d.ts"
-                        cmd_video = ['ffmpeg', '-i', source_val, '-map', '0:v', '-an', '-c:v', 'libx264', '-preset', 'medium', '-crf', '20', '-vf', res_config['scale'], '-b:v', res_config['br'], '-maxrate', res_config['br'], '-bufsize', str(int(res_config['br'].replace('k',''))*2) + 'k', '-pix_fmt', 'yuv420p', '-hls_time', '10', '-hls_list_size', '0', '-hls_segment_filename', str(seg_video), str(video_file), '-y', '-loglevel', 'warning']
-                        subprocess.run(cmd_video, capture_output=True, text=True, timeout=7200)
-                        video_streams.append({'file': f"video_{res_config['label']}.m3u8", 'resolution': res_config['res'], 'bandwidth': int(res_config['br'].replace('k', '000')) + 192000, 'codecs': 'avc1.640028'})
-
-                create_master_m3u8(output_dir, video_streams, audio_playlists)
-
-            elif stream_format == "DASH (MPD)":
-                msg, logs = log_generator("🎬 Generando DASH (fMP4)...", logs)
-                yield msg, logs, ""
-                cmd = ['ffmpeg', '-i', source_val]
-                is_copy_mode = (conversion_option == "Opción 1: Copy Video + Copy Audio")
-                audio_codec = 'copy' if is_copy_mode else 'aac'
-                video_codec = 'copy' if is_copy_mode else 'libx264'
+                user_resp = requests.get("https://codeberg.org/api/v1/user", headers=headers_cb, timeout=10)
+                if user_resp.status_code != 200:
+                    raise Exception("Token de Codeberg inválido")
+                username = user_resp.json().get('login')
+                logs.append(f"👤 Usuario: {username}")
+            except Exception as e:
+                return "\n".join(logs + [f"❌ {str(e)}"]), "Error"
+        
+        # Preparar nombres
+        base_name = Path(source).stem if not is_url else get_filename_from_url(source)
+        repo_name = clean_for_repo(base_name)
+        folder_name = clean_for_folder(base_name) + f"_{stream_format.lower().replace(' ', '_')}"
+        output_dir = Path.cwd() / folder_name
+        
+        if output_dir.exists():
+            shutil.rmtree(output_dir)
+        output_dir.mkdir(exist_ok=True)
+        
+        logs.append(f"📹 Procesando: {base_name}")
+        yield "\n".join(logs), "Procesando"
+        
+        # Detectar audio
+        audio_tracks = detect_audio_streams(source)
+        if not audio_tracks:
+            audio_tracks = [{'index': 0, 'language': 'und', 'title': 'Audio', 'codec': 'unknown'}]
+        audio_tracks = prioritize_audio_tracks(audio_tracks)
+        
+        logs.append(f"🎵 {len(audio_tracks)} streams de audio detectados")
+        yield "\n".join(logs), "Procesando"
+        
+        # Conversión FFmpeg
+        if stream_format == "HLS (M3U8)":
+            # Procesar audio
+            audio_playlists = []
+            for i, track in enumerate(audio_tracks):
+                audio_file = output_dir / f"audio_{i}.m3u8"
+                seg_audio = output_dir / f"audio_{i}_%03d.ts"
                 
-                if is_copy_mode or conversion_option == "Opción 2":
-                    cmd.extend(['-map', '0:v:0', '-c:v:0', video_codec])
+                if conversion_mode == "Copy Video + Copy Audio":
+                    audio_params = ['-c:a', 'copy']
                 else:
-                    res_list = []
-                    if conversion_option == "Opción 3: Multi-Res (1080p + 720p) H.264":
-                        res_list = [{'idx': 0, 'scale': 'scale=-2:1080', 'br': '5000k'}, {'idx': 1, 'scale': 'scale=-2:720', 'br': '2800k'}]
-                    elif conversion_option == "Opción 4: Multi-Res (4K + 1080p + 720p) H.264":
-                        res_list = [{'idx': 0, 'scale': 'scale=-2:2160', 'br': '15000k'}, {'idx': 1, 'scale': 'scale=-2:1080', 'br': '5000k'}, {'idx': 2, 'scale': 'scale=-2:720', 'br': '2800k'}]
-                    for r in res_list:
-                        cmd.extend(['-map', '0:v:0'])
-                        cmd.extend([f'-c:v:{r["idx"]}', video_codec, '-preset', 'medium', '-crf', '20', f'-vf:v:{r["idx"]}', r['scale'], f'-b:v:{r["idx"]}', r['br'], '-pix_fmt', 'yuv420p'])
-
-                for i, track in enumerate(audio_tracks):
-                    cmd.extend(['-map', f"0:{track['index']}", f'-c:a:{i}', audio_codec, '-b:a:192k', '-ar', '48000'])
-
-                mpd_output = output_dir / "manifest.mpd"
-                cmd.extend(['-f', 'dash', '-seg_duration', '10', '-use_template', '1', '-use_timeline', '0', '-init_seg_name', 'init-$RepresentationID$.m4s', '-media_seg_name', 'chunk-$RepresentationID$-$Number%05d$.m4s', str(mpd_output), '-y', '-loglevel', 'warning'])
-                subprocess.run(cmd, capture_output=True, text=True, timeout=7200)
-
-            # --- Subida a destinos ---
-            result_links = [f"**{base_name}**"]
+                    audio_params = ['-c:a', 'libmp3lame', '-b:a', '192k', '-ar', '48000']
+                
+                cmd_audio = ['ffmpeg', '-i', source, '-map', f"0:{track['index']}"] + audio_params + [
+                    '-hls_time', '10', '-hls_list_size', '0', '-hls_segment_filename', str(seg_audio), str(audio_file), '-y', '-loglevel', 'warning'
+                ]
+                subprocess.run(cmd_audio, capture_output=True, timeout=3600)
+                audio_playlists.append({'file': f"audio_{i}.m3u8", 'language': track['language'], 'title': track['title'], 'is_default': i == 0})
             
-            if upload_codeberg_flag:
-                for update in upload_to_codeberg(output_dir, repo_name, codeberg_token, username, int(batch_size_vid), stream_format, logs):
-                    yield update[0], update[1], "\n\n".join(final_links)
-                    if update[2]:
-                        result_links.append(f"📂 Codeberg: {update[2]}")
+            # Procesar video
+            video_streams = []
+            if conversion_mode in ["Copy Video + Copy Audio", "Copy Video + MP3 Audio"]:
+                video_file = output_dir / "video_1080p.m3u8"
+                seg_video = output_dir / "video_1080p_%03d.ts"
+                cmd_video = ['ffmpeg', '-i', source, '-map', '0:v', '-c:v', 'copy', '-an', '-hls_time', '10', '-hls_list_size', '0', 
+                           '-hls_segment_filename', str(seg_video), str(video_file), '-y', '-loglevel', 'warning']
+                subprocess.run(cmd_video, capture_output=True, timeout=7200)
+                video_streams.append({'file': 'video_1080p.m3u8', 'resolution': '1920x1080', 'bandwidth': 5000000, 'codecs': 'avc1.640028'})
             
-            if upload_cloudflare_flag:
-                for update in upload_to_cloudflare_pages(output_dir, repo_name, cf_token, cf_account_id, stream_format, logs):
-                    yield update[0], update[1], "\n\n".join(final_links)
-                    if update[2]:
-                        result_links.append(f"☁️ Cloudflare: {update[2]}")
+            elif conversion_mode == "Multi-Res (1080p + 720p)":
+                for res in [{'label': '1080p', 'scale': 'scale=-2:1080', 'br': '5000k', 'res': '1920x1080'},
+                           {'label': '720p', 'scale': 'scale=-2:720', 'br': '2800k', 'res': '1280x720'}]:
+                    video_file = output_dir / f"video_{res['label']}.m3u8"
+                    seg_video = output_dir / f"video_{res['label']}_%03d.ts"
+                    cmd_video = ['ffmpeg', '-i', source, '-map', '0:v', '-an', '-c:v', 'libx264', '-preset', 'medium', '-crf', '20',
+                               '-vf', res['scale'], '-b:v', res['br'], '-maxrate', res['br'], '-bufsize', str(int(res['br'].replace('k',''))*2) + 'k',
+                               '-pix_fmt', 'yuv420p', '-hls_time', '10', '-hls_list_size', '0', '-hls_segment_filename', str(seg_video), 
+                               str(video_file), '-y', '-loglevel', 'warning']
+                    subprocess.run(cmd_video, capture_output=True, timeout=7200)
+                    video_streams.append({'file': f"video_{res['label']}.m3u8", 'resolution': res['res'], 
+                                        'bandwidth': int(res['br'].replace('k', '000')) + 192000, 'codecs': 'avc1.640028'})
             
-            final_links.append("\n".join(result_links))
+            create_master_m3u8(output_dir, video_streams, audio_playlists)
+        
+        elif stream_format == "DASH (MPD)":
+            cmd = ['ffmpeg', '-i', source]
+            is_copy = (conversion_mode == "Copy Video + Copy Audio")
             
-            if delete_local:
-                try:
-                    shutil.rmtree(output_dir)
-                    msg, logs = log_generator("🗑️ Archivos locales eliminados", logs)
-                    yield msg, logs, "\n\n".join(final_links)
-                except: 
-                    pass
-        
-        except Exception as global_e:
-            import traceback
-            logs.append(f"\n❌ ERROR: {str(global_e)}")
-            print(traceback.format_exc())
-            yield "\n".join(logs), logs, "\n\n".join(final_links)
-
-    msg, logs = log_generator("\n✅ Proceso completado", logs)
-    yield msg, logs, "\n\n".join(final_links)
+            if is_copy:
+                cmd.extend(['-map', '0:v:0', '-c:v:0', 'copy'])
+            else:
+                if conversion_mode == "Multi-Res (1080p + 720p)":
+                    for idx, r in enumerate([{'scale': 'scale=-2:1080', 'br': '5000k'}, {'scale': 'scale=-2:720', 'br': '2800k'}]):
+                        cmd.extend(['-map', '0:v:0', f'-c:v:{idx}', 'libx264', '-preset', 'medium', '-crf', '20',
+                                  f'-vf:v:{idx}', r['scale'], f'-b:v:{idx}', r['br'], '-pix_fmt', 'yuv420p'])
+            
+            for i, track in enumerate(audio_tracks):
+                cmd.extend(['-map', f"0:{track['index']}", f'-c:a:{i}', 'aac' if not is_copy else 'copy', '-b:a:192k', '-ar', '48000'])
+            
+            mpd_output = output_dir / "manifest.mpd"
+            cmd.extend(['-f', 'dash', '-seg_duration', '10', '-use_template', '1', '-use_timeline', '0',
+                       '-init_seg_name', 'init-$RepresentationID$.m4s', '-media_seg_name', 'chunk-$RepresentationID$-$Number%05d$.m4s',
+                       str(mpd_output), '-y', '-loglevel', 'warning'])
+            subprocess.run(cmd, capture_output=True, timeout=7200)
+        
+        logs.append("✅ Conversión completada")
+        yield "\n".join(logs), "Subiendo"
+        
+        # Subir a destinos
+        result_links = []
+        
+        if upload_codeberg_flag:
+            for update in upload_to_codeberg(output_dir, repo_name, codeberg_token, username, int(batch_size), stream_format, logs):
+                yield update[0], "Subiendo"
+                if update[2]:
+                    result_links.append(f"📂 Codeberg: {update[2]}")
+        
+        if upload_cloudflare_flag:
+            for update in upload_to_cloudflare_pages(output_dir, repo_name, cf_token, cf_account_id, stream_format, logs):
+                yield update[0], "Subiendo"
+                if update[2]:
+                    result_links.append(f"☁️ Cloudflare: {update[2]}")
+        
+        if delete_local:
+            shutil.rmtree(output_dir)
+            logs.append("🗑️ Archivos locales eliminados")
+        
+        final_output = "\n".join(logs + ["", "🔗 Enlaces:"] + result_links)
+        return final_output, "¡Listo!"
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return "\n".join(logs + [f"❌ ERROR: {str(e)}"]), "Fallo"
 
-# --- UI LIMPIA ESTILO HUGGING FACE ---
+# --- Interfaz Gradio ---
 
 with gr.Blocks(title="Video Streaming Converter", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("# 🎬 Video Streaming Converter")
-    gr.Markdown("Convierte videos a HLS/DASH y súbelos automáticamente a Codeberg o Cloudflare Pages")
+    gr.Markdown("Convierte videos a HLS/DASH y súbelos a Codeberg o Cloudflare Pages")
     
     with gr.Row():
         with gr.Column(scale=1):
-            # Entrada
-            with gr.Tab("Archivo"):
-                input_file = gr.File(
-                    label="Subir video(s)", 
-                    file_count="multiple", 
-                    file_types=["video"]
-                )
-            with gr.Tab("URL"):
-                input_urls = gr.Textbox(
-                    label="URLs de videos (opcional, una por línea)", 
-                    lines=3, 
-                    placeholder="https://ejemplo.com/video.mp4"
-                )
+            # Tokens
+            codeberg_token = gr.Textbox(
+                label="Codeberg Token", 
+                value="92427ac14a228f0762ec303d478b9f093be4f608",
+                type="password",
+                placeholder="Token con permisos 'repo'"
+            )
+            cf_token = gr.Textbox(
+                label="Cloudflare Token", 
+                value="mOvchd-yxYyQ6Zj3xMb_38Rkf-HwROchlsx-Ud9H",
+                type="password",
+                placeholder="Token de Cloudflare Pages"
+            )
+            cf_account_id = gr.Textbox(
+                label="Cloudflare Account ID",
+                value="bd06ac4017668e45b656db342029929d",
+                placeholder="ID de tu cuenta"
+            )
             
-            # Configuración
-            gr.Markdown("### ⚙️ Configuración")
-            conversion_option = gr.Dropdown(
-                choices=[
-                    "Opción 1: Copy Video + Copy Audio", 
-                    "Opción 2: Copy Video + MP3 Audio",
-                    "Opción 3: Multi-Res (1080p + 720p) H.264",
-                    "Opción 4: Multi-Res (4K + 1080p + 720p) H.264"
-                ],
-                value="Opción 3: Multi-Res (1080p + 720p) H.264",
-                label="Modo de conversión"
+            # Modo
+            conversion_mode = gr.Radio(
+                choices=["Copy Video + Copy Audio", "Copy Video + MP3 Audio", "Multi-Res (1080p + 720p)"],
+                value="Multi-Res (1080p + 720p)",
+                label="Modo"
             )
+            
             stream_format = gr.Radio(
-                choices=["HLS (M3U8)", "DASH (MPD)"], 
-                value="HLS (M3U8)", 
-                label="Formato de streaming"
+                choices=["HLS (M3U8)", "DASH (MPD)"],
+                value="HLS (M3U8)",
+                label="Formato"
             )
             
             # Destino
-            gr.Markdown("### 🌐 Destino de subida")
-            upload_codeberg = gr.Checkbox(value=True, label="Subir a Codeberg")
-            upload_cloudflare = gr.Checkbox(value=False, label="Subir a Cloudflare Pages")
-            
-            # Credenciales
-            with gr.Accordion("🔑 Credenciales (API Tokens)", open=False):
-                codeberg_token = gr.Textbox(
-                    label="Codeberg Token", 
-                    type="password", 
-                    placeholder="Token con permisos 'repo'"
-                )
-                cf_token = gr.Textbox(
-                    label="Cloudflare API Token", 
-                    type="password", 
-                    placeholder="Token con permisos 'Cloudflare Pages'"
-                )
-                cf_account_id = gr.Textbox(
-                    label="Cloudflare Account ID", 
-                    placeholder="ID de tu cuenta Cloudflare"
-                )
+            upload_codeberg = gr.Checkbox(label="Subir a Codeberg", value=True)
+            upload_cloudflare = gr.Checkbox(label="Subir a Cloudflare Pages", value=False)
             
             # Opciones avanzadas
-            with gr.Accordion("⚙️ Opciones avanzadas", open=False):
-                batch_size = gr.Number(
-                    value=20, 
-                    label="Tamaño de lote (Git)", 
-                    precision=0,
-                    minimum=10,
-                    maximum=100
-                )
-                delete_local = gr.Checkbox(
-                    value=True, 
-                    label="Eliminar archivos locales al finalizar"
-                )
-            
-            btn = gr.Button("🚀 PROCESAR Y SUBIR", variant="primary", size="lg")
+            with gr.Accordion("Opciones Avanzadas", open=False):
+                batch_size = gr.Number(value=20, label="Batch Size", precision=0)
+                delete_local = gr.Checkbox(value=True, label="Borrar archivos locales")
         
         with gr.Column(scale=2):
-            # Logs
-            gr.Markdown("### 🖥️ Logs de proceso")
-            log_output = gr.Textbox(
-                lines=20, 
-                interactive=False,
-                show_label=False,
-                placeholder="Los logs aparecerán aquí durante el proceso..."
-            )
+            # Entrada
+            with gr.Tab("Archivo"):
+                file_input = gr.File(label="Subir Video", file_types=["video"])
+            with gr.Tab("URL"):
+                url_input = gr.Textbox(label="URL del Video", placeholder="https://ejemplo.com/video.mp4")
             
-            # Enlaces
-            gr.Markdown("### 🔗 Enlaces generados")
-            final_links = gr.Textbox(
-                lines=8, 
-                interactive=False,
-                show_label=False,
-                placeholder="Los enlaces de streaming aparecerán aquí al finalizar..."
-            )
+            # Botón
+            btn_process = gr.Button("🚀 PROCESAR Y SUBIR", variant="primary", size="lg")
+            
+            # Outputs
+            log_output = gr.Textbox(label="Log", lines=15, interactive=False)
+            status_output = gr.Textbox(label="Estado", interactive=False)
     
     gr.Markdown("---")
-    gr.Markdown("💡 **Tip:** Marca solo el destino que necesites. Cloudflare Pages es más rápido pero público, Codeberg es privado pero más lento.")
+    gr.Markdown("💡 **Tip:** Cloudflare Pages es rápido pero público. Codeberg es privado pero más lento.")
     
     # Eventos
-    btn.click(
+    btn_process.click(
         fn=process_video,
         inputs=[
-            codeberg_token, cf_token, cf_account_id, 
-            input_file, input_urls,
-            conversion_option, stream_format, 
-            batch_size, delete_local,
-            upload_codeberg, upload_cloudflare
+            file_input, url_input, codeberg_token, cf_token, cf_account_id,
+            conversion_mode, stream_format, upload_codeberg, upload_cloudflare,
+            batch_size, delete_local
         ],
-        outputs=[log_output, gr.State(), final_links]
+        outputs=[log_output, status_output]
     )
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        max_file_size=2_000_000_000
-    )
+    demo.launch()