Update app.py

app.py

@@ -1,112 +1,36 @@
-# =============================
-# app.py
-# FFmpeg Frames + Real-ESRGAN Upscale + Re-encode (3-step) + Quick Mode
-# - Step 1: Extract frames (with live estimate & progress)
-# - Step 2: Upscale frames (now supports uploading your own images directly)
-# - Step 3: Re-encode frames (now supports uploading your own frames/ZIP and optional audio source)
-# - Previews: 30 frames sampled evenly; scrollable galleries
-# - Prefix defaults to input video filename if left blank
-# =============================
-
-
 # ────────────────────────────────────────────────────────
 # Standard imports
 # ────────────────────────────────────────────────────────
-# ---- TorchVision shim so basicsr can import without torchvision installed ----
-import sys, types
-try:
-    # If torchvision is present, great — use it.
-    import torchvision.transforms.functional_tensor as _ft  # noqa: F401
-except Exception:
-    # Create a minimal module that provides rgb_to_grayscale with Torch ops.
-    import torch
-
-    _mod = types.ModuleType("torchvision.transforms.functional_tensor")
-
-    def rgb_to_grayscale(img: "torch.Tensor", num_output_channels: int = 1) -> "torch.Tensor":
-        """
-        Minimal replacement for torchvision's rgb_to_grayscale.
-        Expects a Tensor with channel-last-three: (..., 3, H, W) and returns
-        (..., 1, H, W) or (..., 3, H, W) if num_output_channels == 3.
-        """
-        if not torch.is_tensor(img):
-            raise TypeError("rgb_to_grayscale expects a torch.Tensor")
-        if img.ndim < 3 or img.shape[-3] != 3:
-            raise ValueError(f"expected tensor with C=3 as the third-from-last dim, got shape {tuple(img.shape)}")
-
-        r = img[..., -3, :, :]
-        g = img[..., -2, :, :]
-        b = img[..., -1, :, :]
-
-        gray = 0.2989 * r + 0.5870 * g + 0.1140 * b  # same weights as TV
-        if num_output_channels == 3:
-            out = torch.stack([gray, gray, gray], dim=-3)
-        else:
-            out = gray.unsqueeze(-3)
-        return out
-
-    _mod.rgb_to_grayscale = rgb_to_grayscale
-    sys.modules["torchvision.transforms.functional_tensor"] = _mod
-# ---------------------------------------------------------------------------
 
-import os
-import re
-import cv2
-import json
-import math
-import time
-import shutil
-import zipfile
-import tempfile
-import subprocess
-import inspect
+import os, re, json, math, time, zipfile, tempfile, subprocess, base64
 from pathlib import Path
-from typing import List, Optional, Tuple
-
+from typing import List, Optional
 import gradio as gr
 import numpy as np
-from PIL import Image
-
-from basicsr.archs.rrdbnet_arch import RRDBNet as _RRDBNet
-from basicsr.utils.download_util import load_file_from_url
-
-from realesrgan import RealESRGANer
-from realesrgan.archs.srvgg_arch import SRVGGNetCompact
 
 _num = re.compile(r'(\d+)')
 
-def _rgb_to_grayscale_np(arr: np.ndarray) -> np.ndarray:
-    # arr: HxWx3 uint8
-    r, g, b = arr[...,0], arr[...,1], arr[...,2]
-    gray = (0.2989*r + 0.5870*g + 0.1140*b).astype(arr.dtype)
-    return np.stack([gray, gray, gray], axis=-1)
-
 def _natural_key(p: Path | str):
     s = str(p)
     return [int(t) if t.isdigit() else t.lower() for t in _num.split(s)]
 
 def sample_paths(paths: List[Path] | List[str], n: int = 30) -> List[str]:
-    """Evenly sample up to n items across the entire list, in order."""
     if not paths:
         return []
-    # Ensure stable numeric ordering first (00001, 00002, ... 01000)
     paths = sorted(paths, key=_natural_key)
     total = len(paths)
     n = max(1, min(n, total))
     if n == total:
         return [str(p) for p in paths]
-    # Even spacing (no duplicates), covering start→end
     step = (total - 1) / (n - 1)
     idxs = [round(i * step) for i in range(n)]
-    # De-dupe in case of edge rounding on tiny sets
-    out = []
-    seen = set()
+    out, seen = [], set()
     for i in idxs:
         if i not in seen:
-            out.append(str(paths[i]))
-            seen.add(i)
+            out.append(str(paths[int(i)]))
+            seen.add(int(i))
     return out
-
+    
 import base64
 
 APP_DIR = os.getcwd()
@@ -129,69 +53,6 @@ def render_logo_html(px: int = 96) -> str:
     <hr>
     """
 
-# Flag so UI can know if realesrgan is importable
-HAVE_REALESRGAN = True
-
-def build_rrdb(scale: int, num_block: int):
-    # simple wrapper to the imported RRDBNet class
-    return _RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=num_block, num_grow_ch=32, scale=scale)
-
-def _weights_dir() -> str:
-    ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
-    wdir = os.path.join(ROOT_DIR, "weights")
-    os.makedirs(wdir, exist_ok=True)
-    return wdir
-
-def get_realesrganer(model_id: str, scale: int, tile: int, half: bool, device: str = "cpu") -> RealESRGANer:
-    """
-    model_id: one of {"x4plus", "x4plus-anime", "x2plus"}
-    Downloads weights if missing, builds the proper arch, and returns a RealESRGANer.
-    """
-    wdir = _weights_dir()
-
-    if model_id == "x4plus":
-        model = build_rrdb(scale=4, num_block=23)
-        netscale = 4
-        urls = ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth"]
-        model_path = os.path.join(wdir, "RealESRGAN_x4plus.pth")
-        dni_weight = None
-    elif model_id == "x4plus-anime":
-        model = build_rrdb(scale=4, num_block=6)
-        netscale = 4
-        urls = ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth"]
-        model_path = os.path.join(wdir, "RealESRGAN_x4plus_anime_6B.pth")
-        dni_weight = None
-    elif model_id == "x2plus":
-        model = build_rrdb(scale=2, num_block=23)
-        netscale = 2
-        urls = ["https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth"]
-        model_path = os.path.join(wdir, "RealESRGAN_x2plus.pth")
-        dni_weight = None
-    else:
-        raise ValueError(f"Unknown model_id: {model_id}")
-
-    # ensure weights on disk
-    for url in urls:
-        fname = os.path.basename(url)
-        local_path = os.path.join(wdir, fname)
-        if not os.path.isfile(local_path):
-            load_file_from_url(url=url, model_dir=wdir, progress=True)
-
-    # Use GPU if visible; otherwise CPU
-    gpu_id = 0 if (device == "cuda") else None
-
-    upsampler = RealESRGANer(
-        scale=netscale,
-        model_path=model_path,
-        dni_weight=dni_weight,
-        model=model,
-        tile=tile or 256,
-        tile_pad=10,
-        pre_pad=10,
-        half=bool(half and device == "cuda"),
-        gpu_id=gpu_id
-    )
-    return upsampler
 
 
 # ─────────────────────────────────────────────────────────────
@@ -220,25 +81,6 @@ else:
 # Helpers
 # ─────────────────────────────────────────────────────────────
 
-# Map UI model names (demo) to our internal model IDs
-def map_ui_model_to_internal(ui_name: str) -> str:
-    mapping = {
-        "RealESRGAN_x4plus": "x4plus",
-        "RealESRGAN_x4plus_anime_6B": "x4plus-anime",
-        "RealESRGAN_x2plus": "x2plus",
-        # Unsupported in our current RRDBNet wiring – fallback:
-        "RealESRNet_x4plus": "x4plus",
-        "realesr-general-x4v3": "x4plus",
-    }
-    return mapping.get(ui_name, "x4plus")
-
-def clamp_scale_for_model(outscale: int, model_id: str) -> int:
-    # Our current models are ×2 or ×4 only.
-    if model_id == "x2plus":
-        return 2
-    # For x4plus / x4plus-anime, force 4 (ignore 5–6)
-    return 4
-
 def sanitize_prefix(txt: str) -> str:
     txt = (txt or "").strip()
     if not txt:
@@ -369,131 +211,6 @@ def build_ffmpeg_extract(
     details = f"Frames extracted: {len(frames)} | Saved to: {raw_dir}"
     return gallery, str(zip_path), details, cmd_preview, render_progress(100.0, f"Extracted {len(frames)} frames"), [str(p) for p in frames], str(raw_dir), prefix
 
-
-def realesrgan(img, model_name, denoise_strength, face_enhance, outscale):
-    if img is None:
-        return
-
-    # ----- Select backbone + weights -----
-    if model_name == 'RealESRGAN_x4plus':
-        model = build_rrdb(scale=4, num_block=23); netscale = 4
-        file_url = ['https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth']
-
-    elif model_name == 'RealESRNet_x4plus':
-        model = build_rrdb(scale=4, num_block=23); netscale = 4
-        file_url = ['https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/RealESRNet_x4plus.pth']
-
-    elif model_name == 'RealESRGAN_x4plus_anime_6B':
-        model = build_rrdb(scale=4, num_block=6); netscale = 4
-        file_url = ['https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth']
-
-    elif model_name == 'RealESRGAN_x2plus':
-        model = build_rrdb(scale=2, num_block=23); netscale = 2
-        file_url = ['https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth']
-
-    elif model_name == 'realesr-general-x4v3':
-        model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=32, upscale=4, act_type='prelu'); netscale = 4
-        file_url = [
-            'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth',
-            'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-wdn-x4v3.pth'
-        ]
-    else:
-        raise ValueError(f"Unknown model: {model_name}")
-
-    # ----- Ensure weights on disk -----
-    ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
-    weights_dir = os.path.join(ROOT_DIR, 'weights')
-    os.makedirs(weights_dir, exist_ok=True)
-
-    for url in file_url:
-        fname = os.path.basename(url)
-        local_path = os.path.join(weights_dir, fname)
-        if not os.path.isfile(local_path):
-            load_file_from_url(url=url, model_dir=weights_dir, progress=True)
-
-    if model_name == 'realesr-general-x4v3':
-        base_path = os.path.join(weights_dir, 'realesr-general-x4v3.pth')
-        wdn_path  = os.path.join(weights_dir, 'realesr-general-wdn-x4v3.pth')
-        model_path = [base_path, wdn_path]
-        denoise_strength = float(denoise_strength)
-        dni_weight = [1.0 - denoise_strength, denoise_strength]  # base, WDN
-    else:
-        model_path = os.path.join(weights_dir, f"{model_name}.pth")
-        dni_weight = None
-
-    # ----- CUDA / precision / tiling -----
-    use_cuda = False
-    try:
-        use_cuda = hasattr(cv2, "cuda") and cv2.cuda.getCudaEnabledDeviceCount() > 0
-    except Exception:
-        use_cuda = False
-    gpu_id = 0 if use_cuda else None
-
-    upsampler = RealESRGANer(
-        scale=netscale,
-        model_path=model_path,
-        dni_weight=dni_weight,
-        model=model,
-        tile=256,       # VRAM-safe default; lower to 128 if OOM
-        tile_pad=10,
-        pre_pad=10,
-        half=bool(use_cuda),
-        gpu_id=gpu_id
-    )
-
-    # ----- Optional face enhancement -----
-    face_enhancer = None
-    if face_enhance:
-        from gfpgan import GFPGANer
-        face_enhancer = GFPGANer(
-            model_path='https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth',
-            upscale=outscale,
-            arch='clean',
-            channel_multiplier=2,
-            bg_upsampler=upsampler
-        )
-import random, string
-
-def rnd_string(n: int = 8) -> str:
-    return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(n))
-
-    # ----- PIL -> cv2 -----
-    cv_img = np.array(img)
-    if cv_img.ndim == 3 and cv_img.shape[2] == 4:
-        cv_img = cv2.cvtColor(cv_img, cv2.COLOR_RGBA2BGRA)
-    else:
-        cv_img = cv2.cvtColor(cv_img, cv2.COLOR_RGB2BGR)
-
-    # ----- Enhance -----
-    try:
-        if face_enhancer:
-            _, _, output = face_enhancer.enhance(cv_img, has_aligned=False, only_center_face=False, paste_back=True)
-        else:
-            output, _ = upsampler.enhance(cv_img, outscale=int(outscale))
-    except RuntimeError as error:
-        print('Error', error)
-        print('Tip: If you hit CUDA OOM, try a smaller tile size (e.g., 128).')
-        return None
-
-    # ----- cv2 -> display ndarray, also save -----
-    if output.ndim == 3 and output.shape[2] == 4:
-        display_img = cv2.cvtColor(output, cv2.COLOR_BGRA2RGBA)
-        extension = 'png'
-    else:
-        display_img = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
-        extension = 'jpg'
-
-    out_filename = f"output_{rnd_string(8)}.{extension}"
-    try:
-        cv2.imwrite(out_filename, output)
-        global last_file
-        last_file = out_filename
-    except Exception as e:
-        print("Save error:", e)
-
-    return display_img
-
-
 def render_progress(pct: float, label: str = "") -> str:
     pct = max(0.0, min(100.0, pct))
     return f'''<div style="width:100%;border:1px solid #ddd;border-radius:8px;overflow:hidden;height:18px;"><div style="height:100%;width:{pct:.1f}%;background:#3b82f6;"></div></div><div style="font-size:12px;opacity:.8;margin-top:4px;">{label} {pct:.1f}%</div>'''
@@ -627,726 +344,106 @@ def step1_extract(
     details = f"Frames extracted: {len(frames)} | Saved to: {raw_dir}"
     yield gallery, str(zip_path), details, cmd_preview, render_progress(100.0, f"Extracted {len(frames)} frames"), [str(p) for p in frames], str(raw_dir), prefix
 
-# ───────────────── Upscale (Step 2) — supports uploaded images OR frames from Step 1
-
-# Manual-batch Step 2 helpers (resumable, click-to-advance)
-def _ensure_dir(p: Path) -> Path:
-    p.mkdir(parents=True, exist_ok=True)
-    return p
-
-def _save_zip_of_dir(dir_path: Path, zip_path: Path) -> str:
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for p in sorted(dir_path.glob("*.*"), key=_natural_key):
-            if p.suffix.lower() in [".jpg", ".jpeg", ".png"]:
-                zf.write(p, p.name)
-    return str(zip_path)
-
-def _list_image_paths_from_upload(files: List[gr.File] | None) -> List[str]:
-    if not files: return []
-    return [str(Path(f.name)) for f in files if Path(f.name).suffix.lower() in [".jpg",".jpeg",".png"]]
-
-def _build_gallery_from_dir(dir_path: Path, n: int = 30) -> List[str]:
-    paths = sorted(list(dir_path.glob("*.jpg")) + list(dir_path.glob("*.png")), key=_natural_key)
-    return sample_paths(paths, n)
-
-def step2_prepare_sources(frames_list, uploaded_imgs, max_images):
-    src = _list_image_paths_from_upload(uploaded_imgs) or (frames_list or [])
-    if not src:
-        return [], "", 0, 0, "No images found. Upload files or run Step 1 first.", render_progress(0.0, "Idle")
-    try:
-        max_images = int(max_images or 0)
-    except Exception:
-        max_images = 0
-    if max_images > 0:
-        src = src[:max_images]
-    work = Path(tempfile.mkdtemp(prefix="up_manual_"))
-    out_dir = _ensure_dir(work / "upscaled")
-    total = len(src)
-    done_idx = 0
-    msg = f"Sources loaded: {total} image(s). Click 'Process Next Batch' to start."
-    prog = render_progress(0.0, "Ready")
-    return src, str(out_dir), done_idx, total, msg, prog
-
-def step2_process_next_batch(
-    up_src_paths, up_out_dir, up_done_idx, up_total,
-    ui_model_name, outscale, tile, precision, denoise_strength, face_enhance, batch_size,
-):
-    # Turn this into a generator that streams progress
-    if not up_src_paths or not up_out_dir:
-        yield None, None, "Load sources first.", render_progress(0.0, "Idle"), up_done_idx, up_out_dir
-        return
-
-    model_id = map_ui_model_to_internal(ui_model_name)
-    scale = clamp_scale_for_model(int(outscale or 4), model_id)
-    device = "cuda" if os.environ.get("CUDA_VISIBLE_DEVICES") else "cpu"
-    half = (precision == "half") and (device == "cuda")
-    tile = int(tile or 256)
-    batch_size = max(1, int(batch_size or 8))
-
-    # Build upsampler
-    upsampler = get_realesrganer(model_id, scale, tile, half, device=device)
-
-    # Optional: GFPGAN face enhancer
-    face_enhancer = None
-    if face_enhance:
-        try:
-            from gfpgan import GFPGANer
-            face_enhancer = GFPGANer(
-                model_path="https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth",
-                upscale=scale,
-                arch="clean",
-                channel_multiplier=2,
-                bg_upsampler=upsampler
-            )
-        except Exception as e:
-            print("GFPGAN load failed:", e)
-            face_enhancer = None
-
-    start = int(up_done_idx or 0)
-    end = min(start + batch_size, int(up_total or 0))
-    out_dir = Path(up_out_dir)
-
-    if start >= up_total:
-        gallery = _build_gallery_from_dir(out_dir, 30)
-        zip_path = Path(out_dir.parent) / "upscaled.zip"
-        zip_file = _save_zip_of_dir(out_dir, zip_path)
-        prog = render_progress(100.0, "All images processed")
-        details = f"Done. Total upscaled: {len(list(out_dir.glob('*.jpg')))+len(list(out_dir.glob('*.png')))}"
-        yield gallery, zip_file, details, prog, start, up_out_dir
-        return
-
-    batch_paths = up_src_paths[start:end]
-    total_in_batch = len(batch_paths)
-    processed_now = 0
-
-    # For ETA
-    t0 = time.time()
-    for idx, fp in enumerate(batch_paths, start=1):
-        try:
-            with Image.open(fp) as im:
-                img = im.convert("RGB")
-                cv_img = np.array(img)
-
-                if face_enhancer:
-                    _, _, output = face_enhancer.enhance(
-                        cv_img, has_aligned=False, only_center_face=False, paste_back=True
-                    )
-                else:
-                    # denoise_strength only applies to general-x4v3, but harmless otherwise
-                    output, _ = upsampler.enhance(cv_img, outscale=scale, denoise_strength=float(denoise_strength or 0.5))
-
-                Image.fromarray(output).save(out_dir / (Path(fp).stem + ".jpg"), quality=95)
-
-        except Exception as e:
-            print("Upscale error:", e)
-
-        processed_now = idx
-        # Progress & ETA for THIS batch
-        pct_batch = (processed_now / total_in_batch) * 100.0
-        elapsed = time.time() - t0
-        secs_per_img = elapsed / max(1, processed_now)
-        remaining_imgs = total_in_batch - processed_now
-        eta = remaining_imgs * secs_per_img
-        label = (f"Batch: {processed_now}/{total_in_batch} · "
-                 f"~{eta:.1f}s ETA · global {start+processed_now}/{up_total} "
-                 f"(x{scale}, model={ui_model_name}, denoise={denoise_strength}, face={face_enhance})")
-
-        gallery = _build_gallery_from_dir(out_dir, 30)
-        zip_path = Path(out_dir.parent) / "upscaled.zip"
-        zip_file = _save_zip_of_dir(out_dir, zip_path)
-        yield gallery, zip_file, label, render_progress(pct_batch, f"Upscaling… {pct_batch:.0f}% (this batch)"), start+processed_now, up_out_dir
-
-    # Batch complete — final emit for this click
-    next_idx = end
-    gallery = _build_gallery_from_dir(out_dir, 30)
-    zip_path = Path(out_dir.parent) / "upscaled.zip"
-    zip_file = _save_zip_of_dir(out_dir, zip_path)
-
-    # Total (global) percentage across all sources
-    pct_global = (next_idx / up_total) * 100.0 if up_total else 100.0
-    final_label = (f"Processed batch {total_in_batch} image(s). "
-                   f"{next_idx}/{up_total} done (global {pct_global:.0f}%).")
-    yield gallery, zip_file, final_label, render_progress(pct_global, "Upscaling… (global)"), next_idx, up_out_dir
-
-
-def save_uploaded_images(files: List[gr.File] | None, prefix: str = "upload") -> Tuple[List[Path], Path]:
-    tmp = Path(tempfile.mkdtemp(prefix="imgup_"))
-    in_dir = tmp / "input"; in_dir.mkdir(parents=True, exist_ok=True)
-    paths: List[Path] = []
-    if not files:
-        return paths, in_dir
-    for f in files:
-        src = Path(f.name)
-        name = f"{prefix}_{src.name}"
-        dst = in_dir / name
-        shutil.copy2(src, dst)
-        paths.append(dst)
-    return paths, in_dir
-
-def step2_upscale(
-    frames_list: List[str] | None,
-    ui_model_name: str,
-    outscale: int,
-    tile: int,
-    precision: str,
-    prog_html: str,
-    uploaded_imgs: List[gr.File] | None,
-    denoise_strength: float = 0.5,
-    face_enhance: bool = False,
-    batch_size: int = 16,          # << NEW
-    max_images: int = 0,           # << NEW (0 = all)
-):
-    """Upscale frames **in batches** with live progress updates.
-    Streams: "Upscaling… 20% · 80/100 remaining (batch 2/10)"
-    """
-    if not HAVE_REALESRGAN:
-        msg = ("Real-ESRGAN not available. Check requirements.txt includes: --prefer-binary, "
-               "numpy==1.26.4, scipy==1.11.4, scikit-image==0.22.0, opencv-python-headless, "
-               "torch==2.2.2, realesrgan==0.3.0, basicsr==1.4.2, pillow, gradio.")
-        yield None, None, msg, prog_html
-        return
-
-    # Source: uploaded > frames from Step 1
-    if uploaded_imgs and len(uploaded_imgs) > 0:
-        # Use direct file paths; no extra staging copy
-        src_paths = [str(Path(f.name)) for f in uploaded_imgs]
-    else:
-        src_paths = frames_list or []
-
-    if not src_paths:
-        yield None, None, "No images provided. Upload files or run Step 1 first.", prog_html
-        return
-
-    # Optional cap
-    try:
-        max_images = int(max_images or 0)
-    except Exception:
-        max_images = 0
-    if max_images > 0:
-        src_paths = src_paths[:max_images]
-
-    # Batch size
-    try:
-        batch_size = max(1, int(batch_size or 1))
-    except Exception:
-        batch_size = 16
-
-    # Map UI model -> internal id; clamp scale to model
-    model_id = map_ui_model_to_internal(ui_model_name)
-    scale = clamp_scale_for_model(int(outscale or 4), model_id)
-
-
-    scale = _clamp_scale_for_model(int(outscale or 4), model_id)
-    device = "cuda" if os.environ.get("CUDA_VISIBLE_DEVICES") else "cpu"
-    half = (precision == "half") and (device == "cuda")
-    upsampler = get_realesrganer(model_id, scale, tile, half, device=device)
-
-    work = Path(tempfile.mkdtemp(prefix="up_"))
-    out_dir = work / "upscaled"
-    out_dir.mkdir(parents=True, exist_ok=True)
-
-    total = len(src_paths)
-    done = 0
-    up_paths: List[Path] = []
-
-    # Process in batches
-    for i in range(0, total, batch_size):
-        batch = src_paths[i:i+batch_size]
-
-        for fp in batch:
-            try:
-                with Image.open(fp) as im:
-                    img = im.convert("RGB")
-                    output, _ = upsampler.enhance(np.array(img), outscale=scale)
-                out_img = Image.fromarray(output)
-                out_file = out_dir / (Path(fp).stem + ".jpg")
-                out_img.save(out_file, quality=95)
-                up_paths.append(out_file)
-            except Exception:
-                # continue on errors
-                pass
-            finally:
-                done += 1
-
-        # Emit progress after each batch
-        pct = int(round((done / total) * 100)) if total else 0
-        remaining = max(0, total - done)
-        label = f"Upscaling… {pct}% · {remaining}/{total} remaining (batch {i//batch_size+1}/{(total+batch_size-1)//batch_size})"
-        prog_html = render_progress(pct, label)
-        yield None, None, label, prog_html
-
-    if not up_paths:
-        yield None, None, "Upscaling produced no outputs.", prog_html
-        return
-
-    up_paths = sorted(up_paths, key=_natural_key)
-    gallery = sample_paths(up_paths, 30)
-    zip_path = work / "upscaled.zip"
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for p in up_paths:
-            zf.write(p, p.name)
-
-    final_label = (f"Upscaled: {len(up_paths)} | Model: {ui_model_name}→{model_id} | "
-                   f"Scale: x{scale} | Tile: {tile} | Precision: {precision} | Batch: {batch_size}")
-    yield gallery, str(zip_path), final_label, render_progress(100.0, "Upscaling complete")
-
-
-# ───────────────── Encode (Step 3) — supports uploaded frames/ZIP & optional audio source
-
-def prepare_frames_from_upload(files: List[gr.File] | None, prefix: str = "enc") -> Tuple[Optional[str], Optional[str]]:
-    if not files:
-        return None, None
-    work = Path(tempfile.mkdtemp(prefix="enc_"))
-    frames_dir = work / "frames"; frames_dir.mkdir(parents=True, exist_ok=True)
-    detected_prefix = None
-
-    # If a single ZIP is uploaded, unzip
-    if len(files) == 1 and Path(files[0].name).suffix.lower() == ".zip":
-        with zipfile.ZipFile(files[0].name, "r") as zf:
-            zf.extractall(frames_dir)
-        # try detect a prefix
-        imgs = sorted(frames_dir.glob("*.jpg")) + sorted(frames_dir.glob("*.png"))
-        if imgs:
-            detected_prefix = Path(imgs[0]).stem.split("_")[0]
-        return str(frames_dir), detected_prefix or prefix
-
-    # else, copy images directly
-    counter = 1
-    for f in files:
-        src = Path(f.name)
-        if src.suffix.lower() not in [".jpg", ".jpeg", ".png"]:
-            continue
-        dst = frames_dir / f"{prefix}_{counter:05d}{src.suffix.lower()}"
-        shutil.copy2(src, dst)
-        counter += 1
-    return str(frames_dir), prefix
-
-
-def build_ffmpeg_encode(frames_dir: str, prefix: str, fps: float, fmt: str, include_audio: bool, orig_video: str | None) -> List[str]:
-    pattern_jpg = Path(frames_dir) / f"{prefix}_%05d.jpg"
-    pattern_png = Path(frames_dir) / f"{prefix}_%05d.png"
-    pattern = str(pattern_jpg if pattern_jpg.exists() else pattern_png)
-    args = [FFMPEG, "-y", "-start_number", "1", "-framerate", f"{fps:.6f}", "-i", pattern]
-    if include_audio and orig_video:
-        args += ["-i", orig_video, "-map", "0:v:0", "-map", "1:a:0", "-shortest"]
-    if fmt == "h265":
-        vcodec = ["-c:v", "libx265"]
-    elif fmt == "vp9":
-        vcodec = ["-c:v", "libvpx-vp9"]
-    else:
-        vcodec = ["-c:v", "libx264"]
-    args += vcodec + ["-pix_fmt", "yuv420p", "-crf", "18", "-preset", "medium"]
-    out_name = "output.mp4" if fmt in ("h264", "h265") else "output.webm"
-    args += [out_name]
-    return args
-
-
-def step3_encode(
-    frames_dir_state: str | None,
-    prefix_state: str | None,
-    orig_video: gr.File | None,
-    fps: float | None,
-    fmt: str,
-    include_audio: bool,
-    prog_html: str,
-    uploaded_frames: List[gr.File] | None,
-    uploaded_audio_video: gr.File | None
-):
-    # Choose frames source: uploaded takes priority
-    frames_dir = frames_dir_state
-    prefix = prefix_state
-    if uploaded_frames and len(uploaded_frames) > 0:
-        frames_dir, detected = prepare_frames_from_upload(uploaded_frames, prefix or "enc")
-        if detected:
-            prefix = detected
-    if not frames_dir or not prefix:
-        yield None, "No frames available. Upload frames (ZIP/images) or run Step 1.", prog_html
-        return
-
-    fps = float(fps or 30.0)
-    orig_path = uploaded_audio_video.name if uploaded_audio_video else (orig_video.name if orig_video else None)
-
-    # Build ffmpeg command
-    cmd = build_ffmpeg_encode(frames_dir, prefix, fps, fmt, include_audio, orig_path)
-
-    # Inject progress reporting
-    cmd.insert(1, "-progress")
-    cmd.insert(2, "pipe:2")
-
-    # Try to estimate total frames for progress %
-    total_frames = len(list(Path(frames_dir).glob(f"{prefix}_*.jpg"))) \
-                 + len(list(Path(frames_dir).glob(f"{prefix}_*.png")))
-
-    proc = subprocess.Popen(
-        cmd,
-        stderr=subprocess.PIPE,
-        stdout=subprocess.DEVNULL,
-        text=True,
-        bufsize=1,
-        cwd=frames_dir
-    )
-
-    last_html = prog_html
-    current_frame = 0
-
-    while True:
-        line = proc.stderr.readline()
-        if not line and proc.poll() is not None:
-            break
-
-        if "frame=" in line:
-            try:
-                # parse `frame=123`
-                current_frame = int(line.strip().split("=")[-1])
-            except Exception:
-                pass
-
-            if total_frames > 0:
-                pct = min(100.0, (current_frame / total_frames) * 100.0)
-                last_html = render_progress(pct, f"Encoding… {current_frame}/{total_frames} frames")
-                yield None, f"Encoding in progress… {current_frame}/{total_frames}", last_html
-            else:
-                last_html = render_progress(50.0, "Encoding…")
-                yield None, "Encoding in progress…", last_html
-
-    ret = proc.wait()
-    out_file = Path(frames_dir) / ("output.mp4" if fmt in ("h264", "h265") else "output.webm")
-
-    if ret != 0 or not out_file.exists():
-        try:
-            err = proc.stderr.read() if proc.stderr else ""
-        except Exception:
-            err = ""
-        yield None, f"Encoding failed.\n\n{err}", last_html
-        return
-
-    yield str(out_file), f"Video created: {out_file.name}", render_progress(100.0, "Encoding complete")
-
-
-# ───────────────── Quick Mode — one click: All frames → Upscale ×4 → MP4 (audio)
-
-#def quick_mode(video: gr.File | None, start_time: str, end_time: str, resize_long: int, prefix_in: str, prog_html: str):
-#    if not video or not video.name:
-#        return None, None, None, "Upload a video.", prog_html
-#    if not (FFMPEG and FFPROBE and HAVE_REALESRGAN):
-#        return None, None, None, "Missing deps (ffmpeg/ffprobe/realesrgan). See requirements.txt.", prog_html
-
-#    info = parse_video_info(ffprobe_json(video.name))
-#    in_fps = info.get("fps") or 30.0
-#    prefix = sanitize_prefix(prefix_in) or Path(video.name).stem
-
-#    work = Path(tempfile.mkdtemp(prefix="quick_"))
-#    raw_dir = work / "frames_raw"; raw_dir.mkdir(parents=True, exist_ok=True)
-#    up_dir = work / "upscaled";   up_dir.mkdir(parents=True, exist_ok=True)
-
-    # Extract all frames
-#    extract_cmd = build_ffmpeg_extract(
-#        input_path=video.name,
-#        mode="All frames",
-#        every_seconds=1.0,
-#        nth_frame=1,
-#        exact_fps=in_fps,
-#        start_time=(start_time or "").strip(),
-#        end_time=(end_time or "").strip(),
-#        long_side=resize_long,
-#        out_format="jpg",
-#        jpg_quality=3,
-#        png_level=2,
-#        scene_detect=False,
-#        scene_thresh=0.3,
-#        out_pattern=str(raw_dir / f"{prefix}_%05d.jpg"),
-#    )
-#    proc = subprocess.Popen(extract_cmd, stderr=subprocess.PIPE, stdout=subprocess.DEVNULL, text=True, bufsize=1)
-#    est = estimate_output_count("All frames", info.get("duration"), in_fps, 1.0, 1, in_fps)
-#    created = 0
-#    while True:
-#        line = proc.stderr.readline()
-#        if not line and proc.poll() is not None:
-#            break
-#        if int(time.time()*10) % 3 == 0:
-#            created = len(list(raw_dir.glob(f"{prefix}_*.jpg")))
-#            pct = min(100.0, (created / est) * 100.0) if est else 0
-#            prog_html = render_progress(pct, f"Phase 1/3: Extracting {created}/{est or '?'}")
-#    proc.wait()
-
-#    frames = sorted(raw_dir.glob(f"{prefix}_*.jpg"))
-#    if not frames:
-#        return None, None, None, "No frames extracted in Quick Mode.", prog_html
-
-    # Upscale x4
-#    device = "cuda" if os.environ.get("CUDA_VISIBLE_DEVICES") else "cpu"
-#    upsampler = get_realesrganer("x4plus", 4, 0, (device=="cuda"), device=device)
-
-#    total = len(frames)
-#    done = 0
-#    for fp in frames:
-#        img = Image.open(fp).convert("RGB")
-#        output, _ = upsampler.enhance(np.array(img), outscale=4)
-#        Image.fromarray(output).save(up_dir / (Path(fp).stem + ".jpg"), quality=95)
-#        done += 1
-#        pct = (done/total)*100 if total else 0
-#        prog_html = render_progress(pct, f"Phase 2/3: Upscaling {done}/{total}")
-
-    # Encode MP4 with audio
-#    encode_cmd = build_ffmpeg_encode(str(up_dir), prefix, in_fps, "h264", True, video.name)
-#    proc2 = subprocess.Popen(encode_cmd, stderr=subprocess.PIPE, stdout=subprocess.DEVNULL, text=True, bufsize=1, cwd=str(up_dir))
-#    while True:
-#        line = proc2.stderr.readline()
-#        if not line and proc2.poll() is not None:
-#            break
-#        if int(time.time()*10) % 5 == 0:
-#            prog_html = render_progress(50.0, "Phase 3/3: Encoding…")
-#    proc2.wait()
-
-#    out_file = Path(up_dir) / "output.mp4"
-#    if not out_file.exists():
-#        return None, None, None, "Encoding failed in Quick Mode.", prog_html
-
-    # Intermediates
-#    zip_frames = work / "frames.zip"
-#    with zipfile.ZipFile(zip_frames, "w", zipfile.ZIP_DEFLATED) as zf:
-#        for p in frames:
-#            zf.write(p, p.name)
-#    zip_up = work / "upscaled.zip"
-#    with zipfile.ZipFile(zip_up, "w", zipfile.ZIP_DEFLATED) as zf:
-#        for p in sorted(up_dir.glob("*.jpg"), key=_natural_key):
-#            zf.write(p, p.name)
-
-#    return str(out_file), str(zip_frames), str(zip_up), "Quick Mode complete.", render_progress(100.0, "All done")
-
 # ───────────────── UI
 
 def build_ui():
-    with gr.Blocks(theme=gr.themes.Soft(), css="""
-    .cf-title { font-size: 1.6rem; font-weight: 800; }
-    .cmdbox textarea { font-family: ui-monospace, Menlo, monospace; font-size: 12px; }
-    """) as demo:
-        gr.HTML(render_logo_html(96))
-        gr.Markdown("Three-step workflow. Video → Frames → Upscale → Re-encode")
-
-
-        # Shared states (from Step 1)
-        frames_state = gr.State([])        # list[str]
-        frames_dir_state = gr.State("")   # str
-        prefix_state = gr.State("")       # str
-        fps_state = gr.State(30.0)         # float
-        # Shared Step 2 states (manual batching)
-        up_src_paths_state = gr.State([])     # list[str] absolute paths to process
-        up_out_dir_state   = gr.State("")     # str: output dir path
-        up_done_idx_state  = gr.State(0)      # int: next index to start from
-        up_total_state     = gr.State(0)      # int: total images
-        
-        with gr.Tabs():
-            # STEP 1
-            with gr.Tab("Step 1 · Extract Frames"):
-                with gr.Row():
-                    video = gr.File(label="Upload video", file_types=[".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"], type="filepath")
-                with gr.Accordion("Extraction Settings", open=True):
-                    with gr.Row():
-                        mode = gr.Dropdown(["Every N seconds", "Every Nth frame", "Exact FPS", "All frames"], value="Every N seconds", label="Mode")
-                        every_seconds = gr.Number(value=1.0, label="Every N seconds")
-                        nth_frame = gr.Number(value=30, label="Every Nth frame")
-                        exact_fps = gr.Number(value=1.0, label="Exact FPS")
-                    with gr.Row():
-                        start_time = gr.Textbox(value="", label="Start (HH:MM:SS.mmm)")
-                        end_time = gr.Textbox(value="", label="End (HH:MM:SS.mmm)")
-                        long_side = gr.Number(value=0, label="Resize long side px (0 = none)")
-                    with gr.Row():
-                        out_format = gr.Dropdown(["jpg", "png"], value="jpg", label="Output format")
-                        jpg_quality = gr.Slider(2, 31, value=3, step=1, label="JPG quality (2=best)")
-                        png_level = gr.Slider(0, 9, value=2, step=1, label="PNG compression level")
-                    with gr.Row():
-                        scene_detect = gr.Checkbox(False, label="Scene-change detect")
-                        scene_thresh = gr.Slider(0.0, 1.0, value=0.3, step=0.01, label="Scene threshold")
-                        prefix_vid = gr.Textbox(value="", label="Filename prefix (defaults to input file name)")
-                estimate_md = gr.Markdown("Estimated output: —")
-                with gr.Row():
-                    btn_extract = gr.Button("Step 1: Extract Frames", variant="primary")
-                prog1 = gr.HTML(render_progress(0.0, "Idle"))
-                gallery = gr.Gallery(label="Preview (all ≤100, else sample 100)", columns=6, height=480)
-                zip_out = gr.File(label="Download frames ZIP")
-                details1 = gr.Markdown("Ready.")
-                with gr.Accordion("Show FFmpeg command", open=False):
-                    cmd_preview = gr.Textbox(label="ffmpeg command", lines=4, elem_classes=["cmdbox"])
-                if MISSING_MSG:
-                    gr.Markdown(f"<span style='color:#b45309'>{MISSING_MSG}</span>")
-                # Wire behavior: enable/disable param groups depending on mode / format
-                def _toggle_params(mode_val, fmt):
-                    return (
-                        gr.update(visible=(mode_val == "Every N seconds")),
-                        gr.update(visible=(mode_val == "Every Nth frame")),
-                        gr.update(visible=(mode_val == "Exact FPS")),
-                        gr.update(visible=(fmt == "jpg")),
-                        gr.update(visible=(fmt == "png")),
-                    )
-        
-                mode.change(
-                    _toggle_params,
-                    inputs=[mode, out_format],
-                    outputs=[every_seconds, nth_frame, exact_fps, jpg_quality, png_level],
-                )
-                out_format.change(
-                    _toggle_params,
-                    inputs=[mode, out_format],
-                    outputs=[every_seconds, nth_frame, exact_fps, jpg_quality, png_level],
-                )
-                # Initialize visibility
-                demo.load(_toggle_params, inputs=[mode, out_format], outputs=[every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
-        
-                def update_estimate(vfile, mode_val, evs, nth, exfps, st, et):
-                    if not vfile or not getattr(vfile, 'name', None):
-                        return "Estimated output: —"
-                    info = parse_video_info(ffprobe_json(vfile.name))
-                    dur = info.get("duration")
-                    def parse_ts(ts: str):
-                        if not ts: return 0.0
-                        parts = ts.split(":")
-                        if len(parts) == 3:
-                            try: return float(parts[0])*3600 + float(parts[1])*60 + float(parts[2])
-                            except Exception: return 0.0
-                        return 0.0
-                    st_s = parse_ts(st or ""); et_s = parse_ts(et or "")
-                    if dur:
-                        if st_s: dur = max(0.0, dur - st_s)
-                        if et_s and et_s < info.get("duration", 0) and et_s > 0:
-                            dur = min(dur, et_s)
-                    est = estimate_output_count(mode_val, dur, info.get("fps"), evs or 1.0, int(nth or 1), exfps or 1.0)
-                    return f"Estimated output: **~{est} frames**" if est else "Estimated output: —"
-
-                for ctrl in [video, mode, every_seconds, nth_frame, exact_fps, start_time, end_time]:
-                    ctrl.change(update_estimate, inputs=[video, mode, every_seconds, nth_frame, exact_fps, start_time, end_time], outputs=[estimate_md])
-
-                btn_extract.click(
-                    step1_extract,
-                    inputs=[
-                        video, mode, every_seconds, nth_frame, exact_fps,
-                        start_time, end_time, long_side, out_format, jpg_quality, png_level,
-                        scene_detect, scene_thresh, prefix_vid,
-                        prog1,
-                    ],
-                    outputs=[gallery, zip_out, details1, cmd_preview, prog1, frames_state, frames_dir_state, prefix_state],
-                )
-
-            # STEP 2 — Upscale
-            with gr.Tab("Step 2 · Upscale Frames"):
-                if not HAVE_REALESRGAN:
-                    gr.Markdown("⚠️ Upscaling disabled. Install dependencies in requirements.txt (realesrgan, basicsr, torch, etc.).")
-                
-                gr.Markdown("Use frames from Step 1 **or** upload images below.")
-                imgs_override = gr.Files(
-                    label="Upload images to upscale (JPG/PNG)",
-                    file_types=[".jpg", ".jpeg", ".png"],
-                    type="filepath"
-                )
-                
-                with gr.Accordion("Upscaling options", open=True):
-                    with gr.Row():
-                        ui_model_name = gr.Dropdown(
-                            label="Upscaler model",
-                            choices=[
-                                "RealESRGAN_x4plus",
-                                "RealESRNet_x4plus",
-                                "RealESRGAN_x4plus_anime_6B",
-                                "RealESRGAN_x2plus",
-                                "realesr-general-x4v3",
-                            ],
-                            value="RealESRGAN_x4plus",
-                            show_label=True
-                        )
-                        denoise_strength = gr.Slider(0, 1, value=0.5, step=0.1, label="Denoise (only general-x4v3)")
-                        outscale = gr.Slider(1, 6, value=4, step=1, label="Resolution upscale")
-                        face_enhance = gr.Checkbox(value=False, label="Face Enhancement (GFPGAN)")
-                
-                with gr.Row():
-                    tile = gr.Number(value=256, label="Tile size (try 128 if OOM; 0=auto)")
-                    precision = gr.Dropdown(["auto", "half", "full"], value="auto", label="Precision (GPU=half, CPU=full)")
-                with gr.Row():
-                    batch_size = gr.Number(value=12, precision=0, label="Batch size per click")
-                    max_images = gr.Number(value=0, precision=0, label="Max images to process (0 = all)")
-                
-                with gr.Row():
-                    btn_prepare = gr.Button("Step 2: Load / Reset Sources", variant="secondary")
-                    btn_next    = gr.Button("Process Next Batch", variant="primary")
-                
-                prog2 = gr.HTML(render_progress(0.0, "Idle"))
-                gallery_up = gr.Gallery(label="Upscaled preview (30 sampled)", columns=6, height=480)
-                zip_up = gr.File(label="Download upscaled ZIP")
-                details2 = gr.Markdown("")
-                
-                # 1) load/reset sources
-                btn_prepare.click(
-                    step2_prepare_sources,
-                    inputs=[frames_state, imgs_override, max_images],
-                    outputs=[up_src_paths_state, up_out_dir_state, up_done_idx_state, up_total_state, details2, prog2]
-                )
-                
-                # 2) process one batch per click
-                btn_next.click(
-                    step2_process_next_batch,
-                    inputs=[
-                        up_src_paths_state, up_out_dir_state, up_done_idx_state, up_total_state,
-                        ui_model_name, outscale, tile, precision, denoise_strength, face_enhance, batch_size
-                    ],
-                    outputs=[gallery_up, zip_up, details2, prog2, up_done_idx_state, up_out_dir_state]
-                )
-
-
-            # STEP 3 — Re-encode
-            with gr.Tab("Step 3 · Re-encode Video"):
-                gr.Markdown("Use frames from Step 1 **or** upload a frames ZIP / images. Optionally provide a video for audio track.")
-                uploaded_frames = gr.Files(label="Upload frames (ZIP or images)", type="filepath")
-                uploaded_audio = gr.File(label="Optional: video/audio source for audio track", file_types=[".mp4", ".mov", ".mkv", ".webm", ".mp3", ".wav"], type="filepath")
-                with gr.Row():
-                    fmt = gr.Dropdown(["h264", "h265", "vp9"], value="h264", label="Format")
-                    include_audio = gr.Checkbox(True, label="Include audio if available")
-                with gr.Row():
-                    btn_encode = gr.Button("Step 3: Create Video", variant="primary")
-                prog3 = gr.HTML(render_progress(0.0, "Idle"))
-                video_player = gr.Video(label="Preview video")
-                details3 = gr.Markdown("")
-
-                def set_fps(vfile):
-                    if not vfile or not getattr(vfile, 'name', None):
-                        return 30.0
-                    info = parse_video_info(ffprobe_json(vfile.name))
-                    return float(info.get("fps") or 30.0)
-                # capture FPS from the original step1 video when it changes
-                video.change(set_fps, inputs=[video], outputs=[fps_state])
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.HTML(render_logo_html(88))
+        gr.Markdown("Extract frames from a video with live progress.")
+
+        # Upload video
+        with gr.Row():
+            video = gr.File(
+                label="Upload video",
+                file_types=[".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"],
+                type="filepath"
+            )
 
-                btn_encode.click(
-                    step3_encode,
-                    inputs=[frames_dir_state, prefix_state, video, fps_state, fmt, include_audio, prog3, uploaded_frames, uploaded_audio],
-                    outputs=[video_player, details3, prog3],
+        # Extraction settings
+        with gr.Accordion("Extraction Settings", open=True):
+            with gr.Row():
+                mode = gr.Dropdown(
+                    ["Every N seconds", "Every Nth frame", "Exact FPS", "All frames"],
+                    value="Every N seconds", label="Mode"
                 )
+                every_seconds = gr.Number(value=1.0, label="Every N seconds")
+                nth_frame = gr.Number(value=30, label="Every Nth frame")
+                exact_fps = gr.Number(value=1.0, label="Exact FPS")
+            with gr.Row():
+                start_time = gr.Textbox(value="", label="Start (HH:MM:SS.mmm)")
+                end_time = gr.Textbox(value="", label="End (HH:MM:SS.mmm)")
+                long_side = gr.Number(value=0, label="Resize long side px (0 = none)")
+            with gr.Row():
+                out_format = gr.Dropdown(["jpg", "png"], value="jpg", label="Output format")
+                jpg_quality = gr.Slider(2, 31, value=3, step=1, label="JPG quality (2=best)")
+                png_level = gr.Slider(0, 9, value=2, step=1, label="PNG compression level")
+            with gr.Row():
+                scene_detect = gr.Checkbox(False, label="Scene-change detect")
+                scene_thresh = gr.Slider(0.0, 1.0, value=0.3, step=0.01, label="Scene threshold")
+                prefix_vid = gr.Textbox(value="", label="Filename prefix (defaults to input file name)")
+
+        # Controls & outputs
+        btn_extract = gr.Button("Extract Frames", variant="primary")
+        prog = gr.HTML(render_progress(0.0, "Idle"))
+        gallery = gr.Gallery(label="Preview (≤100, else sample 100)", columns=6, height=480)
+        zip_out = gr.File(label="Download frames ZIP")
+        details = gr.Markdown("Ready.")
+        with gr.Accordion("Show FFmpeg command", open=False):
+            cmd_preview = gr.Textbox(label="ffmpeg command", lines=4)
+        estimate_md = gr.Markdown("Estimated output: —")
+
+        # === Functions wired into UI ===
+        def _toggle_params(mode_val, fmt):
+            return (
+                gr.update(visible=(mode_val == "Every N seconds")),
+                gr.update(visible=(mode_val == "Every Nth frame")),
+                gr.update(visible=(mode_val == "Exact FPS")),
+                gr.update(visible=(fmt == "jpg")),
+                gr.update(visible=(fmt == "png")),
+            )
 
-            # QUICK MODE
-#            with gr.Tab("⚡ Quick Mode"):
-#                gr.Markdown("Extract ALL frames → Upscale ×4 → MP4 (H.264) with original audio. No toggles.")
-#                with gr.Row():
-#                    q_video = gr.File(label="Upload video", file_types=[".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"], type="filepath")
-#                with gr.Row():
-#                    q_start = gr.Textbox(value="", label="Start (HH:MM:SS.mmm, optional)")
-#                    q_end = gr.Textbox(value="", label="End (HH:MM:SS.mmm, optional)")
-#                    q_resize = gr.Number(value=0, label="Resize long side before upscale (0 = none)")
-#                q_prefix = gr.Textbox(value="", label="Filename prefix (defaults to input file name)")
-
-#                q_btn = gr.Button("Run Quick Pipeline", variant="primary")
-#                q_prog = gr.HTML(render_progress(0.0, "Idle"))
-#                q_video_out = gr.Video(label="Output video")
-#                with gr.Accordion("Show intermediates", open=False):
-#                    q_zip_frames = gr.File(label="frames.zip")
-#                    q_zip_up = gr.File(label="upscaled.zip")
-#                q_details = gr.Markdown("")
+        def update_estimate(vfile, mode_val, evs, nth, exfps, st, et):
+            if not vfile or not getattr(vfile, 'name', None):
+                return "Estimated output: —"
+            info = parse_video_info(ffprobe_json(vfile.name))
+            dur = info.get("duration")
+
+            def parse_ts(ts: str):
+                if not ts: return 0.0
+                parts = ts.split(":")
+                if len(parts) == 3:
+                    try:
+                        return float(parts[0])*3600 + float(parts[1])*60 + float(parts[2])
+                    except Exception:
+                        return 0.0
+                return 0.0
+
+            st_s = parse_ts(st or ""); et_s = parse_ts(et or "")
+            if dur:
+                if st_s: dur = max(0.0, dur - st_s)
+                if et_s and et_s < info.get("duration", 0) and et_s > 0:
+                    dur = min(dur, et_s)
+            est = estimate_output_count(mode_val, dur, info.get("fps"), evs or 1.0, int(nth or 1), exfps or 1.0)
+            return f"Estimated output: **~{est} frames**" if est else "Estimated output: —"
+
+        # Wire up dynamic visibility
+        mode.change(_toggle_params, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
+        out_format.change(_toggle_params, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
+        demo.load(_toggle_params, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
+
+        # Wire up estimate updater
+        for ctrl in [video, mode, every_seconds, nth_frame, exact_fps, start_time, end_time]:
+            ctrl.change(update_estimate, inputs=[video, mode, every_seconds, nth_frame, exact_fps, start_time, end_time], outputs=[estimate_md])
+
+        # Extract button
+        btn_extract.click(
+            step1_extract,
+            inputs=[video, mode, every_seconds, nth_frame, exact_fps, start_time, end_time, long_side, out_format, jpg_quality, png_level, scene_detect, scene_thresh, prefix_vid, prog],
+            outputs=[gallery, zip_out, details, cmd_preview, prog],
+        )
 
-#                q_btn.click(
-#                    quick_mode,
-#                    inputs=[q_video, q_start, q_end, q_resize, q_prefix, q_prog],
-#                    outputs=[q_video_out, q_zip_frames, q_zip_up, q_details, q_prog],
-#                )
+        if MISSING_MSG:
+            gr.Markdown(f"<span style='color:#b45309'>{MISSING_MSG}</span>")
 
     return demo
-
-
-if __name__ == "__main__":
-    demo = build_ui()
-    demo.queue().launch()
+if __name__ == "__main__": demo = build_ui() demo.queue().launch()