Upload 2 files

hls_dash_converter.py

@@ -0,0 +1,815 @@
+"""
+HLS/DASH Converter EXTREME — App nativa Windows
+Convierte a HLS/DASH y sube a GitHub. Sin Gradio.
+Auto-elevación a administrador.
+"""
+import sys
+import os
+import ctypes
+import subprocess
+import threading
+import tempfile
+import shutil
+import re
+import json
+import time
+import uuid
+import tkinter as tk
+from tkinter import ttk, filedialog, messagebox, scrolledtext
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+# ─── AUTO-ELEVACIÓN ADMINISTRADOR ───────────────────────────
+def is_admin():
+    try:
+        return ctypes.windll.shell32.IsUserAnAdmin()
+    except:
+        return False
+
+def elevate():
+    if not is_admin():
+        ctypes.windll.shell32.ShellExecuteW(
+            None, "runas", sys.executable, " ".join(sys.argv), None, 1
+        )
+        sys.exit()
+
+elevate()
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+# ─── COLORES ────────────────────────────────────────────────
+BG      = "#080d18"
+BG2     = "#0f1629"
+BG3     = "#17213a"
+ACCENT  = "#6366f1"
+ACCENT2 = "#8b5cf6"
+GREEN   = "#22c55e"
+RED     = "#ef4444"
+YELLOW  = "#f59e0b"
+CYAN    = "#22d3ee"
+FG      = "#e2e8f0"
+FG2     = "#94a3b8"
+FG3     = "#3a5070"
+BORDER  = "#1a2a40"
+FM      = ("Consolas", 10)
+FB      = ("Consolas", 11, "bold")
+FS      = ("Consolas", 9)
+
+# ─── UTILS ──────────────────────────────────────────────────
+def get_threads():
+    try:
+        return max(len(os.sched_getaffinity(0)) - 1, 1)
+    except:
+        return max((os.cpu_count() or 4) - 1, 1)
+
+N_THREADS = get_threads()
+
+def clean_folder(n): return re.sub(r'[<>:"/\\|?*]', '_', n).strip()[:200]
+def clean_repo(n):
+    n = re.sub(r'[^a-zA-Z0-9_-]', '-', n)
+    return re.sub(r'-+', '-', n).strip('-')[:100]
+
+def build_name(ctype, mname, sname, season, ep_start, idx):
+    if ctype == "Película":
+        b = mname.strip() or "Pelicula"
+        return clean_folder(b), clean_repo(b)
+    name = sname.strip() or "Serie"
+    try: t = int(season)
+    except: t = 1
+    try: e = int(ep_start) + idx
+    except: e = idx + 1
+    lbl = f"{name}_T{t}_Ep{e}"
+    return clean_folder(lbl), clean_repo(lbl)
+
+def is_live(url):
+    if not url.startswith(("http://", "https://")): return False
+    lo = url.lower()
+    if any(lo.endswith(x) for x in ['.mp4','.mkv','.avi','.mov','.ts']): return False
+    return any(p in lo for p in ['/live/','/stream/','.m3u8','.mpd','/hls/','/dash/'])
+
+def input_args(src):
+    ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+    if src.startswith(("http://", "https://")):
+        if is_live(src):
+            return ['-user_agent', ua, '-timeout', '60000000',
+                    '-reconnect','1','-reconnect_streamed','1',
+                    '-fflags','+genpts+igndts','-probesize','100M','-analyzeduration','50M']
+        return ['-user_agent', ua, '-timeout', '120000000',
+                '-reconnect','1','-reconnect_streamed','1','-reconnect_delay_max','10',
+                '-analyzeduration','500000000','-probesize','500000000',
+                '-fflags','+genpts+igndts','-err_detect','ignore_err',
+                '-max_delay','10000000','-rw_timeout','120000000']
+    return ['-analyzeduration','100000000','-probesize','100000000','-fflags','+genpts+igndts']
+
+def render_args():
+    return ['-threads', str(N_THREADS), '-thread_type', 'slice+frame',
+            '-slices', str(N_THREADS), '-max_muxing_queue_size', '9999',
+            '-thread_queue_size', '4096']
+
+def detect_duration(src, iargs):
+    try:
+        cmd = ['ffprobe','-v','error'] + iargs + ['-show_entries','format=duration','-of','json','-i',src]
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+        d = json.loads(r.stdout).get('format',{}).get('duration')
+        return float(d) if d and d != 'N/A' else None
+    except: return None
+
+def detect_audio(src, iargs):
+    try:
+        cmd = ['ffprobe','-v','error'] + iargs + [
+            '-select_streams','a',
+            '-show_entries','stream=index,codec_name:stream_tags=language,title',
+            '-of','json','-i',src]
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
+        tracks = []
+        for s in json.loads(r.stdout).get('streams',[]):
+            tags = s.get('tags',{})
+            tracks.append({'index': s.get('index',0),
+                           'language': tags.get('language','und').lower(),
+                           'title': tags.get('title', f"Audio {s.get('index',0)}"),
+                           'codec': s.get('codec_name','unknown')})
+        return tracks
+    except: return []
+
+def prioritize_audio(tracks):
+    prio = ['spa','es','spanish','español','latino','lat','es-mx','es-419']
+    def key(t):
+        l, ti = t['language'], t['title'].lower()
+        for p in prio:
+            if p in l or p in ti: return 0
+        return 1 if l == 'und' else 2
+    return sorted(tracks, key=key)
+
+def make_master_m3u8(out_dir, video_streams, audio_playlists):
+    c = "#EXTM3U\n#EXT-X-VERSION:7\n\n"
+    for a in audio_playlists:
+        d = "YES" if a['is_default'] else "NO"
+        c += f'#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="{a["title"]}",LANGUAGE="{a["language"]}",DEFAULT={d},AUTOSELECT={d},URI="{a["file"]}"\n'
+    c += "\n"
+    for v in video_streams:
+        c += f'#EXT-X-STREAM-INF:BANDWIDTH={v["bandwidth"]},RESOLUTION={v["resolution"]},CODECS="{v["codecs"]}",AUDIO="audio"\n{v["file"]}\n'
+    (out_dir / "master.m3u8").write_text(c)
+
+RAMDISK_PATH = None
+def setup_ramdisk():
+    global RAMDISK_PATH
+    for p in [r"C:\Temp\hls_tmp", tempfile.gettempdir() + r"\hls_tmp"]:
+        try:
+            Path(p).mkdir(parents=True, exist_ok=True)
+            RAMDISK_PATH = Path(p)
+            return Path(p)
+        except: continue
+    RAMDISK_PATH = Path(tempfile.gettempdir())
+    return RAMDISK_PATH
+
+RAMDISK = setup_ramdisk()
+
+def process_audio_track(args):
+    track, i, total, src, out_dir, iargs = args
+    tmp = RAMDISK / f"aud_{os.getpid()}_{i}_{int(time.time())}"
+    tmp.mkdir(exist_ok=True)
+    try:
+        af = tmp / f"audio_{i}.m3u8"
+        sf = tmp / f"audio_{i}_%03d.ts"
+        wav_tmp = tmp / f"audio_{i}_raw.wav"
+
+        r_dec = subprocess.run(
+            ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [
+                '-i',src,'-map',f"0:{track['index']}",'-vn',
+                '-c:a','pcm_s16le','-ar','48000','-ac','2','-f','wav',
+                str(wav_tmp),'-y','-loglevel','error'],
+            capture_output=True, text=True, timeout=7200)
+        if r_dec.returncode != 0 or not wav_tmp.exists():
+            raise Exception(f"Decode PCM falló: {r_dec.stderr[-300:]}")
+
+        r_enc = subprocess.run(
+            ['ffmpeg','-hide_banner','-threads',str(N_THREADS),
+             '-i',str(wav_tmp),'-c:a','libmp3lame','-b:a','192k',
+             '-ar','48000','-ac','2','-compression_level','0',
+             '-max_muxing_queue_size','9999','-thread_queue_size','4096',
+             '-hls_time','5','-hls_list_size','0',
+             '-hls_segment_filename',str(sf),
+             '-hls_flags','independent_segments+append_list+temp_file',
+             '-hls_playlist_type','vod','-hls_segment_type','mpegts',
+             str(af),'-y','-loglevel','error'],
+            capture_output=True, text=True, timeout=7200)
+        wav_tmp.unlink(missing_ok=True)
+
+        if r_enc.returncode != 0 or not af.exists():
+            raise Exception(f"Encode MP3 falló: {r_enc.stderr[-300:]}")
+
+        ts_files = list(tmp.glob(f"audio_{i}_*.ts"))
+        if not ts_files: raise Exception("Sin segmentos TS")
+
+        shutil.move(str(af), str(out_dir / f"audio_{i}.m3u8"))
+        for ts in ts_files: shutil.move(str(ts), str(out_dir / ts.name))
+
+        return {'success': True, 'index': i, 'track': track,
+                'segments_count': len(ts_files),
+                'playlist': {'file': f"audio_{i}.m3u8",
+                             'language': track['language'],
+                             'title': track['title'], 'is_default': i == 0}}
+    except Exception as e:
+        return {'success': False, 'index': i, 'error': str(e), 'track': track}
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+def process_video_copy(src, iargs, out_dir, tmp_v, vf, sf, log_cb):
+    hls = ['-hls_time','5','-hls_list_size','0','-hls_segment_filename',str(sf),
+           '-hls_flags','independent_segments+append_list+temp_file+split_by_time',
+           '-hls_playlist_type','vod','-hls_segment_type','mpegts',str(vf),'-y','-loglevel','error']
+    base = ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [
+        '-i',src,'-map','0:v:0','-an',
+        '-max_muxing_queue_size','9999','-avoid_negative_ts','make_zero',
+        '-fflags','+genpts+igndts+flush_packets+discardcorrupt',
+        '-err_detect','ignore_err','-copytb','1','-start_at_zero','-thread_queue_size','4096']
+
+    r1 = subprocess.run(base + ['-c:v','copy','-bsf:v','h264_mp4toannexb,dump_extra'] + hls,
+                        capture_output=True, text=True, timeout=7200)
+    if r1.returncode == 0 and vf.exists() and list(tmp_v.glob("video_1080p_*.ts")):
+        log_cb("  ✓ Video COPY OK (h264_mp4toannexb)"); return True
+
+    vf.unlink(missing_ok=True)
+    for f in tmp_v.glob("video_1080p_*.ts"): f.unlink(missing_ok=True)
+    log_cb("  ⚠ Copy con bsf falló, reintentando sin bsf…")
+
+    r2 = subprocess.run(base + ['-c:v','copy'] + hls,
+                        capture_output=True, text=True, timeout=7200)
+    if r2.returncode == 0 and vf.exists() and list(tmp_v.glob("video_1080p_*.ts")):
+        log_cb("  ✓ Video COPY OK (sin bsf)"); return True
+
+    vf.unlink(missing_ok=True)
+    for f in tmp_v.glob("video_1080p_*.ts"): f.unlink(missing_ok=True)
+    log_cb("  ⚠ Copy falló, re-encode H.264 ultrafast…")
+
+    hls2 = ['-hls_time','5','-hls_list_size','0','-hls_segment_filename',str(sf),
+            '-hls_flags','independent_segments+append_list+temp_file',
+            '-hls_playlist_type','vod','-hls_segment_type','mpegts',str(vf),'-y','-loglevel','error']
+    r3 = subprocess.run(
+        ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [
+            '-i',src,'-map','0:v:0','-an','-c:v','libx264','-preset','ultrafast','-crf','23',
+            '-pix_fmt','yuv420p','-threads',str(N_THREADS),
+            '-max_muxing_queue_size','9999','-thread_queue_size','4096'] + hls2,
+        capture_output=True, text=True, timeout=14400)
+    if r3.returncode == 0 and vf.exists() and list(tmp_v.glob("video_1080p_*.ts")):
+        log_cb("  ✓ Video re-encode H.264 OK"); return True
+    raise Exception(f"Video falló en todos los modos: {r3.stderr[-400:]}")
+
+def git_push_retry(gd, args, retries=3, timeout=600):
+    for attempt in range(retries):
+        try:
+            subprocess.run(['git','push'] + args, cwd=gd, check=True,
+                           capture_output=True, timeout=timeout)
+            return True
+        except:
+            if attempt == retries-1: return False
+            time.sleep(3)
+    return False
+
+def run_conversion(job, log_cb, progress_cb, done_cb):
+    """Hilo principal de conversión"""
+    token         = job['token']
+    sources       = job['sources']
+    conv_opt      = job['conv_opt']
+    stream_fmt    = job['stream_fmt']
+    batch_size    = job['batch_size']
+    delete_local  = job['delete_local']
+    max_workers   = job['max_workers']
+    ctype         = job['ctype']
+    mname         = job['mname']
+    sname         = job['sname']
+    season        = job['season']
+    ep_start      = job['ep_start']
+
+    final_links = []
+    try:
+        log_cb(f"🚀 EXTREME v5.1 | Threads: {N_THREADS} | Temp: {RAMDISK}")
+
+        for idx, source in enumerate(sources):
+            src = source['value']
+            folder_name, repo_name = build_name(ctype, mname, sname, season, ep_start, idx)
+            log_cb(f"\n📦 [{idx+1}/{len(sources)}] {folder_name}")
+            progress_cb(int(idx/len(sources)*100), f"[{idx+1}/{len(sources)}] {folder_name}")
+
+            out_dir = RAMDISK / "outputs" / folder_name
+            out_dir.mkdir(parents=True, exist_ok=True)
+
+            iargs = input_args(src)
+            dur = detect_duration(src, iargs)
+            if dur:
+                h, m, s2 = int(dur//3600), int((dur%3600)//60), int(dur%60)
+                log_cb(f"  ⏱ Duración: {h:02d}:{m:02d}:{s2:02d}")
+
+            audio_tracks = detect_audio(src, iargs) or [{'index':0,'language':'und','title':'Audio','codec':'unk'}]
+            audio_tracks = prioritize_audio(audio_tracks)
+            log_cb(f"  🎵 {len(audio_tracks)} pista(s)")
+
+            manifest_file = ""
+
+            if stream_fmt == "HLS (M3U8)":
+                log_cb(f"  🎵 Procesando {len(audio_tracks)} audio(s) → PCM → MP3")
+                aargs_list = [(t, i, len(audio_tracks), src, out_dir, iargs) for i, t in enumerate(audio_tracks)]
+                audio_playlists = []
+                with ThreadPoolExecutor(max_workers=max_workers) as ex:
+                    futures = {ex.submit(process_audio_track, a): a for a in aargs_list}
+                    for fut in as_completed(futures):
+                        res = fut.result()
+                        if res['success']:
+                            audio_playlists.append(res['playlist'])
+                            log_cb(f"    ✓ Audio {res['index']+1}: {res['track']['title']} ({res['segments_count']} segs)")
+                        else:
+                            log_cb(f"    ✗ Audio {res['index']+1}: {res.get('error','')[:120]}")
+
+                audio_playlists.sort(key=lambda x: int(x['file'].split('_')[1].split('.')[0]))
+                if not audio_playlists: raise Exception("Sin audio procesado")
+
+                video_streams = []
+                if "Copy" in conv_opt:
+                    log_cb("  ⚡ Video COPY → HLS")
+                    tmp_v = RAMDISK / f"vid_{idx}"
+                    tmp_v.mkdir(exist_ok=True)
+                    vf = tmp_v / "video_1080p.m3u8"
+                    sf = tmp_v / "video_1080p_%03d.ts"
+                    process_video_copy(src, iargs, out_dir, tmp_v, vf, sf, log_cb)
+                    final_1080 = out_dir / "video_1080p.m3u8"
+                    shutil.move(str(vf), str(final_1080))
+                    for ts in tmp_v.glob("video_1080p_*.ts"):
+                        shutil.move(str(ts), str(out_dir / ts.name))
+                    shutil.rmtree(tmp_v, ignore_errors=True)
+                    (out_dir / "video_720p.m3u8").write_text(final_1080.read_text())
+                    video_streams = [
+                        {'file':'video_1080p.m3u8','resolution':'1920x1080','bandwidth':5000000,'codecs':'avc1.640028'},
+                        {'file':'video_720p.m3u8', 'resolution':'1280x720', 'bandwidth':3000000,'codecs':'avc1.640028'},
+                    ]
+                else:
+                    rlist = ([{'label':'4K','scale':'scale=-2:2160','br':'15000k','bufsize':'30000k','res':'3840x2160'},
+                               {'label':'1080p','scale':'scale=-2:1080','br':'5000k','bufsize':'10000k','res':'1920x1080'},
+                               {'label':'720p','scale':'scale=-2:720','br':'2800k','bufsize':'5600k','res':'1280x720'}]
+                              if "4K" in conv_opt else
+                              [{'label':'1080p','scale':'scale=-2:1080','br':'5000k','bufsize':'10000k','res':'1920x1080'},
+                               {'label':'720p','scale':'scale=-2:720','br':'2800k','bufsize':'5600k','res':'1280x720'}])
+                    for rc in rlist:
+                        log_cb(f"  🔄 Renderizando {rc['label']}…")
+                        tmp_r = RAMDISK / f"render_{rc['label']}"
+                        tmp_r.mkdir(exist_ok=True)
+                        vf = tmp_r / f"video_{rc['label']}.m3u8"
+                        sf = tmp_r / f"video_{rc['label']}_%03d.ts"
+                        r = subprocess.run(
+                            ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + [
+                                '-i',src,'-map','0:v:0','-an','-c:v','libx264',
+                                '-preset','ultrafast','-crf','23','-vf',rc['scale'],
+                                '-b:v',rc['br'],'-maxrate',rc['br'],'-bufsize',rc['bufsize'],
+                                '-pix_fmt','yuv420p'] + render_args() + [
+                                '-hls_time','5','-hls_list_size','0',
+                                '-hls_segment_filename',str(sf),
+                                '-hls_flags','independent_segments+append_list+temp_file',
+                                '-hls_playlist_type','vod','-hls_segment_type','mpegts',
+                                str(vf),'-y','-loglevel','error'],
+                            capture_output=True, text=True, timeout=14400)
+                        if r.returncode != 0:
+                            shutil.rmtree(tmp_r, ignore_errors=True)
+                            log_cb(f"  ⚠ Error {rc['label']}")
+                            continue
+                        shutil.move(str(vf), str(out_dir / f"video_{rc['label']}.m3u8"))
+                        for ts in tmp_r.glob(f"video_{rc['label']}_*.ts"):
+                            shutil.move(str(ts), str(out_dir / ts.name))
+                        shutil.rmtree(tmp_r, ignore_errors=True)
+                        video_streams.append({'file':f"video_{rc['label']}.m3u8",
+                                              'resolution':rc['res'],
+                                              'bandwidth':int(rc['br'].replace('k','000'))+192000,
+                                              'codecs':'avc1.640028'})
+                        log_cb(f"  ✓ {rc['label']} OK")
+
+                if not video_streams: raise Exception("Sin video generado")
+                make_master_m3u8(out_dir, video_streams, audio_playlists)
+                manifest_file = "master.m3u8"
+
+            elif stream_fmt == "DASH (MPD)":
+                log_cb("  🎬 Generando DASH…")
+                tmp_d = RAMDISK / f"dash_{idx}"
+                tmp_d.mkdir(exist_ok=True)
+                cmd = ['ffmpeg','-hide_banner','-threads',str(N_THREADS)] + iargs + ['-i',src]
+                vc = "copy" if "Copy" in conv_opt else "libx264"
+                cmd += ['-map','0:v:0','-c:v:0',vc]
+                if vc != "copy": cmd += ['-preset','ultrafast','-crf','23']
+                for i2, t2 in enumerate(audio_tracks):
+                    cmd += ['-map',f"0:{t2['index']}",f'-c:a:{i2}','aac',f'-b:a:{i2}','192k',
+                            f'-ar:a:{i2}','48000',f'-ac:a:{i2}','2']
+                mpd_out = tmp_d / "manifest.mpd"
+                cmd += (render_args() if vc != "copy" else
+                        ['-max_muxing_queue_size','9999','-copytb','1','-start_at_zero','-thread_queue_size','4096'])
+                cmd += ['-f','dash','-seg_duration','5','-use_template','1','-use_timeline','0',
+                        '-init_seg_name','init-$RepresentationID$.m4s',
+                        '-media_seg_name','chunk-$RepresentationID$-$Number%05d$.m4s',
+                        str(mpd_out),'-y','-loglevel','error']
+                r = subprocess.run(cmd, capture_output=True, text=True, timeout=14400)
+                if r.returncode != 0:
+                    shutil.rmtree(tmp_d, ignore_errors=True)
+                    raise Exception(f"DASH falló: {r.stderr[-400:]}")
+                shutil.move(str(mpd_out), str(out_dir / "manifest.mpd"))
+                for m4s in tmp_d.glob("*.m4s"): shutil.move(str(m4s), str(out_dir / m4s.name))
+                shutil.rmtree(tmp_d, ignore_errors=True)
+                manifest_file = "manifest.mpd"
+                log_cb("  ✓ DASH OK")
+
+            # ── GITHUB ──
+            log_cb(f"  ☁ Subiendo a GitHub: {repo_name}")
+            if not requests:
+                raise Exception("requests no instalado — pip install requests")
+            headers = {"Authorization": f"token {token}"}
+            rr = requests.post("https://api.github.com/user/repos", headers=headers,
+                               json={"name": repo_name, "private": True}, timeout=30)
+            if rr.status_code == 422:
+                u = requests.get("https://api.github.com/user", headers=headers, timeout=30)
+                html_url = f"https://github.com/{u.json()['login']}/{repo_name}"
+            elif rr.status_code in [200, 201]:
+                html_url = rr.json()['html_url']
+            else:
+                raise Exception(f"GitHub API {rr.status_code}: {rr.text[:200]}")
+
+            git_url = html_url.replace('https://', f'https://{token}@') + '.git'
+            gd = str(out_dir)
+
+            for gc in [['git','init'],['git','checkout','-b','main'],
+                       ['git','remote','add','origin',git_url],
+                       ['git','config','http.postBuffer','524288000'],
+                       ['git','config','core.compression','0']]:
+                subprocess.run(gc, cwd=gd, check=True, capture_output=True)
+
+            all_files = os.listdir(gd)
+            ext_s = '.m4s' if stream_fmt == "DASH (MPD)" else '.ts'
+            ext_m = '.mpd' if stream_fmt == "DASH (MPD)" else '.m3u8'
+            segs = [f for f in all_files if f.endswith(ext_s)]
+            mans = [f for f in all_files if f.endswith(ext_m)]
+
+            subprocess.run(['git','add'] + mans, cwd=gd, check=True, capture_output=True)
+            subprocess.run(['git','commit','-m',f'init {folder_name}'], cwd=gd, check=True, capture_output=True)
+            git_push_retry(gd, ['-u','origin','main'])
+
+            log_cb(f"  📦 {len(segs)} segmentos → batch {batch_size}")
+            for i3 in range(0, len(segs), batch_size):
+                batch = segs[i3:i3+batch_size]
+                subprocess.run(['git','add']+batch, cwd=gd, check=True, capture_output=True)
+                subprocess.run(['git','commit','-m',f'segs {i3}-{i3+len(batch)}'],
+                               cwd=gd, check=True, capture_output=True)
+                ok = git_push_retry(gd, ['origin','main'])
+                if ok: log_cb(f"  📤 {min(i3+batch_size,len(segs))}/{len(segs)}")
+                else:  log_cb(f"  ⚠ Batch {i3} error")
+
+            gp = f"https://gooplay.xyz/gp/stream.php?repo={repo_name}&branch=main&file={manifest_file}"
+            gh = f"{html_url}/blob/main/{manifest_file}"
+            final_links.append(f"{folder_name}\nGooplay: {gp}\nGitHub:  {gh}")
+            log_cb(f"  ✓ Completado: {folder_name}")
+
+            if delete_local:
+                shutil.rmtree(out_dir, ignore_errors=True)
+                log_cb("  ✓ Archivos locales borrados")
+            else:
+                log_cb(f"  ℹ Archivos en: {out_dir}")
+
+        result = "\n\n".join(final_links)
+        log_cb("\n🎉 TODOS COMPLETADOS\n" + "="*40 + "\n" + result)
+        done_cb(True, result)
+
+    except Exception as e:
+        import traceback
+        log_cb(f"\n✗ ERROR: {e}\n{traceback.format_exc()}")
+        done_cb(False, str(e))
+
+
+# ════════════════════════════════════════════════════════════
+#  GUI
+# ════════════════════════════════════════════════════════════
+class AppHLS(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("HLS/DASH Converter EXTREME")
+        self.geometry("1100x750")
+        self.minsize(900, 620)
+        self.configure(bg=BG)
+        self.resizable(True, True)
+        self._build()
+        self._center()
+
+    def _center(self):
+        self.update_idletasks()
+        w, h = self.winfo_width(), self.winfo_height()
+        sw, sh = self.winfo_screenwidth(), self.winfo_screenheight()
+        self.geometry(f"{w}x{h}+{(sw-w)//2}+{(sh-h)//2}")
+
+    def _style(self):
+        s = ttk.Style(self)
+        s.theme_use("clam")
+        s.configure(".", background=BG, foreground=FG, font=FM,
+                     fieldbackground=BG2, borderwidth=0)
+        s.configure("TFrame", background=BG)
+        s.configure("TLabel", background=BG, foreground=FG)
+        s.configure("TEntry", fieldbackground=BG2, foreground=FG,
+                     insertcolor=FG, borderwidth=1)
+        s.configure("TCombobox", fieldbackground=BG2, background=BG3,
+                     foreground=FG, arrowcolor=FG2)
+        s.map("TCombobox", fieldbackground=[("readonly", BG2)],
+              foreground=[("readonly", FG)])
+        s.configure("TCheckbutton", background=BG, foreground=FG2)
+        s.map("TCheckbutton", background=[("active", BG)])
+        s.configure("TRadiobutton", background=BG, foreground=FG2)
+        s.map("TRadiobutton", background=[("active", BG)])
+        s.configure("Horizontal.TProgressbar",
+                     troughcolor=BG3, background=ACCENT,
+                     borderwidth=0, thickness=6)
+
+    def _build(self):
+        self._style()
+
+        # HEADER
+        hdr = tk.Frame(self, bg=BG, pady=8)
+        hdr.pack(fill="x", padx=20)
+        tk.Label(hdr, text="HLS/DASH CONVERTER EXTREME", bg=BG, fg=ACCENT,
+                 font=("Consolas", 15, "bold")).pack(side="left")
+        tk.Label(hdr, text=f"  ·  {N_THREADS} threads  ·  {RAMDISK}",
+                 bg=BG, fg=FG3, font=FS).pack(side="left")
+        self._lbl_status = tk.Label(hdr, text="● Listo", bg=BG, fg=GREEN, font=FS)
+        self._lbl_status.pack(side="right")
+
+        tk.Frame(self, bg=BORDER, height=1).pack(fill="x", padx=20)
+
+        body = tk.Frame(self, bg=BG)
+        body.pack(fill="both", expand=True, padx=20, pady=8)
+
+        # ─ LEFT ─
+        left = tk.Frame(body, bg=BG, width=340)
+        left.pack(side="left", fill="y", padx=(0, 10))
+        left.pack_propagate(False)
+
+        self._section(left, "GITHUB TOKEN")
+        self._gh_token = self._entry_var(left, "ghp_…", show="*")
+
+        self._section(left, "FUENTES")
+        # Files
+        f_files = tk.Frame(left, bg=BG)
+        f_files.pack(fill="x", pady=(0, 4))
+        self._file_lbl = tk.Label(f_files, text="Sin archivos", bg=BG3, fg=FG3,
+                                   font=FS, anchor="w", padx=6, pady=3)
+        self._file_lbl.pack(side="left", fill="x", expand=True)
+        tk.Button(f_files, text="📁 Archivos", bg=BG3, fg=FG2, bd=0,
+                  font=FS, cursor="hand2", command=self._browse_files,
+                  padx=6, pady=3).pack(side="right")
+        self._files_list = []
+
+        # URLs
+        tk.Label(left, text="URLs (una por línea):", bg=BG, fg=FG2, font=FS).pack(anchor="w")
+        self._urls_txt = tk.Text(left, bg=BG2, fg=FG, insertbackground=FG,
+                                  font=FS, bd=0, relief="flat", height=5, wrap="none")
+        self._urls_txt.pack(fill="x", pady=(0, 6))
+
+        self._section(left, "CONVERSIÓN")
+        self._conv_opt = ttk.Combobox(left, state="readonly", font=FS, height=6,
+                                      values=["Opción 1: Copy Video",
+                                              "Opción 2: Copy Video MP3",
+                                              "Opción 3: 1080p+720p H.264",
+                                              "Opción 4: 4K+1080p+720p H.264"])
+        self._conv_opt.set("Opción 1: Copy Video")
+        self._conv_opt.pack(fill="x", pady=(0, 4))
+
+        self._stream_fmt = ttk.Combobox(left, state="readonly", font=FS,
+                                         values=["HLS (M3U8)", "DASH (MPD)"])
+        self._stream_fmt.set("HLS (M3U8)")
+        self._stream_fmt.pack(fill="x", pady=(0, 6))
+
+        f_nums = tk.Frame(left, bg=BG)
+        f_nums.pack(fill="x", pady=(0, 4))
+        tk.Label(f_nums, text="Batch git:", bg=BG, fg=FG2, font=FS).pack(side="left")
+        self._batch_var = tk.StringVar(value="30")
+        tk.Entry(f_nums, textvariable=self._batch_var, bg=BG2, fg=FG,
+                 insertbackground=FG, font=FS, bd=0, width=5,
+                 relief="flat").pack(side="left", padx=4)
+        tk.Label(f_nums, text="Workers:", bg=BG, fg=FG2, font=FS).pack(side="left")
+        self._workers_var = tk.StringVar(value="4")
+        tk.Entry(f_nums, textvariable=self._workers_var, bg=BG2, fg=FG,
+                 insertbackground=FG, font=FS, bd=0, width=4,
+                 relief="flat").pack(side="left", padx=4)
+
+        self._del_local = tk.BooleanVar(value=True)
+        ttk.Checkbutton(left, text="Borrar archivos locales al terminar",
+                        variable=self._del_local).pack(anchor="w")
+
+        self._section(left, "CONTENIDO")
+        self._ctype = tk.StringVar(value="Serie")
+        f_ct = tk.Frame(left, bg=BG)
+        f_ct.pack(fill="x")
+        for ct in ["Película", "Serie"]:
+            ttk.Radiobutton(f_ct, text=ct, variable=self._ctype,
+                            value=ct, command=self._toggle_ctype).pack(side="left", padx=4)
+
+        self._movie_frame = tk.Frame(left, bg=BG)
+        tk.Label(self._movie_frame, text="Nombre:", bg=BG, fg=FG2, font=FS).pack(anchor="w")
+        self._mname = self._entry_var(self._movie_frame, "El Padrino")
+
+        self._serie_frame = tk.Frame(left, bg=BG)
+        tk.Label(self._serie_frame, text="Serie:", bg=BG, fg=FG2, font=FS).pack(anchor="w")
+        self._sname = self._entry_var(self._serie_frame, "Breaking Bad")
+        f_ss = tk.Frame(self._serie_frame, bg=BG)
+        f_ss.pack(fill="x")
+        tk.Label(f_ss, text="Temp:", bg=BG, fg=FG2, font=FS).pack(side="left")
+        self._season = tk.StringVar(value="1")
+        tk.Entry(f_ss, textvariable=self._season, bg=BG2, fg=FG,
+                 insertbackground=FG, font=FS, bd=0, width=4,
+                 relief="flat").pack(side="left", padx=4)
+        tk.Label(f_ss, text="Ep inicial:", bg=BG, fg=FG2, font=FS).pack(side="left")
+        self._ep_start = tk.StringVar(value="1")
+        tk.Entry(f_ss, textvariable=self._ep_start, bg=BG2, fg=FG,
+                 insertbackground=FG, font=FS, bd=0, width=4,
+                 relief="flat").pack(side="left", padx=4)
+        self._serie_frame.pack(fill="x", pady=(4, 0))
+
+        # ─ RIGHT ─
+        right = tk.Frame(body, bg=BG)
+        right.pack(side="right", fill="both", expand=True)
+
+        # Progress
+        self._lbl_prog = tk.Label(right, text="", bg=BG, fg=FG2, font=FS, anchor="w")
+        self._lbl_prog.pack(fill="x")
+        self._pbar = ttk.Progressbar(right, mode="determinate",
+                                      style="Horizontal.TProgressbar")
+        self._pbar.pack(fill="x", pady=(2, 6))
+
+        # Log
+        tk.Label(right, text="LOG DE PROCESAMIENTO", bg=BG, fg=FG3,
+                 font=("Consolas", 8, "bold")).pack(anchor="w")
+        log_f = tk.Frame(right, bg=BORDER)
+        log_f.pack(fill="both", expand=True, pady=(2, 6))
+        self._log_txt = tk.Text(
+            log_f, bg="#030810", fg=CYAN, font=("Consolas", 9),
+            bd=0, relief="flat", state="disabled", wrap="word",
+            insertbackground=FG, selectbackground=ACCENT2
+        )
+        sb = ttk.Scrollbar(log_f, command=self._log_txt.yview)
+        self._log_txt.configure(yscrollcommand=sb.set)
+        sb.pack(side="right", fill="y")
+        self._log_txt.pack(fill="both", expand=True, padx=1, pady=1)
+
+        # Links output
+        tk.Label(right, text="LINKS GENERADOS", bg=BG, fg=FG3,
+                 font=("Consolas", 8, "bold")).pack(anchor="w")
+        lnk_f = tk.Frame(right, bg=BORDER)
+        lnk_f.pack(fill="x", pady=(2, 6))
+        self._links_txt = tk.Text(
+            lnk_f, bg="#020c08", fg=GREEN, font=("Consolas", 9),
+            bd=0, relief="flat", state="disabled", height=6,
+            insertbackground=FG
+        )
+        lsb = ttk.Scrollbar(lnk_f, command=self._links_txt.yview)
+        self._links_txt.configure(yscrollcommand=lsb.set)
+        lsb.pack(side="right", fill="y")
+        self._links_txt.pack(fill="x", padx=1, pady=1)
+
+        # Buttons
+        bf = tk.Frame(right, bg=BG)
+        bf.pack(fill="x")
+        self._btn_start = tk.Button(
+            bf, text="🚀  INICIAR CONVERSIÓN",
+            bg=ACCENT, fg="white", bd=0, padx=16, pady=10,
+            font=("Consolas", 12, "bold"), cursor="hand2",
+            command=self._do_start
+        )
+        self._btn_start.pack(side="left", fill="x", expand=True)
+        tk.Button(
+            bf, text="✕", bg=BG3, fg=RED, bd=0,
+            padx=14, pady=10, font=FB, cursor="hand2",
+            command=self._do_cancel
+        ).pack(side="right", padx=(6, 0))
+
+        self._cancelled = False
+
+    # ── HELPERS ──────────────────────────────────────────
+    def _section(self, parent, text):
+        f = tk.Frame(parent, bg=BG)
+        f.pack(fill="x", pady=(10, 2))
+        tk.Label(f, text=text, bg=BG, fg=FG3,
+                 font=("Consolas", 8, "bold")).pack(side="left")
+        tk.Frame(f, bg=BORDER, height=1).pack(side="right", fill="x",
+                                               expand=True, padx=(6, 0), pady=4)
+
+    def _entry_var(self, parent, placeholder, show=None):
+        v = tk.StringVar()
+        kw = {"show": show} if show else {}
+        tk.Entry(parent, textvariable=v, bg=BG2, fg=FG2,
+                 insertbackground=FG, font=FS, bd=0, relief="flat",
+                 **kw).pack(fill="x", ipady=5, pady=(0, 4))
+        return v
+
+    def _toggle_ctype(self):
+        if self._ctype.get() == "Película":
+            self._serie_frame.pack_forget()
+            self._movie_frame.pack(fill="x", pady=(4, 0))
+        else:
+            self._movie_frame.pack_forget()
+            self._serie_frame.pack(fill="x", pady=(4, 0))
+
+    def _browse_files(self):
+        files = filedialog.askopenfilenames(
+            filetypes=[("Video", "*.mp4 *.mkv *.avi *.mov *.ts *.m2ts *.webm"),
+                       ("Todos", "*.*")]
+        )
+        if files:
+            self._files_list = list(files)
+            names = ", ".join(Path(f).name for f in files)
+            self._file_lbl.configure(
+                text=names[:60] + ("…" if len(names) > 60 else ""), fg=FG2
+            )
+
+    def _log(self, msg):
+        self._log_txt.configure(state="normal")
+        self._log_txt.insert("end", msg + "\n")
+        self._log_txt.see("end")
+        self._log_txt.configure(state="disabled")
+
+    def _set_progress(self, pct, label=""):
+        self._pbar["value"] = pct
+        self._lbl_prog.configure(text=label)
+        self.update_idletasks()
+
+    def _set_links(self, text):
+        self._links_txt.configure(state="normal")
+        self._links_txt.delete("1.0", "end")
+        self._links_txt.insert("1.0", text)
+        self._links_txt.configure(state="disabled")
+
+    # ── START ──────────────────────���─────────────────────
+    def _do_start(self):
+        token = self._gh_token.get().strip()
+        if not token:
+            messagebox.showwarning("Token", "Ingresá tu token de GitHub")
+            return
+
+        sources = []
+        for f in self._files_list:
+            sources.append({"type": "file", "value": f})
+        for line in self._urls_txt.get("1.0", "end").strip().split("\n"):
+            u = line.strip()
+            if u: sources.append({"type": "url", "value": u})
+
+        if not sources:
+            messagebox.showwarning("Fuente", "Agregá archivos o URLs")
+            return
+
+        self._btn_start.configure(state="disabled", bg=FG3)
+        self._lbl_status.configure(text="● Procesando…", fg=YELLOW)
+        self._log_txt.configure(state="normal")
+        self._log_txt.delete("1.0", "end")
+        self._log_txt.configure(state="disabled")
+        self._pbar["value"] = 0
+        self._cancelled = False
+
+        try:
+            batch_size  = int(self._batch_var.get() or 30)
+            max_workers = int(self._workers_var.get() or 4)
+            season      = int(self._season.get() or 1)
+            ep_start    = int(self._ep_start.get() or 1)
+        except:
+            batch_size, max_workers, season, ep_start = 30, 4, 1, 1
+
+        job = {
+            'token': token, 'sources': sources,
+            'conv_opt': self._conv_opt.get(),
+            'stream_fmt': self._stream_fmt.get(),
+            'batch_size': batch_size,
+            'delete_local': self._del_local.get(),
+            'max_workers': max_workers,
+            'ctype': self._ctype.get(),
+            'mname': self._mname.get().strip(),
+            'sname': self._sname.get().strip(),
+            'season': season, 'ep_start': ep_start,
+        }
+
+        def _done(ok, result):
+            self.after(0, self._btn_start.configure, {"state": "normal", "bg": ACCENT})
+            if ok:
+                self.after(0, self._lbl_status.configure, {"text": "● Completado", "fg": GREEN})
+                self.after(0, self._set_links, result)
+                self.after(0, self._set_progress, 100, "Completado")
+            else:
+                self.after(0, self._lbl_status.configure, {"text": "● Error", "fg": RED})
+
+        threading.Thread(
+            target=run_conversion,
+            args=(job,
+                  lambda m: self.after(0, self._log, m),
+                  lambda p, l: self.after(0, self._set_progress, p, l),
+                  _done),
+            daemon=True
+        ).start()
+
+    def _do_cancel(self):
+        self._cancelled = True
+        self._lbl_status.configure(text="● Cancelado", fg=RED)
+        self._log("⛔ Cancelado por usuario")
+        self._btn_start.configure(state="normal", bg=ACCENT)
+
+
+if __name__ == "__main__":
+    app = AppHLS()
+    app.mainloop()

video_converter_pro.py

@@ -0,0 +1,597 @@
+"""
+Video Converter Pro — App nativa Windows
+Convierte video y sube a HuggingFace. Sin Gradio.
+Auto-elevación a administrador.
+"""
+import sys
+import os
+import ctypes
+import subprocess
+import threading
+import tempfile
+import shutil
+import re
+import json
+import uuid
+import tkinter as tk
+from tkinter import ttk, filedialog, messagebox
+from pathlib import Path
+
+# ─── AUTO-ELEVACIÓN ADMINISTRADOR ───────────────────────────
+def is_admin():
+    try:
+        return ctypes.windll.shell32.IsUserAnAdmin()
+    except:
+        return False
+
+def elevate():
+    if not is_admin():
+        ctypes.windll.shell32.ShellExecuteW(
+            None, "runas", sys.executable, " ".join(sys.argv), None, 1
+        )
+        sys.exit()
+
+elevate()
+
+# ─── HF IMPORT ──────────────────────────────────────────────
+try:
+    from huggingface_hub import HfApi, list_models
+    HF_OK = True
+except ImportError:
+    HF_OK = False
+
+# ─── COLORES / TEMA ─────────────────────────────────────────
+BG       = "#0b0f1a"
+BG2      = "#111827"
+BG3      = "#1a2235"
+ACCENT   = "#3b82f6"
+ACCENT2  = "#6366f1"
+GREEN    = "#22c55e"
+RED      = "#ef4444"
+YELLOW   = "#f59e0b"
+FG       = "#e2e8f0"
+FG2      = "#94a3b8"
+FG3      = "#475569"
+BORDER   = "#1e2d42"
+FONT_MAIN = ("Consolas", 10)
+FONT_BIG  = ("Consolas", 12, "bold")
+FONT_SM   = ("Consolas", 9)
+
+# ─── UTILS ──────────────────────────────────────────────────
+def safe_name(s, maxlen=120):
+    return re.sub(r'[<>:"/\\|?*\x00-\x1f]', '_', s).strip()[:maxlen]
+
+def fmt_dur(secs):
+    s = int(secs)
+    return f"{s//3600:02d}:{(s%3600)//60:02d}:{s%60:02d}"
+
+# ─── FFPROBE ────────────────────────────────────────────────
+def probe(source):
+    info = {"audio": [], "subs": [], "duration": 0.0, "title": ""}
+    try:
+        r = subprocess.run(
+            ["ffprobe", "-v", "quiet", "-print_format", "json",
+             "-show_format", "-show_streams", source],
+            capture_output=True, text=True, timeout=90
+        )
+        if r.returncode != 0:
+            return info
+        data = json.loads(r.stdout)
+        tags = data.get("format", {}).get("tags", {})
+        info["title"] = (tags.get("title") or tags.get("TITLE") or "").strip()
+        info["duration"] = float(data.get("format", {}).get("duration", 0) or 0)
+        ai = si = 0
+        for s in data.get("streams", []):
+            t = s.get("tags", {})
+            ct = s.get("codec_type", "")
+            if ct == "audio":
+                info["audio"].append({
+                    "idx": ai, "codec": s.get("codec_name", "?"),
+                    "lang": t.get("language", "und"), "ch": s.get("channels", 2),
+                    "title": t.get("title", ""),
+                })
+                ai += 1
+            elif ct == "subtitle":
+                info["subs"].append({
+                    "idx": si, "codec": s.get("codec_name", "?"),
+                    "lang": t.get("language", "und"), "title": t.get("title", ""),
+                    "forced": s.get("disposition", {}).get("forced", 0) == 1,
+                })
+                si += 1
+    except Exception as e:
+        pass
+    return info
+
+# ─── FFMPEG ─────────────────────────────────────────────────
+NET_ARGS = [
+    "-user_agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+    "-headers", "Referer: https://google.com\r\n",
+    "-timeout", "180000000",
+    "-reconnect", "1", "-reconnect_streamed", "1",
+    "-reconnect_at_eof", "1", "-reconnect_delay_max", "30",
+    "-rw_timeout", "180000000", "-multiple_requests", "1",
+]
+
+def run_ffmpeg(cmd, total, log_cb, progress_cb, label):
+    try:
+        proc = subprocess.Popen(
+            cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
+            universal_newlines=True, bufsize=1
+        )
+        pat = re.compile(r"time=(\d+):(\d+):(\d+)\.(\d+)")
+        for line in proc.stderr:
+            m = pat.search(line)
+            if m:
+                h, mi, s, cs = map(int, m.groups())
+                cur = h*3600 + mi*60 + s + cs/100
+                pct = min(99, int(cur / max(total, 1) * 100))
+                progress_cb(pct, f"{label}: {pct}%  [{fmt_dur(cur)} / {fmt_dur(total)}]")
+        proc.wait()
+        return proc.returncode == 0
+    except Exception as e:
+        log_cb(f"  ✗ ffmpeg: {e}")
+        return False
+
+# ─── HF UPLOAD ────────────────────────────────────────────��─
+def hf_upload(token, repo_id, folder_path, log_cb, progress_cb):
+    if not HF_OK:
+        log_cb("  ✗ huggingface_hub no instalado")
+        return False
+    try:
+        api = HfApi(token=token)
+        try:
+            api.create_repo(repo_id=repo_id, repo_type="model", private=True, exist_ok=True)
+        except:
+            pass
+        files = list(Path(folder_path).iterdir())
+        for i, f in enumerate(files):
+            if f.is_file():
+                rpath = f"videos/{Path(folder_path).name}/{f.name}"
+                log_cb(f"  ↑ {f.name}")
+                progress_cb(int(i/len(files)*100), f"Subiendo {i+1}/{len(files)}")
+                api.upload_file(
+                    path_or_fileobj=str(f),
+                    path_in_repo=rpath,
+                    repo_id=repo_id,
+                    repo_type="model",
+                )
+        progress_cb(100, "Subida completa")
+        log_cb(f"  ✓ Subido → {repo_id}/videos/{Path(folder_path).name}/")
+        return True
+    except Exception as e:
+        log_cb(f"  ✗ upload error: {e}")
+        return False
+
+# ─── PROCESO PRINCIPAL ──────────────────────────────────────
+def process_video(token, repo_id, source, is_url, mode,
+                  audio_idx, gen_single, extract_sub, sub_idx,
+                  delete_local, log_cb, progress_cb, done_cb):
+    try:
+        extra = NET_ARGS if is_url else []
+        log_cb("⟳ Analizando fuente…")
+        info = probe(source)
+        dur = info["duration"] if info["duration"] > 0 else 1
+        log_cb(f"  ✓ {fmt_dur(dur)} | {len(info['audio'])} audio | {len(info['subs'])} sub")
+
+        base = info["title"] if info["title"] else Path(source).stem or "video"
+        fname = safe_name(base)
+
+        tmp = tempfile.mkdtemp(prefix="vcpro_")
+        out_mp4 = os.path.join(tmp, f"{fname}.mp4")
+
+        cmd = ["ffmpeg", "-y"] + extra + ["-i", source, "-map", "0:v:0"]
+        for i in range(len(info["audio"])):
+            cmd.extend(["-map", f"0:a:{i}"])
+
+        if mode == "Copy + MP3":
+            cmd += ["-c:v", "copy"]
+            for i in range(len(info["audio"])):
+                cmd += [f"-c:a:{i}", "libmp3lame", f"-b:a:{i}", "320k", f"-ar:a:{i}", "48000"]
+        elif mode == "Copy + FLAC":
+            cmd += ["-c:v", "copy"]
+            for i in range(len(info["audio"])):
+                cmd += [f"-c:a:{i}", "flac", f"-compression_level:a:{i}", "0"]
+        else:
+            cmd += ["-c:v", "libx264", "-vf", "scale=-2:1080", "-preset", "slow", "-crf", "18"]
+            for i in range(len(info["audio"])):
+                cmd += [f"-c:a:{i}", "libmp3lame", f"-b:a:{i}", "320k", f"-ar:a:{i}", "48000"]
+
+        cmd += ["-map_metadata", "0", out_mp4]
+
+        log_cb(f"⚙ Convirtiendo ({mode})…")
+        ok = run_ffmpeg(cmd, dur, log_cb, progress_cb, "Convirtiendo")
+        if not ok:
+            log_cb("✗ Conversión falló")
+            if delete_local:
+                shutil.rmtree(tmp, ignore_errors=True)
+            done_cb(False)
+            return
+
+        progress_cb(100, "Conversión OK")
+        log_cb("  ✓ Conversión OK")
+
+        if gen_single and info["audio"] and audio_idx < len(info["audio"]):
+            sp = os.path.join(tmp, f"{fname}_aud{audio_idx}.mp4")
+            sc = ["ffmpeg", "-y", "-i", out_mp4,
+                  "-map", "0:v:0", "-map", f"0:a:{audio_idx}", "-c", "copy", sp]
+            run_ffmpeg(sc, dur, log_cb, progress_cb, "Audio individual")
+            log_cb("  ✓ Audio individual extraído")
+
+        if extract_sub and info["subs"] and sub_idx < len(info["subs"]):
+            vtt = os.path.join(tmp, f"{fname}_sub{sub_idx}.vtt")
+            sc = ["ffmpeg", "-y"] + extra + [
+                "-i", source, "-map", f"0:s:{sub_idx}", "-c:s", "webvtt", vtt]
+            try:
+                subprocess.run(sc, capture_output=True, check=True, timeout=120)
+                log_cb("  ✓ Subtítulo extraído")
+            except Exception as e:
+                log_cb(f"  ⚠ sub error: {e}")
+
+        log_cb(f"☁ Subiendo a HuggingFace → {repo_id}")
+        ok2 = hf_upload(token, repo_id, tmp, log_cb, progress_cb)
+
+        if delete_local:
+            shutil.rmtree(tmp, ignore_errors=True)
+            log_cb("  ✓ Archivos locales borrados")
+        else:
+            log_cb(f"  ℹ Archivos guardados en: {tmp}")
+
+        done_cb(ok2)
+
+    except Exception as e:
+        import traceback
+        log_cb(f"✗ Error: {e}\n{traceback.format_exc()}")
+        done_cb(False)
+
+
+# ════════════════════════════════════════════════════════════
+#  GUI
+# ════════════════════════════════════════════════════════════
+class App(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("Video Converter Pro")
+        self.geometry("960x700")
+        self.minsize(820, 600)
+        self.configure(bg=BG)
+        self.resizable(True, True)
+        self._repos = []
+        self._info  = None
+        self._build()
+        self._center()
+
+    def _center(self):
+        self.update_idletasks()
+        w, h = self.winfo_width(), self.winfo_height()
+        sw = self.winfo_screenwidth()
+        sh = self.winfo_screenheight()
+        self.geometry(f"{w}x{h}+{(sw-w)//2}+{(sh-h)//2}")
+
+    # ── ESTILOS ────────────────────────────────────────────
+    def _style(self):
+        s = ttk.Style(self)
+        s.theme_use("clam")
+        s.configure(".", background=BG, foreground=FG, font=FONT_MAIN,
+                     fieldbackground=BG2, borderwidth=0)
+        s.configure("TFrame", background=BG)
+        s.configure("TLabel", background=BG, foreground=FG, font=FONT_MAIN)
+        s.configure("Dim.TLabel", foreground=FG2, font=FONT_SM)
+        s.configure("H.TLabel", foreground=ACCENT, font=FONT_BIG)
+        s.configure("TEntry", fieldbackground=BG2, foreground=FG,
+                     insertcolor=FG, borderwidth=1, relief="flat")
+        s.configure("TCombobox", fieldbackground=BG2, background=BG3,
+                     foreground=FG, arrowcolor=FG2, borderwidth=1)
+        s.map("TCombobox", fieldbackground=[("readonly", BG2)],
+              foreground=[("readonly", FG)])
+        s.configure("TCheckbutton", background=BG, foreground=FG2,
+                     activebackground=BG, activeforeground=FG)
+        s.map("TCheckbutton", background=[("active", BG)])
+        s.configure("TRadiobutton", background=BG, foreground=FG2)
+        s.map("TRadiobutton", background=[("active", BG)])
+        s.configure("Horizontal.TProgressbar",
+                     troughcolor=BG3, background=ACCENT,
+                     darkcolor=ACCENT2, lightcolor=ACCENT,
+                     borderwidth=0, thickness=6)
+
+    # ── BUILD ──────────────────────────────────────────────
+    def _build(self):
+        self._style()
+
+        # ── HEADER ──
+        hdr = tk.Frame(self, bg=BG, pady=10)
+        hdr.pack(fill="x", padx=20)
+        tk.Label(hdr, text="VIDEO CONVERTER PRO", bg=BG, fg=ACCENT,
+                 font=("Consolas", 16, "bold")).pack(side="left")
+        tk.Label(hdr, text="  →  HuggingFace", bg=BG, fg=FG3,
+                 font=("Consolas", 10)).pack(side="left")
+        self._lbl_status = tk.Label(hdr, text="● Listo", bg=BG, fg=GREEN,
+                                    font=FONT_SM)
+        self._lbl_status.pack(side="right")
+
+        sep = tk.Frame(self, bg=BORDER, height=1)
+        sep.pack(fill="x", padx=20)
+
+        # ── BODY ──
+        body = tk.Frame(self, bg=BG)
+        body.pack(fill="both", expand=True, padx=20, pady=10)
+
+        # ─ LEFT PANEL ─
+        left = tk.Frame(body, bg=BG, width=320)
+        left.pack(side="left", fill="y", padx=(0, 10))
+        left.pack_propagate(False)
+
+        # HF Token
+        self._section(left, "HUGGING FACE")
+        self._hf_token = self._entry(left, "Token  (hf_…)", show="*")
+        f_repo = tk.Frame(left, bg=BG)
+        f_repo.pack(fill="x", pady=(2, 6))
+        self._repo_cb = ttk.Combobox(f_repo, state="readonly",
+                                      font=FONT_SM, height=8)
+        self._repo_cb.pack(side="left", fill="x", expand=True)
+        tk.Button(f_repo, text="↺", bg=BG3, fg=ACCENT, bd=0,
+                  font=FONT_SM, cursor="hand2",
+                  command=self._load_repos).pack(side="right", padx=(4, 0))
+
+        # Mode
+        self._section(left, "MODO DE CONVERSIÓN")
+        self._mode = tk.StringVar(value="Copy + MP3")
+        for m in ["Copy + MP3", "Copy + FLAC", "H264 1080p"]:
+            ttk.Radiobutton(left, text=m, variable=self._mode,
+                            value=m).pack(anchor="w")
+
+        # Opciones
+        self._section(left, "OPCIONES")
+        self._gen_single = tk.BooleanVar(value=False)
+        self._ext_sub    = tk.BooleanVar(value=False)
+        self._del_local  = tk.BooleanVar(value=True)
+        ttk.Checkbutton(left, text="Generar audio individual",
+                        variable=self._gen_single).pack(anchor="w")
+        ttk.Checkbutton(left, text="Extraer subtítulo (.vtt)",
+                        variable=self._ext_sub).pack(anchor="w")
+        ttk.Checkbutton(left, text="Borrar archivos locales al terminar",
+                        variable=self._del_local).pack(anchor="w")
+
+        # Pistas
+        self._section(left, "PISTAS")
+        tk.Label(left, text="Audio:", bg=BG, fg=FG2,
+                 font=FONT_SM).pack(anchor="w")
+        self._aud_cb = ttk.Combobox(left, state="readonly",
+                                    font=FONT_SM, height=6)
+        self._aud_cb.pack(fill="x", pady=(0, 4))
+        tk.Label(left, text="Subtítulo:", bg=BG, fg=FG2,
+                 font=FONT_SM).pack(anchor="w")
+        self._sub_cb = ttk.Combobox(left, state="readonly",
+                                    font=FONT_SM, height=6)
+        self._sub_cb.pack(fill="x")
+
+        # Botón analizar
+        tk.Button(left, text="⟳  ANALIZAR",
+                  bg=BG3, fg=ACCENT, bd=0, padx=12, pady=6,
+                  font=FONT_MAIN, cursor="hand2",
+                  command=self._do_analyze).pack(fill="x", pady=(10, 2))
+
+        # ─ RIGHT PANEL ─
+        right = tk.Frame(body, bg=BG)
+        right.pack(side="right", fill="both", expand=True)
+
+        # Source tabs
+        nb_frame = tk.Frame(right, bg=BG)
+        nb_frame.pack(fill="x", pady=(0, 6))
+        self._src_mode = tk.StringVar(value="file")
+        tk.Button(nb_frame, text="📁 Archivo", bg=ACCENT, fg="white",
+                  bd=0, padx=10, pady=4, font=FONT_SM, cursor="hand2",
+                  command=lambda: self._switch_src("file")).pack(side="left")
+        tk.Button(nb_frame, text="🔗 URL", bg=BG3, fg=FG2,
+                  bd=0, padx=10, pady=4, font=FONT_SM, cursor="hand2",
+                  command=lambda: self._switch_src("url")).pack(side="left", padx=4)
+
+        self._file_frame = tk.Frame(right, bg=BG)
+        self._file_frame.pack(fill="x", pady=(0, 4))
+        self._file_var = tk.StringVar()
+        e_file = tk.Entry(self._file_frame, textvariable=self._file_var,
+                          bg=BG2, fg=FG, insertbackground=FG,
+                          font=FONT_SM, bd=0, relief="flat")
+        e_file.pack(side="left", fill="x", expand=True, ipady=6, padx=(0, 4))
+        tk.Button(self._file_frame, text="Buscar…", bg=BG3, fg=FG2,
+                  bd=0, padx=8, pady=4, font=FONT_SM, cursor="hand2",
+                  command=self._browse).pack(side="right")
+
+        self._url_frame = tk.Frame(right, bg=BG)
+        self._url_var = tk.StringVar()
+        tk.Entry(self._url_frame, textvariable=self._url_var,
+                 bg=BG2, fg=FG, insertbackground=FG,
+                 font=FONT_SM, bd=0, relief="flat",
+                 ).pack(fill="x", ipady=6)
+
+        # Info strip
+        self._lbl_info = tk.Label(right, text="Sin fuente analizada",
+                                  bg=BG3, fg=FG2, font=FONT_SM,
+                                  anchor="w", padx=8, pady=4)
+        self._lbl_info.pack(fill="x", pady=(0, 8))
+
+        # Progress
+        self._lbl_prog = tk.Label(right, text="", bg=BG, fg=FG2, font=FONT_SM)
+        self._lbl_prog.pack(anchor="w")
+        self._pbar = ttk.Progressbar(right, mode="determinate",
+                                      style="Horizontal.TProgressbar")
+        self._pbar.pack(fill="x", pady=(2, 8))
+
+        # Log
+        tk.Label(right, text="LOG", bg=BG, fg=FG3,
+                 font=("Consolas", 8, "bold")).pack(anchor="w")
+        log_f = tk.Frame(right, bg=BORDER)
+        log_f.pack(fill="both", expand=True, pady=(2, 8))
+        self._log_txt = tk.Text(
+            log_f, bg="#050d18", fg="#22d3ee", font=("Consolas", 9),
+            bd=0, relief="flat", state="disabled", wrap="word",
+            insertbackground=FG, selectbackground=ACCENT2
+        )
+        sb = ttk.Scrollbar(log_f, command=self._log_txt.yview)
+        self._log_txt.configure(yscrollcommand=sb.set)
+        sb.pack(side="right", fill="y")
+        self._log_txt.pack(fill="both", expand=True, padx=1, pady=1)
+
+        # PROCESAR button
+        self._btn_proc = tk.Button(
+            right, text="⬆  PROCESAR Y SUBIR",
+            bg=ACCENT, fg="white", bd=0, padx=16, pady=10,
+            font=("Consolas", 12, "bold"), cursor="hand2",
+            command=self._do_process
+        )
+        self._btn_proc.pack(fill="x")
+
+    # ── HELPERS ───────────────────────────────────────────
+    def _section(self, parent, text):
+        f = tk.Frame(parent, bg=BG)
+        f.pack(fill="x", pady=(10, 2))
+        tk.Label(f, text=text, bg=BG, fg=FG3,
+                 font=("Consolas", 8, "bold")).pack(side="left")
+        tk.Frame(f, bg=BORDER, height=1).pack(side="right",
+                                               fill="x", expand=True,
+                                               padx=(6, 0), pady=4)
+
+    def _entry(self, parent, placeholder, show=None):
+        v = tk.StringVar()
+        kw = {"show": show} if show else {}
+        e = tk.Entry(parent, textvariable=v, bg=BG2, fg=FG2,
+                     insertbackground=FG, font=FONT_SM,
+                     bd=0, relief="flat", **kw)
+        e.pack(fill="x", ipady=6, pady=(0, 4))
+        return v
+
+    def _switch_src(self, mode):
+        if mode == "file":
+            self._file_frame.pack(fill="x", pady=(0, 4))
+            self._url_frame.pack_forget()
+        else:
+            self._url_frame.pack(fill="x", pady=(0, 4))
+            self._file_frame.pack_forget()
+        self._src_mode.set(mode)
+
+    def _browse(self):
+        p = filedialog.askopenfilename(
+            filetypes=[("Video", "*.mp4 *.mkv *.avi *.mov *.ts *.m2ts *.webm"),
+                       ("Todos", "*.*")]
+        )
+        if p:
+            self._file_var.set(p)
+
+    def _log(self, msg):
+        self._log_txt.configure(state="normal")
+        self._log_txt.insert("end", msg + "\n")
+        self._log_txt.see("end")
+        self._log_txt.configure(state="disabled")
+
+    def _set_progress(self, pct, label=""):
+        self._pbar["value"] = pct
+        self._lbl_prog.configure(text=label)
+        self.update_idletasks()
+
+    def _get_source(self):
+        if self._src_mode.get() == "file":
+            v = self._file_var.get().strip()
+            return v, False
+        else:
+            v = self._url_var.get().strip()
+            return v, True
+
+    # ── LOAD REPOS ────────────────────────────────────────
+    def _load_repos(self):
+        token = self._hf_token.get().strip()
+        if not token or not HF_OK:
+            messagebox.showwarning("Token", "Ingresá un token HF válido")
+            return
+        def _go():
+            try:
+                api = HfApi(token=token)
+                uname = api.whoami(token=token)["name"]
+                repos = [m.modelId for m in list(
+                    list_models(token=token, author=uname, limit=200)
+                )]
+                self._repos = repos
+                self._repo_cb["values"] = repos
+                if repos:
+                    self._repo_cb.set(repos[0])
+                self._log(f"✓ {len(repos)} repositorios cargados")
+            except Exception as e:
+                self._log(f"✗ Error cargando repos: {e}")
+        threading.Thread(target=_go, daemon=True).start()
+
+    # ── ANALIZAR ──────────────────────────────────────────
+    def _do_analyze(self):
+        source, _ = self._get_source()
+        if not source:
+            messagebox.showwarning("Fuente", "Seleccioná archivo o ingresá URL")
+            return
+        def _go():
+            self._log(f"⟳ Analizando…")
+            info = probe(source)
+            self._info = info
+            ac = [f"[{t['idx']}] {t['lang']} · {t['codec']} · {t['ch']}ch" for t in info["audio"]]
+            sc = [f"[{t['idx']}] {t['lang']} · {t['codec']}" + (" (Forzado)" if t["forced"] else "") for t in info["subs"]]
+            self._aud_cb["values"] = ac
+            self._sub_cb["values"] = sc
+            if ac: self._aud_cb.set(ac[0])
+            if sc: self._sub_cb.set(sc[0])
+            txt = f"✓  {info['title'] or '—'}  ·  {fmt_dur(info['duration'])}  ·  {len(ac)} aud  ·  {len(sc)} sub"
+            self._lbl_info.configure(text=txt, fg=GREEN)
+            self._log(txt)
+        threading.Thread(target=_go, daemon=True).start()
+
+    # ── PROCESAR ──────────────────────────────────────────
+    def _do_process(self):
+        token   = self._hf_token.get().strip()
+        repo_id = self._repo_cb.get().strip()
+        source, is_url = self._get_source()
+
+        if not token:
+            messagebox.showwarning("Token", "Ingresá tu token de HuggingFace")
+            return
+        if not repo_id:
+            messagebox.showwarning("Repo", "Seleccioná o cargá un repositorio")
+            return
+        if not source:
+            messagebox.showwarning("Fuente", "Seleccioná archivo o ingresá URL")
+            return
+
+        ai = 0
+        si = 0
+        if self._aud_cb.get():
+            try: ai = int(self._aud_cb.get().split("]")[0].strip("["))
+            except: ai = 0
+        if self._sub_cb.get():
+            try: si = int(self._sub_cb.get().split("]")[0].strip("["))
+            except: si = 0
+
+        self._btn_proc.configure(state="disabled", bg=FG3)
+        self._lbl_status.configure(text="● Procesando…", fg=YELLOW)
+        self._log_txt.configure(state="normal")
+        self._log_txt.delete("1.0", "end")
+        self._log_txt.configure(state="disabled")
+        self._pbar["value"] = 0
+
+        def _done(ok):
+            self._btn_proc.configure(state="normal", bg=ACCENT)
+            if ok:
+                self._lbl_status.configure(text="● Completado", fg=GREEN)
+                self._log("✓ COMPLETADO")
+                self._set_progress(100, "Completado")
+            else:
+                self._lbl_status.configure(text="● Error", fg=RED)
+                self._log("✗ FALLÓ")
+
+        threading.Thread(
+            target=process_video,
+            args=(token, repo_id, source, is_url, self._mode.get(),
+                  ai, self._gen_single.get(), self._ext_sub.get(), si,
+                  self._del_local.get(),
+                  lambda m: self.after(0, self._log, m),
+                  lambda p, l: self.after(0, self._set_progress, p, l),
+                  lambda ok: self.after(0, _done, ok)),
+            daemon=True
+        ).start()
+
+
+if __name__ == "__main__":
+    app = App()
+    app.mainloop()