Upload 11 files

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+output_audio/

.python-version

@@ -0,0 +1 @@
+3.12

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,13 +1,81 @@
----
-title: FSub
-emoji: 📊
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 6.1.0
-app_file: app.py
-pinned: false
-short_description: My TTS
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎙️ VieNeu-TTS API Server
+
+**Vietnamese Text-to-Speech API với 10 giọng nói tự nhiên**
+
+## 🚀 Quick Start
+
+### 1. Khởi động Server
+```bash
+start_server.bat
+```
+
+### 2. Test API
+```bash
+curl -X POST "http://127.0.0.1:8000/fast-tts" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "text": "Xin chào, tôi là VieNeu-TTS",
+    "voice_choice": "Tuyên (nam miền Bắc)",
+    "return_base64": true
+  }'
+```
+
+### 3. Sử dụng trong Python
+```python
+import requests
+import base64
+
+# Gửi request
+response = requests.post("http://127.0.0.1:8000/fast-tts", json={
+    "text": "Xin chào từ VieNeu-TTS",
+    "voice_choice": "Ngọc (nữ miền Bắc)",
+    "return_base64": True
+})
+
+# Lưu audio
+if response.status_code == 200:
+    result = response.json()
+    audio_bytes = base64.b64decode(result["audio_base64"])
+    with open("output.wav", "wb") as f:
+        f.write(audio_bytes)
+```
+
+## 📡 API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/fast-tts` | POST | **TTS nhanh** (recommended) |
+| `/tts` | POST | TTS standard |
+| `/bulk-tts` | POST | Xử lý batch (max 50) |
+| `/voices` | GET | Danh sách giọng nói |
+| `/health` | GET | Health check |
+| `/docs` | GET | **API Documentation** |
+
+## 🎭 Giọng nói có sẵn
+
+- **Nam miền Bắc**: Tuyên, Bình
+- **Nam miền Nam**: Vĩnh, Nguyên, Sơn  
+- **Nữ miền Bắc**: Ngọc, Ly
+- **Nữ miền Nam**: Đoan, Dung
+- **Đặc biệt**: Nhỏ Ngọt Ngào
+
+## 🔧 Cấu hình
+
+- **Server**: http://127.0.0.1:8000
+- **GUI**: Tích hợp sẵn khi chạy server
+- **Performance**: Có thể điều chỉnh từ giao diện
+- **Cache**: Tự động cache giọng nói
+
+## 📚 Tài liệu đầy đủ
+
+Xem [API_DOCUMENTATION.md](API_DOCUMENTATION.md) để biết chi tiết.
+
+## 💡 Tips
+
+1. **Dùng `/fast-tts`** thay vì `/tts`
+2. **Set `return_base64=true`** để tránh file I/O
+3. **Cache kết quả** theo text + voice + speed
+4. **Dùng cùng giọng** cho requests liên tiếp
+
+
+**🚀 Bắt đầu ngay với `start_server.bat`!**

gradio_app.py

@@ -0,0 +1,446 @@
+import gradio as gr
+import soundfile as sf
+import tempfile
+import torch
+from vieneu_tts import VieNeuTTS
+import os
+import time
+import threading
+import pickle
+import hashlib
+import numpy as np
+from pydub import AudioSegment
+
+print("🎚️ Speed Control: Sử dụng Pydub (đơn giản, sạch, không vang)")
+
+print("⏳ Đang khởi động VieNeu-TTS...")
+
+# --- 1. SETUP MODEL ---
+print("📦 Đang tải model...")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"🖥️ Sử dụng thiết bị: {device.upper()}")
+
+# Cache cho reference codes
+CACHE_DIR = "./reference_cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+reference_cache = {}
+reference_cache_lock = threading.Lock()
+
+def get_cache_path(cache_key):
+    """Tạo đường dẫn file cache từ key"""
+    # Hash key để tạo tên file an toàn
+    key_hash = hashlib.md5(cache_key.encode()).hexdigest()
+    return os.path.join(CACHE_DIR, f"{key_hash}.pkl")
+
+def load_cache_from_disk(cache_key):
+    """Load cache từ disk nếu có"""
+    cache_path = get_cache_path(cache_key)
+    if os.path.exists(cache_path):
+        try:
+            with open(cache_path, 'rb') as f:
+                return pickle.load(f)
+        except:
+            return None
+    return None
+
+def save_cache_to_disk(cache_key, ref_codes):
+    """Lưu cache xuống disk"""
+    cache_path = get_cache_path(cache_key)
+    try:
+        with open(cache_path, 'wb') as f:
+            pickle.dump(ref_codes, f)
+        # Lưu metadata để dễ debug
+        meta_path = cache_path.replace('.pkl', '.txt')
+        with open(meta_path, 'w', encoding='utf-8') as f:
+            f.write(f"Cache key: {cache_key}\n")
+            f.write(f"Created: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+    except Exception as e:
+        print(f"   ⚠️ Không thể lưu cache: {e}")
+
+try:
+    tts = VieNeuTTS(
+        backbone_repo="pnnbao-ump/VieNeu-TTS",
+        backbone_device=device,
+        codec_repo="neuphonic/neucodec",
+        codec_device=device
+    )
+    print("✅ Model đã tải xong!")
+    
+    # Kiểm tra device thực tế
+    if hasattr(tts, 'backbone'):
+        if hasattr(tts.backbone, 'device'):
+            print(f"   📍 Backbone device: {tts.backbone.device}")
+        else:
+            # For transformers model
+            print(f"   📍 Backbone device: {next(tts.backbone.parameters()).device}")
+    
+    if hasattr(tts, 'codec'):
+        if hasattr(tts.codec, 'device'):
+            print(f"   📍 Codec device: {tts.codec.device}")
+        else:
+            print(f"   📍 Codec device: {next(tts.codec.parameters()).device}")
+    
+    print(f"   💾 GPU Memory allocated: {torch.cuda.memory_allocated(0) / 1024**3:.2f} GB" if torch.cuda.is_available() else "")
+    
+except Exception as e:
+    print(f"⚠️ Không thể tải model (Chế độ UI Demo): {e}")
+    class MockTTS:
+        def encode_reference(self, path): return None
+        def infer(self, text, ref, ref_text): 
+            import numpy as np
+            # Giả lập độ trễ để test tính năng đo thời gian
+            time.sleep(1.5) 
+            return np.random.uniform(-0.5, 0.5, 24000*3)
+    tts = MockTTS()
+
+# --- 2. DATA ---
+VOICE_SAMPLES = {
+    "Tuyên (nam miền Bắc)": {"audio": "./sample/Tuyên (nam miền Bắc).wav", "text": "./sample/Tuyên (nam miền Bắc).txt"},
+    "Vĩnh (nam miền Nam)": {"audio": "./sample/Vĩnh (nam miền Nam).wav", "text": "./sample/Vĩnh (nam miền Nam).txt"},
+    "Bình (nam miền Bắc)": {"audio": "./sample/Bình (nam miền Bắc).wav", "text": "./sample/Bình (nam miền Bắc).txt"},
+    "Nguyên (nam miền Nam)": {"audio": "./sample/Nguyên (nam miền Nam).wav", "text": "./sample/Nguyên (nam miền Nam).txt"},
+    "Sơn (nam miền Nam)": {"audio": "./sample/Sơn (nam miền Nam).wav", "text": "./sample/Sơn (nam miền Nam).txt"},
+    "Đoan (nữ miền Nam)": {"audio": "./sample/Đoan (nữ miền Nam).wav", "text": "./sample/Đoan (nữ miền Nam).txt"},
+    "Ngọc (nữ miền Bắc)": {"audio": "./sample/Ngọc (nữ miền Bắc).wav", "text": "./sample/Ngọc (nữ miền Bắc).txt"},
+    "Ly (nữ miền Bắc)": {"audio": "./sample/Ly (nữ miền Bắc).wav", "text": "./sample/Ly (nữ miền Bắc).txt"},
+    "Dung (nữ miền Nam)": {"audio": "./sample/Dung (nữ miền Nam).wav", "text": "./sample/Dung (nữ miền Nam).txt"},
+    "Nhỏ Ngọt Ngào": {"audio": "./sample/Nhỏ Ngọt Ngào.wav", "text": "./sample/Nhỏ Ngọt Ngào.txt"},
+    
+    # Thêm giọng mới ở đây:
+    # "Tên Giọng": {"audio": "./sample/Tên_Giọng.wav", "text": "./sample/Tên_Giọng.txt"},
+}
+
+# --- 3. HELPER FUNCTIONS ---
+def load_reference_info(voice_choice):
+    if voice_choice in VOICE_SAMPLES:
+        audio_path = VOICE_SAMPLES[voice_choice]["audio"]
+        text_path = VOICE_SAMPLES[voice_choice]["text"]
+        try:
+            if os.path.exists(text_path):
+                with open(text_path, "r", encoding="utf-8") as f:
+                    ref_text = f.read()
+                return audio_path, ref_text
+            else:
+                return audio_path, "⚠️ Không tìm thấy file text mẫu."
+        except Exception as e:
+            return None, f"❌ Lỗi: {str(e)}"
+    return None, ""
+
+def synthesize_speech(text, voice_choice, custom_audio, custom_text, mode_tab, speed_factor):
+    try:
+        if not text or text.strip() == "":
+            return None, "⚠️ Vui lòng nhập văn bản cần tổng hợp!"
+        
+        # --- LOGIC CHECK LIMIT 250 ---
+        if len(text) > 250:
+            return None, f"❌ Văn bản quá dài ({len(text)}/250 ký tự)! Vui lòng cắt ngắn lại để đảm bảo chất lượng."
+
+        # Logic chọn Reference
+        if mode_tab == "custom_mode": 
+            if custom_audio is None or not custom_text:
+                return None, "⚠️ Vui lòng tải lên Audio và nhập nội dung Audio đó."
+            ref_audio_path = custom_audio
+            ref_text_raw = custom_text
+            print("🎨 Mode: Custom Voice")
+        else: # Preset
+            if voice_choice not in VOICE_SAMPLES:
+                 return None, "⚠️ Vui lòng chọn một giọng mẫu."
+            ref_audio_path = VOICE_SAMPLES[voice_choice]["audio"]
+            ref_text_path = VOICE_SAMPLES[voice_choice]["text"]
+            
+            if not os.path.exists(ref_audio_path):
+                 return None, f"❌ Không tìm thấy file audio: {ref_audio_path}"
+                 
+            with open(ref_text_path, "r", encoding="utf-8") as f:
+                ref_text_raw = f.read()
+            print(f"🎤 Mode: Preset Voice ({voice_choice})")
+
+        # Inference & Đo thời gian
+        print(f"📝 Text: {text[:50]}...")
+        
+        start_time = time.time()
+        
+        # Encode reference (with thread-safe cache + disk cache)
+        t1 = time.time()
+        cache_key = f"{mode_tab}:{voice_choice}" if mode_tab == "preset_mode" else ref_audio_path
+        
+        with reference_cache_lock:
+            # Check memory cache first
+            if cache_key in reference_cache:
+                print(f"   ✨ Using memory cache for {cache_key}")
+                ref_codes = reference_cache[cache_key]
+            else:
+                # Check disk cache
+                ref_codes = load_cache_from_disk(cache_key)
+                if ref_codes is not None:
+                    print(f"   💿 Loaded from disk cache for {cache_key}")
+                    reference_cache[cache_key] = ref_codes
+                else:
+                    # Encode mới
+                    print(f"   🔄 Encoding reference (first time for {cache_key})...")
+                    ref_codes = tts.encode_reference(ref_audio_path)
+                    reference_cache[cache_key] = ref_codes
+                    save_cache_to_disk(cache_key, ref_codes)
+                    print(f"   💾 Saved to disk cache for {cache_key}")
+        
+        t2 = time.time()
+        print(f"   ⏱️ Encode reference: {t2-t1:.2f}s")
+        
+        # Inference
+        t3 = time.time()
+        wav = tts.infer(text, ref_codes, ref_text_raw)
+        t4 = time.time()
+        print(f"   ⏱️ Inference: {t4-t3:.2f}s")
+        
+        # Apply speed adjustment if needed (using Pydub - simple & clean)
+        if speed_factor != 1.0:
+            t5 = time.time()
+            print(f"   🎚️ Applying speed adjustment: {speed_factor}x")
+            print(f"   🔧 Using Pydub (simple & clean)")
+            
+            # Pydub method - thay đổi frame rate
+            with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+                sf.write(tmp.name, wav, 24000)
+                tmp_path = tmp.name
+            
+            sound = AudioSegment.from_wav(tmp_path)
+            new_frame_rate = int(sound.frame_rate * speed_factor)
+            sound_stretched = sound._spawn(sound.raw_data, overrides={'frame_rate': new_frame_rate})
+            sound_stretched = sound_stretched.set_frame_rate(24000)
+            
+            wav = np.array(sound_stretched.get_array_of_samples()).astype(np.float32) / 32768.0
+            if sound_stretched.channels == 2:
+                wav = wav.reshape((-1, 2)).mean(axis=1)
+            
+            os.unlink(tmp_path)
+            
+            t6 = time.time()
+            print(f"   ⏱️ Speed adjustment: {t6-t5:.2f}s")
+        
+        end_time = time.time()   # <--- Kết thúc bấm giờ
+        process_time = end_time - start_time # <--- Tính thời gian xử lý
+        
+        # Save
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+            sf.write(tmp_file.name, wav, 24000)
+            output_path = tmp_file.name
+        
+        # <--- Cập nhật thông báo kết quả
+        speed_info = f" (Speed: {speed_factor}x)" if speed_factor != 1.0 else ""
+        return output_path, f"✅ Thành công! (Mất {process_time:.2f} giây để tạo){speed_info}"
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return None, f"❌ Lỗi hệ thống: {str(e)}"
+
+# --- 4. UI SETUP ---
+theme = gr.themes.Ocean(
+    primary_hue="indigo",
+    secondary_hue="cyan",
+    neutral_hue="slate",
+    font=[gr.themes.GoogleFont('Inter'), 'ui-sans-serif', 'system-ui'],
+).set(
+    button_primary_background_fill="linear-gradient(90deg, #6366f1 0%, #0ea5e9 100%)",
+    button_primary_background_fill_hover="linear-gradient(90deg, #4f46e5 0%, #0284c7 100%)",
+    block_shadow="0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06)",
+)
+
+# <--- CSS ĐÃ SỬA (Background xanh đen + Chữ sáng)
+css = """
+.container { max-width: 1200px; margin: auto; }
+.header-box { 
+    text-align: center; 
+    margin-bottom: 25px; 
+    padding: 25px; 
+    background: linear-gradient(135deg, #0f172a 0%, #1e293b 100%); /* Xanh đen (Slate 900 -> 800) */
+    border-radius: 12px; 
+    border: 1px solid #334155; 
+    box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.3);
+}
+.header-title { 
+    font-size: 2.5rem; 
+    font-weight: 800; 
+    color: white; /* Chữ trắng */
+    background: -webkit-linear-gradient(45deg, #60A5FA, #22D3EE); /* Gradient xanh sáng cho chữ nổi bật */
+    -webkit-background-clip: text; 
+    -webkit-text-fill-color: transparent; 
+    margin-bottom: 10px; 
+}
+.header-desc {
+    font-size: 1.1rem; 
+    color: #cbd5e1; /* Màu xám sáng (Slate-300) */
+    margin-bottom: 15px;
+}
+.link-group a { 
+    text-decoration: none; 
+    margin: 0 10px; 
+    font-weight: 600; 
+    color: #94a3b8; /* Màu link sáng hơn chút */
+    transition: color 0.2s; 
+}
+.link-group a:hover { color: #38bdf8; text-shadow: 0 0 5px rgba(56, 189, 248, 0.5); }
+
+.status-box { font-weight: bold; text-align: center; border: none; background: transparent; }
+.warning-note { 
+    background-color: #fff7ed; 
+    border-left: 4px solid #f97316; 
+    padding: 12px; 
+    color: #9a3412; 
+    font-size: 0.9rem; 
+    border-radius: 4px;
+    margin-top: 10px;
+    margin-bottom: 10px;
+}
+"""
+
+EXAMPLES_LIST = [
+    # Nam Miền Nam
+    ["Về miền Tây không chỉ để ngắm nhìn sông nước hữu tình, mà còn để cảm nhận tấm chân tình của người dân nơi đây. Cùng ngồi xuồng ba lá len lỏi qua rặng dừa nước, nghe câu vọng cổ ngọt ngào thì còn gì bằng.", "Vĩnh (nam miền Nam)"],
+    
+    # Nam Miền Bắc
+    ["Hà Nội những ngày vào thu mang một vẻ đẹp trầm mặc và cổ kính đến lạ thường. Đi dạo quanh Hồ Gươm vào sáng sớm, hít hà mùi hoa sữa nồng nàn và thưởng thức chút cốm làng Vòng là trải nghiệm khó quên.", "Bình (nam miền Bắc)"],
+    
+    # Nam Miền Bắc
+    ["Sự bùng nổ của trí tuệ nhân tạo đang định hình lại cách chúng ta làm việc và sinh sống. Từ xe tự lái đến trợ lý ảo thông minh, công nghệ đang dần xóa nhòa ranh giới giữa thực tại và những bộ phim viễn tưởng.", "Tuyên (nam miền Bắc)"],
+    
+    # Nam Miền Nam
+    ["Sài Gòn hối hả là thế, nhưng chỉ cần tấp vào một quán cà phê ven đường, gọi ly bạc xỉu đá và ngắm nhìn dòng người qua lại, bạn sẽ thấy thành phố này cũng có những khoảng lặng thật bình yên và đáng yêu.", "Nguyên (nam miền Nam)"],
+    
+    # Nam Miền Nam
+    ["Để đảm bảo tiến độ dự án quan trọng này, chúng ta cần tập trung tối đa nguồn lực và phối hợp chặt chẽ giữa các phòng ban. Mọi khó khăn phát sinh cần được báo cáo ngay lập tức để ban lãnh đạo xử lý kịp thời.", "Sơn (nam miền Nam)"],
+
+    # Nữ Miền Nam
+    ["Ngày xửa ngày xưa, ở một ngôi làng nọ có cô Tấm xinh đẹp, nết na nhưng sớm mồ côi mẹ. Dù bị mẹ kế và Cám hãm hại đủ đường, Tấm vẫn giữ được tấm lòng lương thiện và cuối cùng tìm được hạnh phúc xứng đáng.", "Đoan (nữ miền Nam)"],
+    
+    # Nữ Miền Bắc
+    ["Dạ em chào anh chị, hiện tại bên em đang có chương trình ưu đãi đặc biệt cho căn hộ hướng sông này. Với thiết kế hiện đại và không gian xanh mát, đây chắc chắn là tổ ấm lý tưởng mà gia đình mình đang tìm kiếm.", "Ly (nữ miền Bắc)"],
+    
+    # Nữ Miền Bắc
+    ["Dưới cơn mưa phùn lất phất của những ngày cuối đông, em khẽ nép vào vai anh, cảm nhận hơi ấm lan tỏa. Những khoảnh khắc bình dị như thế này khiến em nhận ra r��ng, hạnh phúc đôi khi chỉ đơn giản là được ở bên nhau.", "Ngọc (nữ miền Bắc)"],
+]
+
+with gr.Blocks(theme=theme, css=css, title="VieNeu-TTS Studio") as demo:
+    
+    with gr.Column(elem_classes="container"):
+        # Header - Cập nhật class cho HTML
+        gr.HTML("""
+            <div class="header-box">
+                <div class="header-title">🎙️ VieNeu-TTS Studio</div>
+                <div class="header-desc">
+                    Phiên bản: VieNeu-TTS-1000h (model mới nhất, train trên 1000 giờ dữ liệu)
+                </div>
+                <div class="link-group">
+                    <a href="https://huggingface.co/pnnbao-ump/VieNeu-TTS" target="_blank">🤗 Model Card</a> • 
+                    <a href="https://huggingface.co/datasets/pnnbao-ump/VieNeu-TTS-1000h" target="_blank">📖 Dataset 1000h</a> • 
+                    <a href="https://github.com/pnnbao97/VieNeu-TTS" target="_blank">🦜 GitHub</a>
+                </div>
+            </div>
+        """)
+    
+    with gr.Row(elem_classes="container", equal_height=False):
+        
+        # --- LEFT: INPUT ---
+        with gr.Column(scale=3, variant="panel"):
+            gr.Markdown("### 📝 Văn bản đầu vào")
+            text_input = gr.Textbox(
+                label="Nhập văn bản",
+                placeholder="Nhập nội dung tiếng Việt cần chuyển thành giọng nói...",
+                lines=4,
+                value="Sự bùng nổ của trí tuệ nhân tạo đang định hình lại cách chúng ta làm việc và sinh sống. Từ xe tự lái đến trợ lý ảo thông minh, công nghệ đang dần xóa nhòa ranh giới giữa thực tại và những bộ phim viễn tưởng.",
+                show_label=False
+            )
+            
+            # Counter + Warning
+            with gr.Row():
+                char_count = gr.HTML("<div style='text-align: right; color: #64748B; font-size: 0.8rem;'>0 / 250 ký tự</div>")
+            
+            gr.Markdown("### 🗣️ Chọn giọng đọc")
+            with gr.Tabs() as tabs:
+                with gr.TabItem("👤 Giọng có sẵn (Preset)", id="preset_mode"):
+                    voice_select = gr.Dropdown(
+                        choices=list(VOICE_SAMPLES.keys()),
+                        value="Tuyên (nam miền Bắc)",
+                        label="Danh sách giọng",
+                        interactive=True
+                    )
+                    with gr.Accordion("Thông tin giọng mẫu", open=False):
+                        ref_audio_preview = gr.Audio(label="Audio mẫu", interactive=False, type="filepath")
+                        ref_text_preview = gr.Markdown("...")
+
+                with gr.TabItem("🎙️ Giọng tùy chỉnh (Custom)", id="custom_mode"):
+                    gr.Markdown("Tải lên giọng của bạn (Zero-shot Cloning)")
+                    custom_audio = gr.Audio(label="File ghi âm (.wav)", type="filepath")
+                    custom_text = gr.Textbox(label="Nội dung ghi âm", placeholder="Nhập chính xác lời thoại...")
+
+            current_mode = gr.Textbox(visible=False, value="preset_mode")
+            
+            gr.Markdown("### ⚙️ Cài đặt nâng cao")
+            speed_slider = gr.Slider(
+                minimum=0.5,
+                maximum=2.0,
+                value=1.0,
+                step=0.1,
+                label="Tốc độ giọng nói (Speed)",
+                info="0.5x = chậm, 1.0x = bình thường, 2.0x = nhanh"
+            )
+            
+            btn_generate = gr.Button("Tổng hợp giọng nói", variant="primary", size="lg")
+
+        # --- RIGHT: OUTPUT ---
+        with gr.Column(scale=2):
+            gr.Markdown("### 🎧 Kết quả")
+            with gr.Group():
+                audio_output = gr.Audio(label="Audio đầu ra", type="filepath", show_download_button=True, autoplay=True)
+                status_output = gr.Textbox(label="Trạng thái", show_label=False, elem_classes="status-box", placeholder="Sẵn sàng...")
+
+    # --- EXAMPLES ---
+    with gr.Row(elem_classes="container"):
+        with gr.Column():
+            gr.Markdown("### 📚 Ví dụ mẫu")
+            gr.Examples(examples=EXAMPLES_LIST, inputs=[text_input, voice_select], label="Thử nghiệm nhanh")
+
+    # --- LOGIC ---
+    def update_count(text):
+        l = len(text)
+        if l > 250:
+            color = "#dc2626" # Red
+            msg = f"⚠️ <b>{l} / 250</b> - Quá giới hạn!"
+        elif l > 200:
+            color = "#ea580c" # Orange
+            msg = f"{l} / 250"
+        else:
+            color = "#64748B" # Gray
+            msg = f"{l} / 250 ký tự"
+        return f"<div style='text-align: right; color: {color}; font-size: 0.8rem; font-weight: bold'>{msg}</div>"
+
+    text_input.change(update_count, text_input, char_count)
+
+    def update_ref_preview(voice):
+        audio, text = load_reference_info(voice)
+        return audio, f"> *\"{text}\"*"
+    
+    voice_select.change(update_ref_preview, voice_select, [ref_audio_preview, ref_text_preview])
+    demo.load(update_ref_preview, voice_select, [ref_audio_preview, ref_text_preview])
+
+    # Tab handling - FIXED WITH *ARGS
+    tab_preset = tabs.children[0]
+    tab_custom = tabs.children[1]
+    
+    # Dùng *args để nhận bất kỳ số lượng tham số nào (0 hoặc 1), tránh lỗi Warning
+    tab_preset.select(fn=lambda *args: "preset_mode", inputs=None, outputs=current_mode)
+    tab_custom.select(fn=lambda *args: "custom_mode", inputs=None, outputs=current_mode)
+
+    btn_generate.click(
+        fn=synthesize_speech,
+        inputs=[text_input, voice_select, custom_audio, custom_text, current_mode, speed_slider],
+        outputs=[audio_output, status_output]
+    )
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=20).launch(
+        server_name="127.0.0.1", 
+        server_port=7860, 
+        share=False
+    )

main.py

@@ -0,0 +1,75 @@
+from vieneu_tts import VieNeuTTS
+import soundfile as sf
+import torch
+import os
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+input_texts = [
+    "Các khóa học trực tuyến đang giúp học sinh tiếp cận kiến thức mọi lúc mọi nơi. Giáo viên sử dụng video, bài tập tương tác và thảo luận trực tuyến để nâng cao hiệu quả học tập.",
+
+    "Các nghiên cứu về bệnh Alzheimer cho thấy tác dụng tích cực của các bài tập trí não và chế độ dinh dưỡng lành mạnh, giúp giảm tốc độ suy giảm trí nhớ ở người cao tuổi.",
+
+    "Một tiểu thuyết trinh thám hiện đại dẫn dắt độc giả qua những tình tiết phức tạp, bí ẩn, kết hợp yếu tố tâm lý sâu sắc khiến người đọc luôn hồi hộp theo dõi diễn biến câu chuyện.",
+
+    "Các nhà khoa học nghiên cứu gen người phát hiện những đột biến mới liên quan đến bệnh di truyền. Điều này giúp nâng cao khả năng chẩn đoán và điều trị.",
+]
+
+output_dir = "./output_audio"
+os.makedirs(output_dir, exist_ok=True)
+
+def main(backbone="pnnbao-ump/VieNeu-TTS", codec="neuphonic/neucodec"):
+    """
+    In the sample directory, there are wav files and txt files with matching names.
+    These are pre-prepared reference files for testing with Vietnamese names:
+    - Bình (nam miền Bắc) - Male, North accent
+    - Tuyên (nam miền Bắc) - Male, North accent
+    - Nguyên (nam miền Nam) - Male, South accent
+    - Sơn (nam miền Nam) - Male, South accent
+    - Vĩnh (nam miền Nam) - Male, South accent
+    - Hương (nữ miền Bắc) - Female, North accent
+    - Ly (nữ miền Bắc) - Female, North accent
+    - Ngọc (nữ miền Bắc) - Female, North accent
+    - Đoan (nữ miền Nam) - Female, South accent
+    - Dung (nữ miền Nam) - Female, South accent
+    
+    Note: The model can clone any voice you provide (with corresponding text).
+    However, quality may not match the sample files. For best results, finetune
+    the model on your target voice. See finetune guide at:
+    https://github.com/pnnbao-ump/VieNeuTTS/blob/main/finetune.ipynb
+    """
+    # Male voice (South accent)
+    ref_audio_path = "./sample/Vĩnh (nam miền Nam).wav"
+    ref_text_path = "./sample/Vĩnh (nam miền Nam).txt"
+    
+    # Female voice (South accent) - uncomment to use
+    # ref_audio_path = "./sample/Đoan (nữ miền Nam).wav"
+    # ref_text_path = "./sample/Đoan (nữ miền Nam).txt"
+
+    ref_text_raw = open(ref_text_path, "r", encoding="utf-8").read()
+    
+    if not ref_audio_path or not ref_text_raw:
+        print("No reference audio or text provided.")
+        return None
+
+    # Initialize VieNeuTTS-1000h
+    tts = VieNeuTTS(
+        backbone_repo=backbone,
+        backbone_device=device,
+        codec_repo=codec,
+        codec_device=device
+    )
+
+    print("Encoding reference audio...")
+    ref_codes = tts.encode_reference(ref_audio_path)
+
+    # Generate speech for all input texts
+    for i, text in enumerate(input_texts, 1):
+        print(f"Generating audio {i}/{len(input_texts)}: {text[:50]}...")
+        wav = tts.infer(text, ref_codes, ref_text_raw)
+        output_path = os.path.join(output_dir, f"output_{i}.wav")
+        sf.write(output_path, wav, 24000)
+        print(f"✓ Saved to {output_path}")
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,28 @@
+[tool.uv]
+index-strategy = "unsafe-best-match"
+
+[[tool.uv.index]]
+name = "pytorch"
+url = "https://download.pytorch.org/whl/cu118"
+
+[project]
+name = "VieNeu-TTS"
+version = "0.1.0"
+description = "VieNeu-TTS - TTS for Vietnamese language"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "phonemizer>=3.3.0",
+    "torch",
+    "torchvision",
+    "torchaudio",
+    "huggingface-hub[cli]>=0.36.0",
+    "neucodec>=0.0.4",
+    "librosa>=0.11.0",
+    "gradio>=5.49.1",
+]
+
+[tool.uv.sources]
+torch = { index = "pytorch" }
+torchvision = { index = "pytorch" }
+torchaudio = { index = "pytorch" }

requirements.txt

@@ -0,0 +1,14 @@
+phonemizer>=3.3.0
+torch
+torchvision
+torchaudio
+gradio
+neucodec>=0.0.4
+librosa>=0.11.0
+fastapi
+uvicorn
+soundfile
+pydub
+aiohttp
+aiofiles
+pygame

server_manager.py

@@ -0,0 +1,468 @@
+"""
+TTS Server Manager - Giao diện quản lý server với điều chỉnh thông số real-time
+"""
+import tkinter as tk
+from tkinter import ttk, messagebox
+import requests
+import threading
+import time
+import json
+from datetime import datetime
+import subprocess
+import os
+import signal
+
+class ServerManager:
+    def __init__(self, root):
+        self.root = root
+        self.root.title("VieNeu-TTS Server Manager")
+        self.root.geometry("800x600")
+        
+        # Server config
+        self.server_url = "http://127.0.0.1:8000"
+        self.server_process = None
+        
+        # Current settings
+        self.current_settings = {
+            "gpu_semaphore": 2,
+            "cpu_semaphore": 4,
+            "io_semaphore": 6,
+            "thread_pool": 6
+        }
+        
+        self.setup_ui()
+        self.start_monitoring()
+        
+    def setup_ui(self):
+        # Main notebook
+        notebook = ttk.Notebook(self.root)
+        notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        
+        # Server Control Tab
+        self.setup_server_tab(notebook)
+        
+        # Settings Tab
+        self.setup_settings_tab(notebook)
+        
+        # Monitor Tab
+        self.setup_monitor_tab(notebook)
+        
+    def setup_server_tab(self, notebook):
+        """Tab điều khiển server"""
+        server_frame = ttk.Frame(notebook)
+        notebook.add(server_frame, text="Server Control")
+        
+        # Server status
+        status_frame = ttk.LabelFrame(server_frame, text="Server Status", padding="10")
+        status_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        self.status_label = ttk.Label(status_frame, text="Checking server...", font=("Arial", 12))
+        self.status_label.pack()
+        
+        # Server controls
+        control_frame = ttk.LabelFrame(server_frame, text="Server Controls", padding="10")
+        control_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        button_frame = ttk.Frame(control_frame)
+        button_frame.pack()
+        
+        self.start_btn = ttk.Button(button_frame, text="Start Server", command=self.start_server)
+        self.start_btn.pack(side=tk.LEFT, padx=(0, 10))
+        
+        self.stop_btn = ttk.Button(button_frame, text="Stop Server", command=self.stop_server, state="disabled")
+        self.stop_btn.pack(side=tk.LEFT, padx=(0, 10))
+        
+        self.restart_btn = ttk.Button(button_frame, text="Restart Server", command=self.restart_server)
+        self.restart_btn.pack(side=tk.LEFT)
+        
+        # Quick actions
+        quick_frame = ttk.LabelFrame(server_frame, text="Quick Actions", padding="10")
+        quick_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        ttk.Button(quick_frame, text="Open API Docs", command=self.open_api_docs).pack(side=tk.LEFT, padx=(0, 10))
+        ttk.Button(quick_frame, text="Test Server", command=self.test_server).pack(side=tk.LEFT, padx=(0, 10))
+        ttk.Button(quick_frame, text="Clear Cache", command=self.clear_cache).pack(side=tk.LEFT)
+        
+    def setup_settings_tab(self, notebook):
+        """Tab cài đặt async parameters"""
+        settings_frame = ttk.Frame(notebook)
+        notebook.add(settings_frame, text="Async Settings")
+        
+        # Current settings display
+        current_frame = ttk.LabelFrame(settings_frame, text="Current Settings", padding="10")
+        current_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        self.current_settings_text = tk.Text(current_frame, height=4, width=60, state="disabled")
+        self.current_settings_text.pack()
+        
+        # Settings controls
+        control_frame = ttk.LabelFrame(settings_frame, text="Adjust Settings", padding="10")
+        control_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        # GPU Semaphore
+        gpu_frame = ttk.Frame(control_frame)
+        gpu_frame.pack(fill=tk.X, pady=(0, 5))
+        ttk.Label(gpu_frame, text="GPU Semaphore (1-4):").pack(side=tk.LEFT)
+        self.gpu_var = tk.StringVar(value="2")
+        gpu_spin = ttk.Spinbox(gpu_frame, from_=1, to=4, width=10, textvariable=self.gpu_var)
+        gpu_spin.pack(side=tk.RIGHT)
+        
+        # CPU Semaphore
+        cpu_frame = ttk.Frame(control_frame)
+        cpu_frame.pack(fill=tk.X, pady=(0, 5))
+        ttk.Label(cpu_frame, text="CPU Semaphore (2-8):").pack(side=tk.LEFT)
+        self.cpu_var = tk.StringVar(value="4")
+        cpu_spin = ttk.Spinbox(cpu_frame, from_=2, to=8, width=10, textvariable=self.cpu_var)
+        cpu_spin.pack(side=tk.RIGHT)
+        
+        # I/O Semaphore
+        io_frame = ttk.Frame(control_frame)
+        io_frame.pack(fill=tk.X, pady=(0, 5))
+        ttk.Label(io_frame, text="I/O Semaphore (3-10):").pack(side=tk.LEFT)
+        self.io_var = tk.StringVar(value="6")
+        io_spin = ttk.Spinbox(io_frame, from_=3, to=10, width=10, textvariable=self.io_var)
+        io_spin.pack(side=tk.RIGHT)
+        
+        # Thread Pool
+        thread_frame = ttk.Frame(control_frame)
+        thread_frame.pack(fill=tk.X, pady=(0, 10))
+        ttk.Label(thread_frame, text="Thread Pool (2-12):").pack(side=tk.LEFT)
+        self.thread_var = tk.StringVar(value="6")
+        thread_spin = ttk.Spinbox(thread_frame, from_=2, to=12, width=10, textvariable=self.thread_var)
+        thread_spin.pack(side=tk.RIGHT)
+        
+        # Apply buttons
+        apply_frame = ttk.Frame(control_frame)
+        apply_frame.pack(fill=tk.X)
+        
+        ttk.Button(apply_frame, text="Apply Settings", command=self.apply_settings).pack(side=tk.LEFT, padx=(0, 10))
+        ttk.Button(apply_frame, text="Reset to Default", command=self.reset_settings).pack(side=tk.LEFT, padx=(0, 10))
+        ttk.Button(apply_frame, text="Load Presets", command=self.show_presets).pack(side=tk.LEFT)
+        
+        # Presets
+        presets_frame = ttk.LabelFrame(settings_frame, text="Performance Presets", padding="10")
+        presets_frame.pack(fill=tk.X)
+        
+        preset_buttons = ttk.Frame(presets_frame)
+        preset_buttons.pack()
+        
+        ttk.Button(preset_buttons, text="Light (1,2,3,3)", command=lambda: self.apply_preset(1,2,3,3)).pack(side=tk.LEFT, padx=(0, 5))
+        ttk.Button(preset_buttons, text="Balanced (2,4,6,6)", command=lambda: self.apply_preset(2,4,6,6)).pack(side=tk.LEFT, padx=(0, 5))
+        ttk.Button(preset_buttons, text="Performance (3,6,8,8)", command=lambda: self.apply_preset(3,6,8,8)).pack(side=tk.LEFT, padx=(0, 5))
+        ttk.Button(preset_buttons, text="Max (4,8,10,12)", command=lambda: self.apply_preset(4,8,10,12)).pack(side=tk.LEFT)
+        
+    def setup_monitor_tab(self, notebook):
+        """Tab monitor server"""
+        monitor_frame = ttk.Frame(notebook)
+        notebook.add(monitor_frame, text="Monitor")
+        
+        # Resource usage
+        resource_frame = ttk.LabelFrame(monitor_frame, text="Resource Usage", padding="10")
+        resource_frame.pack(fill=tk.X, pady=(0, 10))
+        
+        self.resource_text = tk.Text(resource_frame, height=8, width=70, state="disabled")
+        self.resource_text.pack()
+        
+        # Recent requests
+        requests_frame = ttk.LabelFrame(monitor_frame, text="Recent Activity", padding="10")
+        requests_frame.pack(fill=tk.BOTH, expand=True)
+        
+        self.activity_text = tk.Text(requests_frame, height=15, width=70, state="disabled")
+        scrollbar = ttk.Scrollbar(requests_frame, orient="vertical", command=self.activity_text.yview)
+        self.activity_text.configure(yscrollcommand=scrollbar.set)
+        
+        self.activity_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        
+        # Auto refresh
+        refresh_frame = ttk.Frame(monitor_frame)
+        refresh_frame.pack(fill=tk.X, pady=(10, 0))
+        
+        self.auto_refresh_var = tk.BooleanVar(value=True)
+        ttk.Checkbutton(refresh_frame, text="Auto Refresh", variable=self.auto_refresh_var).pack(side=tk.LEFT)
+        ttk.Button(refresh_frame, text="Refresh Now", command=self.refresh_monitor).pack(side=tk.RIGHT)
+        
+    def start_server(self):
+        """Start TTS server"""
+        try:
+            if self.server_process and self.server_process.poll() is None:
+                messagebox.showwarning("Warning", "Server is already running!")
+                return
+                
+            self.log_activity("Starting TTS server...")
+            
+            # Start server process
+            self.server_process = subprocess.Popen(
+                ["python", "tts_server.py"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            self.start_btn.config(state="disabled")
+            self.stop_btn.config(state="normal")
+            
+            # Monitor server output
+            threading.Thread(target=self.monitor_server_output, daemon=True).start()
+            
+            self.log_activity("Server starting... Please wait for initialization.")
+            
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to start server: {str(e)}")
+            
+    def stop_server(self):
+        """Stop TTS server"""
+        try:
+            if self.server_process:
+                self.log_activity("Stopping TTS server...")
+                self.server_process.terminate()
+                self.server_process.wait(timeout=10)
+                self.server_process = None
+                
+            self.start_btn.config(state="normal")
+            self.stop_btn.config(state="disabled")
+            self.log_activity("Server stopped.")
+            
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to stop server: {str(e)}")
+            
+    def restart_server(self):
+        """Restart server"""
+        self.stop_server()
+        time.sleep(2)
+        self.start_server()
+        
+    def monitor_server_output(self):
+        """Monitor server console output"""
+        if not self.server_process:
+            return
+            
+        try:
+            for line in iter(self.server_process.stdout.readline, ''):
+                if line:
+                    # Only log important messages, not all console output
+                    if any(keyword in line for keyword in ['✅', '❌', '🎤', '📊', 'ERROR', 'WARNING']):
+                        self.log_activity(f"Server: {line.strip()}")
+                        
+                if self.server_process.poll() is not None:
+                    break
+                    
+        except Exception as e:
+            self.log_activity(f"Error monitoring server: {str(e)}")
+            
+    def apply_settings(self):
+        """Apply new async settings"""
+        try:
+            new_settings = {
+                "gpu_semaphore": int(self.gpu_var.get()),
+                "cpu_semaphore": int(self.cpu_var.get()),
+                "io_semaphore": int(self.io_var.get()),
+                "thread_pool": int(self.thread_var.get())
+            }
+            
+            # Send settings to server via API
+            response = requests.post(f"{self.server_url}/admin/update_settings", json=new_settings, timeout=5)
+            
+            if response.status_code == 200:
+                self.current_settings = new_settings
+                self.update_current_settings_display()
+                self.log_activity(f"Settings applied: GPU({new_settings['gpu_semaphore']}) CPU({new_settings['cpu_semaphore']}) I/O({new_settings['io_semaphore']}) Threads({new_settings['thread_pool']})")
+                messagebox.showinfo("Success", "Settings applied successfully!")
+            else:
+                messagebox.showerror("Error", f"Failed to apply settings: {response.text}")
+                
+        except requests.exceptions.RequestException:
+            messagebox.showwarning("Warning", "Server not responding. Settings will be applied on next restart.")
+        except Exception as e:
+            messagebox.showerror("Error", f"Failed to apply settings: {str(e)}")
+            
+    def apply_preset(self, gpu, cpu, io, threads):
+        """Apply preset configuration"""
+        self.gpu_var.set(str(gpu))
+        self.cpu_var.set(str(cpu))
+        self.io_var.set(str(io))
+        self.thread_var.set(str(threads))
+        self.apply_settings()
+        
+    def reset_settings(self):
+        """Reset to default settings"""
+        self.gpu_var.set("2")
+        self.cpu_var.set("4")
+        self.io_var.set("6")
+        self.thread_var.set("6")
+        
+    def show_presets(self):
+        """Show preset explanations"""
+        presets_info = """
+Performance Presets:
+
+• Light (1,2,3,3): Minimal resource usage, good for testing
+• Balanced (2,4,6,6): Default configuration, good performance
+• Performance (3,6,8,8): High performance, more resource usage
+• Max (4,8,10,12): Maximum performance, highest resource usage
+
+Note: Higher values = better performance but more resource usage
+        """
+        messagebox.showinfo("Presets Info", presets_info)
+        
+    def check_server_status(self):
+        """Check server status"""
+        try:
+            response = requests.get(f"{self.server_url}/health", timeout=3)
+            if response.status_code == 200:
+                data = response.json()
+                status_text = f"✅ Server Online | Model: {data.get('model_status', 'unknown')}"
+                
+                if 'async_resources' in data:
+                    async_info = data['async_resources']
+                    status_text += f" | GPU: {async_info.get('gpu_available', 0)}"
+                    status_text += f" | CPU: {async_info.get('cpu_available', 0)}"
+                    status_text += f" | I/O: {async_info.get('io_available', 0)}"
+                
+                self.status_label.config(text=status_text, foreground="green")
+                return True
+            else:
+                self.status_label.config(text="❌ Server Error", foreground="red")
+                return False
+        except Exception:
+            self.status_label.config(text="❌ Server Offline", foreground="red")
+            return False
+            
+    def update_current_settings_display(self):
+        """Update current settings display"""
+        settings_text = f"""GPU Semaphore: {self.current_settings['gpu_semaphore']} (concurrent GPU tasks)
+CPU Semaphore: {self.current_settings['cpu_semaphore']} (concurrent CPU tasks)
+I/O Semaphore: {self.current_settings['io_semaphore']} (concurrent I/O tasks)
+Thread Pool: {self.current_settings['thread_pool']} (worker threads)"""
+        
+        self.current_settings_text.config(state="normal")
+        self.current_settings_text.delete(1.0, tk.END)
+        self.current_settings_text.insert(1.0, settings_text)
+        self.current_settings_text.config(state="disabled")
+        
+    def refresh_monitor(self):
+        """Refresh monitor data"""
+        try:
+            # Get detailed status
+            response = requests.get(f"{self.server_url}/status", timeout=3)
+            if response.status_code == 200:
+                data = response.json()
+                
+                resource_info = "=== RESOURCE USAGE ===\n"
+                
+                if 'async_processing' in data:
+                    async_data = data['async_processing']
+                    for resource, info in async_data.items():
+                        usage_pct = (info['in_use'] / info['max_capacity']) * 100
+                        resource_info += f"{resource}: {info['in_use']}/{info['max_capacity']} ({usage_pct:.0f}% used)\n"
+                
+                if 'model_info' in data:
+                    model_info = data['model_info']
+                    resource_info += f"\nModel: {model_info.get('device', 'unknown')}\n"
+                    resource_info += f"Cache: {model_info.get('reference_cache_size', 0)} voices cached\n"
+                
+                resource_info += f"\nLast Updated: {datetime.now().strftime('%H:%M:%S')}"
+                
+                self.resource_text.config(state="normal")
+                self.resource_text.delete(1.0, tk.END)
+                self.resource_text.insert(1.0, resource_info)
+                self.resource_text.config(state="disabled")
+                
+        except requests.exceptions.RequestException:
+            # Don't log connection errors to avoid spam
+            pass
+        except Exception as e:
+            self.log_activity(f"Monitor error: {str(e)}")
+            
+    def clear_monitor_display(self):
+        """Clear monitor display when server is offline"""
+        offline_info = "=== SERVER OFFLINE ===\n\nServer is not running.\nUse 'Start Server' button to launch the server.\n\nMonitoring will resume when server is online."
+        
+        self.resource_text.config(state="normal")
+        self.resource_text.delete(1.0, tk.END)
+        self.resource_text.insert(1.0, offline_info)
+        self.resource_text.config(state="disabled")
+            
+    def log_activity(self, message):
+        """Log activity to monitor"""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        log_message = f"[{timestamp}] {message}\n"
+        
+        self.activity_text.config(state="normal")
+        self.activity_text.insert(tk.END, log_message)
+        self.activity_text.see(tk.END)
+        self.activity_text.config(state="disabled")
+        
+        # Keep only last 100 lines
+        lines = self.activity_text.get(1.0, tk.END).split('\n')
+        if len(lines) > 100:
+            self.activity_text.config(state="normal")
+            self.activity_text.delete(1.0, f"{len(lines)-100}.0")
+            self.activity_text.config(state="disabled")
+            
+    def start_monitoring(self):
+        """Start monitoring loop"""
+        def monitor_loop():
+            while True:
+                server_online = self.check_server_status()
+                
+                # Only refresh monitor if server is online and auto refresh is enabled
+                if server_online and self.auto_refresh_var.get():
+                    self.refresh_monitor()
+                elif not server_online:
+                    # Clear monitor display when server is offline
+                    self.clear_monitor_display()
+                    
+                time.sleep(10)  # Update every 10 seconds to reduce spam
+                
+        threading.Thread(target=monitor_loop, daemon=True).start()
+        
+        # Initial updates
+        self.update_current_settings_display()
+        
+    def open_api_docs(self):
+        """Open API documentation"""
+        import webbrowser
+        webbrowser.open(f"{self.server_url}/docs")
+        
+    def test_server(self):
+        """Quick server test"""
+        try:
+            test_data = {
+                "text": "Test server connection",
+                "voice_choice": "Tuyên (nam miền Bắc)",
+                "speed_factor": 1.0
+            }
+            
+            self.log_activity("Testing server...")
+            response = requests.post(f"{self.server_url}/tts", json=test_data, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                self.log_activity(f"✅ Server test successful! Processing time: {result.get('processing_time', 0):.2f}s")
+            else:
+                self.log_activity(f"❌ Server test failed: HTTP {response.status_code}")
+                
+        except Exception as e:
+            self.log_activity(f"❌ Server test error: {str(e)}")
+            
+    def clear_cache(self):
+        """Clear server cache"""
+        try:
+            response = requests.post(f"{self.server_url}/admin/clear_cache", timeout=5)
+            if response.status_code == 200:
+                self.log_activity("✅ Cache cleared successfully")
+            else:
+                self.log_activity("❌ Failed to clear cache")
+        except Exception as e:
+            self.log_activity(f"❌ Cache clear error: {str(e)}")
+
+def main():
+    root = tk.Tk()
+    app = ServerManager(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    main()

tts_server.py

@@ -0,0 +1,1165 @@
+"""
+FastAPI TTS Server với Speed Control + Async Processing
+"""
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List
+import tempfile
+import os
+import time
+from datetime import datetime
+import soundfile as sf
+import numpy as np
+from pydub import AudioSegment
+import torch
+from vieneu_tts import VieNeuTTS
+import asyncio
+import concurrent.futures
+import threading
+
+# ==========================================
+# SETUP
+# ==========================================
+app = FastAPI(title="VieNeu-TTS API", version="1.0.0")
+
+# Global variables
+tts = None
+device = None
+
+# Async control - Semaphores để kiểm soát tài nguyên
+gpu_semaphore = None  # Chỉ 1 GPU task cùng lúc
+cpu_semaphore = None  # 3 CPU tasks cùng lúc
+io_semaphore = None   # 5 I/O tasks cùng lúc
+
+# Thread pool cho blocking operations
+thread_pool = None
+
+# Voice samples
+VOICE_SAMPLES = {
+    "Tuyên (nam miền Bắc)": {"audio": "./sample/Tuyên (nam miền Bắc).wav", "text": "./sample/Tuyên (nam miền Bắc).txt"},
+    "Vĩnh (nam miền Nam)": {"audio": "./sample/Vĩnh (nam miền Nam).wav", "text": "./sample/Vĩnh (nam miền Nam).txt"},
+    "Bình (nam miền Bắc)": {"audio": "./sample/Bình (nam miền Bắc).wav", "text": "./sample/Bình (nam miền Bắc).txt"},
+    "Nguyên (nam miền Nam)": {"audio": "./sample/Nguyên (nam miền Nam).wav", "text": "./sample/Nguyên (nam miền Nam).txt"},
+    "Sơn (nam miền Nam)": {"audio": "./sample/Sơn (nam miền Nam).wav", "text": "./sample/Sơn (nam miền Nam).txt"},
+    "Đoan (nữ miền Nam)": {"audio": "./sample/Đoan (nữ miền Nam).wav", "text": "./sample/Đoan (nữ miền Nam).txt"},
+    "Ngọc (nữ miền Bắc)": {"audio": "./sample/Ngọc (nữ miền Bắc).wav", "text": "./sample/Ngọc (nữ miền Bắc).txt"},
+    "Ly (nữ miền Bắc)": {"audio": "./sample/Ly (nữ miền Bắc).wav", "text": "./sample/Ly (nữ miền Bắc).txt"},
+    "Dung (nữ miền Nam)": {"audio": "./sample/Dung (nữ miền Nam).wav", "text": "./sample/Dung (nữ miền Nam).txt"},
+    "Nhỏ Ngọt Ngào": {"audio": "./sample/Nhỏ Ngọt Ngào.wav", "text": "./sample/Nhỏ Ngọt Ngào.txt"},
+}
+
+# Cache for reference codes
+reference_cache = {}
+
+# ==========================================
+# MODELS
+# ==========================================
+class TTSRequest(BaseModel):
+    text: str
+    voice_choice: str = "Tuyên (nam miền Bắc)"
+    speed_factor: float = 1.0
+
+class TTSResponse(BaseModel):
+    audio_url: str
+    status: str
+    processing_time: float
+    voice_used: str
+    speed_applied: float
+
+# ==========================================
+# HELPER FUNCTIONS
+# ==========================================
+def apply_speed_control(audio, speed_factor):
+    """Áp dụng speed control với Pydub"""
+    if speed_factor == 1.0:
+        return audio
+    
+    sr = 24000
+    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
+        sf.write(tmp.name, audio, sr)
+        tmp_path = tmp.name
+    
+    sound = AudioSegment.from_wav(tmp_path)
+    new_frame_rate = int(sound.frame_rate * speed_factor)
+    sound_stretched = sound._spawn(sound.raw_data, overrides={'frame_rate': new_frame_rate})
+    sound_stretched = sound_stretched.set_frame_rate(sr)
+    
+    audio_stretched = np.array(sound_stretched.get_array_of_samples()).astype(np.float32) / 32768.0
+    if sound_stretched.channels == 2:
+        audio_stretched = audio_stretched.reshape((-1, 2)).mean(axis=1)
+    
+    os.unlink(tmp_path)
+    return audio_stretched
+
+# ==========================================
+# API ENDPOINTS
+# ==========================================
+@app.get("/")
+async def root():
+    return {
+        "message": "VieNeu-TTS API Server with Async Processing",
+        "version": "1.0.0",
+        "available_voices": list(VOICE_SAMPLES.keys()),
+        "async_features": {
+            "gpu_semaphore": "2 concurrent GPU tasks",
+            "cpu_semaphore": "4 concurrent CPU tasks", 
+            "io_semaphore": "6 concurrent I/O tasks",
+            "thread_pool": "6 worker threads"
+        },
+        "endpoints": {
+            "POST /tts": "Synthesize speech (standard)",
+            "POST /fast-tts": "Fast TTS for external apps",
+            "POST /bulk-tts": "Bulk processing (up to 50 requests)",
+            "GET /voices": "List available voices",
+            "GET /health": "Health check with async status",
+            "GET /status": "Detailed async resource status",
+            "POST /admin/update_settings": "Update async settings real-time",
+            "POST /admin/clear_cache": "Clear reference cache",
+            "GET /admin/settings": "Get current settings"
+        },
+        "external_app_recommendations": {
+            "single_requests": "Use POST /fast-tts with return_base64=true",
+            "batch_requests": "Use POST /bulk-tts for up to 50 requests",
+            "performance_tips": [
+                "Use same voice for consecutive requests (cache benefit)",
+                "Keep text under 200 characters for best speed",
+                "Use return_base64=true to avoid file I/O",
+                "Consider bulk-tts for batches of 10-50 requests"
+            ]
+        }
+    }
+
+@app.get("/voices")
+async def get_voices():
+    return {
+        "voices": list(VOICE_SAMPLES.keys()),
+        "total": len(VOICE_SAMPLES)
+    }
+
+@app.get("/health")
+async def health_check():
+    model_status = "loaded" if tts is not None else "not_loaded"
+    
+    # Check CUDA memory if using GPU
+    cuda_info = {}
+    if device == "cuda" and torch.cuda.is_available():
+        cuda_info = {
+            "cuda_memory_allocated": f"{torch.cuda.memory_allocated(0) / 1024**3:.2f} GB",
+            "cuda_memory_reserved": f"{torch.cuda.memory_reserved(0) / 1024**3:.2f} GB"
+        }
+    
+    # Async resource status
+    async_status = {}
+    if gpu_semaphore and cpu_semaphore and io_semaphore:
+        async_status = {
+            "gpu_available": gpu_semaphore._value,
+            "cpu_available": cpu_semaphore._value,
+            "io_available": io_semaphore._value,
+            "thread_pool_active": thread_pool._threads if thread_pool else 0
+        }
+    
+    return {
+        "status": "healthy",
+        "model_status": model_status,
+        "device": device,
+        "cache_size": len(reference_cache),
+        "async_resources": async_status,
+        "timestamp": datetime.now().isoformat(),
+        **cuda_info
+    }
+
+@app.get("/status")
+async def get_status():
+    """Detailed server status including async resource usage"""
+    
+    # Semaphore status
+    semaphore_status = {}
+    if gpu_semaphore and cpu_semaphore and io_semaphore:
+        semaphore_status = {
+            "gpu_semaphore": {
+                "available": gpu_semaphore._value,
+                "max_capacity": 2,
+                "in_use": 2 - gpu_semaphore._value
+            },
+            "cpu_semaphore": {
+                "available": cpu_semaphore._value,
+                "max_capacity": 4,
+                "in_use": 4 - cpu_semaphore._value
+            },
+            "io_semaphore": {
+                "available": io_semaphore._value,
+                "max_capacity": 6,
+                "in_use": 6 - io_semaphore._value
+            }
+        }
+    
+    # Thread pool status
+    thread_status = {}
+    if thread_pool:
+        thread_status = {
+            "max_workers": thread_pool._max_workers,
+            "active_threads": len(thread_pool._threads) if hasattr(thread_pool, '_threads') else 0
+        }
+    
+    # Model and cache info
+    model_info = {
+        "model_loaded": tts is not None,
+        "device": device,
+        "reference_cache_size": len(reference_cache),
+        "cached_voices": list(reference_cache.keys())
+    }
+    
+    return {
+        "server_status": "running",
+        "async_processing": semaphore_status,
+        "thread_pool": thread_status,
+        "model_info": model_info,
+        "available_voices": list(VOICE_SAMPLES.keys()),
+        "timestamp": datetime.now().isoformat()
+    }
+
+async def _load_reference_text(ref_text_path: str) -> str:
+    """Load reference text with I/O semaphore"""
+    async with io_semaphore:
+        loop = asyncio.get_event_loop()
+        with open(ref_text_path, "r", encoding="utf-8") as f:
+            return await loop.run_in_executor(thread_pool, f.read)
+
+async def _encode_reference_async(ref_audio_path: str, cache_key: str, request_id: str = "") -> torch.Tensor:
+    """Encode reference audio with GPU semaphore"""
+    async with gpu_semaphore:
+        print(f"   🔄 [{request_id}] Encoding reference for {cache_key}...")
+        loop = asyncio.get_event_loop()
+        
+        def encode_sync():
+            try:
+                # Clear CUDA cache before encoding
+                if device == "cuda":
+                    torch.cuda.empty_cache()
+                
+                ref_codes = tts.encode_reference(ref_audio_path)
+                
+                # Ensure ref_codes is on CPU for caching
+                if hasattr(ref_codes, 'cpu'):
+                    ref_codes = ref_codes.cpu()
+                
+                return ref_codes
+            except Exception as e:
+                print(f"   ❌ [{request_id}] Failed to encode reference: {e}")
+                raise e
+        
+        ref_codes = await loop.run_in_executor(thread_pool, encode_sync)
+        reference_cache[cache_key] = ref_codes
+        print(f"   ✅ [{request_id}] Reference encoded and cached")
+        return ref_codes
+
+async def _generate_speech_async(text: str, ref_codes: torch.Tensor, ref_text_raw: str, request_id: str = "") -> np.ndarray:
+    """Generate speech with GPU semaphore"""
+    async with gpu_semaphore:
+        print(f"   🎵 [{request_id}] Generating speech...")
+        loop = asyncio.get_event_loop()
+        
+        def infer_sync():
+            try:
+                # Clear CUDA cache before inference
+                if device == "cuda":
+                    torch.cuda.empty_cache()
+                
+                wav = tts.infer(text, ref_codes, ref_text_raw)
+                return wav
+            except Exception as e:
+                print(f"   ❌ [{request_id}] Failed to generate speech: {e}")
+                raise e
+        
+        wav = await loop.run_in_executor(thread_pool, infer_sync)
+        print(f"   ✅ [{request_id}] Speech generated")
+        return wav
+
+async def _apply_speed_control_async(audio: np.ndarray, speed_factor: float, request_id: str = "") -> np.ndarray:
+    """Apply speed control with CPU semaphore"""
+    if speed_factor == 1.0:
+        return audio
+    
+    async with cpu_semaphore:
+        print(f"   🎚️ [{request_id}] Applying speed control: {speed_factor}x")
+        loop = asyncio.get_event_loop()
+        
+        def speed_control_sync():
+            return apply_speed_control(audio, speed_factor)
+        
+        return await loop.run_in_executor(thread_pool, speed_control_sync)
+
+async def _save_audio_async(wav: np.ndarray, output_path: str) -> None:
+    """Save audio file with I/O semaphore"""
+    async with io_semaphore:
+        loop = asyncio.get_event_loop()
+        
+        def save_sync():
+            sf.write(output_path, wav, 24000)
+        
+        await loop.run_in_executor(thread_pool, save_sync)
+
+@app.post("/tts", response_model=TTSResponse)
+async def synthesize_speech(request: TTSRequest):
+    """
+    Tổng hợp giọng nói với speed control - Async Processing
+    """
+    start_time = time.time()
+    
+    try:
+        # Validate input
+        if not request.text or len(request.text.strip()) == 0:
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+        
+        if len(request.text) > 500:
+            raise HTTPException(status_code=400, detail="Text too long (max 500 characters)")
+        
+        if request.voice_choice not in VOICE_SAMPLES:
+            raise HTTPException(status_code=400, detail=f"Voice not found. Available: {list(VOICE_SAMPLES.keys())}")
+        
+        if not (0.5 <= request.speed_factor <= 2.0):
+            raise HTTPException(status_code=400, detail="Speed factor must be between 0.5 and 2.0")
+        
+        request_id = f"REQ-{int(time.time() * 1000) % 100000}"
+        print(f"🎤 [{request_id}] Processing: {request.text[:50]}...")
+        print(f"🎚️ [{request_id}] Voice: {request.voice_choice}, Speed: {request.speed_factor}x")
+        
+        # Get reference audio and text paths
+        voice_info = VOICE_SAMPLES[request.voice_choice]
+        ref_audio_path = voice_info["audio"]
+        ref_text_path = voice_info["text"]
+        
+        if not os.path.exists(ref_audio_path):
+            raise HTTPException(status_code=500, detail=f"Reference audio not found: {ref_audio_path}")
+        
+        # Load reference text (async I/O)
+        ref_text_raw = await _load_reference_text(ref_text_path)
+        
+        # Encode reference (with cache) - async GPU
+        cache_key = request.voice_choice
+        if cache_key in reference_cache:
+            print(f"   ✨ [{request_id}] Using cached reference for {cache_key}")
+            ref_codes = reference_cache[cache_key]
+        else:
+            ref_codes = await _encode_reference_async(ref_audio_path, cache_key, request_id)
+        
+        # Generate speech - async GPU
+        wav = await _generate_speech_async(request.text, ref_codes, ref_text_raw, request_id)
+        
+        # Apply speed control - async CPU
+        wav = await _apply_speed_control_async(wav, request.speed_factor, request_id)
+        
+        # Prepare output path
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]  # milliseconds
+        filename = f"tts_{request.speed_factor}x_{timestamp}.wav"
+        
+        # Create temp directory if not exists
+        temp_dir = "./temp_audio"
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        output_path = os.path.join(temp_dir, filename)
+        
+        # Save output - async I/O
+        await _save_audio_async(wav, output_path)
+        
+        processing_time = time.time() - start_time
+        
+        print(f"   ✅ [{request_id}] Success! Processing time: {processing_time:.2f}s")
+        print(f"   📁 [{request_id}] Saved: {output_path}")
+        
+        # Return response
+        return TTSResponse(
+            audio_url=f"/audio/{filename}",
+            status="success",
+            processing_time=processing_time,
+            voice_used=request.voice_choice,
+            speed_applied=request.speed_factor
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        processing_time = time.time() - start_time
+        print(f"   ❌ [{request_id}] Error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@app.get("/audio/{filename}")
+async def get_audio(filename: str):
+    """
+    Tải file audio đã tạo
+    """
+    file_path = os.path.join("./temp_audio", filename)
+    
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="Audio file not found")
+    
+    return FileResponse(
+        path=file_path,
+        media_type="audio/wav",
+        filename=filename
+    )
+
+# ==========================================
+# ADMIN ENDPOINTS
+# ==========================================
+class SettingsUpdate(BaseModel):
+    gpu_semaphore: int = 2
+    cpu_semaphore: int = 4
+    io_semaphore: int = 6
+    thread_pool: int = 6
+
+@app.post("/admin/update_settings")
+async def update_settings(settings: SettingsUpdate):
+    """
+    Cập nhật async settings real-time
+    """
+    global gpu_semaphore, cpu_semaphore, io_semaphore, thread_pool
+    
+    try:
+        # Validate settings
+        if not (1 <= settings.gpu_semaphore <= 4):
+            raise HTTPException(status_code=400, detail="GPU semaphore must be between 1-4")
+        if not (2 <= settings.cpu_semaphore <= 16):
+            raise HTTPException(status_code=400, detail="CPU semaphore must be between 2-16")
+        if not (3 <= settings.io_semaphore <= 16):
+            raise HTTPException(status_code=400, detail="I/O semaphore must be between 3-16")
+        if not (2 <= settings.thread_pool <= 20):
+            raise HTTPException(status_code=400, detail="Thread pool must be between 2-20")
+        
+        # Update semaphores
+        gpu_semaphore = asyncio.Semaphore(settings.gpu_semaphore)
+        cpu_semaphore = asyncio.Semaphore(settings.cpu_semaphore)
+        io_semaphore = asyncio.Semaphore(settings.io_semaphore)
+        
+        # Update thread pool (need to shutdown old one)
+        if thread_pool:
+            old_pool = thread_pool
+            thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=settings.thread_pool)
+            # Shutdown old pool gracefully
+            threading.Thread(target=lambda: old_pool.shutdown(wait=True), daemon=True).start()
+        else:
+            thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=settings.thread_pool)
+        
+        print(f"🔄 Settings updated: GPU({settings.gpu_semaphore}) CPU({settings.cpu_semaphore}) I/O({settings.io_semaphore}) Threads({settings.thread_pool})")
+        
+        return {
+            "status": "success",
+            "message": "Settings updated successfully",
+            "new_settings": {
+                "gpu_semaphore": settings.gpu_semaphore,
+                "cpu_semaphore": settings.cpu_semaphore,
+                "io_semaphore": settings.io_semaphore,
+                "thread_pool": settings.thread_pool
+            },
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ Failed to update settings: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to update settings: {str(e)}")
+
+@app.post("/admin/clear_cache")
+async def clear_cache():
+    """
+    Xóa reference cache
+    """
+    global reference_cache
+    
+    try:
+        cache_size = len(reference_cache)
+        reference_cache.clear()
+        
+        # Clear CUDA cache if available
+        if device == "cuda" and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        print(f"🧹 Cache cleared: {cache_size} references removed")
+        
+        return {
+            "status": "success",
+            "message": f"Cache cleared successfully. {cache_size} references removed.",
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        print(f"❌ Failed to clear cache: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to clear cache: {str(e)}")
+
+@app.get("/admin/settings")
+async def get_current_settings():
+    """
+    Lấy settings hiện tại
+    """
+    current_settings = {
+        "gpu_semaphore": {
+            "current": gpu_semaphore._value if gpu_semaphore else 0,
+            "max_capacity": 2  # Default, will be updated based on actual semaphore
+        },
+        "cpu_semaphore": {
+            "current": cpu_semaphore._value if cpu_semaphore else 0,
+            "max_capacity": 4
+        },
+        "io_semaphore": {
+            "current": io_semaphore._value if io_semaphore else 0,
+            "max_capacity": 6
+        },
+        "thread_pool": {
+            "max_workers": thread_pool._max_workers if thread_pool else 0,
+            "active_threads": len(thread_pool._threads) if thread_pool and hasattr(thread_pool, '_threads') else 0
+        }
+    }
+    
+    return {
+        "status": "success",
+        "settings": current_settings,
+        "timestamp": datetime.now().isoformat()
+    }
+
+# ==========================================
+# FAST TTS ENDPOINT FOR EXTERNAL APPS
+# ==========================================
+class FastTTSRequest(BaseModel):
+    text: str
+    voice_choice: str = "Tuyên (nam miền Bắc)"
+    speed_factor: float = 1.0
+    return_base64: bool = False  # Option to return audio as base64
+    skip_file_save: bool = False  # Option to skip saving file
+
+@app.post("/fast-tts")
+async def fast_tts(request: FastTTSRequest):
+    """
+    Fast TTS endpoint tối ưu cho external apps gửi nhiều requests
+    - Ít validation hơn
+    - Có thể return base64 thay vì file
+    - Có thể skip file saving
+    """
+    start_time = time.time()
+    request_id = f"FAST-{int(time.time() * 1000) % 100000}"
+    
+    try:
+        # Minimal validation
+        if not request.text or len(request.text.strip()) == 0:
+            raise HTTPException(status_code=400, detail="Text cannot be empty")
+        
+        if len(request.text) > 1000:  # Increased limit for external apps
+            raise HTTPException(status_code=400, detail="Text too long (max 1000 characters)")
+        
+        if request.voice_choice not in VOICE_SAMPLES:
+            # Auto fallback to default voice instead of error
+            request.voice_choice = "Tuyên (nam miền Bắc)"
+        
+        if not (0.5 <= request.speed_factor <= 2.0):
+            request.speed_factor = 1.0  # Auto fallback instead of error
+        
+        print(f"⚡ [{request_id}] Fast processing: {request.text[:30]}... | {request.voice_choice} | {request.speed_factor}x")
+        
+        # Get reference (with cache)
+        voice_info = VOICE_SAMPLES[request.voice_choice]
+        ref_audio_path = voice_info["audio"]
+        ref_text_path = voice_info["text"]
+        
+        # Load reference text (async I/O)
+        ref_text_raw = await _load_reference_text(ref_text_path)
+        
+        # Encode reference (with cache) - async GPU
+        cache_key = request.voice_choice
+        if cache_key in reference_cache:
+            ref_codes = reference_cache[cache_key]
+        else:
+            ref_codes = await _encode_reference_async(ref_audio_path, cache_key, request_id)
+        
+        # Generate speech - async GPU
+        wav = await _generate_speech_async(request.text, ref_codes, ref_text_raw, request_id)
+        
+        # Apply speed control - async CPU
+        wav = await _apply_speed_control_async(wav, request.speed_factor, request_id)
+        
+        processing_time = time.time() - start_time
+        
+        # Return options
+        if request.return_base64:
+            # Return audio as base64 (no file saving)
+            import base64
+            import io
+            
+            # Convert to bytes
+            audio_buffer = io.BytesIO()
+            sf.write(audio_buffer, wav, 24000, format='WAV')
+            audio_bytes = audio_buffer.getvalue()
+            audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+            
+            print(f"   ✅ [{request_id}] Fast success (base64): {processing_time:.2f}s")
+            
+            return {
+                "audio_base64": audio_base64,
+                "status": "success",
+                "processing_time": processing_time,
+                "voice_used": request.voice_choice,
+                "speed_applied": request.speed_factor,
+                "format": "wav",
+                "sample_rate": 24000
+            }
+            
+        elif request.skip_file_save:
+            # Return raw audio data info (for streaming)
+            print(f"   ✅ [{request_id}] Fast success (no save): {processing_time:.2f}s")
+            
+            return {
+                "status": "success",
+                "processing_time": processing_time,
+                "voice_used": request.voice_choice,
+                "speed_applied": request.speed_factor,
+                "audio_length": len(wav),
+                "sample_rate": 24000,
+                "message": "Audio generated but not saved"
+            }
+            
+        else:
+            # Standard file saving
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
+            filename = f"fast_{request.speed_factor}x_{timestamp}.wav"
+            
+            temp_dir = "./temp_audio"
+            os.makedirs(temp_dir, exist_ok=True)
+            
+            output_path = os.path.join(temp_dir, filename)
+            await _save_audio_async(wav, output_path)
+            
+            print(f"   ✅ [{request_id}] Fast success: {processing_time:.2f}s | {filename}")
+            
+            return {
+                "audio_url": f"/audio/{filename}",
+                "status": "success",
+                "processing_time": processing_time,
+                "voice_used": request.voice_choice,
+                "speed_applied": request.speed_factor,
+                "filename": filename
+            }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        processing_time = time.time() - start_time
+        print(f"   ❌ [{request_id}] Fast error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Fast TTS error: {str(e)}")
+
+@app.post("/bulk-tts")
+async def bulk_tts(requests: List[FastTTSRequest]):
+    """
+    Bulk TTS endpoint - xử lý nhiều requests cùng lúc
+    Tối ưu cho external apps gửi batch
+    """
+    if len(requests) > 50:  # Limit batch size
+        raise HTTPException(status_code=400, detail="Too many requests in batch (max 50)")
+    
+    start_time = time.time()
+    batch_id = f"BULK-{int(time.time() * 1000) % 100000}"
+    
+    print(f"📦 [{batch_id}] Processing bulk: {len(requests)} requests")
+    
+    # Process all requests concurrently
+    async def process_single(req, index):
+        try:
+            # Add index to request for tracking
+            req_copy = req.copy()
+            result = await fast_tts(req_copy)
+            return {"index": index, "status": "success", "result": result}
+        except Exception as e:
+            return {"index": index, "status": "error", "error": str(e)}
+    
+    # Create tasks for all requests
+    tasks = [process_single(req, i) for i, req in enumerate(requests)]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    
+    # Process results
+    processed_results = []
+    for result in results:
+        if isinstance(result, Exception):
+            processed_results.append({"status": "exception", "error": str(result)})
+        else:
+            processed_results.append(result)
+    
+    total_time = time.time() - start_time
+    success_count = len([r for r in processed_results if r.get("status") == "success"])
+    
+    print(f"   ✅ [{batch_id}] Bulk completed: {success_count}/{len(requests)} success in {total_time:.2f}s")
+    
+    return {
+        "batch_id": batch_id,
+        "total_requests": len(requests),
+        "successful": success_count,
+        "failed": len(requests) - success_count,
+        "total_time": total_time,
+        "avg_time_per_request": total_time / len(requests),
+        "results": processed_results
+    }
+
+# ==========================================
+# STARTUP EVENT
+# ==========================================
+@app.on_event("startup")
+async def startup_event():
+    global tts, device, gpu_semaphore, cpu_semaphore, io_semaphore, thread_pool
+    
+    print("=" * 60)
+    print("🎙️ VieNeu-TTS FastAPI Server (Async)")
+    print("=" * 60)
+    
+    # Setup async controls
+    gpu_semaphore = asyncio.Semaphore(2)   # 2 GPU tasks (parallel inference)
+    cpu_semaphore = asyncio.Semaphore(4)   # 4 CPU tasks (more speed processing)
+    io_semaphore = asyncio.Semaphore(6)    # 6 I/O tasks (more file operations)
+    thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=6)
+    
+    print("🔄 Async setup: GPU(2) | CPU(4) | I/O(6) | ThreadPool(6)")
+    
+    # Device
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"🖥️ Using device: {device}")
+
+    # Check if local backbone exists
+    local_backbone = "./models/VieNeu-TTS"
+    
+    if os.path.exists(local_backbone):
+        print("📦 Loading VieNeu-TTS model (hybrid: local backbone + online codec)...")
+        backbone_repo = local_backbone
+        codec_repo = "neuphonic/neucodec"  # Codec must be online (VieNeuTTS limitation)
+        print("   🔧 Using local backbone (no internet for backbone)")
+        print("   🌐 Using online codec (small download)")
+    else:
+        print("📦 Loading VieNeu-TTS model from HuggingFace...")
+        backbone_repo = "pnnbao-ump/VieNeu-TTS"
+        codec_repo = "neuphonic/neucodec"
+        print("   🌐 Using online models (internet required)")
+        print("   💡 Run 'python download_models.py' to use local backbone")
+    
+    try:
+        tts = VieNeuTTS(
+            backbone_repo=backbone_repo,
+            backbone_device=device,
+            codec_repo=codec_repo,
+            codec_device=device
+        )
+        print("✅ Model loaded successfully!")
+    except Exception as e:
+        print(f"❌ Failed to load model: {e}")
+        if not os.path.exists(local_backbone):
+            print("💡 Try running: python download_models.py")
+        raise e
+    
+    print(f"📦 Model: VieNeu-TTS-1000h")
+    print(f"🎚️ Speed Control: Pydub")
+    print("=" * 60)
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    global thread_pool
+    
+    print("🔄 Shutting down server...")
+    
+    # Cleanup thread pool
+    if thread_pool:
+        print("   🧹 Shutting down thread pool...")
+        thread_pool.shutdown(wait=True)
+        print("   ✅ Thread pool shutdown complete")
+    
+    # Clear CUDA cache
+    if device == "cuda" and torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        print("   🧹 CUDA cache cleared")
+    
+    print("✅ Server shutdown complete")
+
+# ==========================================
+# STARTUP
+# ==========================================
+def start_gui():
+    """Start GUI in separate thread"""
+    import tkinter as tk
+    from tkinter import ttk, messagebox
+    import webbrowser
+    import os
+    import sys
+    
+    class ServerGUI:
+        def __init__(self, root):
+            self.root = root
+            self.root.title("VieNeu-TTS Server Control")
+            self.root.geometry("600x500")
+            
+            # Handle window close event
+            self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
+            
+            # Add menu bar
+            self.setup_menu()
+            
+            # Server info
+            info_frame = ttk.LabelFrame(root, text="Server Information", padding="10")
+            info_frame.pack(fill=tk.X, padx=10, pady=5)
+            
+            ttk.Label(info_frame, text="🎙️ VieNeu-TTS FastAPI Server", font=("Arial", 14, "bold")).pack()
+            
+            url_frame = ttk.Frame(info_frame)
+            url_frame.pack()
+            ttk.Label(url_frame, text="Server URL: ").pack(side=tk.LEFT)
+            url_label = ttk.Label(url_frame, text="http://127.0.0.1:8000", foreground="blue", cursor="hand2")
+            url_label.pack(side=tk.LEFT)
+            url_label.bind("<Button-1>", lambda e: webbrowser.open("http://127.0.0.1:8000"))
+            
+            self.status_label = ttk.Label(info_frame, text="Status: ✅ Running", foreground="green")
+            self.status_label.pack()
+            
+            # Quick actions
+            actions_frame = ttk.LabelFrame(root, text="Quick Actions", padding="10")
+            actions_frame.pack(fill=tk.X, padx=10, pady=5)
+            
+            btn_frame = ttk.Frame(actions_frame)
+            btn_frame.pack()
+            
+            ttk.Button(btn_frame, text="Open API Docs", command=self.open_docs).pack(side=tk.LEFT, padx=5)
+            ttk.Button(btn_frame, text="Test Server", command=self.test_server).pack(side=tk.LEFT, padx=5)
+            ttk.Button(btn_frame, text="Clear Cache", command=self.clear_cache).pack(side=tk.LEFT, padx=5)
+            
+            # Shutdown button
+            shutdown_btn = ttk.Button(btn_frame, text="Tắt Server", command=self.shutdown_server)
+            shutdown_btn.pack(side=tk.RIGHT, padx=5)
+            shutdown_btn.configure(style="Accent.TButton")  # Make it stand out
+            
+            # Settings control
+            settings_frame = ttk.LabelFrame(root, text="Async Settings Control", padding="10")
+            settings_frame.pack(fill=tk.X, padx=10, pady=5)
+            
+            # Current settings display
+            self.settings_text = tk.Text(settings_frame, height=4, width=60, state="disabled")
+            self.settings_text.pack(pady=(0, 10))
+            
+            # Settings controls
+            control_frame = ttk.Frame(settings_frame)
+            control_frame.pack(fill=tk.X)
+            
+            # GPU Semaphore
+            gpu_frame = ttk.Frame(control_frame)
+            gpu_frame.pack(fill=tk.X, pady=2)
+            ttk.Label(gpu_frame, text="GPU Semaphore (1-4):").pack(side=tk.LEFT)
+            self.gpu_var = tk.StringVar(value="2")
+            ttk.Spinbox(gpu_frame, from_=1, to=4, width=10, textvariable=self.gpu_var).pack(side=tk.RIGHT)
+            
+            # CPU Semaphore
+            cpu_frame = ttk.Frame(control_frame)
+            cpu_frame.pack(fill=tk.X, pady=2)
+            ttk.Label(cpu_frame, text="CPU Semaphore (2-16):").pack(side=tk.LEFT)
+            self.cpu_var = tk.StringVar(value="4")
+            ttk.Spinbox(cpu_frame, from_=2, to=16, width=10, textvariable=self.cpu_var).pack(side=tk.RIGHT)
+            
+            # I/O Semaphore
+            io_frame = ttk.Frame(control_frame)
+            io_frame.pack(fill=tk.X, pady=2)
+            ttk.Label(io_frame, text="I/O Semaphore (3-16):").pack(side=tk.LEFT)
+            self.io_var = tk.StringVar(value="6")
+            ttk.Spinbox(io_frame, from_=3, to=16, width=10, textvariable=self.io_var).pack(side=tk.RIGHT)
+            
+            # Thread Pool
+            thread_frame = ttk.Frame(control_frame)
+            thread_frame.pack(fill=tk.X, pady=2)
+            ttk.Label(thread_frame, text="Thread Pool (2-20):").pack(side=tk.LEFT)
+            self.thread_var = tk.StringVar(value="6")
+            ttk.Spinbox(thread_frame, from_=2, to=20, width=10, textvariable=self.thread_var).pack(side=tk.RIGHT)
+            
+            # Apply button
+            ttk.Button(control_frame, text="Apply Settings", command=self.apply_settings).pack(pady=10)
+            
+            # Presets
+            presets_frame = ttk.LabelFrame(settings_frame, text="Performance Presets")
+            presets_frame.pack(fill=tk.X, pady=(10, 0))
+            
+            preset_grid = ttk.Frame(presets_frame)
+            preset_grid.pack(pady=5)
+            
+            ttk.Button(preset_grid, text="Light (1,2,4,4)", command=lambda: self.apply_preset(1,2,4,4), width=15).grid(row=0, column=0, padx=2, pady=2)
+            ttk.Button(preset_grid, text="Balanced (2,4,6,6)", command=lambda: self.apply_preset(2,4,6,6), width=15).grid(row=0, column=1, padx=2, pady=2)
+            ttk.Button(preset_grid, text="Performance (3,8,10,10)", command=lambda: self.apply_preset(3,8,10,10), width=15).grid(row=1, column=0, padx=2, pady=2)
+            ttk.Button(preset_grid, text="Ultra (4,12,12,16)", command=lambda: self.apply_preset(4,12,12,16), width=15).grid(row=1, column=1, padx=2, pady=2)
+            
+            # Status monitor
+            monitor_frame = ttk.LabelFrame(root, text="Resource Monitor", padding="10")
+            monitor_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
+            
+            self.monitor_text = tk.Text(monitor_frame, height=8, state="disabled")
+            scrollbar = ttk.Scrollbar(monitor_frame, orient="vertical", command=self.monitor_text.yview)
+            self.monitor_text.configure(yscrollcommand=scrollbar.set)
+            
+            self.monitor_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+            scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+            
+            # Start monitoring
+            self.update_display()
+            self.start_monitoring()
+            
+        def setup_menu(self):
+            """Setup menu bar"""
+            menubar = tk.Menu(self.root)
+            self.root.config(menu=menubar)
+            
+            # File menu
+            file_menu = tk.Menu(menubar, tearoff=0)
+            menubar.add_cascade(label="File", menu=file_menu)
+            file_menu.add_command(label="Ẩn giao diện", command=lambda: self.root.withdraw())
+            file_menu.add_separator()
+            file_menu.add_command(label="Tắt server", command=self.shutdown_server)
+            
+            # View menu
+            view_menu = tk.Menu(menubar, tearoff=0)
+            menubar.add_cascade(label="View", menu=view_menu)
+            view_menu.add_command(label="Refresh", command=self.update_display)
+            view_menu.add_command(label="Open API Docs", command=self.open_docs)
+            
+            # Help menu
+            help_menu = tk.Menu(menubar, tearoff=0)
+            menubar.add_cascade(label="Help", menu=help_menu)
+            help_menu.add_command(label="About", command=self.show_about)
+            
+        def show_about(self):
+            """Show about dialog"""
+            about_text = """VieNeu-TTS Server Control
+
+Version: 1.0.0
+Server: FastAPI with Async Processing
+Model: VieNeu-TTS-1000h
+
+Features:
+• Real-time settings adjustment
+• Performance monitoring
+• Cache management
+• Multiple presets
+
+Server URL: http://127.0.0.1:8000"""
+            
+            messagebox.showinfo("About", about_text)
+            
+        def on_closing(self):
+            """Handle window closing event"""
+            result = messagebox.askyesnocancel(
+                "Tắt Server", 
+                "Đóng giao diện sẽ tắt server.\n\n" +
+                "• Yes: Tắt server và giao diện\n" +
+                "• No: Chỉ ẩn giao diện (server vẫn chạy)\n" +
+                "• Cancel: Không làm gì"
+            )
+            
+            if result is True:  # Yes - Shutdown server
+                self.log_message("🔄 Đang tắt server...")
+                self.status_label.config(text="Status: 🔄 Shutting down...", foreground="orange")
+                self.root.destroy()
+                
+                # Force exit the entire application
+                import threading
+                def force_exit():
+                    import time
+                    time.sleep(1)  # Give time for cleanup
+                    os._exit(0)  # Force exit
+                
+                threading.Thread(target=force_exit, daemon=True).start()
+                
+            elif result is False:  # No - Just hide GUI
+                self.log_message("ℹ️ Giao diện đã ẩn. Server vẫn chạy tại http://127.0.0.1:8000")
+                self.root.withdraw()  # Hide window instead of destroying
+                
+                # Add system tray notification (if possible)
+                try:
+                    import subprocess
+                    subprocess.run([
+                        'powershell', '-Command', 
+                        f'Add-Type -AssemblyName System.Windows.Forms; ' +
+                        f'[System.Windows.Forms.MessageBox]::Show("Server vẫn chạy tại http://127.0.0.1:8000", "VieNeu-TTS", "OK", "Information")'
+                    ], capture_output=True)
+                except:
+                    pass
+            # If Cancel (None), do nothing
+            
+        def open_docs(self):
+            webbrowser.open("http://127.0.0.1:8000/docs")
+            
+        def test_server(self):
+            import requests
+            try:
+                test_data = {
+                    "text": "Test từ giao diện server",
+                    "voice_choice": "Tuyên (nam miền Bắc)",
+                    "speed_factor": 1.0
+                }
+                response = requests.post("http://127.0.0.1:8000/tts", json=test_data, timeout=30)
+                if response.status_code == 200:
+                    result = response.json()
+                    self.log_message(f"✅ Test thành công! Thời gian: {result.get('processing_time', 0):.2f}s")
+                else:
+                    self.log_message(f"❌ Test thất bại: HTTP {response.status_code}")
+            except Exception as e:
+                self.log_message(f"❌ Lỗi test: {str(e)}")
+                
+        def clear_cache(self):
+            import requests
+            try:
+                response = requests.post("http://127.0.0.1:8000/admin/clear_cache", timeout=5)
+                if response.status_code == 200:
+                    self.log_message("✅ Cache đã được xóa")
+                else:
+                    self.log_message("❌ Không thể xóa cache")
+            except Exception as e:
+                self.log_message(f"❌ Lỗi xóa cache: {str(e)}")
+                
+        def shutdown_server(self):
+            """Shutdown server gracefully"""
+            if messagebox.askokcancel("Tắt Server", "Bạn có chắc chắn muốn tắt server?"):
+                self.log_message("🔄 Đang tắt server...")
+                self.status_label.config(text="Status: 🔄 Shutting down...", foreground="orange")
+                
+                # Close the GUI and exit
+                self.root.after(1000, lambda: [self.root.destroy(), os._exit(0)])
+                
+        def apply_preset(self, gpu, cpu, io, threads):
+            preset_names = {
+                (1,2,4,4): "Light",
+                (2,4,6,6): "Balanced", 
+                (3,8,10,10): "Performance",
+                (4,12,12,16): "Ultra"
+            }
+            preset_name = preset_names.get((gpu, cpu, io, threads), "Custom")
+            
+            self.log_message(f"🎯 Áp dụng preset {preset_name}...")
+            self.gpu_var.set(str(gpu))
+            self.cpu_var.set(str(cpu))
+            self.io_var.set(str(io))
+            self.thread_var.set(str(threads))
+            self.apply_settings()
+            
+        def apply_settings(self):
+            import requests
+            try:
+                settings = {
+                    "gpu_semaphore": int(self.gpu_var.get()),
+                    "cpu_semaphore": int(self.cpu_var.get()),
+                    "io_semaphore": int(self.io_var.get()),
+                    "thread_pool": int(self.thread_var.get())
+                }
+                
+                self.log_message(f"🔄 Đang áp dụng cài đặt...")
+                response = requests.post("http://127.0.0.1:8000/admin/update_settings", json=settings, timeout=5)
+                if response.status_code == 200:
+                    self.log_message(f"✅ Cài đặt đã áp dụng: GPU({settings['gpu_semaphore']}) CPU({settings['cpu_semaphore']}) I/O({settings['io_semaphore']}) Threads({settings['thread_pool']})")
+                    # Update display after a short delay to see the changes
+                    self.root.after(1000, self.update_display)
+                else:
+                    self.log_message(f"❌ Không thể áp dụng cài đặt: {response.text}")
+            except Exception as e:
+                self.log_message(f"❌ Lỗi áp dụng cài đặt: {str(e)}")
+                
+        def update_display(self):
+            import requests
+            try:
+                response = requests.get("http://127.0.0.1:8000/status", timeout=3)
+                if response.status_code == 200:
+                    data = response.json()
+                    
+                    # Update settings display
+                    settings_info = "=== CÀI ĐẶT HIỆN TẠI ===\n"
+                    if 'async_processing' in data:
+                        async_data = data['async_processing']
+                        for resource, info in async_data.items():
+                            available = info.get('available', 0)
+                            max_cap = info.get('max_capacity', 0)
+                            in_use = max(0, max_cap - available)  # Ensure non-negative
+                            settings_info += f"{resource}: {max_cap} max, {in_use} đang dùng\n"
+                    
+                    self.settings_text.config(state="normal")
+                    self.settings_text.delete(1.0, tk.END)
+                    self.settings_text.insert(1.0, settings_info)
+                    self.settings_text.config(state="disabled")
+                    
+                    # Update monitor
+                    monitor_info = f"=== TRẠNG THÁI SERVER ===\n"
+                    monitor_info += f"Cập nhật: {datetime.now().strftime('%H:%M:%S')}\n\n"
+                    
+                    if 'async_processing' in data:
+                        monitor_info += "📊 Tài nguyên Async:\n"
+                        async_data = data['async_processing']
+                        for resource, info in async_data.items():
+                            available = info.get('available', 0)
+                            max_cap = info.get('max_capacity', 1)
+                            in_use = max(0, max_cap - available)
+                            usage_pct = (in_use / max_cap) * 100 if max_cap > 0 else 0
+                            
+                            # Visual progress bar
+                            bar_length = 10
+                            filled = int((usage_pct / 100) * bar_length)
+                            bar = "█" * filled + "░" * (bar_length - filled)
+                            
+                            monitor_info += f"  {resource}: {bar} {usage_pct:.0f}% ({in_use}/{max_cap})\n"
+                    
+                    if 'model_info' in data:
+                        model_info = data['model_info']
+                        monitor_info += f"\n🖥️ Model Info:\n"
+                        monitor_info += f"  Device: {model_info.get('device', 'unknown')}\n"
+                        monitor_info += f"  Cache: {model_info.get('reference_cache_size', 0)} giọng nói\n"
+                        
+                        cached_voices = model_info.get('cached_voices', [])
+                        if cached_voices:
+                            monitor_info += f"  Cached: {', '.join(cached_voices[:3])}"
+                            if len(cached_voices) > 3:
+                                monitor_info += f" (+{len(cached_voices)-3} khác)"
+                            monitor_info += "\n"
+                    
+                    self.monitor_text.config(state="normal")
+                    self.monitor_text.delete(1.0, tk.END)
+                    self.monitor_text.insert(1.0, monitor_info)
+                    self.monitor_text.config(state="disabled")
+                    
+            except Exception:
+                pass  # Ignore errors during startup
+                
+        def log_message(self, message):
+            timestamp = datetime.now().strftime("%H:%M:%S")
+            log_msg = f"[{timestamp}] {message}\n"
+            
+            self.monitor_text.config(state="normal")
+            self.monitor_text.insert(tk.END, log_msg)
+            self.monitor_text.see(tk.END)
+            self.monitor_text.config(state="disabled")
+            
+        def start_monitoring(self):
+            def monitor_loop():
+                while True:
+                    try:
+                        self.update_display()
+                    except:
+                        pass
+                    time.sleep(5)
+                    
+            import threading
+            threading.Thread(target=monitor_loop, daemon=True).start()
+    
+    try:
+        root = tk.Tk()
+        gui = ServerGUI(root)
+        root.mainloop()
+    except Exception as e:
+        print(f"GUI Error: {e}")
+
+if __name__ == "__main__":
+    import uvicorn
+    import threading
+    
+    # Start GUI in separate thread
+    gui_thread = threading.Thread(target=start_gui, daemon=True)
+    gui_thread.start()
+    
+    # Start server
+    uvicorn.run(
+        "tts_server:app",
+        host="127.0.0.1",
+        port=8000,
+        reload=False,
+        log_level="info"
+    )