Duplicate from STBack23/omnivoice-vi

Co-authored-by: STBack23 <STBack23@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,62 @@
+---
+license: apache-2.0
+language:
+- vi
+tags:
+- text-to-speech
+- tts
+- voice-cloning
+- vietnamese
+- srt
+- dubbing
+- omnivoice
+pretty_name: OmniVoice Vietnamese Voices
+size_categories:
+- n<1K
+---
+
+# OmniVoice VI — Giọng Việt + SRT lồng tiếng
+
+Dataset chứa **6 giọng tiếng Việt** và công cụ `speak.py` để chạy trên **Google Colab** với [OmniVoice](https://huggingface.co/k2-fsa/OmniVoice).
+
+## Giọng có sẵn
+
+| Slug | Tên |
+|------|-----|
+| `ban_mai` | Ban Mai |
+| `lan_trinh` | Lan Trinh |
+| `ngan_ha` | Ngan Ha |
+| `ngoc_huyen` | Ngoc Huyen |
+| `thao_trinh` | Thao Trinh |
+| `tuong_vy` | Tuong Vy |
+
+Mỗi giọng gồm `profile.json`, `voice.pt` (prompt cache), audio mẫu và `ref_text.txt`.
+
+## Chạy trên Colab
+
+1. Mở notebook `colab/Omivoice_VI_Colab.ipynb`
+2. Đặt `HF_REPO = "<repo-này>"`
+3. Runtime → GPU → chạy từng cell
+
+## Cấu trúc
+
+```
+├── voices/<slug>/     # profile + voice.pt + ref audio
+├── tools/speak.py     # TTS + SRT pipeline
+└── colab/             # Notebook Colab
+```
+
+## SRT merge modes
+
+- **`native`** (mặc định): model nói nhanh native, tràn vào khoảng trống sau cue, không cắt ngắt
+- **`cascade`**: giữ tốc độ tự nhiên, cue dài đẩy cue sau
+- **`fit`**: kéo nén tín hiệu vừa khung SRT
+- **`strict`**: ghép theo timestamp (có thể cắt audio)
+
+## Model gốc
+
+- [k2-fsa/OmniVoice](https://huggingface.co/k2-fsa/OmniVoice) — tự tải khi chạy lần đầu (~GB VRAM T4)
+
+## License
+
+Apache-2.0 (theo OmniVoice upstream).

colab/Omivoice_VI_Colab.ipynb

@@ -0,0 +1,401 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# OmniVoice — Lồng tiếng tiếng Việt trên Colab\n",
+        "\n",
+        "Notebook chạy [OmniVoice](https://huggingface.co/k2-fsa/OmniVoice) với pipeline **SRT lồng tiếng** (`native`).\n",
+        "\n",
+        "**Luồng Drive:**\n",
+        "1. Cấu hình giọng + tên file SRT ở **mục 0**\n",
+        "2. Đặt file `.srt` vào **`MyDrive/Omivoice/`** (tên = `SRT_FILE` + `.srt`, vd. `input` → `input.srt`)\n",
+        "3. Chạy notebook → kết quả ghi lại **`MyDrive/Omivoice/`**\n",
+        "\n",
+        "**Yêu cầu:** Runtime **GPU L4** (Runtime → Change runtime type → L4)."
+      ],
+      "id": "4027962a"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 0. Cấu hình"
+      ],
+      "id": "02fceea2"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "# Hugging Face (giọng + speak.py)\n",
+        "HF_REPO = \"STBack23/omnivoice-vi\"\n",
+        "\n",
+        "# Google Drive — MyDrive/Omivoice/\n",
+        "DRIVE_FOLDER = \"Omivoice\"\n",
+        "SRT_FILE = \"input\"   # tên file (không cần .srt) -> input.srt\n",
+        "\n",
+        "# Giọng: ban_mai | lan_trinh | ngan_ha | ngoc_huyen | thao_trinh | tuong_vy\n",
+        "DEFAULT_VOICE = \"tuong_vy\"\n",
+        "MERGE_MODE = \"native\"  # native | cascade | fit | strict\n",
+        "NUM_STEP = 32"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "1d36167e"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 1. Kiểm tra GPU & cài đặt"
+      ],
+      "id": "342cf199"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "import torch\n",
+        "\n",
+        "assert torch.cuda.is_available(), (\n",
+        "    \"Bật GPU L4: Runtime → Change runtime type → Hardware accelerator → L4\"\n",
+        ")\n",
+        "gpu = torch.cuda.get_device_name(0)\n",
+        "print(f\"GPU: {gpu}\")\n",
+        "if \"L4\" not in gpu.upper():\n",
+        "    print(\n",
+        "        f\"⚠ Đang dùng {gpu}, không phải L4 — đổi runtime sang L4 để nhanh hơn.\"\n",
+        "    )"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "9372766b"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "# Tắt XET — thường gây treo download ~89% trên Colab.\n",
+        "# PHẢI chạy cell này TRƯỚC mọi `from huggingface_hub import ...`\n",
+        "import os\n",
+        "\n",
+        "os.environ[\"HF_HUB_DISABLE_XET\"] = \"1\"\n",
+        "os.environ[\"HF_HUB_DOWNLOAD_TIMEOUT\"] = \"300\"\n",
+        "\n",
+        "print(\"HF: HF_HUB_DISABLE_XET=1, timeout 300s\")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "109256f6"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "!pip install -q omnivoice audiotsm huggingface_hub soundfile librosa"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "f320297d"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "### Repo private — đăng nhập Hugging Face (một lần)\n",
+        "\n",
+        "1. Tạo token **Read** tại [hf.co/settings/tokens](https://huggingface.co/settings/tokens)\n",
+        "2. Colab → **🔑 Khóa bí mật** (Manage secrets) → thêm tên `HF_TOKEN`, dán token → **Lưu**\n",
+        "3. Chỉ cần làm **một lần** — các lần chạy sau notebook tự lấy token, không cần nhập lại"
+      ],
+      "id": "dd112ce5"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "from huggingface_hub import login\n",
+        "from google.colab import userdata\n",
+        "\n",
+        "try:\n",
+        "    token = userdata.get(\"HF_TOKEN\")\n",
+        "except userdata.SecretNotFoundError as e:\n",
+        "    raise RuntimeError(\n",
+        "        \"Chưa có khóa bí mật HF_TOKEN.\\n\"\n",
+        "        \"Colab → 🔑 Khóa bí mật → Thêm secret tên HF_TOKEN \"\n",
+        "        \"(token Read từ hf.co/settings/tokens).\\n\"\n",
+        "        \"Lưu một lần, lần sau không cần nhập lại.\"\n",
+        "    ) from e\n",
+        "\n",
+        "if not token or not str(token).strip():\n",
+        "    raise RuntimeError(\"HF_TOKEN trong Khóa bí mật đang trống — hãy cập nhật lại.\")\n",
+        "\n",
+        "login(token.strip())\n",
+        "print(\"Đã login Hugging Face (HF_TOKEN từ Khóa bí mật)\")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "7093f8b8"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 2. Tải giọng & công cụ t�� Hugging Face"
+      ],
+      "id": "cf360488"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "from pathlib import Path\n",
+        "from huggingface_hub import snapshot_download\n",
+        "\n",
+        "ROOT = Path(snapshot_download(HF_REPO, repo_type=\"dataset\", local_dir=\"/content/omnivoice-vi\"))\n",
+        "print(f\"Đã tải: {ROOT}\")\n",
+        "print(\"Giọng:\", [p.parent.name for p in sorted((ROOT / \"voices\").glob(\"*/profile.json\"))])"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "db3a8b3d"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "import importlib.util\n",
+        "import sys\n",
+        "\n",
+        "speak_path = ROOT / \"tools\" / \"speak.py\"\n",
+        "spec = importlib.util.spec_from_file_location(\"speak\", speak_path)\n",
+        "speak = importlib.util.module_from_spec(spec)\n",
+        "sys.modules[\"speak\"] = speak\n",
+        "spec.loader.exec_module(speak)\n",
+        "print(\"Đã load speak.py\")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "15179395"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 3. Tải & nạp model (~3–8 phút lần đầu)\n",
+        "\n",
+        "Lần đầu tải **~3.3 GB**. Treo ở ~89% → **Runtime → Restart session**, chạy lại từ **mục 1** (cell tắt XET phải chạy trước login HF)."
+      ],
+      "id": "1098d631"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "from huggingface_hub import hf_hub_download\n",
+        "\n",
+        "OMNI_MODEL = \"k2-fsa/OmniVoice\"\n",
+        "\n",
+        "# Tải từng file lớn (tránh treo snapshot_download trên Colab)\n",
+        "for relpath, label in [\n",
+        "    (\"model.safetensors\", \"LLM ~2.4 GB\"),\n",
+        "    (\"audio_tokenizer/model.safetensors\", \"Audio tokenizer ~770 MB\"),\n",
+        "]:\n",
+        "    print(f\"\\n>>> {label}\")\n",
+        "    path = hf_hub_download(OMNI_MODEL, relpath)\n",
+        "    print(f\"    OK: {path}\")\n",
+        "\n",
+        "for relpath in (\n",
+        "    \"config.json\",\n",
+        "    \"tokenizer.json\",\n",
+        "    \"tokenizer_config.json\",\n",
+        "    \"chat_template.jinja\",\n",
+        "    \"audio_tokenizer/config.json\",\n",
+        "    \"audio_tokenizer/preprocessor_config.json\",\n",
+        "):\n",
+        "    hf_hub_download(OMNI_MODEL, relpath)\n",
+        "\n",
+        "print(\"\\n✓ Model k2-fsa/OmniVoice đã cache xong.\")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "f69ce212"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "PROFILE = speak.load_profile(ROOT / \"voices\" / DEFAULT_VOICE / \"profile.json\")\n",
+        "MODEL = speak.load_model(PROFILE)\n",
+        "PROMPT = speak.ensure_voice_prompt(MODEL, PROFILE)\n",
+        "print(f\"Giọng: {PROFILE['name']} ({DEFAULT_VOICE}) | SR: {MODEL.sampling_rate}\")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "93c1dc54"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 4. Lồng tiếng SRT từ Google Drive\n",
+        "\n",
+        "Đặt file SRT vào **`MyDrive/Omivoice/`**. Giọng = **`DEFAULT_VOICE`** ở mục 0."
+      ],
+      "id": "1ea557c5"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "from google.colab import drive\n",
+        "\n",
+        "drive.mount(\"/content/drive\")\n",
+        "\n",
+        "DRIVE_OMIVOICE = Path(\"/content/drive/MyDrive\") / DRIVE_FOLDER\n",
+        "DRIVE_OMIVOICE.mkdir(parents=True, exist_ok=True)\n",
+        "\n",
+        "srt_name = SRT_FILE if SRT_FILE.lower().endswith(\".srt\") else f\"{SRT_FILE}.srt\"\n",
+        "SRT_PATH = DRIVE_OMIVOICE / srt_name\n",
+        "\n",
+        "if not SRT_PATH.exists():\n",
+        "    existing = sorted(DRIVE_OMIVOICE.glob(\"*.srt\"))\n",
+        "    hint = \"\\n  \".join(str(p.name) for p in existing) if existing else \"(chưa có file .srt)\"\n",
+        "    raise FileNotFoundError(\n",
+        "        f\"Không thấy {SRT_PATH}\\n\"\n",
+        "        f\"Đặt file vào MyDrive/{DRIVE_FOLDER}/ hoặc sửa SRT_FILE.\\n\"\n",
+        "        f\"Các file .srt hiện có:\\n  {hint}\"\n",
+        "    )\n",
+        "\n",
+        "MERGE_OUT = DRIVE_OMIVOICE / f\"{SRT_PATH.stem}_merged.wav\"\n",
+        "OUTPUT_DIR = DRIVE_OMIVOICE / \"output\" / DEFAULT_VOICE / SRT_PATH.stem\n",
+        "\n",
+        "print(f\"Drive:  {DRIVE_OMIVOICE}\")\n",
+        "print(f\"Giọng:  {DEFAULT_VOICE}\")\n",
+        "print(f\"Input:  {SRT_PATH}\")\n",
+        "print(f\"Output: {MERGE_OUT}\")\n",
+        "print(f\"Cues:   {OUTPUT_DIR}\")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "ccb48064"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "from IPython.display import Audio, display\n",
+        "from tqdm.auto import tqdm\n",
+        "import sys\n",
+        "\n",
+        "profile_path = ROOT / \"voices\" / DEFAULT_VOICE / \"profile.json\"\n",
+        "\n",
+        "pbar = tqdm(total=100, unit=\"%\", desc=\"Chuẩn bị\")\n",
+        "\n",
+        "\n",
+        "def on_log(line: str) -> None:\n",
+        "    tqdm.write(line)\n",
+        "    sys.stdout.flush()\n",
+        "\n",
+        "def on_progress(pct: float, desc: str = \"\") -> None:\n",
+        "    pbar.n = min(100, max(0, int(round(pct * 100))))\n",
+        "    if desc:\n",
+        "        pbar.set_description(desc)\n",
+        "    pbar.refresh()\n",
+        "\n",
+        "print(f\"=== SRT: {SRT_PATH.name} | giọng {DEFAULT_VOICE} | mode {MERGE_MODE} ===\", flush=True)\n",
+        "\n",
+        "result = speak.run_srt_pipeline(\n",
+        "    profile_path,\n",
+        "    SRT_PATH,\n",
+        "    output_dir=OUTPUT_DIR,\n",
+        "    merge=True,\n",
+        "    merge_output=MERGE_OUT,\n",
+        "    merge_mode=MERGE_MODE,\n",
+        "    num_step=NUM_STEP,\n",
+        "    model=MODEL,\n",
+        "    prompt=PROMPT,\n",
+        "    on_log=on_log,\n",
+        "    progress=on_progress,\n",
+        ")\n",
+        "\n",
+        "pbar.close()\n",
+        "\n",
+        "merged = result.get(\"merged_wav\")\n",
+        "if merged:\n",
+        "    display(Audio(str(merged)))\n",
+        "\n",
+        "print(\"\\n--- Đã lưu trên Drive ---\")\n",
+        "print(f\"WAV gộp:     {result.get('merged_wav')}\")\n",
+        "print(f\"Từng cue:    {result.get('output_dir')}\")\n",
+        "print(f\"SRT shifted: {result.get('shifted_srt')}\")\n",
+        "stats = result.get(\"stats\", {})\n",
+        "print(\n",
+        "    f\"Thống kê: {stats.get('generated', 0)} cue mới, \"\n",
+        "    f\"{stats.get('skipped', 0)} bỏ qua, \"\n",
+        "    f\"{stats.get('overflow', 0)} tràn\"\n",
+        ")"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "d924855a"
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## 5. Giải phóng VRAM & tắt runtime\n",
+        "\n",
+        "Giải phóng bộ nhớ GPU rồi **ngắt session Colab** (không tính phí GPU nữa). Chạy cell này sau khi mục 4 xong."
+      ],
+      "id": "4ec794ec"
+    },
+    {
+      "cell_type": "code",
+      "metadata": {},
+      "source": [
+        "import gc\n",
+        "import torch\n",
+        "from google.colab import runtime\n",
+        "\n",
+        "try:\n",
+        "    del MODEL, PROMPT, result, pbar\n",
+        "except NameError:\n",
+        "    pass\n",
+        "\n",
+        "gc.collect()\n",
+        "if torch.cuda.is_available():\n",
+        "    torch.cuda.empty_cache()\n",
+        "    torch.cuda.ipc_collect()\n",
+        "\n",
+        "print(\"Đã giải phóng VRAM\")\n",
+        "print(\"Đang tắt runtime Colab...\")\n",
+        "runtime.unassign()"
+      ],
+      "execution_count": null,
+      "outputs": [],
+      "id": "a3acbb68"
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "L4",
+      "machine_shape": "hm",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python",
+      "version": "3.10.0"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

tools/speak.py

@@ -0,0 +1,1209 @@
+"""Đọc văn bản / file / SRT bằng voice profile (.pt).
+
+Ví dụ:
+    python tools/speak.py voices
+    python tools/speak.py --profile voices/ban_mai/profile.json build
+    python tools/speak.py --profile voices/ban_mai/profile.json text --text "..." -o out.wav
+    python tools/speak.py --profile voices/ban_mai/profile.json srt --input video.srt
+    python tools/speak.py --profile voices/ban_mai/profile.json srt --input video.srt --merge -o dub.wav --fit-duration
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import re
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, List, Optional
+
+import librosa
+import numpy as np
+import soundfile as sf
+import torch
+
+from omnivoice.models.omnivoice import OmniVoice, VoiceClonePrompt
+
+ROOT = Path(__file__).resolve().parents[1]
+VOICES_DIR = ROOT / "voices"
+DEFAULT_VOICE_SLUG = "tuong_vy"
+DEFAULT_PROFILE = VOICES_DIR / DEFAULT_VOICE_SLUG / "profile.json"
+
+# Mặc định biểu cảm: bật lấy mẫu token có nhiệt độ thay vì greedy (0.0).
+# Greedy khiến ngữ điệu phẳng, "máy móc"; 0.4 cho nhấn nhá vừa phải, ổn định.
+DEFAULT_CLASS_TEMPERATURE = 0.4
+DEFAULT_GUIDANCE_SCALE = 2.0
+
+
+@dataclass
+class SrtCue:
+    index: int
+    start_sec: float
+    end_sec: float
+    text: str
+
+
+def discover_profiles() -> List[Path]:
+    if not VOICES_DIR.exists():
+        return []
+    return sorted(
+        p for p in VOICES_DIR.glob("*/profile.json") if p.is_file()
+    )
+
+
+def profile_slug(profile_path: Path) -> str:
+    return profile_path.parent.name
+
+
+def load_profile(profile_path: Path) -> dict:
+    with profile_path.open(encoding="utf-8") as f:
+        profile = json.load(f)
+    base = profile_path.parent
+    profile["_base"] = base
+    profile["_profile_path"] = str(profile_path)
+    profile["slug"] = profile.get("slug", profile_slug(profile_path))
+    profile["ref_audio_path"] = str(base / profile["ref_audio"])
+    profile["ref_text_path"] = str(base / profile["ref_text_file"])
+    profile["voice_prompt_path"] = str(base / profile["voice_prompt"])
+    return profile
+
+
+def default_output_dir(profile: dict, stem: str) -> Path:
+    return ROOT / "output" / profile["slug"] / stem
+
+
+def read_ref_text(profile: dict) -> str:
+    return Path(profile["ref_text_path"]).read_text(encoding="utf-8").strip()
+
+
+def load_model(profile: dict) -> OmniVoice:
+    return OmniVoice.from_pretrained(
+        profile.get("model", "k2-fsa/OmniVoice"),
+        device_map=profile.get("device", "cuda:0"),
+        dtype=torch.float16,
+    )
+
+
+def build_voice_prompt(model: OmniVoice, profile: dict) -> VoiceClonePrompt:
+    preprocess = profile.get("preprocess_prompt", True)
+    auto_transcribe = profile.get("auto_transcribe", False)
+
+    if auto_transcribe:
+        ref_text = None
+        logging.info(
+            "Tạo voice profile từ %s (Whisper tự nhận diện ref_text)",
+            profile["ref_audio_path"],
+        )
+    else:
+        ref_text = read_ref_text(profile)
+        logging.info("Tạo voice profile từ %s", profile["ref_audio_path"])
+
+    prompt = model.create_voice_clone_prompt(
+        ref_audio=profile["ref_audio_path"],
+        ref_text=ref_text,
+        preprocess_prompt=preprocess,
+    )
+
+    if auto_transcribe:
+        ref_text_path = Path(profile["ref_text_path"])
+        ref_text_path.write_text(prompt.ref_text, encoding="utf-8")
+        logging.info("Đã cập nhật ref_text từ Whisper: %s", ref_text_path)
+
+    return prompt
+
+
+def save_voice_prompt(prompt: VoiceClonePrompt, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    torch.save(
+        {
+            "ref_audio_tokens": prompt.ref_audio_tokens.cpu(),
+            "ref_text": prompt.ref_text,
+            "ref_rms": prompt.ref_rms,
+        },
+        path,
+    )
+    logging.info("Đã lưu voice profile: %s", path)
+
+
+def load_voice_prompt(path: Path) -> VoiceClonePrompt:
+    data = torch.load(path, map_location="cpu", weights_only=True)
+    return VoiceClonePrompt(
+        ref_audio_tokens=data["ref_audio_tokens"],
+        ref_text=data["ref_text"],
+        ref_rms=data["ref_rms"],
+    )
+
+
+def ensure_voice_prompt(model: OmniVoice, profile: dict) -> VoiceClonePrompt:
+    prompt_path = Path(profile["voice_prompt_path"])
+    if prompt_path.exists():
+        logging.info("Dùng voice profile có sẵn: %s", prompt_path)
+        return load_voice_prompt(prompt_path)
+    prompt = build_voice_prompt(model, profile)
+    save_voice_prompt(prompt, prompt_path)
+    return prompt
+
+
+def time_stretch_speech(audio: np.ndarray, rate: float) -> np.ndarray:
+    """Tăng/giảm tốc audio giữ cao độ, ưu tiên WSOLA cho giọng nói.
+
+    WSOLA (audiotsm) giữ chất giọng tự nhiên hơn nhiều so với phase vocoder
+    của librosa khi tăng tốc. Nếu WSOLA lỗi, fallback về librosa.
+    """
+    rate = float(rate)
+    audio = np.ascontiguousarray(audio.astype(np.float32))
+    if abs(rate - 1.0) < 1e-3 or audio.size == 0:
+        return audio
+    try:
+        from audiotsm import wsola
+        from audiotsm.io.array import ArrayReader, ArrayWriter
+
+        reader = ArrayReader(audio.reshape(1, -1))
+        writer = ArrayWriter(channels=1)
+        wsola(channels=1, speed=rate).run(reader, writer)
+        out = np.asarray(writer.data, dtype=np.float32).flatten()
+        if out.size > 0:
+            return out
+        raise ValueError("WSOLA trả về rỗng")
+    except Exception as exc:  # noqa: BLE001
+        logging.warning("WSOLA lỗi (%s), dùng librosa phase vocoder", exc)
+        return librosa.effects.time_stretch(audio, rate=rate)
+
+
+def apply_speed_policy(
+    audio: np.ndarray,
+    sample_rate: int,
+    slot_sec: float,
+    *,
+    speed_mode: str,
+    gentle_threshold: float,
+) -> tuple[np.ndarray, dict]:
+    """Xử lý tốc độ theo chế độ — ưu tiên giữ chất giọng đoạn dài.
+
+    - off: không đổi tốc độ, cascade tràn sang cue sau.
+    - gentle: chỉ tăng tốc nhẹ nếu cần <= gentle_threshold (mặc định 1.08).
+    - force: ép vừa slot bằng time-stretch (có thể méo giọng).
+    """
+    generated_sec = len(audio) / sample_rate
+    meta = {
+        "generated_sec": round(generated_sec, 3),
+        "slot_sec": round(slot_sec, 3),
+        "required_speed_factor": 1.0,
+        "speed_factor": 1.0,
+        "speed_mode": speed_mode,
+        "gentle_threshold": round(gentle_threshold, 3),
+        "speed_fitted": False,
+        "speed_skipped": False,
+        "speed_skip_reason": None,
+    }
+
+    if slot_sec <= 0 or generated_sec <= slot_sec:
+        meta["audio_sec"] = round(generated_sec, 3)
+        return audio, meta
+
+    required_rate = generated_sec / slot_sec
+    meta["required_speed_factor"] = round(required_rate, 3)
+
+    if speed_mode == "off":
+        meta["audio_sec"] = round(generated_sec, 3)
+        meta["speed_skipped"] = True
+        meta["speed_skip_reason"] = "cascade_overflow"
+        logging.info(
+            "Cue %.2fs > slot %.2fs: giữ nguyên giọng, tràn cascade (cần x%.2f)",
+            generated_sec,
+            slot_sec,
+            required_rate,
+        )
+        return audio, meta
+
+    if speed_mode == "gentle" and required_rate > gentle_threshold:
+        meta["audio_sec"] = round(generated_sec, 3)
+        meta["speed_skipped"] = True
+        meta["speed_skip_reason"] = "exceeds_gentle_threshold"
+        logging.info(
+            "Cue dài %.2fs / slot %.2fs (x%.2f > %.2f): giữ nguyên giọng, tràn cascade",
+            generated_sec,
+            slot_sec,
+            required_rate,
+            gentle_threshold,
+        )
+        return audio, meta
+
+    rate = required_rate if speed_mode == "force" else min(required_rate, gentle_threshold)
+    stretched = time_stretch_speech(audio, rate)
+
+    if speed_mode == "gentle" or speed_mode == "force":
+        target_samples = int(round(slot_sec * sample_rate))
+        if len(stretched) > target_samples:
+            stretched = stretched[:target_samples]
+        elif len(stretched) < target_samples:
+            stretched = np.pad(stretched, (0, target_samples - len(stretched)))
+
+    meta["speed_factor"] = round(rate, 3)
+    meta["speed_fitted"] = True
+    meta["audio_sec"] = round(len(stretched) / sample_rate, 3)
+    logging.info(
+        "Tăng tốc nhẹ cue: %.2fs -> %.2fs (x%.2f, mode=%s)",
+        generated_sec,
+        meta["audio_sec"],
+        rate,
+        speed_mode,
+    )
+    return stretched, meta
+
+
+def synthesize(
+    model: OmniVoice,
+    prompt: VoiceClonePrompt,
+    text: str,
+    language: str,
+    **kwargs,
+) -> np.ndarray:
+    text = text.strip()
+    if not text:
+        raise ValueError("Văn bản trống.")
+    audios = model.generate(
+        text=text,
+        language=language,
+        voice_clone_prompt=prompt,
+        **kwargs,
+    )
+    return audios[0]
+
+
+def estimate_natural_duration_sec(
+    model: OmniVoice, prompt: VoiceClonePrompt, text: str
+) -> float:
+    """Ước lượng thời lượng đọc tự nhiên (giây) của text với giọng mẫu.
+
+    Dùng chính bộ ước lượng của model (không cần sinh audio), nhờ đó biết
+    trước câu nào sẽ dài hơn khung SRT để quyết định tốc độ native.
+    """
+    text = text.strip()
+    if not text:
+        return 0.0
+    est_tokens = model.duration_estimator.estimate_duration(
+        text,
+        prompt.ref_text,
+        prompt.ref_audio_tokens.size(-1),
+    )
+    frame_rate = model.audio_tokenizer.config.frame_rate
+    return float(est_tokens) / frame_rate if frame_rate else 0.0
+
+
+def parse_srt_time(value: str) -> float:
+    hh, mm, rest = value.strip().split(":")
+    ss, ms = rest.split(",")
+    return int(hh) * 3600 + int(mm) * 60 + int(ss) + int(ms) / 1000.0
+
+
+def parse_srt(content: str) -> List[SrtCue]:
+    content = content.replace("\r\n", "\n").replace("\r", "\n").strip()
+    blocks = re.split(r"\n\s*\n", content)
+    cues: List[SrtCue] = []
+
+    for block in blocks:
+        lines = [line.strip() for line in block.split("\n") if line.strip()]
+        if len(lines) < 2:
+            continue
+        if not lines[0].isdigit():
+            continue
+        index = int(lines[0])
+        if "-->" not in lines[1]:
+            continue
+        start_raw, end_raw = [part.strip() for part in lines[1].split("-->")]
+        text = " ".join(lines[2:])
+        text = re.sub(r"<[^>]+>", "", text).strip()
+        if not text:
+            continue
+        cues.append(
+            SrtCue(
+                index=index,
+                start_sec=parse_srt_time(start_raw),
+                end_sec=parse_srt_time(end_raw),
+                text=text,
+            )
+        )
+    return cues
+
+
+def format_srt_time(sec: float) -> str:
+    if sec < 0:
+        sec = 0.0
+    total_ms = int(round(sec * 1000))
+    ms = total_ms % 1000
+    total_sec = total_ms // 1000
+    hours = total_sec // 3600
+    minutes = (total_sec % 3600) // 60
+    seconds = total_sec % 60
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d},{ms:03d}"
+
+
+def plan_cascade_placements(
+    cues: List[SrtCue],
+    segments: List[np.ndarray],
+    sample_rate: int,
+) -> List[dict]:
+    """Tính vị trí thực tế: cue dài hơn slot sẽ đẩy các cue sau."""
+    placements: List[dict] = []
+    cursor = 0.0
+
+    for cue, audio in zip(cues, segments):
+        audio_sec = len(audio) / sample_rate
+        slot_sec = max(0.0, cue.end_sec - cue.start_sec)
+        actual_start = max(cue.start_sec, cursor)
+        actual_end = actual_start + audio_sec
+        pushed = actual_start > cue.start_sec + 0.01
+        if pushed:
+            overflow_sec = 0.0
+        else:
+            overflow_sec = max(0.0, actual_end - cue.end_sec)
+
+        placements.append(
+            {
+                "actual_start_sec": round(actual_start, 3),
+                "actual_end_sec": round(actual_end, 3),
+                "overflow_sec": round(overflow_sec, 3),
+                "pushed_by_previous": pushed,
+            }
+        )
+        if overflow_sec > 0:
+            logging.info(
+                "Cue %s dài %.2fs / slot %.2fs -> tràn %.2fs, kết thúc %.2fs",
+                cue.index,
+                audio_sec,
+                slot_sec,
+                overflow_sec,
+                actual_end,
+            )
+        cursor = actual_end
+
+    return placements
+
+
+def plan_native_placements(
+    cues: List[SrtCue],
+    segments: List[np.ndarray],
+    sample_rate: int,
+) -> List[dict]:
+    """Neo cứng mỗi cue đúng mốc SRT gốc — lỗi lệch KHÔNG bao giờ cộng dồn.
+
+    Kiểu lồng tiếng chuyên nghiệp: câu dài hơn khung đã được nói nhanh native
+    vừa đủ chứa hết chữ (xử lý lúc sinh audio), nên ở đây chỉ cần đặt từng câu
+    đúng vị trí thời gian của nó. Mỗi câu độc lập theo mốc SRT, câu này không
+    đẩy câu kia → đồng bộ tiếng/hình ổn định suốt video.
+    """
+    placements: List[dict] = []
+    n = len(cues)
+
+    for i, (cue, audio) in enumerate(zip(cues, segments)):
+        audio_sec = len(audio) / sample_rate
+        actual_start = cue.start_sec
+        actual_end = actual_start + audio_sec
+        next_start = cues[i + 1].start_sec if i + 1 < n else actual_end
+        overflow = max(0.0, actual_end - next_start)
+
+        placements.append(
+            {
+                "actual_start_sec": round(actual_start, 3),
+                "actual_end_sec": round(actual_end, 3),
+                "overflow_sec": round(overflow, 3),
+                "pushed_by_previous": False,
+            }
+        )
+        if overflow > 0.05:
+            logging.info(
+                "Cue %s: vẫn vượt khung %.2fs sau khi tăng tốc (cân nhắc tăng "
+                "--native-speed-cap để chứa hết chữ)",
+                cue.index,
+                overflow,
+            )
+
+    return placements
+
+
+def write_shifted_srt(
+    path: Path,
+    cues: List[SrtCue],
+    placements: List[dict],
+) -> None:
+    blocks = []
+    for cue, placement in zip(cues, placements):
+        start = format_srt_time(placement["actual_start_sec"])
+        end = format_srt_time(placement["actual_end_sec"])
+        blocks.append(f"{cue.index}\n{start} --> {end}\n{cue.text}\n")
+    path.write_text("\n".join(blocks), encoding="utf-8")
+
+
+def write_manifest(
+    path: Path,
+    cues: List[SrtCue],
+    wav_paths: List[Path],
+    fit_metas: List[dict],
+    sample_rate: int,
+    profile: dict,
+    srt_input: Path,
+    merge_mode: str,
+) -> None:
+    rows = []
+    for cue, wav, fit_meta in zip(cues, wav_paths, fit_metas):
+        slot_sec = max(0.0, cue.end_sec - cue.start_sec)
+        rows.append(
+            {
+                "index": cue.index,
+                "start_sec": cue.start_sec,
+                "end_sec": cue.end_sec,
+                "slot_sec": round(slot_sec, 3),
+                "actual_start_sec": fit_meta.get("actual_start_sec"),
+                "actual_end_sec": fit_meta.get("actual_end_sec"),
+                "overflow_sec": fit_meta.get("overflow_sec", 0.0),
+                "pushed_by_previous": fit_meta.get("pushed_by_previous", False),
+                "fit_applied": fit_meta.get("fit_applied", False),
+                "fit_speed_factor": fit_meta.get("fit_speed_factor", 1.0),
+                "generated_sec": fit_meta.get("generated_sec"),
+                "audio_sec": fit_meta.get("audio_sec"),
+                "required_speed_factor": fit_meta.get("required_speed_factor", 1.0),
+                "speed_factor": fit_meta.get("speed_factor", 1.0),
+                "speed_mode": fit_meta.get("speed_mode"),
+                "gentle_threshold": fit_meta.get("gentle_threshold"),
+                "speed_fitted": fit_meta.get("speed_fitted", False),
+                "speed_skipped": fit_meta.get("speed_skipped", False),
+                "speed_skip_reason": fit_meta.get("speed_skip_reason"),
+                "text": cue.text,
+                "wav": str(wav),
+                "wav_relative": wav.name,
+            }
+        )
+    payload = {
+        "voice": profile.get("name", profile["slug"]),
+        "voice_slug": profile["slug"],
+        "language": profile.get("language"),
+        "srt_input": str(srt_input),
+        "sample_rate": sample_rate,
+        "merge_mode": merge_mode,
+        "cues": rows,
+    }
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def merge_timeline_strict(
+    cues: List[SrtCue],
+    audio_segments: List[np.ndarray],
+    sample_rate: int,
+    tail_sec: float = 0.5,
+) -> np.ndarray:
+    if not cues:
+        raise ValueError("Không có cue SRT để gộp.")
+    total_sec = max(cue.end_sec for cue in cues) + tail_sec
+    merged = np.zeros(int(total_sec * sample_rate), dtype=np.float32)
+    for cue, audio in zip(cues, audio_segments):
+        start = int(cue.start_sec * sample_rate)
+        end = min(start + len(audio), len(merged))
+        merged[start:end] = audio[: end - start]
+    return _normalize_audio(merged)
+
+
+def merge_timeline_cascade(
+    placements: List[dict],
+    audio_segments: List[np.ndarray],
+    sample_rate: int,
+    tail_sec: float = 0.5,
+) -> np.ndarray:
+    if not placements:
+        raise ValueError("Không có cue SRT để gộp.")
+    total_sec = placements[-1]["actual_end_sec"] + tail_sec
+    merged = np.zeros(int(total_sec * sample_rate), dtype=np.float32)
+    for placement, audio in zip(placements, audio_segments):
+        start = int(placement["actual_start_sec"] * sample_rate)
+        end = start + len(audio)
+        if end > len(merged):
+            merged = np.pad(merged, (0, end - len(merged)))
+        merged[start:end] = audio
+    return _normalize_audio(merged)
+
+
+def plan_fit_placements(
+    cues: List[SrtCue],
+    segments: List[np.ndarray],
+    sample_rate: int,
+    max_speed_factor: float = 1.6,
+    min_gap_sec: float = 0.05,
+) -> tuple[List[dict], List[np.ndarray]]:
+    """Neo mỗi cue đúng mốc SRT gốc, tăng tốc cả câu (giữ pitch) cho vừa khung.
+
+    - Cue vừa khung: giữ nguyên, không đổi tốc độ.
+    - Cue tràn, cần tăng tốc <= max_speed_factor: time-stretch vừa đủ -> khớp SRT
+      tuyệt đối, giọng tự nhiên (phase vocoder giữ cao độ).
+    - Cue tràn nặng, cần > max_speed_factor: chỉ tăng tới trần (giữ giọng),
+      phần dư cho tràn nhẹ và tự khớp lại ở các cue ngắn kế tiếp (cascade mềm).
+    """
+    placements: List[dict] = []
+    fitted_segments: List[np.ndarray] = []
+    n = len(cues)
+    cursor = 0.0
+
+    for i, (cue, audio) in enumerate(zip(cues, segments)):
+        audio_sec = len(audio) / sample_rate
+        start = max(cue.start_sec, cursor)
+
+        if i + 1 < n:
+            room_sec = max(min_gap_sec, cues[i + 1].start_sec - start)
+        else:
+            room_sec = audio_sec  # cue cuối: không giới hạn
+
+        capped = False
+        if audio_sec > room_sec + 1e-3:
+            required = audio_sec / room_sec
+            rate = min(required, max_speed_factor)
+            stretched = time_stretch_speech(audio, rate)
+            if rate >= required - 1e-3:
+                target = int(round(room_sec * sample_rate))
+                if len(stretched) > target:
+                    stretched = stretched[:target]
+                elif len(stretched) < target:
+                    stretched = np.pad(stretched, (0, target - len(stretched)))
+            else:
+                capped = True
+            fitted = True
+            speed_factor = rate
+        else:
+            stretched = audio
+            fitted = False
+            speed_factor = 1.0
+
+        seg_sec = len(stretched) / sample_rate
+        actual_end = start + seg_sec
+        next_start = cues[i + 1].start_sec if i + 1 < n else actual_end
+        overflow = max(0.0, actual_end - next_start)
+        placements.append(
+            {
+                "actual_start_sec": round(start, 3),
+                "actual_end_sec": round(actual_end, 3),
+                "overflow_sec": round(overflow, 3),
+                "pushed_by_previous": start > cue.start_sec + 0.01,
+                "fit_applied": fitted,
+                "fit_speed_factor": round(speed_factor, 3),
+                "fit_capped": capped,
+            }
+        )
+        fitted_segments.append(stretched)
+        cursor = actual_end
+        if fitted:
+            logging.info(
+                "Cue %s: %.2fs -> %.2fs (x%.2f%s)",
+                cue.index,
+                audio_sec,
+                seg_sec,
+                speed_factor,
+                ", chạm trần - tràn nhẹ" if capped else "",
+            )
+
+    return placements, fitted_segments
+
+
+def merge_timeline_fit(
+    placements: List[dict],
+    fitted_segments: List[np.ndarray],
+    sample_rate: int,
+    tail_sec: float = 0.5,
+) -> np.ndarray:
+    if not placements:
+        raise ValueError("Không có cue SRT để gộp.")
+    total_sec = placements[-1]["actual_end_sec"] + tail_sec
+    merged = np.zeros(int(total_sec * sample_rate), dtype=np.float32)
+    for placement, audio in zip(placements, fitted_segments):
+        start = int(placement["actual_start_sec"] * sample_rate)
+        end = start + len(audio)
+        if end > len(merged):
+            merged = np.pad(merged, (0, end - len(merged)))
+        merged[start:end] = audio
+    return _normalize_audio(merged)
+
+
+def _normalize_audio(audio: np.ndarray) -> np.ndarray:
+    peak = np.max(np.abs(audio))
+    if peak > 1.0:
+        return audio / peak * 0.98
+    return audio
+
+
+def cmd_build(args: argparse.Namespace) -> None:
+    profile = load_profile(Path(args.profile))
+    model = load_model(profile)
+    prompt = build_voice_prompt(model, profile)
+    save_voice_prompt(prompt, Path(profile["voice_prompt_path"]))
+
+
+def cmd_text(args: argparse.Namespace) -> None:
+    profile = load_profile(Path(args.profile))
+    model = load_model(profile)
+    prompt = ensure_voice_prompt(model, profile)
+    audio = synthesize(
+        model,
+        prompt,
+        args.text,
+        profile["language"],
+        num_step=args.num_step,
+        class_temperature=args.class_temperature,
+        guidance_scale=args.guidance_scale,
+    )
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    sf.write(out, audio, model.sampling_rate)
+    logging.info("Đã lưu: %s", out)
+
+
+def cmd_file(args: argparse.Namespace) -> None:
+    text = Path(args.input).read_text(encoding="utf-8").strip()
+    ns = argparse.Namespace(**vars(args))
+    ns.text = text
+    cmd_text(ns)
+
+
+def cmd_voices(_: argparse.Namespace) -> None:
+    profiles = discover_profiles()
+    if not profiles:
+        print("Chưa có giọng nào trong voices/*/profile.json")
+        return
+    for path in profiles:
+        profile = load_profile(path)
+        ready = Path(profile["voice_prompt_path"]).exists()
+        status = "ready" if ready else "missing voice.pt"
+        print(f"- {profile['slug']}: {profile.get('name', profile['slug'])} [{status}]")
+        print(f"  profile: {path}")
+
+
+def list_voice_choices() -> List[tuple[str, str, str]]:
+    rows = []
+    for path in discover_profiles():
+        profile = load_profile(path)
+        ready = Path(profile["voice_prompt_path"]).exists()
+        label = f"{profile.get('name', profile['slug'])} ({'ready' if ready else 'no .pt'})"
+        rows.append((profile["slug"], label, str(path)))
+    return rows
+
+
+def _pipe_log(log_lines: List[str], line: str, on_log: Optional[Callable[[str], None]] = None) -> None:
+    log_lines.append(line)
+    if on_log is not None:
+        on_log(line)
+
+
+def run_srt_pipeline(
+    profile_path: Path,
+    srt_path: Path,
+    *,
+    output_dir: Optional[Path] = None,
+    merge: bool = False,
+    merge_output: Optional[Path] = None,
+    merge_mode: str = "cascade",
+    speed_mode: str = "off",
+    gentle_threshold: float = 1.08,
+    max_speed_factor: float = 1.6,
+    native_speed_cap: float = 2.0,
+    num_step: int = 32,
+    class_temperature: float = DEFAULT_CLASS_TEMPERATURE,
+    guidance_scale: float = DEFAULT_GUIDANCE_SCALE,
+    skip_existing: bool = False,
+    from_cue: Optional[int] = None,
+    to_cue: Optional[int] = None,
+    model: Optional[OmniVoice] = None,
+    prompt: Optional[VoiceClonePrompt] = None,
+    progress=None,
+    on_log: Optional[Callable[[str], None]] = None,
+) -> dict:
+    if speed_mode == "gentle" and gentle_threshold <= 1.0:
+        raise ValueError("--gentle-threshold phải lớn hơn 1.0")
+
+    profile = load_profile(profile_path)
+    if model is None:
+        model = load_model(profile)
+    if prompt is None:
+        prompt = ensure_voice_prompt(model, profile)
+
+    srt_path = Path(srt_path)
+    content = srt_path.read_text(encoding="utf-8")
+    cues = parse_srt(content)
+    if not cues:
+        raise ValueError("Không đọc được cue nào từ file SRT.")
+
+    if from_cue is not None:
+        cues = [c for c in cues if c.index >= from_cue]
+    if to_cue is not None:
+        cues = [c for c in cues if c.index <= to_cue]
+    if not cues:
+        raise ValueError("Không còn cue nào sau khi lọc from/to.")
+
+    if output_dir:
+        output_dir = Path(output_dir)
+    else:
+        output_dir = default_output_dir(profile, srt_path.stem)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    wav_paths: List[Path] = []
+    segments: List[np.ndarray] = []
+    fit_metas: List[dict] = []
+    log_lines: List[str] = []
+    generated = 0
+    skipped = 0
+    speed_fitted_count = 0
+    speed_skipped_count = 0
+    merged_path: Optional[Path] = None
+    total = len(cues)
+    _pipe_log(log_lines, f"Bắt đầu: {total} cue | chế độ ghép: {merge_mode}", on_log)
+
+    for idx, cue in enumerate(cues):
+        if progress is not None:
+            progress(idx / max(total, 1), desc=f"Cue {cue.index}/{total}")
+
+        wav_path = output_dir / f"{cue.index:04d}.wav"
+        slot_sec = max(0.0, cue.end_sec - cue.start_sec)
+
+        if skip_existing and wav_path.exists():
+            audio, sr = sf.read(wav_path, dtype="float32")
+            if audio.ndim > 1:
+                audio = audio.mean(axis=1)
+            audio_sec = len(audio) / sr
+            segments.append(audio)
+            wav_paths.append(wav_path)
+            fit_metas.append(
+                {
+                    "generated_sec": round(audio_sec, 3),
+                    "audio_sec": round(audio_sec, 3),
+                    "slot_sec": round(slot_sec, 3),
+                    "required_speed_factor": 1.0,
+                    "speed_factor": 1.0,
+                    "speed_mode": speed_mode,
+                    "gentle_threshold": round(gentle_threshold, 3),
+                    "speed_fitted": False,
+                    "speed_skipped": False,
+                    "speed_skip_reason": None,
+                }
+            )
+            skipped += 1
+            _pipe_log(log_lines, f"[skip] Cue {cue.index}: {wav_path.name}", on_log)
+            if progress is not None:
+                progress((idx + 1) / max(total, 1), desc=f"Xong cue {cue.index}/{total}")
+            continue
+
+        _pipe_log(log_lines, f"[gen] Cue {cue.index} ({slot_sec:.1f}s): {cue.text[:50]}...", on_log)
+
+        native_meta: Optional[dict] = None
+        gen_duration: Optional[float] = None
+        if merge_mode == "native":
+            # Ngân sách = thời gian tới khi cue kế bắt đầu (slot + khoảng lặng sau).
+            if idx + 1 < total:
+                budget = max(0.05, cues[idx + 1].start_sec - cue.start_sec)
+            else:
+                budget = None
+            if budget is not None and budget > 0:
+                # Chừa biên an toàn nhỏ để phần đệm fade/pad ở đuôi không đè
+                # sang cue sau (tránh cảm giác mất chữ/đè đuôi).
+                fit_target = max(0.1, budget - 0.12)
+                natural_sec = estimate_natural_duration_sec(model, prompt, cue.text)
+                if natural_sec > fit_target + 1e-3:
+                    # Ép native vừa khít, không vượt trần tốc độ.
+                    gen_duration = round(
+                        max(fit_target, natural_sec / native_speed_cap), 3
+                    )
+                    native_meta = {
+                        "natural_sec": round(natural_sec, 3),
+                        "budget_sec": round(budget, 3),
+                        "native_duration_sec": gen_duration,
+                        "native_speed_factor": round(
+                            natural_sec / gen_duration, 3
+                        )
+                        if gen_duration
+                        else 1.0,
+                        "native_capped": natural_sec / native_speed_cap
+                        > fit_target + 1e-3,
+                    }
+
+        synth_kwargs = dict(
+            num_step=num_step,
+            class_temperature=class_temperature,
+            guidance_scale=guidance_scale,
+        )
+        if gen_duration is not None:
+            synth_kwargs["duration"] = gen_duration
+
+        audio = synthesize(
+            model,
+            prompt,
+            cue.text,
+            profile["language"],
+            **synth_kwargs,
+        )
+
+        if merge_mode == "native":
+            audio_sec = len(audio) / model.sampling_rate
+            fit_meta = {
+                "generated_sec": round(audio_sec, 3),
+                "audio_sec": round(audio_sec, 3),
+                "slot_sec": round(slot_sec, 3),
+                "required_speed_factor": 1.0,
+                "speed_factor": 1.0,
+                "speed_mode": "native",
+                "gentle_threshold": round(gentle_threshold, 3),
+                "speed_fitted": gen_duration is not None,
+                "speed_skipped": False,
+                "speed_skip_reason": None,
+            }
+            if native_meta is not None:
+                fit_meta.update(native_meta)
+                speed_fitted_count += 1
+                if native_meta.get("native_capped"):
+                    _pipe_log(
+                        log_lines,
+                        f"  Cue {cue.index}: native {native_meta['natural_sec']}s "
+                        f"-> {native_meta['native_duration_sec']}s "
+                        f"(x{native_meta['native_speed_factor']}, chạm trần - tràn nhẹ)",
+                        on_log,
+                    )
+        elif slot_sec > 0 and merge_mode != "fit":
+            audio, fit_meta = apply_speed_policy(
+                audio,
+                model.sampling_rate,
+                slot_sec,
+                speed_mode=speed_mode,
+                gentle_threshold=gentle_threshold,
+            )
+            if fit_meta["speed_fitted"]:
+                speed_fitted_count += 1
+            if fit_meta.get("speed_skipped"):
+                speed_skipped_count += 1
+        else:
+            audio_sec = len(audio) / model.sampling_rate
+            fit_meta = {
+                "generated_sec": round(audio_sec, 3),
+                "audio_sec": round(audio_sec, 3),
+                "slot_sec": round(slot_sec, 3),
+                "required_speed_factor": 1.0,
+                "speed_factor": 1.0,
+                "speed_mode": speed_mode,
+                "gentle_threshold": round(gentle_threshold, 3),
+                "speed_fitted": False,
+                "speed_skipped": False,
+                "speed_skip_reason": None,
+            }
+
+        sf.write(wav_path, audio, model.sampling_rate)
+        wav_paths.append(wav_path)
+        segments.append(audio)
+        fit_metas.append(fit_meta)
+        generated += 1
+        if progress is not None:
+            progress((idx + 1) / max(total, 1), desc=f"Xong cue {cue.index}/{total}")
+
+    if progress is not None:
+        progress(0.9, desc="Đang canh giờ & ghi manifest")
+    fitted_segments: Optional[List[np.ndarray]] = None
+    if merge_mode == "native":
+        placements = plan_native_placements(cues, segments, model.sampling_rate)
+    elif merge_mode == "cascade":
+        placements = plan_cascade_placements(cues, segments, model.sampling_rate)
+    elif merge_mode == "fit":
+        placements, fitted_segments = plan_fit_placements(
+            cues, segments, model.sampling_rate, max_speed_factor=max_speed_factor
+        )
+    else:
+        placements = [
+            {
+                "actual_start_sec": round(cue.start_sec, 3),
+                "actual_end_sec": round(
+                    cue.start_sec + len(audio) / model.sampling_rate, 3
+                ),
+                "overflow_sec": 0.0,
+                "pushed_by_previous": False,
+            }
+            for cue, audio in zip(cues, segments)
+        ]
+
+    overflow_count = sum(1 for p in placements if p["overflow_sec"] > 0)
+    pushed_count = sum(1 for p in placements if p["pushed_by_previous"])
+    fit_count = sum(1 for p in placements if p.get("fit_applied"))
+    capped_count = sum(1 for p in placements if p.get("fit_capped"))
+
+    for fit_meta, placement in zip(fit_metas, placements):
+        fit_meta.update(placement)
+
+    manifest = output_dir / "manifest.json"
+    write_manifest(
+        manifest,
+        cues,
+        wav_paths,
+        fit_metas,
+        model.sampling_rate,
+        profile,
+        srt_path,
+        merge_mode,
+    )
+
+    shifted_srt = output_dir / f"{srt_path.stem}_shifted.srt"
+    write_shifted_srt(shifted_srt, cues, placements)
+
+    if merge_mode == "fit":
+        summary = (
+            f"Hoàn tất [{profile['slug']}] (fit): {generated} cue mới, "
+            f"{fit_count} cue tăng tốc khớp giờ ({capped_count} chạm trần, tràn nhẹ), "
+            f"{skipped} bỏ qua"
+        )
+    elif merge_mode == "native":
+        native_capped = sum(1 for m in fit_metas if m.get("native_capped"))
+        summary = (
+            f"Hoàn tất [{profile['slug']}] (native): {generated} cue mới, "
+            f"{speed_fitted_count} cue nói nhanh native cho vừa khung "
+            f"({native_capped} câu chạm trần x{native_speed_cap}, còn vượt khung; "
+            f"neo cứng SRT - không cộng dồn lệch), {skipped} bỏ qua"
+        )
+    else:
+        summary = (
+            f"Hoàn tất [{profile['slug']}] ({merge_mode}): {generated} cue mới, "
+            f"{overflow_count} tràn, {pushed_count} đẩy, {speed_fitted_count} tăng tốc nhẹ, "
+            f"{speed_skipped_count} giữ giọng, {skipped} bỏ qua"
+        )
+    for line in (
+        summary,
+        f"Output: {output_dir}",
+        f"Manifest: {manifest}",
+        f"Shifted SRT: {shifted_srt}",
+    ):
+        _pipe_log(log_lines, line, on_log)
+
+    if merge:
+        if progress is not None:
+            progress(0.95, desc="Đang ghép file WAV")
+        _pipe_log(log_lines, "Đang ghép file WAV...", on_log)
+        if merge_mode in ("cascade", "native"):
+            merged = merge_timeline_cascade(
+                placements, segments, model.sampling_rate
+            )
+        elif merge_mode == "fit":
+            merged = merge_timeline_fit(
+                placements, fitted_segments or segments, model.sampling_rate
+            )
+        else:
+            merged = merge_timeline_strict(cues, segments, model.sampling_rate)
+        merge_out = (
+            Path(merge_output)
+            if merge_output
+            else output_dir / f"{srt_path.stem}_merged.wav"
+        )
+        merge_out.parent.mkdir(parents=True, exist_ok=True)
+        sf.write(merge_out, merged, model.sampling_rate)
+        merged_path = merge_out
+        _pipe_log(log_lines, f"Merged WAV: {merge_out}", on_log)
+
+    if progress is not None:
+        progress(1.0, desc="Hoàn tất")
+
+    return {
+        "output_dir": str(output_dir),
+        "manifest": str(manifest),
+        "shifted_srt": str(shifted_srt),
+        "merged_wav": str(merged_path) if merged_path else None,
+        "sample_rate": model.sampling_rate,
+        "stats": {
+            "generated": generated,
+            "overflow": overflow_count,
+            "pushed": pushed_count,
+            "speed_fitted": speed_fitted_count,
+            "speed_skipped": speed_skipped_count,
+            "skipped": skipped,
+        },
+        "log": "\n".join(log_lines),
+    }
+
+
+def cmd_srt(args: argparse.Namespace) -> None:
+    result = run_srt_pipeline(
+        Path(args.profile),
+        Path(args.input),
+        output_dir=Path(args.output_dir) if args.output_dir else None,
+        merge=args.merge,
+        merge_output=Path(args.output) if args.output else None,
+        merge_mode=args.merge_mode,
+        speed_mode=args.speed_mode,
+        gentle_threshold=args.gentle_threshold,
+        max_speed_factor=args.max_speed_factor,
+        native_speed_cap=args.native_speed_cap,
+        num_step=args.num_step,
+        class_temperature=args.class_temperature,
+        guidance_scale=args.guidance_scale,
+        skip_existing=args.skip_existing,
+        from_cue=args.from_cue,
+        to_cue=args.to_cue,
+    )
+    print(result["log"])
+
+
+def get_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Đọc văn bản/SRT bằng voice profile trong voices/",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument(
+        "--profile",
+        type=str,
+        default=str(DEFAULT_PROFILE),
+        help="Đường dẫn profile.json",
+    )
+    parser.add_argument(
+        "--num-step",
+        type=int,
+        default=32,
+        help="Số bước diffusion (16 = nhanh hơn, 32 = chất lượng cao hơn)",
+    )
+    parser.add_argument(
+        "--class-temperature",
+        type=float,
+        default=DEFAULT_CLASS_TEMPERATURE,
+        help="Độ biểu cảm: nhiệt độ lấy mẫu token. 0 = đều/máy móc (greedy), "
+        "0.7-0.9 = nhấn nhá tự nhiên, >1.0 = ngẫu hứng mạnh hơn",
+    )
+    parser.add_argument(
+        "--guidance-scale",
+        type=float,
+        default=DEFAULT_GUIDANCE_SCALE,
+        help="Mức bám giọng mẫu (CFG). Cao hơn = rõ/chắc giọng, thấp hơn = mềm hơn",
+    )
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_voices = sub.add_parser("voices", help="Liệt kê các giọng có sẵn")
+    p_voices.set_defaults(func=cmd_voices)
+
+    p_build = sub.add_parser("build", help="Tạo file voice.pt từ audio mẫu")
+    p_build.set_defaults(func=cmd_build)
+
+    p_text = sub.add_parser("text", help="Đọc một đoạn văn bản")
+    p_text.add_argument("--text", required=True)
+    p_text.add_argument("-o", "--output", required=True)
+    p_text.set_defaults(func=cmd_text)
+
+    p_file = sub.add_parser("file", help="Đọc cả file .txt")
+    p_file.add_argument("--input", required=True)
+    p_file.add_argument("-o", "--output", required=True)
+    p_file.set_defaults(func=cmd_file)
+
+    p_srt = sub.add_parser("srt", help="Đọc file phụ đề .srt")
+    p_srt.add_argument("--input", required=True)
+    p_srt.add_argument(
+        "--output-dir",
+        type=str,
+        default=None,
+        help="Thư mục lưu từng cue. Mặc định: output/<voice>/<ten_srt>/",
+    )
+    p_srt.add_argument(
+        "-o",
+        "--output",
+        type=str,
+        default=None,
+        help="File WAV gộp khi dùng --merge",
+    )
+    p_srt.add_argument(
+        "--merge",
+        action="store_true",
+        help="Gộp các cue thành 1 file WAV",
+    )
+    p_srt.add_argument(
+        "--merge-mode",
+        choices=["native", "fit", "cascade", "strict"],
+        default="native",
+        help="native: model nói nhanh native (giữ nhấn nhá) có trần tốc độ, "
+        "phần dư tràn nhẹ/cascade - khuyến nghị cho lồng tiếng; "
+        "fit: sinh dài rồi kéo nén tín hiệu vừa khung SRT (khít giờ, dễ mất nhấn nhá); "
+        "cascade: cue dài tràn/đẩy cue sau (giữ chất giọng, lệch SRT); "
+        "strict: ghép theo timestamp gốc (có thể cắt audio)",
+    )
+    p_srt.add_argument(
+        "--speed-mode",
+        choices=["off", "gentle", "force"],
+        default="off",
+        help="off: giữ giọng, tràn cascade (mặc định); "
+        "gentle: chỉ tăng tốc nhẹ khi hơn slot <= gentle-threshold; "
+        "force: ép vừa slot (có thể méo giọng)",
+    )
+    p_srt.add_argument(
+        "--gentle-threshold",
+        type=float,
+        default=1.08,
+        help="Với gentle: chỉ tăng tốc nếu cần <= hệ số này (vd. 1.08 = 8%%)",
+    )
+    p_srt.add_argument(
+        "--max-speed-factor",
+        type=float,
+        default=1.6,
+        help="Với fit: trần tăng tốc 1 câu để giữ giọng tự nhiên (vd. 1.6 = 60%%). "
+        "Câu cần hơn trần sẽ tràn nhẹ và tự khớp lại sau",
+    )
+    p_srt.add_argument(
+        "--native-speed-cap",
+        type=float,
+        default=2.0,
+        help="Với native: trần tốc độ nói native để chứa hết chữ trong khung "
+        "(vd. 2.0 = nói nhanh tối đa gấp đôi). Cao hơn = chắc chắn đủ chữ nhưng "
+        "câu dài nói nhanh hơn; thấp hơn = giữ nhấn nhá nhưng câu rất dài có thể "
+        "vẫn vượt khung",
+    )
+    p_srt.add_argument(
+        "--skip-existing",
+        action="store_true",
+        help="Bỏ qua cue đã có file WAV (tiếp tục job dở)",
+    )
+    p_srt.add_argument("--from-cue", type=int, default=None, help="Cue bắt đầu")
+    p_srt.add_argument("--to-cue", type=int, default=None, help="Cue kết thúc")
+    p_srt.set_defaults(func=cmd_srt)
+
+    return parser
+
+
+def _force_utf8_stdio() -> None:
+    """Tránh UnicodeEncodeError khi in tiếng Việt trên console Windows (cp1252)."""
+    for stream in (sys.stdout, sys.stderr):
+        if stream is None:
+            continue
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is not None:
+            try:
+                reconfigure(encoding="utf-8", errors="replace")
+            except (ValueError, OSError, AttributeError):
+                pass
+
+
+class _SafeLogHandler(logging.StreamHandler):
+    """Handler log không crash khi console Windows không hỗ trợ Unicode."""
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            super().emit(record)
+        except UnicodeEncodeError:
+            record.msg = str(record.getMessage()).encode("ascii", errors="replace").decode("ascii")
+            record.args = ()
+            super().emit(record)
+
+
+def _setup_logging() -> None:
+    _force_utf8_stdio()
+    root = logging.getLogger()
+    if root.handlers:
+        return
+    handler = _SafeLogHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    root.addHandler(handler)
+    root.setLevel(logging.INFO)
+
+
+def main() -> None:
+    _setup_logging()
+    parser = get_parser()
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()
+else:
+    _setup_logging()

voices/ban_mai/profile.json

@@ -0,0 +1,11 @@
+{
+  "name": "Ban Mai",
+  "language": "Vietnamese",
+  "ref_audio": "ref.mp3",
+  "ref_text_file": "ref_text.txt",
+  "voice_prompt": "voice.pt",
+  "model": "k2-fsa/OmniVoice",
+  "device": "cuda:0",
+  "preprocess_prompt": false,
+  "auto_transcribe": true
+}

voices/ban_mai/ref.mp3

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

voices/ban_mai/ref_text.txt

@@ -0,0 +1 @@
+Capybara, còn được gọi là chuột lang nước, được mệnh danh là Bộ trưởng Bộ Ngoại giao trong thế giới động vật vì tính cách hiền lành, thân thiện và khả năng hòa đồng. Chúng thường sống hòa bình với các loài động vật khác, kể cả những loài săn mồi, và được yêu thích bởi sự gần gũi, thân thiện với con người.

voices/ban_mai/ref_text_asr.txt

@@ -0,0 +1 @@
+Capybara, còn được gọi là chuột lang nước, được mệnh danh là Bộ trưởng Bộ Ngoại giao trong thế giới động vật vì tính cách hiền lành, thân thiện và khả năng hòa đồng. Chúng thường sống hòa bình với các loài động vật khác, kể cả những loài săn mồi, và được yêu thích bởi sự gần gũi, thân thiện với con người.

voices/ban_mai/voice.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35009a3ebca2fa59e7082177f4b8ab9ff8fa0cbcd44c952b03cfd2dfd9e2d139
+size 27547

voices/lan_trinh/profile.json

@@ -0,0 +1,11 @@
+{
+  "name": "Lan Trinh",
+  "language": "Vietnamese",
+  "ref_audio": "ref.wav",
+  "ref_text_file": "ref_text.txt",
+  "voice_prompt": "voice.pt",
+  "model": "k2-fsa/OmniVoice",
+  "device": "cuda:0",
+  "preprocess_prompt": false,
+  "auto_transcribe": false
+}

voices/lan_trinh/ref.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5369ba15dc222cd390d4d9f6db1253cd17ae3d9c60d3e5068484c1d4aba6af4b
+size 2719822

voices/lan_trinh/ref_text.txt

@@ -0,0 +1 @@
+Tức chết được, tức chết được. Vì tên và chuyên ngành y hệt nên mình mới đọc cuốn tiểu thuyết này. Nhân vật này đúng là làm mất mặt sinh viên ngành y. Yêu đương mù quáng, tỉnh lại đi. Bạch Khê à, Cố Thanh Diên là bạn học của con, vậy mối hôn sự này mẹ cả quyết định cho con

voices/lan_trinh/voice.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1979379e5b32997011db6078f9f6cc22195db7c81bba92d5d777896086de481c
+size 26587

voices/ngan_ha/profile.json

@@ -0,0 +1,11 @@
+{
+  "name": "Ngân Hà",
+  "language": "Vietnamese",
+  "ref_audio": "ref.wav",
+  "ref_text_file": "ref_text.txt",
+  "voice_prompt": "voice.pt",
+  "model": "k2-fsa/OmniVoice",
+  "device": "cuda:0",
+  "preprocess_prompt": false,
+  "auto_transcribe": false
+}

voices/ngan_ha/ref.wav

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

voices/ngan_ha/ref_text.txt

@@ -0,0 +1 @@
+Tên hôn quân vô sĩ kia, sao dám nhìn lén bổn hậu tắm rữa! Chẳng phải ta đang ở biên cảnh làm nhiệm vụ bí mật sao? Chỉ chợp mắt một lát sao lại biến thành nông nổi này? Ta vậy mà lại xuyên không thành hoàng đế Đại Chu! Tên Hoàng Đế này chỉ là bù nhìn

voices/ngan_ha/voice.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:311b4f4c42c19e466eb0592c5cd40ac6edee5e710caef699763accd85bd52f87
+size 24347

voices/ngoc_huyen/profile.json

@@ -0,0 +1,9 @@
+{
+  "name": "Ngoc Huyen",
+  "language": "Vietnamese",
+  "ref_audio": "ref.mp3",
+  "ref_text_file": "ref_text.txt",
+  "voice_prompt": "voice.pt",
+  "model": "k2-fsa/OmniVoice",
+  "device": "cuda:0"
+}

voices/ngoc_huyen/ref.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8a4628b205482f448499847bae3c2697a3f3c97be97b27e470cf670db3ff4e57
+size 254162

voices/ngoc_huyen/ref_text.txt

@@ -0,0 +1 @@
+Capybara, còn được gọi là chuột lang nước, được mệnh danh là "bộ trưởng bộ ngoại giao" trong thế giới động vật vì tính cách hiền lành, thân thiện và khả năng hòa đồng. Chúng thường sống hòa bình với các loài động vật khác, kể cả những loài săn mồi, và được yêu thích bởi sự gần gũi, thân thiện với con người.

voices/ngoc_huyen/voice.pt

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

voices/thao_trinh/profile.json

@@ -0,0 +1,11 @@
+{
+  "name": "Thảo Trinh",
+  "language": "Vietnamese",
+  "ref_audio": "ref.wav",
+  "ref_text_file": "ref_text.txt",
+  "voice_prompt": "voice.pt",
+  "model": "k2-fsa/OmniVoice",
+  "device": "cuda:0",
+  "preprocess_prompt": false,
+  "auto_transcribe": false
+}

voices/thao_trinh/ref.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53c73596dbcf9edea22bee79485cc14bcc8c22764ee4a35be17436f8b3dc5b0f
+size 2670670

voices/thao_trinh/ref_text.txt

@@ -0,0 +1 @@
+Liên quan gì đến ngươi và Viện Thanh Sơn của ngươi, Gia Cát Nguyệt! Từ nay, chúng ta không còn tình nghĩa, chỉ như người lạ. Yến Trung cho rằng mọi việc đều do Viện Thanh Sơn làm, hoàn toàn trở mặt với ta. Tinh Nhi gây dựng lại quân Tú Lệ, trợ giúp Yến Trung chạy về Yến Bắc.

voices/thao_trinh/voice.pt

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

voices/tuong_vy/profile.json

@@ -0,0 +1,11 @@
+{
+  "name": "Tường Vy",
+  "language": "Vietnamese",
+  "ref_audio": "ref.wav",
+  "ref_text_file": "ref_text.txt",
+  "voice_prompt": "voice.pt",
+  "model": "k2-fsa/OmniVoice",
+  "device": "cuda:0",
+  "preprocess_prompt": false,
+  "auto_transcribe": false
+}

voices/tuong_vy/ref.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f4c2d8e0fadb33d3dce0e46bbaa58303676cb56b83b1c3761b8d41fd053ad7f
+size 372164

voices/tuong_vy/ref_text.txt

@@ -0,0 +1 @@
+Mau mau xem mau. Nghe nói Thất công chúa đến đây để hủy hôn với thế tử, Trấn Bắc Vương. Không phải chứ? Cha hắn, Trấn Bắc Vương chẳng phải mới tử trận nơi biên cương sao? Nghe nói tên đó ngoài việc lêu lổng thanh lâu thì chẳng biết làm gì. Nếu là ta thì ta cũng hủy hôn

voices/tuong_vy/voice.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e3bec906d12cf9d1012e8e8bd749f36056989ef868bb50f8b292f4520dba1bf
+size 22747