Upload folder using huggingface_hub

source/qwen_app/__init__.py

@@ -0,0 +1,18 @@
+# qwen_app/__init__.py
+"""
+Lazy __init__ — chỉ expose build_ui khi được gọi trực tiếp.
+Import bất kỳ submodule nào (model_manager, omni_engine...) sẽ KHÔNG kéo gradio.
+"""
+import os
+
+# Vĩnh viễn ép hệ thống dùng thư mục _Qwen_Models_Cache cài sẵn nội bộ
+_proj_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_cache_dir = os.path.join(_proj_root, "_Qwen_Models_Cache")
+os.environ["HF_HOME"] = _cache_dir
+os.makedirs(_cache_dir, exist_ok=True)
+os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")
+
+def build_ui():
+    """Lazy import — chỉ load ui.py (và gradio) khi thực sự gọi build_ui()."""
+    from .ui import build_ui as _build_ui
+    return _build_ui()

source/qwen_app/audio_validator.py

@@ -0,0 +1,522 @@
+# qwen_app/audio_validator.py
+"""
+Audio Integrity Validator — Bidirectional SRT ↔ Audio Cross-Reference
+
+Vai trò TRUNG GIAN:
+  1. Parse SRT → list các entry (idx, start, end, text)
+  2. Phân tích energy audio theo từng window
+  3. Đối chiếu 2 chiều:
+       SRT → Audio : mỗi dòng SRT có audio energy không?  (MISSING_AUDIO)
+       Audio → SRT : mỗi vùng audio có SRT entry không?  (UNMATCHED_AUDIO)
+  4. Báo cáo chi tiết + severity rating
+  5. Fallback suggestions: tự động đề xuất re-generate chunk nào bị lỗi
+
+Sử dụng: soundfile (đã có) + numpy, không cần librosa.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+import subprocess
+import tempfile
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import List, Tuple, Optional
+
+import numpy as np
+
+# ─── Constants ────────────────────────────────────────────────────────────────
+ENERGY_WINDOW_MS         = 50      # ms per energy window
+SILENCE_THRESHOLD_RMS    = 0.003   # below this = silent
+MIN_SPEECH_COVERAGE      = 0.25    # ≥25% windows must be non-silent
+EDGE_TOLERANCE_MS        = 150     # ms to trim from start/end of each SRT window (codec delay)
+MAX_CHUNK_RETRIES        = 2       # max retries per chunk before giving up
+ORPHAN_MIN_DURATION_S    = 0.50    # min orphan region to flag (was 0.30 → caused false positives)
+ORPHAN_CONSEC_WINDOWS    = 3       # consecutive non-silent windows required to start an orphan region
+
+
+def check_array_energy(arr: "np.ndarray", sr: int = 24000, threshold: float = SILENCE_THRESHOLD_RMS) -> float:
+    """
+    Fast inline check: returns RMS of the array (no file I/O).
+    Returns 0.0 for empty/None. Use to decide if a chunk needs retry.
+    Compare result against SILENCE_THRESHOLD_RMS.
+    """
+    if arr is None or len(arr) == 0:
+        return 0.0
+    return float(np.sqrt(np.mean(arr.astype(np.float32) ** 2)))
+
+
+
+# ─── Data classes ─────────────────────────────────────────────────────────────
+@dataclass
+class SRTEntry:
+    idx:   int
+    start: float   # seconds
+    end:   float   # seconds
+    text:  str
+
+
+@dataclass
+class ChunkIssue:
+    chunk_idx:   int
+    chunk_text:  str
+    issue_type:  str   # "MISSING_AUDIO" | "LOW_ENERGY" | "UNMATCHED_AUDIO" | "SRT_OVERFLOW"
+    severity:    str   # "CRITICAL" | "WARNING" | "INFO"
+    detail:      str
+    suggested_action: str
+
+
+@dataclass
+class ValidationReport:
+    audio_path:      str
+    srt_path:        str
+    audio_duration:  float
+    srt_total_entries: int
+    issues:          List[ChunkIssue] = field(default_factory=list)
+    passed_entries:  int = 0
+    missing_audio:   int = 0
+    low_energy:      int = 0
+    unmatched_audio: int = 0
+    srt_overflow:    int = 0
+    overall_status:  str = "UNKNOWN"   # "PASS" | "WARN" | "FAIL"
+
+    @property
+    def total_issues(self) -> int:
+        return len(self.issues)
+
+    @property
+    def critical_count(self) -> int:
+        return sum(1 for i in self.issues if i.severity == "CRITICAL")
+
+
+# ─── SRT Parser ───────────────────────────────────────────────────────────────
+def parse_srt(srt_path: str) -> List[SRTEntry]:
+    """Parse SRT file → list of SRTEntry with float timestamps."""
+    entries: List[SRTEntry] = []
+    if not os.path.exists(srt_path):
+        return entries
+
+    with open(srt_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    blocks = re.split(r"\n\s*\n", content.strip())
+    for block in blocks:
+        lines = [l.strip() for l in block.strip().splitlines() if l.strip()]
+        if len(lines) < 3:
+            continue
+        try:
+            idx = int(lines[0])
+        except ValueError:
+            continue
+        m = re.match(
+            r"(\d{2}):(\d{2}):(\d{2})[,.](\d{3})\s*-->\s*(\d{2}):(\d{2}):(\d{2})[,.](\d{3})",
+            lines[1]
+        )
+        if not m:
+            continue
+        h1, m1, s1, ms1, h2, m2, s2, ms2 = [int(x) for x in m.groups()]
+        start = h1 * 3600 + m1 * 60 + s1 + ms1 / 1000.0
+        end   = h2 * 3600 + m2 * 60 + s2 + ms2 / 1000.0
+        text  = " ".join(lines[2:])
+        entries.append(SRTEntry(idx=idx, start=start, end=end, text=text))
+
+    return entries
+
+
+# ─── Audio Energy Analyzer ────────────────────────────────────────────────────
+def _load_audio_as_mono(audio_path: str) -> Tuple[np.ndarray, int]:
+    """
+    Load audio file into mono float32 array.
+    Supports WAV natively via soundfile. For MP3, decode via FFmpeg → temp WAV.
+    """
+    import soundfile as sf
+
+    ext = os.path.splitext(audio_path)[-1].lower()
+    if ext in (".wav", ".flac", ".ogg"):
+        data, sr = sf.read(audio_path, dtype="float32", always_2d=False)
+    else:
+        # MP3 / AAC / M4A — decode through FFmpeg
+        tmp = os.path.join(tempfile.gettempdir(), f"val_{uuid.uuid4().hex}.wav")
+        try:
+            ff_flags = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+            cmd = [
+                "ffmpeg", "-y", "-i", audio_path,
+                "-ac", "1", "-ar", "24000",
+                "-c:a", "pcm_f32le",
+                "-loglevel", "error", tmp
+            ]
+            if ff_flags:
+                subprocess.run(cmd, check=True, creationflags=ff_flags)
+            else:
+                subprocess.run(cmd, check=True)
+            data, sr = sf.read(tmp, dtype="float32", always_2d=False)
+        finally:
+            if os.path.exists(tmp):
+                try:
+                    os.remove(tmp)
+                except Exception:
+                    pass
+
+    # Stereo → mono
+    if data.ndim == 2:
+        data = data.mean(axis=1)
+    return data, int(sr)
+
+
+def compute_rms_windows(
+    data: np.ndarray, sr: int, window_ms: int = ENERGY_WINDOW_MS
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Compute RMS energy per window.
+    Returns:
+        times   : center time of each window (seconds)
+        rms_arr : RMS value of each window
+    """
+    hop = max(1, int(sr * window_ms / 1000))
+    n_windows = max(1, len(data) // hop)
+    times = np.arange(n_windows) * (hop / sr) + (hop / sr) / 2
+    rms = np.array([
+        np.sqrt(np.mean(data[i * hop: i * hop + hop] ** 2))
+        for i in range(n_windows)
+    ], dtype=np.float32)
+    return times, rms
+
+
+def _coverage_in_range(
+    times: np.ndarray,
+    rms: np.ndarray,
+    start: float,
+    end: float,
+    threshold: float = SILENCE_THRESHOLD_RMS,
+    edge_tol: float = EDGE_TOLERANCE_MS / 1000.0,
+) -> float:
+    """
+    Return fraction of non-silent windows within [start+edge, end-edge].
+    """
+    s = start + edge_tol
+    e = end   - edge_tol
+    if e <= s:
+        s, e = start, end  # fallback when window is very narrow
+    mask = (times >= s) & (times <= e)
+    if not mask.any():
+        return 0.0
+    return float(np.mean(rms[mask] > threshold))
+
+
+# ─── Core Validation Logic ────────────────────────────────────────────────────
+def validate_audio_vs_srt(
+    audio_path: str,
+    srt_path: str,
+    energy_threshold: float = SILENCE_THRESHOLD_RMS,
+    min_coverage: float = MIN_SPEECH_COVERAGE,
+    warn_multitrack_srt: bool = True,
+) -> ValidationReport:
+    """
+    Bidirectional audio-SRT validation.
+    FIX #6+#7: Improved orphan detection (500ms min, 3-consecutive-window rule).
+    FIX: warn when SRT appears to be a multi-phase FULL_MASTER used on single-phase audio.
+
+    Pass 1 (SRT -> Audio): each SRT entry must have >= min_coverage non-silent windows.
+    Pass 2 (Audio -> SRT): significant audio regions must map to at least one SRT entry.
+
+    Returns ValidationReport with full issue list.
+    """
+    report = ValidationReport(
+        audio_path=audio_path,
+        srt_path=srt_path,
+        audio_duration=0.0,
+        srt_total_entries=0,
+    )
+
+    # ── Load audio
+    try:
+        data, sr = _load_audio_as_mono(audio_path)
+    except Exception as e:
+        report.issues.append(ChunkIssue(
+            chunk_idx=0, chunk_text="",
+            issue_type="MISSING_AUDIO", severity="CRITICAL",
+            detail=f"Cannot load audio file: {e}",
+            suggested_action="Check FFmpeg is installed and audio file is not corrupted.",
+        ))
+        report.overall_status = "FAIL"
+        return report
+
+    report.audio_duration = len(data) / sr
+
+    # ── Parse SRT
+    entries = parse_srt(srt_path)
+    report.srt_total_entries = len(entries)
+    if not entries:
+        report.issues.append(ChunkIssue(
+            chunk_idx=0, chunk_text="",
+            issue_type="SRT_OVERFLOW", severity="CRITICAL",
+            detail="SRT file is empty or could not be parsed.",
+            suggested_action="Re-generate audio and SRT for this file.",
+        ))
+        report.overall_status = "FAIL"
+        return report
+
+    # Check SRT doesn't extend beyond audio
+    last_srt_end = max(e.end for e in entries)
+    overflow_delta = last_srt_end - report.audio_duration
+
+    # FIX: Detect when FULL_MASTER.srt (multi-phase) is passed for a single-phase audio
+    if warn_multitrack_srt and overflow_delta > 5.0:
+        report.issues.append(ChunkIssue(
+            chunk_idx=-1, chunk_text="",
+            issue_type="SRT_OVERFLOW", severity="WARNING",
+            detail=(
+                f"SRT ends at {last_srt_end:.2f}s but audio is only {report.audio_duration:.2f}s "
+                f"(Δ={overflow_delta:.1f}s). This SRT may be a multi-phase FULL_MASTER.srt "
+                f"— use per-phase SRTs for accurate validation."
+            ),
+            suggested_action="Pass per-phase SRT (not FULL_MASTER.srt) to validate_audio_vs_srt().",
+        ))
+        report.srt_overflow += 1
+        # Do NOT run per-entry validation — it will all be false positives
+        report.overall_status = "WARN"
+        return report
+    elif overflow_delta > 0.5:
+        report.issues.append(ChunkIssue(
+            chunk_idx=len(entries), chunk_text=entries[-1].text,
+            issue_type="SRT_OVERFLOW", severity="CRITICAL",
+            detail=(
+                f"SRT ends at {last_srt_end:.2f}s but audio is only {report.audio_duration:.2f}s. "
+                f"Δ={overflow_delta:.2f}s overflow."
+            ),
+            suggested_action=(
+                "Speed factor may be too high — SRT timestamps computed with wrong speed. "
+                "Re-generate with corrected timing."
+            ),
+        ))
+        report.srt_overflow += 1
+
+    # ── Compute energy windows
+    times, rms = compute_rms_windows(data, sr)
+
+    # ── Pass 1: SRT → Audio
+    for entry in entries:
+        coverage = _coverage_in_range(times, rms, entry.start, entry.end, energy_threshold)
+        
+        # FIX: Timing drift for short sentences (they merge with adjacent or fall into pauses)
+        if coverage < min_coverage and (entry.end - entry.start) < 2.5:
+            drift_tol = 1.0  # Expand search window by +/- 1.0 second
+            s_exp = max(0.0, entry.start - drift_tol)
+            e_exp = min(report.audio_duration, entry.end + drift_tol)
+            mask_exp = (times >= s_exp) & (times <= e_exp)
+            if mask_exp.any():
+                # If there are at least 3 active windows (150ms) nearby, assume it merged or drifted.
+                if np.sum(rms[mask_exp] > energy_threshold) >= 3:
+                    coverage = min_coverage
+
+        if coverage < min_coverage:
+            if coverage < 0.05:
+                sev = "CRITICAL"
+                itype = "MISSING_AUDIO"
+                action = (
+                    f"Chunk {entry.idx} ('{entry.text[:60]}…') produced near-zero audio. "
+                    "Likely a model inference failure — re-generate this chunk."
+                )
+            else:
+                sev = "WARNING"
+                itype = "LOW_ENERGY"
+                action = (
+                    f"Chunk {entry.idx} has partial audio. "
+                    "Check if FFmpeg atempo clipped this segment. "
+                    "Try lowering speed or increasing max_new_tokens."
+                )
+            report.issues.append(ChunkIssue(
+                chunk_idx=entry.idx,
+                chunk_text=entry.text,
+                issue_type=itype,
+                severity=sev,
+                detail=(
+                    f"SRT [{entry.start:.2f}s → {entry.end:.2f}s] "
+                    f"energy coverage={coverage:.0%} (threshold={min_coverage:.0%})"
+                ),
+                suggested_action=action,
+            ))
+            if itype == "MISSING_AUDIO":
+                report.missing_audio += 1
+            else:
+                report.low_energy += 1
+        else:
+            report.passed_entries += 1
+
+    # ── Pass 2: Audio → SRT  (detect orphaned audio)
+    # Build a mask of SRT-covered samples
+    n_samples = len(data)
+    covered = np.zeros(n_samples, dtype=bool)
+    for entry in entries:
+        i_start = max(0, int(entry.start * sr))
+        i_end   = min(n_samples, int(entry.end * sr))
+        covered[i_start:i_end] = True
+
+    # Find continuous uncovered regions with significant energy
+    # FIX #6: require ORPHAN_CONSEC_WINDOWS consecutive active windows + ORPHAN_MIN_DURATION_S
+    not_covered = ~covered
+    hop = max(1, int(sr * ENERGY_WINDOW_MS / 1000))
+    orphan_regions = []
+    in_orphan      = False
+    orphan_start   = 0.0
+    consec_count   = 0
+    n_check        = n_samples // hop
+
+    for i in range(n_check):
+        seg_start = i * hop
+        seg_end   = min(n_samples, seg_start + hop)
+        seg_rms   = float(np.sqrt(np.mean(data[seg_start:seg_end] ** 2)))
+        seg_uncov = not_covered[seg_start:seg_end].all()
+        t_start   = seg_start / sr
+
+        if seg_uncov and seg_rms > energy_threshold:
+            consec_count += 1
+            if not in_orphan and consec_count >= ORPHAN_CONSEC_WINDOWS:
+                in_orphan    = True
+                orphan_start = t_start - (ORPHAN_CONSEC_WINDOWS - 1) * (hop / sr)
+        else:
+            if in_orphan:
+                orphan_end = t_start
+                if orphan_end - orphan_start >= ORPHAN_MIN_DURATION_S:
+                    orphan_regions.append((orphan_start, orphan_end))
+            in_orphan    = False
+            consec_count = 0
+
+    for (os_, oe_) in orphan_regions:
+        report.issues.append(ChunkIssue(
+            chunk_idx=-1,
+            chunk_text="",
+            issue_type="UNMATCHED_AUDIO",
+            severity="WARNING",
+            detail=(
+                f"Audio has speech at [{os_:.2f}s → {oe_:.2f}s] "
+                f"({oe_-os_:.2f}s) with no SRT entry covering it."
+            ),
+            suggested_action=(
+                "SRT timing might be shifted. Check global_cursor accumulation logic "
+                "and verify speed-scaling is applied consistently."
+            ),
+        ))
+        report.unmatched_audio += 1
+
+    # ── Overall status
+    if report.critical_count > 0 or report.srt_overflow > 0:
+        report.overall_status = "FAIL"
+    elif report.total_issues > 0:
+        report.overall_status = "WARN"
+    else:
+        report.overall_status = "PASS"
+
+    return report
+
+
+# ─── Batch Folder Validation ──────────────────────────────────────────────────
+def validate_batch_output(
+    out_dir: str,
+    master_srt: Optional[str] = None,
+) -> List[ValidationReport]:
+    """
+    Scan out_dir for all (*.mp3, matching *.srt OR FULL_MASTER.srt) pairs.
+    Returns list of ValidationReport, one per audio file found.
+    """
+    reports: List[ValidationReport] = []
+    if not os.path.isdir(out_dir):
+        return reports
+
+    # Try FULL_MASTER.srt for mode3_news structure
+    full_master = master_srt or os.path.join(out_dir, "FULL_MASTER.srt")
+    has_master = os.path.exists(full_master)
+
+    mp3_files = sorted(f for f in os.listdir(out_dir) if f.lower().endswith(".mp3"))
+
+    for mp3 in mp3_files:
+        mp3_path = os.path.join(out_dir, mp3)
+        # Prefer per-file SRT, fall back to FULL_MASTER.srt
+        srt_candidate = os.path.join(out_dir, os.path.splitext(mp3)[0] + ".srt")
+        if os.path.exists(srt_candidate):
+            srt_path = srt_candidate
+        elif has_master:
+            srt_path = full_master
+        else:
+            reports.append(ValidationReport(
+                audio_path=mp3_path, srt_path="(MISSING)",
+                audio_duration=0.0, srt_total_entries=0,
+                issues=[ChunkIssue(
+                    chunk_idx=0, chunk_text="",
+                    issue_type="MISSING_AUDIO", severity="CRITICAL",
+                    detail=f"No SRT file found for {mp3}",
+                    suggested_action="Re-run batch generation to recreate SRT.",
+                )],
+                overall_status="FAIL",
+            ))
+            continue
+        reports.append(validate_audio_vs_srt(mp3_path, srt_path))
+
+    return reports
+
+
+# ─── Report Formatter ─────────────────────────────────────────────────────────
+def format_validation_report(report: ValidationReport) -> str:
+    """Render a ValidationReport as human-readable log text."""
+    lines = []
+    ts = datetime.now().strftime("%H:%M:%S")
+    status_icon = {"PASS": "✅", "WARN": "⚠️", "FAIL": "❌", "UNKNOWN": "❓"}.get(report.overall_status, "❓")
+
+    lines.append(f"[{ts}] {status_icon} STATUS: {report.overall_status}")
+    lines.append(f"  Audio  : {os.path.basename(report.audio_path)}  ({report.audio_duration:.2f}s)")
+    lines.append(f"  SRT    : {os.path.basename(report.srt_path)}  ({report.srt_total_entries} entries)")
+    lines.append(f"  Passed : {report.passed_entries}/{report.srt_total_entries}")
+
+    if report.missing_audio:
+        lines.append(f"  ❌ MISSING AUDIO  : {report.missing_audio} chunk(s) — SILENT where speech expected")
+    if report.low_energy:
+        lines.append(f"  ⚠️  LOW ENERGY     : {report.low_energy} chunk(s) — partial audio detected")
+    if report.unmatched_audio:
+        lines.append(f"  ⚠️  UNMATCHED AUDIO: {report.unmatched_audio} region(s) — speech with no SRT entry")
+    if report.srt_overflow:
+        lines.append(f"  ❌ SRT OVERFLOW   : SRT timestamps exceed audio duration")
+
+    if report.issues:
+        lines.append("\n  ── Issue Detail ─────────────────────────────")
+        for iss in report.issues:
+            icon = "❌" if iss.severity == "CRITICAL" else "⚠️"
+            lines.append(f"  {icon} [{iss.issue_type}] chunk#{iss.chunk_idx}")
+            if iss.chunk_text:
+                preview = iss.chunk_text[:80] + ("…" if len(iss.chunk_text) > 80 else "")
+                lines.append(f"     Text   : {preview}")
+            lines.append(f"     Detail : {iss.detail}")
+            lines.append(f"     Fix    : {iss.suggested_action}")
+    else:
+        lines.append("  🎉 All SRT entries verified — audio is complete and intact.")
+
+    return "\n".join(lines)
+
+
+# ─── Batch Report Formatter ───────────────────────────────────────────────────
+def format_batch_reports(reports: List[ValidationReport]) -> str:
+    """Render a list of ValidationReports as a summary log."""
+    if not reports:
+        return "⚠️ No audio files found to validate."
+
+    total = len(reports)
+    passed = sum(1 for r in reports if r.overall_status == "PASS")
+    warned = sum(1 for r in reports if r.overall_status == "WARN")
+    failed = sum(1 for r in reports if r.overall_status == "FAIL")
+
+    ts = datetime.now().strftime("%H:%M:%S")
+    lines = [
+        f"[{ts}] 🔍 VALIDATION COMPLETE",
+        f"  Total  : {total} file(s)",
+        f"  ✅ PASS : {passed}",
+        f"  ⚠️  WARN : {warned}",
+        f"  ❌ FAIL : {failed}",
+        "",
+    ]
+    for r in reports:
+        lines.append(format_validation_report(r))
+        lines.append("")
+
+    return "\n".join(lines)

source/qwen_app/config.py

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+import gradio as gr
+THEME = gr.themes.Soft(font=[gr.themes.GoogleFont("Source Sans Pro"), "Arial", "sans-serif"])
+
+LANGUAGES = [
+    "Auto",
+    "Chinese",
+    "English",
+    "Japanese",
+    "Korean",
+    "French",
+    "German",
+    "Spanish",
+    "Portuguese",
+    "Russian",
+]
+SPEAKERS = ["Aiden", "Dylan", "Eric", "Ono_anna", "Ryan", "Serena", "Sohee", "Uncle_fu", "Vivian"]
+
+VOICE_LIB_DIR = Path("voice_library")
+VOICE_DB_PATH = VOICE_LIB_DIR / "voices.json"
+VOICE_AUDIO_DIR = VOICE_LIB_DIR / "audio"

source/qwen_app/downloader.py

@@ -0,0 +1,45 @@
+import os
+import gradio as gr
+from huggingface_hub import snapshot_download
+from datetime import datetime
+
+def ts():
+    return datetime.now().strftime("%H:%M:%S")
+
+MODELS_TO_CACHE = [
+    {"repo_id": "Qwen/Qwen3-TTS-12Hz-0.6B-Base", "allow_patterns": ["*.safetensors", "*.json", "*.txt"]},
+    {"repo_id": "Qwen/Qwen3-TTS-12Hz-1.7B-Base", "allow_patterns": ["*.safetensors", "*.json", "*.txt"]},
+    {"repo_id": "Qwen/Qwen3-TTS-12Hz-0.6B-CustomVoice", "allow_patterns": ["*.safetensors", "*.json", "*.txt"]},
+    {"repo_id": "Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice", "allow_patterns": ["*.safetensors", "*.json", "*.txt"]},
+    {"repo_id": "hynt/F5-TTS-Vietnamese-ViVoice", "allow_patterns": ["model_last.pt"]},
+    {"repo_id": "charactr/vocos-mel-24khz", "allow_patterns": ["pytorch_model.bin", "config.yaml"]},
+]
+
+def download_all_models(progress=gr.Progress()):
+    log = f"[{ts()}] 🚀 BẮT ĐẦU KIỂM TRA & TẢI MODELS OFFLINE...\n"
+    cache_dir = os.environ.get("HF_HOME", "Cache mặc định")
+    log += f"[{ts()}] 📂 Thư mục lưu trữ: {cache_dir}\n"
+    log += f"[{ts()}] (Lưu ý: Quá trình này có thể tốn vài phút tùy tốc độ mạng)\n\n"
+    yield log
+
+    total = len(MODELS_TO_CACHE)
+    for i, item in enumerate(MODELS_TO_CACHE):
+        repo_id = item["repo_id"]
+        patterns = item["allow_patterns"]
+        progress((i, total), desc=f"Đang xử lý {repo_id}...")
+        log += f"[{ts()}] ⏳ Kiểm tra/Tải {repo_id}...\n"
+        yield log
+
+        try:
+            path = snapshot_download(repo_id, allow_patterns=patterns, local_dir_use_symlinks=False)
+            log += f"[{ts()}] ✅ HOÀN TẤT {repo_id}\n    └─ Path: {path}\n\n"
+            yield log
+        except Exception as e:
+            log += f"[{ts()}] ❌ LỖI KHI TẢI {repo_id}: {str(e)}\n\n"
+            yield log
+
+    progress((total, total), desc="DONE")
+    log += f"[{ts()}] 🎉 ĐÃ CÀI ĐẶT TOÀN BỘ MODELS XONG!\n"
+    log += f"Hệ thống đã sẵn sàng chạy Offline 100% tại máy mà không cần tải lại.\n"
+    yield log
+

source/qwen_app/generation.py

@@ -0,0 +1,438 @@
+import re
+import os
+import sys
+import time
+import uuid
+import tempfile
+import subprocess
+from typing import Dict, List
+
+import numpy as np
+import soundfile as sf
+
+import gradio as gr
+import spaces
+
+from .model_manager import model_manager
+from .voice_library import normalize_audio, resolve_reference_details, set_seed
+from .prosody import PauseConfig, DEFAULT_PAUSE, make_silence, detect_pause_ms
+
+
+def decode_params(seed, temperature, top_p, repetition_penalty, max_new_tokens) -> Dict:
+    set_seed(int(seed or 0))
+    return dict(
+        do_sample=True,
+        temperature=float(temperature),
+        top_k=50,
+        top_p=float(top_p),
+        repetition_penalty=float(repetition_penalty),
+        max_new_tokens=int(max_new_tokens),
+    )
+
+
+def _is_faster_backend(model) -> bool:
+    return model.__class__.__name__ == "FasterQwen3TTS"
+
+
+def smart_chunk_text(text: str, max_words: int = 40) -> List[str]:
+    """Split long text into sentence-aware chunks for more stable generation."""
+    clean = (text or "").strip()
+    if not clean:
+        return []
+
+    def has_cjk(value: str) -> bool:
+        return bool(re.search(r"[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]", value))
+
+    is_cjk = has_cjk(clean)
+    sentence_pattern = r"(?<=[.!?。！？।؟])(?![.!?。！？।؟])\s*|\n+"
+    sentences = [s.strip() for s in re.split(sentence_pattern, clean) if s.strip()]
+
+    chunks: List[str] = []
+    current_chunk: List[str] = []
+    current_count = 0
+
+    for sentence in sentences:
+        sentence_count = len(re.sub(r"\s+", "", sentence)) if is_cjk else len(sentence.split())
+
+        if current_count + sentence_count > max_words:
+            if current_chunk:
+                chunks.append("".join(current_chunk) if is_cjk else " ".join(current_chunk))
+                current_chunk = []
+                current_count = 0
+
+            if sentence_count > max_words:
+                parts = [p.strip() for p in re.split(r"[,;،、；،]\s*", sentence) if p.strip()]
+                for part in parts:
+                    part_count = len(re.sub(r"\s+", "", part)) if is_cjk else len(part.split())
+                    if current_count + part_count > max_words and current_chunk:
+                        chunks.append("".join(current_chunk) if is_cjk else " ".join(current_chunk))
+                        current_chunk = [part]
+                        current_count = part_count
+                    else:
+                        current_chunk.append(part)
+                        current_count += part_count
+            else:
+                current_chunk.append(sentence)
+                current_count += sentence_count
+        else:
+            current_chunk.append(sentence)
+            current_count += sentence_count
+
+    if current_chunk:
+        chunks.append("".join(current_chunk) if is_cjk else " ".join(current_chunk))
+
+    return chunks if chunks else [clean]
+
+
+def _estimate_generation_time_seconds(text_length: int, chunks: int, model_size: str | None = None) -> float:
+    base = max(3.0, (text_length / 70.0) * 1.8)
+    chunk_overhead = max(0, chunks - 1) * 0.9
+    size_factor = 1.0 if model_size == "0.6B" else 1.25
+    return (base + chunk_overhead) * size_factor
+
+
+def _format_seconds(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    m = int(seconds // 60)
+    s = seconds % 60
+    return f"{m}m {s:.1f}s"
+
+
+def _elapsed_str(t0: float) -> str:
+    return _format_seconds(time.time() - t0)
+
+
+def _build_atempo_filter_chain(speed: float) -> List[str]:
+    """
+    Build a safe FFmpeg atempo filter chain for any speed value.
+
+    FFmpeg atempo only accepts values in [0.5, 2.0]. For values outside
+    this range we chain multiple filters:
+      speed=0.3  → ["atempo=0.5", "atempo=0.6"]
+      speed=3.0  → ["atempo=2.0", "atempo=1.5"]
+      speed=0.8  → ["atempo=0.800000"]
+
+    Returns empty list if speed is effectively 1.0 (no-op).
+    """
+    if abs(speed - 1.0) < 0.01:
+        return []
+    filters: List[str] = []
+    s = float(speed)
+    while s > 2.0:
+        filters.append("atempo=2.0")
+        s /= 2.0
+    while s < 0.5:
+        filters.append("atempo=0.5")
+        s *= 2.0
+    filters.append(f"atempo={s:.6f}")
+    return filters
+
+
+def apply_speed_post_process(audio_tuple, speed: float):
+    """
+    Apply FFmpeg atempo speed change AFTER model inference — never before.
+    Input:  (sample_rate, np.ndarray float32)
+    Output: (sample_rate, np.ndarray float32) at new speed.
+
+    - Speed 1.0 → no-op, returns original immediately.
+    - Chains atempo filters for values outside [0.5, 2.0].
+    - Preserves pitch (atempo = pitch-preserving time-stretch).
+    - Falls back to original audio if FFmpeg fails.
+    """
+    if audio_tuple is None:
+        return None
+    sr, data = audio_tuple
+    if data is None or len(data) == 0:
+        return audio_tuple
+    if abs(speed - 1.0) < 0.01:
+        return audio_tuple  # Skip FFmpeg entirely
+
+    tmp_dir = tempfile.gettempdir()
+    uid = uuid.uuid4().hex
+    tmp_in = os.path.join(tmp_dir, f"qwen_spd_in_{uid}.wav")
+    tmp_out = os.path.join(tmp_dir, f"qwen_spd_out_{uid}.wav")
+    try:
+        arr = data.astype(np.float32)
+        sf.write(tmp_in, arr, sr)
+
+        filters = _build_atempo_filter_chain(speed)
+        cmd = [
+            "ffmpeg", "-y", "-i", tmp_in,
+            "-filter:a", ",".join(filters),
+            "-c:a", "pcm_f32le",
+            "-loglevel", "error",
+            tmp_out,
+        ]
+        ff_flags = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+        if ff_flags:
+            subprocess.run(cmd, check=True, creationflags=ff_flags)
+        else:
+            subprocess.run(cmd, check=True)
+
+        result, out_sr = sf.read(tmp_out, dtype="float32")
+        return (out_sr, result)
+    except Exception:
+        return audio_tuple  # Graceful fallback
+    finally:
+        for f in [tmp_in, tmp_out]:
+            if os.path.exists(f):
+                try:
+                    os.remove(f)
+                except Exception:
+                    pass
+
+
+# ─── Core generation functions ────────────────────────────────────────────────
+
+@spaces.GPU(duration=120)
+def generate_voice_design(text, language, voice_description, seed, temperature, top_p, repetition_penalty, max_new_tokens, speed=1.0, pause_config: PauseConfig | None = None, progress=gr.Progress(track_tqdm=True)):
+    cfg = pause_config or DEFAULT_PAUSE
+    try:
+        t0 = time.time()
+        if not text or not text.strip():
+            yield 0, None, "Error: text is required."
+            return
+        if not voice_description or not voice_description.strip():
+            yield 0, None, "Error: voice description is required."
+            return
+
+        yield 10, None, "Loading VoiceDesign 1.7B..."
+        progress(0.15, desc="Loading model")
+        model, note = model_manager.get_model("VoiceDesign", "1.7B")
+        yield 35, None, note
+
+        chunks = smart_chunk_text(text.strip())
+        total_chunks = len(chunks)
+        estimated = _estimate_generation_time_seconds(len(text.strip()), total_chunks, model_size="1.7B")
+        kwargs = decode_params(seed, temperature, top_p, repetition_penalty, max_new_tokens)
+        generated_chunks = []
+        sr = None
+
+        completed_pct = 35
+        yield completed_pct, None, (
+            f"{note} | Chunks: {total_chunks} | Estimated: {_format_seconds(estimated)} | Elapsed: {_elapsed_str(t0)}"
+        )
+        for i, chunk in enumerate(chunks):
+            yield completed_pct, None, f"{note} | Running chunk {i+1}/{total_chunks} | Elapsed: {_elapsed_str(t0)}"
+            if _is_faster_backend(model):
+                wavs, sr = model.generate_voice_design(text=chunk, language=language, instruct=voice_description.strip(), **kwargs)
+            else:
+                wavs, sr = model.generate_voice_design(text=chunk, language=language, instruct=voice_description.strip(), non_streaming_mode=True, **kwargs)
+            if wavs and len(wavs) > 0:
+                generated_chunks.append(normalize_audio(wavs[0]))
+                generated_chunks.append(make_silence(detect_pause_ms(chunk, cfg)))
+                completed_pct = 35 + int(((i + 1) / total_chunks) * 55)
+                yield completed_pct, None, f"{note} | Completed chunk {i+1}/{total_chunks} | Elapsed: {_elapsed_str(t0)}"
+
+        if not generated_chunks or sr is None:
+            yield 0, None, "Error: no audio generated."
+            return
+
+        full_audio = np.concatenate(generated_chunks) if len(generated_chunks) > 1 else generated_chunks[0]
+        total_time = time.time() - t0
+        progress(1.0, desc=f"Done | Total {_format_seconds(total_time)}")
+        audio_out = apply_speed_post_process((sr, full_audio), speed)
+        speed_note = f" | Speed: {speed:.2f}x" if abs(speed - 1.0) >= 0.01 else ""
+        yield 100, audio_out, (
+            f"Voice design completed. Chunks: {total_chunks} | Estimated: {_format_seconds(estimated)} | Total: {_format_seconds(total_time)}{speed_note}"
+        )
+    except Exception as e:
+        yield 0, None, f"Error: {type(e).__name__}: {e}"
+
+
+@spaces.GPU(duration=120)
+def generate_base(model_size, selected_voice_name, ref_audio, ref_text, target_text, language, xvector_only, seed, temperature, top_p, repetition_penalty, max_new_tokens, speed=1.0, pause_config: PauseConfig | None = None, progress=gr.Progress(track_tqdm=True)):
+    cfg = pause_config or DEFAULT_PAUSE
+    try:
+        t0 = time.time()
+        if not target_text or not target_text.strip():
+            yield 0, None, "Error: target text is required."
+            return
+
+        resolved_audio, resolved_audio_path, resolved_ref_text, src_note = resolve_reference_details(
+            selected_voice_name, ref_audio, ref_text, xvector_only
+        )
+        if resolved_audio is None:
+            yield 0, None, src_note
+            return
+
+        yield 10, None, f"Loading Base {model_size}..."
+        progress(0.15, desc="Loading model")
+        model, note = model_manager.get_model("Base", model_size)
+        yield 35, None, f"{note} | {src_note}"
+
+        chunks = smart_chunk_text(target_text.strip())
+        total_chunks = len(chunks)
+        estimated = _estimate_generation_time_seconds(len(target_text.strip()), total_chunks, model_size=model_size)
+        kwargs = decode_params(seed, temperature, top_p, repetition_penalty, max_new_tokens)
+        generated_chunks = []
+        sr = None
+
+        completed_pct = 35
+        yield completed_pct, None, (
+            f"{note} | {src_note} | Chunks: {total_chunks} | Estimated: {_format_seconds(estimated)} | Elapsed: {_elapsed_str(t0)}"
+        )
+        for i, chunk in enumerate(chunks):
+            yield completed_pct, None, (
+                f"{note} | {src_note} | Running chunk {i+1}/{total_chunks} | Elapsed: {_elapsed_str(t0)}"
+            )
+            if _is_faster_backend(model):
+                ref_audio_for_call = resolved_audio_path if resolved_audio_path else resolved_audio
+                wavs, sr = model.generate_voice_clone(
+                    text=chunk, language=language,
+                    ref_audio=ref_audio_for_call, ref_text=resolved_ref_text or "",
+                    xvec_only=bool(xvector_only), non_streaming_mode=True, **kwargs,
+                )
+            else:
+                wavs, sr = model.generate_voice_clone(
+                    text=chunk, language=language,
+                    ref_audio=resolved_audio, ref_text=resolved_ref_text,
+                    x_vector_only_mode=bool(xvector_only), non_streaming_mode=True, **kwargs,
+                )
+            if wavs and len(wavs) > 0:
+                generated_chunks.append(normalize_audio(wavs[0]))
+                generated_chunks.append(make_silence(detect_pause_ms(chunk, cfg)))
+                completed_pct = 35 + int(((i + 1) / total_chunks) * 55)
+                yield completed_pct, None, (
+                    f"{note} | {src_note} | Completed chunk {i+1}/{total_chunks} | Elapsed: {_elapsed_str(t0)}"
+                )
+
+        if not generated_chunks or sr is None:
+            yield 0, None, "Error: no audio generated."
+            return
+
+        full_audio = np.concatenate(generated_chunks) if len(generated_chunks) > 1 else generated_chunks[0]
+        total_time = time.time() - t0
+        progress(1.0, desc=f"Done | Total {_format_seconds(total_time)}")
+        audio_out = apply_speed_post_process((sr, full_audio), speed)
+        speed_note = f" | Speed: {speed:.2f}x" if abs(speed - 1.0) >= 0.01 else ""
+        yield 100, audio_out, (
+            f"Base {model_size} generation completed. Chunks: {total_chunks} | Estimated: {_format_seconds(estimated)} | Total: {_format_seconds(total_time)}{speed_note}"
+        )
+    except Exception as e:
+        yield 0, None, f"Error: {type(e).__name__}: {e}"
+
+
+@spaces.GPU(duration=120)
+def generate_custom(model_size, text, language, speaker, instruct, seed, temperature, top_p, repetition_penalty, max_new_tokens, speed=1.0, pause_config: PauseConfig | None = None, progress=gr.Progress(track_tqdm=True)):
+    cfg = pause_config or DEFAULT_PAUSE
+    try:
+        t0 = time.time()
+        if not text or not text.strip():
+            yield 0, None, "Error: text is required."
+            return
+        if not speaker:
+            yield 0, None, "Error: speaker is required."
+            return
+
+        yield 10, None, f"Loading CustomVoice {model_size}..."
+        progress(0.15, desc="Loading model")
+        model, note = model_manager.get_model("CustomVoice", model_size)
+        yield 35, None, note
+
+        chunks = smart_chunk_text(text.strip())
+        total_chunks = len(chunks)
+        estimated = _estimate_generation_time_seconds(len(text.strip()), total_chunks, model_size=model_size)
+        kwargs = decode_params(seed, temperature, top_p, repetition_penalty, max_new_tokens)
+        generated_chunks = []
+        sr = None
+
+        completed_pct = 35
+        yield completed_pct, None, (
+            f"{note} | Chunks: {total_chunks} | Estimated: {_format_seconds(estimated)} | Elapsed: {_elapsed_str(t0)}"
+        )
+        for i, chunk in enumerate(chunks):
+            yield completed_pct, None, f"{note} | Running chunk {i+1}/{total_chunks} | Elapsed: {_elapsed_str(t0)}"
+            if _is_faster_backend(model):
+                wavs, sr = model.generate_custom_voice(
+                    text=chunk, language=language,
+                    speaker=speaker.lower().replace(" ", "_"),
+                    instruct=(instruct or "").strip() if model_size == "1.7B" else None,
+                    **kwargs,
+                )
+            else:
+                wavs, sr = model.generate_custom_voice(
+                    text=chunk, language=language,
+                    speaker=speaker.lower().replace(" ", "_"),
+                    instruct=(instruct or "").strip() if model_size == "1.7B" else None,
+                    non_streaming_mode=True, **kwargs,
+                )
+            if wavs and len(wavs) > 0:
+                generated_chunks.append(normalize_audio(wavs[0]))
+                generated_chunks.append(make_silence(detect_pause_ms(chunk, cfg)))
+                completed_pct = 35 + int(((i + 1) / total_chunks) * 55)
+                yield completed_pct, None, (
+                    f"{note} | Completed chunk {i+1}/{total_chunks} | Elapsed: {_elapsed_str(t0)}"
+                )
+
+        if not generated_chunks or sr is None:
+            yield 0, None, "Error: no audio generated."
+            return
+
+        full_audio = np.concatenate(generated_chunks) if len(generated_chunks) > 1 else generated_chunks[0]
+        total_time = time.time() - t0
+        progress(1.0, desc=f"Done | Total {_format_seconds(total_time)}")
+        audio_out = apply_speed_post_process((sr, full_audio), speed)
+        speed_note = f" | Speed: {speed:.2f}x" if abs(speed - 1.0) >= 0.01 else ""
+        yield 100, audio_out, (
+            f"CustomVoice {model_size} generation completed. Chunks: {total_chunks} | Estimated: {_format_seconds(estimated)} | Total: {_format_seconds(total_time)}{speed_note}"
+        )
+    except Exception as e:
+        yield 0, None, f"Error: {type(e).__name__}: {e}"
+
+
+# ── Helper to build PauseConfig from 7 flat slider values ───────────────────
+def _build_cfg(ps, pc, psc, pco, pel, pnl, pdf) -> PauseConfig:
+    return PauseConfig(
+        sentence_ms=int(ps), comma_ms=int(pc),
+        semicolon_ms=int(psc), colon_ms=int(pco),
+        ellipsis_ms=int(pel), newline_ms=int(pnl),
+        default_ms=int(pdf),
+    )
+
+
+# ── Tab wrapper functions ─────────────────────────────────────────────────────
+
+def generate_base_17(
+    selected_voice_name, target_text, language, xvector_only,
+    seed, temperature, top_p, repetition_penalty, max_new_tokens,
+    speed=1.0,
+    ps=500, pc=180, psc=300, pco=250, pel=700, pnl=600, pdf=80,
+):
+    yield from generate_base("1.7B", selected_voice_name, None, "", target_text, language, xvector_only,
+                             seed, temperature, top_p, repetition_penalty, max_new_tokens,
+                             speed, _build_cfg(ps, pc, psc, pco, pel, pnl, pdf))
+
+
+def generate_base_06(
+    selected_voice_name, target_text, language, xvector_only,
+    seed, temperature, top_p, repetition_penalty, max_new_tokens,
+    speed=1.0,
+    ps=500, pc=180, psc=300, pco=250, pel=700, pnl=600, pdf=80,
+):
+    yield from generate_base("0.6B", selected_voice_name, None, "", target_text, language, xvector_only,
+                             seed, temperature, top_p, repetition_penalty, max_new_tokens,
+                             speed, _build_cfg(ps, pc, psc, pco, pel, pnl, pdf))
+
+
+def generate_custom_17(
+    text, language, speaker, instruct,
+    seed, temperature, top_p, repetition_penalty, max_new_tokens,
+    speed=1.0,
+    ps=500, pc=180, psc=300, pco=250, pel=700, pnl=600, pdf=80,
+):
+    yield from generate_custom("1.7B", text, language, speaker, instruct,
+                               seed, temperature, top_p, repetition_penalty, max_new_tokens,
+                               speed, _build_cfg(ps, pc, psc, pco, pel, pnl, pdf))
+
+
+def generate_custom_06(
+    text, language, speaker,
+    seed, temperature, top_p, repetition_penalty, max_new_tokens,
+    speed=1.0,
+    ps=500, pc=180, psc=300, pco=250, pel=700, pnl=600, pdf=80,
+):
+    yield from generate_custom("0.6B", text, language, speaker, "",
+                               seed, temperature, top_p, repetition_penalty, max_new_tokens,
+                               speed, _build_cfg(ps, pc, psc, pco, pel, pnl, pdf))

source/qwen_app/mode3_news.py

@@ -0,0 +1,625 @@
+# qwen_app/mode3_news.py  — v2.0 (Full Rewrite)
+# ─── Fixes Applied ────────────────────────────────────────────────────────────
+# FIX #1: Per-phase MP3 + per-phase SRT  →  validator chinh xac 1:1
+# FIX #2: FULL_MASTER.srt tong hop (offset dung) giu lai for external use
+# FIX #3: CJK-aware fallback duration (tieng Han/Viet/Korean tinh theo char)
+# FIX #4: Natural sort phases (1,2,...,9,10 thay vi 1,10,11,...,2)
+# FIX #5: Retry logging chi tiet (attempt#, RMS, chunk preview)
+# FIX #6: Orphan audio threshold tang (>500ms) + consecutive check
+# FIX #7: Validation 2 chieu chinh xac: moi phase MP3 chi validate voi SRT rieng
+# FIX #8: Skip-if-done kiem tra theo phase, khong theo tong the
+# ──────────────────────────────────────────────────────────────────────────────
+
+import os
+import re
+import sys
+import uuid
+import hashlib
+import traceback
+import subprocess
+import gc
+import numpy as np
+import soundfile as sf
+import gradio as gr
+from datetime import timedelta, datetime
+
+try:
+    import torch
+except ImportError:
+    torch = None
+
+from .model_manager import model_manager
+from .generation import decode_params, smart_chunk_text, _is_faster_backend, _build_atempo_filter_chain
+from .voice_library import normalize_audio, resolve_reference_details
+from .prosody import PauseConfig, DEFAULT_PAUSE, make_silence, detect_pause_ms
+from .audio_validator import (
+    validate_audio_vs_srt, format_validation_report,
+    check_array_energy, SILENCE_THRESHOLD_RMS, MAX_CHUNK_RETRIES
+)
+
+AUTO_PROJECT_OUTPUT_FOLDER_NAME = "_OUTPUT_PROJECTS"
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+def sanitize_filename(name):
+    return re.sub(r'[/*?:"<>|]', "", name)
+
+def generate_clean_guid(s):
+    return hashlib.sha1(s.encode('utf-8')).hexdigest()[:16]
+
+def format_timestamp(seconds):
+    td = timedelta(seconds=max(0.0, seconds))
+    total_s = int(td.total_seconds())
+    h, rem = divmod(total_s, 3600)
+    m, s = divmod(rem, 60)
+    ms = int(td.microseconds / 1000)
+    return f"{h:02}:{m:02}:{s:02},{ms:03}"
+
+def clean_text(text):
+    if not text: return ""
+    # 1. Remove URLs to prevent spelling out gibberish
+    text = re.sub(r'https?:\/\/[^\s]+', '', text)
+    text = re.sub(r'www\.[^\s]+', '', text)
+    
+    # 2. Unify ellipsis, quotes
+    text = text.replace('…', '...')
+    text = re.sub(r'[“”]', '"', text)
+    text = re.sub(r'[‘’]', "'", text)
+    
+    # 3. Limit repeating punctuations that cause glitches
+    text = re.sub(r'([!?。！？]){2,}', r'\1\1', text) 
+    text = re.sub(r'([,;،、；:]){2,}', r'\1', text)
+    text = re.sub(r'\.{4,}', '...', text)
+    
+    # 4. Fix missing space after punctuation before a letter
+    # [^\W\d_] matches any Unicode letter (Latin, Cyrillic, CJK, Hangul, etc.)
+    text = re.sub(r'([.,!?])([^\W\d_])', r'\1 \2', text)
+    
+    # 5. Basic printable char filter
+    text = "".join(ch for ch in text if ch.isprintable() or ch == '\n')
+    
+    # 6. Normalize spaces (flatten newlines to space like original logic)
+    return re.sub(r'\s+', ' ', text).strip()
+
+def is_speakable(text):
+    return bool(re.search(r'[a-zA-Z0-9\u00C0-\u1EF9\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]', text))
+
+def has_cjk(text):
+    """True if text contains CJK / Korean / Japanese characters."""
+    return bool(re.search(r'[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]', text))
+
+def ts():
+    return datetime.now().strftime("%H:%M:%S")
+
+def _natural_sort_key(s: str):
+    """Sort key that handles numeric parts naturally: PHASE_1 < PHASE_2 < PHASE_10."""
+    return [int(c) if c.isdigit() else c.lower() for c in re.split(r'(\d+)', s)]
+
+
+# ─── CJK-aware fallback duration estimator ────────────────────────────────────
+def _estimate_chunk_duration(chunk: str, speed: float) -> float:
+    """
+    Estimate audio duration (in seconds AFTER speed) for a chunk that failed inference.
+    - CJK/Korean: ~4.2 characters/second at speed=1.0 (conservative)
+    - Latin/Vietnamese: ~130 words/minute = ~2.17 words/second
+    """
+    s = max(speed, 0.1)
+    if has_cjk(chunk):
+        char_count = max(1, len(re.sub(r'\s+', '', chunk)))
+        return (char_count / 4.2) / s
+    else:
+        word_count = max(1, len(chunk.split()))
+        return (word_count / 130.0) * 60.0 / s
+
+
+# ─── Project Parser ────────────────────────────────────────────────────────────
+class ProjectParser:
+    @staticmethod
+    def parse_txt(file_path, project_folder_name):
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            if "STORY |" not in content or "END GAMES" not in content:
+                return None, None
+            core = content.split("STORY |")[1].split("END GAMES")[0].strip()
+            g = generate_clean_guid(
+                f"{sanitize_filename(project_folder_name)}_{sanitize_filename(os.path.splitext(os.path.basename(file_path))[0])}"
+            )
+            pattern = re.compile(
+                r'PHASE\s+(\d+)\s*\|\s*(.*?)\s*\|\s*Prompt\s*\d+\s*:\s*(.*?)(?=\n\s*PHASE|\Z)',
+                re.DOTALL | re.IGNORECASE
+            )
+            phases = []
+            for m in pattern.findall(core):
+                txt = clean_text(m[1].strip())
+                if txt:
+                    phases.append({
+                        "id":          int(m[0].strip()),
+                        "text":        txt,
+                        "prompt":      m[2].strip(),
+                        "prompt_name": f"{m[0].strip()}_PHASE_{g}"
+                    })
+            if phases:
+                # FIX #4: natural sort by numeric id
+                return sorted(phases, key=lambda x: x['id']), None
+        except Exception:
+            pass
+        return None, None
+
+
+# ─── Core TTS inference for one chunk ────────────────────────────────────────
+def _infer_chunk(model, voice_mode, chunk_text, lang,
+                 speaker, instruct, model_size,
+                 ref_audio, ref_text, xvec_only, kwargs):
+    """Route chunk to Base or CustomVoice. Returns normalized np.float32 array or None."""
+    wavs = None
+    sr = None
+    if voice_mode == "Base (Voice Library)":
+        if _is_faster_backend(model):
+            wavs, sr = model.generate_voice_clone(
+                text=chunk_text, language=lang,
+                ref_audio=ref_audio, ref_text=ref_text or "",
+                xvec_only=bool(xvec_only), non_streaming_mode=True, **kwargs
+            )
+        else:
+            wavs, sr = model.generate_voice_clone(
+                text=chunk_text, language=lang,
+                ref_audio=ref_audio, ref_text=ref_text,
+                x_vector_only_mode=bool(xvec_only),
+                non_streaming_mode=True, **kwargs
+            )
+    else:  # CustomVoice
+        spk = (speaker or "").lower().replace(" ", "_")
+        ins = (instruct or "").strip() if model_size == "1.7B" else None
+        if _is_faster_backend(model):
+            wavs, sr = model.generate_custom_voice(
+                text=chunk_text, language=lang, speaker=spk, instruct=ins, **kwargs
+            )
+        else:
+            wavs, sr = model.generate_custom_voice(
+                text=chunk_text, language=lang, speaker=spk, instruct=ins,
+                non_streaming_mode=True, **kwargs
+            )
+    if wavs and len(wavs) > 0:
+        return normalize_audio(wavs[0])
+    return None
+
+
+def _infer_chunk_with_retry(
+    model, voice_mode, chunk_text, lang,
+    speaker, instruct, model_size,
+    ref_audio, ref_text, xvec_only, kwargs,
+    max_retries: int = MAX_CHUNK_RETRIES,
+    log_prefix: str = "",
+):
+    """
+    FIX #5: Enhanced retry with per-attempt RMS logging.
+
+    Returns: (arr_or_None, status_str, attempt_log_lines)
+      status = 'OK'       → arr is good, attempt 0
+      status = 'RETRY_OK' → arr recovered after N retries
+      status = 'SILENT'   → all retries failed → caller should fill silence
+      status = 'ERROR'    → exception, arr is None
+    """
+    attempt_logs = []
+    last_exc = None
+    for attempt in range(1 + max_retries):
+        try:
+            arr = _infer_chunk(
+                model, voice_mode, chunk_text, lang,
+                speaker, instruct, model_size,
+                ref_audio, ref_text, xvec_only, kwargs,
+            )
+            rms = check_array_energy(arr)
+            attempt_logs.append(f"    attempt {attempt+1}: RMS={rms:.5f} → {'✅ OK' if rms >= SILENCE_THRESHOLD_RMS else '⚠️ low'}")
+            if rms >= SILENCE_THRESHOLD_RMS:
+                status = 'OK' if attempt == 0 else 'RETRY_OK'
+                return arr, status, attempt_logs
+            last_exc = f"low energy (RMS={rms:.5f})"
+        except Exception as exc:
+            last_exc = str(exc)
+            attempt_logs.append(f"    attempt {attempt+1}: EXCEPTION={exc}")
+
+    return None, 'SILENT', attempt_logs
+
+
+# ─── FFmpeg: WAV → MP3 helper ────────────────────────────────────────────────
+def _wav_to_mp3(tmp_wav: str, mp3_out: str, speed: float, do_norm: bool) -> bool:
+    """Convert WAV to MP3 with atempo speed change + optional loudnorm. Returns True on success."""
+    cmd = ["ffmpeg", "-y", "-i", tmp_wav]
+    filt = _build_atempo_filter_chain(speed)
+    if do_norm:
+        filt.append("loudnorm=I=-16:TP=-1.5:LRA=11")
+    if filt:
+        cmd += ["-filter:a", ",".join(filt)]
+    cmd += ["-c:a", "libmp3lame", "-b:a", "192k", "-loglevel", "error", mp3_out]
+    try:
+        ff_flags = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+        subprocess.run(cmd, check=True, creationflags=ff_flags)
+        return os.path.exists(mp3_out) and os.path.getsize(mp3_out) >= 1024
+    except Exception:
+        return False
+
+
+# ─── Per-phase SRT writer ─────────────────────────────────────────────────────
+def _write_srt(path: str, entries: list):
+    """Write a list of {idx, start, end, text} dicts to SRT file."""
+    with open(path, 'w', encoding='utf-8') as f:
+        for s in entries:
+            f.write(f"{s['idx']}\n{s['start']} --> {s['end']}\n{s['text']}\n\n")
+
+
+# ─── Main batch generator ──────────────────────────────────────────────────────
+def process_news_batch(
+    txt_paths_str,
+    voice_mode, m3_saved_voice, m3_xvec,
+    model_size, speaker, lang, instruct,
+    speed, silence_sec, do_norm,
+    seed, temperature, top_p, rep_penalty, max_tokens,
+    pause_sentence_ms=500, pause_comma_ms=180, pause_semicolon_ms=300,
+    pause_colon_ms=250, pause_ellipsis_ms=700, pause_newline_ms=600, pause_default_ms=80,
+    progress=gr.Progress()
+):
+    pause_cfg = PauseConfig(
+        sentence_ms=int(pause_sentence_ms),
+        comma_ms=int(pause_comma_ms),
+        semicolon_ms=int(pause_semicolon_ms),
+        colon_ms=int(pause_colon_ms),
+        ellipsis_ms=int(pause_ellipsis_ms),
+        newline_ms=int(pause_newline_ms),
+        default_ms=int(pause_default_ms),
+    )
+    log = f"[{ts()}] 🚀 BẮT ĐẦU BATCH CHẾ ĐỘ 3 (v2.0)...\n"
+    yield log
+
+    # ── Validate paths
+    folders = [p.strip() for p in (txt_paths_str or "").split('\n')
+               if p.strip() and os.path.isdir(p.strip())]
+    if not folders:
+        log += f"[{ts()}] ❌ LỖI: Không tìm thấy thư mục hợp lệ!\n"
+        yield log; return
+
+    # ── Scan TXT files
+    log += f"[{ts()}] 🔎 Quét file .txt...\n"; yield log
+    valid_txts = []
+    for d in folders:
+        for root, _, files in os.walk(d):
+            if AUTO_PROJECT_OUTPUT_FOLDER_NAME in root:
+                continue
+            for f in sorted(files, key=_natural_sort_key):
+                if not f.lower().endswith(".txt"):
+                    continue
+                path = os.path.join(root, f)
+                phases, _ = ProjectParser.parse_txt(path, os.path.basename(os.path.dirname(path)))
+                if phases:
+                    valid_txts.append({
+                        "path":   path,
+                        "group":  os.path.basename(os.path.normpath(d)),
+                        "phases": phases
+                    })
+
+    if not valid_txts:
+        log += f"[{ts()}] ❌ Không tìm thấy Story nào theo chuẩn PHASE!\n"
+        yield log; return
+
+    log += f"[{ts()}] ✅ Tìm thấy {len(valid_txts)} story hợp lệ.\n"; yield log
+
+    # ── Resolve voice reference (Base mode)
+    ref_audio = None; ref_text = None; xvec_only = m3_xvec
+    if voice_mode == "Base (Voice Library)":
+        if not m3_saved_voice or m3_saved_voice == "None":
+            log += f"[{ts()}] ❌ LỖI: Chưa chọn Voice Library!\n"
+            yield log; return
+        resolved_audio, resolved_path, resolved_text, src_note = resolve_reference_details(
+            m3_saved_voice, None, None, xvec_only
+        )
+        if resolved_audio is None:
+            log += f"[{ts()}] ❌ Lỗi Load Voice Library: {src_note}\n"
+            yield log; return
+        ref_audio = resolved_path if resolved_path else resolved_audio
+        ref_text  = resolved_text
+        log += f"[{ts()}] 🎤 Voice Library: {src_note}\n"; yield log
+        model_type = "Base"
+    else:
+        model_type = "CustomVoice"
+
+    # ── Load model
+    log += f"[{ts()}] ⚙️ Nạp Model {model_type} ({model_size})...\n"; yield log
+    try:
+        model, note = model_manager.get_model(model_type, model_size)
+        log += f"[{ts()}] ✅ Load xong: {note}\n"; yield log
+    except Exception as e:
+        log += f"[{ts()}] ❌ Lỗi Load Model: {e}\n"; yield log; return
+
+    kwargs = decode_params(seed=seed, temperature=temperature, top_p=top_p,
+                           repetition_penalty=rep_penalty, max_new_tokens=max_tokens)
+
+    CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "Qwen_Mode3_Cache")
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    total = len(valid_txts)
+    batch_results = []  # (txt_name, passed: bool)
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    for i, item in enumerate(valid_txts):
+        progress((i, total), desc=f"{i+1}/{total}...")
+        txt_path = item["path"]
+        phases   = item["phases"]   # already natural-sorted by id
+        txt_name = os.path.basename(txt_path)
+        txt_base = os.path.splitext(txt_name)[0]
+        proj_dir = os.path.dirname(txt_path)
+        out_dir  = os.path.join(proj_dir, AUTO_PROJECT_OUTPUT_FOLDER_NAME, sanitize_filename(txt_base))
+        os.makedirs(out_dir, exist_ok=True)
+
+        # FIX #8: Per-phase skip — only check MP3s + FULL_MASTER.srt (no per-phase SRT in out_dir)
+        srt_master_path = os.path.join(out_dir, "FULL_MASTER.srt")
+        all_done = all(
+            os.path.exists(os.path.join(out_dir, f"{p['prompt_name']}.mp3"))
+            for p in phases
+        ) and os.path.exists(srt_master_path)
+
+        if all_done:
+            log += f"[{ts()}] ⏭ BỎ QUA (đã hoàn thành): {txt_name}\n"; yield log
+            continue
+
+        log += f"\n[{ts()}] ▶ [{item['group']}] → {txt_name}\n"; yield log
+
+        # Accumulate master SRT across all phases
+        master_srt_entries = []
+        master_srt_idx     = 1
+        master_cursor      = 0.0   # global time cursor for FULL_MASTER.srt
+        _phase_tmp_srts    = {}    # track temp per-phase SRT files for validation
+
+        story_passed = True
+
+        for phase in phases:
+            pt = phase['text']
+            if not is_speakable(pt):
+                continue
+            chunks = smart_chunk_text(pt)
+            if not chunks:
+                continue
+
+            phase_mp3      = os.path.join(out_dir, f"{phase['prompt_name']}.mp3")
+            # Per-phase SRT lives in CACHE_DIR (temp) — deleted after validation
+            # Output folder only has MP3s + FULL_MASTER.srt
+            phase_srt_tmp  = os.path.join(CACHE_DIR, f"phase_srt_{uuid.uuid4().hex}.srt")
+            _phase_tmp_srts[phase['prompt_name']] = phase_srt_tmp
+
+            # FIX #8b: Skip individual phase if MP3 already exists (no need for per-phase SRT)
+            if os.path.exists(phase_mp3):
+                log += f"  ⏭ Phase {phase['id']}: MP3 có sẵn, bỏ qua\n"; yield log
+                # Estimate local_cursor from MP3 duration to keep master_cursor accurate
+                try:
+                    from .audio_validator import _load_audio_as_mono
+                    _d, _sr = _load_audio_as_mono(phase_mp3)
+                    master_cursor += len(_d) / _sr
+                except Exception:
+                    pass
+                continue
+
+            log += f"  ⏳ Phase {phase['id']}: {len(chunks)} chunk(s) → GPU...\n"; yield log
+
+            phase_arrays  = []   # raw pre-speed arrays to be concatenated
+            phase_entries = []   # per-phase SRT entries (local timestamps starting at 0)
+            local_cursor  = 0.0  # time cursor WITHIN this phase (pre-speed local)
+
+            # ── Per-chunk inference loop ──────────────────────────────────
+            for ci, chunk in enumerate(chunks):
+                if not is_speakable(chunk):
+                    log += f"  ⏭ Chunk {ci+1} chỉ chứa dấu câu — lấp silence\n"; yield log
+                    pause_ms_f = detect_pause_ms(chunk, pause_cfg)
+                    gap_dur_f  = (pause_ms_f / 1000.0) / max(speed, 0.1)
+                    phase_arrays.append(make_silence(pause_ms_f))
+                    local_cursor += gap_dur_f
+                    continue
+
+                arr, infer_status, attempt_logs = None, 'ERROR', []
+                try:
+                    arr, infer_status, attempt_logs = _infer_chunk_with_retry(
+                        model, voice_mode, chunk, lang,
+                        speaker, instruct, model_size,
+                        ref_audio, ref_text, xvec_only, kwargs,
+                    )
+                except Exception as e:
+                    infer_status = 'ERROR'
+                    attempt_logs = [f"    CRITICAL EXCEPTION: {e}"]
+                    log += f"  ❌ Chunk {ci+1} EXCEPTION: {e}\n"; yield log
+
+                # FIX #5: log attempt details if retried or failed
+                if infer_status in ('RETRY_OK', 'SILENT', 'ERROR') or len(attempt_logs) > 1:
+                    log += f"  🔁 Chunk {ci+1} '{chunk[:30]}...':\n"
+                    for al in attempt_logs:
+                        log += al + "\n"
+                    yield log
+
+                if infer_status == 'RETRY_OK':
+                    log += f"  ↻ Chunk {ci+1}: Recovered after retry ✅\n"; yield log
+
+                # ── FALLBACK: inference failed → silence placeholder ──────
+                if infer_status in ('SILENT', 'ERROR') and arr is None:
+                    log += (f"  ⚠️ Chunk {ci+1}: {MAX_CHUNK_RETRIES+1} lần thử thất bại"
+                            f" — lấp silence ({chunk[:40]}...)\n"); yield log
+
+                    # FIX #3: CJK-aware duration estimate
+                    est_dur  = _estimate_chunk_duration(chunk, speed)
+                    pause_ms = detect_pause_ms(chunk, pause_cfg)
+                    gap_dur  = (pause_ms / 1000.0) / max(speed, 0.1)
+
+                    sil_samples = int(est_dur * 24000)
+                    phase_arrays.extend([np.zeros(sil_samples, dtype=np.float32),
+                                         make_silence(pause_ms)])
+
+                    start_ts = local_cursor
+                    end_ts   = local_cursor + est_dur
+                    phase_entries.append({
+                        "idx":   len(phase_entries) + 1,
+                        "start": format_timestamp(start_ts),
+                        "end":   format_timestamp(end_ts),
+                        "text":  f"[RETRY FAILED — SILENT: {chunk[:60]}]",
+                    })
+                    master_srt_entries.append({
+                        "idx":   master_srt_idx,
+                        "start": format_timestamp(master_cursor + start_ts),
+                        "end":   format_timestamp(master_cursor + end_ts),
+                        "text":  f"[RETRY FAILED — SILENT: {chunk[:60]}]",
+                    })
+                    master_srt_idx += 1
+                    local_cursor   += est_dur + gap_dur
+                    continue
+
+                # ── NORMAL: good audio ────────────────────────────────────
+                if arr is not None and len(arr) > 0:
+                    raw_dur  = len(arr) / 24000.0
+                    pause_ms = detect_pause_ms(chunk, pause_cfg)
+                    sil      = make_silence(pause_ms)
+                    phase_arrays.extend([arr, sil])
+
+                    speech_dur = raw_dur / max(speed, 0.1)
+                    gap_dur    = (pause_ms / 1000.0) / max(speed, 0.1)
+                    start_ts   = local_cursor
+                    end_ts     = start_ts + speech_dur
+
+                    phase_entries.append({
+                        "idx":   len(phase_entries) + 1,
+                        "start": format_timestamp(start_ts),
+                        "end":   format_timestamp(end_ts),
+                        "text":  chunk,
+                    })
+                    master_srt_entries.append({
+                        "idx":   master_srt_idx,
+                        "start": format_timestamp(master_cursor + start_ts),
+                        "end":   format_timestamp(master_cursor + end_ts),
+                        "text":  chunk,
+                    })
+                    master_srt_idx += 1
+                    local_cursor   += speech_dur + gap_dur
+
+            # ── Write phase WAV → MP3 ─────────────────────────────────────
+            if phase_arrays:
+                tmp = os.path.join(CACHE_DIR, f"tmp_{uuid.uuid4().hex}.wav")
+                try:
+                    sf.write(tmp, np.concatenate(phase_arrays), 24000)
+                    ok = _wav_to_mp3(tmp, phase_mp3, speed, do_norm)
+                    if not ok:
+                        log += f"  ⚠️ Phase {phase['id']}: FFmpeg thất bại hoặc MP3 rỗng!\n"; yield log
+                except Exception as e:
+                    log += f"  ❌ Phase {phase['id']} WAV/FFmpeg lỗi: {e}\n"; yield log
+                    traceback.print_exc()
+                finally:
+                    if os.path.exists(tmp):
+                        try: os.remove(tmp)
+                        except Exception: pass
+
+            # ── Write per-phase SRT to CACHE (temp) — NOT in out_dir ────
+            if phase_entries:
+                _write_srt(phase_srt_tmp, phase_entries)
+
+            # Advance master cursor by total phase duration
+            master_cursor += local_cursor
+
+        # ── Write FULL_MASTER.srt ─────────────────────────────────────────
+        if master_srt_entries:
+            _write_srt(srt_master_path, master_srt_entries)
+
+        # ═══ BIDIRECTIONAL VALIDATION  ══════════════════════════════════════
+        # FIX #7: Validate each phase MP3 against its TEMP per-phase SRT (in CACHE_DIR)
+        # After validate → delete temp SRT. Out dir stays clean: MP3s + FULL_MASTER.srt only.
+        log += f"[{ts()}] 🔍 Bidirectional validation — {len(phases)} phase(s)...\n"; yield log
+        all_phases_ok = True
+
+        for phase in phases:
+            phase_mp3     = os.path.join(out_dir, f"{phase['prompt_name']}.mp3")
+            # Temp SRT was written to CACHE_DIR during inference; reconstruct expected path
+            # (We store the path in a side-channel dict built during inference)
+            tmp_srt_path  = _phase_tmp_srts.get(phase['prompt_name'])
+
+            if not os.path.exists(phase_mp3):
+                log += f"  ⚠️ Phase {phase['id']}: MP3 bị thiếu — bỏ qua validate\n"
+                all_phases_ok = False
+                yield log
+                continue
+
+            if not tmp_srt_path or not os.path.exists(tmp_srt_path):
+                log += f"  ℹ️ Phase {phase['id']}: đã có từ session trước — bỏ qua validate\n"
+                yield log
+                continue
+
+            rpt = validate_audio_vs_srt(phase_mp3, tmp_srt_path)
+            pname = f"Phase {phase['id']}"
+
+            if rpt.overall_status == "PASS":
+                log += (f"  ✅ {pname}: PASS "
+                        f"({rpt.passed_entries}/{rpt.srt_total_entries} entries OK"
+                        f", {rpt.audio_duration:.1f}s)\n")
+            elif rpt.overall_status == "WARN":
+                all_phases_ok = False
+                log += f"  ⚠️ {pname}: WARN\n"
+                log += format_validation_report(rpt) + "\n"
+            else:  # FAIL
+                all_phases_ok = False
+                log += f"  ❌ {pname}: FAIL\n"
+                log += format_validation_report(rpt) + "\n"
+            yield log
+
+            # Delete temp SRT — output folder stays clean
+            try:
+                if os.path.exists(tmp_srt_path):
+                    os.remove(tmp_srt_path)
+            except Exception:
+                pass
+
+        # ── Also sanity-check FULL_MASTER.srt (duration vs last entry) ───
+        if os.path.exists(srt_master_path) and master_srt_entries:
+            from .audio_validator import parse_srt as _parse_srt
+            master_entries = _parse_srt(srt_master_path)
+            if master_entries:
+                expected_end = master_entries[-1].end
+                total_mp3_dur = 0.0
+                for phase in phases:
+                    ph_mp3 = os.path.join(out_dir, f"{phase['prompt_name']}.mp3")
+                    if os.path.exists(ph_mp3):
+                        try:
+                            from .audio_validator import _load_audio_as_mono
+                            d, sr_ = _load_audio_as_mono(ph_mp3)
+                            total_mp3_dur += len(d) / sr_
+                        except Exception:
+                            pass
+                if abs(total_mp3_dur - expected_end) < 2.0:
+                    log += (f"[{ts()}] ✅ FULL_MASTER.srt sanity: "
+                            f"total audio={total_mp3_dur:.1f}s ≈ SRT end={expected_end:.1f}s\n")
+                else:
+                    log += (f"[{ts()}] ⚠️ FULL_MASTER.srt drift: "
+                            f"total audio={total_mp3_dur:.1f}s vs SRT end={expected_end:.1f}s "
+                            f"(Δ={abs(total_mp3_dur-expected_end):.1f}s)\n")
+                    all_phases_ok = False
+                yield log
+
+        if all_phases_ok:
+            log += f"[{ts()}] ✅ XÁC NHẬN XONG: {txt_name} — ĐẦY ĐỦ & TOÀN VẸN\n"
+            story_passed = True
+        else:
+            log += f"[{ts()}] ⚠️ NGƯỜI DÙNG CẦN KIỂM TRA: {txt_name} có một số đoạn bị thiếu!\n"
+            story_passed = False
+        yield log
+
+        batch_results.append((txt_name, story_passed))
+
+        gc.collect()
+        if torch and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    progress((total, total), desc="Done")
+
+    # ── FINAL BATCH SUMMARY ────────────────────────────────────────────
+    n_pass = sum(1 for _, ok in batch_results if ok)
+    n_fail = len(batch_results) - n_pass
+    log += f"\n{'='*60}\n"
+    log += f"[{ts()}] 🏁 KẾT QUẢ BATCH: {n_pass}/{len(batch_results)} story ĐÃ QUA KIỂM TRA\n"
+    if n_fail > 0:
+        log += f"  ❌ {n_fail} story có vấn đề:\n"
+        for name, ok in batch_results:
+            if not ok:
+                log += f"    • {name}\n"
+    else:
+        log += f"  ✅ Tất cả {n_pass} story ĐẦY ĐỦ & TOÀN VẸN — SẢN PHẨM SẴN SÀNG GIAO!\n"
+    log += f"{'='*60}\n"
+    yield log

source/qwen_app/mode_batch_txt.py

@@ -0,0 +1,269 @@
+# qwen_app/mode_batch_txt.py
+import os
+import gc
+import sys
+import subprocess
+import uuid
+import numpy as np
+import soundfile as sf
+import gradio as gr
+
+try:
+    import torch
+except ImportError:
+    torch = None
+
+from .model_manager import model_manager
+from .generation import decode_params, smart_chunk_text, _build_atempo_filter_chain
+from .voice_library import resolve_reference_details
+from .mode3_news import ts, clean_text, is_speakable, format_timestamp, _infer_chunk, _infer_chunk_with_retry
+from .prosody import PauseConfig, DEFAULT_PAUSE, make_silence, detect_pause_ms
+from .audio_validator import validate_audio_vs_srt, format_validation_report, MAX_CHUNK_RETRIES
+
+AUTO_TXT_OUTPUT_FOLDER_NAME = "_OUTPUT_TXT"
+
+def process_batch_txt_pure(
+    txt_paths_str,
+    voice_mode, m3_saved_voice, m3_xvec,
+    model_size, speaker, lang, instruct,
+    speed, silence_sec, do_norm,
+    seed, temperature, top_p, rep_penalty, max_tokens,
+    # Prosodic pause config
+    pause_sentence_ms=500, pause_comma_ms=180, pause_semicolon_ms=300,
+    pause_colon_ms=250, pause_ellipsis_ms=700, pause_newline_ms=600, pause_default_ms=80,
+    progress=gr.Progress()
+):
+    pause_cfg = PauseConfig(
+        sentence_ms=int(pause_sentence_ms),
+        comma_ms=int(pause_comma_ms),
+        semicolon_ms=int(pause_semicolon_ms),
+        colon_ms=int(pause_colon_ms),
+        ellipsis_ms=int(pause_ellipsis_ms),
+        newline_ms=int(pause_newline_ms),
+        default_ms=int(pause_default_ms),
+    )
+    log = f"[{ts()}] 🚀 BẮT ĐẦU BATCH TXT (PURE)...\n"
+    yield log
+
+    folders = [p.strip() for p in (txt_paths_str or "").split('\n') if p.strip() and os.path.isdir(p.strip())]
+    if not folders:
+        log += f"[{ts()}] ❌ LỖI: Không tìm thấy thư mục hợp lệ!\n"
+        yield log; return
+
+    log += f"[{ts()}] 🔎 Quét file .txt...\n"; yield log
+    valid_txts = []
+    for d in folders:
+        for root, _, files in os.walk(d):
+            if AUTO_TXT_OUTPUT_FOLDER_NAME in root: continue
+            for f in files:
+                if not f.lower().endswith(".txt"): continue
+                path = os.path.join(root, f)
+                with open(path, 'r', encoding='utf-8') as file:
+                    content = clean_text(file.read())
+                    if content and is_speakable(content):
+                        valid_txts.append({"path": path, "content": content, "folder": d})
+
+    if not valid_txts:
+        log += f"[{ts()}] ❌ Không tìm thấy file TXT có chữ hợp lệ!\n"
+        yield log; return
+
+    log += f"[{ts()}] ✅ Tìm thấy {len(valid_txts)} file TXT.\n"; yield log
+
+    ref_audio = None; ref_text = None; xvec_only = m3_xvec
+    if voice_mode == "Base (Voice Library)":
+        if not m3_saved_voice or m3_saved_voice == "None":
+            log += f"[{ts()}] ❌ LỖI: Chưa chọn Voice Library!\n"
+            yield log; return
+        resolved_audio, resolved_path, resolved_text, src_note = resolve_reference_details(
+            m3_saved_voice, None, None, xvec_only
+        )
+        if resolved_audio is None:
+            log += f"[{ts()}] ❌ Lỗi Load Voice Library: {src_note}\n"; yield log; return
+        ref_audio = resolved_path if resolved_path else resolved_audio
+        ref_text = resolved_text
+        log += f"[{ts()}] 🎤 Đã tải Voice Library: {src_note}\n"; yield log
+        model_type = "Base"
+    else:
+        model_type = "CustomVoice"
+
+    log += f"[{ts()}] ⚙️ Nạp Model {model_type} ({model_size}) lên GPU...\n"; yield log
+    try:
+        model, note = model_manager.get_model(model_type, model_size)
+        log += f"[{ts()}] ✅ Load xong: {note}\n"; yield log
+    except Exception as e:
+        log += f"[{ts()}] ❌ Lỗi Load Model: {e}\n"; yield log; return
+
+    kwargs = decode_params(seed=seed, temperature=temperature, top_p=top_p,
+                           repetition_penalty=rep_penalty, max_new_tokens=max_tokens)
+
+    CACHE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "Qwen_Mode3_Cache")
+    os.makedirs(CACHE_DIR, exist_ok=True)
+    total = len(valid_txts)
+    batch_results = []   # (txt_name, passed: bool)
+
+    for i, item in enumerate(valid_txts):
+        progress((i, total), desc=f"{i+1}/{total}...")
+        txt_path = item["path"]
+        content = item["content"]
+        txt_name = os.path.basename(txt_path)
+        txt_base = os.path.splitext(txt_name)[0]
+        
+        # Output directly into a subfolder _OUTPUT_TXT of the original folder
+        out_dir = os.path.join(item["folder"], AUTO_TXT_OUTPUT_FOLDER_NAME)
+        os.makedirs(out_dir, exist_ok=True)
+
+        mp3_path = os.path.join(out_dir, f"{txt_base}.mp3")
+        srt_path = os.path.join(out_dir, f"{txt_base}.srt")
+
+        if os.path.exists(mp3_path) and os.path.exists(srt_path):
+            log += f"[{ts()}] ⏭ BỎ QUA (đã có): {txt_name}\n"; yield log; continue
+
+        log += f"\n[{ts()}] ▶ Đang xử lý: {txt_name}\n"; yield log
+
+        chunks = smart_chunk_text(content)
+        if not chunks: continue
+        log += f"  ⏳ {len(chunks)} chunk(s) → GPU...\n"; yield log
+
+        phase_arrays = []
+        srt_entries = []
+        srt_idx = 1
+        global_cursor = 0.0
+
+        for ci, chunk in enumerate(chunks):
+            if not is_speakable(chunk):
+                log += f"  ⏭ Chunk {ci+1} chỉ chứa dấu câu — lấp silence\n"; yield log
+                pause_ms_f = detect_pause_ms(chunk, pause_cfg)
+                gap_dur_f  = (pause_ms_f / 1000.0) / max(speed, 0.1)
+                phase_arrays.append(make_silence(pause_ms_f))
+                global_cursor += gap_dur_f
+                continue
+
+            arr, infer_status, attempt_logs = None, 'ERROR', []
+            try:
+                arr, infer_status, attempt_logs = _infer_chunk_with_retry(
+                    model, voice_mode, chunk, lang, speaker, instruct,
+                    model_size, ref_audio, ref_text, xvec_only, kwargs
+                )
+            except Exception as e:
+                infer_status = 'ERROR'
+                attempt_logs = [f"    CRITICAL EXCEPTION: {e}"]
+                log += f"  ❌ Chunk {ci+1} EXCEPTION: {e}\n"; yield log
+
+            # Log retry details when retried or failed
+            if infer_status in ('RETRY_OK', 'SILENT', 'ERROR') or len(attempt_logs) > 1:
+                log += f"  🔁 Chunk {ci+1} '{chunk[:30]}...':\n"
+                for al in attempt_logs:
+                    log += al + "\n"
+                yield log
+
+            if infer_status == 'RETRY_OK':
+                log += f"  ↻ Chunk {ci+1}: Recovered after retry — audio OK\n"; yield log
+
+            if infer_status == 'SILENT' or (infer_status == 'ERROR' and arr is None):
+                log += f"  ⚠️ Chunk {ci+1}: Tất cả {MAX_CHUNK_RETRIES+1} lần thử — đặt silence lấp khoảng trống\n"; yield log
+                word_count = max(1, len(chunk.split()))
+                est_dur = (word_count / 130.0) / max(speed, 0.1)
+                pause_ms_f = detect_pause_ms(chunk, pause_cfg)
+                gap_dur_f  = (pause_ms_f / 1000.0) / max(speed, 0.1)
+                # Lấp silence: giữ timing dòng SRT sau không bị lệch
+                silence_samples = int(est_dur * 24000)
+                phase_arrays.extend([np.zeros(silence_samples, dtype=np.float32), make_silence(pause_ms_f)])
+                srt_entries.append({
+                    "idx"  : srt_idx,
+                    "start": format_timestamp(global_cursor),
+                    "end"  : format_timestamp(global_cursor + est_dur),
+                    "text" : f"[RETRY FAILED — SILENT: {chunk[:60]}]"
+                })
+                global_cursor += est_dur + gap_dur_f
+                srt_idx += 1
+                continue
+
+            if arr is not None and len(arr) > 0:
+                raw_dur = len(arr) / 24000.0
+                # Punctuation-aware silence
+                pause_ms = detect_pause_ms(chunk, pause_cfg)
+                sil = make_silence(pause_ms)
+                phase_arrays.extend([arr, sil])
+
+                speech_dur = raw_dur / speed
+                gap_dur = (pause_ms / 1000.0) / speed
+                start, end = global_cursor, global_cursor + speech_dur
+
+                srt_entries.append({
+                    "idx": srt_idx,
+                    "start": format_timestamp(start),
+                    "end": format_timestamp(end),
+                    "text": chunk
+                })
+                global_cursor += (speech_dur + gap_dur)
+                srt_idx += 1
+
+        if phase_arrays:
+            tmp = os.path.join(CACHE_DIR, f"tmp_{uuid.uuid4().hex}.wav")
+            sf.write(tmp, np.concatenate(phase_arrays), 24000)
+
+            # BUG FIX #1 & #4: safe atempo chain — handles speed < 0.5 and > 2.0
+            cmd = ["ffmpeg", "-y", "-i", tmp]
+            filt = _build_atempo_filter_chain(speed)
+            if do_norm: filt.append("loudnorm=I=-16:TP=-1.5:LRA=11")
+            if filt: cmd += ["-filter:a", ",".join(filt)]
+            cmd += ["-c:a", "libmp3lame", "-b:a", "192k", "-loglevel", "error", mp3_path]
+            try:
+                ff_flags = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+                if ff_flags:
+                    subprocess.run(cmd, check=True, creationflags=ff_flags)
+                else:
+                    subprocess.run(cmd, check=True)
+                # Sanity check: MP3 should exist and be non-empty
+                if not os.path.exists(mp3_path) or os.path.getsize(mp3_path) < 1024:
+                    log += f"  ⚠️ {txt_name}: MP3 tạo ra bị thiếu hoặc rỗng!\n"; yield log
+            except Exception as e:
+                log += f"  ❌ FFmpeg {txt_name}: {e}\n"; yield log
+            if os.path.exists(tmp): os.remove(tmp)
+
+        if srt_entries:
+            with open(srt_path, 'w', encoding='utf-8') as f:
+                for s in srt_entries:
+                    f.write(f"{s['idx']}\n{s['start']} --> {s['end']}\n{s['text']}\n\n")
+
+        # ── AUTO INTEGRITY VALIDATION ──────────────────────────────────────────
+        # Validate ngay sau khi ghi xong — chỉ ✅ DONE nếu pass.
+        if os.path.exists(mp3_path) and os.path.exists(srt_path):
+            log += f"[{ts()}] 🔍 Auto-validating: {txt_name}...\n"; yield log
+            rpt = validate_audio_vs_srt(mp3_path, srt_path)
+            if rpt.overall_status == "PASS":
+                log += f"[{ts()}] ✅ XÁC NHẬN: {txt_name} — ĐẦY ĐỦ & TOÀN VẸN ({rpt.passed_entries}/{rpt.srt_total_entries} entries)\n"
+                batch_results.append((txt_name, True))
+            elif rpt.overall_status == "WARN":
+                log += f"[{ts()}] ⚠️ CẢNH BÁO: {txt_name}\n"
+                log += format_validation_report(rpt) + "\n"
+                batch_results.append((txt_name, False))
+            else:
+                log += f"[{ts()}] ❌ LỖI: {txt_name} — MẤT DỮ LIỆU!\n"
+                log += format_validation_report(rpt) + "\n"
+                batch_results.append((txt_name, False))
+            yield log
+        else:
+            log += f"[{ts()}] ⚠️ {txt_name}: MP3 hoặc SRT chưa được tạo ra!\n"; yield log
+            batch_results.append((txt_name, False))
+
+        gc.collect()
+        if torch and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    progress((total, total), desc="Done")
+
+    # ── FINAL BATCH SUMMARY ────────────────────────────────────────────
+    n_pass = sum(1 for _, ok in batch_results if ok)
+    n_fail = len(batch_results) - n_pass
+    log += f"\n{'='*60}\n"
+    log += f"[{ts()}] 🏁 KẼT QUẢ BATCH TXT: {n_pass}/{len(batch_results)} file ĐẨ QUA KIỂM TRA\n"
+    if n_fail > 0:
+        log += f"  ❌ {n_fail} file có vấn đề — xem chi tiết ở trên:\n"
+        for name, ok in batch_results:
+            if not ok:
+                log += f"    • {name}\n"
+    else:
+        log += f"  ✅ Tất cả {n_pass} file ĐẦY ĐỦ & TOÀN VẸN — SẢN PHẨM SẴN SÀNG GIAO!\n"
+    log += f"{'='*60}\n"
+    yield log

source/qwen_app/mode_omni_batch.py

@@ -0,0 +1,650 @@
+# qwen_app/mode_omni_batch.py
+"""
+OmniVoice Batch TXT Pipeline — VN + Global (600+ Languages)
+=============================================================
+Uses OmniVoice NATIVE long-form generation with Macro Chunking (3000 chars)
+for memory safety (Anti-OOM) while preserving strong emotional context.
+"""
+
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import re
+import sys
+import subprocess
+import time
+import traceback
+import uuid
+from datetime import timedelta
+from typing import Generator, List, Optional
+
+import numpy as np
+import soundfile as sf
+import gradio as gr
+
+try:
+    import torch
+    _TORCH = torch
+except ImportError:
+    _TORCH = None  # type: ignore
+
+from .omni_engine import (
+    omni_engine,
+    SILENCE_THRESHOLD,
+    get_available_vram_gb,
+)
+from .prosody import PauseConfig, DEFAULT_PAUSE, make_silence, detect_pause_ms
+
+try:
+    from .text_cleaner import preprocess_for_tts
+    _TEXT_CLEANER_AVAILABLE = True
+except ImportError:
+    _TEXT_CLEANER_AVAILABLE = False
+
+from .audio_validator import (
+    validate_audio_vs_srt,
+    format_validation_report,
+    check_array_energy,
+)
+
+logger = logging.getLogger("qwen_app.mode_omni_batch")
+
+# ─── Constants ────────────────────────────────────────────────────────────────
+AUTO_OUTPUT_FOLDER = "_OUTPUT_OMNI"
+MAX_SRT_CHARS = 80
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+def _ts() -> str:
+    return time.strftime("%H:%M:%S")
+
+
+def _fmt_ts(seconds: float) -> str:
+    s = max(0.0, seconds)
+    td = timedelta(seconds=s)
+    total = int(td.total_seconds())
+    h, rem = divmod(total, 3600)
+    m, sec = divmod(rem, 60)
+    ms = int(td.microseconds / 1000)
+    return f"{h:02}:{m:02}:{sec:02},{ms:03}"
+
+
+def _clean_text(text: str) -> str:
+    """Minimal cleaning: strip, collapse whitespace."""
+    text = text.strip()
+    text = re.sub(r"\r\n|\r", "\n", text)
+    text = re.sub(r"([.,!?…])([^\W\d_])", r"\1 \2", text)
+    text = re.sub(r"[ \t]+", " ", text)
+    return text
+
+
+def _is_speakable(text: str) -> bool:
+    return bool(re.search(r"\w", text))
+
+
+def _is_vietnamese(language: str) -> bool:
+    return language.lower() in ("vietnamese", "tiếng việt", "vi", "vie")
+
+
+def _preprocess_text(text: str, language: str = "auto") -> str:
+    """Full preprocessing: universal clean + language-specific normalization."""
+    if _TEXT_CLEANER_AVAILABLE:
+        try:
+            return preprocess_for_tts(text, language=language)
+        except Exception as e:
+            logger.warning(f"[mode_omni_batch] text_cleaner failed: {e} — passthrough")
+            return text
+    return text
+
+
+# ─── Macro Chunker ─────────────────────────────────────
+
+def omni_smart_chunk_text(text: str, max_chars: int = 3000, language: str = "auto") -> List[str]:
+    """
+    Split text into large blocks (macro chunks) to prevent OOM
+    while maintaining massive emotional context.
+    """
+    clean = (text or "").strip()
+    if not clean:
+        return []
+
+    def has_cjk(value: str) -> bool:
+        return bool(re.search(r"[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]", value))
+
+    is_cjk = has_cjk(clean)
+
+    pattern = r'([.!?…।؟。！？]+[\"\u0027\u201c\u201d\u2018\u2019]?(?:[ \t]+|\n+|$))'
+    parts = re.split(pattern, clean)
+    raw_parts = []
+    for i in range(0, len(parts) - 1, 2):
+        sent = parts[i] + parts[i+1]
+        if sent.strip():
+            raw_parts.append(sent.strip())
+    if len(parts) % 2 != 0 and parts[-1].strip():
+        raw_parts.append(parts[-1].strip())
+
+    sentences: List[str] = []
+    for part in raw_parts:
+        sub = [s.strip() for s in part.splitlines() if s.strip()]
+        sentences.extend(sub if sub else [part])
+
+    chunks: List[str] = []
+    buffer = ""
+
+    def _len(t: str) -> int:
+        return len(re.sub(r"\s+", "", t)) if is_cjk else len(t)
+
+    for sent in sentences:
+        if not sent:
+            continue
+        sent_len = _len(sent)
+        if not buffer:
+            buffer = sent
+        elif _len(buffer) + sent_len + 1 <= max_chars + 50:
+            buffer = buffer + " " + sent
+        else:
+            chunks.append(buffer)
+            buffer = sent
+
+    if buffer:
+        chunks.append(buffer)
+
+    return chunks if chunks else ([clean] if clean else [])
+
+
+# ─── Smart SRT sub-splitter ──────────────────────────────────────────────────
+
+def _split_srt_text(text: str, max_chars: int = MAX_SRT_CHARS) -> List[str]:
+    text = text.strip()
+    if not text:
+        return []
+    if len(text) <= max_chars:
+        return [text]
+
+    sentence_pat = re.compile(r'([.!?…।؟。！？]+["\u2018\u2019\u201c\u201d]?(?:\s+|$))')
+    parts = sentence_pat.split(text)
+    sentences: List[str] = []
+    for i in range(0, len(parts) - 1, 2):
+        sent = (parts[i] + parts[i + 1]).strip()
+        if sent:
+            sentences.append(sent)
+    if len(parts) % 2 != 0 and parts[-1].strip():
+        sentences.append(parts[-1].strip())
+
+    if not sentences:
+        sentences = [text]
+
+    result: List[str] = []
+    buffer = ""
+    for sent in sentences:
+        if not buffer:
+            buffer = sent
+        elif len(buffer) + 1 + len(sent) <= max_chars:
+            buffer = buffer + " " + sent
+        else:
+            result.append(buffer)
+            buffer = sent
+
+    if buffer:
+        result.append(buffer)
+
+    final: List[str] = []
+    for piece in result:
+        if len(piece) <= max_chars:
+            final.append(piece)
+        else:
+            words = piece.split()
+            sub_lines = []
+            line = ""
+            for w in words:
+                if not line:
+                    line = w
+                elif len(line) + 1 + len(w) <= max_chars:
+                    line += " " + w
+                else:
+                    sub_lines.append(line)
+                    line = w
+            if line:
+                sub_lines.append(line)
+            
+            # Balance trailing words to avoid completely isolated 1-2 word SRT blocks
+            while len(sub_lines) >= 2:
+                prev = sub_lines[-2].split()
+                curr = sub_lines[-1].split()
+                if len(sub_lines[-1]) < len(sub_lines[-2]) - 15 and len(prev) > 1:
+                    word = prev.pop()
+                    new_curr = word + " " + " ".join(curr)
+                    new_prev = " ".join(prev)
+                    if len(new_curr) <= max_chars:
+                        sub_lines[-2] = new_prev
+                        sub_lines[-1] = new_curr
+                        continue
+                break
+            
+            final.extend(sub_lines)
+
+    return final if final else [text]
+
+
+# ─── Main batch function ──────────────────────────────────────────────────────
+
+def process_omni_batch_txt(
+    txt_paths_str: str,
+    omni_voice_name: str,
+    speed: float = 1.0,
+    do_norm: bool = True,
+    num_step: int = 32,
+    language: str = "auto",
+    use_flash_attn: bool = False,
+    use_flash_whl: str = "",
+    enable_precheck: bool = True,
+    precheck_punct: str = ".,!?;:。？！…",
+    precheck_max_len: int = 400,
+    # Prosodic pause config
+    pause_sentence_ms: int = 500,
+    pause_comma_ms: int = 180,
+    pause_semicolon_ms: int = 300,
+    pause_colon_ms: int = 250,
+    pause_ellipsis_ms: int = 700,
+    pause_newline_ms: int = 600,
+    pause_default_ms: int = 80,
+    progress=gr.Progress(),
+) -> Generator[str, None, None]:
+
+    t_batch_start = time.perf_counter()
+
+    pause_cfg = PauseConfig(
+        sentence_ms=int(pause_sentence_ms),
+        comma_ms=int(pause_comma_ms),
+        semicolon_ms=int(pause_semicolon_ms),
+        colon_ms=int(pause_colon_ms),
+        ellipsis_ms=int(pause_ellipsis_ms),
+        newline_ms=int(pause_newline_ms),
+        default_ms=int(pause_default_ms),
+    )
+
+    is_vn = _is_vietnamese(language)
+    lang_label = "Tiếng Việt" if is_vn else language.upper()
+
+    log = f"[{_ts()}] 🌍 BẮT ĐẦU OMNI HYBRID BATCH ({lang_label} — OmniVoice 600+ Lang)...\n"
+    logger.info("[mode_omni_batch] ═══ process_omni_batch_txt START ═══")
+    yield log
+
+    from .voice_library_vi import resolve_vi_ref, NONE_CHOICE
+    if not omni_voice_name or omni_voice_name == NONE_CHOICE:
+        log += f"[{_ts()}] ❌ LỖI: Chưa chọn voice!\n"
+        yield log
+        return
+
+    ref_audio_path, ref_text = resolve_vi_ref(omni_voice_name)
+    if ref_audio_path is None:
+        log += f"[{_ts()}] ❌ LỖI: Voice '{omni_voice_name}' không tìm thấy file audio!\n"
+        yield log
+        return
+
+    log += f"[{_ts()}] 🎤 Voice: {omni_voice_name}\n"
+    log += f"[{_ts()}] 🌐 Language: {lang_label}\n"
+    yield log
+
+    folders = [p.strip() for p in (txt_paths_str or "").split("\n")
+               if p.strip() and os.path.isdir(p.strip())]
+    if not folders:
+        log += f"[{_ts()}] ❌ LỖI: Không tìm thấy thư mục hợp lệ!\n"
+        yield log
+        return
+
+    log += f"[{_ts()}] 🔎 Quét file .txt...\n"
+    yield log
+
+    valid_txts = []
+    for d in folders:
+        for root, _, files in os.walk(d):
+            if AUTO_OUTPUT_FOLDER in root:
+                continue
+            for f in sorted(files):
+                if not f.lower().endswith(".txt"):
+                    continue
+                path = os.path.join(root, f)
+                try:
+                    with open(path, "r", encoding="utf-8") as fh:
+                        raw = fh.read()
+                    content = _clean_text(raw)
+                    if content and _is_speakable(content):
+                        valid_txts.append({"path": path, "content": content, "folder": d})
+                except Exception as scan_err:
+                    continue
+
+    if not valid_txts:
+        log += f"[{_ts()}] ❌ Không tìm thấy file TXT có chữ hợp lệ!\n"
+        yield log
+        return
+
+    log += f"[{_ts()}] ✅ Tìm thấy {len(valid_txts)} file TXT.\n"
+    
+    vram = get_available_vram_gb()
+    if vram >= 11.9:          # RTX 3060 12GB → props.total_memory/1024^3 = 11.999...
+        macro_chunk_size = 3000
+    elif vram >= 8.0:
+        macro_chunk_size = 2000
+    elif vram >= 6.0:
+        macro_chunk_size = 1200
+    elif vram > 0:
+        macro_chunk_size = 800
+    else:
+        macro_chunk_size = 2000
+        
+    log += f"[{_ts()}] ℹ️  GPU VRAM: {vram:.1f}GB ➜ Auto Macro Chunk: {macro_chunk_size} ký tự/block.\n"
+    yield log
+
+    log += f"[{_ts()}] ⏳ Load OmniVoice (600+ ngôn ngữ)...\n"
+    yield log
+
+    def _eng_log(msg: str):
+        nonlocal log
+        clean = msg.strip()
+        log += f"  {clean}\n"
+
+    try:
+        omni_engine.load(use_flash_attn=use_flash_attn, flash2_whl=use_flash_whl, log_callback=_eng_log)
+    except Exception as e:
+        tb = traceback.format_exc()
+        log += f"[{_ts()}] ❌ Load model thất bại: {e}\n  📋 {tb}\n"
+        yield log
+        return
+
+    total = len(valid_txts)
+    batch_results = []
+
+    for i, item in enumerate(valid_txts):
+        progress((i, total), desc=f"{i+1}/{total}...")
+        txt_path = item["path"]
+        content  = item["content"]
+        txt_name = os.path.basename(txt_path)
+        txt_base = os.path.splitext(txt_name)[0]
+
+        out_dir  = os.path.join(item["folder"], AUTO_OUTPUT_FOLDER)
+        os.makedirs(out_dir, exist_ok=True)
+
+        mp3_path = os.path.join(out_dir, f"{txt_base}.mp3")
+        srt_path = os.path.join(out_dir, f"{txt_base}.srt")
+
+        if os.path.exists(mp3_path) and os.path.exists(srt_path):
+            log += f"[{_ts()}] ⏭ BỎ QUA (đã có): {txt_name}\n"
+            yield log
+            continue
+
+        t_file_start = time.perf_counter()
+        log += f"\n[{_ts()}] ▶ Đang xử lý: {txt_name} ({len(content)} ký tự)\n"
+        yield log
+
+        # Pre-check
+        if enable_precheck and precheck_punct:
+            valid_puncts = [p for p in precheck_punct if p.strip()]
+            if valid_puncts:
+                has_any = any(p in content for p in valid_puncts)
+                if not has_any:
+                    log += f"  ⏭ BỎ QUA (Pre-check): Toàn bộ văn bản không chứa bất kỳ dấu câu nào trong tập [{precheck_punct}]\n"
+                    yield log
+                    batch_results.append((txt_name, False))
+                    continue
+                
+                import re
+                escaped = [re.escape(p) for p in valid_puncts]
+                pattern = "|".join(escaped)
+                segments = re.split(pattern, content)
+                failed_precheck = False
+                for seg in segments:
+                    if len(seg.strip()) > precheck_max_len:
+                        log += f"  ⏭ BỎ QUA (Pre-check): Phát hiện đoạn văn quá dài ({len(seg.strip())} ký tự) không có dấu câu.\n"
+                        failed_precheck = True
+                        break
+                
+                if failed_precheck:
+                    yield log
+                    batch_results.append((txt_name, False))
+                    continue
+
+        # Preprocessing
+        normalized = _preprocess_text(content, language=language)
+        if normalized != content:
+            log += f"  🧹 Text cleaned: {len(content)} → {len(normalized)} ký tự\n"
+            yield log
+
+        if not normalized.strip():
+            log += f"  ⚠️ {txt_name}: Text rỗng sau khi clean — bỏ qua!\n"
+            yield log
+            batch_results.append((txt_name, False))
+            continue
+
+        # Macro Chunking
+        blocks = omni_smart_chunk_text(normalized, max_chars=macro_chunk_size, language=language)
+        log += f"  ✂️ Text chia làm {len(blocks)} block lớn (max {macro_chunk_size} char) để chống OOM\n"
+        yield log
+
+        phase_arrays: List[np.ndarray] = []
+        srt_entries  = []
+        srt_idx      = 1
+        global_cursor = 0.0
+        
+        has_fatal = False
+
+        for b_idx, block_text in enumerate(blocks):
+            if not block_text.strip():
+                continue
+                
+            log += f"  ⏳ Generate Block {b_idx+1}/{len(blocks)} ({len(block_text)} chars)...\n"
+            yield log
+            
+            try:
+                segment_arrays, sr = omni_engine.infer(
+                    ref_audio_path=ref_audio_path,
+                    ref_text=ref_text,
+                    gen_text=block_text,
+                    language=language,
+                    speed=speed,
+                    num_step=num_step,
+                )
+            except Exception as infer_err:
+                tb = traceback.format_exc()
+                log += f"  ❌ INFER FAILED block {b_idx+1}: {infer_err}\n"
+                has_fatal = True
+                break
+
+            if not segment_arrays:
+                log += f"  ⚠️ Block {b_idx+1}: Không có audio! Bỏ qua block.\n"
+                continue
+                
+            seg_texts = _distribute_text_to_segments(block_text, segment_arrays, sr)
+            
+            for seg_i, (arr, seg_text) in enumerate(zip(segment_arrays, seg_texts)):
+                arr_dur = len(arr) / sr
+                pause_ms = detect_pause_ms(seg_text, pause_cfg)
+                sil = make_silence(pause_ms)
+
+                phase_arrays.append(arr)
+                phase_arrays.append(sil)
+
+                seg_spd_dur = arr_dur / max(speed, 0.1)
+                gap_dur = (pause_ms / 1000.0) / max(speed, 0.1)
+
+                srt_lines = _split_srt_text(seg_text, MAX_SRT_CHARS)
+                n_lines = len(srt_lines)
+
+                if n_lines == 0:
+                    global_cursor += seg_spd_dur + gap_dur
+                    continue
+
+                total_chars = sum(len(line.strip()) for line in srt_lines)
+                
+                if total_chars == 0:
+                    line_dur = seg_spd_dur / n_lines
+                    for li, line_text in enumerate(srt_lines):
+                        line_start = global_cursor + li * line_dur
+                        line_end   = line_start + line_dur
+                        srt_entries.append({
+                            "idx":   srt_idx,
+                            "start": _fmt_ts(line_start),
+                            "end":   _fmt_ts(line_end),
+                            "text":  line_text,
+                        })
+                        srt_idx += 1
+                    global_cursor += seg_spd_dur + gap_dur
+                else:
+                    for line_text in srt_lines:
+                        line_weight = len(line_text.strip()) / total_chars
+                        line_dur = seg_spd_dur * line_weight
+                        
+                        line_start = global_cursor
+                        line_end   = global_cursor + line_dur
+                        
+                        srt_entries.append({
+                            "idx":   srt_idx,
+                            "start": _fmt_ts(line_start),
+                            "end":   _fmt_ts(line_end),
+                            "text":  line_text,
+                        })
+                        srt_idx += 1
+                        global_cursor += line_dur
+                    
+                    global_cursor += gap_dur
+
+            if _TORCH and _TORCH.cuda.is_available():
+                _TORCH.cuda.empty_cache()
+
+        if has_fatal or not phase_arrays:
+            log += f"  ❌ {txt_name}: Thất bại ở một hoặc toàn bộ block!\n"
+            yield log
+            batch_results.append((txt_name, False))
+            continue
+
+        # ── Write WAV → MP3 ──
+        cache_dir = os.path.join(out_dir, "_omni_caches", txt_base)
+        os.makedirs(cache_dir, exist_ok=True)
+        tmp_wav = os.path.join(cache_dir, f"tmp_{uuid.uuid4().hex}.wav")
+        try:
+            sf.write(tmp_wav, np.concatenate(phase_arrays), sr)
+            filt = _build_atempo(speed)
+            if do_norm:
+                filt.append("loudnorm=I=-16:TP=-1.5:LRA=11")
+
+            cmd = ["ffmpeg", "-y", "-i", tmp_wav]
+            if filt:
+                cmd += ["-filter:a", ",".join(filt)]
+            cmd += ["-c:a", "libmp3lame", "-b:a", "192k", "-loglevel", "error", mp3_path]
+
+            ff_flags = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+            if ff_flags:
+                subprocess.run(cmd, check=True, creationflags=ff_flags)
+            else:
+                subprocess.run(cmd, check=True)
+
+            if not os.path.exists(mp3_path) or os.path.getsize(mp3_path) < 1024:
+                log += f"  ⚠️ {txt_name}: MP3 tạo ra bị thiếu hoặc rỗng!\n"
+                yield log
+        except Exception as e:
+            tb = traceback.format_exc()
+            log += f"  ❌ FFmpeg {txt_name}: {e}\n  📋 {tb}\n"
+            yield log
+        finally:
+            if os.path.exists(tmp_wav):
+                try: os.remove(tmp_wav)
+                except Exception: pass
+
+        # ── Write SRT ──
+        if srt_entries:
+            with open(srt_path, "w", encoding="utf-8") as f:
+                for s in srt_entries:
+                    f.write(f"{s['idx']}\n{s['start']} --> {s['end']}\n{s['text']}\n\n")
+
+        # ── Auto validate ──
+        if os.path.exists(mp3_path) and os.path.exists(srt_path):
+            try:
+                rpt = validate_audio_vs_srt(mp3_path, srt_path)
+                if rpt.overall_status == "PASS":
+                    log += f"[{_ts()}] ✅ XÁC NHẬN: {txt_name} — ĐẦY ĐỦ ({rpt.passed_entries}/{rpt.srt_total_entries})  [{rpt.audio_duration:.0f}s audio]\n"
+                    batch_results.append((txt_name, True))
+                elif rpt.overall_status == "WARN":
+                    log += f"[{_ts()}] ⚠️ CẢNH BÁO: {txt_name} — (File MP3 vẫn OK! {rpt.total_issues} vấn đề nhỏ)\n"
+                    log += format_validation_report(rpt) + "\n"
+                    batch_results.append((txt_name, True))
+                else:
+                    # FAIL ≠ audio mất — file MP3 vẫn được lưu.
+                    # Thường là SRT_OVERFLOW (timing drift tích lũy qua nhiều blocks)
+                    # hoặc MISSING_AUDIO coverage thấp ở vài SRT entries.
+                    log += f"[{_ts()}] ⚠️ VALIDATION FAIL: {txt_name} — (MP3 OK, SRT timing lệch)\n"
+                    log += format_validation_report(rpt) + "\n"
+                    batch_results.append((txt_name, True))
+            except Exception as val_err:
+                log += f"[{_ts()}] ⚠️ {txt_name}: Validate lỗi (bỏ qua): {val_err}\n"
+                batch_results.append((txt_name, True))
+            yield log
+        else:
+            log += f"[{_ts()}] ⚠️ {txt_name}: MP3/SRT lỗi không được tạo.\n"
+            yield log
+            batch_results.append((txt_name, False))
+
+        gc.collect()
+
+    progress((total, total), desc="Done")
+
+    n_pass = sum(1 for _, ok in batch_results if ok)
+    batch_elapsed = time.perf_counter() - t_batch_start
+
+    log += f"\n{'='*60}\n"
+    log += f"[{_ts()}] 🏁 KẾT QUẢ BATCH: {n_pass}/{len(batch_results)} file ĐẠT\n"
+    log += f"[{_ts()}] ⏱️ Tổng thời gian: {batch_elapsed:.1f}s\n{'='*60}\n"
+    yield log
+
+
+def _distribute_text_to_segments(full_text: str, segment_arrays: List[np.ndarray], sr: int) -> List[str]:
+    if len(segment_arrays) == 1:
+        return [full_text.strip()]
+    sent_pat = re.compile(r'(?<=[.!?。！？…])\s+|(?<=\n)')
+    sentences = [s.strip() for s in sent_pat.split(full_text) if s.strip()]
+    if not sentences:
+        sentences = [full_text.strip()]
+    durations = [len(arr) / sr for arr in segment_arrays]
+    total_dur = sum(durations)
+    if total_dur <= 0 or len(sentences) == 0:
+        return [full_text.strip()] * len(segment_arrays)
+
+    total_chars = sum(len(s) for s in sentences)
+    seg_char_budgets = [max(1, int(d / total_dur * total_chars)) for d in durations]
+    seg_texts: List[str] = []
+    sent_idx = 0
+    for bi, budget in enumerate(seg_char_budgets):
+        bucket: List[str] = []
+        chars_used = 0
+        if bi == len(seg_char_budgets) - 1:
+            bucket = sentences[sent_idx:]
+        else:
+            while sent_idx < len(sentences):
+                s = sentences[sent_idx]
+                if chars_used == 0 or chars_used + len(s) <= budget + 20:
+                    bucket.append(s)
+                    chars_used += len(s)
+                    sent_idx += 1
+                else:
+                    break
+        seg_texts.append(" ".join(bucket).strip() if bucket else "")
+    while len(seg_texts) < len(segment_arrays):
+        seg_texts.append("")
+    return seg_texts[:len(segment_arrays)]
+
+
+def _build_atempo(speed: float) -> List[str]:
+    if abs(speed - 1.0) < 0.01:
+        return []
+    filters: List[str] = []
+    s = float(speed)
+    while s > 2.0:
+        filters.append("atempo=2.0")
+        s /= 2.0
+    while s < 0.5:
+        filters.append("atempo=0.5")
+        s *= 2.0
+    filters.append(f"atempo={s:.6f}")
+    return filters

source/qwen_app/mode_omni_news.py

@@ -0,0 +1,944 @@
+# qwen_app/mode_omni_news.py  — v1.0 (OmniVoice Phase Batch)
+# ─── Bê nguyên logic Mode3 News Bats từ FAST source sang OMMI ─────────────────
+# Chạy theo dạng PHASE: STORY | PHASE N | text | Prompt N: ...
+# Thay Qwen engine → OmniVoice engine (600+ ngôn ngữ)
+# Output: Per-phase MP3 + FULL_MASTER.srt (giống FAST)
+# Text clean: preprocess_for_tts() (universal + vi_normalizer)
+# Multi-encoding parser: utf-8, utf-8-sig, cp1258, cp1252
+# ──────────────────────────────────────────────────────────────────────────────
+
+from __future__ import annotations
+
+import gc
+import hashlib
+import logging
+import os
+import re
+import sys
+import subprocess
+import time
+import traceback
+import uuid
+from datetime import timedelta
+from typing import Generator, List, Optional, Tuple
+
+import numpy as np
+import soundfile as sf
+import gradio as gr
+
+try:
+    import torch
+    _TORCH = torch
+except ImportError:
+    _TORCH = None  # type: ignore
+
+from .omni_engine import (
+    omni_engine,
+    get_available_vram_gb,
+    SILENCE_THRESHOLD,
+)
+from .prosody import PauseConfig, DEFAULT_PAUSE, make_silence, detect_pause_ms
+from .audio_validator import (
+    validate_audio_vs_srt,
+    format_validation_report,
+    check_array_energy,
+)
+
+try:
+    from .text_cleaner import preprocess_for_tts
+    _TEXT_CLEANER_AVAILABLE = True
+except ImportError:
+    _TEXT_CLEANER_AVAILABLE = False
+
+logger = logging.getLogger("qwen_app.mode_omni_news")
+
+# ─── Constants ────────────────────────────────────────────────────────────────
+AUTO_PROJECT_OUTPUT_FOLDER_NAME = "_OUTPUT_PROJECTS"
+MAX_SRT_CHARS = 80
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+def _ts() -> str:
+    return time.strftime("%H:%M:%S")
+
+
+def _fmt_ts(seconds: float) -> str:
+    s = max(0.0, seconds)
+    td = timedelta(seconds=s)
+    total = int(td.total_seconds())
+    h, rem = divmod(total, 3600)
+    m, sec = divmod(rem, 60)
+    ms = int(td.microseconds / 1000)
+    return f"{h:02}:{m:02}:{sec:02},{ms:03}"
+
+
+def sanitize_filename(name: str) -> str:
+    return re.sub(r'[/*?:"<>|]', "", name)
+
+
+def generate_clean_guid(s: str) -> str:
+    return hashlib.sha1(s.encode("utf-8")).hexdigest()[:16]
+
+
+def _natural_sort_key(s: str):
+    return [int(c) if c.isdigit() else c.lower() for c in re.split(r"(\d+)", s)]
+
+
+def _is_speakable(text: str) -> bool:
+    return bool(re.search(r"[a-zA-Z0-9\u00C0-\u1EF9\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]", text))
+
+
+def _has_cjk(text: str) -> bool:
+    return bool(re.search(r"[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]", text))
+
+
+# ─── Text pre-cleaner (giữ cấu trúc PHASE format, chỉ làm sạch nội dung) ─────
+
+def _clean_phase_text(text: str) -> str:
+    """Minimal inline cleaner cho text trong PHASE block (trước khi gọi preprocess_for_tts)."""
+    if not text:
+        return ""
+    text = text.replace("…", "...")
+    text = re.sub(r'[""]', '"', text)
+    text = re.sub(r"['']", "'", text)
+    text = re.sub(r"([!?。！？]){2,}", r"\1\1", text)
+    text = re.sub(r"([,;،、；:]){2,}", r"\1", text)
+    text = re.sub(r"\.{4,}", "...", text)
+    text = re.sub(r"([.,!?])([^\W\d_])", r"\1 \2", text)
+    text = "".join(ch for ch in text if ch.isprintable() or ch == "\n")
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _preprocess_phase_text(text: str, language: str = "auto") -> str:
+    """Full clean: minimal inline → preprocess_for_tts (text_cleaner + vi_normalizer)."""
+    text = _clean_phase_text(text)
+    if _TEXT_CLEANER_AVAILABLE:
+        try:
+            return preprocess_for_tts(text, language=language)
+        except Exception as e:
+            logger.warning(f"[mode_omni_news] text_cleaner failed: {e} — passthrough")
+    return text
+
+
+# ─── Project Parser (FAST source, multi-encoding) ─────────────────────────────
+
+class ProjectParser:
+    @staticmethod
+    def parse_txt(file_path: str, project_folder_name: str):
+        """
+        Parse PHASE format:
+            STORY | ... PHASE N | text | Prompt N: ...  END GAMES
+        Multi-encoding: utf-8, utf-8-sig, cp1258, cp1252.
+        Returns (phases_list_sorted, None) or (None, None).
+        """
+        try:
+            content = ""
+            for enc in ["utf-8", "utf-8-sig", "cp1258", "cp1252"]:
+                try:
+                    with open(file_path, "r", encoding=enc) as f:
+                        content = f.read()
+                    break
+                except (UnicodeDecodeError, LookupError):
+                    continue
+            if not content:
+                with open(file_path, "r", encoding="cp1252", errors="replace") as f:
+                    content = f.read()
+
+            if "STORY |" not in content or "END GAMES" not in content:
+                return None, None
+
+            core = content.split("STORY |")[1].split("END GAMES")[0].strip()
+            g = generate_clean_guid(
+                f"{sanitize_filename(project_folder_name)}_"
+                f"{sanitize_filename(os.path.splitext(os.path.basename(file_path))[0])}"
+            )
+            pattern = re.compile(
+                r"PHASE\s+(\d+)\s*\|\s*(.*?)\s*\|\s*Prompt\s*\d+\s*:\s*(.*?)(?=\n\s*PHASE|\Z)",
+                re.DOTALL | re.IGNORECASE,
+            )
+            phases = []
+            for m in pattern.findall(core):
+                txt = _clean_phase_text(m[1].strip())
+                if txt:
+                    phases.append({
+                        "id":          int(m[0].strip()),
+                        "text":        txt,
+                        "prompt":      m[2].strip(),
+                        "prompt_name": f"{m[0].strip()}_PHASE_{g}",
+                    })
+            if phases:
+                return sorted(phases, key=lambda x: x["id"]), None
+        except Exception:
+            pass
+        return None, None
+
+
+# ─── Macro Chunker (từ mode_omni_batch, VRAM-aware) ──────────────────────────
+
+def _omni_smart_chunk_text(text: str, max_chars: int = 3000) -> List[str]:
+    """Split text thành macro blocks để tránh OOM khi infer OmniVoice."""
+    clean = (text or "").strip()
+    if not clean:
+        return []
+
+    is_cjk = _has_cjk(clean)
+    # Lookbehind split: cat SAU dau cau ket thuc
+    sentence_end = re.compile(r'(?<=[.!?])[\s]+')
+    raw_sents = sentence_end.split(clean)
+
+    sentences: List[str] = []
+    for _s in raw_sents:
+        _stripped = _s.strip()
+        if not _stripped:
+            continue
+        for sub in _stripped.splitlines():
+            sub = sub.strip()
+            if sub:
+                sentences.append(sub)
+
+    if not sentences:
+        sentences = [clean]
+
+    def _len(t: str) -> int:
+        return len(re.sub(r"\s+", "", t)) if is_cjk else len(t)
+
+    chunks: List[str] = []
+    buffer = ""
+    for sent in sentences:
+        if not sent:
+            continue
+        sent_len = _len(sent)
+        if not buffer:
+            buffer = sent
+        elif _len(buffer) + sent_len + 1 <= max_chars + 50:
+            buffer = buffer + " " + sent
+        else:
+            chunks.append(buffer)
+            buffer = sent
+    if buffer:
+        chunks.append(buffer)
+
+    return chunks if chunks else ([clean] if clean else [])
+
+
+# ─── SRT sub-splitter (từ mode_omni_batch) ────────────────────────────────────
+
+def _split_srt_text(text: str, max_chars: int = MAX_SRT_CHARS) -> List[str]:
+    text = text.strip()
+    if not text:
+        return []
+    if len(text) <= max_chars:
+        return [text]
+
+    sentence_pat = re.compile(r'([.!?…।؟。！？]+["\u2018\u2019\u201c\u201d]?(?:\s+|$))')
+    parts = sentence_pat.split(text)
+    sentences: List[str] = []
+    for i in range(0, len(parts) - 1, 2):
+        sent = (parts[i] + parts[i + 1]).strip()
+        if sent:
+            sentences.append(sent)
+    if len(parts) % 2 != 0 and parts[-1].strip():
+        sentences.append(parts[-1].strip())
+    if not sentences:
+        sentences = [text]
+
+    result: List[str] = []
+    buffer = ""
+    for sent in sentences:
+        if not buffer:
+            buffer = sent
+        elif len(buffer) + 1 + len(sent) <= max_chars:
+            buffer = buffer + " " + sent
+        else:
+            result.append(buffer)
+            buffer = sent
+    if buffer:
+        result.append(buffer)
+
+    final: List[str] = []
+    for piece in result:
+        if len(piece) <= max_chars:
+            final.append(piece)
+        else:
+            words = piece.split()
+            sub_lines = []
+            line = ""
+            for w in words:
+                if not line:
+                    line = w
+                elif len(line) + 1 + len(w) <= max_chars:
+                    line += " " + w
+                else:
+                    sub_lines.append(line)
+                    line = w
+            if line:
+                sub_lines.append(line)
+
+            # Balance trailing words to avoid completely isolated 1-2 word SRT blocks
+            while len(sub_lines) >= 2:
+                prev = sub_lines[-2].split()
+                curr = sub_lines[-1].split()
+                if len(sub_lines[-1]) < len(sub_lines[-2]) - 15 and len(prev) > 1:
+                    word = prev.pop()
+                    new_curr = word + " " + " ".join(curr)
+                    new_prev = " ".join(prev)
+                    if len(new_curr) <= max_chars:
+                        sub_lines[-2] = new_prev
+                        sub_lines[-1] = new_curr
+                        continue
+                break
+
+            final.extend(sub_lines)
+
+    return final if final else [text]
+
+
+# ─── Distribute text to OmniVoice segments (từ mode_omni_batch) ───────────────
+
+def _distribute_text_to_segments(
+    full_text: str, segment_arrays: List[np.ndarray], sr: int
+) -> List[str]:
+    if len(segment_arrays) == 1:
+        return [full_text.strip()]
+    sent_pat = re.compile(r"(?<=[.!?。！？…])\s+|(?<=\n)")
+    sentences = [s.strip() for s in sent_pat.split(full_text) if s.strip()]
+    if not sentences:
+        sentences = [full_text.strip()]
+    durations = [len(arr) / sr for arr in segment_arrays]
+    total_dur = sum(durations)
+    if total_dur <= 0 or not sentences:
+        return [full_text.strip()] * len(segment_arrays)
+
+    total_chars = sum(len(s) for s in sentences)
+    seg_char_budgets = [max(1, int(d / total_dur * total_chars)) for d in durations]
+    seg_texts: List[str] = []
+    sent_idx = 0
+    for bi, budget in enumerate(seg_char_budgets):
+        bucket: List[str] = []
+        chars_used = 0
+        if bi == len(seg_char_budgets) - 1:
+            bucket = sentences[sent_idx:]
+        else:
+            while sent_idx < len(sentences):
+                s = sentences[sent_idx]
+                if chars_used == 0 or chars_used + len(s) <= budget + 20:
+                    bucket.append(s)
+                    chars_used += len(s)
+                    sent_idx += 1
+                else:
+                    break
+        seg_texts.append(" ".join(bucket).strip() if bucket else "")
+    while len(seg_texts) < len(segment_arrays):
+        seg_texts.append("")
+    return seg_texts[: len(segment_arrays)]
+
+
+# ─── FFmpeg: WAV → MP3 ───────────────────────────────────────────────────────
+
+def _build_atempo(speed: float) -> List[str]:
+    if abs(speed - 1.0) < 0.01:
+        return []
+    filters: List[str] = []
+    s = float(speed)
+    while s > 2.0:
+        filters.append("atempo=2.0")
+        s /= 2.0
+    while s < 0.5:
+        filters.append("atempo=0.5")
+        s *= 2.0
+    filters.append(f"atempo={s:.6f}")
+    return filters
+
+
+def _wav_to_mp3(tmp_wav: str, mp3_out: str, speed: float, do_norm: bool) -> bool:
+    cmd = ["ffmpeg", "-y", "-i", tmp_wav]
+    filt = _build_atempo(speed)
+    if do_norm:
+        filt.append("loudnorm=I=-16:TP=-1.5:LRA=11")
+    if filt:
+        cmd += ["-filter:a", ",".join(filt)]
+    cmd += ["-c:a", "libmp3lame", "-b:a", "192k", "-loglevel", "error", mp3_out]
+    try:
+        ff_flags = subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0
+        subprocess.run(cmd, check=True, creationflags=ff_flags)
+        return os.path.exists(mp3_out) and os.path.getsize(mp3_out) >= 1024
+    except Exception:
+        return False
+
+
+# ─── SRT writer ───────────────────────────────────────────────────────────────
+
+def _write_srt(path: str, entries: list):
+    with open(path, "w", encoding="utf-8") as f:
+        for s in entries:
+            f.write(f"{s['idx']}\n{s['start']} --> {s['end']}\n{s['text']}\n\n")
+
+
+# ─── Main batch function ──────────────────────────────────────────────────────
+
+def process_omni_news_batch(
+    txt_paths_str: str,
+    omni_voice_name: str,
+    speed: float = 1.0,
+    do_norm: bool = True,
+    num_step: int = 32,
+    language: str = "auto",
+    use_flash_attn: bool = False,
+    use_flash_whl: str = "",
+    enable_precheck: bool = True,
+    precheck_punct: str = ".,!?;:。？！…",
+    precheck_max_len: int = 400,
+    # Prosodic pause config
+    pause_sentence_ms: int = 500,
+    pause_comma_ms: int = 180,
+    pause_semicolon_ms: int = 300,
+    pause_colon_ms: int = 250,
+    pause_ellipsis_ms: int = 700,
+    pause_newline_ms: int = 600,
+    pause_default_ms: int = 80,
+    progress=gr.Progress(),
+) -> Generator[str, None, None]:
+
+    t_batch_start = time.perf_counter()
+
+    pause_cfg = PauseConfig(
+        sentence_ms=int(pause_sentence_ms),
+        comma_ms=int(pause_comma_ms),
+        semicolon_ms=int(pause_semicolon_ms),
+        colon_ms=int(pause_colon_ms),
+        ellipsis_ms=int(pause_ellipsis_ms),
+        newline_ms=int(pause_newline_ms),
+        default_ms=int(pause_default_ms),
+    )
+
+    lang_label = language.upper() if language and language.lower() != "auto" else "AUTO"
+    log = f"[{_ts()}] 🚀 BẮT ĐẦU OMNI NEWS BATCH (Phase Mode — OmniVoice 600+ Lang)...\n"
+    log += f"[{_ts()}] 🌐 Language: {lang_label}\n"
+    yield log
+
+    # ── Resolve voice ──────────────────────────────────────────────────────────
+    from .voice_library_vi import resolve_vi_ref, NONE_CHOICE
+    if not omni_voice_name or omni_voice_name == NONE_CHOICE:
+        log += f"[{_ts()}] ❌ LỖI: Chưa chọn voice!\n"
+        yield log
+        return
+
+    ref_audio_path, ref_text = resolve_vi_ref(omni_voice_name)
+    if ref_audio_path is None:
+        log += f"[{_ts()}] ❌ LỖI: Voice '{omni_voice_name}' không tìm thấy file audio!\n"
+        yield log
+        return
+
+    log += f"[{_ts()}] 🎤 Voice: {omni_voice_name}\n"
+    yield log
+
+    # ── Validate paths ─────────────────────────────────────────────────────────
+    folders = [p.strip() for p in (txt_paths_str or "").split("\n")
+               if p.strip() and os.path.isdir(p.strip())]
+    if not folders:
+        log += f"[{_ts()}] ❌ LỖI: Không tìm thấy thư mục hợp lệ!\n"
+        yield log
+        return
+
+    # ── Scan TXT files (PHASE format) ─────────────────────────────────────────
+    log += f"[{_ts()}] 🔎 Quét file .txt theo chuẩn PHASE...\n"
+    yield log
+
+    valid_txts = []
+    for d in folders:
+        for root, _, files in os.walk(d):
+            if AUTO_PROJECT_OUTPUT_FOLDER_NAME in root:
+                continue
+            for f in sorted(files, key=_natural_sort_key):
+                if not f.lower().endswith(".txt"):
+                    continue
+                path = os.path.join(root, f)
+                phases, _ = ProjectParser.parse_txt(
+                    path, os.path.basename(os.path.dirname(path))
+                )
+                if phases:
+                    valid_txts.append({
+                        "path":   path,
+                        "group":  os.path.basename(os.path.normpath(d)),
+                        "phases": phases,
+                    })
+
+    if not valid_txts:
+        log += f"[{_ts()}] ❌ Không tìm thấy Story nào theo chuẩn PHASE (STORY | ... END GAMES)!\n"
+        log += f"[{_ts()}] ℹ️  Định dạng cần có: STORY | ... PHASE N | nội dung | Prompt N: ... END GAMES\n"
+        yield log
+        return
+
+    log += f"[{_ts()}] ✅ Tìm thấy {len(valid_txts)} story hợp lệ.\n"
+    yield log
+
+    # ── VRAM-aware macro chunk size ────────────────────────────────────────────
+    vram = get_available_vram_gb()
+    if vram >= 11.9:
+        macro_chunk_size = 3000
+    elif vram >= 8.0:
+        macro_chunk_size = 2000
+    elif vram >= 6.0:
+        macro_chunk_size = 1200
+    elif vram > 0:
+        macro_chunk_size = 800
+    else:
+        macro_chunk_size = 2000
+
+    log += f"[{_ts()}] ℹ️  GPU VRAM: {vram:.1f}GB ➜ Macro Chunk: {macro_chunk_size} ký tự/block.\n"
+    yield log
+
+    # ── Load OmniVoice ─────────────────────────────────────────────────────────
+    log += f"[{_ts()}] ⏳ Load OmniVoice (600+ ngôn ngữ)...\n"
+    yield log
+
+    def _eng_log(msg: str):
+        nonlocal log
+        log += f"  {msg.strip()}\n"
+
+    try:
+        omni_engine.load(use_flash_attn=use_flash_attn, flash2_whl=use_flash_whl, log_callback=_eng_log)
+        yield log
+    except Exception as e:
+        tb = traceback.format_exc()
+        log += f"[{_ts()}] ❌ Load model thất bại: {e}\n  📋 {tb}\n"
+        yield log
+        return
+
+    log += f"[{_ts()}] ✅ OmniVoice sẵn sàng!\n"
+    yield log
+
+    CACHE_DIR = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), "..", "Qwen_Mode3_Cache"
+    )
+    os.makedirs(CACHE_DIR, exist_ok=True)
+
+    total = len(valid_txts)
+    batch_results = []  # (txt_name, passed: bool)
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    for i, item in enumerate(valid_txts):
+        progress((i, total), desc=f"{i+1}/{total}...")
+        txt_path = item["path"]
+        phases   = item["phases"]
+        txt_name = os.path.basename(txt_path)
+        txt_base = os.path.splitext(txt_name)[0]
+        proj_dir = os.path.dirname(txt_path)
+        out_dir  = os.path.join(proj_dir, AUTO_PROJECT_OUTPUT_FOLDER_NAME, sanitize_filename(txt_base))
+        os.makedirs(out_dir, exist_ok=True)
+
+        # Skip-if-done: kiểm tra per-phase MP3 + FULL_MASTER.srt
+        srt_master_path = os.path.join(out_dir, "FULL_MASTER.srt")
+        all_done = all(
+            os.path.exists(os.path.join(out_dir, f"{p['prompt_name']}.mp3"))
+            for p in phases
+        ) and os.path.exists(srt_master_path)
+
+        if all_done:
+            log += f"[{_ts()}] ⏭ BỎ QUA (đã hoàn thành): {txt_name}\n"
+            yield log
+            continue
+
+        log += f"\n[{_ts()}] ▶ [{item['group']}] → {txt_name} ({len(phases)} phase(s))\n"
+        yield log
+
+        # Pre-check
+        if enable_precheck and precheck_punct:
+            valid_puncts = [p for p in precheck_punct if p.strip()]
+            if valid_puncts:
+                full_text = " ".join([p["text"] for p in phases])
+                has_any = any(p in full_text for p in valid_puncts)
+                if not has_any:
+                    log += f"  ⏭ BỎ QUA (Pre-check): Toàn bộ story không chứa bất kỳ dấu câu nào trong tập [{precheck_punct}]\n"
+                    yield log
+                    batch_results.append((txt_name, False))
+                    continue
+                
+                import re
+                escaped = [re.escape(p) for p in valid_puncts]
+                pattern = "|".join(escaped)
+                segments = re.split(pattern, full_text)
+                failed_precheck = False
+                for seg in segments:
+                    if len(seg.strip()) > precheck_max_len:
+                        log += f"  ⏭ BỎ QUA (Pre-check): Phát hiện đoạn văn quá dài ({len(seg.strip())} ký tự) không có dấu câu.\n"
+                        failed_precheck = True
+                        break
+                
+                if failed_precheck:
+                    yield log
+                    batch_results.append((txt_name, False))
+                    continue
+
+        # Accumulate master SRT across all phases
+        master_srt_entries = []
+        master_srt_idx     = 1
+        master_cursor      = 0.0
+        _phase_tmp_srts    = {}
+
+        story_passed = True
+
+        # ─── 1. Preprocess and filter phases ──────────────────────────────────
+        active_phases = []
+        for phase in phases:
+            raw_text = phase["text"]
+            if not _is_speakable(raw_text):
+                continue
+
+            phase_mp3     = os.path.join(out_dir, f"{phase['prompt_name']}.mp3")
+            phase_srt_tmp = os.path.join(CACHE_DIR, f"phase_srt_{uuid.uuid4().hex}.srt")
+            _phase_tmp_srts[phase["prompt_name"]] = phase_srt_tmp
+
+            # Skip individual phase if MP3 already exists
+            if os.path.exists(phase_mp3):
+                log += f"  ⏭ Phase {phase['id']}: MP3 có sẵn, bỏ qua\n"
+                yield log
+                try:
+                    from .audio_validator import _load_audio_as_mono
+                    _d, _sr = _load_audio_as_mono(phase_mp3)
+                    master_cursor += len(_d) / _sr
+                except Exception:
+                    pass
+                continue
+
+            # Preprocess text
+            normalized = _preprocess_phase_text(raw_text, language=language)
+            if normalized != raw_text:
+                log += f"  🧹 Phase {phase['id']}: text cleaned {len(raw_text)} → {len(normalized)} ký tự\n"
+                yield log
+
+            if not normalized.strip():
+                log += f"  ⚠️ Phase {phase['id']}: text rỗng sau clean — bỏ qua!\n"
+                yield log
+                continue
+
+            phase["normalized_text"] = normalized
+            phase["audio_arrays"] = []
+            phase["phase_entries"] = []
+            phase["phase_mp3"] = phase_mp3
+            phase["phase_srt_tmp"] = phase_srt_tmp
+            active_phases.append(phase)
+
+        # ─── 2. Group into macro blocks ───────────────────────────────────────
+        macro_blocks = []
+        current_group = []
+        current_len = 0
+        for phase in active_phases:
+            # Add 2 chars for "\n\n" separator between phases
+            l = len(phase["normalized_text"]) + (2 if current_group else 0)
+            if current_len + l > macro_chunk_size and current_group:
+                macro_blocks.append(current_group)
+                current_group = [phase]
+                current_len = len(phase["normalized_text"])
+            else:
+                current_group.append(phase)
+                current_len += l
+        if current_group:
+            macro_blocks.append(current_group)
+
+        # ─── 3. Group block inference & distribution ──────────────────────────
+        for b_idx, group in enumerate(macro_blocks):
+            block_text = "\n\n".join(p["normalized_text"] for p in group)
+            log += f"  ⏳ Group {b_idx+1}/{len(macro_blocks)} ({len(group)} phases, {len(block_text)} chars) → GPU...\n"
+            yield log
+
+            try:
+                segment_arrays, sr = omni_engine.infer(
+                    ref_audio_path=ref_audio_path,
+                    ref_text=ref_text,
+                    gen_text=block_text,
+                    language=language,
+                    speed=speed,
+                    num_step=num_step,
+                )
+            except Exception as infer_err:
+                log += f"    ❌ INFER FAILED Group {b_idx+1}: {infer_err}\n"
+                story_passed = False
+                yield log
+                continue
+
+            if not segment_arrays:
+                log += f"    ⚠️ Group {b_idx+1}: Không có audio! Bỏ qua group.\n"
+                continue
+
+            seg_texts = _distribute_text_to_segments(block_text, segment_arrays, sr)
+
+            # Sub-distribute back to individual phases within the group
+            phase_idx = 0
+            chars_remaining = len(re.sub(r'\s+', '', group[phase_idx]["normalized_text"]))
+            local_cursor = 0.0
+
+            # 3a. Break into linear pieces
+            pieces = []
+            
+            for seg_i, (arr, seg_text) in enumerate(zip(segment_arrays, seg_texts)):
+                pause_ms = detect_pause_ms(seg_text, pause_cfg) if seg_text.strip() else 80
+                sil = make_silence(pause_ms)
+                
+                if not seg_text.strip():
+                    pieces.append({"arr": arr, "sil": sil, "text": seg_text})
+                    continue
+                    
+                srt_lines = _split_srt_text(seg_text, MAX_SRT_CHARS)
+                n_lines = len(srt_lines)
+                
+                if n_lines == 0:
+                    pieces.append({"arr": arr, "sil": sil, "text": ""})
+                    continue
+
+                total_chars = sum(len(line.strip()) for line in srt_lines)
+                arr_len = len(arr)
+                cursor_s = 0
+                
+                if total_chars == 0:
+                    samples_per_line = arr_len // n_lines
+                    for li, line_text in enumerate(srt_lines):
+                        if li == n_lines - 1:
+                            line_arr = arr[cursor_s:]
+                            line_sil = sil
+                        else:
+                            line_arr = arr[cursor_s : cursor_s + samples_per_line]
+                            line_sil = np.array([], dtype=np.float32)
+                        pieces.append({"arr": line_arr, "sil": line_sil, "text": line_text})
+                        cursor_s += samples_per_line
+                else:
+                    for li, line_text in enumerate(srt_lines):
+                        weight = len(line_text.strip()) / total_chars
+                        if li == n_lines - 1:
+                            line_arr = arr[cursor_s:]
+                            line_sil = sil
+                        else:
+                            samples = int(weight * arr_len)
+                            line_arr = arr[cursor_s : cursor_s + samples]
+                            line_sil = np.array([], dtype=np.float32)
+                        pieces.append({"arr": line_arr, "sil": line_sil, "text": line_text})
+                        cursor_s += int(weight * arr_len)
+
+            # 3b. Distribute pieces to phases
+            for p in pieces:
+                target_phase = group[phase_idx]
+                p_arr = p["arr"]
+                p_sil = p["sil"]
+                p_text = p["text"]
+                
+                target_phase["audio_arrays"].extend([p_arr, p_sil])
+                
+                arr_dur_spd = (len(p_arr) / sr) / max(speed, 0.1)
+                sil_dur_spd = (len(p_sil) / sr) / max(speed, 0.1)
+                
+                if p_text.strip():
+                    line_start = local_cursor
+                    line_end = local_cursor + arr_dur_spd
+                    target_phase["phase_entries"].append({
+                        "start": line_start,
+                        "end": line_end,
+                        "text": p_text
+                    })
+                    
+                local_cursor += arr_dur_spd + sil_dur_spd
+                
+                seg_len = len(re.sub(r'\s+', '', p_text))
+                chars_remaining -= seg_len
+                
+                while chars_remaining <= 0 and phase_idx < len(group) - 1:
+                    target_phase["total_phase_dur"] = local_cursor
+                    phase_idx += 1
+                    chars_remaining += len(re.sub(r'\s+', '', group[phase_idx]["normalized_text"]))
+                    local_cursor = 0.0
+            
+            # Store duration of the last advanced phase in group
+            if phase_idx < len(group):
+                group[phase_idx]["total_phase_dur"] = local_cursor
+
+            if _TORCH and _TORCH.cuda.is_available():
+                _TORCH.cuda.empty_cache()
+
+        # ─── 4. Output Phase MP3s & Build Master SRT ──────────────────────────
+        for phase in active_phases:
+            if not phase.get("audio_arrays"):
+                log += f"  ❌ Phase {phase['id']}: thất bại — không tạo được âm thanh.\n"
+                story_passed = False
+                yield log
+                continue
+
+            tmp_wav = os.path.join(CACHE_DIR, f"tmp_{uuid.uuid4().hex}.wav")
+            # Assume 'sr' from infer() remains identical across standard models.
+            try:
+                sf.write(tmp_wav, np.concatenate(phase["audio_arrays"]), sr)
+                ok = _wav_to_mp3(tmp_wav, phase["phase_mp3"], speed, do_norm)
+                if ok:
+                    log += f"  ✅ Phase {phase['id']}: MP3 OK ({len(phase['audio_arrays']) // 2} segments)\n"
+                else:
+                    log += f"  ⚠️ Phase {phase['id']}: FFmpeg thất bại hoặc rỗng!\n"
+                    story_passed = False
+            except Exception as e:
+                log += f"  ❌ Phase {phase['id']} WAV/FFmpeg lỗi: {e}\n"
+                story_passed = False
+                traceback.print_exc()
+            finally:
+                if os.path.exists(tmp_wav):
+                    try: os.remove(tmp_wav)
+                    except Exception: pass
+            
+            yield log
+
+            if phase["phase_entries"]:
+                formatted_phase_entries = []
+                for entry in phase["phase_entries"]:
+                    line_start = entry["start"]
+                    line_end   = entry["end"]
+                    line_text  = entry["text"]
+                    _append_srt_entry(
+                        formatted_phase_entries, master_srt_entries, master_srt_idx,
+                        line_text, line_start, line_end, master_cursor
+                    )
+                    master_srt_idx += 1
+                
+                _write_srt(phase["phase_srt_tmp"], formatted_phase_entries)
+            
+            phase_dur = phase.get("total_phase_dur", 0.0)
+            master_cursor += phase_dur
+
+        # ── Write FULL_MASTER.srt ─────────────────────────────────────────────
+        if master_srt_entries:
+            _write_srt(srt_master_path, master_srt_entries)
+            log += f"[{_ts()}] 📄 FULL_MASTER.srt: {len(master_srt_entries)} entries\n"
+            yield log
+
+        # ═══ BIDIRECTIONAL VALIDATION ════════════════════════════════════════
+        log += f"[{_ts()}] 🔍 Validate {len(phases)} phase(s)...\n"
+        yield log
+        all_phases_ok = True
+
+        for phase in phases:
+            phase_mp3    = os.path.join(out_dir, f"{phase['prompt_name']}.mp3")
+            tmp_srt_path = _phase_tmp_srts.get(phase["prompt_name"])
+
+            if not os.path.exists(phase_mp3):
+                log += f"  ⚠️ Phase {phase['id']}: MP3 bị thiếu — bỏ qua validate\n"
+                all_phases_ok = False
+                yield log
+                continue
+
+            if not tmp_srt_path or not os.path.exists(tmp_srt_path):
+                log += f"  ℹ️ Phase {phase['id']}: đã có từ session trước — bỏ qua validate\n"
+                yield log
+                continue
+
+            rpt = validate_audio_vs_srt(phase_mp3, tmp_srt_path)
+            pname = f"Phase {phase['id']}"
+
+            if rpt.overall_status == "PASS":
+                log += (
+                    f"  ✅ {pname}: PASS "
+                    f"({rpt.passed_entries}/{rpt.srt_total_entries} entries OK"
+                    f", {rpt.audio_duration:.1f}s)\n"
+                )
+            elif rpt.overall_status == "WARN":
+                all_phases_ok = False
+                log += f"  ⚠️ {pname}: WARN\n"
+                log += format_validation_report(rpt) + "\n"
+            else:
+                all_phases_ok = False
+                log += f"  ❌ {pname}: FAIL\n"
+                log += format_validation_report(rpt) + "\n"
+            yield log
+
+            # Delete temp SRT — output folder stays clean
+            try:
+                if os.path.exists(tmp_srt_path):
+                    os.remove(tmp_srt_path)
+            except Exception:
+                pass
+
+        # ── Sanity-check FULL_MASTER.srt duration ────────────────────────────
+        if os.path.exists(srt_master_path) and master_srt_entries:
+            try:
+                from .audio_validator import parse_srt as _parse_srt, _load_audio_as_mono
+                master_parsed = _parse_srt(srt_master_path)
+                if master_parsed:
+                    expected_end   = master_parsed[-1].end
+                    total_mp3_dur  = 0.0
+                    for phase in phases:
+                        ph_mp3 = os.path.join(out_dir, f"{phase['prompt_name']}.mp3")
+                        if os.path.exists(ph_mp3):
+                            try:
+                                d, sr_ = _load_audio_as_mono(ph_mp3)
+                                total_mp3_dur += len(d) / sr_
+                            except Exception:
+                                pass
+                    drift = abs(total_mp3_dur - expected_end)
+                    if drift < 2.0:
+                        log += (
+                            f"[{_ts()}] ✅ FULL_MASTER.srt sanity: "
+                            f"audio={total_mp3_dur:.1f}s ≈ SRT end={expected_end:.1f}s\n"
+                        )
+                    else:
+                        log += (
+                            f"[{_ts()}] ⚠️ FULL_MASTER.srt drift: "
+                            f"audio={total_mp3_dur:.1f}s vs SRT={expected_end:.1f}s "
+                            f"(Δ={drift:.1f}s)\n"
+                        )
+                        all_phases_ok = False
+                    yield log
+            except Exception:
+                pass
+
+        if all_phases_ok:
+            log += f"[{_ts()}] ✅ XÁC NHẬN XONG: {txt_name} — ĐẦY ĐỦ & TOÀN VẸN\n"
+            story_passed = True
+        else:
+            log += f"[{_ts()}] ⚠️ NGƯỜI DÙNG CẦN KIỂM TRA: {txt_name} có một số đoạn cần xem lại!\n"
+            story_passed = False
+        yield log
+
+        batch_results.append((txt_name, story_passed))
+
+        gc.collect()
+        if _TORCH and _TORCH.cuda.is_available():
+            _TORCH.cuda.empty_cache()
+
+    progress((total, total), desc="Done")
+
+    # ── FINAL BATCH SUMMARY ────────────────────────────────────────────────────
+    n_pass = sum(1 for _, ok in batch_results if ok)
+    n_fail = len(batch_results) - n_pass
+    elapsed = time.perf_counter() - t_batch_start
+    log += f"\n{'='*60}\n"
+    log += f"[{_ts()}] 🏁 KẾT QUẢ BATCH: {n_pass}/{len(batch_results)} story ĐÃ QUA KIỂM TRA\n"
+    log += f"[{_ts()}] ⏱️  Tổng thời gian: {elapsed:.1f}s\n"
+    if n_fail > 0:
+        log += f"  ❌ {n_fail} story có vấn đề:\n"
+        for name, ok in batch_results:
+            if not ok:
+                log += f"    • {name}\n"
+    else:
+        log += f"  ✅ Tất cả {n_pass} story ĐẦY ĐỦ & TOÀN VẸN — SẢN PHẨM SẴN SÀNG GIAO!\n"
+    log += f"{'='*60}\n"
+    yield log
+
+
+# ─── Internal SRT entry appender ──────────────────────────────────────────────
+
+def _append_srt_entry(
+    phase_entries: list,
+    master_srt_entries: list,
+    master_srt_idx: int,
+    text: str,
+    local_start: float,
+    local_end: float,
+    master_cursor: float,
+):
+    phase_entries.append({
+        "idx":   len(phase_entries) + 1,
+        "start": _fmt_ts(local_start),
+        "end":   _fmt_ts(local_end),
+        "text":  text,
+    })
+    master_srt_entries.append({
+        "idx":   master_srt_idx,
+        "start": _fmt_ts(master_cursor + local_start),
+        "end":   _fmt_ts(master_cursor + local_end),
+        "text":  text,
+    })

source/qwen_app/model_manager.py

@@ -0,0 +1,173 @@
+"""
+qwen_app/model_manager.py
+==========================
+LazyModelManager — tải torch/huggingface_hub theo yêu cầu (không import ngay khi khởi động).
+Điều này giúp UI xuất hiện ngay lập tức mà không cần chờ PyTorch khởi tạo.
+
+Tổng quan:
+  - get_model()      : tải model lần đầu khi cần, cache lại cho lần sau
+  - _unload_all()    : giải phóng VRAM khi chuyển model
+  - snapshot_paths   : cache đường dẫn snapshot HuggingFace
+"""
+
+from __future__ import annotations
+
+import os
+import time
+import logging
+from typing import Dict, Optional, Tuple
+
+logger = logging.getLogger("qwen_app.model_manager")
+
+# ─── Constants (resolved lazily) ─────────────────────────────────────────────
+
+def _get_device_dtype():
+    """Lazy-resolve device and dtype — only import torch when called."""
+    import torch  # noqa: PLC0415
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    dtype  = torch.bfloat16 if device == "cuda" else torch.float32
+    return device, dtype, device  # (device, dtype, device_map)
+
+
+class LazyModelManager:
+    """
+    Lazy model loader — torch/huggingface_hub được import chỉ khi cần.
+    Safe to instantiate at module-level mà không block startup.
+    """
+
+    def __init__(self):
+        self.snapshot_paths: Dict[str, str] = {}
+        self.loaded_models: Dict[str, object] = {}
+        self.active_model_key: Optional[str] = None
+        self._faster_cls = None
+        self._faster_available = False
+        self._use_faster = os.environ.get("QWEN_USE_FASTER_BACKEND", "1") == "1"
+        # NOTE: _init_faster_backend() is deferred to first get_model() call
+        self._faster_checked = False
+
+    # ─── Internal ─────────────────────────────────────────────────────────────
+
+    def _init_faster_backend(self) -> None:
+        """Lazy-init faster backend — called once before first model load."""
+        if self._faster_checked:
+            return
+        self._faster_checked = True
+        try:
+            import torch  # noqa: PLC0415
+            if not self._use_faster or not torch.cuda.is_available():
+                return
+            from faster_qwen3_tts import FasterQwen3TTS  # type: ignore
+            self._faster_cls = FasterQwen3TTS
+            self._faster_available = True
+            logger.debug("[model_manager] faster_qwen3_tts backend available ✅")
+        except Exception as e:
+            self._faster_cls = None
+            self._faster_available = False
+            logger.debug(f"[model_manager] faster_qwen3_tts not available: {e}")
+
+    @staticmethod
+    def _repo_id(model_type: str, model_size: str) -> str:
+        return f"Qwen/Qwen3-TTS-12Hz-{model_size}-{model_type}"
+
+    def _snapshot_path(self, repo_id: str) -> Tuple[str, str]:
+        if repo_id in self.snapshot_paths:
+            logger.debug(f"[model_manager] snapshot cache hit: {repo_id}")
+            return self.snapshot_paths[repo_id], f"Cache hit: {repo_id}"
+        from huggingface_hub import snapshot_download  # noqa: PLC0415
+        logger.info(f"[model_manager] Downloading snapshot: {repo_id}")
+        t0 = time.perf_counter()
+        path = snapshot_download(repo_id, local_dir_use_symlinks=False)
+        elapsed = time.perf_counter() - t0
+        self.snapshot_paths[repo_id] = path
+        logger.info(f"[model_manager] snapshot_download done in {elapsed:.2f}s → {path}")
+        return path, f"Downloaded: {repo_id}"
+
+    def _unload_all(self) -> None:
+        if not self.loaded_models:
+            return
+        logger.info(f"[model_manager] Unloading {list(self.loaded_models.keys())} from memory")
+        self.loaded_models.clear()
+        self.active_model_key = None
+        try:
+            import torch  # noqa: PLC0415
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                logger.debug("[model_manager] VRAM cache cleared")
+        except ImportError:
+            pass
+
+    # ─── Public API ───────────────────────────────────────────────────────────
+
+    def get_model(self, model_type: str, model_size: str) -> Tuple[object, str]:
+        """
+        Load (or return cached) model.
+        First call imports torch + optionally huggingface_hub.
+        Subsequent calls return cached model instantly.
+        """
+        import torch  # noqa: PLC0415
+        device   = "cuda" if torch.cuda.is_available() else "cpu"
+        dtype    = torch.bfloat16 if device == "cuda" else torch.float32
+        dev_map  = device
+
+        self._init_faster_backend()  # lazy — safe to call multiple times
+
+        key = f"{model_type}:{model_size}"
+        if key in self.loaded_models:
+            self.active_model_key = key
+            logger.debug(f"[model_manager] Model cache hit: {key}")
+            return self.loaded_models[key], f"Model ready (loaded): {key}"
+
+        if self.active_model_key and self.active_model_key != key:
+            logger.info(f"[model_manager] Switching model: {self.active_model_key} → {key}")
+            self._unload_all()
+
+        repo_id = self._repo_id(model_type, model_size)
+        note = ""
+        t0 = time.perf_counter()
+
+        if self._faster_available and self._faster_cls is not None:
+            try:
+                logger.info(f"[model_manager] Loading via FasterQwen3TTS: {repo_id}")
+                model = self._faster_cls.from_pretrained(
+                    repo_id,
+                    device="cuda",
+                    dtype=dtype,
+                    attn_implementation="eager",
+                    max_seq_len=4096,
+                )
+                elapsed = time.perf_counter() - t0
+                note = f"Loaded faster backend in {elapsed:.2f}s: {repo_id}"
+                logger.info(f"[model_manager] {note}")
+            except Exception as fast_err:
+                logger.warning(f"[model_manager] FasterQwen3TTS failed: {fast_err} — falling back to standard")
+                model_path, dl_note = self._snapshot_path(repo_id)
+                from qwen_tts import Qwen3TTSModel  # noqa: PLC0415
+                model = Qwen3TTSModel.from_pretrained(
+                    model_path,
+                    device_map=dev_map,
+                    dtype=dtype,
+                    attn_implementation="sdpa",
+                )
+                elapsed = time.perf_counter() - t0
+                note = f"{dl_note} | Fallback standard in {elapsed:.2f}s: {repo_id}"
+                logger.info(f"[model_manager] {note}")
+        else:
+            model_path, dl_note = self._snapshot_path(repo_id)
+            from qwen_tts import Qwen3TTSModel  # noqa: PLC0415
+            logger.info(f"[model_manager] Loading Qwen3TTSModel: {model_path}")
+            model = Qwen3TTSModel.from_pretrained(
+                model_path,
+                device_map=dev_map,
+                dtype=dtype,
+                attn_implementation="sdpa",
+            )
+            elapsed = time.perf_counter() - t0
+            note = f"{dl_note} | Standard backend in {elapsed:.2f}s: {repo_id}"
+            logger.info(f"[model_manager] {note}")
+
+        self.loaded_models[key] = model
+        self.active_model_key = key
+        return model, f"{note} | active={key} device={device}"
+
+
+model_manager = LazyModelManager()

source/qwen_app/omni_engine.py

@@ -0,0 +1,428 @@
+# qwen_app/omni_engine.py
+"""
+OmniVoice Engine — Singleton Wrapper
+======================================
+- Lazy-load OmniVoice model from HuggingFace (k2-fsa/OmniVoice)
+- Uses OmniVoice NATIVE long-form generation (audio_chunk_duration / audio_chunk_threshold)
+- NO manual chunking — model handles all splitting internally for best quality
+- preprocess_prompt=True + postprocess_output=True for cleaner reference and output audio
+- 600+ languages supported natively
+- Accepts 'num_step' from UI slider dynamically.
+"""
+
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import time
+import sys
+import subprocess
+import traceback
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+try:
+    import torch
+    _TORCH_AVAILABLE = True
+except ImportError:
+    torch = None  # type: ignore
+    _TORCH_AVAILABLE = False
+
+logger = logging.getLogger("qwen_app.omni_engine")
+
+# ─── GPU AUTO-TUNE ────────────────────────────────────────────────────────────
+
+class GPUProfile:
+    """Auto-detected GPU settings for maximum quality at maximum speed."""
+
+    def __init__(self):
+        self.gpu_name = "CPU"
+        self.vram_gb = 0.0
+        self.compute_cap = (0, 0)
+        self.tier = "cpu"
+        self.num_step = 32          # OmniVoice diffusion steps (auto-tuned)
+        self.dtype = "float16"
+        self.cudnn_benchmark = False
+        # chunk_size and batch_parallel are kept for legacy logging only
+        self.chunk_size = 0         # Not used — OmniVoice handles internally
+        self.batch_parallel = 1
+        self.model_vram_est = 3.0   # OmniVoice model ~3GB FP16
+
+        self.detect()
+
+    def detect(self):
+        if not _TORCH_AVAILABLE or not torch.cuda.is_available():
+            logger.info("[gpu_profile] No CUDA → CPU mode")
+            self.dtype = "float32"
+            self.num_step = 16
+            return
+
+        try:
+            props = torch.cuda.get_device_properties(0)
+            self.gpu_name = props.name
+            self.vram_gb = props.total_memory / (1024**3)
+            self.compute_cap = (props.major, props.minor)
+            major = props.major
+        except Exception as e:
+            logger.warning(f"[gpu_profile] Detection failed: {e}")
+            return
+
+        # ── Tier classification ──
+        if major >= 8:
+            self.tier = "high"       # Ampere / Ada — FP16 Tensor Cores
+            self.num_step = 32       # High quality
+            self.dtype = "float16"
+            self.cudnn_benchmark = True
+        elif major >= 7:
+            self.tier = "mid"        # Turing
+            self.num_step = 32       # Still 32 for quality
+            self.dtype = "float16"
+            self.cudnn_benchmark = True
+        elif major >= 6:
+            self.tier = "low"        # Pascal
+            self.num_step = 16
+            self.dtype = "float32"
+            self.cudnn_benchmark = True
+        else:
+            self.tier = "legacy"
+            self.num_step = 16
+            self.dtype = "float32"
+            self.cudnn_benchmark = False
+
+        # ── CUDNN ──
+        if self.cudnn_benchmark:
+            torch.backends.cudnn.benchmark = True
+            logger.info("[gpu_profile] CUDNN benchmark enabled")
+
+        logger.info(
+            f"[gpu_profile] {self.gpu_name} | VRAM={self.vram_gb:.1f}GB | "
+            f"cap={self.compute_cap} | tier={self.tier} | "
+            f"num_step={self.num_step}"
+        )
+
+    def summary(self) -> str:
+        return (
+            f"GPU: {self.gpu_name} ({self.vram_gb:.1f}GB) | "
+            f"Tier: {self.tier.upper()} | "
+            f"Steps: {self.num_step}"
+        )
+
+
+# Global GPU profile
+gpu_profile = GPUProfile()
+
+
+def get_available_vram_gb() -> float:
+    return gpu_profile.vram_gb
+
+
+# ─── Engine Singleton ─────────────────────────────────────────────────────────
+
+class OmniEngine:
+    """
+    Singleton OmniVoice engine.
+    Uses model's native long-form generation — NO manual chunking.
+    Supports 600+ languages with zero-shot voice cloning.
+    """
+
+    _instance: Optional["OmniEngine"] = None
+
+    def __new__(cls) -> "OmniEngine":
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self.model = None
+        self.device: str = "cuda" if (_TORCH_AVAILABLE and torch.cuda.is_available()) else "cpu"
+        self._initialized = True
+        self._use_flash_attn = False
+        logger.debug(f"[omni_engine] OmniEngine singleton created — device={self.device}")
+
+    # ── Internal helpers ──────────────────────────────────────────────────────
+
+    def _unload_qwen(self):
+        """Unload Qwen model_manager if it holds GPU memory."""
+        try:
+            from .model_manager import model_manager
+            if model_manager.loaded_models:
+                logger.info(f"[omni_engine] Unloading Qwen models: {list(model_manager.loaded_models.keys())}")
+                model_manager._unload_all()
+            else:
+                logger.debug("[omni_engine] Qwen model_manager: nothing to unload")
+        except Exception as ue:
+            logger.warning(f"[omni_engine] _unload_qwen exception (safe to ignore): {ue}")
+
+        if _TORCH_AVAILABLE and torch.cuda.is_available():
+            before = torch.cuda.memory_reserved() / (1024**3)
+            torch.cuda.empty_cache()
+            after = torch.cuda.memory_reserved() / (1024**3)
+            gc.collect()
+            logger.debug(f"[omni_engine] VRAM after Qwen unload: {before:.2f}→{after:.2f} GB reserved")
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    @property
+    def is_loaded(self) -> bool:
+        return self.model is not None
+
+    def load(self, use_flash_attn: bool = False, flash2_whl: str = "", log_callback=None) -> None:
+        """Load OmniVoice model. Unloads Qwen first. Full timing + deep log."""
+        if flash2_whl is None:
+            flash2_whl = ""
+        if self.is_loaded:
+            if getattr(self, "_use_flash_attn", False) == use_flash_attn:
+                logger.debug("[omni_engine] load() called but already loaded with matched flash-attn config — skipping")
+                return
+            else:
+                msg = f"🔄 Thay đổi Flash Attention ({getattr(self, '_use_flash_attn', False)} -> {use_flash_attn}), reloading..."
+                logger.info("[omni_engine] " + msg)
+                if log_callback: log_callback(msg)
+                self.unload()
+
+        def _log(msg: str):
+            logger.info(f"[omni_engine] {msg.strip()}")
+            if log_callback:
+                log_callback(msg)
+            else:
+                print(msg)
+
+        _log("🔄 Unload Qwen nếu đang chiếm VRAM...")
+        self._unload_qwen()
+
+        _log("⏳ Load OmniVoice model (600+ ngôn ngữ)...")
+        t_total = time.perf_counter()
+
+        try:
+            import torch as _torch
+
+            # Determine dtype
+            if gpu_profile.dtype == "float16" and _torch.cuda.is_available():
+                dtype = _torch.float16
+            else:
+                dtype = _torch.float32
+
+            device_map = "cuda:0" if _torch.cuda.is_available() else "cpu"
+
+            _log(f"  ⚙️ Loading OmniVoice (dtype={gpu_profile.dtype}, device={device_map})...")
+            t0 = time.perf_counter()
+
+            from omnivoice import OmniVoice
+            kwargs = {
+                "device_map": device_map,
+                "dtype": dtype,
+                "load_asr": True,   # Enable Whisper ASR for auto ref_text transcription
+            }
+            if use_flash_attn:
+                try:
+                    import flash_attn
+                except ImportError:
+                    if flash2_whl and os.path.isfile(flash2_whl):
+                        _log(f"  ⚡ Flash Attention chưa cài, đang cài từ {os.path.basename(flash2_whl)}...")
+                        try:
+                            cmd = [sys.executable, "-m", "pip", "install", flash2_whl]
+                            subprocess.run(cmd, check=True, capture_output=True, text=True)
+                            _log("  ✅ Đã cài đặt xong Flash Attention 2 từ file WHL!")
+                        except subprocess.CalledProcessError as sub_err:
+                            _log(f"  ❌ Cài đặt thất bại: {sub_err.stderr}. Sẽ thử tiếp với Flash Attention...")
+                    else:
+                        _log(f"  ⚠️ Flash Attention chưa được cài đặt và không có file .whl. Có thể lỗi!")
+
+                kwargs["attn_implementation"] = "flash_attention_2"
+                _log("  ⚡ Kích hoạt thử Flash Attention 2...")
+
+            try:
+                self.model = OmniVoice.from_pretrained("k2-fsa/OmniVoice", **kwargs)
+                self._use_flash_attn = use_flash_attn
+            except Exception as attempt_e:
+                if use_flash_attn:
+                    _log(f"  ❌ Lỗi load Flash Attention 2: {attempt_e}. Đang tắt Flash Attention và thử lại...")
+                    kwargs.pop("attn_implementation", None)
+                    self.model = OmniVoice.from_pretrained("k2-fsa/OmniVoice", **kwargs)
+                    self._use_flash_attn = False
+                else:
+                    raise
+            logger.info(f"[omni_engine] OmniVoice loaded in {time.perf_counter()-t0:.2f}s")
+
+            # ── Log VRAM usage ──
+            if _torch.cuda.is_available():
+                vram_used = _torch.cuda.memory_allocated() / (1024**3)
+                vram_total = _torch.cuda.get_device_properties(0).total_memory / (1024**3)
+                _log(f"  📊 VRAM: {vram_used:.2f} / {vram_total:.2f} GB")
+                logger.info(f"[omni_engine] VRAM after load: {vram_used:.2f}/{vram_total:.2f} GB")
+
+            elapsed_total = time.perf_counter() - t_total
+            _log(f"✅ OmniVoice loaded trên [{self.device.upper()}] — total {elapsed_total:.1f}s")
+            _log(f"  🌍 Hỗ trợ 600+ ngôn ngữ — sẵn sàng!")
+
+        except Exception as e:
+            self.model = None
+            tb = traceback.format_exc()
+            logger.error(f"[omni_engine] LOAD FAILED:\n{tb}")
+            raise RuntimeError(f"Không thể load OmniVoice model: {e}\n\n--- TRACEBACK ---\n{tb}")
+
+    def unload(self) -> None:
+        """Release GPU memory held by OmniVoice."""
+        if self.model is not None:
+            del self.model
+            self.model = None
+            logger.info("[omni_engine] OmniVoice model deleted from memory")
+        if _TORCH_AVAILABLE and torch.cuda.is_available():
+            before = torch.cuda.memory_reserved() / (1024**3)
+            torch.cuda.empty_cache()
+            after = torch.cuda.memory_reserved() / (1024**3)
+            logger.debug(f"[omni_engine] VRAM after unload: {before:.2f}→{after:.2f} GB")
+        gc.collect()
+
+    def infer(
+        self,
+        ref_audio_path: str,
+        ref_text: str,
+        gen_text: str,
+        language: str = "auto",
+        speed: float = 1.0,
+        num_step: int = 32,
+    ) -> Tuple[List[np.ndarray], int]:
+        """
+        Run inference using OmniVoice's NATIVE long-form generation.
+
+        Returns (list_of_wav_arrays, sample_rate=24000).
+        Each array in the list corresponds to one internal audio chunk
+        generated by OmniVoice (for SRT alignment).
+
+        Key design decisions:
+        - NO manual text splitting — model handles via audio_chunk_duration param
+        - preprocess_prompt=True: cleans reference audio (removes silences, adds punctuation)
+        - postprocess_output=True: removes long silences from generated audio
+        - ref_text is optional: if empty, Whisper ASR auto-transcribes the reference
+        """
+        if not self.is_loaded:
+            raise RuntimeError("OmniVoice model chưa được load. Gọi load() trước.")
+
+        logger.debug(
+            f"[omni_engine.infer] START | speed={speed} num={num_step} "
+            f"lang={language} ref_audio={ref_audio_path} gen_chars={len(gen_text)}"
+        )
+        logger.debug(f"[omni_engine.infer] gen_text[:80]= {gen_text[:80]!r}")
+
+        t0 = time.perf_counter()
+
+        if _TORCH_AVAILABLE and torch.cuda.is_available():
+            vram_before = torch.cuda.memory_allocated() / (1024**3)
+        else:
+            vram_before = 0.0
+
+        try:
+            from omnivoice import OmniVoiceGenerationConfig
+
+            # NOTE: audio_chunk_duration + audio_chunk_threshold MUST be inside
+            # OmniVoiceGenerationConfig — when generation_config is passed to
+            # model.generate(), all **kwargs are ignored (from_dict is not called).
+            gen_config = OmniVoiceGenerationConfig(
+                num_step=num_step,
+                guidance_scale=2.0,
+                denoise=True,
+                preprocess_prompt=True,   # Clean ref audio (remove silences, add punct)
+                postprocess_output=True,  # Clean generated audio (remove long silences)
+                audio_chunk_duration=15.0,   # Target segment ~15s (good for SRT)
+                audio_chunk_threshold=30.0,  # Activate chunking if estimated > 30s
+            )
+
+            lang = language if (language and language.lower() not in ("auto", "")) else None
+
+            gen_kwargs = dict(
+                text=gen_text,
+                language=lang,
+                generation_config=gen_config,
+            )
+
+            if speed is not None and abs(float(speed) - 1.0) > 0.01:
+                gen_kwargs["speed"] = float(speed)
+
+            # Voice cloning mode if ref_audio provided
+            if ref_audio_path and os.path.exists(ref_audio_path):
+                ref_text_clean = (ref_text or "").strip() or None
+                gen_kwargs["voice_clone_prompt"] = self.model.create_voice_clone_prompt(
+                    ref_audio=ref_audio_path,
+                    ref_text=ref_text_clean,
+                    # If ref_text is None, Whisper ASR auto-transcribes
+                )
+
+            audio_tensors = self.model.generate(**gen_kwargs)
+
+        except Exception as e:
+            tb = traceback.format_exc()
+            logger.error(f"[omni_engine.infer] GENERATE FAILED:\n{tb}")
+            raise
+
+        # ── Convert tensor list to numpy arrays ──
+        result_arrays: List[np.ndarray] = []
+        if audio_tensors and len(audio_tensors) > 0:
+            for audio in audio_tensors:
+                if hasattr(audio, 'cpu'):
+                    arr = audio.flatten().cpu().numpy().astype(np.float32)
+                else:
+                    arr = np.array(audio, dtype=np.float32).flatten()
+
+                # Sanitize NaN/Inf
+                nan_count = int(np.isnan(arr).sum())
+                inf_count = int(np.isinf(arr).sum())
+                if nan_count > 0 or inf_count > 0:
+                    logger.error(
+                        f"[omni_engine.infer] ⚠️ NUMERICAL ISSUE: "
+                        f"NaN={nan_count} Inf={inf_count} / {len(arr)} samples"
+                    )
+                    arr = np.nan_to_num(arr, nan=0.0, posinf=0.0, neginf=0.0)
+
+                result_arrays.append(arr)
+        else:
+            logger.warning("[omni_engine.infer] model.generate returned empty list — silence fallback")
+            result_arrays = [np.zeros(2400, dtype=np.float32)]  # 0.1s silence
+
+        sr = 24000  # OmniVoice outputs at 24kHz
+        elapsed = time.perf_counter() - t0
+        total_samples = sum(len(a) for a in result_arrays)
+
+        if _TORCH_AVAILABLE and torch.cuda.is_available():
+            vram_after = torch.cuda.memory_allocated() / (1024**3)
+        else:
+            vram_after = 0.0
+
+        logger.debug(
+            f"[omni_engine.infer] DONE | elapsed={elapsed:.2f}s "
+            f"segments={len(result_arrays)} total_samples={total_samples} "
+            f"({total_samples/sr:.2f}s) vram_alloc {vram_before:.2f}→{vram_after:.2f} GB"
+        )
+
+        # Energy check on full output
+        all_audio = np.concatenate(result_arrays)
+        energy = self.check_array_energy(all_audio)
+        if energy < SILENCE_THRESHOLD:
+            logger.warning(
+                f"[omni_engine.infer] ⚠️ LOW ENERGY OUTPUT: energy={energy:.6f} "
+                f"< threshold={SILENCE_THRESHOLD} — likely silent! "
+                f"gen_text[:60]={gen_text[:60]!r}"
+            )
+
+        return result_arrays, sr
+
+    @staticmethod
+    def check_array_energy(arr: Optional[np.ndarray]) -> float:
+        """Fast inline RMS check — no I/O."""
+        if arr is None or len(arr) == 0:
+            return 0.0
+        clean = np.nan_to_num(arr.astype(np.float32), nan=0.0, posinf=0.0, neginf=0.0)
+        rms = float(np.sqrt(np.mean(clean ** 2)))
+        return rms if np.isfinite(rms) else 0.0
+
+
+# ─── Global singleton ─────────────────────────────────────────────────────────
+omni_engine = OmniEngine()
+
+SILENCE_THRESHOLD = 0.003
+MAX_OMNI_RETRIES  = 2

source/qwen_app/prosody.py

@@ -0,0 +1,101 @@
+# qwen_app/prosody.py
+"""
+Prosodic Pause System
+─────────────────────
+Inserts natural silence gaps between TTS chunks based on the
+punctuation that ends each chunk, exactly like production TTS
+APIs (Minimax, ElevenLabs, OpenAI TTS).
+
+Default values are tuned to professional broadcast standards:
+  • Sentence endings (. ! ?)  → 500 ms
+  • Clause breaks (,)         → 180 ms
+  • Semi-colon (;)            → 300 ms
+  • Colon (:)                 → 250 ms
+  • Ellipsis (...)            → 700 ms
+  • Newline (paragraph)       → 600 ms
+  • Bare chunk boundary       → 80  ms
+"""
+
+import re
+import numpy as np
+from dataclasses import dataclass
+
+
+@dataclass
+class PauseConfig:
+    sentence_ms:   int = 500   # . ! ?
+    comma_ms:      int = 180   # ,
+    semicolon_ms:  int = 300   # ;
+    colon_ms:      int = 250   # :
+    ellipsis_ms:   int = 700   # ...
+    newline_ms:    int = 600   # \n paragraph break
+    default_ms:    int = 80    # no punctuation (bare chunk)
+
+    def to_dict(self):
+        return {
+            "sentence_ms":  self.sentence_ms,
+            "comma_ms":     self.comma_ms,
+            "semicolon_ms": self.semicolon_ms,
+            "colon_ms":     self.colon_ms,
+            "ellipsis_ms":  self.ellipsis_ms,
+            "newline_ms":   self.newline_ms,
+            "default_ms":   self.default_ms,
+        }
+
+
+# Default config — same numbers used by build_pause_ui
+DEFAULT_PAUSE = PauseConfig()
+
+
+def detect_pause_ms(chunk_text: str, cfg: PauseConfig) -> int:
+    """
+    Inspect the last meaningful characters of a chunk and return
+    the appropriate pause duration in milliseconds.
+    Priority: ellipsis > sentence > newline > semicolon > colon > comma > default
+    """
+    text = (chunk_text or "").rstrip()
+    if not text:
+        return cfg.default_ms
+
+    # Ellipsis (Unicode … or triple dot)
+    if text.endswith("…") or text.endswith("..."):
+        return cfg.ellipsis_ms
+
+    # Sentence-ending (works for Vietnamese, CJK, Arabic, Latin)
+    if re.search(r"[.!?。！？।؟]$", text):
+        return cfg.sentence_ms
+
+    # Paragraph / newline break — the original text had a newline here
+    if "\n" in chunk_text:
+        return cfg.newline_ms
+
+    # Semicolon
+    if text.endswith(";") or text.endswith("；"):
+        return cfg.semicolon_ms
+
+    # Colon
+    if text.endswith(":") or text.endswith("："):
+        return cfg.colon_ms
+
+    # Comma
+    if text.endswith(",") or text.endswith("，") or text.endswith("、"):
+        return cfg.comma_ms
+
+    return cfg.default_ms
+
+
+def make_silence(ms: int, sample_rate: int = 24000) -> np.ndarray:
+    """Return a float32 silence array of given duration in milliseconds."""
+    n_samples = max(0, int(ms * sample_rate / 1000))
+    return np.zeros(n_samples, dtype=np.float32)
+
+
+def pause_seconds(chunk_text: str, cfg: PauseConfig, speed: float = 1.0) -> float:
+    """
+    Return the *wall-clock* pause duration in seconds as it will appear
+    in the final sped-up audio. Used for SRT cursor advancement.
+
+    The silence buffer is inserted PRE-SPEED, so atempo will shorten it too.
+    """
+    ms = detect_pause_ms(chunk_text, cfg)
+    return (ms / 1000.0) / max(speed, 0.1)

source/qwen_app/text_cleaner.py

@@ -0,0 +1,288 @@
+# qwen_app/text_cleaner.py
+"""
+Universal Text Cleaner for OmniVoice TTS (600+ Languages)
+===========================================================
+Cleans text BEFORE passing to OmniVoice to ensure maximum speech quality.
+
+Following OmniVoice author recommendations:
+- Remove URLs, emails, file paths (model can't pronounce these)
+- Remove markdown / HTML formatting tags
+- Remove emojis and non-speech symbols
+- Normalize punctuation (no duplicate, no unbalanced brackets)
+- Normalize whitespace and line breaks
+- Keep language-neutral — safe for ALL 600+ supported languages
+
+NOTE: This is GENERATION TEXT cleaning only.
+      preprocess_prompt=True (in OmniVoiceGenerationConfig) handles reference audio.
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Optional
+
+
+# ─── URL / Email / Path patterns ─────────────────────────────────────────────
+
+# Match full URLs (http/https/ftp/www...)
+_URL_PATTERN = re.compile(
+    r"""(?:https?|ftp)://[^\s\]\[<>"']+"""
+    r"""|www\.[a-zA-Z0-9][-a-zA-Z0-9.]+\.[a-zA-Z]{2,}(?:/[^\s]*)?""",
+    re.IGNORECASE,
+)
+
+# Email addresses
+_EMAIL_PATTERN = re.compile(
+    r"[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}",
+    re.IGNORECASE,
+)
+
+# File paths (Windows and Unix style)
+_FILEPATH_PATTERN = re.compile(
+    r"""[a-zA-Z]:\\(?:[^\\\n/:*?"<>|]+\\)*[^\\\n/:*?"<>|]*"""
+    r"""|/(?:[^/\n]+/)+[^/\n]*""",
+)
+
+# Hashtags and @mentions (social media noise)
+_HASHTAG_MENTION_PATTERN = re.compile(r"[@#]\w+")
+
+
+# ─── Markdown / HTML ─────────────────────────────────────────────────────────
+
+# HTML tags
+_HTML_TAG_PATTERN = re.compile(r"<[^>]{1,200}>", re.IGNORECASE)
+
+# Markdown: **bold**, *italic*, __underline__, ~~strike~~, `code`, ```code blocks```
+_MARKDOWN_PATTERN = re.compile(
+    r"```[\s\S]*?```"            # fenced code block
+    r"|`[^`\n]+`"               # inline code
+    r"|_{1,2}([^_\n]+)_{1,2}"  # __bold__ or _italic_
+    r"|\*{1,2}([^*\n]+)\*{1,2}" # **bold** or *italic*
+    r"|~~([^~\n]+)~~"           # ~~strikethrough~~
+    r"|\[([^\]]+)\]\([^)]+\)"   # [link text](url) → keep link text
+)
+
+# Markdown headers # ## ###
+_MD_HEADER_PATTERN = re.compile(r"^#{1,6}\s+", re.MULTILINE)
+
+# Markdown horizontal rule
+_MD_HR_PATTERN = re.compile(r"^[-*_]{3,}\s*$", re.MULTILINE)
+
+# Markdown blockquote
+_MD_QUOTE_PATTERN = re.compile(r"^>\s*", re.MULTILINE)
+
+
+# ─── Emoji / Special Unicode ─────────────────────────────────────────────────
+
+# Emoji ranges (covers most emoji blocks)
+_EMOJI_PATTERN = re.compile(
+    "["
+    "\U0001F600-\U0001F64F"  # emoticons
+    "\U0001F300-\U0001F5FF"  # misc symbols & pictographs
+    "\U0001F680-\U0001F6FF"  # transport & map
+    "\U0001F1E0-\U0001F1FF"  # flags
+    "\u2500-\u2bef"          # box drawing, arrows, misc
+    "\u2702-\u27b0"          # dingbats
+    "\u24c2\U0001F251"       # specific enclosed characters (M and Accept)
+    "\U0001f926-\U0001f937"  # facepalms, shrugs, etc
+    "\U0001F900-\U0001F9FF"  # supplemental symbols and pictographs
+    "\U0001FA70-\U0001FAFF"  # symbols and pictographs extended-A
+    "\u2640-\u2642"          # gender symbols
+    "\u2600-\u2b55"          # misc symbols and arrows
+    "\u200d"                 # zero width joiner
+    "\u23cf"                 # eject symbol
+    "\u23e9"                 # fast forward
+    "\u231a"                 # watch
+    "\ufe0f"                 # variation selector 16
+    "\u3030"                 # wavy dash
+    "]+",
+    re.UNICODE,
+)
+
+# Zero-width and invisible characters
+_ZERO_WIDTH_PATTERN = re.compile(
+    r"[\u200b\u200c\u200d\u200e\u200f\u2028\u2029\ufeff\u00ad\u034f\u180e]"
+)
+
+# Control characters (except newline, tab, carriage return)
+_CONTROL_CHAR_PATTERN = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]")
+
+
+# ─── Punctuation normalization ────────────────────────────────────────────────
+
+# Repeated punctuation (e.g. "!!!" → "!", "..." kept as-is for ellipsis)
+_REPEAT_PUNCT_PATTERN = re.compile(r"([!?])\1+")
+
+# Repeated dots longer than 3 → ellipsis (…)
+_REPEAT_DOTS_PATTERN = re.compile(r"\.{4,}")
+
+# Repeated commas, semicolons, colons
+_REPEAT_COMMA_PATTERN = re.compile(r"[,;:]{2,}")
+
+# Unmatched brackets/parentheses — strip the lonely bracket
+_LONE_BRACKET_OPEN  = re.compile(r"\(\s*\)")   # () empty parens
+_LONE_BRACKET_EMPTY = re.compile(r"\[\s*\]")   # [] empty brackets
+
+# Opening bracket at end of text or closing bracket at start (no pair)
+_TRAILING_OPEN  = re.compile(r"[\(\[\{]\s*$")
+_LEADING_CLOSE  = re.compile(r"^\s*[\)\]\}]")
+
+# Mixed punctuation clutter (e.g. ".-" or ",." etc)
+_PUNCT_CLUTTER = re.compile(r"[,;]\s*[.!?]")  # comma/semi followed by end punct
+
+# ─── Special character substitutions ─────────────────────────────────────────
+
+# These are symbol-to-word mappings that are language-neutral or common
+# Note: Vietnamese-specific ones go in vi_normalizer.py
+_SYMBOL_MAP = [
+    (" & ",  " and "),    # ampersand mid-word → "and"
+    ("®",    ""),         # registered trademark
+    ("™",    ""),         # trademark
+    ("©",    ""),         # copyright
+    ("°",    " degrees "),
+    ("±",    " plus or minus "),
+    ("×",    " times "),
+    ("÷",    " divided by "),
+    ("≈",    " approximately "),
+    ("≠",    " not equal to "),
+    ("≤",    " less than or equal to "),
+    ("≥",    " greater than or equal to "),
+    ("→",    " "),
+    ("←",    " "),
+    ("↑",    " "),
+    ("↓",    " "),
+    ("↔",    " "),
+    ("•",    " "),        # bullet → space
+    ("·",    " "),        # middle dot
+    ("–",    " - "),      # en dash → hyphen
+    ("—",    " - "),      # em dash → hyphen
+    ("„",    '"'),        # lower double quote → normal
+    ("\u201c", '"'),      # left double quote → normal
+    ("\u201d", '"'),      # right double quote → normal
+    ("\u2018", "'"),      # left single quote → normal
+    ("\u2019", "'"),      # right single quote → normal
+    ("\u0060", "'"),      # backtick → normal apostrophe
+]
+
+# Repeated stars/dashes used as decorators (e.g. "*** TITLE ***")
+_DECORATOR_PATTERN = re.compile(r"[*=\-_~^]{3,}")
+
+
+# ─── Main cleaner ─────────────────────────────────────────────────────────────
+
+def clean_tts_text(text: str, language: str = "auto") -> str:
+    """
+    Universal text cleaner for OmniVoice TTS input.
+    Safe for ALL 600+ supported languages.
+
+    Args:
+        text: Raw input text
+        language: Language hint (e.g. "Vietnamese", "English") — used for
+                  language-specific post-processing
+
+    Returns:
+        Cleaned text ready for OmniVoice model.generate()
+    """
+    if not text:
+        return ""
+
+    # ── Step 1: Unicode normalization ──
+    # NFC: compose combining characters (accents for Vietnamese, etc.)
+    text = unicodedata.normalize("NFC", text)
+
+    # ── Step 2: Remove control chars and zero-width chars ──
+    text = _ZERO_WIDTH_PATTERN.sub("", text)
+    text = _CONTROL_CHAR_PATTERN.sub("", text)
+
+    # (Skip aggressive Markdown/HTML/URL/ASCII parsing. User text is AI-precleaned)
+
+    # ── Step 12: Punctuation normalization ──
+    # Repeated ! or ? → single
+    text = _REPEAT_PUNCT_PATTERN.sub(r"\1", text)
+
+    # Very long dot sequences → ellipsis (3 dots)
+    text = _REPEAT_DOTS_PATTERN.sub("...", text)
+
+    # Repeated commas/semicolons/colons → single
+    text = _REPEAT_COMMA_PATTERN.sub(lambda m: m.group(0)[0], text)
+
+    # Comma/semi before sentence end → just keep end punct
+    text = _PUNCT_CLUTTER.sub(lambda m: m.group(0)[-1], text)
+
+    # Empty parens/brackets → remove
+    text = _LONE_BRACKET_OPEN.sub(" ", text)
+    text = _LONE_BRACKET_EMPTY.sub(" ", text)
+
+    # Trailing open bracket or leading close bracket
+    text = _TRAILING_OPEN.sub(" ", text)
+    text = _LEADING_CLOSE.sub(" ", text)
+
+    # ── Step 13: Normalize whitespace ──
+    # Normalize line breaks: multiple blank lines → max 1 blank line
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    # Normalize spaces on each line
+    lines = [re.sub(r"[ \t]+", " ", line).strip() for line in text.split("\n")]
+    # Bỏ qua logic filter "\w" vì nó có thể tự động lược bỏ dòng chữ nước ngoài
+    lines = [l for l in lines if l]
+    text = "\n".join(lines)
+
+    # ── Step 14: Final punctuation spacing cleanup ──
+    # Space before punctuation (e.g. "hello ." → "hello.")
+    text = re.sub(r"\s+([.,!?;:])", r"\1", text)
+    # Multiple spaces → single
+    text = re.sub(r"[ \t]+", " ", text)
+
+    return text.strip()
+
+
+# ─── Convenience wrapper that calls language-specific normalizer after ────────
+
+def preprocess_for_tts(text: str, language: str = "auto") -> str:
+    """
+    Full preprocessing pipeline:
+    1. Universal clean (removes URLs, emojis, HTML, markdown, etc.)
+    2. Language-specific normalization (numbers, dates, symbols)
+
+    Args:
+        text: Raw input text
+        language: Language string (matches OmniVoice language param)
+
+    Returns:
+        Fully normalized text ready for OmniVoice.
+    """
+    # Step 1: Universal clean
+    cleaned = clean_tts_text(text, language=language)
+
+    # Step 2: Vietnamese-specific normalization
+    is_vn = language.lower() in ("vietnamese", "tiếng việt", "vi", "vie", "auto")
+    if is_vn:
+        try:
+            from .vi_normalizer import normalize_vi_text
+            cleaned = normalize_vi_text(cleaned)
+        except Exception:
+            pass
+
+    # Final whitespace cleanup after normalizer
+    cleaned = re.sub(r"[ \t]+", " ", cleaned).strip()
+
+    return cleaned
+
+
+if __name__ == "__main__":
+    # Quick test
+    samples = [
+        "Xem thêm tại https://youtube.com/watch?v=abc123 nhé!!!",
+        "**Thời tiết hôm nay** rất đẹp 😊😊😊",
+        "Email: support@example.com hoặc hotline 1800-1234",
+        "Giá: 1.500.000 VNĐ (khuyến mãi 20%!!!)",
+        "Check file tại D:\\Projects\\data\\output.txt cho tôi",
+        "# Tiêu đề\n## Phụ đề\n> Quote này\n```code```",
+        "Câu 1... câu 2,,, câu 3;;;",
+        "Follow @mypage và #viral trên TikTok nhé !!!",
+    ]
+    for s in samples:
+        result = preprocess_for_tts(s, language="Vietnamese")
+        print(f"IN:  {s!r}")
+        print(f"OUT: {result!r}")
+        print()

source/qwen_app/ui.py

@@ -0,0 +1,813 @@
+import os
+
+import gradio as gr
+from gradio_modal import Modal
+
+try:
+    import psutil
+except Exception:
+    psutil = None
+
+from .config import LANGUAGES, SPEAKERS
+from .voice_library import (
+    delete_voice,
+    ensure_voice_library,
+    preview_saved_voice,
+    save_voice_profile,
+    voice_choices,
+    voice_rows,
+)
+
+# Lazy-loaded wrapper functions for fast UI startup
+def process_omni_batch_txt(*args, **kwargs):
+    from .mode_omni_batch import process_omni_batch_txt as _fn
+    yield from _fn(*args, **kwargs)
+
+def process_omni_news_batch(*args, **kwargs):
+    from .mode_omni_news import process_omni_news_batch as _fn
+    yield from _fn(*args, **kwargs)
+
+def validate_audio_vs_srt(*args, **kwargs):
+    from .audio_validator import validate_audio_vs_srt as _fn
+    return _fn(*args, **kwargs)
+
+def validate_batch_output(*args, **kwargs):
+    from .audio_validator import validate_batch_output as _fn
+    return _fn(*args, **kwargs)
+
+def format_validation_report(*args, **kwargs):
+    from .audio_validator import format_validation_report as _fn
+    return _fn(*args, **kwargs)
+
+def format_batch_reports(*args, **kwargs):
+    from .audio_validator import format_batch_reports as _fn
+    return _fn(*args, **kwargs)
+from .voice_library_vi import (
+    ensure_vi_voice_library,
+    vi_voice_choices,
+    vi_voice_rows,
+    save_vi_voice,
+    delete_vi_voice,
+    preview_vi_voice,
+    resolve_vi_ref,
+    NONE_CHOICE as VI_NONE_CHOICE,
+)
+
+
+# Silence non-fatal symlink warnings on Windows cache.
+os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1")
+
+VOICE_DESCRIPTION_TEMPLATES = {
+    "Cinematic Storyteller (Male)": "Voice type: Male. Speak as a cinematic storyteller with warm resonance, controlled pacing, and emotionally rich phrasing. Begin with calm narrative authority, then build intensity on key words with subtle breath energy and deliberate pauses. Keep articulation crisp but natural, with a polished studio tone suited for trailers, documentaries, and immersive long-form storytelling.",
+    "Premium Conversational Assistant (Female)": "Voice type: Female. Use a premium virtual-assistant style: clear, reassuring, and intelligent. Maintain medium pace, neutral accent, and consistently high intelligibility. Sound professional yet approachable, with slight prosodic lift on supportive phrases and gentle emphasis for instructions. Avoid overacting; prioritize trust, calm confidence, and user comfort in every sentence.",
+    "Energetic Product Presenter (Male)": "Voice type: Male. Deliver with upbeat product-presenter energy: bright tone, confident rhythm, and persuasive clarity. Emphasize benefits, numbers, and call-to-action phrases with controlled enthusiasm. Keep transitions smooth and momentum high without sounding rushed. The voice should feel modern, polished, and conversion-focused, like a premium launch keynote or ad campaign narration.",
+    "Soft Empathetic Guide (Female)": "Voice type: Female. Speak as an empathetic guide with a soft, grounded voice and compassionate pacing. Use gentle onset, smooth sentence endings, and reassuring cadence. Add subtle warmth and emotional safety, especially on sensitive words. Maintain clear diction while sounding human and caring, suitable for wellbeing apps, coaching flows, and emotionally supportive interactions.",
+    "Authoritative News Anchor (Male)": "Voice type: Male. Adopt a composed news-anchor style with strong diction, low emotional volatility, and high credibility. Keep pace steady and measured, with precise phrasing and disciplined pauses at clause boundaries. Emphasize facts and proper nouns cleanly. The voice should project authority, neutrality, and confidence appropriate for reports, briefings, and formal updates.",
+    "Luxury Brand Narrator (Female)": "Voice type: Female. Use a refined luxury-brand tone: smooth, elegant, and restrained. Maintain slower cadence, rich timbre, and highly intentional emphasis on sensory adjectives and brand values. Prioritize sophistication over energy, with tasteful pauses and velvety delivery. Suitable for premium ads, fashion films, hospitality promos, and high-end product storytelling.",
+    "Technical Explainer Pro (Male)": "Voice type: Male. Speak like a senior technical explainer: precise, organized, and high-clarity. Keep cadence structured with audible sectioning, clear enumeration, and firm emphasis on terms, parameters, and constraints. Maintain neutral warmth and avoid dramatic swings. The voice should feel expert and trustworthy for tutorials, onboarding guides, and developer-focused education.",
+    "Playful Youthful Creator (Female)": "Voice type: Female. Deliver with playful creator energy: lively, expressive, and socially engaging. Use dynamic intonation, quick but controlled pacing, and friendly emphasis on surprise or delight moments. Keep pronunciation clear while sounding spontaneous and relatable. Ideal for social clips, creator intros, community updates, and fun lifestyle narration.",
+    "Calm Meditation Coach (Female)": "Voice type: Female. Speak as a calm meditation coach with slow tempo, deep breath spacing, and soothing low-mid tone. Use long gentle pauses, soft transitions, and minimal sharp consonant attack. Keep guidance clear yet tranquil, with a centered emotional profile that reduces tension and promotes focus. Best for breathwork, mindfulness, and sleep content.",
+    "Epic Fantasy Narrator (Male)": "Voice type: Male. Use an epic fantasy narrator style: deep, textured, and atmospheric. Start with measured gravitas, then swell intensity on lore-heavy or dramatic lines. Shape phrases with cinematic contour, weighted pauses, and vivid emphasis on names, places, and stakes. Maintain intelligibility while creating a grand, immersive world-building performance.",
+    "Playful Comedic Performer (Male)": "Voice type: Male. Perform with lively comedic timing, bright tone, and expressive pitch movement. Add natural smile energy and punchline emphasis with short, intentional pauses before humor beats. Keep diction clear while sounding spontaneous and entertaining. Ideal for skits, banter, playful ads, and light-hearted narration that feels genuinely fun.",
+    "Whispered Secret Voice (Female)": "Voice type: Female. Speak in a soft close-mic whisper with delicate breath texture and intimate presence. Keep volume low but intelligible, elongate key words slightly, and use gentle pauses to create suspense. Avoid harsh consonants and maintain smooth articulation. Suitable for ASMR, secretive narration, and mysterious dramatic scenes.",
+    "Panic and Fear Reaction (Female)": "Voice type: Female. Deliver a fear-driven performance with tense breath support, quicker pacing on urgent phrases, and trembling emphasis on high-stakes words. Alternate short gasps with clipped phrases, then drop into hushed concern for contrast. Maintain intelligibility while conveying alarm, uncertainty, and escalating emotional pressure.",
+    "Psychological Horror Narrator (Male)": "Voice type: Male. Use a chilling psychological-horror tone: restrained at first, then subtly unstable as the scene evolves. Keep pace measured with uncomfortable pauses, low resonance, and precise articulation of eerie details. Build dread through controlled intensity rather than shouting. The result should feel unsettling, cinematic, and immersive.",
+    "Suspense Thriller Trailer (Male)": "Voice type: Male. Speak like a thriller trailer narrator with dark confidence, deliberate cadence, and dramatic rise on reveal words. Use weighted pauses and strong sentence endings to create tension. Emphasize stakes, time pressure, and conflict cues. Keep the delivery polished, cinematic, and high-impact for dramatic promo material.",
+    "Sinister Villain Monologue (Male)": "Voice type: Male. Adopt a calculated villain persona with deep controlled tone, slow predatory pacing, and sharp emphasis on threats or promises. Add subtle contempt and confident pauses, with occasional intensity spikes on dominant phrases. Maintain clarity while projecting menace, intelligence, and theatrical authority.",
+    "Over-the-Top Action Hype (Male)": "Voice type: Male. Deliver explosive action-hype energy with fast tempo, punchy stress patterns, and powerful callout emphasis. Drive momentum through short rhythmic phrasing and strong transitions. Keep articulation clean despite high intensity. Great for sports intros, game trailers, and heroic battle-style announcements.",
+    "Noir Detective Voice (Male)": "Voice type: Male. Use a gritty noir detective style with dry wit, low-mid rasp, and reflective pacing. Lean into moody pauses and understated emphasis, as if narrating a rain-soaked city mystery at midnight. Keep phrasing deliberate, cinematic, and character-rich while preserving clear intelligibility.",
+}
+
+# Templates for Emotion Control — no voice-type specification since the speaker is fixed.
+# These describe only the emotional style and delivery.
+EMOTION_STYLE_TEMPLATES = {
+    "Calm & Authoritative": "Speak with measured confidence and composed authority. Keep a steady pace, precise diction, and controlled pauses at clause boundaries. Project credibility and neutrality without emotional volatility.",
+    "Warm & Conversational": "Deliver in a friendly, natural conversational tone. Maintain an approachable cadence with slight prosodic lift on supportive phrases. Sound genuine and reassuring, like speaking to a trusted friend.",
+    "Upbeat & Energetic": "Speak with bright, enthusiastic energy. Use confident rhythm, punchy emphasis on key words, and high momentum. Keep articulation clean while projecting excitement and positivity.",
+    "Soft & Empathetic": "Use a gentle, grounded tone with compassionate pacing. Add subtle warmth on emotionally sensitive words. Keep delivery smooth and caring, creating a sense of safety and understanding.",
+    "Dramatic & Intense": "Deliver with cinematic gravitas. Build tension through weighted pauses, deliberate pacing, and strong emphasis on stakes and key moments. Create a sense of urgency and high emotional investment.",
+    "Playful & Lighthearted": "Speak with lively, expressive intonation and quick pacing. Add natural smile energy, spontaneous rhythm, and emphasis on surprise or delight moments. Keep the tone fun and relatable.",
+    "Melancholic & Reflective": "Use a slow, introspective pace with soft onset and gentle pauses. Add a hint of emotional weight and quiet resignation. Keep the tone sincere, thoughtful, and quietly moving.",
+    "Tense & Anxious": "Deliver with slightly quickened pacing on urgent phrases and subtle breath tension. Alternate short clipped phrases with hushed concern. Convey unease and building pressure without losing intelligibility.",
+    "Inspiring & Motivational": "Speak with rising energy and purposeful conviction. Emphasize action words, aspirations, and calls to change. Build momentum steadily, projecting hope, determination, and forward motion.",
+    "Cold & Detached": "Deliver in a flat, measured tone with minimal prosodic variation. Keep pacing controlled and emotionless. Project clinical precision and deliberate distance, as if reciting facts without involvement.",
+    "Excited & Enthusiastic": "Use rapid-fire energy with dynamic pitch variation and strong callout emphasis on highlights. Drive momentum with short rhythmic phrasing. Sound genuinely thrilled and engaged throughout.",
+    "Somber & Serious": "Speak in a low-key, grave tone with slow deliberate pacing and long pauses. Keep every word weighted and purposeful. Project solemnity and deep seriousness befitting difficult or important subjects.",
+    "Whispered & Secretive": "Use a soft, close-mic delivery with delicate breath texture and intimate presence. Elongate key words slightly and use gentle pauses to create suspense. Avoid harsh consonants while staying intelligible.",
+    "Sarcastic & Dry": "Deliver with flat affect and understated emphasis on ironic words. Use dry wit and slight over-enunciation on sarcastic phrases. Keep the tone deadpan while allowing subtle comedic timing.",
+    "Horror & Dread": "Start restrained, then build subtle instability as tension escalates. Use uncomfortable pauses, deliberate articulation of eerie details, and a low resonant tone. Create dread through controlled intensity rather than volume.",
+}
+
+
+def _progress_status_panel(default_status: str):
+    progress = gr.Slider(label="Progress", minimum=0, maximum=100, value=0, interactive=False)
+    status = gr.Textbox(label="Status", value=default_status, lines=3, interactive=False)
+    output = gr.Audio(label="Generated Audio", type="numpy")
+    return progress, status, output
+
+
+def _advanced_decode_ui(prefix: str):
+    with gr.Accordion(f"Advanced Decode - {prefix}", open=False):
+        seed = gr.Number(value=0, precision=0, label="Seed (0=random)")
+        temperature = gr.Slider(0.1, 2.0, value=0.8, step=0.05, label="Temperature")
+        top_p = gr.Slider(0.1, 1.0, value=0.95, step=0.01, label="Top-p")
+        repetition_penalty = gr.Slider(1.0, 2.0, value=1.15, step=0.05, label="Repetition Penalty")
+        max_new_tokens = gr.Slider(256, 4096, value=2048, step=64, label="Max New Tokens")
+    return seed, temperature, top_p, repetition_penalty, max_new_tokens
+
+
+def _pause_ui(prefix: str):
+    """Prosodic Pause controls — same UX as Minimax / ElevenLabs pause settings.
+    Returns 7 Slider components in this order:
+      sentence_ms, comma_ms, semicolon_ms, colon_ms, ellipsis_ms, newline_ms, default_ms
+    """
+    with gr.Accordion(f"🎵 Prosodic Pauses — {prefix}", open=False):
+        gr.Markdown(
+            "Control silence inserted **between sentences/clauses**. "
+            "Applied AFTER model renders audio — does not affect voice quality. "
+            "All values in **milliseconds (ms)**."
+        )
+        with gr.Row():
+            p_sentence = gr.Slider(0, 1500, value=500, step=10, label="Sentence end  . ! ?")
+            p_comma    = gr.Slider(0, 800,  value=180, step=10, label="Comma  ,")
+            p_semi     = gr.Slider(0, 1000, value=300, step=10, label="Semicolon  ;")
+        with gr.Row():
+            p_colon    = gr.Slider(0, 1000, value=250, step=10, label="Colon  :")
+            p_ellipsis = gr.Slider(0, 2000, value=700, step=10, label="Ellipsis  …  ...")
+            p_newline  = gr.Slider(0, 2000, value=600, step=10, label="Newline / paragraph")
+        p_default  = gr.Slider(0, 500,  value=80,  step=10, label="Default (no punctuation)")
+    return p_sentence, p_comma, p_semi, p_colon, p_ellipsis, p_newline, p_default
+
+
+def _dropdown_update(selected: str = "None"):
+    choices = voice_choices()
+    value = selected if selected in choices else "None"
+    return gr.update(choices=choices, value=value)
+
+
+def _save_cloned_voice_profile(voice_name, language, ref_audio, ref_text):
+    if not (ref_text or "").strip():
+        return (
+            "Error: Reference Transcript is required for Clone Voice.",
+            voice_rows(),
+            _dropdown_update(),
+            _dropdown_update(),
+            _dropdown_update(),
+            _dropdown_update(),
+            _dropdown_update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+        )
+    msg = save_voice_profile(voice_name, language, ref_text, "clone", ref_audio)
+    return (
+        msg,
+        voice_rows(),
+        _dropdown_update(voice_name),
+        _dropdown_update(voice_name),
+        _dropdown_update(voice_name),
+        _dropdown_update(voice_name),
+        _dropdown_update(voice_name),
+        gr.update(value=""),
+        gr.update(value="Auto"),
+        gr.update(value=None),
+        gr.update(value=""),
+    )
+
+
+def _save_designed_voice_profile(voice_name, language, source_text, designed_audio):
+    msg = save_voice_profile(voice_name, language, source_text, "voice_design", designed_audio)
+    return msg, voice_rows(), _dropdown_update(voice_name), _dropdown_update(voice_name), _dropdown_update(voice_name), _dropdown_update(voice_name), _dropdown_update(voice_name)
+
+
+def _refresh_voice_widgets():
+    return voice_rows(), _dropdown_update(), _dropdown_update(), _dropdown_update(), _dropdown_update(), _dropdown_update()
+
+
+def _delete_voice_ui(name: str):
+    msg, rows, _ = delete_voice(name)
+    return msg, rows, _dropdown_update(), _dropdown_update(), _dropdown_update(), _dropdown_update(), _dropdown_update()
+
+
+def _preview_voice_audio(name: str):
+    audio, _ = preview_saved_voice(name)
+    return audio
+
+
+def _char_count_text(text: str) -> str:
+    return f"Characters: {len(text or '')}"
+
+
+def _template_names():
+    return list(VOICE_DESCRIPTION_TEMPLATES.keys())
+
+
+def _template_text(name: str) -> str:
+    return VOICE_DESCRIPTION_TEMPLATES.get(name or "", "")
+
+
+def _apply_template(name: str):
+    return _template_text(name), Modal(visible=False)
+
+
+def _apply_template_only_text(name: str):
+    return _template_text(name)
+
+
+def _emotion_template_names():
+    return list(EMOTION_STYLE_TEMPLATES.keys())
+
+
+def _emotion_template_text(name: str) -> str:
+    return EMOTION_STYLE_TEMPLATES.get(name or "", "")
+
+
+def _apply_emotion_template(name: str):
+    return _emotion_template_text(name), Modal(visible=False)
+
+
+def _resource_monitor_values():
+    ram_pct = None
+    ram_used = None
+    ram_total = None
+    if psutil is not None:
+        vm = psutil.virtual_memory()
+        ram_pct = vm.percent
+        ram_used = vm.used / (1024**3)
+        ram_total = vm.total / (1024**3)
+
+    vram_pct = None
+    vram_alloc = None
+    vram_reserved = None
+    vram_total = None
+    import torch
+    if torch.cuda.is_available():
+        idx = torch.cuda.current_device()
+        props = torch.cuda.get_device_properties(idx)
+        vram_total = props.total_memory / (1024**3)
+        vram_alloc = torch.cuda.memory_allocated(idx) / (1024**3)
+        vram_reserved = torch.cuda.memory_reserved(idx) / (1024**3)
+        vram_pct = min(100.0, (vram_reserved / max(vram_total, 1e-6)) * 100.0)
+
+    ram_line = "N/A"
+    ram_pct_value = 0.0
+    if ram_pct is not None and ram_used is not None and ram_total is not None:
+        ram_line = f"{ram_used:.1f} / {ram_total:.1f} GB ({ram_pct:.0f}%)"
+        ram_pct_value = float(max(0.0, min(100.0, ram_pct)))
+
+    vram_line = "CUDA not available"
+    vram_pct_value = 0.0
+    if vram_pct is not None and vram_alloc is not None and vram_reserved is not None and vram_total is not None:
+        vram_line = f"{vram_alloc:.2f} GB alloc | {vram_reserved:.2f} / {vram_total:.2f} GB reserved ({vram_pct:.0f}%)"
+        vram_pct_value = float(max(0.0, min(100.0, vram_pct)))
+
+    return ram_line, ram_pct_value, vram_line, vram_pct_value
+
+
+def _vi_dropdown_update(selected: str = VI_NONE_CHOICE):
+    choices = vi_voice_choices()
+    value = selected if selected in choices else VI_NONE_CHOICE
+    return gr.update(choices=choices, value=value)
+
+
+def _save_vi_voice_ui(voice_name, ref_audio, ref_text, batch_voice_val, news_voice_val):
+    ref_ta = (ref_text or "").strip()
+    if not ref_ta:
+        return (
+            "❌ Lỗi: Cần nhập transcript tiếng Việt để F5-TTS clone giọng chính xác.",
+            vi_voice_rows(),
+            _vi_dropdown_update(),
+            _vi_dropdown_update(batch_voice_val),
+            _vi_dropdown_update(news_voice_val),
+        )
+    msg = save_vi_voice(voice_name, ref_audio, ref_ta)
+    return msg, vi_voice_rows(), _vi_dropdown_update(voice_name), _vi_dropdown_update(voice_name), _vi_dropdown_update(voice_name)
+
+
+def _delete_vi_voice_ui(name: str, batch_voice_val: str, news_voice_val: str):
+    msg = delete_vi_voice(name)
+    return msg, vi_voice_rows(), _vi_dropdown_update(), _vi_dropdown_update(batch_voice_val), _vi_dropdown_update(news_voice_val)
+
+
+def _preview_vi_voice_ui(name: str):
+    audio_tuple, ref_text = preview_vi_voice(name)
+    return audio_tuple, ref_text
+
+
+def build_ui():
+    ensure_voice_library()
+    ensure_vi_voice_library()
+
+    custom_css = """
+    .gradio-container {
+      max-width: none !important;
+      padding-left: 14px !important;
+      padding-right: 14px !important;
+      --color-accent: #2f62d0 !important;
+      --color-accent-soft: #e8f0ff !important;
+      --button-primary-background-fill: #2f62d0 !important;
+      --button-primary-background-fill-hover: #1d4fb7 !important;
+      --button-primary-border-color: #1d4fb7 !important;
+      --button-primary-text-color: #ffffff !important;
+    }
+    .tabs {border-radius: 12px;}
+    .tabs button {font-weight: 600 !important;}
+    .block, .gr-box, .gr-group {border-radius: 12px !important;}
+    .gr-button-primary,
+    .gradio-container button.primary,
+    .gradio-container .primary {
+      background: linear-gradient(135deg, #2f62d0, #1d4fb7) !important;
+      border: 0 !important;
+      color: #fff !important;
+    }
+    .resource-card {
+      border-radius: 12px !important;
+      padding: 14px !important;
+      border: 1px solid #3b3f4a !important;
+      outline: none !important;
+      background: #2c2f37 !important;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.28) !important;
+    }
+    .resource-card * {color: #dce8ff !important;}
+    .resource-title {
+      margin: 0 0 10px 0 !important;
+      font-size: 1.05rem !important;
+      font-weight: 700 !important;
+      color: #f3f6ff !important;
+    }
+    .resource-section {
+      border-radius: 10px !important;
+      border: 1px solid #4a4f5d !important;
+      background: #3a3d47 !important;
+      padding: 10px 12px !important;
+      margin-top: 8px !important;
+    }
+    .resource-section .resource-label {
+      margin: 0 !important;
+      font-size: 0.82rem !important;
+      font-weight: 700 !important;
+      color: #e8eeff !important;
+      letter-spacing: 0.2px !important;
+    }
+    .resource-section .resource-value {
+      margin: 4px 0 8px 0 !important;
+      font-size: 0.9rem !important;
+      color: #d3dcf2 !important;
+    }
+    .resource-card input[type="range"] {
+      accent-color: #6da7ff !important;
+    }
+    .resource-card .gr-block,
+    .resource-card .gr-box,
+    .resource-card .gr-form {
+      background: transparent !important;
+      border: none !important;
+      box-shadow: none !important;
+    }
+    .resource-card .gradio-slider {
+      background: transparent !important;
+      border: none !important;
+      box-shadow: none !important;
+      padding-left: 0 !important;
+      padding-right: 0 !important;
+    }
+    .resource-card input[type="number"],
+    .resource-card button[aria-label*="refresh"],
+    .resource-card button[title*="refresh"] {
+      display: none !important;
+    }
+    .delete-btn {
+      background: linear-gradient(135deg, #e63946, #bd001b) !important;
+      color: #fff !important;
+      font-weight: bold !important;
+      border: 1px solid #ff4d4d !important;
+      font-size: 1.1rem !important;
+      padding: 12px !important;
+      border-radius: 8px !important;
+      box-shadow: 0 4px 10px rgba(230, 57, 70, 0.4) !important;
+      transition: all 0.2s ease !important;
+    }
+    .delete-btn:hover {
+      background: linear-gradient(135deg, #bd001b, #9e0015) !important;
+      box-shadow: 0 4px 12px rgba(230, 57, 70, 0.6) !important;
+      transform: translateY(-1px) !important;
+    }
+    """
+
+    with gr.Blocks(title="Qwen3-TTS Enhanced Studio", css=custom_css) as demo:
+        with gr.Row():
+            with gr.Column(scale=5):
+                gr.HTML(
+                    f"""
+<div style="max-width: 1000px; margin: 0 auto 14px auto; text-align: center; padding: 16px 18px; border-radius: 12px; background: linear-gradient(135deg, #0f2347 0%, #1b3a73 45%, #2b5298 100%); box-shadow: 0 6px 18px rgba(12, 26, 53, 0.28);">
+  <h1 style="margin: 0; font-size: 2.15rem; font-weight: 700; letter-spacing: 0.2px; color: #f5f8ff;">Qwen3-TTS Enhanced Studio</h1>
+  <p style="margin: 10px 0 8px 0; font-size: 1.02rem; color: #d7e4ff;">Professional voice workflows with persistent voice library and on-demand model loading.</p>
+  <div style="margin: 14px auto 0 auto; max-width: 920px; display: flex; align-items: center; gap: 12px; padding: 12px 14px; border-radius: 10px; border: 1px solid rgba(170,197,255,0.35); background: rgba(255,255,255,0.08);">
+    <div style="width: 46px; height: 46px; min-width: 46px; border-radius: 50%; display: grid; place-items: center; font-size: 0.9rem; font-weight: 700; background: rgba(255, 255, 255, 0.18); border: 1px solid rgba(255,255,255,0.35); color: #eef5ff;">TOG</div>
+    <div style="flex: 1; text-align: left;">
+      <div style="font-size: 1rem; font-weight: 700; color:#f3f7ff; margin-bottom: 2px;">Qwen TTS by The Oracle Guy</div>
+      <div style="font-size: 0.88rem; color:#dce8ff;">Subscribe for more AI voice tools, updates, and releases.</div>
+    </div>
+    <a href="https://www.youtube.com/@theoracleguy_AI?sub_confirmation=1" target="_blank" style="text-decoration: none; background: linear-gradient(135deg, #ff5f6d, #ff3d57); color: #fff; border-radius: 8px; padding: 8px 13px; font-size: 0.86rem; font-weight: 700;">Subscribe</a>
+  </div>
+</div>
+"""
+                )
+            with gr.Column(scale=2):
+                ram_line, ram_pct, vram_line, vram_pct = _resource_monitor_values()
+                with gr.Group(elem_classes=["resource-card"]):
+                    gr.Markdown("<div class='resource-title'>Resource Monitor</div>")
+                    with gr.Group(elem_classes=["resource-section"]):
+                        gr.Markdown("<div class='resource-label'>RAM</div>")
+                        resource_ram_line = gr.Markdown(f"<div class='resource-value'>{ram_line}</div>")
+                        resource_ram_bar = gr.Slider(
+                            minimum=0,
+                            maximum=100,
+                            value=ram_pct,
+                            step=0.1,
+                            label=None,
+                            interactive=False,
+                            show_label=False,
+                            container=False,
+                            show_reset_button=False,
+                        )
+                    with gr.Group(elem_classes=["resource-section"]):
+                        gr.Markdown("<div class='resource-label'>VRAM</div>")
+                        resource_vram_line = gr.Markdown(f"<div class='resource-value'>{vram_line}</div>")
+                        resource_vram_bar = gr.Slider(
+                            minimum=0,
+                            maximum=100,
+                            value=vram_pct,
+                            step=0.1,
+                            label=None,
+                            interactive=False,
+                            show_label=False,
+                            container=False,
+                            show_reset_button=False,
+                        )
+                gr.Timer(2.0).tick(
+                    _resource_monitor_values,
+                    outputs=[resource_ram_line, resource_ram_bar, resource_vram_line, resource_vram_bar],
+                )
+
+        with gr.Tabs():
+            with gr.Tab("🌏 OMNI Voice Studio (VN + Global)"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        with gr.Tabs():
+                            with gr.Tab("🧬 Clone / Upload Voice"):
+                                gr.Markdown("""
+### 🌏 Lưu Voice (OmniVoice — 600+ Ngôn Ngữ)
+> Upload ref audio **ngắn (< 10 giây)**, sắt nét, ít tạp âm.  
+> Nhập transcript — OmniVoice sẽ auto-transcribe nếu bạn bỏ trống.
+""")
+                                vi_clone_name  = gr.Textbox(label="Tên voice", placeholder="e.g. Nam_Cật_Nam")
+                                vi_clone_audio = gr.Audio(
+                                    label="Ref Audio (âm thanh mẫu)",
+                                    type="numpy",
+                                    sources=["upload", "microphone"],
+                                )
+                                vi_clone_text  = gr.Textbox(
+                                    label="Transcript Tiếng Việt (bắt buộc)",
+                                    lines=3,
+                                    placeholder="Nhập chính xác nội dung đoạn âm thanh tham chiếu...",
+                                )
+                                vi_clone_btn    = gr.Button("💾 Lưu Voice VN", variant="primary")
+                                vi_clone_status = gr.Textbox(label="Trạng thái", lines=2, interactive=False)
+
+                    with gr.Column(scale=3):
+                        gr.Markdown("### 📚 Thư viện Voice Tiếng Việt")
+                        vi_refresh_btn  = gr.Button("🔄 Refresh")
+                        vi_voice_table  = gr.Dataframe(
+                            headers=["Tên", "Có Transcript", "Ngày tạo"],
+                            value=vi_voice_rows(),
+                            interactive=False,
+                            row_count=(8, "fixed"),
+                        )
+                        vi_manage_voice   = gr.Dropdown(
+                            label="Chọn voice để quản lý",
+                            choices=vi_voice_choices(),
+                            value=VI_NONE_CHOICE,
+                        )
+                        vi_manage_preview = gr.Audio(label="Preview Voice", type="numpy")
+                        vi_manage_text    = gr.Textbox(label="Transcript đã lưu", lines=2, interactive=False)
+                        vi_delete_btn     = gr.Button("🗑️ XÓA VOICE ĐÃ CHỌN", variant="stop", elem_classes=["delete-btn"])
+                        vi_delete_status  = gr.Textbox(label="Delete Status", lines=2, interactive=False)
+
+            with gr.Tab("🌏 OMNI Batch (VN + Global)"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        gr.Markdown("""
+### 🌏 OmniVoice — Batch TXT (600+ Ngôn Ngữ)
+Xử lý nhiều file `.txt` bằng OmniVoice — hỗ trợ **ALL** ngôn ngữ.  
+Output: **MP3 + SRT** (tự động validate sau mỗi file).
+""")
+                        gr.Markdown("### 📂 Input Folders")
+                        omni_paths = gr.Textbox(
+                            label="Thư mục (mỗi dòng 1 đường dẫn)",
+                            lines=3,
+                            placeholder="D:\\Kenh\\Video1\nD:\\Kenh\\Video2",
+                        )
+
+                        gr.Markdown("### 🎤 Voice & Language")
+                        omni_voice_select = gr.Dropdown(
+                            label="Chọn Voice (từ Voice Studio)",
+                            choices=vi_voice_choices(),
+                            value=VI_NONE_CHOICE,
+                            info="Voice được quản lý tại tab OMNI Voice Studio",
+                        )
+                        omni_voice_preview = gr.Audio(label="Preview Voice", type="numpy")
+                        omni_language = gr.Dropdown(
+                            label="🌐 Ngôn Ngữ (Language)",
+                            choices=[
+                                "auto", "Vietnamese", "English", "Chinese", "Japanese",
+                                "Korean", "French", "German", "Spanish", "Italian",
+                                "Portuguese", "Russian", "Arabic", "Hindi", "Thai",
+                                "Indonesian", "Malay", "Filipino", "Turkish", "Polish",
+                                "Dutch", "Swedish", "Czech", "Romanian", "Hungarian",
+                                "Greek", "Hebrew", "Persian", "Ukrainian", "Bengali",
+                                "Tamil", "Telugu", "Urdu", "Swahili",
+                            ],
+                            value="auto",
+                            info="OmniVoice hỗ trợ 600+ ngôn ngữ — chọn 'auto' để tự phát hiện",
+                        )
+
+                        gr.Markdown("### ⚙️ Cài đặt")
+
+                        try:
+                            from qwen_app.omni_engine import gpu_profile as _gp
+                            _auto_step = _gp.num_step
+                            _gpu_info = (
+                                f"> 🖥️ **GPU Auto-Tune:** {_gp.gpu_name} ({_gp.vram_gb:.1f}GB) | "
+                                f"Tier **{_gp.tier.upper()}** | "
+                                f"Steps={_gp.num_step} | Chunk={_gp.chunk_size}\n"
+                            )
+                        except Exception:
+                            _auto_step = 32
+                            _gpu_info = ""
+
+                        with gr.Row():
+                            omni_speed = gr.Slider(0.5, 2.0, value=1.0, step=0.05, label="Speed")
+                            omni_step  = gr.Slider(8, 64, value=_auto_step, step=8,
+                                                   label=f"Diffusion Steps (auto={_auto_step})")
+                            omni_norm  = gr.Checkbox(label="Normalize", value=True)
+                            
+                        gr.Markdown("#### ⚡ Hiệu suất (Flash Attention 2)")
+                        with gr.Row():
+                            omni_flash2 = gr.Checkbox(label="Bật Flash-Attention 2", value=False)
+                            omni_flash2_whl = gr.File(label="Chọn file .whl (Chỉ cần 1 lần đầu)", file_types=[".whl"], type="filepath", file_count="single")
+
+                        gr.Markdown("#### 🛡️ Pre-check (Kiểm duyệt văn bản)")
+                        with gr.Group(elem_classes=["resource-section"]):
+                            omni_precheck = gr.Checkbox(label="Bật kiểm tra dấu câu bắt buộc", value=True)
+                            with gr.Row():
+                                omni_precheck_punct = gr.Textbox(label="Các dấu câu bắt buộc", value=".,!?;:。？！…", lines=1)
+                                omni_precheck_max_len = gr.Number(label="Độ dài tối đa đoạn không có dấu câu (ký tự)", value=400, precision=0)
+
+                        gr.Markdown(f"""
+{_gpu_info}> ℹ️ **Auto Chunk:** Tự động theo VRAM GPU.  
+> 🌍 **OmniVoice** — RTF 0.025 (40x faster than real-time).  
+> Steps cao hơn = chất lượng cao hơn (32 khuyến nghị, 16 nếu cần nhanh).
+""")
+
+                        omni_ps, omni_pc, omni_psc, omni_pco, omni_pel, omni_pnl, omni_pdf = _pause_ui("OMNI Batch")
+                        omni_btn = gr.Button("🚀 START OMNI BATCH", variant="primary")
+
+                    with gr.Column(scale=2):
+                        gr.Markdown("### 📋 Execution Log")
+                        omni_log = gr.Textbox(
+                            label="Status",
+                            lines=28,
+                            max_lines=40,
+                            interactive=False,
+                            value="Sẵn sàng. Chọn voice + folder + language rồi nhấn START.",
+                        )
+
+
+            with gr.Tab("📰 OMNI News Batch (Phase)"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        gr.Markdown("""
+### 📰 OmniVoice — News Batch (Phase Mode)
+Xử lý hàng loạt file `.txt` theo **định dạng PHASE** (STORY | PHASE N | nội dung | Prompt N: ...)  
+Mỗi PHASE → **1 MP3 riêng** + `FULL_MASTER.srt` tổng hợp.  
+Dùng **OmniVoice 600+ ngôn ngữ** — clone giọng tự động.
+""")
+                        gr.Markdown("### 📂 Input Folders")
+                        omni_news_paths = gr.Textbox(
+                            label="Thư mục chứa file .txt (mỗi dòng 1 đường dẫn)",
+                            lines=3,
+                            placeholder="D:\\Kenh\\Video1\nD:\\Kenh\\Video2",
+                        )
+
+                        gr.Markdown("### 🎤 Voice & Language")
+                        omni_news_voice = gr.Dropdown(
+                            label="Chọn Voice (từ OMNI Voice Studio)",
+                            choices=vi_voice_choices(),
+                            value=VI_NONE_CHOICE,
+                            info="Voice được quản lý tại tab OMNI Voice Studio",
+                        )
+                        omni_news_preview = gr.Audio(label="Preview Voice", type="numpy")
+                        omni_news_language = gr.Dropdown(
+                            label="🌐 Ngôn Ngữ (Language)",
+                            choices=[
+                                "auto", "Vietnamese", "English", "Chinese", "Japanese",
+                                "Korean", "French", "German", "Spanish", "Italian",
+                                "Portuguese", "Russian", "Arabic", "Hindi", "Thai",
+                                "Indonesian", "Malay", "Filipino", "Turkish", "Polish",
+                                "Dutch", "Swedish", "Czech", "Romanian", "Hungarian",
+                                "Greek", "Hebrew", "Persian", "Ukrainian", "Bengali",
+                                "Tamil", "Telugu", "Urdu", "Swahili",
+                            ],
+                            value="auto",
+                            info="OmniVoice hỗ trợ 600+ ngôn ngữ — chọn 'auto' để tự phát hiện",
+                        )
+
+                        gr.Markdown("### ⚙️ Cài đặt")
+                        with gr.Row():
+                            omni_news_speed = gr.Slider(0.5, 2.0, value=1.0, step=0.05, label="Speed")
+                            omni_news_step  = gr.Slider(8, 64, value=_auto_step, step=8,
+                                                        label=f"Diffusion Steps (auto={_auto_step})")
+                            omni_news_norm  = gr.Checkbox(label="Normalize", value=True)
+                        
+                        gr.Markdown("#### ⚡ Hiệu suất (Flash Attention 2)")
+                        with gr.Row():
+                            omni_news_flash2 = gr.Checkbox(label="Bật Flash-Attention 2", value=False)
+                            omni_news_flash2_whl = gr.File(label="Chọn file .whl (Chỉ cần 1 lần đầu)", file_types=[".whl"], type="filepath", file_count="single")
+
+                        gr.Markdown("#### 🛡️ Pre-check (Kiểm duyệt văn bản)")
+                        with gr.Group(elem_classes=["resource-section"]):
+                            omni_news_precheck = gr.Checkbox(label="Bật kiểm tra dấu câu bắt buộc", value=True)
+                            with gr.Row():
+                                omni_news_precheck_punct = gr.Textbox(label="Các dấu câu bắt buộc", value=".,!?;:。？！…", lines=1)
+                                omni_news_precheck_max_len = gr.Number(label="Độ dài tối đa đoạn không có dấu câu (ký tự)", value=400, precision=0)
+
+                        gr.Markdown("""
+> 📋 **Định dạng PHASE** yêu cầu:  
+> `STORY |`  
+> `PHASE 1 | nội dung... | Prompt 1: mô tả`  
+> `PHASE 2 | nội dung... | Prompt 2: mô tả`  
+> `END GAMES`
+> 
+> ✅ Output: `_OUTPUT_PROJECTS/<tên file>/<phase>.mp3` + `FULL_MASTER.srt`
+""")
+
+                        omni_news_ps, omni_news_pc, omni_news_psc, omni_news_pco, omni_news_pel, omni_news_pnl, omni_news_pdf = _pause_ui("OMNI News")
+                        omni_news_btn = gr.Button("🚀 START OMNI NEWS BATCH", variant="primary")
+
+                    with gr.Column(scale=2):
+                        gr.Markdown("### 📋 Execution Log")
+                        omni_news_log = gr.Textbox(
+                            label="Status",
+                            lines=28,
+                            max_lines=40,
+                            interactive=False,
+                            value="Sẵn sàng. Chọn voice + folder + language rồi nhấn START.",
+                        )
+
+            with gr.Tab("🔍 Audio Validator"):
+                gr.Markdown("""
+### 🔍 Bidirectional Audio ↔ SRT Integrity Validator
+Công cụ trung gian kiểm tra TOÀN BỘ tính toàn vẹn của output:
+- **SRT → Audio**: mỗi dòng SRT có âm thanh thực sự không? (phát hiện đoạn silent)
+- **Audio → SRT**: mỗi vùng có tiếng nói có SRT entry không? (phát hiện timestamp lệch)
+- Báo cáo chi tiết với severity CRITICAL / WARNING và hành động khắc phục
+""")
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### 📂 Validate Output Folder (Batch)")
+                        val_folder = gr.Textbox(
+                            label="Output folder path",
+                            placeholder=r"D:\Kenh\Video1\_OUTPUT_PROJECTS\story_name",
+                            lines=1,
+                        )
+                        val_master_srt = gr.Textbox(
+                            label="Custom SRT path (optional, leave blank for auto-detect FULL_MASTER.srt)",
+                            placeholder=r"D:\...\FULL_MASTER.srt",
+                            lines=1,
+                        )
+                        val_folder_btn = gr.Button("🔍 Validate Folder", variant="primary")
+
+                        gr.Markdown("---")
+                        gr.Markdown("#### 🎯 Validate Single File Pair")
+                        val_audio_file = gr.Textbox(
+                            label="Audio file path (.mp3 / .wav)",
+                            placeholder=r"D:\...\phase.mp3",
+                            lines=1,
+                        )
+                        val_srt_file = gr.Textbox(
+                            label="SRT file path",
+                            placeholder=r"D:\...\FULL_MASTER.srt",
+                            lines=1,
+                        )
+                        val_single_btn = gr.Button("🔍 Validate Single Pair", variant="secondary")
+
+                    with gr.Column(scale=2):
+                        gr.Markdown("### 📋 Validation Report")
+                        val_log = gr.Textbox(
+                            label="Report",
+                            lines=32,
+                            max_lines=60,
+                            interactive=False,
+                            value="Chưa có kết quả. Nhấn Validate để bắt đầu.",
+                        )
+
+        # ── Audio Validator handlers ──────────────────────────────────────────
+        def _run_validate_folder(folder: str, master_srt: str) -> str:
+            folder = (folder or "").strip()
+            if not folder or not os.path.isdir(folder):
+                return "❌ Đường dẫn folder không hợp lệ hoặc không tồn tại."
+            srt_override = (master_srt or "").strip() or None
+            reports = validate_batch_output(folder, master_srt=srt_override)
+            if not reports:
+                return "⚠️ Không tìm thấy file MP3 nào trong folder này."
+            return format_batch_reports(reports)
+
+        def _run_validate_single(audio_path: str, srt_path: str) -> str:
+            audio_path = (audio_path or "").strip()
+            srt_path   = (srt_path or "").strip()
+            if not audio_path or not os.path.exists(audio_path):
+                return "❌ File audio không tồn tại."
+            if not srt_path or not os.path.exists(srt_path):
+                return "❌ File SRT không tồn tại."
+            report = validate_audio_vs_srt(audio_path, srt_path)
+            return format_validation_report(report)
+
+        val_folder_btn.click(
+            _run_validate_folder,
+            inputs=[val_folder, val_master_srt],
+            outputs=[val_log],
+        )
+
+        val_single_btn.click(
+            _run_validate_single,
+            inputs=[val_audio_file, val_srt_file],
+            outputs=[val_log],
+        )
+
+        # ── OMNI Voice Studio (VN + Global) ─────────────────────────────────────
+        vi_clone_btn.click(
+            _save_vi_voice_ui,
+            inputs=[vi_clone_name, vi_clone_audio, vi_clone_text, omni_voice_select, omni_news_voice],
+            outputs=[vi_clone_status, vi_voice_table, vi_manage_voice, omni_voice_select, omni_news_voice],
+        )
+
+        vi_refresh_btn.click(
+            lambda v1, v2, v3: (vi_voice_rows(), _vi_dropdown_update(v1), _vi_dropdown_update(v2), _vi_dropdown_update(v3)),
+            inputs=[vi_manage_voice, omni_voice_select, omni_news_voice],
+            outputs=[vi_voice_table, vi_manage_voice, omni_voice_select, omni_news_voice],
+        )
+
+        vi_manage_voice.change(
+            _preview_vi_voice_ui,
+            inputs=[vi_manage_voice],
+            outputs=[vi_manage_preview, vi_manage_text],
+        )
+
+        vi_delete_btn.click(
+            _delete_vi_voice_ui,
+            inputs=[vi_manage_voice, omni_voice_select, omni_news_voice],
+            outputs=[vi_delete_status, vi_voice_table, vi_manage_voice, omni_voice_select, omni_news_voice],
+        )
+
+        # ── OMNI Batch (VN + Global) ──────────────────────────────────────────
+        omni_voice_select.change(
+            lambda name: _preview_vi_voice_ui(name)[0],
+            inputs=[omni_voice_select],
+            outputs=[omni_voice_preview],
+        )
+
+        omni_btn.click(
+            process_omni_batch_txt,
+            inputs=[
+                omni_paths, omni_voice_select,
+                omni_speed, omni_norm, omni_step, omni_language,
+                omni_flash2, omni_flash2_whl,
+                omni_precheck, omni_precheck_punct, omni_precheck_max_len,
+                omni_ps, omni_pc, omni_psc, omni_pco, omni_pel, omni_pnl, omni_pdf,
+            ],
+            outputs=[omni_log],
+        )
+
+        # ── OMNI News Batch (Phase) ───────────────────────────────────────────
+        omni_news_voice.change(
+            lambda name: _preview_vi_voice_ui(name)[0],
+            inputs=[omni_news_voice],
+            outputs=[omni_news_preview],
+        )
+
+        omni_news_btn.click(
+            process_omni_news_batch,
+            inputs=[
+                omni_news_paths, omni_news_voice,
+                omni_news_speed, omni_news_norm, omni_news_step, omni_news_language,
+                omni_news_flash2, omni_news_flash2_whl,
+                omni_news_precheck, omni_news_precheck_punct, omni_news_precheck_max_len,
+                omni_news_ps, omni_news_pc, omni_news_psc, omni_news_pco,
+                omni_news_pel, omni_news_pnl, omni_news_pdf,
+            ],
+            outputs=[omni_news_log],
+        )
+
+    return demo

source/qwen_app/vi_normalizer.py

@@ -0,0 +1,199 @@
+# qwen_app/vi_normalizer.py
+"""
+Vietnamese Pure-Python Text Normalizer
+Zero pip dependencies.
+Handles:
+1. Numbers (1,500,000 -> một triệu năm trăm nghìn)
+2. Dates (15/08/2023 -> mười lăm tháng tám năm hai không hai ba)
+3. Symbols ($ -> đô la, % -> phần trăm)
+4. Loanwords (Facebook -> phây búc)
+"""
+
+import re
+
+# ─── 1. LOANWORDS DICTIONARY ────────────────────────────────────────────────
+
+LOANWORDS = {
+    "facebook": "phây búc",
+    "fb": "phây búc",
+    "marketing": "ma két tinh",
+    "smartphone": "xờ mát phôn",
+    "video": "vi đê ô",
+    "live": "lai",
+    "livestream": "lai chim",
+    "app": "áp",
+    "web": "oép",
+    "website": "oép sai",
+    "page": "pết",
+    "fanpage": "phan pết",
+    "tiktok": "tích tóc",
+    "youtube": "diu túp",
+    "google": "gu gồ",
+    "wifi": "oai phai",
+    "internet": "in tơ nét",
+    "online": "on lai",
+    "offline": "ọp lai",
+    "email": "i meo",
+    "mail": "meo",
+    "hotline": "hót lai",
+    "admin": "át min",
+    "sale": "xêu",
+    "sales": "xêu",
+    "nhân viên sale": "nhân viên xêu",
+    "pr": "pi a",
+    "ce": "xê e",
+    "ceo": "xi y âu",
+    "cfo": "xi ép âu",
+    "cto": "xi tê âu",
+    "kpi": "cây pi ai",
+    "okr": "âu ka rờ",
+    "view": "viu",
+    "like": "lai",
+    "share": "se",
+    "comment": "com men",
+    "post": "pốt",
+    "group": "rúp",
+    "update": "ấp đết",
+    "trend": "tren",
+    "hot": "hót",
+    "idol": "ai đồ",
+    "show": "xô",
+    "game": "gêm",
+    "laptop": "láp tốp",
+    "pc": "bê xê",
+    "macbook": "mác búc",
+    "apple": "áp pồ",
+    "samsung": "sam sung",
+    "ok": "ô kê",
+    "okay": "ô kê",
+    "vnđ": "đồng",
+    "vnd": "đồng",
+    "usd": "đô la mỹ",
+}
+
+# ─── 2. NUMBER TO TEXT ───────────────────────────────────────────────────────
+
+DIGITS = ["không", "một", "hai", "ba", "bốn", "năm", "sáu", "bảy", "tám", "chín"]
+UNITS = ["", "nghìn", "triệu", "tỷ", "nghìn tỷ", "triệu tỷ"]
+
+def _read_3_digits(n: int, read_zero_hundred: bool = False) -> str:
+    if n == 0:
+        return "không không không" if read_zero_hundred else ""
+    
+    h = n // 100
+    rem = n % 100
+    t = rem // 10
+    u = rem % 10
+    
+    words = []
+    
+    if h > 0 or read_zero_hundred:
+        words.append(DIGITS[h])
+        words.append("trăm")
+        
+    if t > 1:
+        words.append(DIGITS[t])
+        words.append("mươi")
+        if u == 1:
+            words.append("mốt")
+        elif u == 5:
+            words.append("lăm")
+        elif u > 0:
+            words.append(DIGITS[u])
+    elif t == 1:
+        words.append("mười")
+        if u == 5:
+            words.append("lăm")
+        elif u > 0:
+            words.append(DIGITS[u])
+    elif t == 0 and u > 0:
+        if h > 0 or read_zero_hundred:
+            words.append("lẻ")
+        words.append(DIGITS[u])
+        
+    return " ".join(words)
+
+def num_to_vi(n: int) -> str:
+    if n == 0:
+        return "không"
+    
+    is_negative = n < 0
+    n = abs(n)
+    
+    blocks = []
+    while n > 0:
+        blocks.append(n % 1000)
+        n //= 1000
+        
+    words = []
+    for i, block in enumerate(blocks):
+        if block > 0:
+            read_zero = i < len(blocks) - 1 and blocks[i] < 100
+            if i > 0 and len(blocks) > 1 and i < len(blocks) - 1:
+                read_zero = True
+            
+            block_str = _read_3_digits(block, read_zero_hundred=(i < len(blocks) -1))
+            block_str = block_str.strip()
+            
+            if block_str:
+                if UNITS[i]:
+                    words.insert(0, UNITS[i])
+                words.insert(0, block_str)
+                
+    res = " ".join(words).strip()
+    # Cleanup edge cases
+    res = re.sub(r'không trăm lẻ không\s*', '', res).strip()
+    return "âm " + res if is_negative else res
+
+# ─── 3. TEXT REPLACEMENTS ────────────────────────────────────────────────────
+
+def _replace_number_match(match):
+    num_str = match.group(0)
+    # Remove dots and commas used as thousand separators
+    clean_num = num_str.replace('.', '').replace(',', '')
+    try:
+        val = int(clean_num)
+        return num_to_vi(val)
+    except:
+        return num_str
+
+def _replace_date_match(match):
+    d = match.group(1)
+    m = match.group(2)
+    y = match.group(4) # group 3 is the / delimiter
+    
+    res = f"ngày {num_to_vi(int(d))} tháng {num_to_vi(int(m))}"
+    if y:
+        # read year digit by digit if starts with 20 or read normally
+        year_val = int(y)
+        res += f" năm {num_to_vi(year_val)}"
+    return res
+
+def normalize_vi_text(text: str) -> str:
+    if not text:
+        return text
+        
+    # 1. Loanwords (Case insensitive word boundary)
+    for word, replacement in LOANWORDS.items():
+        text = re.sub(rf'\b{word}\b', replacement, text, flags=re.IGNORECASE)
+        
+    # 2. Symbols
+    text = text.replace('%', ' phần trăm ')
+    text = text.replace('$', ' đô la ')
+    text = text.replace('&', ' và ')
+    text = text.replace('+', ' cộng ')
+    
+    # 3. Dates (dd/mm/yyyy or dd/mm)
+    text = re.sub(r'\b(\d{1,2})/(\d{1,2})(/(\d{2,4}))?\b', _replace_date_match, text)
+    
+    # 4. Numbers (e.g. 1.500.000 or 1500000)
+    text = re.sub(r'\b\d{1,3}(?:[.,]\d{3})+\b|\b\d+\b', _replace_number_match, text)
+    
+    # Cleanup extra spaces
+    text = re.sub(r'\s+', ' ', text).strip()
+    
+    return text
+
+if __name__ == "__main__":
+    t = "Smartphone này giá 1.500.000 VNĐ ra mắt ngày 15/08/2023 trên Facebook"
+    print(normalize_vi_text(t))

source/qwen_app/vi_prosody.py

@@ -0,0 +1,262 @@
+# qwen_app/vi_prosody.py
+"""
+Vietnamese Prosody Preprocessor — 100% Pure Python
+====================================================
+ZERO external dependencies. No pip install needed.
+
+Built-in Vietnamese word segmentation + grammar rules
+to insert natural pause markers for F5-TTS.
+
+Pipeline:
+  Raw text → normalize → grammar analysis → <#x#> pause markers → F5-TTS
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import List, Tuple
+
+logger = logging.getLogger("qwen_app.vi_prosody")
+
+
+# ─── Built-in Vietnamese Word Database ───────────────────────────────────────
+# These replace pyvi — lightweight, no dependencies
+
+# Conjunctions → pause 0.15s BEFORE
+CONJUNCTIONS = {
+    "và", "nhưng", "hoặc", "mà", "rồi", "nên", "vì", "do",
+    "tuy", "song", "bởi", "hay", "dù", "để", "nếu", "thì",
+    "còn", "lại", "mới", "nào", "như", "khi",
+}
+
+# Prepositions → pause 0.1s BEFORE (lighter than conjunction)
+PREPOSITIONS = {
+    "trong", "ngoài", "trên", "dưới", "về", "từ", "với",
+    "bằng", "theo", "qua", "đến", "tới", "giữa", "cùng",
+    "trước", "sau", "bên", "gần", "xa",
+}
+
+# Sentence-opening adverbs → pause 0.3s AFTER (longest first for greedy match)
+SENTENCE_ADVERBS = [
+    "nói cách khác", "bên cạnh đó", "chính vì thế", "thêm vào đó",
+    "không những", "ngoài ra", "hơn nữa", "mặt khác",
+    "nói chung", "tóm lại", "trước hết", "sau đó",
+    "tiếp theo", "cuối cùng", "đặc biệt", "tuy nhiên",
+    "vì vậy", "do đó", "thật ra", "thực ra", "rõ ràng",
+    "dĩ nhiên", "tất nhiên", "bỗng nhiên", "bất ngờ",
+    "đột nhiên", "thế rồi", "rồi thì", "đồng thời",
+    "ngược lại", "may mắn", "không may", "đáng tiếc",
+    "lạ thay", "thú vị", "quả thật", "đúng vậy",
+    "rất tiếc", "tuy vậy", "dù sao", "mặc dù",
+    "cho nên", "bởi vậy", "vì thế", "nhờ đó",
+]
+
+# Time/place markers at sentence start → pause AFTER
+TIME_PLACE = [
+    "hôm nay", "hôm qua", "ngày mai", "tối nay", "sáng nay",
+    "chiều nay", "lúc đó", "khi đó", "bấy giờ", "ngày xưa",
+    "thuở xưa", "xa xưa", "ở đây", "tại đây", "nơi đây",
+    "bên ngoài", "bên trong", "phía trước", "phía sau",
+    "ngay lúc đó", "vào lúc đó", "trong lúc đó",
+    "mỗi ngày", "mỗi sáng", "mỗi tối", "từ đó",
+]
+
+# Emotion/intensity words → slight pause BEFORE for emphasis
+EMPHASIS_WORDS = {
+    "thật", "rất", "quá", "vô_cùng", "cực_kỳ", "hết_sức",
+    "khủng_khiếp", "kinh_khủng", "tuyệt_vời", "tuyệt_đẹp",
+}
+
+# Common Vietnamese compound words (2-syllable) to NOT split
+COMPOUNDS = {
+    "việt nam", "hà nội", "sài gòn", "đà nẵng", "hải phòng",
+    "thành phố", "đại học", "bệnh viện", "trường học",
+    "công nghệ", "khoa học", "xã hội", "kinh tế",
+    "chính trị", "văn hóa", "lịch sử", "giáo dục",
+    "quốc gia", "thế giới", "con người", "cuộc sống",
+    "tình yêu", "hạnh phúc", "gia đình", "bạn bè",
+}
+
+# Common abbreviations
+ABBREVIATIONS = {
+    "TP.": "thành phố", "PGS.": "phó giáo sư", "GS.": "giáo sư",
+    "TS.": "tiến sĩ", "ThS.": "thạc sĩ", "BS.": "bác sĩ",
+    "KS.": "kỹ sư", "NXB.": "nhà xuất bản", "PGĐ.": "phó giám đốc",
+    "TPHCM": "thành phố hồ chí minh",
+    "VND": "việt nam đồng", "USD": "đô la mỹ",
+}
+
+
+# ─── Stage 1: Text Normalization ─────────────────────────────────────────────
+
+def normalize_vietnamese(text: str) -> str:
+    """Normalize Vietnamese text — pure Python, zero dependencies."""
+    if not text or not text.strip():
+        return text
+
+    result = text.strip()
+
+    # Expand abbreviations
+    for abbr, full in ABBREVIATIONS.items():
+        result = result.replace(abbr, full)
+
+    # Unicode quote normalization
+    for old, new in [('\u201c', '"'), ('\u201d', '"'), ('\u2018', "'"), ('\u2019', "'")]:
+        result = result.replace(old, new)
+
+    # Normalize dots: ". . ." → "..."
+    result = re.sub(r'\.\s*\.\s*\.', '...', result)
+
+    # Collapse whitespace
+    result = re.sub(r'[ \t]+', ' ', result)
+    result = re.sub(r'\n+', ' ', result)
+
+    # Ensure ending punctuation
+    result = result.strip()
+    if result and result[-1] not in '.!?':
+        result += '.'
+
+    return result
+
+
+# ─── Stage 2: Grammar-Aware Prosody ──────────────────────────────────────────
+
+def predict_prosody(text: str) -> str:
+    """
+    Insert <#x#> pause markers using Vietnamese grammar rules.
+    100% Python — no external libraries.
+    """
+    if not text or not text.strip():
+        return text
+
+    # Split into sentences safely (supports quotes and ellipses) without look-behind
+    pattern = r'([.!?…।؟。！？]+[\"\'”’]?(?:[ \t]+|\n+|$))'
+    parts = re.split(pattern, text)
+    sentences = []
+    for i in range(0, len(parts) - 1, 2):
+        sent = parts[i] + parts[i+1]
+        if sent.strip():
+            sentences.append(sent.strip())
+    if len(parts) % 2 != 0 and parts[-1].strip():
+        sentences.append(parts[-1].strip())
+
+    processed = []
+
+    for sent in sentences:
+        if not sent.strip():
+            continue
+        result = _process_sentence(sent)
+        processed.append(result)
+
+    # Join sentences with inter-sentence pause
+    return ' <#0.4#> '.join(processed)
+
+
+def _process_sentence(sent: str) -> str:
+    """Process a single sentence: add pauses at grammatically correct positions."""
+
+    # 1. Handle ellipsis FIRST (dramatic pause)
+    result = re.sub(r'\.\.\.+\s*', '... <#0.6#> ', sent)
+
+    # 2. Handle existing punctuation
+    result = re.sub(r',\s+', ', <#0.2#> ', result)
+    result = re.sub(r':\s+', ': <#0.3#> ', result)
+    result = re.sub(r';\s+', '; <#0.25#> ', result)
+
+    # 3. Handle quotes (dramatic pause before/after dialogue)
+    result = re.sub(r'\s+"', ' <#0.3#> "', result)
+    result = re.sub(r'"\s+', '" <#0.3#> ', result)
+
+    # 4. Check sentence-opening adverbs
+    sent_lower = result.lower().lstrip()
+    for adverb in SENTENCE_ADVERBS:
+        if sent_lower.startswith(adverb):
+            idx = len(adverb)
+            rest = result[idx:].lstrip()
+            if not rest.startswith(',') and not rest.startswith('<#'):
+                result = result[:idx] + ', <#0.3#> ' + rest
+            break
+
+    # 5. Check time/place markers at sentence start
+    if not any(sent_lower.startswith(a) for a in SENTENCE_ADVERBS):
+        for tp in TIME_PLACE:
+            if sent_lower.startswith(tp):
+                idx = len(tp)
+                rest = result[idx:].lstrip()
+                if not rest.startswith(',') and not rest.startswith('<#'):
+                    result = result[:idx] + ', <#0.2#> ' + rest
+                break
+
+    # 6. Word-level analysis: conjunctions, prepositions, long clauses
+    words = result.split()
+    new_words = []
+    word_count = 0  # words since last pause
+
+    for i, word in enumerate(words):
+        # Skip existing pause markers
+        if word.startswith('<#') and word.endswith('#>'):
+            new_words.append(word)
+            word_count = 0
+            continue
+
+        clean = word.lower().strip('.,!?;:"\'-')
+
+        # Hỗ trợ đắc lực: Chỉ ngắt trước liên từ/giới từ khi câu đang dồn quá nhiều chữ (>5 chữ)
+        if clean in CONJUNCTIONS and i > 2 and word_count > 4:
+            if not (new_words and new_words[-1].startswith('<#')):
+                new_words.append('<#0.15#>')
+                word_count = 0
+
+        elif clean in PREPOSITIONS and i > 3 and word_count > 6:
+            if not (new_words and new_words[-1].startswith('<#')):
+                new_words.append('<#0.1#>')
+                word_count = 0
+
+        new_words.append(word)
+        word_count += 1
+
+        # Reset counter after punctuation
+        if word.endswith((',', '.', '!', '?', ';', ':', '...')):
+            word_count = 0
+
+    result = ' '.join(new_words)
+
+    # 7. Cleanup: remove double markers
+    result = re.sub(r'(<#[\d.]+#>\s*){2,}', lambda m: m.group(0).split()[0] + ' ', result)
+    result = re.sub(r'^\s*<#[\d.]+#>\s*', '', result)
+
+    return result.strip()
+
+
+# ─── Main API ────────────────────────────────────────────────────────────────
+
+def preprocess_simple(text: str) -> str:
+    """
+    Full pipeline: normalize → prosody → text with <#x#> markers.
+    Called by mode_f5_batch.py before chunking.
+    """
+    if not text or not text.strip():
+        return text
+
+    normalized = normalize_vietnamese(text)
+    result = predict_prosody(normalized)
+
+    marker_count = result.count('<#')
+    logger.info(f"[vi_prosody] {len(text)} chars → {marker_count} pause markers")
+    return result
+
+
+def split_by_pauses(text: str) -> List[Tuple[str, float]]:
+    """Split text with <#x#> markers into [(segment, pause_seconds)]."""
+    if not text:
+        return [("", 0.0)]
+    parts = re.split(r'<#(\d+\.?\d*)#>', text)
+    segments = []
+    for i in range(0, len(parts), 2):
+        t = parts[i].strip()
+        if not t:
+            continue
+        p = float(parts[i + 1]) if i + 1 < len(parts) else 0.0
+        segments.append((t, p))
+    return segments if segments else [(text, 0.0)]

source/qwen_app/voice_library.py

@@ -0,0 +1,238 @@
+import json
+import re
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import soundfile as sf
+
+from .config import VOICE_AUDIO_DIR, VOICE_DB_PATH, VOICE_LIB_DIR
+
+
+def ensure_voice_library() -> None:
+    VOICE_AUDIO_DIR.mkdir(parents=True, exist_ok=True)
+    if not VOICE_DB_PATH.exists():
+        VOICE_DB_PATH.write_text(json.dumps({"voices": []}, indent=2), encoding="utf-8")
+
+
+def load_voice_db() -> Dict:
+    ensure_voice_library()
+    try:
+        return json.loads(VOICE_DB_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        return {"voices": []}
+
+
+def save_voice_db(db: Dict) -> None:
+    ensure_voice_library()
+    VOICE_DB_PATH.write_text(json.dumps(db, indent=2), encoding="utf-8")
+
+
+def slugify(value: str) -> str:
+    value = re.sub(r"[^a-zA-Z0-9_-]+", "-", value.strip()).strip("-")
+    return value.lower() or "voice"
+
+
+def normalize_audio(wav, eps: float = 1e-12, clip: bool = True) -> np.ndarray:
+    x = np.asarray(wav)
+
+    if np.issubdtype(x.dtype, np.integer):
+        info = np.iinfo(x.dtype)
+        if info.min < 0:
+            y = x.astype(np.float32) / max(abs(info.min), info.max)
+        else:
+            mid = (info.max + 1) / 2.0
+            y = (x.astype(np.float32) - mid) / mid
+    elif np.issubdtype(x.dtype, np.floating):
+        y = x.astype(np.float32)
+        m = np.max(np.abs(y)) if y.size else 0.0
+        if m > 1.0 + 1e-6:
+            y = y / (m + eps)
+    else:
+        raise TypeError(f"Unsupported audio dtype: {x.dtype}")
+
+    if clip:
+        y = np.clip(y, -1.0, 1.0)
+
+    if y.ndim > 1:
+        y = np.mean(y, axis=-1).astype(np.float32)
+
+    return y
+
+
+def audio_to_tuple(audio) -> Optional[Tuple[np.ndarray, int]]:
+    if audio is None:
+        return None
+
+    if isinstance(audio, tuple) and len(audio) == 2:
+        if isinstance(audio[0], int):
+            sr, wav = audio
+            return normalize_audio(wav), int(sr)
+        if isinstance(audio[1], int):
+            wav, sr = audio
+            return normalize_audio(wav), int(sr)
+
+    if isinstance(audio, dict) and "sampling_rate" in audio and "data" in audio:
+        return normalize_audio(audio["data"]), int(audio["sampling_rate"])
+
+    if isinstance(audio, str) and Path(audio).exists():
+        wav, sr = sf.read(audio, dtype="float32", always_2d=False)
+        if wav.ndim > 1:
+            wav = np.mean(wav, axis=-1)
+        return normalize_audio(wav), int(sr)
+
+    return None
+
+
+def set_seed(seed: int) -> None:
+    if seed <= 0:
+        return
+    import torch
+    import numpy as np
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+def voice_choices() -> List[str]:
+    voices = load_voice_db().get("voices", [])
+    names = sorted(v.get("name", "") for v in voices if v.get("name"))
+    return ["None"] + names
+
+
+def voice_rows() -> List[List[str]]:
+    voices = sorted(load_voice_db().get("voices", []), key=lambda x: x.get("created_at", ""), reverse=True)
+    return [
+        [
+            v.get("name", ""),
+            v.get("source", ""),
+            v.get("language", ""),
+            "yes" if v.get("ref_text") else "no",
+            v.get("created_at", ""),
+        ]
+        for v in voices
+    ]
+
+
+def find_voice(name: str) -> Optional[Dict]:
+    if not name or name == "None":
+        return None
+    for item in load_voice_db().get("voices", []):
+        if item.get("name") == name:
+            return item
+    return None
+
+
+def save_voice_profile(name: str, language: str, ref_text: str, source: str, audio_data) -> str:
+    parsed = audio_to_tuple(audio_data)
+    if parsed is None:
+        return "Error: audio is required to save voice profile."
+
+    wav, sr = parsed
+    if not name or not name.strip():
+        return "Error: voice name is required."
+
+    ensure_voice_library()
+    db = load_voice_db()
+
+    voice_id = f"{slugify(name)}-{uuid.uuid4().hex[:8]}"
+    audio_rel = Path("audio") / f"{voice_id}.wav"
+    audio_abs = VOICE_LIB_DIR / audio_rel
+    sf.write(audio_abs.as_posix(), wav, sr)
+
+    db["voices"] = [v for v in db.get("voices", []) if v.get("name") != name.strip()]
+    db["voices"].append(
+        {
+            "id": voice_id,
+            "name": name.strip(),
+            "language": language or "Auto",
+            "ref_text": (ref_text or "").strip(),
+            "source": source,
+            "audio_path": audio_rel.as_posix(),
+            "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+    )
+    save_voice_db(db)
+    return f"Saved voice profile: {name.strip()}"
+
+
+def delete_voice(name: str):
+    if not name or name == "None":
+        return "Select a voice to delete.", voice_rows(), None
+
+    db = load_voice_db()
+    voices = db.get("voices", [])
+    target = None
+    kept = []
+    for v in voices:
+        if v.get("name") == name:
+            target = v
+        else:
+            kept.append(v)
+
+    if target is None:
+        return "Voice not found.", voice_rows(), None
+
+    audio_path = VOICE_LIB_DIR / Path(target.get("audio_path", ""))
+    if audio_path.exists():
+        try:
+            audio_path.unlink()
+        except Exception:
+            pass
+
+    db["voices"] = kept
+    save_voice_db(db)
+    return f"Deleted voice: {name}", voice_rows(), None
+
+
+def preview_saved_voice(name: str):
+    v = find_voice(name)
+    if v is None:
+        return None, ""
+    path = VOICE_LIB_DIR / Path(v.get("audio_path", ""))
+    if not path.exists():
+        return None, ""
+    wav, sr = sf.read(path.as_posix(), dtype="float32", always_2d=False)
+    if wav.ndim > 1:
+        wav = np.mean(wav, axis=-1)
+    return (int(sr), normalize_audio(wav)), v.get("ref_text", "")
+
+
+def resolve_reference(selected_voice_name: str, uploaded_audio, uploaded_ref_text: str, xvector_only: bool):
+    ref_audio, _, ref_text, note = resolve_reference_details(
+        selected_voice_name=selected_voice_name,
+        uploaded_audio=uploaded_audio,
+        uploaded_ref_text=uploaded_ref_text,
+        xvector_only=xvector_only,
+    )
+    return ref_audio, ref_text, note
+
+
+def resolve_reference_details(selected_voice_name: str, uploaded_audio, uploaded_ref_text: str, xvector_only: bool):
+    uploaded = audio_to_tuple(uploaded_audio)
+    if uploaded is not None:
+        ref_text = (uploaded_ref_text or "").strip()
+        if (not xvector_only) and not ref_text:
+            return None, None, None, "Error: transcript is required when x-vector-only is disabled."
+        return uploaded, None, ref_text if ref_text else None, "Using uploaded reference audio."
+
+    v = find_voice(selected_voice_name)
+    if v is None:
+        return None, None, None, "Error: provide reference audio or select a saved voice."
+
+    p = VOICE_LIB_DIR / Path(v.get("audio_path", ""))
+    if not p.exists():
+        return None, None, None, f"Error: saved audio file missing for voice '{selected_voice_name}'."
+
+    wav, sr = sf.read(p.as_posix(), dtype="float32", always_2d=False)
+    if wav.ndim > 1:
+        wav = np.mean(wav, axis=-1)
+    ref_audio = (normalize_audio(wav), int(sr))
+
+    ref_text = (v.get("ref_text") or "").strip()
+    if (not xvector_only) and not ref_text:
+        return None, None, None, f"Error: saved voice '{selected_voice_name}' has no transcript. Enable x-vector-only or provide transcript."
+
+    return ref_audio, p.as_posix(), ref_text if ref_text else None, f"Using saved voice: {selected_voice_name}"

source/qwen_app/voice_library_vi.py

@@ -0,0 +1,220 @@
+# qwen_app/voice_library_vi.py
+"""
+Vietnamese Voice Library — Hoàn toàn độc lập với Qwen Voice Library
+====================================================================
+Lưu trữ voice profiles tiếng Việt (ref audio + transcript) dùng cho F5-TTS.
+Data folder: D:\Qwen3-TTS\Qwen3-TTS\voice_library_vi\
+  ├── index.json          — {name: {ref_audio, ref_text, created}}
+  └── <name>.wav          — ref audio file
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import time
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+# ─── Constants ────────────────────────────────────────────────────────────────
+_VI_LIB_DIR = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "voice_library_vi"
+)
+_INDEX_FILE = os.path.join(_VI_LIB_DIR, "index.json")
+
+NONE_CHOICE = "None"
+
+
+# ─── Internal helpers ─────────────────────────────────────────────────────────
+
+def _ensure_dir() -> None:
+    os.makedirs(_VI_LIB_DIR, exist_ok=True)
+
+
+def _load_index() -> dict:
+    _ensure_dir()
+    if not os.path.exists(_INDEX_FILE):
+        return {}
+    try:
+        with open(_INDEX_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _save_index(index: dict) -> None:
+    _ensure_dir()
+    with open(_INDEX_FILE, "w", encoding="utf-8") as f:
+        json.dump(index, f, ensure_ascii=False, indent=2)
+
+
+# ─── Public API ───────────────────────────────────────────────────────────────
+
+def ensure_vi_voice_library() -> None:
+    """Create voice library directory if not exists."""
+    _ensure_dir()
+
+
+def vi_voice_choices() -> List[str]:
+    """Return [NONE_CHOICE, name1, name2, ...] for Gradio Dropdown."""
+    idx = _load_index()
+    return [NONE_CHOICE] + sorted(idx.keys())
+
+
+def vi_voice_rows() -> List[List[str]]:
+    """Return rows for Gradio Dataframe: [Name, Has Transcript, Created]."""
+    idx = _load_index()
+    rows = []
+    for name, info in sorted(idx.items()):
+        has_text = "✅" if info.get("ref_text") else "❌"
+        created  = info.get("created", "")[:19].replace("T", " ")
+        rows.append([name, has_text, created])
+    return rows if rows else [["—", "—", "—"]]
+
+
+def save_vi_voice(
+    voice_name: str,
+    ref_audio,       # numpy array from gr.Audio(type="numpy") OR file path str
+    ref_text: str,
+    sample_rate: int = 22050,
+) -> str:
+    """
+    Save a Vietnamese voice profile.
+    ref_audio can be:
+      - tuple (sr, np.ndarray) from Gradio Audio widget
+      - str   file path
+      - np.ndarray
+    Returns status message.
+    """
+    name = (voice_name or "").strip()
+    if not name:
+        return "❌ Lỗi: Tên voice không được để trống."
+
+    # Validate ref_text
+    ref_text_clean = (ref_text or "").strip()
+    if not ref_text_clean:
+        return "❌ Lỗi: Transcript là bắt buộc để clone giọng chính xác."
+
+    _ensure_dir()
+
+    try:
+        import soundfile as sf
+
+        out_path = os.path.join(_VI_LIB_DIR, f"{name}.wav")
+
+        if isinstance(ref_audio, str):
+            # File path — copy directly
+            if not os.path.exists(ref_audio):
+                return f"❌ Lỗi: Không tìm thấy file audio: {ref_audio}"
+            shutil.copy2(ref_audio, out_path)
+
+        elif isinstance(ref_audio, (tuple, list)) and len(ref_audio) == 2:
+            # Gradio (sr, ndarray)
+            sr, arr = ref_audio
+            if arr is None or len(arr) == 0:
+                return "❌ Lỗi: Audio rỗng, vui lòng upload lại."
+            arr = arr.astype(np.float32)
+            if arr.ndim == 2:          # stereo → mono
+                arr = arr.mean(axis=1)
+            # Normalize to [-1, 1]
+            peak = np.abs(arr).max()
+            if peak > 1e-6:
+                arr = arr / peak * 0.95
+            sf.write(out_path, arr, int(sr))
+
+        elif isinstance(ref_audio, np.ndarray):
+            arr = ref_audio.astype(np.float32)
+            if arr.ndim == 2:
+                arr = arr.mean(axis=1)
+            sf.write(out_path, arr, sample_rate)
+
+        else:
+            return "❌ Lỗi: Định dạng audio không hỗ trợ."
+
+        # Update index
+        idx = _load_index()
+        idx[name] = {
+            "ref_audio": out_path,
+            "ref_text":  ref_text_clean,
+            "created":   time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }
+        _save_index(idx)
+        return f"✅ Đã lưu voice '{name}' vào Vietnamese Voice Library."
+
+    except Exception as e:
+        return f"❌ Lỗi khi lưu voice: {e}"
+
+
+def delete_vi_voice(voice_name: str) -> str:
+    """Delete a voice profile and its audio file. Returns status message."""
+    name = (voice_name or "").strip()
+    if not name or name == NONE_CHOICE:
+        return "❌ Chọn voice cần xóa trước."
+
+    idx = _load_index()
+    if name not in idx:
+        return f"❌ Không tìm thấy voice '{name}'."
+
+    # Remove audio file
+    audio_path = idx[name].get("ref_audio", "")
+    if audio_path and os.path.exists(audio_path):
+        try:
+            os.remove(audio_path)
+        except Exception:
+            pass
+
+    del idx[name]
+    _save_index(idx)
+    return f"✅ Đã xóa voice '{name}'."
+
+
+def preview_vi_voice(voice_name: str) -> Tuple[Optional[tuple], str]:
+    """
+    Load ref audio for preview.
+    Returns (gradio_audio_tuple, ref_text) or (None, "").
+    """
+    if not voice_name or voice_name == NONE_CHOICE:
+        return None, ""
+
+    idx = _load_index()
+    if voice_name not in idx:
+        return None, ""
+
+    info = idx[voice_name]
+    audio_path = info.get("ref_audio", "")
+    ref_text   = info.get("ref_text", "")
+
+    if not audio_path or not os.path.exists(audio_path):
+        return None, ref_text
+
+    try:
+        import soundfile as sf
+        arr, sr = sf.read(audio_path, dtype="float32")
+        return (int(sr), arr), ref_text
+    except Exception:
+        return None, ref_text
+
+
+def resolve_vi_ref(voice_name: str) -> Tuple[Optional[str], str]:
+    """
+    Resolve selected voice to (ref_audio_path, ref_text).
+    Returns (None, "") if not found.
+    """
+    if not voice_name or voice_name == NONE_CHOICE:
+        return None, ""
+
+    idx = _load_index()
+    if voice_name not in idx:
+        return None, ""
+
+    info = idx[voice_name]
+    audio_path = info.get("ref_audio", "")
+    ref_text   = info.get("ref_text", "")
+
+    if not os.path.exists(audio_path):
+        return None, ref_text
+
+    return audio_path, ref_text