update cut, guide, dub

backend/app/api/cut.py

@@ -41,9 +41,11 @@ async def upload(file: UploadFile = File(...), session: str = Form(None)):
 class PreviewReq(BaseModel):
     session: str
     file: str
-    mode: str = "smart"           # smart | highlight | scene | even
+    mode: str = "auto"            # auto | scene | smart | highlight | even
     count: int | None = None      # số khúc (even) — None để máy tự chia
-    min_len: float = 1.5
+    # PySceneDetect AdaptiveDetector (auto/scene): ngưỡng 3.0 + khúc tối thiểu 1.0s.
+    threshold: float = 3.0
+    min_len: float = 1.0
     sensitivity: float = 0.5
     top_ratio: float = 0.4
     thumbnails: int = 40
@@ -55,7 +57,7 @@ def preview(req: PreviewReq):
     src = os.path.join(session_dir(req.session), req.file)
     info = probe(src)
     segs = modes.build_segments(
-        info, req.mode, n=req.count, min_len=req.min_len,
+        info, req.mode, n=req.count, threshold=req.threshold, min_len=req.min_len,
         sensitivity=req.sensitivity, top_ratio=req.top_ratio)
     # Mỗi video có thư mục thumbnail RIÊNG (theo hash đường dẫn file) để nhiều
     # video trong cùng phiên KHÔNG ghi đè thumbnail của nhau (thumb_000.jpg...).

backend/app/api/dub.py

@@ -181,6 +181,156 @@ def _auto_save_dub(username: str, session: str, outputs: list[dict]):
                 pass
 
 
+# ---------------------------------------------- 2 PHA: prepare + synthesize ---
+
+@router.post("/prepare")
+def prepare(req: DubReq):
+    """PHA 1: tách + ASR + dịch -> TRẢ CÂU DỊCH + MỐC cho user xem/sửa (CHƯA đọc).
+
+    Kết quả mỗi video: {lines:[{i,start,end,src,text}], state, same_language, ...}.
+    Gửi `state` + `lines` (đã sửa) sang /synthesize để tạo giọng & ghép video.
+    """
+    target = req.target_lang if req.target_lang in LANGS else "vi"
+    opt = pipeline.DubOptions(
+        target_lang=target, bg_mode=req.bg_mode, do_clone=req.do_clone,
+        voice_source=req.voice_source, preset=req.preset, style=req.style,
+        engine=req.engine, multi_speaker=req.multi_speaker,
+        temperature=req.temperature, top_k=req.top_k,
+        repetition_penalty=req.repetition_penalty)
+
+    job = jobs.create("dub")
+
+    def work(h):
+        n = len(req.files)
+        outputs = []
+        for idx, rel in enumerate(req.files):
+            src = os.path.join(session_dir(req.session), rel)
+            base = os.path.splitext(os.path.basename(rel))[0]
+            it = h.add_item(os.path.basename(rel))
+            out_dir = sub_dir(req.session, "out", base)
+            try:
+                def prog(p, m, _i=idx, _it=it):
+                    h.set_progress((_i + p) / max(1, n))
+                    h.item_status(_it, "running", detail=m)
+
+                ar = pipeline.analyze(src, out_dir, opt, prog)
+
+                def rel_to(path):
+                    return os.path.relpath(path, session_dir(req.session)).replace(os.sep, "/")
+
+                def url(path):
+                    return f"/api/files/{req.session}/" + rel_to(path)
+
+                result = {
+                    "name": base,
+                    "language": ar.language,
+                    "note": ar.note,
+                    "same_language": ar.same_language,
+                    "state": rel_to(ar.state_path) if ar.state_path else "",
+                    "lines": [{"i": i, "start": l.start, "end": l.end,
+                               "src": l.src, "text": l.text}
+                              for i, l in enumerate(ar.lines)],
+                    "srt_url": url(ar.srt_out) if ar.srt_out else "",
+                    "video_url": url(ar.video_out) if ar.video_out else "",
+                }
+                outputs.append(result)
+                detail = ("giữ nguyên (cùng ngôn ngữ)" if ar.same_language
+                          else f"{len(ar.lines)} câu · {ar.language}")
+                h.item_status(it, "done", detail=detail, result=result)
+            except Exception as e:
+                h.item_status(it, "error", error=str(e))
+            h.set_progress((idx + 1) / max(1, n))
+        return {"session": req.session, "outputs": outputs}
+
+    jobs.submit(job, work)
+    return {"job_id": job.id, "session": req.session, "videos": len(req.files)}
+
+
+class SynthLineIn(BaseModel):
+    start: float
+    end: float
+    text: str
+
+
+class SynthItemIn(BaseModel):
+    state: str                         # rel path state.json (từ /prepare)
+    name: str = ""
+    lines: list[SynthLineIn]
+
+
+class SynthReq(BaseModel):
+    session: str
+    items: list[SynthItemIn]
+    # Chọn GIỌNG sau khi đã xem bản dịch
+    voice_source: str = "video"        # preset | video | upload
+    speaker_file: str = ""
+    preset: str = ""
+    style: str = "natural"
+    engine: str = "auto"
+    do_clone: bool = True
+    temperature: float | None = None
+    top_k: int | None = None
+    repetition_penalty: float | None = None
+    username: str = ""
+
+
+@router.post("/synthesize")
+def synthesize(req: SynthReq):
+    """PHA 2: nhận câu ĐÃ SỬA + chọn giọng -> TTS + neo mốc + ghép -> video."""
+    speaker_wav = ""
+    if req.voice_source == "upload" and req.speaker_file:
+        speaker_wav = os.path.join(session_dir(req.session), req.speaker_file)
+
+    opt = pipeline.DubOptions(
+        target_lang="vi",              # thật sự lấy từ state; đây chỉ là chỗ giữ
+        do_clone=req.do_clone, voice_source=req.voice_source,
+        speaker_wav=speaker_wav, preset=req.preset, style=req.style,
+        engine=req.engine, temperature=req.temperature, top_k=req.top_k,
+        repetition_penalty=req.repetition_penalty)
+
+    job = jobs.create("dub")
+    _username = req.username
+
+    def work(h):
+        n = len(req.items)
+        outputs = []
+        for idx, item in enumerate(req.items):
+            base = item.name or f"video_{idx+1}"
+            it = h.add_item(base)
+            state_abs = os.path.join(session_dir(req.session), item.state)
+            try:
+                def prog(p, m, _i=idx, _it=it):
+                    h.set_progress((_i + p) / max(1, n))
+                    h.item_status(_it, "running", detail=m)
+
+                lines = [{"start": ln.start, "end": ln.end, "text": ln.text}
+                         for ln in item.lines]
+                res = pipeline.synthesize(state_abs, lines, opt, prog)
+
+                def url(path):
+                    return f"/api/files/{req.session}/" + os.path.relpath(
+                        path, session_dir(req.session)).replace(os.sep, "/")
+
+                result = {
+                    "name": base, "language": res.language, "n_lines": res.n_lines,
+                    "video_url": url(res.video_out), "audio_url": url(res.audio_out),
+                    "srt_url": url(res.srt_out), "note": res.note,
+                }
+                outputs.append(result)
+                h.item_status(it, "done",
+                              detail=f"{res.n_lines} câu · {res.language}", result=result)
+            except Exception as e:
+                h.item_status(it, "error", error=str(e))
+            h.set_progress((idx + 1) / max(1, n))
+
+        if _username:
+            _auto_save_dub(_username, req.session, outputs)
+        return {"session": req.session, "outputs": outputs}
+
+    jobs.submit(job, work)
+    return {"job_id": job.id, "session": req.session, "videos": len(req.items)}
+
+
 # ------------------------------------------------------- TTS từ text ---
 
 class TtsReq(BaseModel):

backend/app/api/shuffle.py

@@ -13,6 +13,7 @@ không còn cờ allow_reorder toàn cục.
 from __future__ import annotations
 
 import os
+from dataclasses import replace
 
 from fastapi import APIRouter, File, Form, UploadFile
 from pydantic import BaseModel
@@ -175,8 +176,11 @@ def plan(req: ShuffleReq):
             capped = True
             raw = raw[:PLAN_CAP]
             break
-    # tập biến thể SỐNG SÓT theo bộ lọc hiện tại (tương đồng/ngẫu nhiên/giới hạn)
-    kept = {tuple(s) for s in engine.generate(cfg)}
+    # tập biến thể SỐNG SÓT theo bộ lọc hiện tại (tương đồng/ngẫu nhiên/giới hạn).
+    # Dùng trần = PLAN_CAP (không phải DEFAULT_CAP nhỏ) để tick phản ánh ĐÚNG bộ
+    # lọc trên toàn bảng: không lọc gì -> tick hết; có lọc -> chỉ tick phần sống sót.
+    keep_cfg = replace(cfg, max_outputs=(req.max_outputs or PLAN_CAP))
+    kept = {tuple(s) for s in engine.generate(keep_cfg)}
     variants = []
     for i, seq in enumerate(raw):
         labels = [{"segment": clip_meta.get(c, {}).get("segment", 0) + 1,
@@ -203,33 +207,45 @@ def generate(req: ShuffleReq):
     job = jobs.create("shuffle")
 
     def work(h):
-        from concurrent.futures import ThreadPoolExecutor
+        from concurrent.futures import ThreadPoolExecutor, as_completed
         import threading
         if capped_render:
             h.log(f"Đã chọn quá {MAX_RENDER} biến thể — chỉ render {MAX_RENDER} video đầu.")
         h.log(f"Sẽ render {len(sequences)} biến thể @ {w}x{h_res}"
               + (f" + lồng {len(audio_paths)} track âm thanh" if audio_paths else ""))
         out_dir = sub_dir(req.session, "variations")
+        norm_dir = shuffle_render._norm_dir_for(out_dir)
         n = len(sequences)
         results = [None] * n
         items = [h.add_item(f"Variation_{i+1:02d}") for i in range(n)]
         done_lock = threading.Lock()
         counter = {"done": 0}
 
+        # ── Đường nhanh: chuẩn hoá TRƯỚC mỗi clip nguồn ĐÚNG 1 LẦN (song song) ──
+        # Mọi biến thể sau đó chỉ concat copy (không re-encode) nên rất nhanh.
+        uniq_clips = {c for seq in sequences for c in seq}
+        workers = min(4, max(1, (os.cpu_count() or 2) - 1))
+        if uniq_clips:
+            h.log(f"Chuẩn hoá {len(uniq_clips)} clip nguồn (1 lần/clip)…")
+            with ThreadPoolExecutor(max_workers=workers) as ex:
+                futs = {ex.submit(shuffle_render.normalize_clip,
+                                  clip_map[c], norm_dir, w, h_res): c
+                        for c in uniq_clips}
+                warmed = 0
+                for _ in as_completed(futs):
+                    warmed += 1
+                    # Chiếm ~30% thanh tiến độ cho bước chuẩn hoá.
+                    h.set_progress(0.30 * warmed / max(1, len(uniq_clips)))
+
         def render_one(i, seq):
             it = items[i]
             try:
                 paths = [clip_map[c] for c in seq]
                 name = f"Variation_{i+1:02d}.mp4"
                 out = os.path.join(out_dir, name)
-                if audio_paths:
-                    tmp = os.path.join(out_dir, f".tmp_{i+1:02d}.mp4")
-                    shuffle_render._concat_reencode(paths, tmp, w, h_res)
-                    track = audio_paths[i % len(audio_paths)]
-                    shuffle_render.attach_audio(tmp, track, out)
-                    os.remove(tmp)
-                else:
-                    shuffle_render._concat_reencode(paths, out, w, h_res)
+                track = audio_paths[i % len(audio_paths)] if audio_paths else None
+                shuffle_render.render_variation(paths, out, norm_dir, w, h_res,
+                                                audio_path=track)
                 size = os.path.getsize(out)
                 results[i] = {"name": name, "path": out, "sequence": seq, "size": size}
                 h.item_status(it, "done", detail=f"{size//1024} KB", result={
@@ -239,10 +255,10 @@ def generate(req: ShuffleReq):
                 h.item_status(it, "error", error=str(e))
             with done_lock:
                 counter["done"] += 1
-                h.set_progress(counter["done"] / max(1, n))
+                # 30% chuẩn hoá + 70% ghép biến thể.
+                h.set_progress(0.30 + 0.70 * counter["done"] / max(1, n))
 
-        # render SONG SONG (ffmpeg nặng CPU -> giới hạn số luồng để không nghẽn)
-        workers = min(4, max(1, (os.cpu_count() or 2) - 1))
+        # ghép SONG SONG (concat copy nhẹ -> có thể chạy nhiều luồng)
         with ThreadPoolExecutor(max_workers=workers) as ex:
             for i, seq in enumerate(sequences):
                 ex.submit(render_one, i, seq)

backend/app/assets/voices/vi/README.md

@@ -0,0 +1,33 @@
+# Giọng clone-preset (tiếng Việt)
+
+Thả **file mẫu giọng** vào đây để nó tự xuất hiện trong danh sách "Giọng có sẵn"
+của phần Dịch/Đổi giọng (ngôn ngữ Việt). Model VieNeu sẽ **clone** theo file này.
+
+## Đang khai báo sẵn
+
+| Tên hiện trên UI                        | id     | File cần thả (đặt đúng tên) |
+|-----------------------------------------|--------|-----------------------------|
+| Adam — nam, giọng trầm ấm       | `adam` | `adam.wav`                  |
+
+> Mục chỉ hiện khi file tương ứng đã tồn tại. Thiếu file → không hiện (tránh lỗi).
+
+## Yêu cầu file mẫu (để clone đạt chất lượng)
+
+- Định dạng: `.wav` (khuyến nghị) — 16–48 kHz, mono hoặc stereo đều được.
+- Độ dài: **10–20 giây**, chỉ 1 người nói, **sạch** (không nhạc nền, không tạp âm).
+- Nội dung nói tự nhiên, đủ ngữ điệu (một đoạn đọc bình thường là được).
+
+## Thêm giọng clone-preset mới
+
+1. Bỏ file `<tên>.wav` vào thư mục này.
+2. Khai báo trong `backend/app/services/dubber/tts.py` → `_CLONE_PRESETS["vi"]`:
+   ```python
+   "ten_id": ("Nhãn hiện trên UI", "ten_file.wav"),
+   ```
+
+## Lưu ý về giọng "Adam"
+
+"Adam" là **giọng AI của ElevenLabs** (dịch vụ thương mại) — không phải người thật
+và không có bản tải miễn phí chính thức. Hãy tự chuẩn bị `adam.wav` từ nguồn bạn
+CÓ QUYỀN sử dụng (ví dụ: bản ghi bạn tự tạo/được cấp phép). Đặt tên đúng `adam.wav`
+là chạy được ngay, không cần sửa code.

backend/app/assets/voices/vi/adam.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48a04ea3b8157817f97a34e190a60d3af9fe0539b0df5657a738d9629ec596e6
+size 864078

backend/app/config.py

@@ -53,10 +53,25 @@ class Settings:
 
     # model TTS / config
     DEMUCS_MODEL: str = field(default_factory=lambda: _env("DEMUCS_MODEL", "htdemucs"))
+    # model tách dự phòng khi model chính lỗi/thiếu (nhẹ hơn, chắc chạy)
+    DEMUCS_FALLBACK: str = field(default_factory=lambda: _env("DEMUCS_FALLBACK", "htdemucs"))
     WHISPER_MODEL: str = field(default_factory=lambda: _env("WHISPER_MODEL", "whisper-large-v3"))
     GEMINI_MODEL: str = field(default_factory=lambda: _env("GEMINI_MODEL", "gemini-2.0-flash"))
     GROQ_LLM_FALLBACK: str = field(default_factory=lambda: _env("GROQ_LLM_FALLBACK", "openai/gpt-oss-20b"))
 
+    # --- Đồng bộ mốc thời gian & chống lẫn vị trí khi tách nhạc ---
+    # Chạy ASR trên GIỌNG ĐÃ TÁCH (sạch nhạc/tạp âm) thay vì bản trộn -> mốc chuẩn hơn.
+    # MẶC ĐỊNH TẮT: bật lên = MỌI job đều chạy Demucs (rất nặng trên CPU) chỉ để ASR
+    # sạch hơn chút. Whisper large-v3 vốn nghe tốt trên nền nhạc nên tắt để nhanh;
+    # Demucs chỉ chạy khi thật sự cần giữ nền (bg_mode=demucs).
+    ASR_ON_VOCALS: bool = field(default_factory=lambda: _env("ASR_ON_VOCALS", "0") not in ("0", "false", "False", ""))
+    # Hít mốc bắt đầu/kết thúc câu về đúng chỗ có giọng thật (VAD trên giọng tách).
+    VAD_SNAP: bool = field(default_factory=lambda: _env("VAD_SNAP", "1") not in ("0", "false", "False", ""))
+    # Ép nhạc nền nhỏ lại khi có giọng dịch (sidechain duck) -> nghe rõ lời, đỡ chồng.
+    BG_SIDECHAIN: bool = field(default_factory=lambda: _env("BG_SIDECHAIN", "1") not in ("0", "false", "False", ""))
+    # Ngưỡng (dB) coi là im lặng khi dò VAD trên giọng tách.
+    VAD_SILENCE_DB: float = field(default_factory=lambda: float(_env("VAD_SILENCE_DB", "-32")))
+
     # ASR chạy LOCAL (faster-whisper) khi không có/không gọi được Groq
     LOCAL_WHISPER_MODEL: str = field(default_factory=lambda: _env("LOCAL_WHISPER_MODEL", "base"))
 

backend/app/services/cutter/modes.py

@@ -1,11 +1,18 @@
-"""4 chế độ cắt -> trả về danh sách KHÚC (start_frame, end_frame) frame-accurate.
+"""Các chế độ cắt -> trả về danh sách KHÚC (start_frame, end_frame) frame-accurate.
 
 - even      : chia N khúc bằng nhau.
-- scene     : nhận diện CHUYỂN CẢNH (opencv hist-diff), khúc quá ngắn gộp lại.
+- scene     : nhận diện CHUYỂN CẢNH bằng PySceneDetect (AdaptiveDetector); fallback
+              opencv hist-diff khi thiếu thư viện.
 - highlight : tìm đoạn CHUYỂN ĐỘNG MẠNH (motion energy), tách thành khúc.
 - smart     : dùng model CLIP cắt theo ngữ nghĩa (cần torch + open_clip; có fallback).
+- auto      : cắt tự động theo nội dung — ưu tiên PySceneDetect, fallback thị-giác.
 
 Boundary = (start_frame, end_frame) — end_frame exclusive theo frame index.
+
+Cấu hình PySceneDetect mặc định cho tool Cut: dùng AdaptiveDetector với
+adaptive_threshold = 3.0, độ dài khúc tối thiểu (min_len) = 1.0 giây. Ngưỡng THẤP
+-> nhạy, bắt cả chuyển cảnh nhẹ; min_len chặn khúc vụn. Đổi qua tham số
+``threshold`` / ``min_len`` khi cần.
 """
 
 from __future__ import annotations
@@ -16,6 +23,10 @@ import numpy as np
 
 from .probe import VideoInfo
 
+# Cấu hình PySceneDetect mặc định (theo yêu cầu tool Cut).
+SCENE_THRESHOLD = 3.0        # AdaptiveDetector.adaptive_threshold: thấp = nhạy hơn
+SCENE_MIN_LEN = 1.0          # giây: khúc ngắn hơn mức này sẽ bị gộp
+
 
 @dataclass
 class Segment:
@@ -128,6 +139,42 @@ def scene_cut(info: VideoInfo, min_len: float = 1.5, sensitivity: float = 0.5) -
     return _merge_short(segs, info.fps, min_len)
 
 
+def pyscene_cut(info: VideoInfo, threshold: float = SCENE_THRESHOLD,
+                min_len: float = SCENE_MIN_LEN) -> list[Segment]:
+    """Cắt chuyển cảnh bằng PySceneDetect (AdaptiveDetector) — nhanh & bám nội dung.
+
+    AdaptiveDetector so mỗi frame với BASELINE cục bộ (cửa sổ lân cận) nên tự thích
+    ứng theo độ "động" từng đoạn — ít cắt nhầm ở video quay tay / rung nhẹ, mà vẫn
+    bắt được chuyển cảnh; thực nghiệm cho kết quả vừa nhanh vừa tốt hơn ContentDetector.
+
+    - threshold: ``adaptive_threshold`` (mặc định 3.0) = bội số so với baseline cục
+                 bộ. THẤP -> nhạy hơn (cắt nhiều hơn).
+    - min_len  : độ dài khúc tối thiểu (giây, mặc định 1.0) -> quy ra frame theo fps
+                 thật, khúc ngắn hơn tự bị gộp.
+
+    Trả về các khúc liền mạch phủ trọn [0, nb_frames]. Raise ImportError nếu chưa
+    cài `scenedetect` (caller tự fallback). Không có điểm cắt -> 1 khúc cả video.
+    """
+    from scenedetect import AdaptiveDetector, detect  # ImportError -> caller fallback
+
+    fps = info.fps or 30.0
+    min_frames = max(1, int(round(min_len * fps)))
+    scenes = detect(info.path,
+                    AdaptiveDetector(adaptive_threshold=float(threshold),
+                                     min_scene_len=min_frames))
+    if not scenes:
+        return [Segment(0, 0, info.nb_frames, info.fps)]
+
+    def _fnum(tc) -> int:
+        # PySceneDetect >=0.6: FrameTimecode.frame_num; bản cũ: get_frames().
+        return int(getattr(tc, "frame_num", None) if getattr(tc, "frame_num", None) is not None
+                   else tc.get_frames())
+
+    # Điểm cắt trong = biên phải mỗi khúc trừ khúc cuối (khúc cuối chạm hết video).
+    cut_frames = [_fnum(end) for _, end in scenes[:-1]]
+    return _segments_from_cuts(cut_frames, info.nb_frames, info.fps)
+
+
 def highlight_cut(info: VideoInfo, top_ratio: float = 0.4,
                   min_len: float = 2.0, pad: float = 0.3) -> list[Segment]:
     """Giữ các đoạn CHUYỂN ĐỘNG MẠNH (cao trào) thành khúc riêng."""
@@ -253,15 +300,28 @@ def _merge_short(segs: list[Segment], fps: float, min_len: float) -> list[Segmen
 
 
 def build_segments(info: VideoInfo, mode: str, **kw) -> list[Segment]:
+    threshold = kw.get("threshold", SCENE_THRESHOLD)
+    min_len = kw.get("min_len", SCENE_MIN_LEN)
     if mode == "auto":
-        # Cắt tự động theo nội dung (thị giác 3 tầng). Import lazy tránh vòng lặp import.
+        # Cắt tự động: ƯU TIÊN PySceneDetect (ngưỡng 6.0, min_len 1.0). Thiếu thư
+        # viện / lỗi -> fallback pipeline thị-giác 3 tầng. Import lazy tránh vòng lặp.
+        try:
+            segs = pyscene_cut(info, threshold, min_len)
+            if segs:
+                return segs
+        except Exception:
+            pass
         from .autocut import auto_cut
         return auto_cut(info)
     if mode == "even":
         n = kw.get("n") or auto_segment_count(info)
         return even_cut(info, int(n))
     if mode == "scene":
-        return scene_cut(info, kw.get("min_len", 1.5), kw.get("sensitivity", 0.5))
+        # Scene = PySceneDetect; fallback opencv hist-diff nếu thiếu scenedetect.
+        try:
+            return pyscene_cut(info, threshold, min_len)
+        except Exception:
+            return scene_cut(info, min_len, kw.get("sensitivity", 0.5))
     if mode == "highlight":
         return highlight_cut(info, kw.get("top_ratio", 0.4), kw.get("min_len", 2.0))
     if mode == "smart":

backend/app/services/downloader/ydl.py

@@ -190,22 +190,31 @@ def _build_opts(out_dir: str, cookies_file: str | None = None,
         opts["proxy"] = proxy.strip()
     if source == "youtube":
         # Server cloud (HF Spaces...) hay bị YouTube chặn IP datacenter với lỗi
-        # "Sign in to confirm you're not a bot". Đổi player_client sang các client
-        # ít bị soi hơn (android/tv/web_safari) để né mà KHÔNG cần cookies.
-        # Nếu vẫn bị chặn -> đặt biến môi trường YOUTUBE_COOKIES_FILE trỏ tới file
-        # cookies.txt (Netscape format) export từ trình duyệt đã đăng nhập.
-        opts["extractor_args"] = {
-            "youtube": {"player_client": ["android", "tv", "web_safari", "web"]}
-        }
+        # "Sign in to confirm you're not a bot".
+        # Xác định file cookies TRƯỚC (secret HF / file / trình duyệt local),
+        # vì việc CHỌN player_client phụ thuộc có cookies hay không.
         if not cookies_file:
             cookies_file = _youtube_cookiefile()
-        # Chưa có file cookies -> thử đọc THẲNG từ trình duyệt trên MÁY (chỉ chạy
-        # được ở local, HF không có trình duyệt). Đặt YOUTUBE_COOKIES_BROWSER=
-        #   edge | chrome | firefox | brave | opera | vivaldi
         if not cookies_file:
+            # Đọc thẳng cookies từ trình duyệt trên MÁY (chỉ chạy được ở local).
+            # YOUTUBE_COOKIES_BROWSER = edge | chrome | firefox | brave | opera | vivaldi
             browser = os.environ.get("YOUTUBE_COOKIES_BROWSER", "").strip().lower()
             if browser:
                 opts["cookiesfrombrowser"] = (browser, None, None, None)
+
+        have_cookies = bool(
+            (cookies_file and os.path.exists(cookies_file))
+            or opts.get("cookiesfrombrowser")
+        )
+        # QUAN TRỌNG: client 'android' KHÔNG dùng cookies (cần PO token), nên nếu
+        # có cookies mà để android trước -> cookies bị bỏ qua -> vẫn dính bot-check.
+        #   Có cookies  -> ưu tiên web/tv (dùng được cookies).
+        #   Không cookies -> thử android/tv để né mà không cần đăng nhập.
+        if have_cookies:
+            clients = ["web_safari", "web", "mweb", "tv"]
+        else:
+            clients = ["android", "tv", "web_safari", "web"]
+        opts["extractor_args"] = {"youtube": {"player_client": clients}}
     if cookies_file and os.path.exists(cookies_file):
         opts["cookiefile"] = cookies_file
     return opts

backend/app/services/dubber/align.py

@@ -0,0 +1,111 @@
+"""Căn mốc thời gian câu thoại về ĐÚNG chỗ có giọng thật (VAD nhẹ).
+
+Vì sao cần: Whisper hay báo mốc bắt đầu SỚM hơn thực tế khi có tạp âm/nhạc
+dẫn trước (vd tiếng xịt nước 1-3s rồi mới nói 3-5s -> câu bị đẩy lên 1-3s).
+Chạy trên GIỌNG ĐÃ TÁCH (đã bỏ nhạc/tạp âm), dùng ffmpeg `silencedetect` để tìm
+các khoảng CÓ TIẾNG rồi "hít" start/end mỗi câu về biên giọng gần nhất.
+
+Không cần model nặng -> chạy tốt trên server (chỉ dùng ffmpeg).
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+
+FFMPEG = shutil.which("ffmpeg") or "ffmpeg"
+
+_SIL_START = re.compile(r"silence_start:\s*([0-9.]+)")
+_SIL_END = re.compile(r"silence_end:\s*([0-9.]+)")
+
+
+def speech_intervals(voice_wav: str, silence_db: float = -32.0,
+                     min_silence: float = 0.18) -> list[tuple[float, float]]:
+    """Trả danh sách [(start, end)] các khoảng CÓ GIỌNG (nghịch đảo silencedetect)."""
+    proc = subprocess.run(
+        [FFMPEG, "-hide_banner", "-nostats", "-i", voice_wav,
+         "-af", f"silencedetect=noise={silence_db}dB:d={min_silence}",
+         "-f", "null", "-"],
+        capture_output=True, text=True)
+    log = (proc.stderr or "") + (proc.stdout or "")
+
+    # Ghép các mốc silence_start / silence_end theo thứ tự xuất hiện.
+    sil: list[tuple[float, float]] = []
+    cur_start: float | None = None
+    for line in log.splitlines():
+        ms = _SIL_START.search(line)
+        me = _SIL_END.search(line)
+        if ms:
+            cur_start = float(ms.group(1))
+        if me:
+            end = float(me.group(1))
+            start = cur_start if cur_start is not None else 0.0
+            sil.append((max(0.0, start), end))
+            cur_start = None
+
+    dur = _duration(voice_wav)
+    if not sil:
+        return [(0.0, dur)] if dur > 0 else []
+
+    # Nghịch đảo: khoảng CÓ giọng = phần giữa các khoảng im lặng.
+    speech: list[tuple[float, float]] = []
+    prev_end = 0.0
+    for s, e in sil:
+        if s - prev_end > 0.05:
+            speech.append((prev_end, s))
+        prev_end = max(prev_end, e)
+    if dur - prev_end > 0.05:
+        speech.append((prev_end, dur))
+    return speech
+
+
+def _duration(wav: str) -> float:
+    out = subprocess.run(
+        ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+         "-of", "csv=p=0", wav], capture_output=True, text=True).stdout.strip()
+    try:
+        return float(out)
+    except ValueError:
+        return 0.0
+
+
+def snap_segments(segments, voice_wav: str, silence_db: float = -32.0,
+                  tol: float = 1.5):
+    """Hít mốc start/end mỗi câu về biên giọng thật gần nhất.
+
+    - start: dời tới ONSET giọng đầu tiên trong cửa sổ [start-tol, end] (sửa lỗi đẩy sớm).
+    - end:   dời tới OFFSET giọng cuối cùng trong cửa sổ [start, end+tol].
+    - Chỉ dời khi có bằng chứng giọng; giữ nguyên nếu không tìm thấy (an toàn).
+    - Không để câu đè lên start câu kế (đã kẹp ở pipeline; ở đây chỉ chỉnh trong bản thân câu).
+    """
+    try:
+        intervals = speech_intervals(voice_wav, silence_db)
+    except Exception:
+        return segments
+    if not intervals:
+        return segments
+
+    for seg in segments:
+        s0, e0 = seg.start, seg.end
+        # ONSET: khoảng giọng đầu tiên KẾT THÚC sau (s0 - tol) và bắt đầu trước e0.
+        onset = None
+        for a, b in intervals:
+            if b >= s0 - tol and a <= e0:
+                onset = a
+                break
+        # OFFSET: khoảng giọng cuối cùng BẮT ĐẦU trước (e0 + tol) và kết thúc sau s0.
+        offset = None
+        for a, b in intervals:
+            if a <= e0 + tol and b >= s0:
+                offset = b
+        if onset is not None:
+            # chỉ dời start trong phạm vi tol; không vượt quá end
+            new_start = min(max(onset, s0 - tol), e0 - 0.2)
+            if abs(new_start - s0) <= tol:
+                seg.start = max(0.0, new_start)
+        if offset is not None:
+            new_end = max(min(offset, e0 + tol), seg.start + 0.2)
+            if abs(new_end - e0) <= tol:
+                seg.end = new_end
+    return segments

backend/app/services/dubber/audio.py

@@ -1,7 +1,9 @@
 """Bước AUDIO của pipeline lồng tiếng.
 
 - Tách audio ra 2 bản: 16kHz mono (cho ASR) và 44.1kHz stereo (giữ chất gốc làm nền).
-- Xử lý nền nhạc 3 chế độ: none | duck | demucs.
+- TÁCH GIỌNG/NHẠC bằng Demucs (có fallback model) NGAY TỪ ĐẦU để:
+    * ASR chạy trên GIỌNG SẠCH (không lẫn nhạc/tạp âm) -> mốc thời gian chuẩn.
+    * "Giữ nền" dùng đúng bản no_vocals (đã bỏ giọng gốc), không còn giọng gốc chồng lệch.
 - Cắt mẫu clone giọng (~10-20s) từ lúc bắt đầu nói (ưu tiên bản giọng tách sạch).
 """
 
@@ -10,18 +12,22 @@ from __future__ import annotations
 import os
 import shutil
 import subprocess
+import sys
 from dataclasses import dataclass
 
+from ...config import settings
+
 FFMPEG = shutil.which("ffmpeg") or "ffmpeg"
 
 
 @dataclass
 class AudioBundle:
-    asr_wav: str            # 16k mono cho Whisper
+    asr_wav: str            # 16k mono cho Whisper (ưu tiên giọng đã tách)
     full_wav: str           # 44.1k stereo gốc
     bg_wav: str             # nền nhạc theo chế độ (none -> im lặng)
     voice_wav: str          # giọng đã tách (demucs) hoặc bản gốc
     mode: str
+    voice_is_clean: bool = False   # True khi voice_wav là giọng đã tách sạch (dùng cho VAD)
 
 
 def _run(cmd: list[str]):
@@ -32,18 +38,26 @@ def extract_tracks(video: str, out_dir: str) -> tuple[str, str]:
     os.makedirs(out_dir, exist_ok=True)
     asr_wav = os.path.join(out_dir, "asr_16k_mono.wav")
     full_wav = os.path.join(out_dir, "full_44k_stereo.wav")
+    # 1 LẦN decode video -> 2 output (ASR 16k mono + nền 44.1k stereo) để KHÔNG
+    # phải decode toàn bộ video hai lượt (tiết kiệm rõ với video dài).
     _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", video,
-          "-vn", "-ac", "1", "-ar", "16000", asr_wav])
-    _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", video,
+          "-vn", "-ac", "1", "-ar", "16000", asr_wav,
           "-vn", "-ac", "2", "-ar", "44100", full_wav])
     return asr_wav, full_wav
 
 
+def to_16k_mono(src: str, out: str) -> str:
+    """Chuyển 1 wav bất kỳ về 16k mono cho Whisper."""
+    _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", src,
+          "-vn", "-ac", "1", "-ar", "16000", out])
+    return out
+
+
 def _silence_like(ref_wav: str, out: str):
     """Tạo track im lặng dài bằng ref (cho chế độ none)."""
     dur = _duration(ref_wav)
     _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
-          "-f", "lavfi", "-i", f"anullsrc=r=44100:cl=stereo",
+          "-f", "lavfi", "-i", "anullsrc=r=44100:cl=stereo",
           "-t", f"{dur:.3f}", out])
 
 
@@ -57,44 +71,100 @@ def _duration(wav: str) -> float:
         return 0.0
 
 
-def _demucs_separate(full_wav: str, out_dir: str, model: str) -> tuple[str, str]:
-    """Tách nhạc & giọng bằng Demucs. Trả (bg_wav, voice_wav).
+def _demucs_api(full_wav: str, out_dir: str, model: str) -> tuple[str, str]:
+    """Tách bằng API demucs, ĐỌC/GHI wav bằng soundfile.
 
-    Cần `pip install demucs`. Nếu thiếu -> raise để pipeline fallback duck.
+    Vì sao không dùng CLI: torchaudio 2.8+ đẩy việc lưu wav sang `torchcodec`;
+    thiếu torchcodec -> CLI `-m demucs` chết ở bước ghi file dù model chạy xong.
+    Đọc/ghi bằng soundfile (libsndfile) né hẳn torchaudio.save -> chạy ổn mọi nơi.
     """
+    import numpy as np  # noqa: F401
+    import soundfile as sf
+    import torch
+    from demucs.apply import apply_model
+    from demucs.pretrained import get_model
+
+    m = get_model(model)          # tải weight lần đầu nếu chưa có (cache demucs)
+    m.eval()
+    sr_model = m.samplerate
+    ch_model = m.audio_channels
+
+    data, sr = sf.read(full_wav, dtype="float32", always_2d=True)   # [n, ch]
+    wav = torch.from_numpy(data.T)                                  # [ch, n]
+    if wav.shape[0] == 1 and ch_model == 2:
+        wav = wav.repeat(2, 1)
+    elif wav.shape[0] > ch_model:
+        wav = wav[:ch_model]
+    if sr != sr_model:
+        import torchaudio  # chỉ dùng DSP resample, KHÔNG đụng save/torchcodec
+        wav = torchaudio.functional.resample(wav, sr, sr_model)
+
+    ref = wav.mean(0)
+    w = (wav - ref.mean()) / (ref.std() + 1e-8)
+    with torch.no_grad():
+        srcs = apply_model(m, w[None], device="cpu", split=True,
+                           overlap=0.25, progress=False)[0]
+    srcs = srcs * ref.std() + ref.mean()
+
+    names = list(m.sources)
+    vi = names.index("vocals")
+    vocals_t = srcs[vi]
+    no_vocals_t = sum(srcs[i] for i in range(len(names)) if i != vi)
+
+    stem_root = os.path.join(out_dir, "demucs", model,
+                             os.path.splitext(os.path.basename(full_wav))[0])
+    os.makedirs(stem_root, exist_ok=True)
+    vocals = os.path.join(stem_root, "vocals.wav")
+    no_vocals = os.path.join(stem_root, "no_vocals.wav")
+    sf.write(vocals, vocals_t.T.cpu().numpy(), sr_model)
+    sf.write(no_vocals, no_vocals_t.T.cpu().numpy(), sr_model)
+    return no_vocals, vocals
+
+
+def _demucs_cli(full_wav: str, out_dir: str, model: str) -> tuple[str, str]:
+    """Tách bằng CLI demucs (dự phòng — chỉ chạy được nếu torchaudio ghi wav được)."""
     import demucs.separate  # type: ignore  # noqa: F401
 
     sep_dir = os.path.join(out_dir, "demucs")
     os.makedirs(sep_dir, exist_ok=True)
     subprocess.run(
-        ["python", "-m", "demucs", "-n", model, "--two-stems", "vocals",
+        [sys.executable, "-m", "demucs", "-n", model, "--two-stems", "vocals",
          "-o", sep_dir, full_wav], check=True, capture_output=True)
     stem_root = os.path.join(sep_dir, model,
                              os.path.splitext(os.path.basename(full_wav))[0])
     vocals = os.path.join(stem_root, "vocals.wav")
     no_vocals = os.path.join(stem_root, "no_vocals.wav")
+    if not (os.path.exists(vocals) and os.path.exists(no_vocals)):
+        raise RuntimeError("Demucs không xuất đủ stem vocals/no_vocals")
     return no_vocals, vocals
 
 
-def prepare_background(full_wav: str, out_dir: str, mode: str,
-                       demucs_model: str = "htdemucs") -> tuple[str, str]:
-    """Trả (bg_wav, voice_wav) theo chế độ nền."""
-    bg = os.path.join(out_dir, "bg.wav")
-    if mode == "none":
-        _silence_like(full_wav, bg)
-        return bg, full_wav
-    if mode == "duck":
-        # giảm tiếng gốc ~ -12dB làm nền mờ
-        _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
-              "-i", full_wav, "-af", "volume=-12dB", bg])
-        return bg, full_wav
-    if mode == "demucs":
+def _demucs_once(full_wav: str, out_dir: str, model: str) -> tuple[str, str]:
+    """Tách 1 lần: ưu tiên API (né torchcodec), lỗi thì thử CLI. Raise nếu cả hai lỗi."""
+    try:
+        return _demucs_api(full_wav, out_dir, model)
+    except Exception as e_api:
+        print(f"[audio] demucs API lỗi ({e_api}); thử CLI…", file=sys.stderr)
+        return _demucs_cli(full_wav, out_dir, model)
+
+
+def separate(full_wav: str, out_dir: str, model: str) -> tuple[str, str]:
+    """Tách giọng/nhạc với FALLBACK model. Trả (no_vocals, vocals) hoặc raise nếu hết cách."""
+    tried = []
+    for m in [model, settings.DEMUCS_FALLBACK, "htdemucs"]:
+        if not m or m in tried:
+            continue
+        tried.append(m)
         try:
-            return _demucs_separate(full_wav, out_dir, demucs_model)
-        except Exception:
-            # fallback an toàn -> duck
-            return prepare_background(full_wav, out_dir, "duck")
-    raise ValueError(f"bg mode không hợp lệ: {mode}")
+            return _demucs_once(full_wav, out_dir, m)
+        except Exception as e:  # noqa: PERF203
+            print(f"[audio] tách bằng '{m}' lỗi: {e}", file=sys.stderr)
+    raise RuntimeError(f"Tách giọng thất bại với các model: {tried}")
+
+
+def _duck(full_wav: str, bg: str, db: float = -12.0):
+    _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
+          "-i", full_wav, "-af", f"volume={db}dB", bg])
 
 
 def cut_clone_sample(voice_wav: str, out_dir: str, start: float = 0.0,
@@ -109,6 +179,51 @@ def cut_clone_sample(voice_wav: str, out_dir: str, start: float = 0.0,
 
 def build_audio(video: str, out_dir: str, bg_mode: str,
                 demucs_model: str = "htdemucs") -> AudioBundle:
-    asr_wav, full_wav = extract_tracks(video, out_dir)
-    bg_wav, voice_wav = prepare_background(full_wav, out_dir, bg_mode, demucs_model)
-    return AudioBundle(asr_wav, full_wav, bg_wav, voice_wav, bg_mode)
+    """Chuẩn bị audio cho pipeline.
+
+    Chiến lược mới:
+      1) Tách giọng/nhạc (Demucs) khi cần -> để ASR chạy trên GIỌNG SẠCH.
+      2) Nền theo chế độ:  none -> im lặng;  demucs -> no_vocals (đã bỏ giọng gốc).
+      3) Nếu tách lỗi -> lùi an toàn: ASR trên bản trộn, nền = duck (-12dB).
+    """
+    asr_full, full_wav = extract_tracks(video, out_dir)
+
+    # Có cần tách không? Cần khi giữ nền (demucs) HOẶC muốn ASR trên giọng sạch.
+    want_sep = (bg_mode == "demucs") or settings.ASR_ON_VOCALS
+    no_vocals = vocals = None
+    if want_sep:
+        try:
+            no_vocals, vocals = separate(full_wav, out_dir, demucs_model)
+        except Exception as e:
+            print(f"[audio] bỏ tách, dùng bản trộn: {e}", file=sys.stderr)
+            no_vocals = vocals = None
+
+    # --- chọn nguồn cho ASR + mẫu clone ---
+    voice_is_clean = False
+    if vocals and settings.ASR_ON_VOCALS:
+        asr_wav = to_16k_mono(vocals, os.path.join(out_dir, "asr_16k_vocals.wav"))
+        voice_wav = vocals
+        voice_is_clean = True
+    else:
+        asr_wav = asr_full
+        voice_wav = vocals or full_wav
+        voice_is_clean = bool(vocals)
+
+    # --- chọn NỀN theo chế độ ---
+    bg = os.path.join(out_dir, "bg.wav")
+    if bg_mode == "none":
+        _silence_like(full_wav, bg)                     # bỏ hẳn tiếng gốc
+    elif bg_mode == "demucs":
+        if no_vocals:
+            shutil.copy(no_vocals, bg)                  # giữ nhạc/tiếng động, bỏ giọng gốc
+        else:
+            # Tách LỖI: KHÔNG lùi về duck — duck giữ NGUYÊN giọng gốc (-12dB) nên
+            # nghe như "chưa dịch". Thà bỏ nền, dùng im lặng để bản dub SẠCH.
+            _silence_like(full_wav, bg)
+    elif bg_mode == "duck":
+        _duck(full_wav, bg)
+    else:
+        raise ValueError(f"bg mode không hợp lệ: {bg_mode}")
+
+    return AudioBundle(asr_wav=asr_wav, full_wav=full_wav, bg_wav=bg,
+                       voice_wav=voice_wav, mode=bg_mode, voice_is_clean=voice_is_clean)

backend/app/services/dubber/mux.py

@@ -109,8 +109,34 @@ def assemble_voice(lines: list[PlacedLine], total_dur: float, out_wav: str) -> s
     return out_wav
 
 
-def mix_over_bg(voice_wav: str, bg_wav: str, out_wav: str) -> str:
-    """Trộn giọng dịch lên trên nhạc nền."""
+def mix_over_bg(voice_wav: str, bg_wav: str, out_wav: str,
+                sidechain: bool = True) -> str:
+    """Trộn giọng dịch LÊN TRÊN nhạc nền.
+
+    sidechain=True: ép nền NHỎ LẠI mỗi khi có giọng dịch (sidechaincompress) rồi
+    trộn -> lời rõ, nhạc/tiếng động vẫn còn nhưng không lấn giọng. Đây là cách
+    xử lý tốt cho nền là NHẠC CÓ LỜI (không cần tách sạch tuyệt đối vẫn nghe ổn).
+    Nếu sidechain lỗi (build ffmpeg thiếu filter) -> tự lùi về amix thường.
+    """
+    if sidechain:
+        fg = (
+            "[0:a]aresample=44100,aformat=channel_layouts=stereo[bg];"
+            "[1:a]aresample=44100,aformat=channel_layouts=stereo[vx];"
+            "[vx]asplit=2[vx1][vxsc];"
+            # nén nền theo giọng: khi có giọng -> nền hạ ~ratio; nhả mượt tránh bụp
+            "[bg][vxsc]sidechaincompress=threshold=0.02:ratio=12:attack=5:"
+            "release=350:makeup=1[bgd];"
+            "[bgd][vx1]amix=inputs=2:normalize=0:duration=longest[mix]"
+        )
+        try:
+            subprocess.run(
+                [FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
+                 "-i", bg_wav, "-i", voice_wav,
+                 "-filter_complex", fg, "-map", "[mix]", out_wav],
+                check=True, capture_output=True)
+            return out_wav
+        except Exception:
+            pass  # lùi về trộn thường
     subprocess.run(
         [FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
          "-i", bg_wav, "-i", voice_wav,
@@ -122,18 +148,49 @@ def mix_over_bg(voice_wav: str, bg_wav: str, out_wav: str) -> str:
     return out_wav
 
 
+def video_codec(path: str) -> str:
+    """Tên codec luồng hình (vd 'h264', 'hevc'). Rỗng nếu không đọc được."""
+    out = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "v:0",
+         "-show_entries", "stream=codec_name", "-of", "csv=p=0", path],
+        capture_output=True, text=True).stdout.strip()
+    return out.split(",")[0].strip().lower()
+
+
+def _vcodec_args(src: str) -> list[str]:
+    """Chọn cách xử lý luồng HÌNH:
+
+    - Nguồn đã H.264 -> `-c:v copy`: KHÔNG re-encode (nhanh gần như tức thì và
+      giữ NGUYÊN chất lượng hình). Trình duyệt phát được sẵn.
+    - Nguồn khác (HEVC/H.265, VP9…) -> encode H.264 để web xem được.
+    """
+    if video_codec(src) == "h264":
+        return ["-c:v", "copy"]
+    return ["-c:v", "libx264", "-preset", "veryfast", "-crf", "20", "-pix_fmt", "yuv420p"]
+
+
+def normalize_playable(src: str, out_mp4: str) -> str:
+    """Chuẩn hoá video cho web: giữ nguyên hình nếu đã H.264 (copy), chỉ encode
+    khi cần; luôn xuất audio AAC + faststart. Dùng cho nhánh giữ-nguyên/dự-phòng."""
+    subprocess.run(
+        [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", src,
+         *_vcodec_args(src), "-c:a", "aac", "-movflags", "+faststart", out_mp4],
+        check=True, capture_output=True)
+    return out_mp4
+
+
 def mux_to_video(video: str, audio_wav: str, out_mp4: str) -> str:
-    """Ghép audio mới vào video và RE-ENCODE hình sang H.264/yuv420p + faststart.
+    """Ghép audio mới vào video cho web xem được.
 
-    Không dùng `-c:v copy` vì video nguồn có thể là HEVC/H.265 — trình duyệt
-    (Chrome/Firefox) không phát được -> người dùng thấy player trơ không có hình.
-    H.264 + faststart đảm bảo xem trực tiếp được trên web.
+    Copy luồng hình nếu nguồn đã là H.264 (nhanh + không mất chất); chỉ RE-ENCODE
+    sang H.264/yuv420p khi nguồn là HEVC/H.265 — trình duyệt (Chrome/Firefox)
+    không phát HEVC được. Luôn +faststart để xem trực tiếp.
     """
     subprocess.run(
         [FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
          "-i", video, "-i", audio_wav,
          "-map", "0:v:0", "-map", "1:a:0",
-         "-c:v", "libx264", "-preset", "veryfast", "-crf", "20", "-pix_fmt", "yuv420p",
+         *_vcodec_args(video),
          "-movflags", "+faststart",
          "-c:a", "aac", "-b:a", "192k",
          "-shortest", out_mp4], check=True, capture_output=True)

backend/app/services/dubber/pipeline.py

@@ -7,12 +7,14 @@ Trả về đường dẫn: video đã dịch, audio giọng clone, subtitle SRT
 
 from __future__ import annotations
 
+import json
 import os
 from dataclasses import dataclass
 from typing import Callable, Optional
 
-from . import asr, audio, mux, translate, tts
+from . import align, asr, audio, mux, translate, tts
 from .probe_dur import video_duration
+from ...config import settings
 
 
 @dataclass
@@ -110,22 +112,17 @@ def _passthrough(video: str, out_dir: str, opt: DubOptions, note: str) -> DubRes
     Đảm bảo người dùng luôn TẢI ĐƯỢC video, không bị treo/job lỗi.
     """
     import shutil as _sh
+    import subprocess
     os.makedirs(out_dir, exist_ok=True)
     ffmpeg = _sh.which("ffmpeg") or "ffmpeg"
     video_out = os.path.join(out_dir, f"video_translated_{opt.target_lang}.mp4")
     try:
-        import subprocess
-        # re-encode H.264 để trình duyệt xem được (video gốc có thể là HEVC)
-        subprocess.run([ffmpeg, "-y", "-hide_banner", "-loglevel", "error",
-                        "-i", video, "-c:v", "libx264", "-preset", "veryfast",
-                        "-crf", "20", "-pix_fmt", "yuv420p", "-movflags", "+faststart",
-                        "-c:a", "aac", video_out],
-                       check=True, capture_output=True)
+        # Copy hình nếu đã H.264, chỉ encode khi nguồn là HEVC (xem mux.normalize_playable)
+        mux.normalize_playable(video, video_out)
     except Exception:
         _sh.copy(video, video_out)
     audio_out = os.path.join(out_dir, "audio.m4a")
     try:
-        import subprocess
         subprocess.run([ffmpeg, "-y", "-hide_banner", "-loglevel", "error",
                         "-i", video, "-vn", "-c:a", "aac", audio_out],
                        check=True, capture_output=True)
@@ -138,23 +135,66 @@ def _passthrough(video: str, out_dir: str, opt: DubOptions, note: str) -> DubRes
                      language="unknown", n_lines=0, note=note)
 
 
-def run_dub(video: str, out_dir: str, opt: DubOptions,
-            progress: Callable[[float, str], None] | None = None) -> DubResult:
-    """Bọc pipeline thật: nếu BẤT KỲ bước nào lỗi (thiếu model/API/mạng) thì
-    rơi về _passthrough để người dùng vẫn tải được video. Không bao giờ treo job."""
+# ================================================================= 2 PHA =====
+# Pha 1 (analyze): tách audio -> ASR -> VAD -> dịch  => trả CÂU DỊCH + MỐC cho
+#                  user XEM/SỬA trước khi đọc. Lưu "state.json" để nối pha 2.
+# Pha 2 (synthesize): nhận câu (đã sửa) -> TTS + neo mốc + trộn nền -> video.
+# run_dub() = chạy liền 2 pha (giữ đường một-phát cũ).
+
+
+@dataclass
+class EditableLine:
+    start: float
+    end: float
+    src: str                 # câu GỐC (tham khảo, không sửa)
+    text: str                # bản DỊCH (user sửa được)
+
+
+@dataclass
+class AnalyzeResult:
+    state_path: str          # đường dẫn state.json để gọi pha 2 (rỗng nếu không cần)
+    language: str
+    note: str
+    same_language: bool      # True -> đã ra video luôn, khỏi TTS
+    lines: list              # list[EditableLine]
+    video_out: str = ""
+    audio_out: str = ""
+    srt_out: str = ""
+
+
+def _save_state(out_dir: str, data: dict) -> str:
+    path = os.path.join(out_dir, "state.json")
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False)
+    return path
+
+
+def _load_state(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+# ----------------------------------------------------------------- PHA 1 -----
+
+def analyze(video: str, out_dir: str, opt: DubOptions,
+            progress: Callable[[float, str], None] | None = None) -> AnalyzeResult:
+    """Bọc pha 1: lỗi -> trả video gốc (passthrough) để FE vẫn có cái hiển thị."""
     try:
-        return _run_dub_full(video, out_dir, opt, progress)
+        return _analyze_full(video, out_dir, opt, progress)
     except Exception as e:
         import traceback
-        traceback.print_exc()           # in chi tiết ra console uvicorn để biết tầng nào hỏng
+        traceback.print_exc()
         if progress:
             progress(1.0, "Dùng video gốc (xem ghi chú lỗi)")
-        return _passthrough(video, out_dir, opt,
-                            note=f"Chưa lồng tiếng được nên trả video gốc: {e}")
+        pr = _passthrough(video, out_dir, opt,
+                          note=f"Chưa xử lý để sửa được nên trả video gốc: {e}")
+        return AnalyzeResult(state_path="", language=pr.language, note=pr.note,
+                             same_language=False, lines=[], video_out=pr.video_out,
+                             audio_out=pr.audio_out, srt_out=pr.srt_out)
 
 
-def _run_dub_full(video: str, out_dir: str, opt: DubOptions,
-            progress: Callable[[float, str], None] | None = None) -> DubResult:
+def _analyze_full(video: str, out_dir: str, opt: DubOptions,
+                  progress: Callable[[float, str], None] | None = None) -> AnalyzeResult:
     def emit(p, m):
         if progress:
             progress(p, m)
@@ -163,68 +203,156 @@ def _run_dub_full(video: str, out_dir: str, opt: DubOptions,
     os.makedirs(work, exist_ok=True)
     total = video_duration(video)
 
-    emit(0.05, "Tách audio & xử lý nền nhạc")
+    emit(0.08, "Tách audio & xử lý nền nhạc")
     bundle = audio.build_audio(video, work, opt.bg_mode, opt.demucs_model)
 
-    emit(0.25, "Nhận dạng lời thoại (Whisper)")
+    emit(0.4, "Nhận dạng lời thoại (Whisper)")
     try:
         segments, language = asr.transcribe(bundle.asr_wav)
     except Exception as e:
         raise RuntimeError(f"[Bước ASR/Groq Whisper] {e}") from e
 
+    # Hít mốc thời gian về đúng chỗ có GIỌNG THẬT (chỉ khi có giọng đã tách sạch)
+    if settings.VAD_SNAP and bundle.voice_is_clean and segments:
+        try:
+            segments = align.snap_segments(
+                segments, bundle.voice_wav, silence_db=settings.VAD_SILENCE_DB)
+        except Exception as e:
+            import sys
+            print(f"[pipeline] VAD snap bỏ qua: {e}", file=sys.stderr)
+
     # ── Nếu ngôn ngữ gốc TRÙNG ngôn ngữ đích → giữ nguyên video gốc ──
     _lang_map = {"vi": "vi", "vie": "vi", "english": "en", "en": "en",
                  "filipino": "fil", "fil": "fil", "tagalog": "fil"}
     _detected = _lang_map.get(language.lower().strip(), language.lower().strip())
     _target = _lang_map.get(opt.target_lang.lower().strip(), opt.target_lang.lower().strip())
     if _detected and _detected == _target:
-        if progress:
-            progress(1.0, f"Video đã là ngôn ngữ {opt.target_lang} — giữ nguyên")
+        emit(0.85, f"Video đã là ngôn ngữ {opt.target_lang} — không cần dịch")
+        # Vẫn xuất bản video "giữ nguyên" sẵn để dùng nếu user chọn không đọc lại.
         import shutil as _sh2
         video_out = os.path.join(out_dir, f"video_translated_{opt.target_lang}.mp4")
         try:
-            import subprocess
-            subprocess.run(["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
-                            "-i", video, "-c:v", "libx264", "-preset", "veryfast",
-                            "-crf", "20", "-pix_fmt", "yuv420p", "-movflags", "+faststart",
-                            "-c:a", "aac", video_out],
-                           check=True, capture_output=True)
+            # Copy hình nếu đã H.264 (không re-encode), chỉ encode khi nguồn là HEVC.
+            mux.normalize_playable(video, video_out)
         except Exception:
             _sh2.copy(video, video_out)
-        audio_out = os.path.join(out_dir, "audio.m4a")
-        try:
-            import subprocess
-            subprocess.run(["ffmpeg", "-y", "-hide_banner", "-loglevel", "error",
-                            "-i", video, "-vn", "-c:a", "aac", audio_out],
-                           check=True, capture_output=True)
-        except Exception:
-            audio_out = video_out
+        # KHÔNG dịch (giữ nguyên lời gốc) nhưng VẪN trả transcript + mốc để user xem/sửa.
+        lines = [EditableLine(start=float(s.start), end=float(s.end),
+                              src=s.text, text=s.text) for s in segments]
         srt_out = os.path.join(out_dir, "subtitle.srt")
         with open(srt_out, "w", encoding="utf-8") as f:
-            for i, ln in enumerate(segments, 1):
-                st = _srt_time(ln.start); et = _srt_time(ln.end)
-                f.write(f"{i}\n{st} --> {et}\n{ln.text}\n\n")
-        return DubResult(video_out=video_out, audio_out=audio_out, srt_out=srt_out,
-                         language=language, n_lines=len(segments),
-                         note=f"Video đã là tiếng {_detected.upper()} — giữ nguyên, không dịch lại.")
-
-    emit(0.45, f"Dịch sang {opt.target_lang} (vừa khít thời lượng)")
+            for i, ln in enumerate(lines, 1):
+                f.write(f"{i}\n{_srt_time(ln.start)} --> {_srt_time(ln.end)}\n{ln.text}\n\n")
+        state = {
+            "video": video, "out_dir": out_dir, "work": work,
+            "total_dur": total, "language": language,
+            "bg_wav": bundle.bg_wav, "voice_wav": bundle.voice_wav,
+            "voice_is_clean": bundle.voice_is_clean,
+            "target_lang": opt.target_lang, "bg_mode": opt.bg_mode,
+            "lines": [{"start": l.start, "end": l.end, "src": l.src, "text": l.text}
+                      for l in lines],
+        }
+        state_path = _save_state(out_dir, state)
+        emit(1.0, "Đã có lời gốc — chờ bạn kiểm/sửa")
+        return AnalyzeResult(
+            state_path=state_path, language=language,
+            note=f"Video đã là tiếng {_detected.upper()} — có thể giữ nguyên hoặc sửa lời để đọc lại.",
+            same_language=True, lines=lines, video_out=video_out,
+            audio_out=video_out, srt_out=srt_out)
+
+    emit(0.6, f"Dịch sang {opt.target_lang} (vừa khít thời lượng)")
     try:
         translated = translate.translate_all(segments, opt.target_lang)
     except Exception as e:
         raise RuntimeError(f"[Bước Dịch/Gemini] {e}") from e
+
+    # Ghép câu dịch + câu gốc (tham khảo) theo thứ tự
+    lines: list[EditableLine] = []
+    for i, tl in enumerate(translated):
+        src = segments[i].text if i < len(segments) else ""
+        lines.append(EditableLine(start=float(tl.start), end=float(tl.end),
+                                  src=src, text=tl.text))
+
     srt_out = write_srt(translated, os.path.join(out_dir, "subtitle.srt"))
 
-    # mẫu clone
+    # Lưu state để pha 2 (TTS) nối tiếp mà không phải tách/ASR/dịch lại
+    state = {
+        "video": video, "out_dir": out_dir, "work": work,
+        "total_dur": total, "language": language,
+        "bg_wav": bundle.bg_wav, "voice_wav": bundle.voice_wav,
+        "voice_is_clean": bundle.voice_is_clean,
+        "target_lang": opt.target_lang, "bg_mode": opt.bg_mode,
+        "lines": [{"start": l.start, "end": l.end, "src": l.src, "text": l.text}
+                  for l in lines],
+    }
+    state_path = _save_state(out_dir, state)
+
+    emit(1.0, "Đã dịch xong — chờ bạn kiểm/sửa")
+    return AnalyzeResult(state_path=state_path, language=language, note="",
+                         same_language=False, lines=lines, srt_out=srt_out)
+
+
+# ----------------------------------------------------------------- PHA 2 -----
+
+def synthesize(state_path: str, lines: list[dict], opt: DubOptions,
+               progress: Callable[[float, str], None] | None = None) -> DubResult:
+    """Bọc pha 2: lỗi -> trả video gốc từ state để không treo job."""
+    try:
+        return _synthesize_full(state_path, lines, opt, progress)
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        try:
+            st = _load_state(state_path)
+            return _passthrough(st["video"], st["out_dir"], opt,
+                                note=f"Không tổng hợp giọng được nên trả video gốc: {e}")
+        except Exception:
+            raise
+
+
+def _synthesize_full(state_path: str, lines: list[dict], opt: DubOptions,
+                     progress: Callable[[float, str], None] | None = None) -> DubResult:
+    def emit(p, m):
+        if progress:
+            progress(p, m)
+
+    st = _load_state(state_path)
+    out_dir = st["out_dir"]; work = st["work"]; total = float(st["total_dur"])
+    target = st.get("target_lang", opt.target_lang)
+    bg_wav = st["bg_wav"]; voice_wav = st["voice_wav"]; video = st["video"]
+
+    # Chuẩn hoá câu người dùng gửi lên (đã sửa text/mốc) -> sắp theo start
+    norm = []
+    for ln in (lines or []):
+        try:
+            s = float(ln.get("start", 0.0)); e = float(ln.get("end", s))
+            t = (ln.get("text") or "").strip()
+        except Exception:
+            continue
+        if e < s:
+            e = s
+        norm.append({"start": max(0.0, s), "end": e, "text": t})
+    norm.sort(key=lambda x: x["start"])
+    if not norm:                                   # không có câu -> lấy từ state
+        norm = [{"start": l["start"], "end": l["end"], "text": l["text"]}
+                for l in st.get("lines", [])]
+
+    # SRT theo bản đã sửa
+    srt_out = os.path.join(out_dir, "subtitle.srt")
+    with open(srt_out, "w", encoding="utf-8") as f:
+        for i, ln in enumerate(norm, 1):
+            f.write(f"{i}\n{_srt_time(ln['start'])} --> {_srt_time(ln['end'])}\n{ln['text']}\n\n")
+
+    # Mẫu clone (cắt từ giọng đã tách sạch nếu voice_source=video)
     speaker_wav = opt.speaker_wav
-    if opt.do_clone and opt.voice_source == "video" and segments:
-        emit(0.55, "Cắt mẫu giọng để clone")
+    if opt.do_clone and opt.voice_source == "video" and norm:
+        emit(0.08, "Cắt mẫu giọng để clone")
         speaker_wav = audio.cut_clone_sample(
-            bundle.voice_wav, work, start=max(0.0, segments[0].start), length=15.0)
+            voice_wav, work, start=max(0.0, norm[0]["start"]), length=15.0)
 
-    emit(0.6, "Tổng hợp giọng đọc (TTS) + clone")
+    emit(0.15, "Tổng hợp giọng đọc (TTS)")
     vcfg = tts.VoiceConfig(
-        target_lang=opt.target_lang, voice_source=opt.voice_source,
+        target_lang=target, voice_source=opt.voice_source,
         speaker_wav=speaker_wav, preset=opt.preset, style=opt.style,
         engine=opt.engine, temperature=opt.temperature, top_k=opt.top_k,
         repetition_penalty=opt.repetition_penalty)
@@ -235,31 +363,67 @@ def _run_dub_full(video: str, out_dir: str, opt: DubOptions,
 
     placed: list[mux.PlacedLine] = []
     tts_dir = os.path.join(work, "tts"); os.makedirs(tts_dir, exist_ok=True)
-    n = len(translated)
-    for i, ln in enumerate(translated):
-        raw = os.path.join(tts_dir, f"line_{i:04d}.wav")
-        tts.synth_line(engine, ln.text, raw, vcfg)
-        # ĐỒNG BỘ: mỗi câu dịch phải nằm trong ĐÚNG cửa sổ thời gian câu gốc
-        # [start, end] -> nén cho vừa thời lượng gốc, KHÔNG lấn sang câu kế
-        # (giữ khoảng nghỉ gốc). Neo tuyệt đối tại ln.start khi ghép.
-        own = max(0.3, ln.end - ln.start)                 # thời lượng nói gốc
-        next_start = translated[i + 1].start if i + 1 < n else total
-        slot = max(0.3, min(own, next_start - ln.start))  # không tràn quá câu kế
+    n = len(norm)
+    raws = [os.path.join(tts_dir, f"line_{i:04d}.wav") for i in range(n)]
+
+    # ── Sinh giọng từng câu ──
+    # Edge TTS (en/fil) là request MẠNG độc lập -> chạy SONG SONG (nhanh gấp nhiều
+    # lần cho video nhiều câu). Model LOCAL (VieNeu/XTTS) tính trên CPU đã ăn hết
+    # nhân sẵn -> chạy song song không lợi mà dễ tràn RAM, nên giữ TUẦN TỰ.
+    engine_name = tts.pick_engine(vcfg)
+    if engine_name == "edge" and n > 1:
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        workers = min(8, n)
+        done = 0
+        with ThreadPoolExecutor(max_workers=workers) as ex:
+            futs = {ex.submit(tts.synth_line, engine, norm[i]["text"], raws[i], vcfg): i
+                    for i in range(n)}
+            for fut in as_completed(futs):
+                fut.result()                       # synth_line tự nuốt lỗi -> không ném
+                done += 1
+                emit(0.15 + 0.6 * done / max(1, n), f"TTS câu {done}/{n}")
+    else:
+        for i in range(n):
+            tts.synth_line(engine, norm[i]["text"], raws[i], vcfg)
+            emit(0.15 + 0.6 * (i + 1) / max(1, n), f"TTS câu {i+1}/{n}")
+
+    # ── Ép mỗi câu vào khe thời gian & neo mốc (theo đúng thứ tự) ──
+    for i, ln in enumerate(norm):
+        own = max(0.3, ln["end"] - ln["start"])
+        next_start = norm[i + 1]["start"] if i + 1 < n else total
+        slot = max(0.3, min(own, next_start - ln["start"]))
         fitted = os.path.join(tts_dir, f"fit_{i:04d}.wav")
-        mux.fit_to_slot(raw, slot, fitted)
-        placed.append(mux.PlacedLine(start=ln.start, wav=fitted))
-        emit(0.6 + 0.25 * (i + 1) / max(1, n), f"TTS câu {i+1}/{n}")
+        mux.fit_to_slot(raws[i], slot, fitted)
+        placed.append(mux.PlacedLine(start=ln["start"], wav=fitted))
+    emit(0.8, "Ghép các câu đã đọc")
 
     emit(0.9, "Neo mốc thời gian & trộn nền")
     voice_track = mux.assemble_voice(placed, total, os.path.join(work, "voice.wav"))
-    final_audio = mux.mix_over_bg(voice_track, bundle.bg_wav,
-                                  os.path.join(work, "final_audio.wav"))
+    final_audio = mux.mix_over_bg(voice_track, bg_wav,
+                                  os.path.join(work, "final_audio.wav"),
+                                  sidechain=settings.BG_SIDECHAIN)
 
     emit(0.96, "Ghép vào video")
     video_out = mux.mux_to_video(
         video, final_audio,
-        os.path.join(out_dir, f"video_translated_{opt.target_lang}.mp4"))
+        os.path.join(out_dir, f"video_translated_{target}.mp4"))
 
     emit(1.0, "Hoàn tất")
     return DubResult(video_out=video_out, audio_out=final_audio, srt_out=srt_out,
-                     language=language, n_lines=n)
+                     language=st.get("language", ""), n_lines=n)
+
+
+def run_dub(video: str, out_dir: str, opt: DubOptions,
+            progress: Callable[[float, str], None] | None = None) -> DubResult:
+    """Chạy LIỀN 2 pha (đường một-phát cũ, không có bước sửa tay).
+
+    Nếu BẤT KỲ bước nào lỗi -> _passthrough để người dùng vẫn tải được video.
+    """
+    ar = analyze(video, out_dir, opt, progress)
+    if ar.same_language or not ar.state_path:
+        # cùng ngôn ngữ (đã có video) HOẶC analyze đã passthrough
+        return DubResult(video_out=ar.video_out, audio_out=ar.audio_out or ar.video_out,
+                         srt_out=ar.srt_out, language=ar.language,
+                         n_lines=len(ar.lines), note=ar.note)
+    lines = [{"start": l.start, "end": l.end, "text": l.text} for l in ar.lines]
+    return synthesize(ar.state_path, lines, opt, progress)

backend/app/services/dubber/translate.py

@@ -53,12 +53,34 @@ def _prompt(seg: Segment, target_lang: str, budget: int) -> str:
 
 
 def _gemini(prompt: str) -> str:
-    import google.generativeai as genai  # type: ignore
-
-    genai.configure(api_key=settings.GOOGLE_API_KEY)
-    model = genai.GenerativeModel(settings.GEMINI_MODEL)
-    resp = model.generate_content(prompt)
-    return (resp.text or "").strip()
+    """Gọi Gemini qua REST v1beta, TẮT 'thinking' (thinkingBudget=0).
+
+    Vì sao REST: gemini-2.5-flash bật thinking MẶC ĐỊNH -> mỗi lần dịch 6-8s (batch
+    cả video có thể 40s). Dịch không cần suy luận sâu; tắt thinking nhanh ~7x mà chất
+    lượng như nhau. SDK cũ `google.generativeai` không cho set thinkingConfig, nên gọi
+    thẳng REST (chỉ cần `requests`). Model nào không nhận config thì tự bỏ, gọi lại.
+    """
+    import requests  # có sẵn trong requirements
+
+    model = settings.GEMINI_MODEL
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+    base = {"contents": [{"parts": [{"text": prompt}]}]}
+    for gen_cfg in ({"thinkingConfig": {"thinkingBudget": 0}}, None):
+        body = dict(base)
+        if gen_cfg:
+            body["generationConfig"] = gen_cfg
+        r = requests.post(url, params={"key": settings.GOOGLE_API_KEY},
+                          json=body, timeout=60)
+        if r.status_code == 400 and gen_cfg:
+            continue                          # model không hỗ trợ thinkingConfig -> thử lại
+        r.raise_for_status()
+        data = r.json()
+        cands = data.get("candidates") or []
+        if not cands:
+            raise RuntimeError(f"Gemini không trả nội dung: {str(data)[:200]}")
+        parts = (cands[0].get("content") or {}).get("parts") or []
+        return "".join(p.get("text", "") for p in parts).strip()
+    return ""
 
 
 def _groq_llm(prompt: str) -> str:
@@ -119,32 +141,59 @@ def _parse_batch(text: str) -> dict[int, str]:
     return out
 
 
+def _run_batch(segs: list[Segment], target_lang: str) -> dict[int, str]:
+    """Gọi DỊCH GỘP 1 lần cho danh sách câu -> {1-based index: bản dịch}.
+
+    Ưu tiên map theo SỐ THỨ TỰ model trả; nếu model quên đánh số nhưng số DÒNG
+    khớp số câu thì map theo VỊ TRÍ (đỡ phải rơi về dịch từng câu).
+    """
+    prompt = _batch_prompt(segs, target_lang)
+    try:
+        resp = _gemini(prompt)
+    except Exception:
+        resp = _groq_llm(prompt)                 # tự động dùng dự phòng Groq
+    parsed = _parse_batch(resp)
+    if len(parsed) < len(segs):                  # thiếu số -> thử map theo vị trí
+        rows = [r.strip() for r in (resp or "").splitlines() if r.strip()]
+        if len(rows) == len(segs):
+            parsed = {}
+            for i, r in enumerate(rows, 1):
+                m = re.match(r"\s*\d+[.)]\s*(.+)", r)
+                parsed[i] = (m.group(1).strip() if m else r)
+    return parsed
+
+
 def translate_all(segs: list[Segment], target_lang: str) -> list[TranslatedLine]:
     if target_lang not in LANG_NAME:
         raise ValueError(f"Ngôn ngữ đích chưa hỗ trợ: {target_lang}")
     if not segs:
         return []
+    n = len(segs)
+    results: dict[int, str] = {}                 # 0-based index -> bản dịch
 
-    # 1) DỊCH GỘP: 1 lần gọi cho tất cả câu (tránh 429 do gọi từng câu).
+    # 1) GỘP 1 LẦN cho TẤT CẢ câu (không gọi từng câu).
     try:
-        prompt = _batch_prompt(segs, target_lang)
-        try:
-            resp = _gemini(prompt)
-        except Exception:
-            resp = _groq_llm(prompt)
-        parsed = _parse_batch(resp)
-        if all(i in parsed for i in range(1, len(segs) + 1)):
-            return [TranslatedLine(s.start, s.end, s.text,
-                                   parsed.get(i + 1) or s.text,
-                                   char_budget(s, target_lang))
-                    for i, s in enumerate(segs)]
+        parsed = _run_batch(segs, target_lang)
+        for i in range(1, n + 1):
+            t = (parsed.get(i) or "").strip()
+            if t:
+                results[i - 1] = t
     except Exception:
         pass
 
-    # 2) DỰ PHÒNG: dịch từng câu (chỉ khi gộp lỗi/không parse được).
-    out = []
-    for s in segs:
-        txt = translate_line(s, target_lang)
-        out.append(TranslatedLine(s.start, s.end, s.text, txt,
-                                  char_budget(s, target_lang)))
-    return out
+    # 2) Câu nào còn THIẾU -> GỘP THÊM 1 LẦN chỉ cho các câu thiếu (vẫn 1 request).
+    missing = [i for i in range(n) if i not in results]
+    if missing:
+        try:
+            parsed2 = _run_batch([segs[i] for i in missing], target_lang)
+            for k, gi in enumerate(missing, 1):
+                t = (parsed2.get(k) or "").strip()
+                if t:
+                    results[gi] = t
+        except Exception:
+            pass
+
+    # 3) Vẫn thiếu -> giữ nguyên lời gốc (KHÔNG gọi thêm request nào).
+    return [TranslatedLine(s.start, s.end, s.text,
+                           results.get(i, s.text), char_budget(s, target_lang))
+            for i, s in enumerate(segs)]

backend/app/services/dubber/tts.py

@@ -19,6 +19,37 @@ from typing import Optional
 
 FFMPEG = shutil.which("ffmpeg") or "ffmpeg"
 
+# --------------------------------------------------------------- clone presets ---
+# Giọng "có sẵn" nhưng CLONE TỪ FILE MẪU (khác preset built-in của VieNeu).
+# Thả file wav/mp3 mẫu vào backend/app/assets/voices/vi/ là mục tự hiện trong danh sách.
+_ASSET_VOICE_DIR = os.path.normpath(
+    os.path.join(os.path.dirname(__file__), "..", "..", "assets", "voices"))
+
+# id -> (label, tên file trong <assets>/voices/<lang>/)
+_CLONE_PRESETS: dict[str, dict[str, tuple[str, str]]] = {
+    "vi": {
+        "adam": ("Adam — nam, giọng trầm ấm (clone)", "adam.wav"),
+    },
+}
+
+
+def _clone_preset_path(lang: str, preset_id: str) -> str | None:
+    """Trả đường dẫn file mẫu nếu preset_id là giọng clone-preset và file TỒN TẠI."""
+    entry = _CLONE_PRESETS.get(lang, {}).get((preset_id or "").strip())
+    if not entry:
+        return None
+    path = os.path.join(_ASSET_VOICE_DIR, lang, entry[1])
+    return path if os.path.exists(path) else None
+
+
+def _clone_preset_voices(lang: str) -> list[dict]:
+    """Danh sách giọng clone-preset ĐÃ CÓ FILE cho ngôn ngữ (để ghép vào /voices)."""
+    out = []
+    for pid, (label, fname) in _CLONE_PRESETS.get(lang, {}).items():
+        if os.path.exists(os.path.join(_ASSET_VOICE_DIR, lang, fname)):
+            out.append({"id": pid, "label": label})
+    return out
+
 
 @dataclass
 class VoiceConfig:
@@ -68,9 +99,11 @@ class VieNeuEngine(TTSEngine):  # pragma: no cover - cần model local
             kw["top_k"] = cfg.top_k
         if cfg.repetition_penalty is not None:
             kw["repetition_penalty"] = cfg.repetition_penalty
-        if cfg.speaker_wav:                       # clone từ mẫu
-            audio = self.model.infer(text, ref_audio=cfg.speaker_wav, **kw)
-        else:                                     # giọng preset (voice nhận tên str)
+        # Ưu tiên mẫu upload/video; nếu preset là giọng clone-preset (vd Adam) -> clone file mẫu.
+        ref = cfg.speaker_wav or _clone_preset_path(cfg.target_lang, cfg.preset)
+        if ref:                                   # clone từ mẫu
+            audio = self.model.infer(text, ref_audio=ref, **kw)
+        else:                                     # giọng preset built-in (voice nhận tên str)
             audio = self.model.infer(text, voice=cfg.preset or None, **kw)
         self.model.save(audio, out_wav)           # ghi wav ở sample_rate của model
         return out_wav
@@ -220,6 +253,8 @@ def list_voices(lang: str, allow_load: bool = False) -> list[dict]:
     """Trả danh sách giọng cho ngôn ngữ. Mặc định KHÔNG nạp model (tránh treo request);
     chỉ lấy động khi engine đã được cache sẵn (đã từng dịch) hoặc allow_load=True."""
     name = pick_engine(VoiceConfig(target_lang=lang))
+    # Giọng clone-preset (thả file mẫu vào assets) đặt LÊN ĐẦU danh sách.
+    clone = _clone_preset_voices(lang)
     # Edge: danh sách giọng theo NGÔN NGỮ (engine.list_voices() không biết lang),
     # nên lấy trực tiếp từ bảng giọng Edge để đúng nam/nữ từng thứ tiếng.
     if name != "edge" and (name in _INSTANCES or allow_load):
@@ -227,11 +262,11 @@ def list_voices(lang: str, allow_load: bool = False) -> list[dict]:
             eng = load_engine(VoiceConfig(target_lang=lang))
             vs = eng.list_voices()
             if vs:
-                return [{"id": vid, "label": label} for (label, vid) in vs]
+                return clone + [{"id": vid, "label": label} for (label, vid) in vs]
         except Exception:
             pass
-    return [{"id": vid, "label": label}
-            for (label, vid) in _FALLBACK_VOICES.get(lang, [])]
+    return clone + [{"id": vid, "label": label}
+                    for (label, vid) in _FALLBACK_VOICES.get(lang, [])]
 
 
 def synth_line(engine: TTSEngine, text: str, out_wav: str, cfg: VoiceConfig) -> str:

backend/app/services/shuffler/engine.py

@@ -1,5 +1,4 @@
-"""
-Engine "Xào video" — tạo nhiều biến thể video bằng cách:
+"""Engine "Xào video" — tạo nhiều biến thể video bằng cách:
   1) chọn 1 clip cho mỗi KHÚC (tổ hợp Cartesian các pool clip), và
   2) ĐẢO THỨ TỰ các khúc theo chế độ của TỪNG khúc (không còn cờ toàn cục).
 
@@ -14,21 +13,41 @@ Ví dụ với 5 khúc 1..5:
 - lock 1 & 4, còn lại shuffle -> 1,_,_,4,_ + hoán vị {2,3,5} -> 1,5,2,4,3 ...
 - lock 1, drop 4, còn lại shuffle -> 1 + hoán vị {2,3,5} -> 1,3,5,2 ...
 
-Nếu KHÔNG bật lọc tương đồng (threshold>=1.0) và random_ratio>=1.0
-thì engine trả về TOÀN BỘ tổ hợp (lấy hết video).
+THỨ TỰ SẮP XẾP là MỘT PHẦN của không gian tổ hợp: mỗi bộ clip + mỗi cách sắp xếp
+= một biến thể riêng. Không gian = selection_count × ordering_count.
+
+Tốc độ (bê từ project video_cook)
+---------------------------------
+Thay vì materialize TOÀN BỘ product() rồi lọc/lấy mẫu (bùng nổ bộ nhớ + treo khi
+thả cả thư mục nhiều clip), engine LẤY MẪU NGẪU NHIÊN TRÊN KHÔNG GIAN CHỈ SỐ:
+mỗi tổ hợp có một chỉ số duy nhất, giải mã tức thời qua ``_seq_at`` — không bao
+giờ sinh hết. Lọc tương đồng dùng greedy + dừng sớm khi đã đủ ``cap`` biến thể.
+
+Nếu KHÔNG bật lọc tương đồng (threshold>=1.0) và random_ratio>=1.0 thì engine trả
+về TOÀN BỘ tổ hợp khi còn trong trần ``DEFAULT_CAP``; vượt trần thì lấy mẫu ngẫu
+nhiên ``DEFAULT_CAP`` biến thể (không treo dù tổ hợp lên tới hàng tỉ).
 """
 
 from __future__ import annotations
 
+import random
 from dataclasses import dataclass
 from itertools import permutations, product
-from math import factorial, prod
+from math import ceil, factorial, prod
 from typing import Iterable
 
 import numpy as np
 
 PAD = -9            # sentinel pad cho bằng độ dài, không bao giờ trùng clip thật
 
+# Trần mặc định số biến thể sinh ra khi KHÔNG đặt max_outputs (tránh bùng nổ khi
+# thả cả thư mục → tổ hợp khổng lồ). Là số dòng generate() trả về tối đa.
+DEFAULT_CAP = 500
+
+# Trần số ứng viên bốc ra để LỌC (tương đồng/ngẫu nhiên). Đủ lớn để lọc có ý
+# nghĩa, đủ nhỏ để không treo dù không gian tổ hợp là hàng triệu/tỉ.
+MATERIALIZE_CAP = 20000
+
 
 @dataclass
 class Segment:
@@ -101,6 +120,8 @@ def estimate(cfg: ShuffleConfig) -> ShuffleEstimate:
     active = _active(cfg)
     pools = [s.pool() for s in active]
     selection_count = prod(len(p) for p in pools) if pools else 0
+    if any(len(p) == 0 for p in pools):
+        selection_count = 0
 
     free = sum(0 if s.locked else 1 for s in active)
     ordering_count = factorial(free) if free > 1 else 1
@@ -112,34 +133,43 @@ def estimate(cfg: ShuffleConfig) -> ShuffleEstimate:
     )
 
 
-# ----------------------------------------------------------- generate ---
-
-def _iter_raw_sequences(cfg: ShuffleConfig) -> Iterable[list[int]]:
-    active = _active(cfg)
-    if not active:
-        return
-    pools = [s.pool() for s in active]
-    locked_flags = [s.locked for s in active]
-    orderings = _ordering_indices(locked_flags)
-
-    for selection in product(*pools):
-        for order in orderings:
-            seq = [selection[i] for i in order]
-            if seq:
-                yield seq
+# ------------------------------------------- giải mã tổ hợp theo chỉ số ---
 
+class _Space:
+    """Không gian tổ hợp có thể giải mã tức thời theo chỉ số (không sinh hết).
 
-def _pad_matrix(seqs: list[list[int]]) -> np.ndarray:
-    if not seqs:
-        return np.empty((0, 0), dtype=np.int64)
-    width = max(len(s) for s in seqs)
-    mat = np.full((len(seqs), width), PAD, dtype=np.int64)
-    for r, s in enumerate(seqs):
-        mat[r, : len(s)] = s
-    return mat
+    Chỉ số ``index`` mã hoá cả (bộ clip đã chọn, cách sắp xếp):
+        sel_idx, ord_idx = divmod(index, ord_total)
+    """
 
+    def __init__(self, cfg: ShuffleConfig):
+        active = _active(cfg)
+        self.pools = [s.pool() for s in active]
+        self.locked_flags = [s.locked for s in active]
+        self.orderings = _ordering_indices(self.locked_flags)
+        self.ord_total = len(self.orderings)
+        self.sel_total = prod(len(p) for p in self.pools) if self.pools else 0
+        if any(len(p) == 0 for p in self.pools):
+            self.sel_total = 0
+        self.total = self.sel_total * self.ord_total
+        self.width = len(active)
+
+    def seq_at(self, index: int) -> list[int]:
+        """Giải mã biến thể thứ ``index`` — 1 phép chia/khúc, tức thời."""
+        sel_idx, ord_idx = divmod(index, self.ord_total)
+        sel: list[int] = []
+        for p in reversed(self.pools):
+            sel_idx, r = divmod(sel_idx, len(p))
+            sel.append(p[r])
+        sel.reverse()
+        order = self.orderings[ord_idx]
+        return [sel[i] for i in order]
+
+
+# ------------------------------------------------------- lọc tương đồng ---
 
 def similarity(a: list[int], b: list[int]) -> float:
+    """Tỉ lệ khúc trùng vị trí giữa 2 biến thể (0..1). Giữ để tương thích API."""
     width = max(len(a), len(b))
     if width == 0:
         return 1.0
@@ -151,54 +181,99 @@ def similarity(a: list[int], b: list[int]) -> float:
     return float(eq.sum()) / width
 
 
-def _greedy_dedup(mat: np.ndarray, threshold: float) -> list[int]:
-    n, width = mat.shape
-    if n == 0:
+def _dedup_take(rows: list[list[int]], threshold: float, cap: int) -> list[int]:
+    """Greedy giữ-biến-thể-đầu, loại biến thể sau giống > ngưỡng, DỪNG SỚM khi đủ.
+
+    Trả về danh sách chỉ số (theo ``rows``) được giữ, tối đa ``cap`` phần tử.
+    Dừng sớm giúp khỏi chạy O(n²) khi ngưỡng lỏng (không loại được nhiều) mà chỉ
+    cần vài biến thể — điểm khác biệt tốc độ so với lọc toàn bộ rồi mới cắt.
+    """
+    if not rows:
         return []
-    kept_idx: list[int] = []
+    width = len(rows[0])
+    thr = threshold * width          # số khúc trùng tối đa được phép (dạng float)
+    kept: list[int] = []
     kept_rows = np.empty((0, width), dtype=np.int64)
-    valid = mat != PAD
-
-    for i in range(n):
-        if not kept_idx:
-            kept_idx.append(i)
-            kept_rows = mat[i : i + 1].copy()
-            continue
-        row = mat[i]
-        eq = (kept_rows == row) & valid[i]
-        sims = eq.sum(axis=1) / width
-        if sims.max() < threshold:
-            kept_idx.append(i)
-            kept_rows = np.vstack([kept_rows, row])
-    return kept_idx
+    for i, row in enumerate(rows):
+        r = np.asarray(row, dtype=np.int64)
+        if kept_rows.shape[0]:
+            same = np.count_nonzero(kept_rows == r, axis=1)
+            if float(same.max()) >= thr:     # giống 1 biến thể đã giữ >= ngưỡng
+                continue
+        kept.append(i)
+        kept_rows = np.vstack([kept_rows, r])
+        if len(kept) >= cap:
+            break
+    return kept
+
+
+# ----------------------------------------------------------- generate ---
+
+def _iter_raw_sequences(cfg: ShuffleConfig) -> Iterable[list[int]]:
+    """Sinh LƯỜI toàn bộ biến thể thô (dùng cho bảng xem trước, có cắt trần ngoài)."""
+    space = _Space(cfg)
+    if not space.pools or space.total == 0:
+        return
+    for selection in product(*space.pools):
+        for order in space.orderings:
+            seq = [selection[i] for i in order]
+            if seq:
+                yield seq
 
 
 def generate(cfg: ShuffleConfig) -> list[list[int]]:
-    seqs = list(_iter_raw_sequences(cfg))
-    if not seqs:
+    space = _Space(cfg)
+    total = space.total
+    if total == 0:
+        return []
+
+    rng = random.Random(cfg.seed)
+
+    sim_on = 0.0 < cfg.similarity_threshold < 1.0
+    rand_on = 0.0 < cfg.random_ratio < 1.0
+    cap = cfg.max_outputs if cfg.max_outputs is not None else DEFAULT_CAP
+    cap = max(0, cap)
+    if cap == 0:
         return []
 
-    rng = np.random.default_rng(cfg.seed)
+    # ── Đường nhanh: KHÔNG lọc gì → lấy hết (nếu trong trần) hoặc lấy mẫu ─────
+    if not sim_on and not rand_on:
+        if total <= cap:
+            return [space.seq_at(i) for i in range(total)]
+        idx = rng.sample(range(total), cap)
+        return [space.seq_at(i) for i in idx]
+
+    # ── Có lọc: bốc một pool ứng viên (có trần) rồi lọc trên đó ───────────────
+    pool_size = min(total, MATERIALIZE_CAP)
+    if total <= pool_size:
+        indices = list(range(total))
+        rng.shuffle(indices)            # xáo để lọc/lấy mẫu công bằng, tất định theo seed
+    else:
+        indices = rng.sample(range(total), pool_size)
+
+    # Cần bao nhiêu biến thể "sống sót" trước bước lấy ngẫu nhiên để vẫn đủ cap.
+    if rand_on:
+        want = min(len(indices), ceil(cap / cfg.random_ratio) + 1)
+    else:
+        want = cap
 
-    # 1) lọc trùng theo ngưỡng tương đồng (bỏ qua nếu >=1.0 => lấy hết)
-    if 0.0 < cfg.similarity_threshold < 1.0:
-        mat = _pad_matrix(seqs)
-        perm = rng.permutation(len(seqs))
-        mat = mat[perm]
-        keep = _greedy_dedup(mat, cfg.similarity_threshold)
-        result = [[int(c) for c in mat[k] if c != PAD] for k in keep]
+    if sim_on:
+        rows = [space.seq_at(i) for i in indices]
+        keep = _dedup_take(rows, cfg.similarity_threshold, want)
+        result = [rows[k] for k in keep]
     else:
-        result = [list(s) for s in seqs]
+        take = min(len(indices), want)
+        result = [space.seq_at(indices[i]) for i in range(take)]
 
-    # 2) lấy mẫu ngẫu nhiên theo tỉ lệ (bỏ qua nếu >=1.0 => giữ hết)
-    if 0.0 < cfg.random_ratio < 1.0 and result:
+    # Lấy ngẫu nhiên một phần theo tỉ lệ.
+    if rand_on and result:
         k = max(1, int(round(len(result) * cfg.random_ratio)))
-        idx = rng.choice(len(result), size=min(k, len(result)), replace=False)
-        result = [result[i] for i in sorted(idx.tolist())]
+        k = min(k, len(result))
+        sel = rng.sample(range(len(result)), k)
+        result = [result[i] for i in sorted(sel)]
 
-    # 3) trần số lượng
-    if cfg.max_outputs is not None and len(result) > cfg.max_outputs:
-        idx = rng.choice(len(result), size=cfg.max_outputs, replace=False)
-        result = [result[i] for i in sorted(idx.tolist())]
+    # Trần cứng số lượng.
+    if len(result) > cap:
+        result = result[:cap]
 
     return result

backend/app/services/shuffler/render.py

@@ -4,27 +4,136 @@
 - Mỗi sequence (list clip_id) -> 1 video biến thể (ảnh, KHÔNG tiếng).
 - Nếu có pool âm thanh: mỗi biến thể được gán 1 track (xoay vòng theo thứ tự),
   ví dụ 3 âm thanh s1,s2,s3 -> biến thể 1->s1, 2->s2, 3->s3, 4->s1 ...
+
+Tốc độ (bê "đường nhanh" từ project video_cook)
+-----------------------------------------------
+Ghép cũ re-encode LẠI mọi clip cho TỪNG biến thể → 1 clip nguồn dùng ở N biến thể
+sẽ bị encode N lần (rất chậm). Đường nhanh:
+
+  1) CHUẨN HOÁ MỖI CLIP NGUỒN ĐÚNG 1 LẦN (``normalize_clip``) về cùng khung
+     WxH / fps / pixfmt / codec, cache theo (đường dẫn, độ phân giải). Nhiều biến
+     thể dùng chung cache — encode 1 lần thay vì N lần.
+  2) GHÉP bằng concat demuxer ``-c copy`` (``concat_copy``) — KHÔNG re-encode ở
+     bước ghép, chỉ nối luồng nên gần như tức thời.
+
+Vì mọi clip đã chuẩn hoá về cùng tham số, concat copy nối được sạch. Có validate
+output; nếu vì lý do nào đó copy hỏng thì tự fallback sang ghép re-encode.
 """
 
 from __future__ import annotations
 
+import hashlib
+import json
 import os
 import shutil
 import subprocess
+import threading
 import zipfile
 
 FFMPEG = shutil.which("ffmpeg") or "ffmpeg"
+FFPROBE = shutil.which("ffprobe") or "ffprobe"
+
+
+# --------------------------------------------------------------- validate ---
+
+def _valid_output(path: str) -> bool:
+    """True nếu file mở được: có stream video và duration > 0."""
+    if not os.path.isfile(path) or os.path.getsize(path) < 1024:
+        return False
+    try:
+        r = subprocess.run(
+            [FFPROBE, "-v", "error",
+             "-show_entries", "stream=codec_type",
+             "-show_entries", "format=duration",
+             "-of", "json", path],
+            capture_output=True, timeout=30)
+        data = json.loads(r.stdout or b"{}")
+        has_v = any(s.get("codec_type") == "video" for s in data.get("streams", []))
+        dur = float(data.get("format", {}).get("duration", 0) or 0)
+        return has_v and dur > 0.05
+    except Exception:
+        return False
+
+
+# --------------------------------------------- chuẩn hoá 1 lần / clip nguồn ---
+
+# Khoá theo từng file cache để nhiều luồng render KHÔNG cùng encode 1 clip
+# (tránh 2 ffmpeg cùng ghi 1 file → hỏng / lỗi khoá file trên Windows).
+_norm_locks_guard = threading.Lock()
+_norm_locks: dict[str, threading.Lock] = {}
+
+
+def _lock_for(key: str) -> threading.Lock:
+    with _norm_locks_guard:
+        lk = _norm_locks.get(key)
+        if lk is None:
+            lk = threading.Lock()
+            _norm_locks[key] = lk
+        return lk
+
+
+def _norm_key(src: str, w: int, h: int, fps: int) -> str:
+    sig = f"{os.path.abspath(src)}|{os.path.getmtime(src) if os.path.exists(src) else 0}|{w}x{h}@{fps}"
+    return hashlib.md5(sig.encode("utf-8")).hexdigest()
+
+
+def normalize_clip(src: str, norm_dir: str, w: int = 1080, h: int = 1920,
+                   fps: int = 30) -> str:
+    """Chuẩn hoá 1 clip nguồn về khung WxH/fps/yuv420p/libx264 (video-only), cache.
+
+    Chạy tối đa 1 lần/(clip, độ phân giải) nhờ cache + khoá theo key. Trả về đường
+    dẫn clip đã chuẩn hoá (dùng lại cho mọi biến thể chứa clip đó).
+    """
+    os.makedirs(norm_dir, exist_ok=True)
+    key = _norm_key(src, w, h, fps)
+    cache = os.path.join(norm_dir, f"{key}.mp4")
+    if _valid_output(cache):
+        return cache
+    with _lock_for(cache):
+        if _valid_output(cache):        # luồng khác có thể vừa encode xong
+            return cache
+        vf = (f"scale={w}:{h}:force_original_aspect_ratio=decrease,"
+              f"pad={w}:{h}:(ow-iw)/2:(oh-ih)/2,setsar=1,fps={fps},format=yuv420p")
+        subprocess.run(
+            [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", src,
+             "-an", "-vf", vf,
+             "-c:v", "libx264", "-preset", "veryfast", "-crf", "20",
+             "-video_track_timescale", "15360", cache],
+            check=True, capture_output=True)
+        return cache
+
+
+# -------------------------------------------------------- ghép nhanh (copy) ---
+
+def concat_copy(norm_paths: list[str], out_path: str) -> None:
+    """Nối các clip ĐÃ CHUẨN HOÁ bằng concat demuxer ``-c copy`` (không re-encode)."""
+    if len(norm_paths) == 1:
+        shutil.copy2(norm_paths[0], out_path)
+        return
+    list_file = out_path + ".txt"
+    with open(list_file, "w", encoding="utf-8") as f:
+        for p in norm_paths:
+            safe = os.path.abspath(p).replace("\\", "/").replace("'", "'\\''")
+            f.write(f"file '{safe}'\n")
+    try:
+        subprocess.run(
+            [FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
+             "-f", "concat", "-safe", "0", "-i", list_file,
+             "-c", "copy", "-movflags", "+faststart", out_path],
+            check=True, capture_output=True)
+    finally:
+        try:
+            os.remove(list_file)
+        except OSError:
+            pass
 
 
 def _concat_reencode(clip_paths: list[str], out_path: str,
                      w: int = 1080, h: int = 1920):
-    """Ghép nhiều clip bằng concat filter (re-encode, video-only).
+    """Ghép nhiều clip bằng concat filter (re-encode, video-only) — đường FALLBACK.
 
     Chuẩn hoá MỌI clip về cùng khung WxH bằng scale + pad (giữ tỉ lệ gốc, chèn
-    nền đen phần thừa). Bắt buộc vì filter concat của ffmpeg yêu cầu các input
-    cùng width/height/SAR — clip khác kích thước sẽ làm concat lỗi (mọi biến thể
-    fail -> không ra kết quả). Mặc định khung dọc 1080x1920 (TikTok/Shorts);
-    xào video ngang thì đổi w=1920, h=1080.
+    nền đen phần thừa). Dùng khi concat copy không nối được (hiếm).
     """
     inputs = []
     for p in clip_paths:
@@ -45,6 +154,52 @@ def _concat_reencode(clip_paths: list[str], out_path: str,
         check=True, capture_output=True)
 
 
+def _norm_dir_for(out_dir: str) -> str:
+    """Thư mục cache clip đã chuẩn hoá — đặt cạnh out_dir (cùng phiên, tự dọn theo TTL)."""
+    return os.path.join(os.path.dirname(os.path.abspath(out_dir)), "_norm")
+
+
+def render_variation(clip_paths: list[str], out_path: str, norm_dir: str,
+                     w: int = 1080, h: int = 1920,
+                     audio_path: str | None = None) -> None:
+    """Render 1 biến thể theo đường nhanh: chuẩn hoá 1 lần/clip + concat copy.
+
+    Có audio: ghép video-only ra tmp rồi lồng track (giữ độ dài video). Không
+    audio: concat copy thẳng ra out. Fallback re-encode nếu copy lỗi/hỏng.
+    """
+    try:
+        norm = [normalize_clip(p, norm_dir, w, h) for p in clip_paths]
+        if audio_path:
+            tmp = out_path + ".v.mp4"
+            concat_copy(norm, tmp)
+            try:
+                attach_audio(tmp, audio_path, out_path)
+            finally:
+                try:
+                    os.remove(tmp)
+                except OSError:
+                    pass
+        else:
+            concat_copy(norm, out_path)
+        if _valid_output(out_path):
+            return
+    except subprocess.CalledProcessError:
+        pass
+    # Fallback: re-encode trực tiếp từ clip gốc.
+    if audio_path:
+        tmp = out_path + ".v.mp4"
+        _concat_reencode(clip_paths, tmp, w, h)
+        try:
+            attach_audio(tmp, audio_path, out_path)
+        finally:
+            try:
+                os.remove(tmp)
+            except OSError:
+                pass
+    else:
+        _concat_reencode(clip_paths, out_path, w, h)
+
+
 def attach_audio(video_path: str, audio_path: str, out_path: str):
     """Lồng 1 track âm thanh vào video, GIỮ NGUYÊN độ dài video.
 
@@ -63,21 +218,17 @@ def attach_audio(video_path: str, audio_path: str, out_path: str):
 
 def render_variations(sequences: list[list[int]], clip_map: dict[int, str],
                       out_dir: str, prefix: str = "Variation",
-                      audio_paths: list[str] | None = None) -> list[dict]:
+                      audio_paths: list[str] | None = None,
+                      w: int = 1080, h: int = 1920) -> list[dict]:
     os.makedirs(out_dir, exist_ok=True)
+    norm_dir = _norm_dir_for(out_dir)
     results = []
     for i, seq in enumerate(sequences, 1):
         paths = [clip_map[c] for c in seq]
         name = f"{prefix}_{i:02d}.mp4"
         out = os.path.join(out_dir, name)
-        if audio_paths:
-            tmp = os.path.join(out_dir, f".tmp_{i:02d}.mp4")
-            _concat_reencode(paths, tmp)
-            track = audio_paths[(i - 1) % len(audio_paths)]
-            attach_audio(tmp, track, out)
-            os.remove(tmp)
-        else:
-            _concat_reencode(paths, out)
+        track = audio_paths[(i - 1) % len(audio_paths)] if audio_paths else None
+        render_variation(paths, out, norm_dir, w, h, audio_path=track)
         results.append({
             "name": name, "path": out,
             "sequence": seq, "size": os.path.getsize(out),

backend/requirements.txt

@@ -6,9 +6,12 @@ pydantic>=2.6
 
 # ───────────────────────── Tính toán ────────────────────────
 numpy>=1.26
-opencv-python-headless>=4.9      # cut: scene/highlight/auto detection
+opencv-python-headless>=4.9      # cut: scene/highlight/auto detection + backend cho PySceneDetect
+scenedetect>=0.6.4               # cut scene/auto: PySceneDetect AdaptiveDetector (ngưỡng 3.0, min_len 1.0s)
 imageio-ffmpeg>=0.4.9            # fallback ffmpeg binary nếu hệ thống chưa có
-# cut "auto": chạy ngay bằng thị giác + đổi-màu-vật-giữa (chỉ cần opencv+numpy+ffmpeg).
+# cut "auto"/"scene": ưu tiên PySceneDetect (AdaptiveDetector, threshold=3.0, min_len=1.0s).
+#   Thiếu scenedetect -> tự fallback pipeline thị-giác (opencv+numpy+ffmpeg), không lỗi.
+# cut "auto" (fallback): thị giác + đổi-màu-vật-giữa (chỉ cần opencv+numpy+ffmpeg).
 #   OCR gộp-theo-nội-dung là TÙY CHỌN, cài riêng để tăng độ chính xác nội dung:
 #     pip install rapidocr-onnxruntime
 #   Chưa cài -> auto-cut tự fallback về tách theo chuyển cảnh (không lỗi).

frontend/src/api.js

@@ -21,6 +21,45 @@ async function upload(path, file, fields = {}) {
   return r.json();
 }
 
+// Upload 1 file kèm tiến độ BYTE (fetch không có progress event -> dùng XHR).
+// onProgress(loaded, total) gọi liên tục khi bytes đẩy lên.
+export function uploadWithProgress(path, file, fields = {}, onProgress) {
+  return new Promise((resolve, reject) => {
+    const fd = new FormData();
+    fd.append("file", file);
+    for (const [k, v] of Object.entries(fields)) if (v != null) fd.append(k, v);
+    const xhr = new XMLHttpRequest();
+    xhr.open("POST", BASE + path);
+    if (xhr.upload && onProgress) {
+      xhr.upload.onprogress = (e) => {
+        if (e.lengthComputable) onProgress(e.loaded, e.total);
+      };
+    }
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try { resolve(JSON.parse(xhr.responseText)); }
+        catch { resolve({}); }
+      } else reject(new Error(xhr.responseText || xhr.statusText || `HTTP ${xhr.status}`));
+    };
+    xhr.onerror = () => reject(new Error("Lỗi mạng khi tải lên"));
+    xhr.onabort = () => reject(new Error("Đã huỷ tải lên"));
+    xhr.send(fd);
+  });
+}
+
+// Chạy nhiều tác vụ song song có GIỚI HẠN luồng (mặc định 4) — nhanh hơn tuần tự
+// mà không làm nghẽn trình duyệt (mỗi host chỉ ~6 kết nối đồng thời).
+export async function runPool(count, worker, limit = 4) {
+  let next = 0;
+  const run = async () => {
+    while (next < count) {
+      const i = next++;
+      await worker(i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, count) }, run));
+}
+
 export const fileUrl = (u) => BASE + u;
 
 export const api = {
@@ -50,6 +89,11 @@ export const api = {
     upload("/api/shuffle/upload", file, { segment, session }),
   shuffleUploadAudio: (file, session) =>
     upload("/api/shuffle/upload-audio", file, { session }),
+  // Bản có tiến độ byte (dùng cho loader nhanh + chuẩn khi thả clip/thư mục).
+  shuffleUploadP: (file, segment, session, onProgress) =>
+    uploadWithProgress("/api/shuffle/upload", file, { segment, session }, onProgress),
+  shuffleUploadAudioP: (file, session, onProgress) =>
+    uploadWithProgress("/api/shuffle/upload-audio", file, { session }, onProgress),
   shuffleSegments: (sid) => fetch(BASE + `/api/shuffle/segments/${sid}`).then((r) => r.json()),
   shuffleEstimate: (req) => jpost("/api/shuffle/estimate", req),
   shufflePlan: (req) => jpost("/api/shuffle/plan", req),
@@ -61,6 +105,9 @@ export const api = {
     upload("/api/dub/voice-sample", file, { session }),
   dubVoices: (lang) => fetch(BASE + `/api/dub/voices?lang=${lang}`).then((r) => r.json()),
   dubStart: (req) => jpost("/api/dub/start", req),
+  // 2 pha: dịch trước (xem/sửa) rồi mới tạo giọng
+  dubPrepare: (req) => jpost("/api/dub/prepare", req),
+  dubSynthesize: (req) => jpost("/api/dub/synthesize", req),
   dubTts: (req) => jpost("/api/dub/tts", req),
   // Hard subtitle
   subtitlePlan: (session, srt) => jpost("/api/dub/subtitle/plan", { session, srt }),

frontend/src/pages/CreateVideo.jsx

@@ -100,7 +100,7 @@ export default function CreateVideo() {
           flex: 1, display: "flex", alignItems: "center", justifyContent: "center",
           background: "var(--cream)",
         }}>
-          <div style={{ textAlign: "center", maxWidth: 440 }}>
+          <div style={{ textAlign: "center", maxWidth: 480 }}>
             <div style={{
               width: 64, height: 64, borderRadius: "50%",
               background: "var(--orange-soft)", color: "var(--orange)",
@@ -109,9 +109,31 @@ export default function CreateVideo() {
               <IcVideo size={28} />
             </div>
             <h2 style={{ margin: "0 0 8px", fontSize: 20 }}>Tạo video với AI</h2>
-            <p style={{ color: "var(--ink-2)", fontSize: 14, lineHeight: 1.6, margin: 0 }}>
-              Nhập link Gradio (WanGP) phía trên và kết nối để sử dụng giao diện tạo video gốc.
+            <p style={{ color: "var(--ink-2)", fontSize: 14, lineHeight: 1.6, margin: "0 0 20px" }}>
+              Kết nối tới server WanGP đang chạy để dùng giao diện tạo video gốc ngay trong trang.
             </p>
+            <ol style={{
+              textAlign: "left", margin: "0 auto", padding: 0, listStyle: "none",
+              display: "flex", flexDirection: "column", gap: 12,
+            }}>
+              {[
+                ["Chạy WanGP", "Khởi động công cụ sinh video WanGP và lấy link Gradio công khai của nó (dạng https://xxxx.gradio.live/)."],
+                ["Dán link & Kết nối", "Dán link vào ô phía trên rồi bấm “🔌 Kết nối”. Trạng thái sẽ chuyển sang “Đã kết nối”."],
+                ["Tạo video", "Giao diện WanGP gốc hiện ngay trong trang — nhập prompt và tạo video như bình thường."],
+                ["Ngắt kết nối", "Xong việc bấm “🔌 Ngắt kết nối”. Link được ghi nhớ để lần sau vào lại nhanh."],
+              ].map(([t, d], i) => (
+                <li key={i} style={{ display: "flex", gap: 12, alignItems: "flex-start" }}>
+                  <span style={{
+                    flex: "0 0 24px", width: 24, height: 24, borderRadius: "50%",
+                    background: "var(--orange)", color: "#fff", fontSize: 12, fontWeight: 700,
+                    display: "grid", placeItems: "center", marginTop: 1,
+                  }}>{i + 1}</span>
+                  <span style={{ fontSize: 13, lineHeight: 1.5 }}>
+                    <b>{t}.</b> <span style={{ color: "var(--ink-2)" }}>{d}</span>
+                  </span>
+                </li>
+              ))}
+            </ol>
           </div>
         </div>
       )}

frontend/src/pages/DubVideo.jsx

@@ -10,8 +10,9 @@ import SubtitleEditor from "../components/SubtitleEditor";
 const STEPS = [
   { t: "Tải video", d: "Tải video nguồn cần dịch." },
   { t: "Chọn ngôn ngữ & giọng", d: "Chọn ngôn ngữ đích và giọng đọc (có sẵn hoặc clone)." },
-  { t: "Xử lý & lồng tiếng", d: "Nhận dạng, dịch và lồng giọng vào video." },
-  { t: "Tải video đã dịch", d: "Đầu ra là video đã dịch (kèm audio & phụ đề)." },
+  { t: "Dịch & xem trước", d: "Nhận dạng + dịch, trả câu dịch kèm mốc thời gian." },
+  { t: "Sửa lời & mốc", d: "Kiểm/sửa bản dịch trước khi đọc cho khớp video." },
+  { t: "Tạo giọng & tải về", d: "Đọc lại + ghép vào video (kèm audio & phụ đề)." },
 ];
 
 const LANGS = [
@@ -62,6 +63,7 @@ export default function DubVideo() {
     speakerFile: "", speakerName: "",
     bg: "none", style: "natural", multiSpeaker: false,
     useQuality: false, temperature: 0.8, topK: 25, repPen: 1.2,
+    prepared: [],                    // pha 1: câu dịch + mốc cho user sửa
     outputs: [],
     // khu gen voice từ text
     tts: {
@@ -144,28 +146,68 @@ export default function DubVideo() {
   const qualityPayload = (useQ, temperature, topK, repPen) =>
     useQ ? { temperature, top_k: topK, repetition_penalty: repPen } : {};
 
-  const start = async () => {
+  // PHA 1: dịch + trả câu/mốc để user xem & sửa (chưa đọc)
+  const doPrepare = async () => {
     if (!st.videos.length) return;
-    setBusy(true); set({ outputs: [] });
+    setBusy(true); set({ prepared: [], outputs: [] });
     try {
-      const edge = isEdge(st.target);
-      const src = st.voiceSource;                 // preset | video | upload
-      const doClone = !edge && (src === "video" || src === "upload");
-      const { job_id } = await api.dubStart({
+      const { job_id } = await api.dubPrepare({
         session: st.session, files: st.videos.map((v) => v.file),
         target_lang: st.target, bg_mode: st.bg,
-        do_clone: doClone,
-        voice_source: edge ? "preset" : src,
-        speaker_file: st.speakerFile,
-        preset: edge ? st.voice : (src === "preset" ? st.voice : ""),
-        style: st.style, engine: "auto", multi_speaker: st.multiSpeaker,
-        username: user,
-        ...qualityPayload(!edge && st.useQuality, st.temperature, st.topK, st.repPen),
       });
       const done = await pollJob(job_id, setJob);
       const outs = done.result?.outputs ||
         (done.items || []).filter((i) => i.status === "done").map((i) => i.result);
-      set({ outputs: outs });
+      // cùng ngôn ngữ -> mặc định GIỮ NGUYÊN (không đọc lại), user bỏ tick nếu muốn đọc lại
+      set({ prepared: (outs || []).map((p) => ({ ...p, keep: !!p.same_language })) });
+    } catch (e) { alert("Lỗi: " + e.message); }
+    finally { setBusy(false); }
+  };
+
+  // sửa 1 dòng (text hoặc mốc) trong bản dịch của video thứ pi
+  const setLine = (pi, li, patch) => set((cur) => ({
+    prepared: cur.prepared.map((p, j) => j !== pi ? p
+      : { ...p, lines: p.lines.map((l, k) => k !== li ? l : { ...l, ...patch }) }),
+  }));
+  const setPrep = (pi, patch) => set((cur) => ({
+    prepared: cur.prepared.map((p, j) => j !== pi ? p : { ...p, ...patch }),
+  }));
+
+  // PHA 2: dùng bản dịch (đã sửa) + giọng đã chọn -> TTS + ghép video
+  const doSynthesize = async () => {
+    // các video sẽ ĐỌC LẠI = có state, có lời, và KHÔNG chọn giữ nguyên
+    const editable = st.prepared.filter((p) => p.state && (p.lines || []).length && !p.keep);
+    // các video GIỮ NGUYÊN (cùng ngôn ngữ, user tick giữ) -> dùng luôn video gốc
+    const kept = st.prepared.filter((p) => p.keep && p.video_url).map((p) => ({
+      name: p.name, language: p.language, n_lines: (p.lines || []).length,
+      video_url: p.video_url, audio_url: p.video_url, srt_url: p.srt_url, note: p.note,
+    }));
+    if (!editable.length && !kept.length) return;
+    setBusy(true);
+    try {
+      let synthOuts = [];
+      if (editable.length) {
+        const edge = isEdge(st.target);
+        const src = st.voiceSource;               // preset | video | upload
+        const doClone = !edge && (src === "video" || src === "upload");
+        const { job_id } = await api.dubSynthesize({
+          session: st.session,
+          items: editable.map((p) => ({
+            state: p.state, name: p.name,
+            lines: p.lines.map((l) => ({ start: +l.start, end: +l.end, text: l.text })),
+          })),
+          do_clone: doClone,
+          voice_source: edge ? "preset" : src,
+          speaker_file: st.speakerFile,
+          preset: edge ? st.voice : (src === "preset" ? st.voice : ""),
+          style: st.style, engine: "auto", username: user,
+          ...qualityPayload(!edge && st.useQuality, st.temperature, st.topK, st.repPen),
+        });
+        const done = await pollJob(job_id, setJob);
+        synthOuts = done.result?.outputs ||
+          (done.items || []).filter((i) => i.status === "done").map((i) => i.result);
+      }
+      set({ outputs: [...(synthOuts || []), ...kept] });
     } catch (e) { alert("Lỗi: " + e.message); }
     finally { setBusy(false); }
   };
@@ -251,7 +293,7 @@ export default function DubVideo() {
             <div className="row wrap center">
               <div>
                 <span className="field-label">Ngôn ngữ đích</span>
-                <select value={st.target} onChange={(e) => set({ target: e.target.value })} style={{ width: 160 }}>
+                <select value={st.target} onChange={(e) => set({ target: e.target.value, prepared: [], outputs: [] })} style={{ width: 160 }}>
                   {LANGS.map((l) => <option key={l.id} value={l.id}>{l.label}</option>)}
                 </select>
               </div>
@@ -321,17 +363,77 @@ export default function DubVideo() {
             <div className="mt16">
               <span className="field-label">Xử lý nhạc nền</span>
               <div className="seg-group">
-                {BG.map((b) => <button key={b.id} className={st.bg === b.id ? "active" : ""} onClick={() => set({ bg: b.id })}>{b.label}</button>)}
+                {BG.map((b) => <button key={b.id} className={st.bg === b.id ? "active" : ""} onClick={() => set({ bg: b.id, prepared: [], outputs: [] })}>{b.label}</button>)}
               </div>
             </div>
 
-            <button className="btn primary block mt16" onClick={start} disabled={!st.videos.length || busy}>
-              {busy ? "Đang xử lý..." : <><IcPlay size={16} /> Bắt đầu dịch</>}
+            <button className="btn primary block mt16" onClick={doPrepare} disabled={!st.videos.length || busy}>
+              {busy ? "Đang xử lý..." : <><IcPlay size={16} /> Dịch (xem trước & sửa)</>}
             </button>
           </div>
 
           <ProcessingOverlay busy={busy || ttsBusy} job={job} title="Đang xử lý giọng…" />
 
+          {/* 3. XEM & SỬA bản dịch trước khi đọc (pha giữa) */}
+          {st.prepared.length > 0 && st.outputs.length === 0 && (
+            <div className="card">
+              <div className="panel-title">3. Xem & sửa bản dịch trước khi đọc</div>
+              <p className="small muted" style={{ marginTop: -6 }}>
+                Sửa lời dịch và mốc thời gian (giây) cho khớp, rồi bấm tạo giọng. Câu gốc để tham khảo.
+              </p>
+              <div className="stack mt12">
+                {st.prepared.map((p, pi) => (
+                  <div key={p.name} style={{ border: "1px solid var(--line)", borderRadius: 12, padding: 12 }}>
+                    <div className="flex between center" style={{ marginBottom: 8 }}>
+                      <b className="small">{p.name}</b>
+                      <span className="small muted">{p.same_language ? "cùng ngôn ngữ" : `${(p.lines || []).length} câu · ${p.language || ""}`}</span>
+                    </div>
+                    {!p.state ? (
+                      <div className="small" style={{ color: "var(--orange-700)" }}>⚠ {p.note || "Không xử lý được để sửa."}</div>
+                    ) : (
+                      <div className="stack" style={{ gap: 8 }}>
+                        {p.same_language && (
+                          <div style={{ background: "var(--green-soft)", borderRadius: 8, padding: "8px 10px" }}>
+                            <div className="small" style={{ color: "var(--green)", marginBottom: 6 }}>✅ {p.note}</div>
+                            <label className="small" style={{ display: "flex", alignItems: "center", gap: 6, cursor: "pointer" }}>
+                              <input type="checkbox" checked={!!p.keep} onChange={(e) => setPrep(pi, { keep: e.target.checked })} />
+                              Giữ nguyên video gốc (không đọc lại). Bỏ tick nếu muốn sửa lời & đọc lại bằng giọng đã chọn.
+                            </label>
+                          </div>
+                        )}
+                        {(p.lines || []).map((l, li) => (
+                          <div key={li} style={{ display: "flex", gap: 8, alignItems: "flex-start" }}>
+                            <div style={{ display: "flex", flexDirection: "column", gap: 4, width: 78, flexShrink: 0 }}>
+                              <input type="number" step="0.1" min="0" className="sm" value={Number(l.start).toFixed(1)}
+                                     title="Bắt đầu (giây)"
+                                     onChange={(e) => setLine(pi, li, { start: +e.target.value })}
+                                     style={{ width: 74, padding: "4px 6px", fontSize: 12 }} />
+                              <input type="number" step="0.1" min="0" className="sm" value={Number(l.end).toFixed(1)}
+                                     title="Kết thúc (giây)"
+                                     onChange={(e) => setLine(pi, li, { end: +e.target.value })}
+                                     style={{ width: 74, padding: "4px 6px", fontSize: 12 }} />
+                            </div>
+                            <div style={{ flex: 1, minWidth: 0 }}>
+                              {l.src && <div className="small muted" title="Câu gốc" style={{ marginBottom: 2, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" }}>↳ {l.src}</div>}
+                              <textarea value={l.text} onChange={(e) => setLine(pi, li, { text: e.target.value })}
+                                        style={{ width: "100%", minHeight: 40, fontSize: 13 }} />
+                            </div>
+                          </div>
+                        ))}
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+              <div className="flex gap8 mt16" style={{ flexWrap: "wrap" }}>
+                <button className="btn primary" onClick={doSynthesize} disabled={busy}>
+                  {busy ? "Đang tạo giọng..." : <><IcMic size={16} /> Tạo giọng & ghép video</>}
+                </button>
+                <button className="btn sm" onClick={() => set({ prepared: [] })} disabled={busy}>Dịch lại</button>
+              </div>
+            </div>
+          )}
+
           {/* kết quả */}
           {st.outputs.length > 0 && (
             <div className="card">

frontend/src/pages/Guide.jsx

@@ -1,4 +1,4 @@
-import { IcDownload, IcScissors, IcShuffle, IcMic } from "../components/Icons";
+import { IcDownload, IcScissors, IcShuffle, IcMic, IcImage, IcStar, IcVideo } from "../components/Icons";
 
 const guides = [
   {
@@ -12,6 +12,40 @@ const guides = [
       "Có thể chuyển thẳng từng video sang tool Cut hoặc Dịch/đổi giọng bằng nút bên cạnh.",
     ],
   },
+  {
+    icon: IcImage,
+    title: "Listing ảnh (OpenAI)",
+    steps: [
+      "Tải ảnh sản phẩm (bắt buộc) — chụp chính diện, đủ sáng, rõ nhãn mác. Tuỳ chọn thêm ảnh người mẫu và ảnh bối cảnh để AI dùng đúng gương mặt / khung cảnh cho các ảnh có người.",
+      "Nhập API Key OpenAI của bạn: GPT Vision Key (phân tích ảnh + sinh prompt) và Image Gen Key (sinh ảnh — để trống nếu dùng chung một key). Key được lưu sẵn trên trình duyệt cho lần sau.",
+      "Chọn số lượng ảnh (1–9), ngôn ngữ prompt, và các loại ảnh muốn tạo: Ảnh bìa, Chi tiết SP, Trưng bày, Sử dụng, Mở hộp, Nỗi phiền lo, Trước & Sau, Phong cách sống, Tính năng.",
+      "Bấm “Phân tích & Tạo Prompt”, có thể dán thêm thông tin sản phẩm để prompt chính xác hơn, rồi “Xác nhận & Phân tích”. GPT-4o phân tích và tự sinh ảnh bằng gpt-image-2. AI GIỮ NGUYÊN thiết kế, màu sắc, chữ trên nhãn.",
+      "Ở mỗi ảnh kết quả: bấm 📄 để xem/sửa prompt rồi tạo lại; bấm ✏️ để yêu cầu chỉnh sửa (kèm ảnh tham chiếu nếu cần) mà vẫn giữ nguyên mẫu mã. Bấm vào ảnh để phóng to.",
+      "Bấm “Tải tất cả về” để lấy file zip, hoặc “Làm mới” để bắt đầu lại.",
+    ],
+  },
+  {
+    icon: IcStar,
+    title: "Listing ảnh Free (Flux / Wangp)",
+    steps: [
+      "Dán link Gradio của server Flux/Wangp bạn đang chạy rồi bấm “Connect” để kiểm tra kết nối. Link được lưu sẵn trên trình duyệt. Đây là cách sinh ảnh miễn phí (không tốn phí OpenAI), nhưng cần server Flux/Wangp đang chạy.",
+      "Tải ảnh sản phẩm (bắt buộc), tuỳ chọn thêm ảnh nền và ảnh người mẫu, rồi bấm “Upload & Start”.",
+      "Chọn số lượng ảnh và chế độ: Manual — tự viết prompt mô tả bối cảnh cho từng ảnh; Auto (GPT) — nhập OpenAI key để GPT-4o tự sinh prompt.",
+      "Tinh chỉnh cấu hình: Model (Flux2 Klein 9B/4B, Flux 1.1 Pro, Flux Schnell), độ phân giải, Steps, Guidance, Ref Strength và Negative Prompt.",
+      "Bấm “Generate” — Flux/Wangp tạo nền theo prompt rồi hệ thống phủ chữ thiết kế lên ảnh.",
+      "Bấm “Download all” để lấy file zip, hoặc “Reset” để làm lại.",
+    ],
+  },
+  {
+    icon: IcVideo,
+    title: "Tạo video",
+    steps: [
+      "Chạy WanGP (công cụ sinh video) và lấy link Gradio công khai của nó (dạng https://xxxx.gradio.live/).",
+      "Dán link vào ô phía trên rồi bấm “🔌 Kết nối”. Trạng thái sẽ chuyển sang “Đã kết nối”.",
+      "Sau khi kết nối, giao diện WanGP gốc hiện ngay trong trang để bạn nhập prompt và tạo video.",
+      "Khi dùng xong bấm “🔌 Ngắt kết nối”. Link kết nối được ghi nhớ để lần sau vào lại nhanh.",
+    ],
+  },
   {
     icon: IcScissors,
     title: "Cut video",

frontend/src/pages/ListingFree.jsx

@@ -443,14 +443,14 @@ export default function ListingFree() {
         </div>
 
         <div className="rail">
-          <div className="rail-title">How it works</div>
-          <div className="rail-step"><div className="num">1</div><div className="body"><div className="t">Gradio URL</div><div className="d">Paste your Flux/Wangp Space URL (saved automatically)</div></div></div>
-          <div className="rail-step"><div className="num">2</div><div className="body"><div className="t">Upload image</div><div className="d">Single product image</div></div></div>
-          <div className="rail-step"><div className="num">3</div><div className="body"><div className="t">Choose mode</div><div className="d">Manual: write your own scene prompts. Auto: GPT-4o generates them.</div></div></div>
-          <div className="rail-step"><div className="num">4</div><div className="body"><div className="t">Configure</div><div className="d">Model, resolution, steps, guidance, ref strength, negative prompt</div></div></div>
-          <div className="rail-step"><div className="num">5</div><div className="body"><div className="t">Generate</div><div className="d">Flux/Wangp creates backgrounds → Pillow overlays text design</div></div></div>
-          <div className="rail-step"><div className="num">6</div><div className="body"><div className="t">Download</div><div className="d">All images as zip file</div></div></div>
-          <div className="tip"><b>Tip:</b> OpenAI key is saved in browser. Gradio URL is also saved. Set once, use many times.</div>
+          <div className="rail-title">Hướng dẫn sử dụng</div>
+          <div className="rail-step"><div className="num">1</div><div className="body"><div className="t">Kết nối Gradio</div><div className="d">Dán link server Flux/Wangp bạn đang chạy rồi bấm Connect để kiểm tra. Link được lưu sẵn trên trình duyệt.</div></div></div>
+          <div className="rail-step"><div className="num">2</div><div className="body"><div className="t">Tải ảnh</div><div className="d">Ảnh sản phẩm bắt buộc; ảnh nền và ảnh người mẫu là tuỳ chọn. Rồi bấm “Upload &amp; Start”.</div></div></div>
+          <div className="rail-step"><div className="num">3</div><div className="body"><div className="t">Chọn chế độ</div><div className="d">Manual: tự viết prompt mô tả bối cảnh. Auto (GPT): nhập OpenAI key để GPT-4o tự sinh prompt.</div></div></div>
+          <div className="rail-step"><div className="num">4</div><div className="body"><div className="t">Cấu hình</div><div className="d">Model, độ phân giải, Steps, Guidance, Ref Strength và Negative Prompt.</div></div></div>
+          <div className="rail-step"><div className="num">5</div><div className="body"><div className="t">Sinh ảnh</div><div className="d">Flux/Wangp tạo nền theo prompt rồi hệ thống phủ chữ thiết kế lên ảnh.</div></div></div>
+          <div className="rail-step"><div className="num">6</div><div className="body"><div className="t">Tải về</div><div className="d">Bấm “Download all” để lấy toàn bộ ảnh dạng file zip.</div></div></div>
+          <div className="tip"><b>Mẹo:</b> Đây là cách sinh ảnh miễn phí (không tốn phí OpenAI) nhưng cần server Flux/Wangp đang chạy. OpenAI key và link Gradio đều được lưu trên trình duyệt — cài một lần, dùng nhiều lần.</div>
         </div>
       </div>
     </div>

frontend/src/pages/ListingImage.jsx

@@ -5,9 +5,12 @@ import { useAuth } from "../stores/authStore";
 import { IcImage, IcUpload, IcDownload, IcRefresh } from "../components/Icons";
 
 const STEPS = [
-  { t: "Tải ảnh sản phẩm", d: "Chọn ảnh sản phẩm để phân tích." },
-  { t: "Tạo Prompt & Sinh ảnh", d: "GPT-4o phân tích và tự động sinh ảnh với gpt-image-2." },
-  { t: "Kết quả", d: "Tải ảnh đã tạo + text Shopee." },
+  { t: "Tải ảnh", d: "Ảnh sản phẩm là bắt buộc — chụp chính diện, đủ sáng, rõ nhãn. Thêm ảnh người mẫu / bối cảnh nếu muốn AI dùng đúng gương mặt và khung cảnh." },
+  { t: "Nhập API Key", d: "GPT Vision Key để phân tích + sinh prompt, Image Gen Key để sinh ảnh (để trống nếu dùng chung một key). Key lưu sẵn trên trình duyệt." },
+  { t: "Cấu hình", d: "Chọn số lượng ảnh, ngôn ngữ prompt và các loại ảnh (bìa, chi tiết, trưng bày, sử dụng, lifestyle…)." },
+  { t: "Phân tích & Sinh ảnh", d: "GPT-4o phân tích, tạo prompt rồi tự sinh ảnh bằng gpt-image-2 — giữ nguyên thiết kế, màu sắc, chữ trên nhãn." },
+  { t: "Chỉnh sửa", d: "📄 xem/sửa prompt rồi tạo lại · ✏️ yêu cầu chỉnh sửa (kèm ảnh tham chiếu) vẫn giữ mẫu mã · bấm ảnh để phóng to." },
+  { t: "Tải kết quả", d: "Bấm “Tải tất cả về” để lấy file zip, hoặc “Làm mới” để bắt đầu lại." },
 ];
 
 const PROMPT_TYPES = [
@@ -569,7 +572,7 @@ export default function ListingImage() {
           )}
         </div>
 
-        <ProcessRail steps={STEPS} />
+        <ProcessRail steps={STEPS} tip="Ảnh sản phẩm càng rõ nét, đủ sáng thì AI càng giữ đúng nhãn mác và màu sắc. Muốn sinh ảnh miễn phí (không tốn phí OpenAI)? Dùng tab “Listing ảnh Free” với server Flux/Wangp của bạn." />
       </div>
 
       {lightboxUrl && (

frontend/src/pages/ShuffleVideo.jsx

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import { useSearchParams } from "react-router-dom";
-import { api, pollJob, fileUrl } from "../api";
+import { api, pollJob, fileUrl, runPool } from "../api";
 import { useToolState } from "../store";
 import { useAuth } from "../stores/authStore";
 import { ProcessRail, FileDrop, ProcessingOverlay, CacheNote } from "../components/ui";
@@ -39,7 +39,9 @@ export default function ShuffleVideo() {
   const setJob = (j) => set({ job: j });
   const setBusy = (b) => set({ busy: b });
   const [showNote, setShowNote] = useState(true);
-  const [uploading, setUploading] = useState(null); // {name,i,n,seg} — clip đang tải lên
+  // Loader tải lên: {seg, done, total, pct, name} — pct tính theo BYTE (chuẩn),
+  // upload SONG SONG nên nhanh; seg = index khúc hoặc "audio".
+  const [uploading, setUploading] = useState(null);
 
   const segs = st.segs;
 
@@ -83,45 +85,64 @@ export default function ShuffleVideo() {
     set({ segs: next, plan: [] });
   };
 
-  const addToSeg = (idx) => async (files) => {
+  // Upload SONG SONG (4 luồng) + tiến độ byte gộp -> loader nhanh & chuẩn.
+  // one(i): tải file thứ i, cập nhật bytes đã tải; paint(): vẽ lại loader.
+  const uploadMany = async (arr, upFn, segKey) => {
     let sid = st.session;
-    const added = [];
-    const arr = Array.from(files);
-    for (let i = 0; i < arr.length; i++) {
-      const file = arr[i];
-      setUploading({ name: file.name, i: i + 1, n: arr.length, seg: idx });
+    const totalBytes = arr.reduce((a, f) => a + (f.size || 0), 0) || 1;
+    const loaded = new Array(arr.length).fill(0);
+    const added = new Array(arr.length);
+    let done = 0;
+    const paint = () => {
+      const lb = loaded.reduce((a, b) => a + b, 0);
+      setUploading({
+        seg: segKey, done, total: arr.length,
+        pct: Math.min(100, Math.round((lb / totalBytes) * 100)),
+        name: arr[Math.min(done, arr.length - 1)]?.name || "",
+      });
+    };
+    const one = async (i) => {
       try {
-        const r = await api.shuffleUpload(file, idx, sid);
-        sid = r.session;
-        added.push({ file: r.file, name: r.name, size: r.size, url: r.url });
-      } catch (e) { alert("Lỗi tải clip: " + e.message); }
-    }
+        const r = await upFn(arr[i], sid, (l) => { loaded[i] = l; paint(); });
+        sid = r.session || sid;
+        added[i] = { file: r.file, name: r.name, size: r.size, url: r.url };
+      } catch (e) { console.error("Tải lỗi:", arr[i]?.name, e); }
+      loaded[i] = arr[i].size || 0; done++; paint();
+    };
+    paint();
+    // File đầu chạy TRƯỚC để khoá session; các file sau chia 4 luồng dùng chung session.
+    let start = 0;
+    if (!sid) { await one(0); start = 1; }
+    const limit = sid ? 4 : 1;   // nếu file đầu lỗi (chưa có session) -> tuần tự cho an toàn
+    await runPool(arr.length - start, (k) => one(start + k), limit);
     setUploading(null);
+    const ok = added.filter(Boolean);
+    const failed = arr.length - ok.length;
+    if (failed) alert(`Có ${failed}/${arr.length} tệp tải lỗi (đã bỏ qua).`);
+    return { sid, ok };
+  };
+
+  const addToSeg = (idx) => async (files) => {
+    const arr = Array.from(files);
+    if (!arr.length) return;
+    const { sid, ok } = await uploadMany(
+      arr, (file, sid, onP) => api.shuffleUploadP(file, idx, sid, onP), idx);
     set((cur) => {
       const n = cur.segs.map((s) => ({ ...s, files: [...s.files] }));
-      n[idx].files.push(...added);
+      n[idx].files.push(...ok);
       return { session: sid, segs: n };
     });
   };
 
   const addAudio = async (files) => {
-    let sid = st.session;
-    if (!sid) { // cần session trước -> tạo bằng cách upload clip rỗng? thay vào dùng audio tạo session
-      // upload audio sẽ cần session; nếu chưa có, tải clip trước. Ở đây yêu cầu có clip trước.
+    if (!st.session) {
       return alert("Hãy thêm clip vào khúc trước để khởi tạo phiên, rồi thêm âm thanh.");
     }
-    const added = [];
     const arr = Array.from(files);
-    for (let i = 0; i < arr.length; i++) {
-      const file = arr[i];
-      setUploading({ name: file.name, i: i + 1, n: arr.length, seg: "audio" });
-      try {
-        const r = await api.shuffleUploadAudio(file, sid);
-        added.push({ file: r.file, name: r.name, size: r.size, url: r.url });
-      } catch (e) { alert("Lỗi tải âm thanh: " + e.message); }
-    }
-    setUploading(null);
-    set((cur) => ({ audio: [...cur.audio, ...added] }));
+    if (!arr.length) return;
+    const { ok } = await uploadMany(
+      arr, (file, sid, onP) => api.shuffleUploadAudioP(file, sid, onP), "audio");
+    set((cur) => ({ audio: [...cur.audio, ...ok] }));
   };
 
   const removeClip = (si, fi) => set((cur) => {
@@ -251,8 +272,14 @@ export default function ShuffleVideo() {
                 ) : (
                   <>
                   {uploading?.seg === si && (
-                    <div className="small" style={{ color: "var(--orange-700)", marginBottom: 6 }}>
-                      ⏳ Đang tải lên: <b>{uploading.name}</b> ({uploading.i}/{uploading.n})…
+                    <div className="upload-loader" style={{ marginBottom: 8 }}>
+                      <div className="small flex between" style={{ marginBottom: 4 }}>
+                        <span style={{ color: "var(--orange-700)" }}>
+                          ⏳ Đang tải {uploading.done}/{uploading.total} clip · {uploading.pct}%
+                        </span>
+                        <span className="muted" style={{ maxWidth: 200, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>{uploading.name}</span>
+                      </div>
+                      <div className="progress"><i style={{ width: uploading.pct + "%" }} /></div>
                     </div>
                   )}
                   <div className="clip-row">
@@ -283,8 +310,11 @@ export default function ShuffleVideo() {
                 <FileDrop compact accept="audio/*" onFiles={addAudio} title="Thả âm thanh" hint="MP3, WAV, M4A" />
               </div>
               {uploading?.seg === "audio" && (
-                <div className="small" style={{ color: "var(--orange-700)", alignSelf: "center" }}>
-                  ⏳ Đang tải lên: <b>{uploading.name}</b> ({uploading.i}/{uploading.n})…
+                <div className="upload-loader" style={{ alignSelf: "center", minWidth: 220 }}>
+                  <div className="small" style={{ color: "var(--orange-700)", marginBottom: 4 }}>
+                    ⏳ Đang tải {uploading.done}/{uploading.total} · {uploading.pct}%
+                  </div>
+                  <div className="progress"><i style={{ width: uploading.pct + "%" }} /></div>
                 </div>
               )}
               {st.audio.map((a, ai) => (