diff --git a/Dockerfile b/Dockerfile index c31a84797bb4f5445ab748ef09dc7e38342cea34..39d75d3dd1e9244328c90f37c104aa1362920c0e 100644 --- a/Dockerfile +++ b/Dockerfile @@ -15,9 +15,8 @@ ENV HF_HOME=/tmp/hf_cache WORKDIR /app COPY backend/requirements.txt . RUN pip install --no-cache-dir -r requirements.txt -COPY ./app ./app COPY ./backend ./backend COPY --from=frontend /frontend/dist ./frontend/dist ENV PORT=7860 EXPOSE 7860 -CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"] +CMD ["uvicorn", "backend.app.main:app", "--host", "0.0.0.0", "--port", "7860"] diff --git a/app/api/__init__.py b/app/api/__init__.py deleted file mode 100644 index 226ba7a91e721ee82d20f0253e95f1704c4fd0a2..0000000000000000000000000000000000000000 --- a/app/api/__init__.py +++ /dev/null @@ -1 +0,0 @@ -"""Gói router FastAPI cho các tool.""" diff --git a/app/api/common.py b/app/api/common.py deleted file mode 100644 index b43f12277bdba1666fa58d1c1d311653069c1578..0000000000000000000000000000000000000000 --- a/app/api/common.py +++ /dev/null @@ -1,61 +0,0 @@ -"""Endpoint dùng chung: trạng thái job, tải file kết quả.""" - -from __future__ import annotations - -import os - -from fastapi import APIRouter, HTTPException -from fastapi.responses import FileResponse - -from ..core.files import session_dir, delete_session -from ..core.jobs import jobs - -router = APIRouter(prefix="/api", tags=["common"]) - - -@router.delete("/sessions/{sid}") -def drop_session(sid: str): - """Xoá phiên tạm sau khi user đã tải kết quả về máy (không bắt buộc).""" - return {"deleted": delete_session(sid), "session": sid} - - -@router.get("/jobs/{job_id}") -def job_status(job_id: str): - job = jobs.get(job_id) - if not job: - raise HTTPException(404, "job không tồn tại") - return job.to_dict() - - -@router.post("/jobs/{job_id}/cancel") -def job_cancel(job_id: str): - jobs.cancel(job_id) - return {"ok": True} - - -@router.get("/sessions/{sid}/inputs") -def list_inputs(sid: str): - """Liệt kê video trong thư mục inputs của phiên (dùng khi đẩy từ Down list).""" - d = os.path.join(session_dir(sid), "inputs") - if not os.path.isdir(d): - return {"session": sid, "files": []} - out = [] - for name in sorted(os.listdir(d)): - full = os.path.join(d, name) - if os.path.isfile(full): - out.append({ - "file": f"inputs/{name}", - "name": name, - "size": os.path.getsize(full), - "url": f"/api/files/{sid}/inputs/{name}", - }) - return {"session": sid, "files": out} - - -@router.get("/files/{sid}/{path:path}") -def get_file(sid: str, path: str): - base = os.path.abspath(session_dir(sid)) - full = os.path.abspath(os.path.join(base, path)) - if not full.startswith(base) or not os.path.exists(full): - raise HTTPException(404, "file không tồn tại") - return FileResponse(full, filename=os.path.basename(full)) diff --git a/app/api/cut.py b/app/api/cut.py deleted file mode 100644 index 3840e60a7c64b33f6728ce79d05b512cc5941fb6..0000000000000000000000000000000000000000 --- a/app/api/cut.py +++ /dev/null @@ -1,203 +0,0 @@ -"""API tool: Cut video. - -Luồng FE: - 1) upload video -> /upload (trả session + info) - 2) /preview -> sinh khúc theo mode + thumbnail strip để xem trước/kéo điểm cắt - 3) /execute -> cắt theo các điểm cắt (đã chỉnh tay) -> zip -""" - -from __future__ import annotations - -import os - -from fastapi import APIRouter, File, Form, UploadFile -from pydantic import BaseModel - -from ..core.files import new_session, session_dir, sub_dir, save_upload -from ..core.jobs import jobs -from ..services.cutter import cut as cutter -from ..services.cutter import modes -from ..services.cutter.probe import probe - -router = APIRouter(prefix="/api/cut", tags=["cut"]) - - -@router.post("/upload") -async def upload(file: UploadFile = File(...), session: str = Form(None)): - sid = session or new_session("cut") - path = save_upload(sid, file.filename, await file.read(), folder="inputs") - info = probe(path) - return { - "session": sid, - "file": os.path.relpath(path, session_dir(sid)), - "info": {"duration": info.duration, "fps": info.fps, - "nb_frames": info.nb_frames, - "width": info.width, "height": info.height}, - "auto_count": modes.auto_segment_count(info), - } - - -class PreviewReq(BaseModel): - session: str - file: str - mode: str = "even" # even | scene | highlight | smart - count: int | None = None # số khúc (even) — None để máy tự chia - min_len: float = 1.5 - sensitivity: float = 0.5 - top_ratio: float = 0.4 - thumbnails: int = 40 - - -@router.post("/preview") -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, - sensitivity=req.sensitivity, top_ratio=req.top_ratio) - thumbs = cutter.thumbnail_strip( - info, sub_dir(req.session, "thumbs"), count=req.thumbnails) - rel_thumbs = [{"time": t["time"], - "url": f"/api/files/{req.session}/thumbs/{os.path.basename(t['path'])}"} - for t in thumbs] - return { - "info": {"duration": info.duration, "fps": info.fps, - "nb_frames": info.nb_frames}, - "segments": [s.to_dict() for s in segs], - "thumbnails": rel_thumbs, - } - - -class CutPoint(BaseModel): - start_frame: int - end_frame: int - - -class ExecuteReq(BaseModel): - session: str - file: str - # điểm cắt cuối cùng (đã chỉnh tay / thêm khúc trong UI). Nếu rỗng -> dùng mode. - segments: list[CutPoint] | None = None - mode: str = "even" - count: int | None = None - - -@router.post("/execute") -def execute(req: ExecuteReq): - src = os.path.join(session_dir(req.session), req.file) - info = probe(src) - if req.segments: - segs = [modes.Segment(i, s.start_frame, s.end_frame, info.fps) - for i, s in enumerate(req.segments)] - else: - segs = modes.build_segments(info, req.mode, n=req.count) - - 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)) - zp = os.path.join(session_dir(req.session), "clips.zip") - cutter.zip_clips(results, zp) - return {"session": req.session, "clips": len(results), - "zip": "clips.zip"} - - jobs.submit(job, work) - return {"job_id": job.id, "session": req.session, - "segments": [s.to_dict() for s in segs]} - - -class BatchItem(BaseModel): - file: str - segments: list[CutPoint] | None = None - mode: str = "even" - count: int | None = None - - -class ExecuteBatchReq(BaseModel): - session: str - videos: list[BatchItem] - - -@router.post("/execute-batch") -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. - """ - plans = [] - for vi, item in enumerate(req.videos): - src = os.path.join(session_dir(req.session), item.file) - info = probe(src) - if item.segments: - segs = [modes.Segment(i, s.start_frame, s.end_frame, info.fps) - for i, s in enumerate(item.segments)] - else: - segs = modes.build_segments(info, item.mode, n=item.count) - plans.append((vi, item.file, src, segs)) - - job = jobs.create("cut") - - def work(h): - out_dir = sub_dir(req.session, "clips") - results = [] - 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] - 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)) - results.append({"name": name, "duration": r.duration, - "size": r.size, "video": base, - "url": f"/api/files/{req.session}/clips/{name}"}) - h.item_status(it, "done", detail=f"{r.duration}s", result=results[-1]) - except Exception as e: - h.item_status(it, "error", error=str(e)) - done += 1 - h.set_progress(done / total) - return {"session": req.session, "clips": len(results)} - - jobs.submit(job, work) - return {"job_id": job.id, "session": req.session} - - -@router.post("/push-shuffle") -def push_shuffle(req: PushShuffleReq): - """Đẩy các khúc đã cắt sang tool Xào: mỗi khúc thành 1 segment (seg_i). - - FE mở Xào với session này; mỗi segment đã có sẵn 1 clip theo đúng vị trí, - người dùng có thể thêm clip vào từng segment sau. - """ - import shutil - new_sid = new_session("shuffle") - segments = [] - for i, rel in enumerate(req.clips): - src = os.path.join(session_dir(req.session), rel) - if not os.path.exists(src): - continue - folder = sub_dir(new_sid, f"seg_{i}") - dst = os.path.join(folder, os.path.basename(src)) - shutil.copy(src, dst) - seg_rel = os.path.relpath(dst, session_dir(new_sid)).replace(os.sep, "/") - segments.append({ - "files": [seg_rel], - "name": os.path.basename(src), - "url": f"/api/files/{new_sid}/{seg_rel}", - }) - return {"session": new_sid, "segments": segments} diff --git a/app/api/download.py b/app/api/download.py deleted file mode 100644 index aa9f0165959e70212c1ee0e71460cb1f48d13a1d..0000000000000000000000000000000000000000 --- a/app/api/download.py +++ /dev/null @@ -1,113 +0,0 @@ -"""API tool: Down list video.""" - -from __future__ import annotations - -import os -import shutil - -from fastapi import APIRouter -from pydantic import BaseModel - -from ..config import settings -from ..core.files import new_session, session_dir, sub_dir, zip_paths -from ..core.jobs import DONE, ERROR, RUNNING, jobs -from ..services.downloader.ydl import detect_source, download_one, parse_links - -router = APIRouter(prefix="/api/download", tags=["download"]) - - -class ParseReq(BaseModel): - raw: str - - -class StartReq(BaseModel): - urls: list[str] - zip_output: bool = True - cookies_file: str | None = None - - -@router.post("/parse") -def parse(req: ParseReq): - urls = parse_links(req.raw, settings.MAX_LINKS) - return { - "count": len(urls), - "items": [{"url": u, "source": detect_source(u), "status": "ready"} - for u in urls], - } - - -@router.post("/start") -def start(req: StartReq): - sid = new_session("download") - out_dir = sub_dir(sid, "videos") - job = jobs.create("download") - - def work(h): - items = [h.add_item(u, item_id=str(i)) for i, u in enumerate(req.urls)] - done_paths, failed = [], [] - n = len(req.urls) - for i, url in enumerate(req.urls): - if h.cancelled(): - break - it = items[i] - h.item_status(it, RUNNING, detail="đang tải") - h.log(f"[{i+1}/{n}] tải {url}") - res = download_one(url, out_dir, req.cookies_file) - if res.ok: - done_paths.append(res.path) - h.item_status(it, DONE, detail=res.title, result={ - "path": os.path.relpath(res.path, session_dir(sid)), - "url": f"/api/files/{sid}/" + os.path.relpath( - res.path, session_dir(sid)).replace(os.sep, "/"), - "title": res.title, "ext": res.ext, "size": res.size, - "duration": res.duration, "thumbnail": res.thumbnail, - "source": detect_source(url), - }) - h.log(f" ✔ {res.title} ({res.size} bytes)") - else: - failed.append({"url": url, "error": res.error}) - h.item_status(it, ERROR, error=res.error) - h.log(f" ✗ LỖI: {res.error}", level="error") - h.set_progress((i + 1) / max(1, n)) - - zip_rel = None - if req.zip_output and done_paths: - zp = os.path.join(session_dir(sid), "downloads.zip") - zip_paths(done_paths, zp) - zip_rel = "downloads.zip" - - return { - "session": sid, - "success": len(done_paths), - "failed": failed, - "zip": zip_rel, - } - - jobs.submit(job, work) - return {"job_id": job.id, "session": sid} - - -class PushReq(BaseModel): - session: str - paths: list[str] # đường dẫn tương đối các video đã tải - target_tool: str # cut | shuffle | dub - - -@router.post("/push") -def push_to_tool(req: PushReq): - """Đẩy các video đã tải sang tool khác (cut / shuffle / dub). - - Copy file sang session mới của tool đích, trả session id để FE mở thẳng. - """ - if req.target_tool not in {"cut", "shuffle", "dub"}: - return {"error": "target_tool không hợp lệ"} - new_sid = new_session(req.target_tool) - dst = sub_dir(new_sid, "inputs") - copied = [] - for rel in req.paths: - src = os.path.join(session_dir(req.session), rel) - if os.path.exists(src): - d = os.path.join(dst, os.path.basename(src)) - shutil.copy(src, d) - copied.append(os.path.relpath(d, session_dir(new_sid))) - return {"session": new_sid, "target_tool": req.target_tool, "files": copied} diff --git a/app/api/dub.py b/app/api/dub.py deleted file mode 100644 index 4ca9ef7fbfea6bcd01a24f7c889d889524f2862d..0000000000000000000000000000000000000000 --- a/app/api/dub.py +++ /dev/null @@ -1,174 +0,0 @@ -"""API tool: Dịch / đổi giọng video. - -Luồng FE: - 1) /upload -> tải 1+ video nguồn (gọi nhiều lần) + (tuỳ chọn) mẫu giọng - 2) /voice-sample -> tải file giọng mẫu user tự up (clone) - 3) /start -> chạy pipeline lồng tiếng cho từng video -> trả video+audio+srt - -Mỗi video là một item trong job để FE theo dõi tiến độ riêng. -""" - -from __future__ import annotations - -import os - -from fastapi import APIRouter, File, Form, UploadFile -from pydantic import BaseModel - -from ..core.files import new_session, session_dir, sub_dir, save_upload -from ..core.jobs import jobs -from ..services.dubber import pipeline - -router = APIRouter(prefix="/api/dub", tags=["dub"]) - -LANGS = {"en", "vi", "fil"} - - -# ----------------------------------------------------------------- upload --- - -@router.post("/upload") -async def upload(file: UploadFile = File(...), session: str = Form(None)): - sid = session or new_session("dub") - path = save_upload(sid, file.filename, await file.read(), folder="inputs") - rel = os.path.relpath(path, session_dir(sid)) - return {"session": sid, "file": rel, "name": os.path.basename(path), - "size": os.path.getsize(path)} - - -@router.post("/voice-sample") -async def voice_sample(file: UploadFile = File(...), session: str = Form(None)): - """File giọng mẫu (WAV/MP3) user tự up để clone. Tạo phiên nếu chưa có.""" - sid = session or new_session("dub") - path = save_upload(sid, file.filename, await file.read(), folder="voice") - rel = os.path.relpath(path, session_dir(sid)) - return {"session": sid, "file": rel, "name": os.path.basename(path)} - - -# ------------------------------------------------------------------ start --- - -class DubReq(BaseModel): - session: str - files: list[str] # danh sách video tương đối cần dịch - target_lang: str = "vi" # en | vi | fil - bg_mode: str = "duck" # none | duck | demucs - do_clone: bool = True - voice_source: str = "video" # preset | video | upload - speaker_file: str = "" # rel path nếu voice_source=upload - preset: str = "" # tên preset nếu voice_source=preset - style: str = "natural" - engine: str = "auto" - multi_speaker: bool = False - - -@router.post("/start") -def start(req: DubReq): - target = req.target_lang if req.target_lang in LANGS else "vi" - - 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=target, - bg_mode=req.bg_mode, - do_clone=req.do_clone, - voice_source=req.voice_source, - speaker_wav=speaker_wav, - preset=req.preset, - style=req.style, - engine=req.engine, - multi_speaker=req.multi_speaker, - ) - - 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): - # tiến độ tổng = (đã xong video + p video hiện tại) / n - h.set_progress((_i + p) / max(1, n)) - h.item_status(_it, "running", detail=m) - - res = pipeline.run_dub(src, out_dir, 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)) - return {"session": req.session, "outputs": outputs} - - jobs.submit(job, work) - return {"job_id": job.id, "session": req.session, "videos": len(req.files)} - - -# ------------------------------------------------------- TTS từ text --- - -class TtsReq(BaseModel): - session: str = "" - text: str - target_lang: str = "vi" # en | vi | fil - voice_source: str = "preset" # preset | upload - speaker_file: str = "" # rel path nếu voice_source=upload (clone) - preset: str = "" # tên giọng có sẵn - style: str = "natural" - engine: str = "auto" # auto | vieneu | xtts | voxcpm - - -@router.post("/tts") -def tts_from_text(req: TtsReq): - """Gen voice từ text: đầu vào text + giọng (clone/preset) -> đoạn voice.""" - sid = req.session or new_session("tts") - target = req.target_lang if req.target_lang in LANGS else "vi" - - speaker_wav = "" - if req.voice_source == "upload" and req.speaker_file: - speaker_wav = os.path.join(session_dir(sid), req.speaker_file) - - opt = pipeline.TtsOptions( - text=req.text, target_lang=target, voice_source=req.voice_source, - speaker_wav=speaker_wav, preset=req.preset, style=req.style, - engine=req.engine) - - job = jobs.create("tts") - - def work(h): - it = h.add_item("voice") - out_dir = sub_dir(sid, "tts_out") - try: - def prog(p, m, _it=it): - h.set_progress(p) - h.item_status(_it, "running", detail=m) - wav = pipeline.run_tts(opt, out_dir, prog) - rel = os.path.relpath(wav, session_dir(sid)).replace(os.sep, "/") - result = {"name": "voice.wav", "audio_url": f"/api/files/{sid}/{rel}"} - h.item_status(it, "done", detail="đã tạo voice", result=result) - return {"session": sid, "output": result} - except Exception as e: - h.item_status(it, "error", error=str(e)) - return {"session": sid, "error": str(e)} - - jobs.submit(job, work) - return {"job_id": job.id, "session": sid} diff --git a/app/api/shuffle.py b/app/api/shuffle.py deleted file mode 100644 index 3b50a6ce71c9db9fa417939a73b7ab4f9e85c9ad..0000000000000000000000000000000000000000 --- a/app/api/shuffle.py +++ /dev/null @@ -1,188 +0,0 @@ -"""API tool: Xào video. - -Luồng FE: - 1) /upload -> nạp clip vào từng khúc (folder "seg_{i}") - 2) /upload-audio -> (tùy chọn) nạp track âm thanh để lồng vào biến thể - 3) /estimate -> tính số tổ hợp + số sau lọc trùng - 4) /generate -> sinh tổ hợp + dedup + render (+ lồng audio) -> zip - -Thứ tự đảo do order_mode của TỪNG khúc quyết định (lock|shuffle|drop), -không còn cờ allow_reorder toàn cục. -""" - -from __future__ import annotations - -import os - -from fastapi import APIRouter, File, Form, UploadFile -from pydantic import BaseModel - -from ..core.files import new_session, session_dir, sub_dir, save_upload -from ..core.jobs import jobs -from ..services.shuffler import engine -from ..services.shuffler import render as shuffle_render - -router = APIRouter(prefix="/api/shuffle", tags=["shuffle"]) - - -# ----------------------------------------------------------------- upload --- - -@router.post("/upload") -async def upload( - file: UploadFile = File(...), - segment: int = Form(...), - session: str = Form(None), -): - """Tải 1 clip vào một khúc. Hỗ trợ tải cả thư mục (FE gửi nhiều file).""" - sid = session or new_session("shuffle") - folder = f"seg_{segment}" - path = save_upload(sid, file.filename, await file.read(), folder=folder) - rel = os.path.relpath(path, session_dir(sid)) - return { - "session": sid, "segment": segment, "file": rel, - "name": os.path.basename(path), "size": os.path.getsize(path), - "url": f"/api/files/{sid}/{rel}", - } - - -@router.post("/upload-audio") -async def upload_audio( - file: UploadFile = File(...), - session: str = Form(...), -): - """Tải 1 track âm thanh dùng để lồng vào các biến thể.""" - path = save_upload(session, file.filename, await file.read(), folder="audio") - rel = os.path.relpath(path, session_dir(session)) - return { - "session": session, "file": rel, - "name": os.path.basename(path), "size": os.path.getsize(path), - "url": f"/api/files/{session}/{rel}", - } - - -@router.get("/segments/{sid}") -def list_segments(sid: str): - """Liệt kê các khúc (seg_*) đã có sẵn trong phiên — dùng khi đẩy từ Cut.""" - base = session_dir(sid) - segs = [] - if os.path.isdir(base): - names = sorted( - [d for d in os.listdir(base) if d.startswith("seg_")], - key=lambda x: int(x.split("_")[1]) if x.split("_")[1].isdigit() else 0) - for d in names: - folder = os.path.join(base, d) - if not os.path.isdir(folder): - continue - files = [] - for fn in sorted(os.listdir(folder)): - full = os.path.join(folder, fn) - if os.path.isfile(full): - rel = f"{d}/{fn}" - files.append({"file": rel, "name": fn, - "size": os.path.getsize(full), - "url": f"/api/files/{sid}/{rel}"}) - segs.append({"files": files}) - return {"session": sid, "segments": segs} - - -# ------------------------------------------------ build config từ payload --- - -class SegmentIn(BaseModel): - files: list[str] - order_mode: str = "shuffle" # lock | shuffle | drop - - -class ShuffleReq(BaseModel): - session: str - segments: list[SegmentIn] - audio_files: list[str] = [] # track âm thanh (tùy chọn) - similarity_threshold: float = 0.80 # >=1.0 => tắt lọc trùng - random_ratio: float = 1.0 # >=1.0 => không lấy mẫu - max_outputs: int | None = None - seed: int | None = None - - -def _build(req: ShuffleReq): - clip_map: dict[int, str] = {} - seg_objs = [] - cid = 0 - for seg in req.segments: - ids = [] - for rel in seg.files: - clip_map[cid] = os.path.join(session_dir(req.session), rel) - ids.append(cid) - cid += 1 - seg_objs.append(engine.Segment(clips=ids, order_mode=seg.order_mode)) - cfg = engine.ShuffleConfig( - segments=seg_objs, - similarity_threshold=req.similarity_threshold, - random_ratio=req.random_ratio, - max_outputs=req.max_outputs, - seed=req.seed, - ) - return cfg, clip_map - - -def _audio_paths(req: ShuffleReq) -> list[str]: - return [os.path.join(session_dir(req.session), a) for a in req.audio_files] - - -# --------------------------------------------------------------- estimate --- - -@router.post("/estimate") -def estimate(req: ShuffleReq): - cfg, _ = _build(req) - est = engine.estimate(cfg) - preview = engine.generate(cfg) - return { - "selection_count": est.selection_count, - "ordering_count": est.ordering_count, - "raw_total": est.raw_total, - "after_dedup": len(preview), - } - - -# --------------------------------------------------------------- generate --- - -@router.post("/generate") -def generate(req: ShuffleReq): - cfg, clip_map = _build(req) - sequences = engine.generate(cfg) - audio_paths = _audio_paths(req) - - job = jobs.create("shuffle") - - def work(h): - h.log(f"Sẽ render {len(sequences)} biến thể" - + (f" + lồng {len(audio_paths)} track âm thanh" if audio_paths else "")) - out_dir = sub_dir(req.session, "variations") - results = [] - n = len(sequences) - for i, seq in enumerate(sequences, 1): - it = h.add_item(f"Variation_{i:02d}") - try: - paths = [clip_map[c] for c in seq] - name = f"Variation_{i:02d}.mp4" - out = os.path.join(out_dir, name) - if audio_paths: - tmp = os.path.join(out_dir, f".tmp_{i:02d}.mp4") - shuffle_render._concat_reencode(paths, tmp) - track = audio_paths[(i - 1) % len(audio_paths)] - shuffle_render.attach_audio(tmp, track, out) - os.remove(tmp) - else: - shuffle_render._concat_reencode(paths, out) - size = os.path.getsize(out) - results.append({"name": name, "path": out, "sequence": seq, "size": size}) - h.item_status(it, "done", detail=f"{size//1024} KB", result={ - "name": name, "size": size, "sequence": seq, - "url": f"/api/files/{req.session}/variations/{name}"}) - except Exception as e: - h.item_status(it, "error", error=str(e)) - h.set_progress(i / max(1, n)) - zp = os.path.join(session_dir(req.session), "variations.zip") - shuffle_render.zip_variations(results, zp) - return {"session": req.session, "count": len(results), "zip": "variations.zip"} - - jobs.submit(job, work) - return {"job_id": job.id, "session": req.session, "planned": len(sequences)} diff --git a/app/config.py b/app/config.py deleted file mode 100644 index 42c473e2adb523e282d65bc4aedc8a254978b960..0000000000000000000000000000000000000000 --- a/app/config.py +++ /dev/null @@ -1,70 +0,0 @@ -"""Cấu hình ứng dụng. Đọc từ biến môi trường (xem .env.example).""" - -from __future__ import annotations - -import os -import tempfile -from dataclasses import dataclass, field - -BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) -BACKEND_DIR = BASE_DIR -try: - from dotenv import load_dotenv - load_dotenv(os.path.join(BACKEND_DIR, ".env")) -except Exception: - pass - -def _env(key: str, default: str = "") -> str: - return os.environ.get(key, default) - - -@dataclass -class Settings: - # Vùng LÀM VIỆC TẠM theo phiên (không phải kho lưu trữ): mặc định nằm trong - # thư mục temp của hệ điều hành để không đọng lại trong project. Data xử lý - # xong là trả cho user tải về rồi tự dọn. - STORAGE_DIR: str = field( - default_factory=lambda: _env( - "STORAGE_DIR", os.path.join(tempfile.gettempdir(), "tnt_work") - ) - ) - # API keys cho pipeline lồng tiếng - GROQ_API_KEY: str = field(default_factory=lambda: _env("GROQ_API_KEY")) - GOOGLE_API_KEY: str = field(default_factory=lambda: _env("GOOGLE_API_KEY")) - # API keys cho Listing ảnh - OPENAI_API_KEY: str = field(default_factory=lambda: _env("OPENAI_API_KEY")) - OPENAI_IMAGE_API_KEY: str = field(default_factory=lambda: _env("OPENAI_IMAGE_API_KEY")) - - # Database cho user auth (để trống thì dùng JSON file) - DATABASE_URL: str = field(default_factory=lambda: _env("DATABASE_URL", "")) - - # Danh sách user được dùng key chung (cách nhau bằng dấu phẩy) - AUTHORIZED_USERS: list[str] = field( - default_factory=lambda: [u.strip() for u in _env("AUTHORIZED_USERS", "").split(",") if u.strip()] - ) - - # Video Gen (Gradio proxy) - VIDEO_ADMIN_TOKEN: str = field(default_factory=lambda: _env("VIDEO_ADMIN_TOKEN")) - - # model TTS / config - DEMUCS_MODEL: str = field(default_factory=lambda: _env("DEMUCS_MODEL", "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")) - - # giới hạn - MAX_LINKS: int = 200 - MAX_UPLOAD_MB: int = 2048 - # Phiên tạm tự dọn sau ngần này giờ (mặc định 6h — đủ để xử lý + tải về). - SESSION_TTL_HOURS: int = field( - default_factory=lambda: int(_env("SESSION_TTL_HOURS", "6"))) - - CORS_ORIGINS: list[str] = field( - default_factory=lambda: _env("CORS_ORIGINS", "http://localhost:5173").split(",") - ) - - def __post_init__(self): - os.makedirs(self.STORAGE_DIR, exist_ok=True) - - -settings = Settings() diff --git a/app/core/files.py b/app/core/files.py deleted file mode 100644 index 8328f766a69954cb58e0c44a50f39e7baa1fe1a6..0000000000000000000000000000000000000000 --- a/app/core/files.py +++ /dev/null @@ -1,86 +0,0 @@ -"""Quản lý thư mục lưu trữ theo phiên (session) và đóng gói zip.""" - -from __future__ import annotations - -import os -import shutil -import time -import uuid -import zipfile - -from ..config import settings - - -_last_sweep = 0.0 - - -def new_session(tool: str) -> str: - """Tạo session id + thư mục tạm cho 1 phiên làm việc. Tiện thể dọn phiên cũ.""" - _maybe_sweep() - sid = f"{tool}_{int(time.time())}_{uuid.uuid4().hex[:6]}" - os.makedirs(session_dir(sid), exist_ok=True) - return sid - - -def _maybe_sweep(min_interval_sec: float = 600.0): - """Dọn phiên quá hạn, tối đa ~10 phút/lần để khỏi tốn tài nguyên.""" - global _last_sweep - now = time.time() - if now - _last_sweep < min_interval_sec: - return - _last_sweep = now - try: - cleanup_old(settings.SESSION_TTL_HOURS) - except Exception: - pass - - -def session_dir(sid: str) -> str: - return os.path.join(settings.STORAGE_DIR, sid) - - -def sub_dir(sid: str, *parts: str) -> str: - d = os.path.join(session_dir(sid), *parts) - os.makedirs(d, exist_ok=True) - return d - - -def save_upload(sid: str, filename: str, data: bytes, folder: str = "uploads") -> str: - d = sub_dir(sid, folder) - safe = os.path.basename(filename).replace("/", "_") - path = os.path.join(d, safe) - with open(path, "wb") as f: - f.write(data) - return path - - -def zip_paths(paths: list[str], zip_path: str, arcnames: list[str] | None = None) -> str: - with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf: - for i, p in enumerate(paths): - arc = arcnames[i] if arcnames else os.path.basename(p) - zf.write(p, arcname=arc) - return zip_path - - -def delete_session(sid: str) -> bool: - """Xoá hẳn một phiên (gọi sau khi user đã tải kết quả về máy).""" - p = session_dir(sid) - if os.path.isdir(p): - shutil.rmtree(p, ignore_errors=True) - return True - return False - - -def cleanup_old(max_age_hours: float = 6): - """Dọn các phiên tạm quá hạn (mặc định 6 giờ).""" - now = time.time() - root = settings.STORAGE_DIR - if not os.path.isdir(root): - return - for name in os.listdir(root): - p = os.path.join(root, name) - try: - if now - os.path.getmtime(p) > max_age_hours * 3600: - shutil.rmtree(p, ignore_errors=True) - except OSError: - pass diff --git a/app/core/jobs.py b/app/core/jobs.py deleted file mode 100644 index 1d3a5b060d70e751b35c87bb1ced5befceb09570..0000000000000000000000000000000000000000 --- a/app/core/jobs.py +++ /dev/null @@ -1,151 +0,0 @@ -"""Quản lý job nền: trạng thái, log, tiến độ, và trạng thái từng item con. - -Không phụ thuộc FastAPI -> test độc lập được. Dùng ThreadPool để chạy nền. -""" - -from __future__ import annotations - -import threading -import time -import traceback -import uuid -from concurrent.futures import ThreadPoolExecutor -from dataclasses import asdict, dataclass, field -from typing import Any, Callable - -QUEUED, RUNNING, DONE, ERROR, CANCELLED = "queued", "running", "done", "error", "cancelled" - - -@dataclass -class LogLine: - t: float - level: str - msg: str - - -@dataclass -class JobItem: - """Một item con (vd: 1 link tải, 1 video dịch).""" - id: str - label: str - status: str = QUEUED # queued|running|done|error - detail: str = "" - error: str = "" - result: dict | None = None - - -@dataclass -class Job: - id: str - kind: str - status: str = QUEUED - progress: float = 0.0 - logs: list[LogLine] = field(default_factory=list) - items: list[JobItem] = field(default_factory=list) - result: dict | None = None - error: str = "" - created_at: float = field(default_factory=time.time) - - def to_dict(self) -> dict: - return { - "id": self.id, - "kind": self.kind, - "status": self.status, - "progress": round(self.progress, 4), - "logs": [asdict(l) for l in self.logs[-500:]], - "items": [asdict(i) for i in self.items], - "result": self.result, - "error": self.error, - "created_at": self.created_at, - "failed_items": [ - {"id": i.id, "label": i.label, "error": i.error} - for i in self.items if i.status == ERROR - ], - } - - -class JobHandle: - """Trao cho hàm worker để cập nhật job một cách thread-safe.""" - - def __init__(self, manager: "JobManager", job: Job): - self._m = manager - self.job = job - - def log(self, msg: str, level: str = "info"): - with self._m._lock: - self.job.logs.append(LogLine(time.time(), level, msg)) - - def set_progress(self, p: float): - with self._m._lock: - self.job.progress = max(0.0, min(1.0, p)) - - def add_item(self, label: str, item_id: str | None = None) -> JobItem: - it = JobItem(id=item_id or uuid.uuid4().hex[:8], label=label) - with self._m._lock: - self.job.items.append(it) - return it - - def item_status(self, it: JobItem, status: str, detail: str = "", - error: str = "", result: dict | None = None): - with self._m._lock: - it.status = status - if detail: - it.detail = detail - if error: - it.error = error - if result is not None: - it.result = result - - def cancelled(self) -> bool: - return self._m._cancel.get(self.job.id, False) - - -class JobManager: - def __init__(self, max_workers: int = 4): - self._jobs: dict[str, Job] = {} - self._lock = threading.RLock() - self._pool = ThreadPoolExecutor(max_workers=max_workers) - self._cancel: dict[str, bool] = {} - - def create(self, kind: str) -> Job: - job = Job(id=uuid.uuid4().hex[:12], kind=kind) - with self._lock: - self._jobs[job.id] = job - return job - - def get(self, job_id: str) -> Job | None: - return self._jobs.get(job_id) - - def cancel(self, job_id: str): - self._cancel[job_id] = True - job = self.get(job_id) - if job and job.status in (QUEUED, RUNNING): - with self._lock: - job.status = CANCELLED - - def submit(self, job: Job, fn: Callable[[JobHandle], Any]): - """Chạy fn(handle) ở thread nền; tự set status/result/error.""" - handle = JobHandle(self, job) - - def runner(): - with self._lock: - job.status = RUNNING - try: - result = fn(handle) - with self._lock: - if job.status != CANCELLED: - job.status = DONE - job.progress = 1.0 - if isinstance(result, dict): - job.result = result - except Exception as e: # pragma: no cover - lỗi runtime - with self._lock: - job.status = ERROR - job.error = f"{e}" - handle.log(traceback.format_exc(), level="error") - - self._pool.submit(runner) - - -# instance dùng chung toàn app -jobs = JobManager() diff --git a/app/main.py b/app/main.py deleted file mode 100644 index efb76fb10e4555e7203303bf601bafbd8c041bec..0000000000000000000000000000000000000000 --- a/app/main.py +++ /dev/null @@ -1,83 +0,0 @@ -"""TNT Group - AI Content Create — FastAPI entrypoint. - -Chạy (từ thư mục gốc project): - uvicorn app.main:app --reload --host 0.0.0.0 --port 8000 - -Cần Python 3.10+ và ffmpeg/ffprobe trong PATH. Các thư viện nặng -(yt-dlp, groq, google-generativeai, demucs, TTS...) chỉ cần khi dùng -tool tương ứng — xem requirements.txt. -""" - -from __future__ import annotations - -import os -import sys - -from fastapi import FastAPI -from fastapi.middleware.cors import CORSMiddleware -from fastapi.responses import RedirectResponse, FileResponse -from fastapi.staticfiles import StaticFiles - -from .config import settings -from .core.files import cleanup_old -_here = os.path.dirname(os.path.abspath(__file__)) -_parent = os.path.dirname(_here) -sys.path.insert(0, _parent) - -from backend.app.api import common, download, cut, shuffle, dub -from .api import listing, video, auth - -app = FastAPI(title="TNT Group - AI Content Create", version="1.0.0") - -app.add_middleware( - CORSMiddleware, - allow_origins=settings.CORS_ORIGINS or ["*"], - allow_credentials=True, - allow_methods=["*"], - allow_headers=["*"], -) - -app.include_router(common.router) -app.include_router(download.router) -app.include_router(cut.router) -app.include_router(shuffle.router) -app.include_router(dub.router) -app.include_router(listing.router) -app.include_router(video.router) -app.include_router(auth.router) - - -@app.get("/api/health") -def health(): - return {"ok": True, "name": "tnt-content-ai", "version": "1.0.0"} - - -@app.get("/logo.png") -def logo_png(): - return RedirectResponse(url="/logo.svg") - - -@app.on_event("startup") -def _startup(): - os.makedirs(settings.STORAGE_DIR, exist_ok=True) - try: - cleanup_old(settings.SESSION_TTL_HOURS) - except Exception: - pass - - -# Phục vụ frontend đã build (frontend/dist) nếu có — gắn CUỐI để không nuốt /api. -_here = os.path.dirname(os.path.abspath(__file__)) -_candidates = [ - os.path.join(_here, "..", "..", "frontend", "dist"), # local dev - os.path.join(_here, "..", "frontend", "dist"), # HF Spaces - "/app/frontend/dist", # Docker -] -_dist = "" -for p in _candidates: - p = os.path.abspath(p) - if os.path.isdir(p): - _dist = p - break -if _dist and os.path.isdir(_dist): - app.mount("/", StaticFiles(directory=_dist, html=True), name="frontend") diff --git a/app/services/cutter/__init__.py b/app/services/cutter/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/app/services/cutter/cut.py b/app/services/cutter/cut.py deleted file mode 100644 index 5a39c3562fda036e7de208f739cda94f26d64731..0000000000000000000000000000000000000000 --- a/app/services/cutter/cut.py +++ /dev/null @@ -1,85 +0,0 @@ -"""Thực thi cắt: ffmpeg frame-accurate, KHÔNG TIẾNG (-an), thumbnail strip, zip.""" - -from __future__ import annotations - -import os -import shutil -import subprocess -import zipfile -from dataclasses import dataclass - -from .modes import Segment -from .probe import FFMPEG, VideoInfo, probe - - -@dataclass -class ClipResult: - index: int - path: str - start_time: float - end_time: float - duration: float - size: int - - -def cut_segment(src: str, seg: Segment, out_path: str) -> ClipResult: - """Cắt 1 khúc frame-accurate, re-encode (đảm bảo đúng frame, không thừa/thiếu), - loại bỏ audio (-an).""" - 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 - cmd = [ - FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-ss", f"{start:.6f}", "-i", src, - "-frames:v", str(nframes), - "-an", # KHÔNG TIẾNG - "-c:v", "libx264", "-preset", "veryfast", "-crf", "20", - "-pix_fmt", "yuv420p", - "-vsync", "cfr", - out_path, - ] - subprocess.run(cmd, check=True, capture_output=True) - return ClipResult( - index=seg.index, - path=out_path, - start_time=round(seg.start_time, 3), - end_time=round(seg.end_time, 3), - duration=round(seg.duration, 3), - size=os.path.getsize(out_path), - ) - - -def cut_all(src: str, segments: list[Segment], out_dir: str, - prefix: str = "clip") -> list[ClipResult]: - os.makedirs(out_dir, exist_ok=True) - results = [] - for seg in segments: - name = f"{prefix}_{seg.index + 1:03d}.mp4" - results.append(cut_segment(src, seg, os.path.join(out_dir, name))) - return results - - -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).""" - os.makedirs(out_dir, exist_ok=True) - count = max(2, count) - thumbs = [] - for i in range(count): - t = info.duration * i / count - name = f"thumb_{i:03d}.jpg" - path = os.path.join(out_dir, name) - cmd = [ - FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-ss", f"{t:.3f}", "-i", info.path, - "-frames:v", "1", "-vf", "scale=160:-1", path, - ] - subprocess.run(cmd, check=True, capture_output=True) - thumbs.append({"time": round(t, 3), "path": path}) - return thumbs - - -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_path diff --git a/app/services/cutter/modes.py b/app/services/cutter/modes.py deleted file mode 100644 index eb481385b8ff6c89345999e25afd407eb44adaa5..0000000000000000000000000000000000000000 --- a/app/services/cutter/modes.py +++ /dev/null @@ -1,265 +0,0 @@ -"""4 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. -- 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). - -Boundary = (start_frame, end_frame) — end_frame exclusive theo frame index. -""" - -from __future__ import annotations - -from dataclasses import dataclass - -import numpy as np - -from .probe import VideoInfo - - -@dataclass -class Segment: - index: int - start_frame: int - end_frame: int # exclusive - fps: float - - @property - def start_time(self) -> float: - return self.start_frame / self.fps - - @property - def end_time(self) -> float: - return self.end_frame / self.fps - - @property - def duration(self) -> float: - return (self.end_frame - self.start_frame) / self.fps - - def to_dict(self) -> dict: - return { - "index": self.index, - "start_frame": self.start_frame, - "end_frame": self.end_frame, - "start_time": round(self.start_time, 3), - "end_time": round(self.end_time, 3), - "duration": round(self.duration, 3), - } - - -def _segments_from_cuts(cut_frames: list[int], total: int, fps: float) -> list[Segment]: - """cut_frames = các điểm cắt (frame index). Bao gồm 0 và total ở 2 đầu.""" - pts = sorted(set([0, *[c for c in cut_frames if 0 < c < total], total])) - segs = [] - for i in range(len(pts) - 1): - segs.append(Segment(i, pts[i], pts[i + 1], fps)) - return segs - - -# ----------------------------------------------------------------- even ------ - -def even_cut(info: VideoInfo, n: int) -> list[Segment]: - n = max(1, n) - total = info.nb_frames - # chia đều theo frame, phần dư rải vào các khúc đầu để KHÔNG thừa/thiếu frame nào - base, rem = divmod(total, n) - cuts, acc = [], 0 - for i in range(n): - acc += base + (1 if i < rem else 0) - cuts.append(acc) - return _segments_from_cuts(cuts[:-1], total, info.fps) - - -def auto_segment_count(info: VideoInfo, target_len: float = 6.0) -> int: - """Máy tự đề xuất số khúc dựa trên độ dài mục tiêu mỗi khúc (giây).""" - if info.duration <= 0: - return 1 - return max(1, round(info.duration / max(0.5, target_len))) - - -# -------------------------------------------------------- scene / highlight -- - -def _frame_signals(path: str, max_dim: int = 160): - """Quét video 1 lần, trả (hist_diff[], motion[]) theo từng frame (chuẩn hóa).""" - import cv2 - - cap = cv2.VideoCapture(path) - prev_gray = None - prev_hist = None - hist_diff: list[float] = [0.0] - motion: list[float] = [0.0] - - while True: - ok, frame = cap.read() - if not ok: - break - h, w = frame.shape[:2] - scale = max_dim / max(h, w) - if scale < 1: - frame = cv2.resize(frame, (int(w * scale), int(h * scale))) - gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) - hist = cv2.calcHist([frame], [0, 1, 2], None, [8, 8, 8], - [0, 256, 0, 256, 0, 256]) - cv2.normalize(hist, hist) - - if prev_hist is not None: - d = cv2.compareHist(prev_hist, hist, cv2.HISTCMP_BHATTACHARYYA) - hist_diff.append(float(d)) - m = float(np.mean(cv2.absdiff(gray, prev_gray))) - motion.append(m) - prev_gray, prev_hist = gray, hist - - cap.release() - return np.array(hist_diff), np.array(motion) - - -def scene_cut(info: VideoInfo, min_len: float = 1.5, sensitivity: float = 0.5) -> list[Segment]: - """Cắt tại các điểm chuyển cảnh; khúc < min_len gộp với khúc liền kề.""" - hist_diff, _ = _frame_signals(info.path) - if len(hist_diff) < 2: - return even_cut(info, 1) - - # ngưỡng = mean + k*std, k tỉ lệ nghịch với sensitivity - k = 3.0 - 2.0 * float(np.clip(sensitivity, 0, 1)) # sensitivity 1 -> k=1, 0 -> k=3 - thr = hist_diff.mean() + k * hist_diff.std() - raw_cuts = [int(i) for i in np.where(hist_diff > thr)[0] if i > 0] - - segs = _segments_from_cuts(raw_cuts, info.nb_frames, info.fps) - return _merge_short(segs, info.fps, min_len) - - -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.""" - _, motion = _frame_signals(info.path) - if len(motion) < 2: - return even_cut(info, 1) - - thr = np.quantile(motion, 1.0 - float(np.clip(top_ratio, 0.05, 0.95))) - hot = motion >= thr - - fps = info.fps - pad_f = int(pad * fps) - min_f = int(min_len * fps) - total = info.nb_frames - - # gom các frame "nóng" liền nhau thành đoạn, nới biên pad, lọc đoạn ngắn - spans: list[tuple[int, int]] = [] - i = 0 - while i < len(hot): - if hot[i]: - j = i - while j < len(hot) and hot[j]: - j += 1 - s = max(0, i - pad_f) - e = min(total, j + pad_f) - if e - s >= min_f: - spans.append((s, e)) - i = j - else: - i += 1 - - if not spans: - return even_cut(info, max(1, auto_segment_count(info))) - - # merge spans chồng lấn - spans.sort() - merged = [list(spans[0])] - for s, e in spans[1:]: - if s <= merged[-1][1]: - merged[-1][1] = max(merged[-1][1], e) - else: - merged.append([s, e]) - - return [Segment(i, s, e, fps) for i, (s, e) in enumerate(merged)] - - -def smart_cut(info: VideoInfo, n: int | None = None) -> list[Segment]: - """Cắt theo ngữ nghĩa bằng CLIP. Cần `torch` + `open_clip_torch`. - - Lấy embedding CLIP cho frame mẫu, phát hiện điểm ngữ nghĩa đổi mạnh - (cosine distance giữa frame liền kề vượt ngưỡng) -> điểm cắt. - Nếu thiếu thư viện/model -> fallback sang scene_cut. - """ - try: - import torch # noqa: F401 - import open_clip # noqa: F401 - except Exception: - # Fallback an toàn để luồng không vỡ khi chưa cài model. - return scene_cut(info) - - return _smart_cut_clip(info, n) - - -def _smart_cut_clip(info: VideoInfo, n: int | None) -> list[Segment]: # pragma: no cover - import cv2 - import numpy as np - import open_clip - import torch - - device = "cuda" if torch.cuda.is_available() else "cpu" - model, _, preprocess = open_clip.create_model_and_transforms( - "ViT-B-32", pretrained="laion2b_s34b_b79k" - ) - model = model.to(device).eval() - - cap = cv2.VideoCapture(info.path) - fps = info.fps - step = max(1, int(fps)) # 1 frame/giây - feats, frame_idx = [], [] - idx = 0 - from PIL import Image - while True: - ok, frame = cap.read() - if not ok: - break - if idx % step == 0: - img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) - with torch.no_grad(): - t = preprocess(img).unsqueeze(0).to(device) - f = model.encode_image(t) - f = f / f.norm(dim=-1, keepdim=True) - feats.append(f.cpu().numpy()[0]) - frame_idx.append(idx) - idx += 1 - cap.release() - - if len(feats) < 2: - return scene_cut(info) - feats = np.array(feats) - dist = 1.0 - np.sum(feats[1:] * feats[:-1], axis=1) - thr = dist.mean() + dist.std() - cuts = [frame_idx[i + 1] for i in np.where(dist > thr)[0]] - segs = _segments_from_cuts(cuts, info.nb_frames, info.fps) - return _merge_short(segs, info.fps, 1.5) - - -# ----------------------------------------------------------------- helpers --- - -def _merge_short(segs: list[Segment], fps: float, min_len: float) -> list[Segment]: - if not segs: - return segs - min_f = int(min_len * fps) - merged: list[Segment] = [] - for s in segs: - if merged and (s.end_frame - merged[-1].start_frame) and \ - (s.end_frame - s.start_frame) < min_f: - merged[-1] = Segment(merged[-1].index, merged[-1].start_frame, - s.end_frame, fps) - else: - merged.append(Segment(len(merged), s.start_frame, s.end_frame, fps)) - # đánh số lại - return [Segment(i, m.start_frame, m.end_frame, fps) for i, m in enumerate(merged)] - - -def build_segments(info: VideoInfo, mode: str, **kw) -> list[Segment]: - 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)) - if mode == "highlight": - return highlight_cut(info, kw.get("top_ratio", 0.4), kw.get("min_len", 2.0)) - if mode == "smart": - return smart_cut(info, kw.get("n")) - raise ValueError(f"unknown mode: {mode}") diff --git a/app/services/cutter/probe.py b/app/services/cutter/probe.py deleted file mode 100644 index dbaab8b872cd01b7266e6cdd2d680809dec992b5..0000000000000000000000000000000000000000 --- a/app/services/cutter/probe.py +++ /dev/null @@ -1,63 +0,0 @@ -"""Đọc metadata video bằng ffprobe để cắt frame-accurate.""" - -from __future__ import annotations - -import json -import shutil -import subprocess -from dataclasses import dataclass - -FFPROBE = shutil.which("ffprobe") or "ffprobe" -FFMPEG = shutil.which("ffmpeg") or "ffmpeg" - - -@dataclass -class VideoInfo: - path: str - duration: float # giây - fps: float # khung hình/giây (đã quy đổi từ r_frame_rate) - nb_frames: int # tổng số frame (ước lượng nếu thiếu) - width: int - height: int - - @property - def frame_dur(self) -> float: - return 1.0 / self.fps if self.fps else 0.0 - - -def _parse_rate(rate: str) -> float: - if not rate or rate == "0/0": - return 0.0 - if "/" in rate: - num, den = rate.split("/") - den = float(den) - return float(num) / den if den else 0.0 - return float(rate) - - -def probe(path: str) -> VideoInfo: - 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) - - vstream = next(s for s in data["streams"] if s["codec_type"] == "video") - fps = _parse_rate(vstream.get("avg_frame_rate") or "") or _parse_rate( - vstream.get("r_frame_rate") or "" - ) - duration = float( - 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)) - - return VideoInfo( - path=path, - duration=duration, - fps=fps or 30.0, - nb_frames=nb_frames, - width=int(vstream.get("width", 0)), - height=int(vstream.get("height", 0)), - ) diff --git a/app/services/downloader/__init__.py b/app/services/downloader/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/app/services/downloader/ydl.py b/app/services/downloader/ydl.py deleted file mode 100644 index d441901e76bae6d9af05ab2ff94bf436aa12b0f9..0000000000000000000000000000000000000000 --- a/app/services/downloader/ydl.py +++ /dev/null @@ -1,168 +0,0 @@ -"""Tải video hàng loạt từ nhiều nguồn bằng yt-dlp. - -Hỗ trợ: YouTube, Facebook, TikTok, Douyin, Shopee, 1688, Taobao, ... -Tải đúng CHẤT LƯỢNG GỐC như trên link. - -Lưu ý môi trường: -- Cần `pip install yt-dlp` và có mạng. -- Một số nguồn (Shopee/1688/Taobao) có thể cần cookies; truyền qua `cookies_file`. -""" - -from __future__ import annotations - -import os -import re -from dataclasses import dataclass -from typing import Callable - -URL_RE = re.compile(r"https?://[^\s]+") -ANSI_RE = re.compile(r"\x1b\[[0-9;]*m") - - -@dataclass -class DownloadResult: - url: str - ok: bool - path: str = "" - title: str = "" - ext: str = "" - size: int = 0 - duration: float = 0.0 - thumbnail: str = "" - error: str = "" - - -def clean_error(s) -> str: - """Bỏ mã màu ANSI + tiền tố ERROR, rút gọn để hiển thị gọn gàng.""" - s = ANSI_RE.sub("", str(s or "")) - s = s.replace("ERROR:", "").replace("\n", " ").strip() - return (s[:240] + "…") if len(s) > 240 else s - - -def normalize_url(url: str) -> str: - """Chuẩn hóa một số dạng link để yt-dlp tải được. - - - Douyin 'jingxuan?modal_id=ID' / '?modal_id=ID' -> '/video/ID' - - Bỏ các tham số rác phía sau cho douyin video. - """ - u = (url or "").strip() - m = re.search(r"douyin\.com/.*?[?&]modal_id=(\d+)", u) - if m: - return f"https://www.douyin.com/video/{m.group(1)}" - m = re.search(r"douyin\.com/video/(\d+)", u) - if m: - return f"https://www.douyin.com/video/{m.group(1)}" - return u - - -def parse_links(raw: str, max_links: int = 200) -> list[str]: - """Tách danh sách link: mỗi dòng 1 link, chuẩn hóa, bỏ trùng, giữ thứ tự.""" - seen, out = set(), [] - for line in raw.splitlines(): - line = line.strip() - if not line: - continue - m = URL_RE.search(line) - url = m.group(0) if m else line - url = normalize_url(url) - if url not in seen: - seen.add(url) - out.append(url) - if len(out) >= max_links: - break - return out - - -def detect_source(url: str) -> str: - u = url.lower() - table = { - "youtube": ["youtube.com", "youtu.be"], - "tiktok": ["tiktok.com"], - "douyin": ["douyin.com", "iesdouyin.com"], - "facebook": ["facebook.com", "fb.watch", "fb.com"], - "shopee": ["shopee."], - "1688": ["1688.com"], - "taobao": ["taobao.com", "tmall.com"], - "drive": ["drive.google.com"], - "instagram": ["instagram.com"], - } - for name, keys in table.items(): - if any(k in u for k in keys): - return name - return "other" - - -def _build_opts(out_dir: str, cookies_file: str | None, generic: bool = False) -> dict: - opts = { - "outtmpl": os.path.join(out_dir, "%(title).80s [%(id)s].%(ext)s"), - "format": "bv*+ba/b", - "merge_output_format": "mp4", - "noplaylist": True, - "quiet": True, - "no_warnings": True, - "retries": 3, - "concurrent_fragment_downloads": 4, - "writethumbnail": False, - } - if generic: - # thử quét video nhúng trong trang (Shopee/1688/Taobao... không có extractor riêng) - opts["force_generic_extractor"] = True - if cookies_file and os.path.exists(cookies_file): - opts["cookiefile"] = cookies_file - return opts - - -def _attempt(url: str, out_dir: str, opts: dict) -> DownloadResult: - import yt_dlp # type: ignore - with yt_dlp.YoutubeDL(opts) as ydl: - info = ydl.extract_info(url, download=True) - path = ydl.prepare_filename(info) - base, _ = os.path.splitext(path) - if not os.path.exists(path) and os.path.exists(base + ".mp4"): - path = base + ".mp4" - size = os.path.getsize(path) if os.path.exists(path) else 0 - return DownloadResult( - url=url, ok=True, path=path, - title=info.get("title", "") or os.path.basename(base), - ext=os.path.splitext(path)[1].lstrip("."), - size=size, - duration=float(info.get("duration") or 0), - thumbnail=info.get("thumbnail", "") or "", - ) - - -def download_one(url: str, out_dir: str, cookies_file: str | None = None) -> DownloadResult: - try: - import yt_dlp # noqa: F401 # type: ignore - except Exception as e: # pragma: no cover - return DownloadResult(url=url, ok=False, - error=clean_error(f"yt-dlp chưa được cài đặt: {e}")) - - os.makedirs(out_dir, exist_ok=True) - url = normalize_url(url) - source = detect_source(url) - try: - return _attempt(url, out_dir, _build_opts(out_dir, cookies_file)) - except Exception as e: # pragma: no cover - lỗi mạng/extractor - first_err = clean_error(e) - # Shopee/1688/Taobao: thử lại bằng generic extractor (quét video trong trang) - if source in ("shopee", "1688", "taobao"): - try: - return _attempt(url, out_dir, _build_opts(out_dir, cookies_file, generic=True)) - except Exception as e2: - return DownloadResult(url=url, ok=False, - error=clean_error(f"{source}: {e2}")) - return DownloadResult(url=url, ok=False, error=first_err) - - -def download_many(urls: list[str], out_dir: str, - cookies_file: str | None = None, - on_item: Callable[[int, DownloadResult], None] | None = None - ) -> list[DownloadResult]: - results = [] - for i, url in enumerate(urls): - res = download_one(url, out_dir, cookies_file) - results.append(res) - if on_item: - on_item(i, res) - return results diff --git a/app/services/dubber/__init__.py b/app/services/dubber/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/app/services/dubber/asr.py b/app/services/dubber/asr.py deleted file mode 100644 index 136581e3847b8873f8866365eb81abf6d73a7853..0000000000000000000000000000000000000000 --- a/app/services/dubber/asr.py +++ /dev/null @@ -1,86 +0,0 @@ -"""Bước NHẬN DẠNG (ASR) — Whisper large-v3 qua API Groq. - -- response_format=verbose_json, lấy segment kèm timestamp + no_speech_prob + avg_logprob. -- Lọc đoạn không phải giọng nói thật; nếu lọc sạch hết thì GIỮ NGUYÊN để không mất nội dung. -- Gộp các mảnh vụn thành CÂU trọn vẹn để ngữ điệu mượt & ngân sách thời gian có nghĩa. -""" - -from __future__ import annotations - -import re -from dataclasses import dataclass - -from ...config import settings - - -@dataclass -class Segment: - start: float - end: float - text: str - - @property - def dur(self) -> float: - return max(0.0, self.end - self.start) - - -def transcribe(asr_wav: str, model: str | None = None) -> tuple[list[Segment], str]: - """Trả (segments, language). Cần GROQ_API_KEY và `pip install groq`.""" - from groq import Groq # type: ignore - - client = Groq(api_key=settings.GROQ_API_KEY) - with open(asr_wav, "rb") as f: - resp = client.audio.transcriptions.create( - file=(asr_wav, f.read()), - model=model or settings.WHISPER_MODEL, - response_format="verbose_json", - temperature=0.0, - ) - data = resp.model_dump() if hasattr(resp, "model_dump") else resp - language = data.get("language", "") - raw = data.get("segments", []) or [] - - kept = _filter_speech(raw) - if not kept: # đừng để mất nội dung - kept = [Segment(s["start"], s["end"], s["text"].strip()) for s in raw] - sentences = merge_into_sentences(kept) - return sentences, language - - -def _filter_speech(raw: list[dict], - no_speech_max: float = 0.6, - logprob_min: float = -1.0) -> list[Segment]: - out = [] - for s in raw: - text = (s.get("text") or "").strip() - if not text: - continue - if s.get("no_speech_prob", 0.0) > no_speech_max: - continue - if s.get("avg_logprob", 0.0) < logprob_min: - continue - out.append(Segment(float(s["start"]), float(s["end"]), text)) - return out - - -_SENT_END = re.compile(r"[.!?。!?…]['\"”’)]?\s*$") - - -def merge_into_sentences(segs: list[Segment], max_gap: float = 0.6, - max_dur: float = 12.0) -> list[Segment]: - """Gộp các mảnh Whisper thành câu trọn vẹn.""" - if not segs: - return [] - out: list[Segment] = [] - cur = Segment(segs[0].start, segs[0].end, segs[0].text) - for nxt in segs[1:]: - gap = nxt.start - cur.end - ends_sentence = bool(_SENT_END.search(cur.text)) - too_long = (nxt.end - cur.start) > max_dur - if ends_sentence or gap > max_gap or too_long: - out.append(cur) - cur = Segment(nxt.start, nxt.end, nxt.text) - else: - cur = Segment(cur.start, nxt.end, (cur.text + " " + nxt.text).strip()) - out.append(cur) - return out diff --git a/app/services/dubber/audio.py b/app/services/dubber/audio.py deleted file mode 100644 index 17b6a2643732f3c2a3b82c31c9ec424fe001d18d..0000000000000000000000000000000000000000 --- a/app/services/dubber/audio.py +++ /dev/null @@ -1,114 +0,0 @@ -"""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. -- 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). -""" - -from __future__ import annotations - -import os -import shutil -import subprocess -from dataclasses import dataclass - -FFMPEG = shutil.which("ffmpeg") or "ffmpeg" - - -@dataclass -class AudioBundle: - asr_wav: str # 16k mono cho Whisper - 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 - - -def _run(cmd: list[str]): - subprocess.run(cmd, check=True, capture_output=True) - - -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") - _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", "2", "-ar", "44100", full_wav]) - return asr_wav, full_wav - - -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", - "-t", f"{dur:.3f}", out]) - - -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 _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). - - Cần `pip install demucs`. Nếu thiếu -> raise để pipeline fallback duck. - """ - 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", - "-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") - 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": - 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}") - - -def cut_clone_sample(voice_wav: str, out_dir: str, start: float = 0.0, - length: float = 15.0) -> str: - """Cắt ~10-20s từ lúc bắt đầu nói làm mẫu clone.""" - sample = os.path.join(out_dir, "clone_sample.wav") - _run([FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-ss", f"{start:.3f}", "-i", voice_wav, "-t", f"{length:.3f}", - "-ac", "1", "-ar", "24000", sample]) - return sample - - -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) diff --git a/app/services/dubber/mux.py b/app/services/dubber/mux.py deleted file mode 100644 index 1cbc725eeb0b396a7d3c95197d6af2f4f5e98ba6..0000000000000000000000000000000000000000 --- a/app/services/dubber/mux.py +++ /dev/null @@ -1,127 +0,0 @@ -"""Bước GHÉP (mux). - -- Neo mỗi câu vào ĐÚNG mốc thời gian gốc (không dồn-đẩy gây trôi tích lũy). -- Tinh chỉnh phần dư bằng atempo có KẸP TRẦN để không méo tiếng. -- Ép câu cuối nằm gọn trong phần video còn lại (không mất đuôi). -- Trộn các câu đã đọc LÊN TRÊN nhạc nền rồi mux vào luồng hình gốc. -""" - -from __future__ import annotations - -import os -import shutil -import subprocess -from dataclasses import dataclass - -FFMPEG = shutil.which("ffmpeg") or "ffmpeg" -ATEMPO_MAX = 1.5 # trần tăng tốc (không méo) -ATEMPO_MIN = 0.7 # sàn (chậm lại) - - -def wav_duration(path: str) -> float: - out = subprocess.run( - ["ffprobe", "-v", "error", "-show_entries", "format=duration", - "-of", "csv=p=0", path], capture_output=True, text=True).stdout.strip() - try: - return float(out) - except ValueError: - return 0.0 - - -def _atempo_chain(ratio: float) -> str: - """ffmpeg atempo chỉ nhận 0.5..2.0; ghép nhiều bộ lọc nếu cần.""" - ratio = max(0.25, min(4.0, ratio)) - parts = [] - while ratio > 2.0: - parts.append("atempo=2.0") - ratio /= 2.0 - while ratio < 0.5: - parts.append("atempo=0.5") - ratio /= 0.5 - parts.append(f"atempo={ratio:.4f}") - return ",".join(parts) - - -def fit_to_slot(wav: str, target_dur: float, out: str, - cap: float = ATEMPO_MAX, floor: float = ATEMPO_MIN) -> str: - """Ép câu vào khe target_dur bằng atempo có kẹp trần/sàn. - - - Nếu đọc dài hơn khe: tăng tốc (ratio = dur/target) nhưng không quá cap. - - Nếu ngắn hơn: giữ nguyên (sẽ chèn lặng khi assemble), không kéo dãn gây méo. - """ - dur = wav_duration(wav) - if target_dur <= 0 or dur <= 0: - shutil.copy(wav, out) - return out - ratio = dur / target_dur - if ratio <= 1.0: - shutil.copy(wav, out) # vừa hoặc dư khe -> giữ nguyên - return out - ratio = min(ratio, cap) # KẸP TRẦN - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", "-i", wav, - "-filter:a", _atempo_chain(ratio), out], check=True, capture_output=True) - return out - - -@dataclass -class PlacedLine: - start: float - wav: str - - -def assemble_voice(lines: list[PlacedLine], total_dur: float, out_wav: str) -> str: - """Đặt từng câu đúng mốc start trên 1 track dài total_dur (anchor tuyệt đối).""" - if not lines: - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-f", "lavfi", "-i", "anullsrc=r=44100:cl=stereo", - "-t", f"{total_dur:.3f}", out_wav], check=True, capture_output=True) - return out_wav - - # input 0 = track nền im lặng dài ĐÚNG total_dur làm đáy (đảm bảo đủ độ dài) - inputs = ["-f", "lavfi", "-i", - f"anullsrc=r=44100:cl=stereo:d={total_dur:.3f}"] - filters, amix_in = ["[0:a]aformat=channel_layouts=stereo[base]"], ["[base]"] - for i, ln in enumerate(lines): - idx = i + 1 - inputs += ["-i", ln.wav] - delay_ms = int(max(0.0, ln.start) * 1000) - filters.append( - f"[{idx}:a]aresample=44100,aformat=channel_layouts=stereo," - f"adelay={delay_ms}|{delay_ms}[a{idx}]") - amix_in.append(f"[a{idx}]") - - n = len(lines) + 1 - filtergraph = ";".join(filters) + ";" + "".join(amix_in) + \ - f"amix=inputs={n}:normalize=0:duration=longest[vox]" - - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", *inputs, - "-filter_complex", filtergraph, "-map", "[vox]", - "-t", f"{total_dur:.3f}", out_wav], check=True, capture_output=True) - 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.""" - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-i", bg_wav, "-i", voice_wav, - "-filter_complex", - "[0:a]aresample=44100,aformat=channel_layouts=stereo[bg];" - "[1:a]aresample=44100,aformat=channel_layouts=stereo[vx];" - "[bg][vx]amix=inputs=2:normalize=0:duration=longest[mix]", - "-map", "[mix]", out_wav], check=True, capture_output=True) - return out_wav - - -def mux_to_video(video: str, audio_wav: str, out_mp4: str) -> str: - """Ghép audio mới vào luồng hình gốc (giữ nguyên video).""" - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-i", video, "-i", audio_wav, - "-map", "0:v:0", "-map", "1:a:0", - "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", - "-shortest", out_mp4], check=True, capture_output=True) - return out_mp4 diff --git a/app/services/dubber/pipeline.py b/app/services/dubber/pipeline.py deleted file mode 100644 index 6d8827933b6ab90523fad075fa50a39db7c1e0cf..0000000000000000000000000000000000000000 --- a/app/services/dubber/pipeline.py +++ /dev/null @@ -1,214 +0,0 @@ -"""Nối toàn bộ pipeline lồng tiếng cho 1 video. - -Luồng: tách audio -> nền nhạc -> ASR (Whisper/Groq) -> dịch (Gemini/Groq) -> -[clone] -> TTS theo ngôn ngữ đích -> neo mốc + atempo -> trộn nền -> mux video. -Trả về đường dẫn: video đã dịch, audio giọng clone, subtitle SRT. -""" - -from __future__ import annotations - -import os -from dataclasses import dataclass -from typing import Callable - -from . import asr, audio, mux, translate, tts -from .probe_dur import video_duration - - -@dataclass -class DubOptions: - target_lang: str # en | vi | fil - bg_mode: str = "duck" # none | duck | demucs - do_clone: bool = True - voice_source: str = "video" # preset | video | upload - speaker_wav: str = "" # khi upload/preset đã có sẵn - preset: str = "" - style: str = "natural" - engine: str = "auto" - demucs_model: str = "htdemucs" - multi_speaker: bool = False # ≥3 người nói: clone giọng từng người - - -@dataclass -class DubResult: - video_out: str - audio_out: str - srt_out: str - language: str - n_lines: int - note: str = "" # ghi chú khi phải dùng đường dự phòng - - -def _srt_time(t: float) -> str: - h = int(t // 3600); t -= h * 3600 - m = int(t // 60); t -= m * 60 - s = int(t); ms = int(round((t - s) * 1000)) - return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}" - - -def write_srt(lines: list[translate.TranslatedLine], path: str) -> str: - with open(path, "w", encoding="utf-8") as f: - 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") - return path - - -@dataclass -class TtsOptions: - text: str - target_lang: str = "vi" # en | vi | fil - voice_source: str = "preset" # preset | upload - speaker_wav: str = "" # mẫu clone khi voice_source=upload - preset: str = "" # tên giọng có sẵn - style: str = "natural" - engine: str = "auto" # auto | vieneu | xtts | voxcpm - - -def run_tts(opt: TtsOptions, out_dir: str, - progress: Callable[[float, str], None] | None = None) -> str: - """Sinh 1 đoạn voice từ text nhập vào -> trả về đường dẫn wav. - - Dùng chung engine TTS với pipeline lồng tiếng; chọn model theo ngôn ngữ - (vi->VieNeu, en->XTTS/VoxCPM2, fil->VoxCPM2) hoặc engine người dùng chọn. - """ - os.makedirs(out_dir, exist_ok=True) - if progress: - progress(0.1, "Nạp model giọng") - out_wav = os.path.join(out_dir, "voice.wav") - vcfg = tts.VoiceConfig( - target_lang=opt.target_lang, voice_source=opt.voice_source, - speaker_wav=opt.speaker_wav, preset=opt.preset, style=opt.style, - engine=opt.engine) - try: - engine = tts.load_engine(vcfg) - if progress: - progress(0.4, "Tổng hợp giọng đọc") - tts.synth_line(engine, opt.text, out_wav, vcfg) - except Exception: - # thiếu model TTS -> tạo clip lặng theo độ dài ước lượng để luồng không vỡ - if progress: - progress(0.6, "Thiếu model giọng — tạo clip mẫu") - dur = max(1.0, len(opt.text.split()) / 2.5) - tts._silence(out_wav, min(30.0, dur)) - if progress: - progress(1.0, "Hoàn tất") - return out_wav - - -def _passthrough(video: str, out_dir: str, opt: DubOptions, note: str) -> DubResult: - """Đường DỰ PHÒNG: khi thiếu model/khoá API, vẫn TRẢ VỀ video tải được. - - Xuất ra video gốc (chuẩn hóa mp4) + audio gốc + srt rỗng, kèm ghi chú lý do. - Đảm bảo người dùng luôn TẢI ĐƯỢC video, không bị treo/job lỗi. - """ - import shutil as _sh - 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 - subprocess.run([ffmpeg, "-y", "-hide_banner", "-loglevel", "error", - "-i", video, "-c", "copy", video_out], - check=True, capture_output=True) - 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) - except Exception: - audio_out = video_out - srt_out = os.path.join(out_dir, "subtitle.srt") - with open(srt_out, "w", encoding="utf-8") as f: - f.write("") - return DubResult(video_out=video_out, audio_out=audio_out, srt_out=srt_out, - 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.""" - try: - return _run_dub_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 - 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}") - - -def _run_dub_full(video: str, out_dir: str, opt: DubOptions, - progress: Callable[[float, str], None] | None = None) -> DubResult: - def emit(p, m): - if progress: - progress(p, m) - - work = os.path.join(out_dir, "work") - os.makedirs(work, exist_ok=True) - total = video_duration(video) - - emit(0.05, "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)") - try: - segments, language = asr.transcribe(bundle.asr_wav) - except Exception as e: - raise RuntimeError(f"[Bước ASR/Groq Whisper] {e}") from e - - emit(0.45, 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 - srt_out = write_srt(translated, os.path.join(out_dir, "subtitle.srt")) - - # mẫu clone - 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") - speaker_wav = audio.cut_clone_sample( - bundle.voice_wav, work, start=max(0.0, segments[0].start), length=15.0) - - emit(0.6, "Tổng hợp giọng đọc (TTS) + clone") - vcfg = tts.VoiceConfig( - target_lang=opt.target_lang, voice_source=opt.voice_source, - speaker_wav=speaker_wav, preset=opt.preset, style=opt.style, - engine=opt.engine) - try: - engine = tts.load_engine(vcfg) - except Exception as e: - raise RuntimeError(f"[Bước Giọng/TTS — model chạy local] {e}") from e - - 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) - # khe = đến đầu câu kế (hoặc hết video với câu cuối) - slot_end = translated[i + 1].start if i + 1 < n else total - slot = max(0.3, slot_end - 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}") - - 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")) - - 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")) - - 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) diff --git a/app/services/dubber/probe_dur.py b/app/services/dubber/probe_dur.py deleted file mode 100644 index 7aa00807a42b4fcc5d7cdbd22f51233cc5a3edda..0000000000000000000000000000000000000000 --- a/app/services/dubber/probe_dur.py +++ /dev/null @@ -1,13 +0,0 @@ -"""Helper nhỏ: lấy thời lượng video.""" -import shutil, subprocess -FFPROBE = shutil.which("ffprobe") or "ffprobe" - - -def video_duration(path: str) -> float: - out = subprocess.run( - [FFPROBE, "-v", "error", "-show_entries", "format=duration", - "-of", "csv=p=0", path], capture_output=True, text=True).stdout.strip() - try: - return float(out) - except ValueError: - return 0.0 diff --git a/app/services/dubber/translate.py b/app/services/dubber/translate.py deleted file mode 100644 index a83b527ed66d8d5e137c7deca4b4f9781bb54751..0000000000000000000000000000000000000000 --- a/app/services/dubber/translate.py +++ /dev/null @@ -1,88 +0,0 @@ -"""Bước DỊCH — dịch-vừa-khít-thời-lượng. - -- Chỉ hỗ trợ đích: tiếng Anh (en), tiếng Việt (vi), tiếng Filipino (fil). -- Mỗi câu tính sẵn ngân sách ký tự = thời lượng × tốc độ đọc trung bình, đưa cả số giây - lẫn hạn ký tự vào prompt; ưu tiên paraphrase ngắn gọn tự nhiên, giữ tên riêng/số/dấu câu. -- Model chính: Gemini 2.0 Flash (Google GenLang). Dự phòng: GPT-OSS 20B (Groq). -""" - -from __future__ import annotations - -from dataclasses import dataclass - -from ...config import settings -from .asr import Segment - -# tốc độ đọc trung bình (ký tự/giây) theo ngôn ngữ đích -CPS = {"en": 15.0, "vi": 16.0, "fil": 15.0} -LANG_NAME = {"en": "English", "vi": "Vietnamese", "fil": "Filipino"} - - -@dataclass -class TranslatedLine: - start: float - end: float - source: str - text: str - char_budget: int - - -def char_budget(seg: Segment, target_lang: str) -> int: - cps = CPS.get(target_lang, 15.0) - return max(8, int(seg.dur * cps)) - - -def _prompt(seg: Segment, target_lang: str, budget: int) -> str: - name = LANG_NAME.get(target_lang, target_lang) - return ( - f"Translate the following line into natural {name} for video dubbing.\n" - f"It must be speakable in about {seg.dur:.1f} seconds, so keep it within " - f"~{budget} characters. Prefer a concise, natural paraphrase over a literal " - f"translation if needed to fit the time. Keep proper nouns, numbers and " - f"punctuation. Return ONLY the translated line, no quotes, no notes.\n\n" - f"Line: {seg.text}" - ) - - -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() - - -def _groq_llm(prompt: str) -> str: - from groq import Groq # type: ignore - - client = Groq(api_key=settings.GROQ_API_KEY) - resp = client.chat.completions.create( - model=settings.GROQ_LLM_FALLBACK, - messages=[{"role": "user", "content": prompt}], - temperature=0.3, - ) - return resp.choices[0].message.content.strip() - - -def translate_line(seg: Segment, target_lang: str) -> str: - budget = char_budget(seg, target_lang) - prompt = _prompt(seg, target_lang, budget) - try: - return _gemini(prompt) - except Exception: - try: - return _groq_llm(prompt) # tự động dùng dự phòng - except Exception: - return seg.text # cùng lắm giữ nguyên để không vỡ luồng - - -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}") - 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 diff --git a/app/services/dubber/tts.py b/app/services/dubber/tts.py deleted file mode 100644 index 735fc8e78667526add134f33e66ac275e4cc4ce0..0000000000000000000000000000000000000000 --- a/app/services/dubber/tts.py +++ /dev/null @@ -1,144 +0,0 @@ -"""Bước TỔNG HỢP GIỌNG (TTS). - -Chọn engine theo NGÔN NGỮ ĐÍCH (đã bỏ hoàn toàn edge-tts): - - vi -> VieNeu-TTS (local real-time trên CPU) - - en -> XTTS-v2 (hoặc VoxCPM2 thay thế) - - fil -> VoxCPM2 (en cũng có thể dùng VoxCPM2) - -Tất cả đều clone được giọng từ mẫu 10-20s, hoặc dùng giọng preset. -Nguồn giọng clone (voice_source): preset | video | upload. -""" - -from __future__ import annotations - -import os -import shutil -import subprocess -from dataclasses import dataclass - -FFMPEG = shutil.which("ffmpeg") or "ffmpeg" - - -@dataclass -class VoiceConfig: - target_lang: str - voice_source: str = "video" # preset | video | upload - speaker_wav: str = "" # mẫu clone (khi video/upload) - preset: str = "" # tên giọng preset (khi preset) - style: str = "natural" # phong cách đọc (lấy từ video hoặc người chọn) - engine: str = "auto" # auto | vieneu | xtts | voxcpm - - -def pick_engine(cfg: VoiceConfig) -> str: - if cfg.engine != "auto": - return cfg.engine - return {"vi": "vieneu", "en": "xtts", "fil": "voxcpm"}.get(cfg.target_lang, "voxcpm") - - -class TTSEngine: - """Giao diện chung cho các engine. synth(text, out_wav) -> path.""" - - def synth(self, text: str, out_wav: str, cfg: VoiceConfig) -> str: # pragma: no cover - raise NotImplementedError - - -class VieNeuEngine(TTSEngine): # pragma: no cover - cần model local - def __init__(self): - import vieneu # type: ignore - self.model = None - # 1) Thử factory() — kiểu khởi tạo khuyến nghị nếu có - fac = getattr(vieneu, "factory", None) - if callable(fac): - try: - self.model = fac() - except Exception: - self.model = None - # 2) Nếu chưa được, thử class Vieneu() - if self.model is None: - cls = getattr(vieneu, "Vieneu", None) or getattr(vieneu, "VieNeuTTS", None) - if cls is None: - raise ImportError( - "Không thấy entrypoint TTS trong 'vieneu'. Tên có: " - + ", ".join(n for n in dir(vieneu) if not n.startswith("_")) - ) - self.model = cls() - - def synth(self, text, out_wav, cfg): - ref = cfg.speaker_wav or None - for meth, kwargs in ( - ("tts_to_file", {"text": text, "speaker_wav": ref, "file_path": out_wav}), - ("tts_to_file", {"text": text, "file_path": out_wav}), - ("synthesize", {"text": text, "speaker_wav": ref, "output_path": out_wav}), - ("synthesize", {"text": text, "ref_audio": ref, "output_path": out_wav}), - ("generate", {"text": text, "ref_audio": ref, "output_path": out_wav}), - ("infer", {"text": text, "ref_audio": ref, "output_path": out_wav}), - ("tts", {"text": text, "speaker_wav": ref, "output_path": out_wav}), - ): - fn = getattr(self.model, meth, None) - if fn: - try: - fn(**kwargs) - return out_wav - except TypeError: - continue - raise RuntimeError( - "Vieneu không có hàm xuất file quen thuộc. Hàm đang có: " - + ", ".join(m for m in dir(self.model) if not m.startswith("_")) - ) - - -class XTTSEngine(TTSEngine): # pragma: no cover - cần model local - def __init__(self): - from TTS.api import TTS # type: ignore - self.model = TTS("tts_models/multilingual/multi-dataset/xtts_v2") - - def synth(self, text, out_wav, cfg): - self.model.tts_to_file( - text=text, file_path=out_wav, - speaker_wav=cfg.speaker_wav or None, - language=cfg.target_lang if cfg.target_lang != "fil" else "en", - ) - return out_wav - - -class VoxCPMEngine(TTSEngine): # pragma: no cover - cần model local - def __init__(self): - from voxcpm import VoxCPM # type: ignore - self.model = VoxCPM.from_pretrained("openbmb/VoxCPM2") - - def synth(self, text, out_wav, cfg): - self.model.generate_to_file( - text=text, prompt_wav=cfg.speaker_wav or None, output_path=out_wav) - return out_wav - - -_ENGINES: dict[str, type[TTSEngine]] = { - "vieneu": VieNeuEngine, "xtts": XTTSEngine, "voxcpm": VoxCPMEngine, -} - - -def load_engine(cfg: VoiceConfig) -> TTSEngine: - name = pick_engine(cfg) - cls = _ENGINES.get(name) - if cls is None: - raise ValueError(f"engine không hợp lệ: {name}") - return cls() - - -def synth_line(engine: TTSEngine, text: str, out_wav: str, cfg: VoiceConfig) -> str: - """Tổng hợp 1 câu, chịu lỗi: câu rỗng -> để file lặng ngắn.""" - if not text.strip(): - _silence(out_wav, 0.2) - return out_wav - try: - return engine.synth(text, out_wav, cfg) - except Exception: - _silence(out_wav, 0.4) # lỗi 1 câu -> để khoảng lặng, đi tiếp - return out_wav - - -def _silence(out_wav: str, dur: float): - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-f", "lavfi", "-i", "anullsrc=r=24000:cl=mono", - "-t", f"{dur:.3f}", out_wav], check=True, capture_output=True) diff --git a/app/services/listing/__init__.py b/app/services/listing/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/app/services/shuffler/__init__.py b/app/services/shuffler/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/app/services/shuffler/engine.py b/app/services/shuffler/engine.py deleted file mode 100644 index b8bfa6512036e54e1c03f8a6f67d95cd10abad82..0000000000000000000000000000000000000000 --- a/app/services/shuffler/engine.py +++ /dev/null @@ -1,204 +0,0 @@ -""" -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). - -Mô hình khúc (order_mode) -------------------------- -- "lock" : khúc GIỮ NGUYÊN vị trí (khóa thứ tự). -- "shuffle" : khúc được phép đảo chỗ với các khúc shuffle khác. -- "drop" : BỎ hẳn khúc khỏi output (không xuất hiện trong video). - -Ví dụ với 5 khúc 1..5: -- tất cả lock -> 1,2,3,4,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). -""" - -from __future__ import annotations - -from dataclasses import dataclass -from itertools import permutations, product -from math import 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 - - -@dataclass -class Segment: - """Một khúc và pool clip ứng viên của nó.""" - clips: list[int] # danh sách clip_id ứng viên - order_mode: str = "shuffle" # "lock" | "shuffle" | "drop" - - @property - def locked(self) -> bool: - return self.order_mode == "lock" - - @property - def dropped(self) -> bool: - # "optional" giữ lại như alias cũ = drop - return self.order_mode in ("drop", "optional") - - def pool(self) -> list[int]: - return list(self.clips) - - -@dataclass -class ShuffleConfig: - segments: list[Segment] - similarity_threshold: float = 0.80 # >=1.0 => tắt lọc trùng (lấy hết) - random_ratio: float = 1.0 # >=1.0 => không lấy mẫu ngẫu nhiên - max_outputs: int | None = None - seed: int | None = None - - -@dataclass -class ShuffleEstimate: - selection_count: int - ordering_count: int - raw_total: int - - -# ----------------------------------------------------------- helpers --- - -def _active(cfg: ShuffleConfig): - """Trả về danh sách khúc KHÔNG bị drop (giữ nguyên thứ tự khai báo).""" - return [s for s in cfg.segments if not s.dropped] - - -def _ordering_indices(locked_flags: list[bool]) -> list[tuple[int, ...]]: - """Các hoán vị thứ tự trên những khúc còn hoạt động. - - Khúc locked giữ đúng slot của nó; các khúc shuffle hoán vị trong slot trống. - Index ở đây là 0..M-1 ứng với danh sách khúc đã loại drop. - """ - m = len(locked_flags) - if m == 0: - return [()] - free_positions = [i for i in range(m) if not locked_flags[i]] - if len(free_positions) <= 1: - return [tuple(range(m))] - - out: list[tuple[int, ...]] = [] - for perm in permutations(free_positions): - arr: list[int | None] = [None] * m - for pos in range(m): - if locked_flags[pos]: - arr[pos] = pos - for slot, item in zip(free_positions, perm): - arr[slot] = item - out.append(tuple(arr)) # type: ignore[arg-type] - return out - - -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 - - free = sum(0 if s.locked else 1 for s in active) - ordering_count = factorial(free) if free > 1 else 1 - - return ShuffleEstimate( - selection_count=selection_count, - ordering_count=ordering_count, - raw_total=selection_count * ordering_count, - ) - - -# ----------------------------------------------------------- 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 - - -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 - - -def similarity(a: list[int], b: list[int]) -> float: - width = max(len(a), len(b)) - if width == 0: - return 1.0 - pa = np.full(width, PAD, dtype=np.int64) - pb = np.full(width, PAD, dtype=np.int64) - pa[: len(a)] = a - pb[: len(b)] = b - eq = (pa == pb) & (pa != PAD) - return float(eq.sum()) / width - - -def _greedy_dedup(mat: np.ndarray, threshold: float) -> list[int]: - n, width = mat.shape - if n == 0: - return [] - kept_idx: 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 - - -def generate(cfg: ShuffleConfig) -> list[list[int]]: - seqs = list(_iter_raw_sequences(cfg)) - if not seqs: - return [] - - rng = np.random.default_rng(cfg.seed) - - # 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] - else: - result = [list(s) for s in seqs] - - # 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: - 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())] - - # 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())] - - return result diff --git a/app/services/shuffler/render.py b/app/services/shuffler/render.py deleted file mode 100644 index bf6654b4227939b6800775548c7fb29b42e6e2a5..0000000000000000000000000000000000000000 --- a/app/services/shuffler/render.py +++ /dev/null @@ -1,81 +0,0 @@ -"""Render biến thể xào: ghép clip theo sequence -> mp4; tùy chọn lồng âm thanh; zip. - -- clip_id -> đường dẫn clip (người dùng nạp vào từng khúc). -- 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 ... -""" - -from __future__ import annotations - -import os -import shutil -import subprocess -import zipfile - -FFMPEG = shutil.which("ffmpeg") or "ffmpeg" - - -def _concat_reencode(clip_paths: list[str], out_path: str): - """Ghép nhiều clip bằng concat filter (re-encode, video-only).""" - inputs = [] - for p in clip_paths: - inputs += ["-i", p] - n = len(clip_paths) - streams = "" - for i in range(n): - streams += f"[{i}:v]setsar=1,fps=30,format=yuv420p[v{i}];" - concat_in = "".join(f"[v{i}]" for i in range(n)) - fg = streams + f"{concat_in}concat=n={n}:v=1:a=0[outv]" - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", *inputs, - "-filter_complex", fg, "-map", "[outv]", - "-c:v", "libx264", "-preset", "veryfast", "-crf", "20", out_path], - check=True, capture_output=True) - - -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. - - - Âm thanh ngắn hơn video: phần dư của video sẽ LẶNG (pad silence), KHÔNG lặp. - - Âm thanh dài hơn video: cắt theo độ dài video. - """ - subprocess.run( - [FFMPEG, "-y", "-hide_banner", "-loglevel", "error", - "-i", video_path, "-i", audio_path, - "-filter_complex", "[1:a]apad[aud]", - "-map", "0:v:0", "-map", "[aud]", - "-c:v", "copy", "-c:a", "aac", "-b:a", "192k", - "-shortest", out_path], - check=True, capture_output=True) - - -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]: - os.makedirs(out_dir, exist_ok=True) - 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) - results.append({ - "name": name, "path": out, - "sequence": seq, "size": os.path.getsize(out), - }) - return results - - -def zip_variations(results: list[dict], zip_path: str) -> str: - with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf: - for r in results: - zf.write(r["path"], arcname=r["name"]) - return zip_path diff --git a/app/services/videogen/__init__.py b/app/services/videogen/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/app/__init__.py b/backend/__init__.py similarity index 100% rename from app/__init__.py rename to backend/__init__.py diff --git a/app/api/auth.py b/backend/app/api/auth.py similarity index 100% rename from app/api/auth.py rename to backend/app/api/auth.py diff --git a/backend/app/api/common.py b/backend/app/api/common.py index 70dcb529cd5eab09533096f89b2d257afa8258f6..b43f12277bdba1666fa58d1c1d311653069c1578 100644 --- a/backend/app/api/common.py +++ b/backend/app/api/common.py @@ -55,10 +55,7 @@ def list_inputs(sid: str): @router.get("/files/{sid}/{path:path}") def get_file(sid: str, path: str): base = os.path.abspath(session_dir(sid)) - # chấp nhận cả "/" lẫn "\" trong path (Windows) -> chuẩn hoá trước khi nối - rel = path.replace("\\", "/").strip("/") - full = os.path.abspath(os.path.join(base, *rel.split("/"))) - # phải nằm trong phiên VÀ là FILE thật (đường dẫn thư mục -> 404, không 500) - if not full.startswith(base) or not os.path.isfile(full): + full = os.path.abspath(os.path.join(base, path)) + if not full.startswith(base) or not os.path.exists(full): raise HTTPException(404, "file không tồn tại") return FileResponse(full, filename=os.path.basename(full)) diff --git a/backend/app/api/cut.py b/backend/app/api/cut.py index 8795092d0138dd894d63b87d22884a82e5d23cfe..3840e60a7c64b33f6728ce79d05b512cc5941fb6 100644 --- a/backend/app/api/cut.py +++ b/backend/app/api/cut.py @@ -4,18 +4,16 @@ Luồng FE: 1) upload video -> /upload (trả session + info) 2) /preview -> sinh khúc theo mode + thumbnail strip để xem trước/kéo điểm cắt 3) /execute -> cắt theo các điểm cắt (đã chỉnh tay) -> zip - 4) /execute-batch -> cắt NHIỀU video SONG SONG, trả timeline RIÊNG cho từng video """ from __future__ import annotations import os -from concurrent.futures import ThreadPoolExecutor, as_completed from fastapi import APIRouter, File, Form, UploadFile from pydantic import BaseModel -from ..core.files import new_session, session_dir, sub_dir, save_upload, rel_path +from ..core.files import new_session, session_dir, sub_dir, save_upload from ..core.jobs import jobs from ..services.cutter import cut as cutter from ..services.cutter import modes @@ -31,7 +29,7 @@ async def upload(file: UploadFile = File(...), session: str = Form(None)): info = probe(path) return { "session": sid, - "file": rel_path(path, sid), + "file": os.path.relpath(path, session_dir(sid)), "info": {"duration": info.duration, "fps": info.fps, "nb_frames": info.nb_frames, "width": info.width, "height": info.height}, @@ -43,7 +41,7 @@ class PreviewReq(BaseModel): session: str file: str mode: str = "even" # even | scene | highlight | smart - count: int | None = None # số khúc (even/smart) — None để máy tự chia + count: int | None = None # số khúc (even) — None để máy tự chia min_len: float = 1.5 sensitivity: float = 0.5 top_ratio: float = 0.4 @@ -132,81 +130,53 @@ class BatchItem(BaseModel): class ExecuteBatchReq(BaseModel): session: str videos: list[BatchItem] - workers: int = 3 # số video xử lý song song @router.post("/execute-batch") def execute_batch(req: ExecuteBatchReq): - """Cắt NHIỀU video SONG SONG trong một phiên. + """Cắt NHIỀU video cùng lúc trong một phiên -> 1 danh sách clip gộp. - Mỗi video được cắt ĐỘC LẬP (KHÔNG gộp video), kết quả trả về theo TỪNG video - (timeline riêng). Tên clip có tiền tố theo video để không đè nhau. + Tên clip có tiền tố theo video để không đè nhau: v{vi}_clip_{i}.mp4. """ + plans = [] + for vi, item in enumerate(req.videos): + src = os.path.join(session_dir(req.session), item.file) + info = probe(src) + if item.segments: + segs = [modes.Segment(i, s.start_frame, s.end_frame, info.fps) + for i, s in enumerate(item.segments)] + else: + segs = modes.build_segments(info, item.mode, n=item.count) + plans.append((vi, item.file, src, segs)) + job = jobs.create("cut") - videos = list(req.videos) - workers = max(1, min(req.workers, len(videos) or 1)) def work(h): out_dir = sub_dir(req.session, "clips") - # đăng ký 1 item / video để FE theo dõi tiến độ từng video - items = {vi: h.add_item(os.path.basename(item.file) or f"video_{vi+1}", - item_id=f"v{vi+1}") - for vi, item in enumerate(videos)} - per_video: dict[int, dict] = {} - done_count = [0] - - def process(vi: int, item: BatchItem) -> dict: - it = items[vi] - base = os.path.splitext(os.path.basename(item.file))[0] - try: - src = os.path.join(session_dir(req.session), item.file) - info = probe(src) - if item.segments: - segs = [modes.Segment(i, s.start_frame, s.end_frame, info.fps) - for i, s in enumerate(item.segments)] - else: - segs = modes.build_segments(info, item.mode, n=item.count) - h.item_status(it, "running", detail=f"cắt {len(segs)} khúc") - clips = [] - for i, seg in enumerate(segs): + results = [] + 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] + 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)) - clips.append({ - "name": name, "duration": r.duration, "size": r.size, - "start_time": r.start_time, "end_time": r.end_time, - "video": base, - "url": f"/api/files/{req.session}/clips/{name}", - }) - h.item_status(it, "done", detail=f"{len(clips)} khúc", result={ - "video": base, "file": item.file, "clips": clips}) - return {"video": base, "file": item.file, "clips": clips} - except Exception as e: - h.item_status(it, "error", error=str(e)) - return {"video": base, "file": item.file, "clips": [], "error": str(e)} - finally: - done_count[0] += 1 - h.set_progress(done_count[0] / max(1, len(videos))) - - with ThreadPoolExecutor(max_workers=workers) as ex: - futs = {ex.submit(process, vi, item): vi - for vi, item in enumerate(videos)} - for fut in as_completed(futs): - vi = futs[fut] - per_video[vi] = fut.result() - - ordered = [per_video[vi] for vi in sorted(per_video)] - total_clips = sum(len(v["clips"]) for v in ordered) - return {"session": req.session, "videos": ordered, "clips": total_clips} + results.append({"name": name, "duration": r.duration, + "size": r.size, "video": base, + "url": f"/api/files/{req.session}/clips/{name}"}) + h.item_status(it, "done", detail=f"{r.duration}s", result=results[-1]) + except Exception as e: + h.item_status(it, "error", error=str(e)) + done += 1 + h.set_progress(done / total) + return {"session": req.session, "clips": len(results)} jobs.submit(job, work) return {"job_id": job.id, "session": req.session} -class PushShuffleReq(BaseModel): - session: str - clips: list[str] # đường dẫn tương đối các khúc đã cắt - - @router.post("/push-shuffle") def push_shuffle(req: PushShuffleReq): """Đẩy các khúc đã cắt sang tool Xào: mỗi khúc thành 1 segment (seg_i). diff --git a/backend/app/api/download.py b/backend/app/api/download.py index a402472c00e8510cc0f9aa87df9f941de0decf93..aa9f0165959e70212c1ee0e71460cb1f48d13a1d 100644 --- a/backend/app/api/download.py +++ b/backend/app/api/download.py @@ -9,7 +9,7 @@ from fastapi import APIRouter from pydantic import BaseModel from ..config import settings -from ..core.files import new_session, session_dir, sub_dir, zip_paths, rel_path +from ..core.files import new_session, session_dir, sub_dir, zip_paths from ..core.jobs import DONE, ERROR, RUNNING, jobs from ..services.downloader.ydl import detect_source, download_one, parse_links @@ -23,6 +23,7 @@ class ParseReq(BaseModel): class StartReq(BaseModel): urls: list[str] zip_output: bool = True + cookies_file: str | None = None @router.post("/parse") @@ -42,45 +43,32 @@ def start(req: StartReq): job = jobs.create("download") def work(h): - from concurrent.futures import ThreadPoolExecutor, as_completed - import threading items = [h.add_item(u, item_id=str(i)) for i, u in enumerate(req.urls)] - n = len(req.urls) done_paths, failed = [], [] - lock = threading.Lock() - done = [0] - - def fetch(i: int, url: str): - it = items[i] + n = len(req.urls) + for i, url in enumerate(req.urls): if h.cancelled(): - return + break + it = items[i] h.item_status(it, RUNNING, detail="đang tải") h.log(f"[{i+1}/{n}] tải {url}") - res = download_one(url, out_dir) - with lock: - if res.ok: - done_paths.append(res.path) - h.item_status(it, DONE, detail=res.title, result={ - "path": rel_path(res.path, sid), - "url": f"/api/files/{sid}/" + rel_path(res.path, sid), - "title": res.title, "ext": res.ext, "size": res.size, - "duration": res.duration, "thumbnail": res.thumbnail, - "source": detect_source(url), - }) - h.log(f" ✔ {res.title} ({res.size} bytes)") - else: - failed.append({"url": url, "error": res.error}) - h.item_status(it, ERROR, error=res.error) - h.log(f" ✗ LỖI: {res.error}", level="error") - done[0] += 1 - h.set_progress(done[0] / max(1, n)) - - # Tải SONG SONG (network-bound) -> nhanh hơn nhiều khi nhiều link. - workers = max(1, min(5, n)) - with ThreadPoolExecutor(max_workers=workers) as ex: - futs = [ex.submit(fetch, i, url) for i, url in enumerate(req.urls)] - for fut in as_completed(futs): - fut.result() + res = download_one(url, out_dir, req.cookies_file) + if res.ok: + done_paths.append(res.path) + h.item_status(it, DONE, detail=res.title, result={ + "path": os.path.relpath(res.path, session_dir(sid)), + "url": f"/api/files/{sid}/" + os.path.relpath( + res.path, session_dir(sid)).replace(os.sep, "/"), + "title": res.title, "ext": res.ext, "size": res.size, + "duration": res.duration, "thumbnail": res.thumbnail, + "source": detect_source(url), + }) + h.log(f" ✔ {res.title} ({res.size} bytes)") + else: + failed.append({"url": url, "error": res.error}) + h.item_status(it, ERROR, error=res.error) + h.log(f" ✗ LỖI: {res.error}", level="error") + h.set_progress((i + 1) / max(1, n)) zip_rel = None if req.zip_output and done_paths: @@ -121,5 +109,5 @@ def push_to_tool(req: PushReq): if os.path.exists(src): d = os.path.join(dst, os.path.basename(src)) shutil.copy(src, d) - copied.append(rel_path(d, new_sid)) + copied.append(os.path.relpath(d, session_dir(new_sid))) return {"session": new_sid, "target_tool": req.target_tool, "files": copied} diff --git a/backend/app/api/dub.py b/backend/app/api/dub.py index 438e0d666b9c583b93cf9fd5e3bee987f5e31248..4ca9ef7fbfea6bcd01a24f7c889d889524f2862d 100644 --- a/backend/app/api/dub.py +++ b/backend/app/api/dub.py @@ -15,7 +15,7 @@ import os from fastapi import APIRouter, File, Form, UploadFile from pydantic import BaseModel -from ..core.files import new_session, session_dir, sub_dir, save_upload, rel_path +from ..core.files import new_session, session_dir, sub_dir, save_upload from ..core.jobs import jobs from ..services.dubber import pipeline @@ -30,7 +30,7 @@ LANGS = {"en", "vi", "fil"} async def upload(file: UploadFile = File(...), session: str = Form(None)): sid = session or new_session("dub") path = save_upload(sid, file.filename, await file.read(), folder="inputs") - rel = rel_path(path, sid) + rel = os.path.relpath(path, session_dir(sid)) return {"session": sid, "file": rel, "name": os.path.basename(path), "size": os.path.getsize(path)} @@ -40,7 +40,7 @@ async def voice_sample(file: UploadFile = File(...), session: str = Form(None)): """File giọng mẫu (WAV/MP3) user tự up để clone. Tạo phiên nếu chưa có.""" sid = session or new_session("dub") path = save_upload(sid, file.filename, await file.read(), folder="voice") - rel = rel_path(path, sid) + rel = os.path.relpath(path, session_dir(sid)) return {"session": sid, "file": rel, "name": os.path.basename(path)} @@ -57,7 +57,6 @@ class DubReq(BaseModel): preset: str = "" # tên preset nếu voice_source=preset style: str = "natural" engine: str = "auto" - gender: str = "female" # nam/nữ cho Edge TTS multi_speaker: bool = False @@ -78,7 +77,6 @@ def start(req: DubReq): preset=req.preset, style=req.style, engine=req.engine, - gender=req.gender, multi_speaker=req.multi_speaker, ) @@ -136,8 +134,7 @@ class TtsReq(BaseModel): speaker_file: str = "" # rel path nếu voice_source=upload (clone) preset: str = "" # tên giọng có sẵn style: str = "natural" - engine: str = "auto" # auto | vieneu | xtts | voxcpm | edge - gender: str = "female" # nam/nữ cho Edge TTS + engine: str = "auto" # auto | vieneu | xtts | voxcpm @router.post("/tts") @@ -153,7 +150,7 @@ def tts_from_text(req: TtsReq): opt = pipeline.TtsOptions( text=req.text, target_lang=target, voice_source=req.voice_source, speaker_wav=speaker_wav, preset=req.preset, style=req.style, - engine=req.engine, gender=req.gender) + engine=req.engine) job = jobs.create("tts") diff --git a/app/api/listing.py b/backend/app/api/listing.py similarity index 100% rename from app/api/listing.py rename to backend/app/api/listing.py diff --git a/backend/app/api/shuffle.py b/backend/app/api/shuffle.py index a6e2e0e19ae4f3e21d8f94f655aae1bc9ddb7ec6..3b50a6ce71c9db9fa417939a73b7ab4f9e85c9ad 100644 --- a/backend/app/api/shuffle.py +++ b/backend/app/api/shuffle.py @@ -17,7 +17,7 @@ import os from fastapi import APIRouter, File, Form, UploadFile from pydantic import BaseModel -from ..core.files import new_session, session_dir, sub_dir, save_upload, rel_path +from ..core.files import new_session, session_dir, sub_dir, save_upload from ..core.jobs import jobs from ..services.shuffler import engine from ..services.shuffler import render as shuffle_render @@ -37,7 +37,7 @@ async def upload( sid = session or new_session("shuffle") folder = f"seg_{segment}" path = save_upload(sid, file.filename, await file.read(), folder=folder) - rel = rel_path(path, sid) + rel = os.path.relpath(path, session_dir(sid)) return { "session": sid, "segment": segment, "file": rel, "name": os.path.basename(path), "size": os.path.getsize(path), @@ -52,7 +52,7 @@ async def upload_audio( ): """Tải 1 track âm thanh dùng để lồng vào các biến thể.""" path = save_upload(session, file.filename, await file.read(), folder="audio") - rel = rel_path(path, session) + rel = os.path.relpath(path, session_dir(session)) return { "session": session, "file": rel, "name": os.path.basename(path), "size": os.path.getsize(path), @@ -153,56 +153,36 @@ def generate(req: ShuffleReq): job = jobs.create("shuffle") def work(h): - from concurrent.futures import ThreadPoolExecutor, as_completed - n = len(sequences) - h.log(f"Sẽ render {n} biến thể" + h.log(f"Sẽ render {len(sequences)} biến thể" + (f" + lồng {len(audio_paths)} track âm thanh" if audio_paths else "")) out_dir = sub_dir(req.session, "variations") - - # 1) CHUẨN HOÁ mỗi clip duy nhất về khung dọc MỘT lần (tốn công ở đây, sau đó nối nhanh) - h.log("Chuẩn hoá clip về khung dọc 1080×1920 (một lần)…") - norm = shuffle_render.prepare_clips(clip_map, os.path.join(out_dir, "_norm")) - - # 2) Mỗi biến thể = NỐI (copy) các clip đã chuẩn hoá -> gần như tức thì, chạy SONG SONG - items = {i: h.add_item(f"Variation_{i:02d}") for i in range(1, n + 1)} - results: dict[int, dict] = {} - done = [0] - - def render_one(i: int, seq: list[int]): - it = items[i] - name = f"Variation_{i:02d}.mp4" - out = os.path.join(out_dir, name) - paths = [norm[c] for c in seq] - if audio_paths: - tmp = os.path.join(out_dir, f".tmp_{i:02d}.mp4") - shuffle_render.concat_copy(paths, tmp) - track = audio_paths[(i - 1) % len(audio_paths)] - shuffle_render.attach_audio(tmp, track, out) - os.remove(tmp) - else: - shuffle_render.concat_copy(paths, out) - 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={ - "name": name, "size": size, "sequence": seq, - "url": f"/api/files/{req.session}/variations/{name}"}) - - with ThreadPoolExecutor(max_workers=4) as ex: - futs = {ex.submit(render_one, i, seq): i - for i, seq in enumerate(sequences, 1)} - for fut in as_completed(futs): - i = futs[fut] - try: - fut.result() - except Exception as e: - h.item_status(items[i], "error", error=str(e)) - done[0] += 1 - h.set_progress(done[0] / max(1, n)) - - ordered = [results[i] for i in sorted(results)] + results = [] + n = len(sequences) + for i, seq in enumerate(sequences, 1): + it = h.add_item(f"Variation_{i:02d}") + try: + paths = [clip_map[c] for c in seq] + name = f"Variation_{i:02d}.mp4" + out = os.path.join(out_dir, name) + if audio_paths: + tmp = os.path.join(out_dir, f".tmp_{i:02d}.mp4") + shuffle_render._concat_reencode(paths, tmp) + track = audio_paths[(i - 1) % len(audio_paths)] + shuffle_render.attach_audio(tmp, track, out) + os.remove(tmp) + else: + shuffle_render._concat_reencode(paths, out) + size = os.path.getsize(out) + results.append({"name": name, "path": out, "sequence": seq, "size": size}) + h.item_status(it, "done", detail=f"{size//1024} KB", result={ + "name": name, "size": size, "sequence": seq, + "url": f"/api/files/{req.session}/variations/{name}"}) + except Exception as e: + h.item_status(it, "error", error=str(e)) + h.set_progress(i / max(1, n)) zp = os.path.join(session_dir(req.session), "variations.zip") - shuffle_render.zip_variations(ordered, zp) - return {"session": req.session, "count": len(ordered), "zip": "variations.zip"} + shuffle_render.zip_variations(results, zp) + return {"session": req.session, "count": len(results), "zip": "variations.zip"} jobs.submit(job, work) return {"job_id": job.id, "session": req.session, "planned": len(sequences)} diff --git a/app/api/video.py b/backend/app/api/video.py similarity index 100% rename from app/api/video.py rename to backend/app/api/video.py diff --git a/backend/app/config.py b/backend/app/config.py index 736b47b703e65421ac23519d197b73ecee17a8a1..f1f85ef448f107c167b662d15d2757e45ea6d520 100644 --- a/backend/app/config.py +++ b/backend/app/config.py @@ -7,12 +7,12 @@ import tempfile from dataclasses import dataclass, field BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) -BACKEND_DIR = os.path.dirname(BASE_DIR) +BACKEND_DIR = BASE_DIR try: from dotenv import load_dotenv - for _cand in (os.path.join(BASE_DIR, ".env"), # ...\backend\.env (đúng chỗ) - os.path.join(BACKEND_DIR, ".env"), # ...\website_content\.env - os.path.join(os.getcwd(), ".env")): # thư mục đang chạy + for _cand in (os.path.join(BASE_DIR, ".env"), + os.path.join(os.path.dirname(BASE_DIR), ".env"), + os.path.join(os.getcwd(), ".env")): if os.path.exists(_cand): load_dotenv(_cand, override=True) break @@ -36,14 +36,28 @@ class Settings: # API keys cho pipeline lồng tiếng GROQ_API_KEY: str = field(default_factory=lambda: _env("GROQ_API_KEY")) GOOGLE_API_KEY: str = field(default_factory=lambda: _env("GOOGLE_API_KEY")) + # API keys cho Listing ảnh + OPENAI_API_KEY: str = field(default_factory=lambda: _env("OPENAI_API_KEY")) + OPENAI_IMAGE_API_KEY: str = field(default_factory=lambda: _env("OPENAI_IMAGE_API_KEY")) + + # Database cho user auth (để trống thì dùng JSON file) + DATABASE_URL: str = field(default_factory=lambda: _env("DATABASE_URL", "")) + + # Danh sách user được dùng key chung (cách nhau bằng dấu phẩy) + AUTHORIZED_USERS: list[str] = field( + default_factory=lambda: [u.strip() for u in _env("AUTHORIZED_USERS", "").split(",") if u.strip()] + ) + + # Video Gen (Gradio proxy) + VIDEO_ADMIN_TOKEN: str = field(default_factory=lambda: _env("VIDEO_ADMIN_TOKEN")) # model TTS / config DEMUCS_MODEL: str = field(default_factory=lambda: _env("DEMUCS_MODEL", "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")) - # ASR chạy LOCAL (faster-whisper) khi không có/không gọi được Groq. Máy ít RAM - # nên mặc định "base" (đổi sang "small"/"tiny" qua env nếu cần). + + # 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")) # giới hạn diff --git a/backend/app/core/files.py b/backend/app/core/files.py index 63590423889014c51941b4a32ccb2f602cda21b4..8328f766a69954cb58e0c44a50f39e7baa1fe1a6 100644 --- a/backend/app/core/files.py +++ b/backend/app/core/files.py @@ -45,12 +45,6 @@ def sub_dir(sid: str, *parts: str) -> str: return d -def rel_path(full: str, sid: str) -> str: - """Đường dẫn tương đối trong phiên, LUÔN dùng "/" (an toàn cho URL/JSON, - tránh dấu "\\" của Windows làm hỏng