feat: complete port with all 7 pipeline modes, advanced config, pipeline factory

README.md

@@ -11,49 +11,30 @@ pinned: true
 license: mit
 ---
 
-# WhisperJAV — Japanese Subtitle Generator
+# WhisperJAV — Japanese Subtitle Generator (Full Port)
 
-**ChronosJAV** pipeline powered by `litagin/anime-whisper`.
+Complete port of [WhisperJAV](https://github.com/meizhong986/WhisperJAV) to HuggingFace Spaces.
+All **7 pipeline modes**, ChronosJAV, sensitivity settings, and advanced configuration. CPU-optimized for the free tier.
 
-A HuggingFace Space that brings the [WhisperJAV](https://github.com/meizhong986/WhisperJAV) subtitle generator to the cloud. Optimized for the **free CPU tier**.
+## Pipeline Modes
 
-## Features
-
-- **ChronosJAV Pipeline** — Decoupled text generation + timestamp alignment using anime-whisper
-- **Background Processing** — Tasks run in background threads; close your browser and come back later
-- **Task Monitor** — Real-time view of running, queued, and completed tasks
-- **Download History** — All previously generated subtitle files available for download
-- **CPU Only** — Designed for HuggingFace's free hardware (2 vCPU, 16 GB RAM)
-
-## Usage
-
-1. Upload a video or audio file (MP4, MKV, WAV, MP3, etc.)
-2. Click **Start Transcription**
-3. Wait for processing (30–60 min per hour of video on CPU)
-4. Download the generated `.srt` or `.vtt` subtitle file from the **Download History** tab
-
-## Pipeline
+| Mode | Backend | Best For |
+|------|---------|----------|
+| **anime** | anime-whisper + ChronosJAV | Anime / JAV dialogue |
+| **qwen** | Qwen3-ASR + forced alignment | Maximum accuracy |
+| **balanced** | Faster-Whisper + Silero VAD | Default, noisy content |
+| **fidelity** | OpenAI Whisper + stable-ts | Maximum fidelity |
+| **fast** | Faster-Whisper + auditok | General use, mixed quality |
+| **faster** | Faster-Whisper turbo | Speed, clean audio |
+| **transformers** | Kotoba-Whisper / Qwen | Japanese-optimised models |
 
-The **ChronosJAV** pipeline separates text generation from timestamp alignment:
-
-| Stage | Component |
-|-------|-----------|
-| Audio extraction | FFmpeg (48 kHz) |
-| Scene detection | Semantic (MFCC clustering) |
-| Voice activity detection | WhisperSeg ONNX |
-| Text generation | `litagin/anime-whisper` (Whisper large-v3 fine-tune) |
-| Timestamp alignment | VAD-based (VAD_ONLY mode) |
-| Post-processing | Anime-whisper cleaner (ellipsis filtering) |
-
-## Limitations
-
-- **CPU only** — processing is 5–10× slower than GPU
-- **Japanese only** — optimized for Japanese dialogue; other languages may produce poor results
-- **First run latency** — the anime-whisper model (~3 GB) downloads on first use
-- **Free tier constraints** — 16 GB RAM, 50 GB disk; very long videos (>4 h) may fail
-
-## Credits
+## Features
 
-- [WhisperJAV](https://github.com/meizhong986/WhisperJAV) by MeiZhong
-- [anime-whisper](https://huggingface.co/litagin/anime-whisper) by litagin
-- [ChronusOmni](https://arxiv.org/abs/2512.09841) — Inspiration for the decoupled pipeline architecture
+- **All 7 pipeline modes** with full configuration
+- **Sensitivity settings**: conservative, balanced, aggressive
+- **Scene detection**: semantic, auditok, silero
+- **Voice Activity Detection**: WhisperSeg, Silero, TEN
+- **Background processing** — tasks run in daemon threads
+- **Task monitor** — real-time status with auto-refresh
+- **Download history** — select and download any past subtitle file
+- **Storage Bucket** support — mount `/data` for persistent model cache

app.py

@@ -1,14 +1,15 @@
 """
-WhisperJAV HuggingFace Space — Japanese Subtitle Generator
-==========================================================
-ChronosJAV pipeline (anime-whisper) · CPU mode · Free tier
-Background task processing · Download history · Real-time monitor
+WhisperJAV HuggingFace Space — Complete Japanese Subtitle Generator
+====================================================================
+Full port with all 7 pipeline modes, sensitivity settings, and
+configuration options.  CPU-optimized for free HuggingFace tier.
 
 Architecture:
-  - Gradio Blocks UI with tabs for task submission and monitoring
-  - Background threads process transcription tasks without blocking the frontend
-  - JSON file persists task state across Space restarts
-  - Model auto-downloads from HuggingFace Hub on first use (~3 GB)
+  - Gradio Blocks UI with full configuration panel
+  - Pipeline factory maps mode selection to correct pipeline class
+  - Background threads for transcription (non-blocking)
+  - JSON-backed task store with download history
+  - Auto-detects /data Storage Bucket for persistent model cache
 """
 
 from __future__ import annotations
@@ -17,15 +18,13 @@ import json
 import os
 
 # ── Storage Bucket support ──
-# Redirect HuggingFace cache to mounted persistent storage so models
-# survive Space rebuilds.  Falls back to default ~/.cache/huggingface
-# if the bucket path is not present.
 _BUCKET_HOME = "/data/huggingface"
 if os.path.isdir("/data") and os.access("/data", os.W_OK):
     os.makedirs(_BUCKET_HOME, exist_ok=True)
     os.environ.setdefault("HF_HOME", _BUCKET_HOME)
     os.environ.setdefault("HF_HUB_CACHE", os.path.join(_BUCKET_HOME, "hub"))
     os.environ.setdefault("TRANSFORMERS_CACHE", os.path.join(_BUCKET_HOME, "hub"))
+
 import shutil
 import threading
 import time
@@ -37,32 +36,70 @@ from typing import Any, Dict, List, Optional
 
 import gradio as gr
 
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 # Paths & Configuration
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 
 BASE_DIR = Path(__file__).resolve().parent
 OUTPUT_DIR = BASE_DIR / "outputs"
 TEMP_DIR = BASE_DIR / "temp"
 UPLOAD_DIR = BASE_DIR / "uploads"
 TASKS_FILE = BASE_DIR / "tasks.json"
-MAX_OUTPUT_FILES = 20  # keep most recent N task directories; prune older
+MAX_OUTPUT_FILES = 20
 
 OUTPUT_DIR.mkdir(exist_ok=True)
 TEMP_DIR.mkdir(exist_ok=True)
 UPLOAD_DIR.mkdir(exist_ok=True)
 
-# ═══════════════════════════════════════════════════════════════════════
-# Task Store (memory + JSON-backed)
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
+# Pipeline Config Registry
+# ═══════════════════════════════════════════════════════════════════════════
+
+PIPELINE_MODES = [
+    "anime",       # ChronosJAV — anime-whisper, text gen + VAD alignment
+    "qwen",        # Qwen3-ASR with forced alignment
+    "balanced",    # Faster-Whisper + auditok + Silero VAD (default)
+    "fidelity",    # OpenAI Whisper + auditok + Silero VAD (max accuracy)
+    "fast",        # Faster-Whisper + auditok (general use)
+    "faster",      # Faster-Whisper turbo (speed, clean audio)
+    "transformers", # HuggingFace Kotoba-Whisper models
+]
+
+PIPELINE_INFO = {
+    "anime":        "ChronosJAV — anime-whisper (text gen + VAD alignment). Best for anime/JAV dialogue.",
+    "qwen":         "Qwen3-ASR with forced word-level alignment. High accuracy, slower.",
+    "balanced":     "Faster-Whisper + auditok + Silero VAD. Good default for noisy, dialogue-heavy content.",
+    "fidelity":     "OpenAI Whisper + stable-ts. Maximum accuracy, slowest.",
+    "fast":         "Faster-Whisper + auditok. Good for mixed quality audio.",
+    "faster":       "Faster-Whisper turbo, no scene detection. Fastest, for clean audio.",
+    "transformers": "HuggingFace Kotoba-Whisper (Japanese-optimised). Supports HF and Qwen backends.",
+}
+
+SENSITIVITY_OPTIONS = ["balanced", "aggressive", "conservative"]
+LANGUAGE_OPTIONS = ["Japanese", "auto"]
+OUTPUT_FORMATS = ["srt", "vtt", "both"]
+SCENE_DETECTORS = ["semantic", "auditok", "silero", "none"]
+SPEECH_SEGMENTERS = ["whisperseg", "silero", "ten", "none"]
+QWEEN_GENERATORS = ["qwen3", "anime-whisper", "cohere"]
+QWEEN_MODES = ["assembly", "context_aware", "vad_slicing"]
+TRANSFORMERS_BACKENDS = ["hf", "qwen"]
+TRANSFORMERS_MODELS = [
+    "kotoba-tech/kotoba-whisper-bilingual-v1.0",
+    "kotoba-tech/kotoba-whisper-v2.0",
+    "kotoba-tech/kotoba-whisper-v2.1",
+    "kotoba-tech/kotoba-whisper-v2.2",
+]
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Task Store
+# ═══════════════════════════════════════════════════════════════════════════
 
 _tasks: Dict[str, dict] = {}
 _lock = threading.Lock()
-_semaphore = threading.Semaphore(1)  # single concurrent CPU task
+_semaphore = threading.Semaphore(1)
 
 
 def _load() -> None:
-    """Load persisted tasks; mark stale 'running' ones as interrupted."""
     global _tasks
     if not TASKS_FILE.exists():
         return
@@ -79,7 +116,6 @@ def _load() -> None:
 
 
 def _save() -> None:
-    """Persist lightweight view of tasks to JSON."""
     with _lock:
         slim: Dict[str, dict] = {}
         for tid, t in _tasks.items():
@@ -88,6 +124,7 @@ def _save() -> None:
                 "filename": t.get("filename", ""),
                 "status": t.get("status", "unknown"),
                 "pipeline": t.get("pipeline", ""),
+                "config": t.get("config", ""),
                 "created_at": str(t.get("created_at", "")),
                 "completed_at": str(t.get("completed_at", "")),
                 "output_srt": t.get("output_srt", ""),
@@ -95,14 +132,10 @@ def _save() -> None:
                 "error": str(t.get("error", ""))[:500],
                 "duration_seconds": t.get("duration_seconds", 0),
             }
-        TASKS_FILE.write_text(
-            json.dumps(slim, ensure_ascii=False, indent=2),
-            encoding="utf-8",
-        )
+        TASKS_FILE.write_text(json.dumps(slim, ensure_ascii=False, indent=2), encoding="utf-8")
 
 
 def _prune_old_outputs() -> None:
-    """Remove task output dirs beyond MAX_OUTPUT_FILES to save disk."""
     with _lock:
         completed = sorted(
             [t for t in _tasks.values() if t.get("status") == "completed"],
@@ -118,13 +151,144 @@ def _prune_old_outputs() -> None:
                 pass
 
 
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
+# Pipeline Factory
+# ═══════════════════════════════════════════════════════════════════════════
+
+def _build_pipeline(mode: str, output_dir: str, temp_dir: str, **kwargs):
+    """Create the appropriate whisperjav pipeline instance for the given mode."""
+    device = "cpu"
+    dtype = "float32"
+    language = kwargs.get("language", "Japanese")
+
+    if mode == "faster":
+        from whisperjav.pipelines.faster_pipeline import FasterPipeline
+        return FasterPipeline(
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+            keep_temp_files=False,
+            subs_language="native",
+            resolved_config={
+                "provider": {"device": device, "compute_type": dtype},
+                "scene_detection": {"method": "none"},
+                "vad": {"enabled": False},
+                "transcription": {"language": language},
+            },
+        )
+
+    elif mode == "fast":
+        from whisperjav.pipelines.fast_pipeline import FastPipeline
+        return FastPipeline(
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+            keep_temp_files=False,
+            subs_language="native",
+            resolved_config={
+                "provider": {"device": device, "compute_type": dtype},
+                "scene_detection": {"method": kwargs.get("scene_detector", "auditok")},
+                "vad": {"enabled": False},
+                "transcription": {"language": language},
+            },
+        )
+
+    elif mode == "balanced":
+        from whisperjav.pipelines.balanced_pipeline import BalancedPipeline
+        return BalancedPipeline(
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+            keep_temp_files=False,
+            subs_language="native",
+            resolved_config={
+                "provider": {"device": device, "compute_type": dtype},
+                "scene_detection": {"method": kwargs.get("scene_detector", "auditok")},
+                "vad": {
+                    "enabled": kwargs.get("speech_segmenter", "silero") != "none",
+                    "method": kwargs.get("speech_segmenter", "silero"),
+                },
+                "transcription": {"language": language},
+            },
+        )
+
+    elif mode == "fidelity":
+        from whisperjav.pipelines.fidelity_pipeline import FidelityPipeline
+        return FidelityPipeline(
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+            keep_temp_files=False,
+            subs_language="native",
+            resolved_config={
+                "provider": {"device": device, "compute_type": dtype},
+                "scene_detection": {"method": kwargs.get("scene_detector", "auditok")},
+                "vad": {
+                    "enabled": kwargs.get("speech_segmenter", "silero") != "none",
+                    "method": kwargs.get("speech_segmenter", "silero"),
+                },
+                "transcription": {"language": language},
+            },
+        )
+
+    elif mode == "transformers":
+        from whisperjav.pipelines.transformers_pipeline import TransformersPipeline
+        backend = kwargs.get("transformers_backend", "hf")
+        hf_lang = None if language == "auto" else (language[:2].lower() if language != "Japanese" else "ja")
+        return TransformersPipeline(
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+            keep_temp_files=False,
+            subs_language="native",
+            asr_backend=backend,
+            hf_model_id=kwargs.get("hf_model_id", "kotoba-tech/kotoba-whisper-bilingual-v1.0"),
+            hf_device=device,
+            hf_dtype=dtype,
+            hf_language=hf_lang or "ja",
+            qwen_device=device,
+            qwen_dtype=dtype,
+        )
+
+    elif mode == "qwen":
+        from whisperjav.pipelines.qwen_pipeline import QwenPipeline
+        generator = kwargs.get("qwen_generator", "qwen3")
+        model_map = {
+            "qwen3": "Qwen/Qwen3-ASR-1.7B",
+            "anime-whisper": "litagin/anime-whisper",
+            "cohere": "CohereLabs/cohere-transcribe-03-2026",
+        }
+        return QwenPipeline(
+            generator_backend=generator,
+            model_id=kwargs.get("qwen_model_id", model_map.get(generator, model_map["qwen3"])),
+            device=device,
+            dtype=dtype,
+            scene_detector=kwargs.get("scene_detector", "semantic"),
+            speech_segmenter=kwargs.get("speech_segmenter", "whisperseg"),
+            language=None if language == "auto" else language,
+            qwen_input_mode=kwargs.get("qwen_mode", "assembly"),
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+        )
+
+    elif mode == "anime":
+        from whisperjav.pipelines.qwen_pipeline import QwenPipeline
+        return QwenPipeline(
+            generator_backend="anime-whisper",
+            model_id="litagin/anime-whisper",
+            device=device,
+            dtype=dtype,
+            scene_detector=kwargs.get("scene_detector", "semantic"),
+            speech_segmenter=kwargs.get("speech_segmenter", "whisperseg"),
+            language=None if language == "auto" else language,
+            output_dir=output_dir,
+            temp_dir=temp_dir,
+        )
+
+    else:
+        raise ValueError(f"Unknown pipeline mode: {mode}")
+
+
+# ═══════════════════════════════════════════════════════════════════════════
 # Background Worker
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 
 def _run_transcription(task_id: str, video_path: str) -> None:
-    """Called in a daemon thread.  Loads whisperjav lazily so that the
-    Gradio UI can start serving immediately while models download."""
     try:
         with _lock:
             _tasks[task_id]["status"] = "running"
@@ -132,29 +296,22 @@ def _run_transcription(task_id: str, video_path: str) -> None:
 
         t0 = time.time()
         vp = Path(video_path)
-
-        # Use the original filename (without upload prefix) for output naming
-        original_filename = _tasks.get(task_id, {}).get("filename", vp.name)
+        task = _tasks.get(task_id, {})
+        original_filename = task.get("filename", vp.name)
         basename = Path(original_filename).stem
+        mode = task.get("pipeline", "anime")
+        config = task.get("config", {})
 
         task_out = OUTPUT_DIR / task_id
         task_tmp = TEMP_DIR / task_id
         task_out.mkdir(parents=True, exist_ok=True)
         task_tmp.mkdir(parents=True, exist_ok=True)
 
-        # ── lazy import (model download happens here on first call) ──
-        from whisperjav.pipelines.qwen_pipeline import QwenPipeline
-
-        pipeline = QwenPipeline(
-            generator_backend="anime-whisper",
-            model_id="litagin/anime-whisper",
-            device="cpu",
-            dtype="float32",
-            scene_detector="semantic",
-            speech_segmenter="whisperseg",
-            language="Japanese",
+        pipeline = _build_pipeline(
+            mode=mode,
             output_dir=str(task_out),
             temp_dir=str(task_tmp),
+            **config,
         )
 
         result = pipeline.process({"path": str(vp), "basename": basename})
@@ -162,7 +319,7 @@ def _run_transcription(task_id: str, video_path: str) -> None:
 
         elapsed = round(time.time() - t0, 1)
 
-        # ── copy final artefacts ──
+        # Copy output files
         srt_final = ""
         vtt_final = ""
         srt_src = result.get("srt_path", "")
@@ -171,12 +328,17 @@ def _run_transcription(task_id: str, video_path: str) -> None:
             shutil.copy2(srt_src, dst)
             srt_final = str(dst)
 
-        # Check for sidecar VTT (some configurations emit both)
         vtt_candidate = task_out / f"{basename}.vtt"
         if vtt_candidate.is_file():
             vtt_final = str(vtt_candidate)
 
-        # ── cleanup temp dir ──
+        # Also look for whisperjav-named files
+        for f in task_out.iterdir():
+            if f.suffix == ".srt" and not srt_final:
+                srt_final = str(f)
+            if f.suffix == ".vtt" and not vtt_final:
+                vtt_final = str(f)
+
         try:
             shutil.rmtree(task_tmp, ignore_errors=True)
         except Exception:
@@ -206,33 +368,30 @@ def _run_transcription(task_id: str, video_path: str) -> None:
         _semaphore.release()
 
 
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 # Callbacks
-# ═══════════════════════════════════════════════════════════════════════
-
-def submit_task(video_file) -> tuple:
-    """Kick off a new transcription task."""
+# ═══════════════════════════════════════════════════════════════════════════
+
+def submit_task(
+    video_file, mode, sensitivity, language, output_format,
+    scene_detector, speech_segmenter,
+    qwen_generator, qwen_model_id, qwen_mode,
+    transformers_backend, hf_model_id,
+) -> tuple:
     if video_file is None:
         return (
-            gr.update(value="Please upload a video or audio file first.", visible=True),
-            _render_monitor(),
-            _render_history(),
-            None,
-            _get_completed_filenames(),
+            gr.update(value="Please upload a video or audio file first."),
+            _render_monitor(), _render_history(), None, _get_completed_filenames(),
         )
 
     if not _semaphore.acquire(blocking=False):
         return (
-            gr.update(value="Another task is already processing.  Please wait for it to finish.", visible=True),
-            _render_monitor(),
-            _render_history(),
-            None,
-            _get_completed_filenames(),
+            gr.update(value="Another task is processing. Please wait."),
+            _render_monitor(), _render_history(), None, _get_completed_filenames(),
         )
 
     tid = uuid.uuid4().hex[:12]
 
-    # Gradio 4.x may return str, dict, or file-like object
     if isinstance(video_file, str):
         src_path = video_file
     elif isinstance(video_file, dict):
@@ -240,37 +399,52 @@ def submit_task(video_file) -> tuple:
     else:
         src_path = getattr(video_file, "name", "")
 
-        if not src_path or not os.path.isfile(src_path):
-            _semaphore.release()
-            return (
-                gr.update(value="Upload failed — could not read file path.", visible=True),
-                _render_monitor(),
-                _render_history(),
-                None,
-                _get_completed_filenames(),
-            )
+    if not src_path or not os.path.isfile(src_path):
+        _semaphore.release()
+        return (
+            gr.update(value="Upload failed — could not read file path."),
+            _render_monitor(), _render_history(), None, _get_completed_filenames(),
+        )
 
     fname = Path(src_path).name
 
-    # Warn if file is very large (>2 GB) — may cause OOM on free tier
     file_size_mb = os.path.getsize(src_path) / (1024 * 1024)
     size_warning = ""
     if file_size_mb > 2048:
-        size_warning = (
-            f"  (Warning: file is {file_size_mb:.0f} MB.  "
-            "Files >2 GB may fail on the 16 GB free tier.)"
-        )
+        size_warning = f"  (Warning: {file_size_mb:.0f} MB — may fail on 16 GB RAM)"
 
-    # Copy to persistent upload location so it survives Gradio tmpdir cleanup
     persistent = UPLOAD_DIR / f"{tid}_{fname}"
     shutil.copy2(src_path, persistent)
 
+    # Build config dict for the pipeline factory
+    config = {
+        "language": language,
+        "sensitivity": sensitivity,
+        "output_format": output_format,
+        "scene_detector": scene_detector,
+        "speech_segmenter": speech_segmenter,
+        "qwen_generator": qwen_generator,
+        "qwen_model_id": qwen_model_id or None,
+        "qwen_mode": qwen_mode,
+        "transformers_backend": transformers_backend,
+        "hf_model_id": hf_model_id,
+    }
+    # Remove None values
+    config = {k: v for k, v in config.items() if v is not None}
+
+    pipeline_label = mode
+    if mode == "qwen":
+        pipeline_label = f"qwen ({qwen_generator})"
+    elif mode == "transformers":
+        pipeline_label = f"transformers ({transformers_backend})"
+
     with _lock:
         _tasks[tid] = {
             "id": tid,
             "filename": fname,
             "status": "queued",
-            "pipeline": "ChronosJAV (anime-whisper)",
+            "pipeline": pipeline_label,
+            "config": config,
             "created_at": datetime.now(timezone.utc).isoformat(),
             "completed_at": "",
             "output_srt": "",
@@ -280,84 +454,62 @@ def submit_task(video_file) -> tuple:
         }
     _save()
 
-    threading.Thread(
-        target=_run_transcription,
-        args=(tid, str(persistent)),
-        daemon=True,
-    ).start()
+    threading.Thread(target=_run_transcription, args=(tid, str(persistent)), daemon=True).start()
 
     return (
-        gr.update(value=f"Submitted: {fname}  (ID: `{tid}`){size_warning}", visible=True),
-        _render_monitor(),
-        _render_history(),
-        None,
-        _get_completed_filenames(),
+        gr.update(value=f"Submitted: {fname}  (ID: `{tid}`){size_warning}"),
+        _render_monitor(), _render_history(), None, _get_completed_filenames(),
     )
 
 
-# ── HTML renderers ────────────────────────────────────────────────────
+# ── HTML renderers ────────────────────────────────────────────────────────
 
 _STATUS_COLORS = {
-    "queued":      "#f0ad4e",
-    "running":     "#5bc0de",
-    "completed":   "#5cb85c",
-    "failed":      "#d9534f",
-    "interrupted": "#999",
+    "queued": "#f0ad4e", "running": "#5bc0de", "completed": "#5cb85c",
+    "failed": "#d9534f", "interrupted": "#999",
 }
 _STATUS_ICONS = {
-    "queued":      "⏱",  # ⏳
-    "running":     "🔄",  # 🔄
-    "completed":   "✅",  # ✅
-    "failed":      "❌",  # ❌
-    "interrupted": "⏸",  # ⏸
+    "queued": "⏱", "running": "🔄", "completed": "✅",
+    "failed": "❌", "interrupted": "⏸",
 }
 
-_CSS = """
-<style>
-.tr { font-family: 'SF Mono','Consolas',monospace; font-size: 12px; }
-.tr-card {
-    border: 1px solid #e0e0e0; margin: 4px 0; padding: 8px 12px;
-    border-radius: 6px; background: #fafafa;
-}
+_CSS = """<style>
+.tr { font-family:'SF Mono','Consolas',monospace; font-size:12px; }
+.tr-card { border:1px solid #e0e0e0; margin:4px 0; padding:8px 12px; border-radius:6px; background:#fafafa; }
 .tr-card .head { display:flex; justify-content:space-between; align-items:flex-start; }
-.tr-card .meta { color: #666; margin-top: 3px; font-size: 11px; }
-.tr-card .dl { margin-top: 6px; }
-.dl-btn {
-    display: inline-block; margin: 2px 4px 2px 0; padding: 2px 10px;
-    background: #28a745; color: #fff; text-decoration: none;
-    border-radius: 4px; font-size: 12px;
-}
-.dl-btn:hover { background: #218838; }
-.hist-table { width: 100%; border-collapse: collapse; font-size: 12px; }
-.hist-table th { background: #2c3e50; color: #fff; padding: 8px; text-align: left; }
-.hist-table td { padding: 6px 8px; border-bottom: 1px solid #ddd; }
-.hist-table tr:hover { background: #f0f0f0; }
-</style>
-"""
+.tr-card .meta { color:#666; margin-top:3px; font-size:11px; }
+.hist-table { width:100%; border-collapse:collapse; font-size:12px; }
+.hist-table th { background:#2c3e50; color:#fff; padding:8px; text-align:left; }
+.hist-table td { padding:6px 8px; border-bottom:1px solid #ddd; }
+.hist-table tr:hover { background:#f0f0f0; }
+</style>"""
 
 
 def _render_monitor() -> str:
-    """Return HTML for the real-time task monitor (all tasks, newest first)."""
     with _lock:
         items = list(_tasks.values())
     if not items:
         return _CSS + "<div style='text-align:center;padding:24px;color:#999;'>No tasks yet.  Upload a file to start.</div>"
-
     items.sort(key=lambda t: str(t.get("created_at", "")), reverse=True)
     html = _CSS + '<div class="tr">'
     for t in items[:40]:
         st = t.get("status", "unknown")
         color = _STATUS_COLORS.get(st, "#999")
         icon = _STATUS_ICONS.get(st, "?")
-        html += f"""
-        <div class="tr-card" style="border-left:4px solid {color};">
+        cfg = t.get("config", {})
+        extra = ""
+        if cfg.get("scene_detector") and cfg["scene_detector"] != "none":
+            extra += f" | scene: {cfg['scene_detector']}"
+        if cfg.get("speech_segmenter") and cfg["speech_segmenter"] != "none":
+            extra += f" | vad: {cfg['speech_segmenter']}"
+
+        html += f"""<div class="tr-card" style="border-left:4px solid {color};">
           <div class="head">
             <strong>{icon} {t.get('filename','?')[:55]}</strong>
             <span style="color:{color};font-weight:700;white-space:nowrap;">{st.upper()}</span>
           </div>
           <div class="meta">
-            ID: {t.get('id','?')} &nbsp;|&nbsp; {t.get('pipeline','')}
-            &nbsp;|&nbsp; {str(t.get('created_at',''))[:19]}
+            ID: {t.get('id','?')} | {t.get('pipeline','')}{extra} | {str(t.get('created_at',''))[:19]}
           </div>"""
         if st == "completed":
             html += f'<div class="meta" style="color:#28a745;">Completed in {t.get("duration_seconds",0)}s</div>'
@@ -365,94 +517,107 @@ def _render_monitor() -> str:
             err = str(t.get("error", ""))[:250].replace("<", "&lt;").replace(">", "&gt;")
             html += f'<div class="meta" style="color:#d9534f;">{err}</div>'
         html += "</div>"
-
     html += "</div>"
     return html
 
 
 def _render_history() -> str:
-    """Return an HTML table of completed tasks."""
     with _lock:
         completed = [t for t in _tasks.values() if t.get("status") == "completed"]
     if not completed:
         return _CSS + "<div style='text-align:center;padding:24px;color:#999;'>No completed tasks yet.</div>"
-
     completed.sort(key=lambda t: str(t.get("completed_at", "")), reverse=True)
     html = _CSS + '<table class="hist-table"><thead><tr>'
-    html += "<th>File</th><th>Duration</th><th>Completed</th>"
+    html += "<th>File</th><th>Pipeline</th><th>Duration</th><th>Completed</th>"
     html += "</tr></thead><tbody>"
-
     for t in completed[:MAX_OUTPUT_FILES]:
         ca = str(t.get("completed_at", ""))[:19]
-        html += f"<tr><td>{t.get('filename','')[:55]}</td><td>{t.get('duration_seconds',0)}s</td><td>{ca}</td></tr>"
-
+        html += f"<tr><td>{t.get('filename','')[:45]}</td><td>{t.get('pipeline','')}</td><td>{t.get('duration_seconds',0)}s</td><td>{ca}</td></tr>"
     html += "</tbody></table>"
     return html
 
 
 def _get_latest_srt() -> Optional[str]:
-    """Return the file path of the most recently completed task's SRT."""
     with _lock:
         completed = sorted(
             [t for t in _tasks.values() if t.get("status") == "completed"],
-            key=lambda t: str(t.get("completed_at", "")),
-            reverse=True,
+            key=lambda t: str(t.get("completed_at", "")), reverse=True,
         )
     if not completed:
         return None
     srt = completed[0].get("output_srt", "")
-    if srt and os.path.isfile(srt):
-        return srt
-    return None
+    return srt if (srt and os.path.isfile(srt)) else None
 
 
 def _get_task_file(task_filename: str) -> Optional[str]:
-    """Given a completed task's display name, return its SRT path."""
+    if not task_filename:
+        return None
     with _lock:
         for t in _tasks.values():
             if t.get("filename") == task_filename and t.get("status") == "completed":
                 srt = t.get("output_srt", "")
-                if srt and os.path.isfile(srt):
-                    return srt
+                return srt if (srt and os.path.isfile(srt)) else None
     return None
 
 
 def _get_completed_filenames() -> List[str]:
-    """Return list of completed task filenames for dropdown."""
     with _lock:
         completed = sorted(
             [t for t in _tasks.values() if t.get("status") == "completed"],
-            key=lambda t: str(t.get("completed_at", "")),
-            reverse=True,
+            key=lambda t: str(t.get("completed_at", "")), reverse=True,
         )
     return [t.get("filename", "?") for t in completed]
 
 
 def _auto_refresh() -> tuple:
-    """Called by Gradio's periodic timer to update all panels."""
     latest = _get_latest_srt()
+    return _render_monitor(), _render_history(), latest if latest else None, _get_completed_filenames()
+
+
+def _update_pipeline_info(mode: str) -> str:
+    return PIPELINE_INFO.get(mode, "")
+
+
+def _on_mode_change(mode: str) -> tuple:
+    """Show/hide advanced options based on selected pipeline mode."""
+    show_qwen = mode == "qwen"
+    show_transformers = mode == "transformers"
+    show_legacy = mode in ("balanced", "fidelity", "fast")
+    show_scene = mode != "faster"
+    show_vad = mode in ("balanced", "fidelity", "qwen", "anime")
+
     return (
-        _render_monitor(),
-        _render_history(),
-        latest if latest else None,
-        _get_completed_filenames(),
+        gr.update(visible=show_scene),
+        gr.update(visible=show_vad),
+        gr.update(visible=show_qwen),
+        gr.update(visible=show_transformers),
     )
 
 
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 # Gradio UI
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 
 _FOOTER = """
 <div style="position:fixed;bottom:0;left:0;right:0;padding:6px;
             background:#f8f8f8;text-align:center;font-size:11px;color:#888;
             border-top:1px solid #e0e0e0;">
     WhisperJAV &copy; <a href="https://github.com/meizhong986/WhisperJAV" target="_blank">meizhong986</a>
-    &nbsp;|&nbsp; ChronosJAV pipeline (anime-whisper) &nbsp;|&nbsp;
-    CPU-only &nbsp;|&nbsp; Free HuggingFace Space
+    &nbsp;|&nbsp; Full pipeline port &nbsp;|&nbsp; CPU-only &nbsp;|&nbsp; Free HuggingFace Space
 </div>
 """
 
+RECOMMENDATIONS = """
+| Content Type | Pipeline | Sensitivity |
+|---|---|---|
+| Anime / JAV Dialogue | **anime** | aggressive |
+| Drama / Dialogue Heavy | **balanced** | aggressive |
+| Group Scenes | **faster** | conservative |
+| Amateur / Homemade | **fast** | conservative |
+| ASMR / Whisper | **fidelity** | aggressive |
+| Maximum Accuracy | **qwen** | balanced |
+"""
+
 
 def build_ui() -> gr.Blocks:
     with gr.Blocks(
@@ -461,54 +626,147 @@ def build_ui() -> gr.Blocks:
         css="""
         footer { visibility: hidden }
         .app-footer { position: fixed; bottom: 0; left: 0; right: 0; z-index: 100; }
+        .info-box { padding: 10px; background: #f0f7ff; border-radius: 6px; font-size: 13px; margin-bottom: 8px; }
         """,
     ) as demo:
 
-        # ── Header ──
         gr.Markdown("""
         # WhisperJAV — Japanese Subtitle Generator
 
-        **ChronosJAV** pipeline with `litagin/anime-whisper` — a Whisper large-v3
-        fine-tuned on anime and JAV dialogue.  Runs entirely on **CPU** (free tier).
-        First request downloads the model (~3 GB) — please be patient.
-
-        ⏱️  Processing speed: roughly **30-60 min** per hour of video on CPU.
+        Complete port with **7 pipeline modes** powered by Whisper, Qwen3-ASR,
+        anime-whisper, Kotoba, and ChronosJAV.  Runs entirely on **CPU** (free tier).
+        First request downloads the model (~1–4 GB) — please be patient.
         """)
 
         with gr.Tabs():
-            # ── Tab 1: New Task ──────────────────────────────────────
+            # ── Tab 1: New Transcription ──────────────────────────────
             with gr.Tab("New Transcription"):
                 with gr.Row():
+                    # Left column: file upload + pipeline select
                     with gr.Column(scale=2):
                         upload = gr.File(
                             label="Upload Video or Audio",
                             file_types=["video", "audio"],
                             file_count="single",
                         )
-                        gr.Markdown(
-                            "**Supported**: MP4, MKV, AVI, MOV, WMV, FLV, WAV, MP3, FLAC, M4A\n\n"
-                            "**Pipeline**: ChronosJAV — Text generation + timestamp alignment.\n"
-                            "The anime-whisper model is tuned specifically for Japanese dialogue."
-                        )
-                        submit_btn = gr.Button(
-                            "Start Transcription",
-                            variant="primary",
-                            size="lg",
+
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                mode_select = gr.Dropdown(
+                                    label="Pipeline Mode",
+                                    choices=PIPELINE_MODES,
+                                    value="anime",
+                                    interactive=True,
+                                )
+                            with gr.Column(scale=1):
+                                sensitivity_select = gr.Dropdown(
+                                    label="Sensitivity",
+                                    choices=SENSITIVITY_OPTIONS,
+                                    value="balanced",
+                                    interactive=True,
+                                )
+
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                language_select = gr.Dropdown(
+                                    label="Language",
+                                    choices=LANGUAGE_OPTIONS,
+                                    value="Japanese",
+                                    interactive=True,
+                                )
+                            with gr.Column(scale=1):
+                                format_select = gr.Dropdown(
+                                    label="Output Format",
+                                    choices=OUTPUT_FORMATS,
+                                    value="srt",
+                                    interactive=True,
+                                )
+
+                        pipeline_info = gr.Markdown(
+                            PIPELINE_INFO["anime"],
+                            elem_classes=["info-box"],
                         )
 
+                    # Right column: status + downloads
                     with gr.Column(scale=1):
                         status = gr.Textbox(
                             label="Status",
                             value="Ready.  Upload a file to begin.",
                             interactive=False,
-                            lines=3,
+                            lines=2,
                         )
                         latest_download = gr.File(
                             label="Latest Subtitle",
                             interactive=False,
-                            visible=True,
                         )
 
+                # ── Advanced Options (collapsible) ────────────────────
+                with gr.Accordion("Advanced Options", open=False):
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            scene_detector_select = gr.Dropdown(
+                                label="Scene Detection",
+                                choices=SCENE_DETECTORS,
+                                value="semantic",
+                                interactive=True,
+                            )
+                        with gr.Column(scale=1):
+                            speech_segmenter_select = gr.Dropdown(
+                                label="Speech Segmenter (VAD)",
+                                choices=SPEECH_SEGMENTERS,
+                                value="whisperseg",
+                                interactive=True,
+                            )
+
+                    # Qwen-specific options
+                    with gr.Group(visible=False) as qwen_group:
+                        gr.Markdown("**Qwen Pipeline Options**")
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                qwen_generator_select = gr.Dropdown(
+                                    label="Generator Backend",
+                                    choices=QWEEN_GENERATORS,
+                                    value="qwen3",
+                                    interactive=True,
+                                )
+                            with gr.Column(scale=1):
+                                qwen_mode_select = gr.Dropdown(
+                                    label="Input Mode",
+                                    choices=QWEEN_MODES,
+                                    value="assembly",
+                                    interactive=True,
+                                )
+                        qwen_model_id_text = gr.Textbox(
+                            label="Model ID (leave blank for default)",
+                            placeholder="Qwen/Qwen3-ASR-1.7B",
+                            interactive=True,
+                        )
+
+                    # Transformers-specific options
+                    with gr.Group(visible=False) as transformers_group:
+                        gr.Markdown("**Transformers Pipeline Options**")
+                        with gr.Row():
+                            with gr.Column(scale=1):
+                                transformers_backend_select = gr.Dropdown(
+                                    label="ASR Backend",
+                                    choices=TRANSFORMERS_BACKENDS,
+                                    value="hf",
+                                    interactive=True,
+                                )
+                            with gr.Column(scale=1):
+                                hf_model_id_select = gr.Dropdown(
+                                    label="HF Model",
+                                    choices=TRANSFORMERS_MODELS,
+                                    value=TRANSFORMERS_MODELS[0],
+                                    interactive=True,
+                                    allow_custom_value=True,
+                                )
+
+                submit_btn = gr.Button("Start Transcription", variant="primary", size="lg")
+
+                gr.Markdown("---")
+                gr.Markdown("### Content-Specific Recommendations")
+                gr.Markdown(RECOMMENDATIONS)
                 gr.Markdown("---")
                 gr.Markdown("### Task Monitor  (auto-refreshes every 8 s)")
                 monitor_html = gr.HTML(value=_render_monitor())
@@ -517,27 +775,42 @@ def build_ui() -> gr.Blocks:
             with gr.Tab("Download History"):
                 gr.Markdown("Pick a completed task, then download its subtitle file.")
                 with gr.Row():
-                    with gr.Column(scale=1):
-                        hist_dropdown = gr.Dropdown(
-                            label="Select Completed Task",
-                            choices=_get_completed_filenames(),
-                            interactive=True,
-                        )
-                    with gr.Column(scale=1):
-                        hist_download = gr.File(
-                            label="Subtitle File",
-                            interactive=False,
-                        )
+                    hist_dropdown = gr.Dropdown(
+                        label="Select Completed Task",
+                        choices=_get_completed_filenames(),
+                        interactive=True,
+                    )
+                    hist_download = gr.File(label="Subtitle File", interactive=False)
                 gr.Markdown("---")
                 history_html = gr.HTML(value=_render_history())
 
         # ── Footer ──
         gr.HTML(_FOOTER, elem_classes=["app-footer"])
 
-        # ── Events ──
+        # ══════════════════════════════════════════════════════════════
+        # Events
+        # ══════════════════════════════════════════════════════════════
+
+        mode_select.change(
+            fn=_update_pipeline_info,
+            inputs=[mode_select],
+            outputs=[pipeline_info],
+        )
+
+        mode_select.change(
+            fn=_on_mode_change,
+            inputs=[mode_select],
+            outputs=[scene_detector_select, speech_segmenter_select, qwen_group, transformers_group],
+        )
+
         submit_btn.click(
             fn=submit_task,
-            inputs=[upload],
+            inputs=[
+                upload, mode_select, sensitivity_select, language_select, format_select,
+                scene_detector_select, speech_segmenter_select,
+                qwen_generator_select, qwen_model_id_text, qwen_mode_select,
+                transformers_backend_select, hf_model_id_select,
+            ],
             outputs=[status, monitor_html, history_html, latest_download, hist_dropdown],
         )
 
@@ -547,23 +820,19 @@ def build_ui() -> gr.Blocks:
             outputs=[hist_download],
         )
 
-        # Auto-refresh every 8 seconds (Gradio 5.x Timer API)
         timer = gr.Timer(8, active=True)
         timer.tick(fn=_auto_refresh, outputs=[monitor_html, history_html, latest_download, hist_dropdown])
 
     return demo
 
 
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 # Entry Point
-# ═══════════════════════════════════════════════════════════════════════
+# ═══════════════════════════════════════════════════════════════════════════
 
 if __name__ == "__main__":
     _load()
     _prune_old_outputs()
 
     app = build_ui()
-    app.queue(
-        max_size=10,
-        default_concurrency_limit=5,
-    ).launch()
+    app.queue(max_size=10, default_concurrency_limit=5).launch()