fix(cut): cắt 2+ video không còn 500; tách khúc tự động nhanh gấp ~3 lần

Lỗi: thả nhiều video một lượt lúc chưa có video nào -> `cur` là biến chụp
lúc render nên mọi lần upload đều gửi session rỗng -> backend tạo mỗi video
một phiên riêng. Lúc cắt, FE chỉ gửi phiên của video đầu nên video thứ 2 trở
đi không tìm thấy file, ffprobe chết, cả request 500 "Internal Server Error".
Một video thì không bao giờ dính.

Sửa lỗi:
- FE giữ sid chạy theo vòng lặp upload -> mọi video vào cùng một phiên; và
gửi kèm session của TỪNG video khi cắt để các phiên cũ đã lỡ tách vẫn chạy.
- resolve_src() chặn thoát thư mục phiên; probe() báo lý do đọc được thay vì
CalledProcessError trống trơn.
- execute-batch đưa việc nặng vào job: 1 video hỏng chỉ hỏng phần của nó,
hỏng hết thì job báo lỗi thật.
- Khúc end <= start trước đây bị ffmpeg nuốt im lặng (-frames:v âm = không
giới hạn) và xuất ra clip dài tới hết video -> nay chặn.
- alert hiện `detail` thay vì nguyên cục JSON.

Tăng tốc (đo thật, video QC 1080x1920 30s):
- Tách khúc tự động 11.9s -> 3.9s/video. PySceneDetect đọc bằng OpenCV một
luồng ở độ phân giải gốc; nay dựng bản 360p bằng ffmpeg rồi dò trên đó,
điểm cắt ra y hệt (có test). Gộp luôn thumbnail + bản nhỏ vào 1 lượt ffmpeg.
- FE tách khúc 2 video song song.
- zip clip: DEFLATE -> STORED, nhanh 11x, kích thước y nguyên (mp4 đã nén).
- ffprobe nhiều video chạy song song; /execute-batch trả về ngay.
- Cắt khúc chạy song song (+11%). Khâu này là mã hoá x264 (86% thời gian) nên
gần chạm trần; đã thử gộp mọi khúc vào 1 lượt ffmpeg nhưng chậm hơn -> bỏ.

105/105 test PASS (thêm 10 test).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@

backend/app/api/cut.py

@@ -9,8 +9,9 @@ Luồng FE:
 from __future__ import annotations
 
 import os
+import threading
 
-from fastapi import APIRouter, File, Form, UploadFile
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
 from pydantic import BaseModel
 
 from ..core.files import new_session, rel_path, save_upload_stream, session_dir, sub_dir
@@ -18,18 +19,41 @@ from ..core.jobs import jobs, submit_for_session
 from ..config import settings
 from ..services.cutter import cut as cutter
 from ..services.cutter import modes
-from ..services.cutter.probe import probe
+from ..services.cutter.probe import ProbeError, probe
 from ..services.history.auto_save import auto_save_result
 
 router = APIRouter(prefix="/api/cut", tags=["cut"])
 
 
+def resolve_src(sid: str, rel: str) -> str:
+    """Đường dẫn THẬT của video trong phiên, chặn thoát ra ngoài thư mục phiên.
+
+    Trước đây chỉ os.path.join rồi đưa thẳng cho ffprobe: file không tồn tại
+    (phiên hết hạn bị dọn, hoặc video được tải lên ở PHIÊN KHÁC) thì ffprobe
+    chết và cả request 500 kèm traceback — không ai hiểu chuyện gì.
+    """
+    base = os.path.abspath(session_dir(sid or ""))
+    clean = (rel or "").replace("\\", "/").strip("/")
+    full = os.path.abspath(os.path.join(base, *[p for p in clean.split("/") if p not in ("", ".", "..")]))
+    if not full.startswith(base):
+        raise HTTPException(400, f"Đường dẫn video không hợp lệ: {rel}")
+    return full
+
+
+def probe_or_400(path: str):
+    """probe() nhưng lỗi đọc file -> 400 kèm lời giải thích, KHÔNG phải 500."""
+    try:
+        return probe(path)
+    except ProbeError as e:
+        raise HTTPException(400, str(e))
+
+
 @router.post("/upload")
 def upload(file: UploadFile = File(...), session: str = Form(None)):
     sid = session or new_session("cut")
     path = save_upload_stream(sid, file.filename, file.file, folder="inputs",
                               max_mb=settings.MAX_UPLOAD_MB)
-    info = probe(path)
+    info = probe_or_400(path)
     return {
         "session": sid,
         "file": rel_path(path, sid),
@@ -51,7 +75,7 @@ class SplitAudioReq(BaseModel):
 @router.post("/split-audio")
 def split_audio(req: SplitAudioReq):
     """Tách 1 video -> VIDEO KHÔNG LỜI (mp4) + ÂM THANH (mp3), cho user tải cái nào tuỳ ý."""
-    src = os.path.join(session_dir(req.session), req.file)
+    src = resolve_src(req.session, req.file)
     job = jobs.create("cut")
     _username = req.username
 
@@ -107,16 +131,20 @@ class PreviewReq(BaseModel):
 @router.post("/preview")
 def preview(req: PreviewReq):
     import hashlib
-    src = os.path.join(session_dir(req.session), req.file)
-    info = probe(src)
-    segs = modes.build_segments(
-        info, req.mode, n=req.count, threshold=req.threshold, min_len=req.min_len,
-        sensitivity=req.sensitivity, top_ratio=req.top_ratio)
+    src = resolve_src(req.session, req.file)
+    info = probe_or_400(src)
     # 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...).
     vkey = hashlib.md5(req.file.encode("utf-8")).hexdigest()[:8]
-    thumbs = cutter.thumbnail_strip(
-        info, sub_dir(req.session, "thumbs", vkey), count=req.thumbnails)
+    tdir = sub_dir(req.session, "thumbs", vkey)
+    # MỘT lượt ffmpeg ra cả dải thumbnail lẫn bản nhỏ; dò chuyển cảnh trên bản
+    # nhỏ nhanh gấp ~3 lần mà điểm cắt không đổi.
+    thumbs, proxy = cutter.preview_pass(
+        info, tdir, os.path.join(tdir, "proxy.mp4"), count=req.thumbnails)
+    segs = modes.build_segments(
+        cutter.detect_info(info, proxy) if proxy else info,
+        req.mode, n=req.count, threshold=req.threshold, min_len=req.min_len,
+        sensitivity=req.sensitivity, top_ratio=req.top_ratio)
     rel_thumbs = [{"time": t["time"],
                    "url": f"/api/files/{req.session}/thumbs/{vkey}/{os.path.basename(t['path'])}"}
                   for t in thumbs]
@@ -142,45 +170,63 @@ class ExecuteReq(BaseModel):
     count: int | None = None
 
 
-def _plan_segments(info, item):
+def _plan_segments(info, item, proxy_dir: str = ""):
     """Dựng danh sách Segment từ điểm cắt của UI (nếu có), LỌC khúc lỗi
     (end<=start / vượt biên) để 1 điểm cắt sai không làm hỏng cả job.
-    Không còn khúc hợp lệ -> tự cắt auto."""
+    Không còn khúc hợp lệ -> tự cắt auto.
+
+    `proxy_dir`: nơi để bản nhỏ dò chuyển cảnh — chỉ dùng khi phải tự tách khúc.
+    """
     if item.segments:
         raw = [(s.start_frame, s.end_frame) for s in item.segments]
         valid = [(a, b) for a, b in raw if 0 <= a < b <= info.nb_frames]
         if valid:
             return [modes.Segment(i, a, b, info.fps) for i, (a, b) in enumerate(valid)]
-    return modes.build_segments(info, item.mode or "auto", n=item.count)
+    det = info
+    if proxy_dir:
+        import hashlib
+        key = hashlib.md5(info.path.encode("utf-8")).hexdigest()[:8]
+        proxy = cutter.build_proxy(info, os.path.join(proxy_dir, f"proxy_{key}.mp4"))
+        if proxy:
+            det = cutter.detect_info(info, proxy)
+    return modes.build_segments(det, item.mode or "auto", n=item.count)
 
 
 @router.post("/execute")
 def execute(req: ExecuteReq):
-    src = os.path.join(session_dir(req.session), req.file)
-    info = probe(src)
-    segs = _plan_segments(info, req)
+    src = resolve_src(req.session, req.file)
+    info = probe_or_400(src)
+    segs = _plan_segments(info, req, proxy_dir=sub_dir(req.session, "proxy"))
 
     job = jobs.create("cut")
 
     def work(h):
         out_dir = sub_dir(req.session, "clips")
-        results = []
         n = len(segs)
-        for i, seg in enumerate(segs):
-            it = h.add_item(f"clip_{i+1:03d}")
-            try:
-                name = f"clip_{seg.index + 1:03d}.mp4"
-                r = cutter.cut_segment(src, seg, os.path.join(out_dir, name))
-                results.append(r)
-                h.item_status(it, "done", detail=f"{r.duration}s", result={
-                    "name": name, "duration": r.duration, "size": r.size,
-                    "url": f"/api/files/{req.session}/clips/{name}"})
-            except Exception as e:
-                h.item_status(it, "error", error=str(e))
-            h.set_progress((i + 1) / max(1, n))
+        names = [f"clip_{seg.index + 1:03d}.mp4" for seg in segs]
+        its = [h.add_item(nm[:-4]) for nm in names]
+        results: list = [None] * n
+        done = {"n": 0}
+        lock = threading.Lock()          # on_done chạy từ nhiều luồng cắt
+
+        def on_done(i, r, err):
+            if r is not None:
+                results[i] = r
+                h.item_status(its[i], "done", detail=f"{r.duration}s", result={
+                    "name": names[i], "duration": r.duration, "size": r.size,
+                    "url": f"/api/files/{req.session}/clips/{names[i]}"})
+            else:
+                h.item_status(its[i], "error", error=str(err))
+            with lock:
+                done["n"] += 1
+                h.set_progress(done["n"] / max(1, n))
+
+        cutter.cut_segments(src, segs, [os.path.join(out_dir, nm) for nm in names],
+                            on_done=on_done)
+        ok = [r for r in results if r]
         zp = os.path.join(session_dir(req.session), "clips.zip")
-        cutter.zip_clips(results, zp)
-        return {"session": req.session, "clips": len(results),
+        cutter.zip_clips(ok, zp)
+        return {"session": req.session, "clips": len(ok),
                 "zip": "clips.zip"}
 
     submit_for_session(job, work, req.session)
@@ -190,6 +236,10 @@ def execute(req: ExecuteReq):
 
 class BatchItem(BaseModel):
     file: str
+    # Phiên CHỨA file này. Bình thường trùng phiên chung, nhưng khi người dùng
+    # thả nhiều video một lượt thì trước đây mỗi video có thể rơi vào một phiên
+    # khác nhau -> nhận cả phiên riêng để vẫn cắt được thay vì 500.
+    session: str = ""
     segments: list[CutPoint] | None = None
     mode: str = "auto"           # mặc định: cắt tự động theo nội dung (thị giác 3 tầng)
     count: int | None = None
@@ -206,57 +256,113 @@ def execute_batch(req: ExecuteBatchReq):
     """Cắt NHIỀU video cùng lúc trong một phiên -> 1 danh sách clip gộp.
 
     Tên clip có tiền tố theo video để không đè nhau: v{vi}_clip_{i}.mp4.
+
+    Mọi việc nặng (ffprobe, tách khúc, cắt) chạy TRONG JOB: request trả ngay,
+    và 1 video hỏng chỉ hỏng phần của nó chứ không giết cả mẻ.
     """
-    plans = []
-    for vi, item in enumerate(req.videos):
-        src = os.path.join(session_dir(req.session), item.file)
-        info = probe(src)
-        segs = _plan_segments(info, item)
-        plans.append((vi, item.file, src, segs))
+    if not req.videos:
+        raise HTTPException(400, "Chưa có video nào để cắt.")
+    # Chỉ kiểm đường dẫn (rẻ, chặn thoát thư mục); đọc file để trong job.
+    srcs = [resolve_src(v.session or req.session, v.file) for v in req.videos]
 
     job = jobs.create("cut")
+    _username = req.username
 
     def work(h):
+        from concurrent.futures import ThreadPoolExecutor
+
         out_dir = sub_dir(req.session, "clips")
-        groups = []                                   # gom kết quả theo TỪNG video
-        total = sum(len(p[3]) for p in plans) or 1
-        done = 0
-        for vi, fname, src, segs in plans:
-            base = os.path.splitext(os.path.basename(fname))[0]
-            clips = []
-            for i, seg in enumerate(segs):
-                it = h.add_item(f"v{vi+1}_clip_{i+1:03d}")
-                try:
-                    name = f"v{vi+1}_clip_{i+1:03d}.mp4"
-                    r = cutter.cut_segment(src, seg, os.path.join(out_dir, name))
-                    clip = {"name": name, "duration": r.duration, "size": r.size,
-                            "video": base,
-                            "url": f"/api/files/{req.session}/clips/{name}"}
-                    clips.append(clip)
-                    h.item_status(it, "done", detail=f"{r.duration}s", result=clip)
-                except Exception as e:
-                    h.item_status(it, "error", error=str(e))
-                done += 1
-                h.set_progress(done / total)
-            groups.append({"video": base, "file": fname, "clips": clips})
+        n_vid = len(req.videos)
+
+        # ── 1) Đọc metadata SONG SONG (ffprobe nhẹ, chờ I/O là chính) ────────
+        infos: list = [None] * n_vid
+        errors: list = [None] * n_vid
+
+        def read_info(vi: int):
+            try:
+                infos[vi] = probe(srcs[vi])
+            except Exception as e:
+                errors[vi] = str(e)
+
+        with ThreadPoolExecutor(max_workers=min(4, n_vid)) as ex:
+            list(ex.map(read_info, range(n_vid)))
+
+        # ── 2) Dựng điểm cắt (mode auto phải quét hình -> chạy tuần tự) ──────
+        plans: list = [None] * n_vid
+        for vi in range(n_vid):
+            if infos[vi] is None:
+                continue
+            try:
+                plans[vi] = _plan_segments(infos[vi], req.videos[vi],
+                                           proxy_dir=sub_dir(req.session, "proxy"))
+            except Exception as e:
+                errors[vi] = f"Không tách được khúc: {e}"
+
+        total = sum(len(p) for p in plans if p) or 1
+        done = {"n": 0}
+        lock = threading.Lock()          # on_done chạy từ nhiều luồng cắt
+
+        # ── 3) Cắt từng video ────────────────────────────────────────────────
+        groups = []
+        for vi, item in enumerate(req.videos):
+            base = os.path.splitext(os.path.basename(item.file))[0]
+            if errors[vi] or not plans[vi]:
+                msg = errors[vi] or "Không có khúc nào để cắt."
+                h.item_status(h.add_item(base), "error", error=msg)
+                groups.append({"video": base, "file": item.file, "clips": [], "error": msg})
+                continue
+            segs = plans[vi]
+            names = [f"v{vi+1}_clip_{i+1:03d}.mp4" for i in range(len(segs))]
+            its = [h.add_item(nm[:-4]) for nm in names]
+            clips: list = [None] * len(segs)
+
+            def on_done(i, r, err, _vi=vi, _names=names, _its=its, _clips=clips, _base=base):
+                if r is not None:
+                    clip = {"name": _names[i], "duration": r.duration, "size": r.size,
+                            "video": _base,
+                            "url": f"/api/files/{req.session}/clips/{_names[i]}"}
+                    _clips[i] = clip
+                    h.item_status(_its[i], "done", detail=f"{r.duration}s", result=clip)
+                else:
+                    h.item_status(_its[i], "error", error=str(err))
+                with lock:
+                    done["n"] += 1
+                    h.set_progress(done["n"] / total)
+
+            cutter.cut_segments(
+                srcs[vi], segs, [os.path.join(out_dir, nm) for nm in names],
+                on_done=on_done)
+            ok = [c for c in clips if c]
+            group = {"video": base, "file": item.file, "clips": ok}
+            if len(ok) < len(segs):
+                group["error"] = f"{len(segs) - len(ok)}/{len(segs)} khúc cắt lỗi."
+            groups.append(group)
+
         total_clips = sum(len(g["clips"]) for g in groups)
+        if not total_clips:
+            raise RuntimeError(
+                next((g["error"] for g in groups if g.get("error")), "Không cắt được khúc nào."))
+
+        # Gói 1 file zip cho cả mẻ (lưu trữ, không nén — mp4 nén thêm chẳng lợi).
+        zp = os.path.join(session_dir(req.session), "clips.zip")
+        try:
+            cutter.zip_paths_stored(
+                [os.path.join(out_dir, c["name"]) for g in groups for c in g["clips"]], zp)
+        except Exception:
+            zp = ""
+
         if _username:
-            files = []
-            for g in groups:
-                for clip in g["clips"]:
-                    cp = os.path.join(session_dir(req.session), "clips", clip["name"])
-                    if os.path.exists(cp):
-                        files.append({"path": cp, "name": clip["name"]})
-            zp = os.path.join(session_dir(req.session), "clips.zip")
-            if os.path.exists(zp):
+            files = [{"path": os.path.join(out_dir, c["name"]), "name": c["name"]}
+                     for g in groups for c in g["clips"]]
+            if zp and os.path.exists(zp):
                 files.append({"path": zp, "name": "clips.zip"})
             auto_save_result(_username, "cut", req.session, files,
                              title=f"Cắt {total_clips} clip từ {len(groups)} video",
                              summary=f"{total_clips} clip · {len(groups)} video")
 
-        return {"session": req.session, "clips": total_clips, "videos": groups}
+        return {"session": req.session, "clips": total_clips, "videos": groups,
+                "zip": "clips.zip" if zp else ""}
 
-    _username = req.username
     submit_for_session(job, work, req.session)
     return {"job_id": job.id, "session": req.session}
 

backend/app/services/cutter/cut.py

@@ -28,6 +28,13 @@ def cut_segment(src: str, seg: Segment, out_path: str) -> ClipResult:
     start = seg.start_frame / seg.fps
     # dùng số frame để chốt độ dài chính xác thay vì -to (tránh sai số float)
     nframes = seg.end_frame - seg.start_frame
+    # Khúc ngược/rỗng: ffmpeg KHÔNG báo lỗi, nó coi "-frames:v -40" là không giới
+    # hạn và xuất ra clip dài tới hết video -> người dùng nhận khúc sai mà tưởng
+    # đúng. Chặn ngay tại đây.
+    if nframes <= 0:
+        raise ValueError(
+            f"Khúc {seg.index + 1} không hợp lệ: điểm kết thúc ({seg.end_frame}) "
+            f"phải sau điểm bắt đầu ({seg.start_frame}).")
     cmd = [
         FFMPEG, "-y", "-hide_banner", "-loglevel", "error",
         "-ss", f"{start:.6f}", "-i", src,
@@ -39,6 +46,10 @@ def cut_segment(src: str, seg: Segment, out_path: str) -> ClipResult:
         out_path,
     ]
     subprocess.run(cmd, check=True, capture_output=True)
+    # ffmpeg thoát mã 0 nhưng file rỗng (vd điểm cắt vượt quá cuối video) cũng là hỏng.
+    if not os.path.exists(out_path) or os.path.getsize(out_path) == 0:
+        raise RuntimeError(
+            f"Khúc {seg.index + 1} cắt ra rỗng — điểm cắt nằm ngoài video?")
     return ClipResult(
         index=seg.index,
         path=out_path,
@@ -59,6 +70,141 @@ def cut_all(src: str, segments: list[Segment], out_dir: str,
     return results
 
 
+# ─────────────────────── Cắt cả mẻ: SONG SONG theo số lõi ────────────────────
+# Đo thật trên 900 frame 720x1280: giải mã hết video 0.6s, mã hoá lại 3.8s —
+# tức ~86% thời gian nằm ở MÃ HOÁ. Nên cách nhanh nhất không phải gộp các khúc
+# vào một lượt ffmpeg (đã thử: chỉ tiết kiệm phần giải mã, lại chạy mã hoá nối
+# đuôi nhau nên còn CHẬM HƠN), mà là cắt nhiều khúc CÙNG LÚC để dùng hết lõi.
+
+def _cut_workers() -> int:
+    env = os.environ.get("CUT_WORKERS")
+    if env and env.strip().isdigit():
+        return max(1, int(env))
+    cpu = os.cpu_count() or 2
+    # Trần 4: nhiều hơn nữa thì các tiến trình x264 giành lõi của nhau, không lợi.
+    return min(4, max(2, cpu - 1))
+
+
+def cut_segments(src: str, segments: list[Segment], out_paths: list[str],
+                 on_done=None, workers: int | None = None) -> list[ClipResult | None]:
+    """Cắt cả danh sách khúc SONG SONG, KHÔNG để 1 khúc lỗi giết cả mẻ.
+
+    `on_done(i, result, error)` gọi sau mỗi khúc để cập nhật tiến độ (được gọi
+    từ nhiều luồng, nên bên gọi chỉ nên cộng dồn/ghi trạng thái).
+    """
+    from concurrent.futures import ThreadPoolExecutor
+
+    n = len(segments)
+    results: list[ClipResult | None] = [None] * n
+    workers = workers or _cut_workers()
+
+    def one(i: int):
+        try:
+            results[i] = cut_segment(src, segments[i], out_paths[i])
+            if on_done:
+                on_done(i, results[i], None)
+        except Exception as e:
+            if isinstance(e, subprocess.CalledProcessError):
+                tail = (e.stderr or b"").decode("utf-8", "ignore").strip().splitlines()
+                e = RuntimeError(tail[-1] if tail else f"ffmpeg thoát mã {e.returncode}")
+            if on_done:
+                on_done(i, None, e)
+
+    if n <= 1 or workers <= 1:
+        for i in range(n):
+            one(i)
+    else:
+        with ThreadPoolExecutor(max_workers=min(workers, n)) as ex:
+            list(ex.map(one, range(n)))
+    return results
+
+
+# ───────────── Bản XEM TRƯỚC nhỏ để dò chuyển cảnh cho nhanh ─────────────────
+# PySceneDetect đọc video bằng OpenCV — giải mã MỘT LUỒNG ở độ phân giải gốc.
+# Đo thật trên video QC 1080x1920 dài 30s: dò thẳng trên bản gốc mất 8.4s, còn
+# hạ xuống 360p bằng ffmpeg (đa luồng) rồi dò chỉ mất 2.6s — RA ĐÚNG CÙNG điểm
+# cắt, vì bản thân PySceneDetect cũng thu nhỏ khung hình trước khi so sánh.
+PROXY_HEIGHT = 360
+PROXY_MIN_HEIGHT = 480          # video vốn đã nhỏ thì khỏi hạ, dò thẳng cho nhanh
+
+
+def _proxy_filter(info: VideoInfo) -> str | None:
+    short = min(info.width, info.height) or 0
+    if short and short <= PROXY_MIN_HEIGHT:
+        return None
+    return (f"scale=-2:{PROXY_HEIGHT}" if info.height >= info.width
+            else f"scale={PROXY_HEIGHT}:-2")
+
+
+def detect_info(info: VideoInfo, proxy_path: str) -> VideoInfo:
+    """VideoInfo trỏ vào BẢN NHỎ nhưng giữ nguyên fps/số frame của bản GỐC.
+
+    Bản nhỏ cùng fps nên chỉ số frame khớp 1-1; giữ nb_frames gốc để khúc cuối
+    chạm đúng cuối video thật.
+    """
+    return VideoInfo(path=proxy_path, duration=info.duration, fps=info.fps,
+                     nb_frames=info.nb_frames, width=info.width, height=info.height)
+
+
+def build_proxy(info: VideoInfo, proxy_path: str) -> str | None:
+    """Dựng bản nhỏ để dò cảnh. Trả None nếu không cần / không dựng được."""
+    vf = _proxy_filter(info)
+    if not vf:
+        return None
+    cmd = [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", info.path,
+           "-an", "-vf", vf, "-fps_mode", "cfr",
+           "-c:v", "libx264", "-preset", "ultrafast", "-crf", "28",
+           "-pix_fmt", "yuv420p", proxy_path]
+    try:
+        subprocess.run(cmd, check=True, capture_output=True)
+        return proxy_path if os.path.getsize(proxy_path) > 0 else None
+    except (subprocess.CalledProcessError, OSError):
+        return None
+
+
+def preview_pass(info: VideoInfo, thumb_dir: str, proxy_path: str,
+                 count: int = 40) -> tuple[list[dict], str | None]:
+    """MỘT lượt ffmpeg -> vừa dải thumbnail vừa bản nhỏ dò cảnh.
+
+    Trước đây là 2 lượt, mỗi lượt giải mã lại cả video. Gộp lại chỉ giải mã 1 lần.
+    Hỏng -> lùi về làm rời từng thứ (vẫn chạy được, chỉ chậm hơn).
+    """
+    os.makedirs(thumb_dir, exist_ok=True)
+    vf = _proxy_filter(info)
+    dur = info.duration or 0.0
+    count = max(2, count)
+    if vf and dur > 0:
+        pattern = os.path.join(thumb_dir, "thumb_%03d.jpg")
+        cmd = [
+            FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", info.path,
+            # đầu ra 1: bản nhỏ để dò chuyển cảnh
+            "-an", "-vf", vf, "-fps_mode", "cfr",
+            "-c:v", "libx264", "-preset", "ultrafast", "-crf", "28",
+            "-pix_fmt", "yuv420p", proxy_path,
+            # đầu ra 2: dải thumbnail cho timeline
+            "-an", "-vf", f"fps={count}/{dur:.6f},scale=160:-1",
+            "-frames:v", str(count), "-fps_mode", "passthrough", pattern,
+        ]
+        try:
+            subprocess.run(cmd, check=True, capture_output=True)
+            thumbs = _collect_thumbs(thumb_dir, dur, count)
+            if thumbs and os.path.exists(proxy_path) and os.path.getsize(proxy_path) > 0:
+                return thumbs, proxy_path
+        except (subprocess.CalledProcessError, OSError):
+            pass
+    return thumbnail_strip(info, thumb_dir, count), build_proxy(info, proxy_path)
+
+
+def _collect_thumbs(out_dir: str, dur: float, count: int) -> list[dict]:
+    thumbs = []
+    for i in range(count):
+        path = os.path.join(out_dir, f"thumb_{i+1:03d}.jpg")   # ffmpeg đánh số từ 1
+        if not os.path.exists(path):
+            break
+        thumbs.append({"time": round(dur * i / count, 3), "path": path})
+    return thumbs
+
+
 def thumbnail_strip(info: VideoInfo, out_dir: str, count: int = 40) -> list[dict]:
     """Sinh dải thumbnail để hiển thị nền timeline (preview điểm cắt).
 
@@ -80,12 +226,7 @@ def thumbnail_strip(info: VideoInfo, out_dir: str, count: int = 40) -> list[dict
         ]
         try:
             subprocess.run(cmd, check=True, capture_output=True)
-            thumbs = []
-            for i in range(count):
-                path = os.path.join(out_dir, f"thumb_{i+1:03d}.jpg")  # ffmpeg đánh số từ 1
-                if not os.path.exists(path):
-                    break
-                thumbs.append({"time": round(dur * i / count, 3), "path": path})
+            thumbs = _collect_thumbs(out_dir, dur, count)
             if thumbs:
                 return thumbs
         except subprocess.CalledProcessError:
@@ -110,10 +251,17 @@ def _thumbnail_strip_slow(info: VideoInfo, out_dir: str, count: int) -> list[dic
     return thumbs
 
 
+# mp4 đã nén sẵn: DEFLATE gần như không giảm được byte nào mà ngốn CPU + thời
+# gian (mẻ vài trăm MB mất cả chục giây). ZIP_STORED = gói lại, không nén.
 def zip_clips(clips: list[ClipResult], zip_path: str) -> str:
-    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
-        for c in clips:
-            zf.write(c.path, arcname=os.path.basename(c.path))
+    return zip_paths_stored([c.path for c in clips], zip_path)
+
+
+def zip_paths_stored(paths: list[str], zip_path: str) -> str:
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_STORED) as zf:
+        for p in paths:
+            if os.path.isfile(p):
+                zf.write(p, arcname=os.path.basename(p))
     return zip_path
 
 

backend/app/services/cutter/probe.py

@@ -41,7 +41,19 @@ def _parse_rate(rate: str) -> float:
 _PROBE_CACHE: dict[tuple, "VideoInfo"] = {}
 
 
+class ProbeError(RuntimeError):
+    """ffprobe không đọc được file — kèm lý do người dùng hiểu được."""
+
+
 def probe(path: str) -> VideoInfo:
+    name = os.path.basename(path)
+    # Kiểm tra file TRƯỚC khi gọi ffprobe: thiếu file là lỗi hay gặp nhất (phiên
+    # hết hạn bị dọn, hoặc video nằm ở phiên khác) và ffprobe chỉ trả về
+    # CalledProcessError trống trơn -> 500 không ai đoán được nguyên nhân.
+    if not os.path.isfile(path):
+        raise ProbeError(
+            f"Không tìm thấy video '{name}' trên máy chủ — phiên làm việc có thể "
+            f"đã hết hạn. Hãy tải lại video rồi cắt.")
     try:
         stt = os.stat(path)
         key = (os.path.abspath(path), stt.st_mtime_ns, stt.st_size)
@@ -50,15 +62,28 @@ def probe(path: str) -> VideoInfo:
             return cached
     except OSError:
         key = None
+        stt = None
+    if stt is not None and stt.st_size == 0:
+        raise ProbeError(f"Video '{name}' rỗng (0 byte) — tải lên chưa xong hoặc đã hỏng.")
 
     cmd = [
         FFPROBE, "-v", "error", "-print_format", "json",
         "-show_streams", "-show_format", path,
     ]
-    out = subprocess.run(cmd, capture_output=True, text=True, check=True).stdout
-    data = json.loads(out)
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    if proc.returncode != 0:
+        err = (proc.stderr or "").strip().splitlines()
+        detail = err[-1] if err else f"ffprobe thoát mã {proc.returncode}"
+        raise ProbeError(f"Không đọc được video '{name}': {detail}")
+    try:
+        data = json.loads(proc.stdout)
+    except json.JSONDecodeError:
+        raise ProbeError(f"Không đọc được thông tin video '{name}' (ffprobe trả về dữ liệu lạ).")
 
-    vstream = next(s for s in data["streams"] if s["codec_type"] == "video")
+    vstream = next(
+        (s for s in data.get("streams", []) if s.get("codec_type") == "video"), None)
+    if vstream is None:
+        raise ProbeError(f"File '{name}' không có luồng hình — đây không phải video.")
     fps = _parse_rate(vstream.get("avg_frame_rate") or "") or _parse_rate(
         vstream.get("r_frame_rate") or ""
     )
@@ -66,12 +91,16 @@ def probe(path: str) -> VideoInfo:
         vstream.get("duration") or data.get("format", {}).get("duration") or 0.0
     )
     nb = vstream.get("nb_frames")
-    nb_frames = int(nb) if nb and nb.isdigit() else int(round(duration * fps))
+    eff_fps = fps or 30.0
+    nb_frames = int(nb) if nb and str(nb).isdigit() else int(round(duration * eff_fps))
+    if nb_frames <= 0:
+        raise ProbeError(
+            f"Video '{name}' không có khung hình nào đọc được (file hỏng hoặc tải lên dở dang).")
 
     info = VideoInfo(
         path=path,
         duration=duration,
-        fps=fps or 30.0,
+        fps=eff_fps,
         nb_frames=nb_frames,
         width=int(vstream.get("width", 0)),
         height=int(vstream.get("height", 0)),

backend/tests/test_cut.py

@@ -203,3 +203,194 @@ def test_multi_video_unique_names():
             cutter.cut_segment(v, seg, os.path.join(outdir, name))
             names.append(name)
     assert len(names) == len(set(names)) == 4   # 2 video × 2 khúc, không trùng tên
+
+
+def _wait(job, secs=120):
+    import time
+    for _ in range(secs * 4):
+        if job.status in ("done", "error"):
+            break
+        time.sleep(0.25)
+    return job
+
+
+def test_execute_batch_videos_in_different_sessions():
+    """Ca gây lỗi thật: thả nhiều video một lượt -> mỗi video rơi vào MỘT PHIÊN
+    khác nhau, nhưng lúc cắt chỉ gửi phiên của video đầu. Trước đây ffprobe
+    không thấy file -> CalledProcessError -> 500 "Lỗi cắt: Internal Server Error".
+    """
+    from app.api import cut as cutapi
+    from app.core import files as F
+    from app.core.jobs import jobs
+
+    sid_a = F.new_session("cut")
+    sid_b = F.new_session("cut")
+    make_video(os.path.join(F.sub_dir(sid_a, "inputs"), "a.mp4"), dur=3.0, rate=20, color="red")
+    make_video(os.path.join(F.sub_dir(sid_b, "inputs"), "b.mp4"), dur=3.0, rate=20, color="blue")
+
+    req = cutapi.ExecuteBatchReq(session=sid_a, videos=[
+        cutapi.BatchItem(file="inputs/a.mp4", mode="even", count=2),
+        cutapi.BatchItem(file="inputs/b.mp4", session=sid_b, mode="even", count=2),
+    ])
+    job = _wait(jobs.get(cutapi.execute_batch(req)["job_id"]))
+    assert job.status == "done", job.error
+    counts = {v["video"]: len(v["clips"]) for v in job.result["videos"]}
+    assert counts == {"a": 2, "b": 2}, counts
+    # Mọi clip nằm gọn trong phiên chung -> tải về / đẩy sang Xào đều thấy.
+    for v in job.result["videos"]:
+        for c in v["clips"]:
+            assert os.path.exists(os.path.join(F.session_dir(sid_a), "clips", c["name"]))
+
+
+def test_execute_batch_one_bad_video_does_not_kill_batch():
+    """Một video mất file (phiên hết hạn) chỉ hỏng phần của nó — video còn lại
+    vẫn ra clip, và lỗi là câu tiếng Việt đọc được chứ không phải 500."""
+    from app.api import cut as cutapi
+    from app.core import files as F
+    from app.core.jobs import jobs
+
+    sid = F.new_session("cut")
+    make_video(os.path.join(F.sub_dir(sid, "inputs"), "ok.mp4"), dur=3.0, rate=20)
+
+    req = cutapi.ExecuteBatchReq(session=sid, videos=[
+        cutapi.BatchItem(file="inputs/mat_tieu.mp4", mode="even", count=2),
+        cutapi.BatchItem(file="inputs/ok.mp4", mode="even", count=2),
+    ])
+    job = _wait(jobs.get(cutapi.execute_batch(req)["job_id"]))
+    assert job.status == "done", job.error
+    by = {v["video"]: v for v in job.result["videos"]}
+    assert by["mat_tieu"]["clips"] == [] and "Không tìm thấy video" in by["mat_tieu"]["error"]
+    assert len(by["ok"]["clips"]) == 2
+
+
+def test_execute_batch_all_bad_reports_error():
+    """Hỏng hết thì job phải BÁO LỖI (không im lặng trả 0 clip)."""
+    from app.api import cut as cutapi
+    from app.core import files as F
+    from app.core.jobs import jobs
+
+    sid = F.new_session("cut")
+    F.sub_dir(sid, "inputs")
+    req = cutapi.ExecuteBatchReq(session=sid, videos=[
+        cutapi.BatchItem(file="inputs/khong_co.mp4", mode="even", count=2)])
+    job = _wait(jobs.get(cutapi.execute_batch(req)["job_id"]))
+    assert job.status == "error" and "Không tìm thấy video" in (job.error or "")
+
+
+def test_probe_errors_are_readable():
+    """probe() phải nói rõ lý do, không ném CalledProcessError trống trơn."""
+    from app.services.cutter.probe import ProbeError
+
+    d = tempfile.mkdtemp()
+    for name, content in [("mat.mp4", None), ("rong.mp4", b""), ("rac.mp4", b"khong phai video")]:
+        p = os.path.join(d, name)
+        if content is not None:
+            open(p, "wb").write(content)
+        try:
+            probe(p)
+            raise AssertionError(f"{name}: đáng lẽ phải báo lỗi")
+        except ProbeError as e:
+            assert name in str(e) or "Không tìm thấy" in str(e), str(e)
+
+
+def test_resolve_src_blocks_escape():
+    """Đường dẫn file không được thoát khỏi thư mục phiên."""
+    from fastapi import HTTPException
+    from app.api import cut as cutapi
+    from app.core import files as F
+
+    sid = F.new_session("cut")
+    assert cutapi.resolve_src(sid, "inputs/a.mp4").startswith(F.session_dir(sid))
+    try:
+        cutapi.resolve_src(sid, "../../etc/passwd")
+    except HTTPException:
+        pass
+    # ".." bị lọc bỏ -> vẫn nằm trong phiên
+    assert cutapi.resolve_src(sid, "a/../b.mp4").startswith(F.session_dir(sid))
+
+
+def test_cut_segments_parallel_matches_sequential():
+    """Cắt song song cho ra ĐÚNG file như cắt tuần tự, và khúc lỗi chỉ hỏng một mình."""
+    import hashlib
+
+    d = tempfile.mkdtemp()
+    v = make_video(os.path.join(d, "in.mp4"), dur=4.0, rate=20)
+    info = probe(v)
+    segs = modes.build_segments(info, "even", n=4)
+
+    seq_dir = os.path.join(d, "seq"); os.makedirs(seq_dir)
+    seq = cutter.cut_all(v, segs, seq_dir)
+    par = [os.path.join(d, f"p{i}.mp4") for i in range(len(segs))]
+    res = cutter.cut_segments(v, segs, par)
+    assert all(r is not None for r in res)
+    for a, b in zip(seq, par):
+        assert hashlib.md5(open(a.path, "rb").read()).hexdigest() == \
+               hashlib.md5(open(b, "rb").read()).hexdigest()
+
+    bad = [modes.Segment(0, 0, 20, info.fps),
+           modes.Segment(1, 50, 10, info.fps),        # end < start -> ffmpeg lỗi
+           modes.Segment(2, 20, 40, info.fps)]
+    outs = [os.path.join(d, f"b{i}.mp4") for i in range(3)]
+    seen = {}
+    cutter.cut_segments(v, bad, outs, on_done=lambda i, r, e: seen.__setitem__(i, r is not None))
+    assert seen[0] and seen[2] and not seen[1], seen
+
+
+def test_preview_pass_gives_thumbs_and_proxy():
+    """1 lượt ffmpeg ra cả dải thumbnail lẫn bản nhỏ dò cảnh; bản nhỏ giữ đúng
+    fps/số frame nên điểm cắt tìm trên đó dùng thẳng cho bản gốc được."""
+    d = tempfile.mkdtemp()
+    v = make_video(os.path.join(d, "in.mp4"), dur=4.0, size="1080x1920", rate=20)
+    info = probe(v)
+    tdir = os.path.join(d, "thumbs")
+    thumbs, proxy = cutter.preview_pass(info, tdir, os.path.join(tdir, "proxy.mp4"), count=10)
+    assert len(thumbs) == 10 and all(os.path.getsize(t["path"]) > 0 for t in thumbs)
+    assert proxy and os.path.getsize(proxy) > 0
+    pinfo = probe(proxy)
+    assert pinfo.height < info.height              # đã thu nhỏ thật
+    assert abs(pinfo.nb_frames - info.nb_frames) <= 1   # cùng fps -> khung khớp 1-1
+
+    det = cutter.detect_info(info, proxy)
+    assert det.path == proxy
+    assert det.nb_frames == info.nb_frames and det.fps == info.fps
+    # khúc dò trên bản nhỏ vẫn phủ trọn video GỐC
+    segs = modes.build_segments(det, "auto")
+    assert segs[0].start_frame == 0 and segs[-1].end_frame == info.nb_frames
+
+
+def test_preview_proxy_finds_same_cuts_as_original():
+    """Thu nhỏ để dò cho nhanh KHÔNG được làm đổi điểm cắt."""
+    d = tempfile.mkdtemp()
+    v = _multi_scene_video(os.path.join(d, "in.mp4"),
+                           colors=("red", "green", "blue", "yellow"), each=2.0, rate=20)
+    info = probe(v)
+    full = [s.start_frame for s in modes.build_segments(info, "auto")]
+    proxy = cutter.build_proxy(info, os.path.join(d, "proxy.mp4"))
+    if not proxy:                       # video test nhỏ sẵn -> không cần bản nhỏ
+        return
+    small = [s.start_frame for s in modes.build_segments(cutter.detect_info(info, proxy), "auto")]
+    assert len(full) == len(small), (full, small)
+    for a, b in zip(full, small):
+        assert abs(a - b) <= 2, (full, small)      # lệch tối đa 2 frame
+
+
+def test_small_video_skips_proxy():
+    """Video vốn đã nhỏ thì khỏi dựng bản nhỏ (dựng còn tốn hơn dò thẳng)."""
+    d = tempfile.mkdtemp()
+    v = make_video(os.path.join(d, "in.mp4"), dur=2.0, size="320x240", rate=15)
+    assert cutter.build_proxy(probe(v), os.path.join(d, "p.mp4")) is None
+
+
+def test_zip_clips_is_stored_not_deflated():
+    """mp4 nén lại chẳng lợi byte nào mà tốn CPU -> phải gói kiểu STORED."""
+    import zipfile
+
+    d = tempfile.mkdtemp()
+    v = make_video(os.path.join(d, "in.mp4"), dur=2.0, rate=20)
+    info = probe(v)
+    segs = modes.build_segments(info, "even", n=2)
+    clips = cutter.cut_all(v, segs, os.path.join(d, "clips"))
+    zp = cutter.zip_clips(clips, os.path.join(d, "c.zip"))
+    with zipfile.ZipFile(zp) as zf:
+        assert len(zf.namelist()) == 2
+        assert all(i.compress_type == zipfile.ZIP_STORED for i in zf.infolist())

frontend/src/api.js

@@ -3,13 +3,26 @@ import { currentCtx as trackCtx } from "./lib/track";
 
 const BASE = "";
 
+// Lỗi FastAPI trả về dạng {"detail": "..."} — lấy ra câu chữ cho người đọc,
+// đừng ném nguyên cục JSON vào alert.
+async function errFrom(r) {
+  const text = await r.text().catch(() => "");
+  try {
+    const j = JSON.parse(text);
+    const d = j?.detail ?? j?.error ?? j?.message;
+    if (typeof d === "string" && d) return new Error(d);
+    if (Array.isArray(d) && d.length) return new Error(d.map((x) => x.msg || "").join("; "));
+  } catch { /* không phải JSON -> dùng nguyên văn */ }
+  return new Error(text || r.statusText || `HTTP ${r.status}`);
+}
+
 async function jpost(path, body) {
   const r = await fetch(BASE + path, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(body),
   });
-  if (!r.ok) throw new Error((await r.text()) || r.statusText);
+  if (!r.ok) throw await errFrom(r);
   return r.json();
 }
 
@@ -18,7 +31,7 @@ async function upload(path, file, fields = {}) {
   fd.append("file", file);
   for (const [k, v] of Object.entries(fields)) if (v != null) fd.append(k, v);
   const r = await fetch(BASE + path, { method: "POST", body: fd });
-  if (!r.ok) throw new Error((await r.text()) || r.statusText);
+  if (!r.ok) throw await errFrom(r);
   return r.json();
 }
 

frontend/src/pages/CutVideo.jsx

@@ -208,11 +208,18 @@ export default function CutVideo() {
 
   const onFiles = async (files) => {
     const arr = Array.from(files);
+    // MỌI video của lần thả này phải vào CÙNG MỘT PHIÊN. `cur` là biến chụp lúc
+    // render nên không đổi trong vòng lặp: trước đây thả 2 video lúc chưa có
+    // video nào -> cả 2 lần upload đều gửi session rỗng -> backend tạo 2 phiên
+    // riêng, mà lúc cắt lại gửi chung phiên của video đầu -> video thứ 2 không
+    // tìm thấy file -> "Lỗi cắt: Internal Server Error". Giữ sid chạy theo vòng lặp.
+    let sid = videos[0]?.session || cur?.session || null;
     for (let i = 0; i < arr.length; i++) {
       const file = arr[i];
       setUploading({ name: file.name, i: i + 1, n: arr.length });
       try {
-        const r = await api.cutUpload(file, cur?.session);
+        const r = await api.cutUpload(file, sid);
+        sid = r.session;
         const v = {
           session: r.session, file: r.file, name: file.name,
           url: fileUrl(`/api/files/${r.session}/${r.file}`),
@@ -251,10 +258,21 @@ export default function CutVideo() {
     if (!videos.length) return;
     setPrevBusy(true);
     track.runClick({ phase: "auto_segment", videos: videos.length });
+    // Chạy 2 video CÙNG LÚC (không phải xếp hàng từng cái) — đây là bước chờ lâu
+    // nhất của tool. Giữ ở 2 để máy chủ còn phục vụ người khác.
+    // Một video hỏng KHÔNG được chặn các video còn lại — báo gọn ở cuối.
+    const failed = [];
+    const queue = videos.map((_, i) => i);
+    const worker = async () => {
+      for (let i = queue.shift(); i !== undefined; i = queue.shift()) {
+        try { await doPreview(i); }
+        catch (e) { failed.push(`${videos[i]?.name || `video ${i + 1}`}: ${e.message}`); }
+      }
+    };
     try {
-      for (let i = 0; i < videos.length; i++) await doPreview(i);
-    } catch (e) { alert("Lỗi tách khúc: " + e.message); }
-    finally { setPrevBusy(false); }
+      await Promise.all(Array.from({ length: Math.min(2, videos.length) }, worker));
+      if (failed.length) alert("Không tách khúc được:\n• " + failed.join("\n• "));
+    } finally { setPrevBusy(false); }
   };
 
   const segmentsFromCuts = (video) => {
@@ -279,6 +297,9 @@ export default function CutVideo() {
         session: sid,
         videos: videos.map((v) => ({
           file: v.file,
+          // Gửi kèm phiên CỦA TỪNG VIDEO: các phiên cũ (tải lên trước bản sửa)
+          // có thể nằm rải rác, backend tìm đúng chỗ thay vì báo lỗi.
+          session: v.session || sid,
           // ưu tiên điểm cắt trên timeline; nếu chưa tách thì để backend tự cắt auto
           segments: (v.cuts && v.cuts.length) ? segmentsFromCuts(v) : null,
           mode: "auto",