Upload 7 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+logo.jpg filter=lfs diff=lfs merge=lfs -text

audio_processor.py

@@ -0,0 +1,161 @@
+import os
+import logging
+from typing import List, Optional
+from pydub import AudioSegment
+from pydub.effects import normalize
+import uuid
+
+logger = logging.getLogger(__name__)
+
+class AudioProcessor:
+    def __init__(self):
+        self.supported_formats = ['mp3', 'wav', 'm4a', 'aac', 'ogg']
+    
+    async def combine_audios(
+        self,
+        audio_paths: List[str],
+        background_music_path: Optional[str] = None,
+        output_dir: str = "temp",
+        background_volume: float = 0.3,
+        fade_duration: int = 1000  # milliseconds
+    ) -> str:
+        """
+        Tổng hợp các file audio thành một file duy nhất
+        
+        Args:
+            audio_paths: Danh sách đường dẫn audio các cảnh
+            background_music_path: Đường dẫn nhạc nền (optional)
+            output_dir: Thư mục output
+            background_volume: Âm lượng nhạc nền (0.0 - 1.0)
+            fade_duration: Thời gian fade in/out (ms)
+        
+        Returns:
+            Đường dẫn file audio đã tổng hợp
+        """
+        try:
+            logger.info(f"Bắt đầu tổng hợp {len(audio_paths)} file audio")
+            
+            # Kiểm tra file input
+            valid_audio_paths = []
+            for path in audio_paths:
+                if os.path.exists(path):
+                    valid_audio_paths.append(path)
+                    logger.info(f"Audio hợp lệ: {path}")
+                else:
+                    logger.warning(f"Audio không tồn tại: {path}")
+            
+            if not valid_audio_paths:
+                raise ValueError("Không có file audio hợp lệ nào")
+            
+            # Load và ghép các audio cảnh
+            combined_audio = None
+            total_duration = 0
+            
+            for i, audio_path in enumerate(valid_audio_paths):
+                logger.info(f"Xử lý audio {i+1}/{len(valid_audio_paths)}: {audio_path}")
+                
+                # Load audio với format tự động detect
+                audio_segment = AudioSegment.from_file(audio_path)
+                
+                # Normalize audio
+                audio_segment = normalize(audio_segment)
+                
+                # Thêm fade in/out cho audio đầu và cuối
+                if i == 0:  # Audio đầu tiên
+                    audio_segment = audio_segment.fade_in(fade_duration)
+                if i == len(valid_audio_paths) - 1:  # Audio cuối cùng
+                    audio_segment = audio_segment.fade_out(fade_duration)
+                
+                # Ghép audio
+                if combined_audio is None:
+                    combined_audio = audio_segment
+                else:
+                    combined_audio = combined_audio + audio_segment
+                
+                total_duration += len(audio_segment)
+                logger.info(f"Đã thêm audio {i+1}, tổng thời lượng: {total_duration/1000:.2f}s")
+            
+            logger.info(f"Hoàn thành ghép audio cảnh, tổng thời lượng: {total_duration/1000:.2f}s")
+            
+            # Thêm nhạc nền nếu có
+            if background_music_path and os.path.exists(background_music_path):
+                logger.info("Đang thêm nhạc nền...")
+                
+                # Load nhạc nền
+                background_music = AudioSegment.from_file(background_music_path)
+                
+                # Điều chỉnh âm lượng nhạc nền
+                background_music = background_music - (20 - int(background_volume * 20))  # Giảm dB
+                
+                # Lặp lại nhạc nền nếu cần
+                if len(background_music) < len(combined_audio):
+                    # Tính số lần lặp cần thiết
+                    repeat_times = (len(combined_audio) // len(background_music)) + 1
+                    background_music = background_music * repeat_times
+                
+                # Cắt nhạc nền cho khớp với audio chính
+                background_music = background_music[:len(combined_audio)]
+                
+                # Thêm fade in/out cho nhạc nền
+                background_music = background_music.fade_in(fade_duration * 2).fade_out(fade_duration * 2)
+                
+                # Mix audio chính với nhạc nền
+                combined_audio = combined_audio.overlay(background_music)
+                logger.info("Đã thêm nhạc nền thành công")
+            
+            # Tạo tên file output
+            output_filename = f"combined_audio_{uuid.uuid4().hex[:8]}.wav"
+            output_path = os.path.join(output_dir, output_filename)
+            
+            # Export file kết quả
+            combined_audio.export(
+                output_path,
+                format="wav",
+                parameters=["-ac", "2", "-ar", "44100"]  # Stereo, 44.1kHz
+            )
+            
+            logger.info(f"Đã xuất file audio tổng hợp: {output_path}")
+            logger.info(f"Thời lượng cuối cùng: {len(combined_audio)/1000:.2f}s")
+            
+            return output_path
+            
+        except Exception as e:
+            logger.error(f"Lỗi khi tổng hợp audio: {str(e)}")
+            raise
+    
+    def get_audio_info(self, audio_path: str) -> dict:
+        """
+        Lấy thông tin về file audio
+        """
+        try:
+            audio = AudioSegment.from_file(audio_path)
+            return {
+                "duration_seconds": len(audio) / 1000,
+                "channels": audio.channels,
+                "frame_rate": audio.frame_rate,
+                "sample_width": audio.sample_width,
+                "file_size_mb": os.path.getsize(audio_path) / (1024 * 1024)
+            }
+        except Exception as e:
+            logger.error(f"Lỗi khi lấy thông tin audio {audio_path}: {str(e)}")
+            return {}
+    
+    def validate_audio_file(self, audio_path: str) -> bool:
+        """
+        Kiểm tra tính hợp lệ của file audio
+        """
+        try:
+            if not os.path.exists(audio_path):
+                return False
+            
+            # Kiểm tra extension
+            ext = audio_path.lower().split('.')[-1]
+            if ext not in self.supported_formats:
+                return False
+            
+            # Thử load file
+            AudioSegment.from_file(audio_path)
+            return True
+            
+        except Exception:
+            return False

job_manager.py

@@ -0,0 +1,213 @@
+# job_manager.py
+import json
+import os
+import logging
+from typing import Dict, List, Optional
+from datetime import datetime, timedelta
+import threading
+import time
+import queue
+import asyncio
+
+logger = logging.getLogger(__name__)
+
+class JobManager:
+    def __init__(self, jobs_file: str = "jobs.json"):
+        self.jobs_file = jobs_file
+        self.jobs: Dict = {}
+        self.lock = threading.Lock()
+        
+        # --- Thêm cơ chế save bất đồng bộ ---
+        self._save_queue = queue.Queue()
+        self._save_thread = threading.Thread(target=self._save_worker, daemon=True)
+        self._save_thread.start()
+        self._pending_save = False # Flag để tránh queue quá nhiều save request
+        # ------------------------------------
+
+        # Load existing jobs
+        self._load_jobs()
+        # Cleanup old jobs
+        self._cleanup_old_jobs()
+
+    def _load_jobs(self):
+        """Load jobs từ file"""
+        try:
+            if os.path.exists(self.jobs_file):
+                with open(self.jobs_file, 'r', encoding='utf-8') as f:
+                    self.jobs = json.load(f)
+                logger.info(f"Loaded {len(self.jobs)} jobs from {self.jobs_file}")
+            else:
+                self.jobs = {}
+                logger.info("No existing jobs file, starting fresh")
+        except Exception as e:
+            logger.error(f"Lỗi load jobs: {e}")
+            self.jobs = {}
+
+    def _save_jobs(self):
+        """Save jobs ra file - phiên bản blocking cũ, giờ được gọi bởi worker thread"""
+        try:
+            # logger.info("_save_jobs (blocking version) được gọi bởi worker thread.") # Có thể bật log để debug
+            # Luôn cần lock khi truy cập self.jobs để đọc dữ liệu cần lưu
+            with self.lock:
+                 # Tạo một bản sao dữ liệu để ghi, giảm thời gian giữ lock
+                 jobs_to_save = self.jobs.copy() 
+            # Thực hiện I/O bên ngoài lock để không block các thao tác khác
+            with open(self.jobs_file, 'w', encoding='utf-8') as f:
+                json.dump(jobs_to_save, f, indent=2, ensure_ascii=False)
+            logger.info("Jobs saved to file successfully.")
+        except Exception as e:
+            logger.error(f"Lỗi save jobs: {e}")
+
+    def _request_save(self):
+        """Yêu cầu lưu jobs, nhưng không thực hiện ngay lập tức"""
+        # Tránh việc queue quá nhiều yêu cầu save nếu các thay đổi diễn ra nhanh
+        if not self._pending_save:
+            self._pending_save = True
+            # logger.info("Put save request to queue") # Có thể bật log để debug
+            self._save_queue.put(True) # Gửi tín hiệu yêu cầu save
+
+    def _save_worker(self):
+        """Worker thread để xử lý các yêu cầu save"""
+        while True:
+            try:
+                # Chờ tín hiệu yêu cầu save
+                _ = self._save_queue.get(timeout=1) # Timeout để có thể kiểm tra vòng lặp
+                self._pending_save = False # Reset flag khi bắt đầu xử lý
+                # logger.info("Worker nhận được yêu cầu save, đang thực hiện...") # Có thể bật log để debug
+                self._save_jobs() # Gọi hàm save blocking thực tế
+                self._save_queue.task_done()
+            except queue.Empty:
+                # Timeout, tiếp tục vòng lặp
+                continue
+            except Exception as e:
+                self._pending_save = False # Đảm bảo flag được reset ngay cả khi lỗi
+                logger.error(f"Error in save worker: {e}")
+
+    # --- Các hàm public ---
+    
+    def create_job(self, job_id: str, job_data: Dict):
+        """
+        Tạo job mới - Phiên bản nhanh, không blocking I/O
+        """
+        try:
+            logger.info(f"[{job_id}] create_job được gọi.")
+            with self.lock:
+                logger.info(f"[{job_id}] Đã có lock. Đang thêm job vào bộ nhớ...")
+                self.jobs[job_id] = job_data
+                logger.info(f"[{job_id}] Đã thêm vào bộ nhớ. Đang yêu cầu save (async)...")
+                # Thay vì gọi self._save_jobs() trực tiếp (gây blocking),
+                # ta chỉ yêu cầu worker thread làm điều đó.
+                self._request_save() 
+                # Không đợi save xong, trả về ngay!
+            logger.info(f"[{job_id}] Created job thành công (chưa chắc file đã lưu).")
+        except Exception as e:
+            logger.error(f"[{job_id}] Lỗi create job: {e}", exc_info=True)
+            raise
+
+    def update_job(self, job_id: str, updates: Dict):
+        """
+        Cập nhật job - Phiên bản nhanh, không blocking I/O
+        """
+        try:
+            with self.lock:
+                if job_id in self.jobs:
+                    self.jobs[job_id].update(updates)
+                    self.jobs[job_id]['updated_at'] = datetime.now().isoformat()
+                     # Log progress updates
+                    if 'progress' in updates:
+                        logger.info(f"Job {job_id}: {updates.get('message', '')} ({updates['progress']}%)")
+                    # Yêu cầu save async
+                    logger.info(f"[{job_id}] Đang yêu cầu save update (async)...")
+                    self._request_save()
+                else:
+                    logger.warning(f"Job {job_id} not found for update")
+        except Exception as e:
+            logger.error(f"Lỗi update job {job_id}: {e}")
+
+    def get_job(self, job_id: str) -> Optional[Dict]:
+        """Lấy thông tin job - Vẫn đồng bộ vì cần trả về dữ liệu ngay"""
+        # Truy cập đọc thường không cần lock nếu không có write đồng thời,
+        # nhưng để an toàn và nhất quán, có thể dùng lock.
+        with self.lock:
+            return self.jobs.get(job_id)
+
+    def list_jobs(self, status: Optional[str] = None, limit: int = 20) -> List[Dict]:
+        """Lấy danh sách jobs - Vẫn đồng bộ"""
+        try:
+            with self.lock:
+                jobs_list = list(self.jobs.values()) # Sao chép để an toàn khi sort/filter
+            # Filter by status
+            if status:
+                jobs_list = [job for job in jobs_list if job.get('status') == status]
+            # Sort by created_at desc
+            jobs_list.sort(key=lambda x: x.get('created_at', ''), reverse=True)
+            # Limit results
+            return jobs_list[:limit]
+        except Exception as e:
+            logger.error(f"Lỗi list jobs: {e}")
+            return []
+
+    def delete_job(self, job_id: str) -> bool:
+        """
+        Xóa job - Nhanh, không blocking I/O
+        """
+        try:
+            with self.lock:
+                if job_id in self.jobs:
+                    del self.jobs[job_id]
+                    logger.info(f"Deleted job {job_id} from memory. Đang yêu cầu save (async)...")
+                    self._request_save()
+                    return True
+                return False
+        except Exception as e:
+            logger.error(f"Lỗi delete job {job_id}: {e}")
+            return False
+
+    def _cleanup_old_jobs(self, days_old: int = 7):
+        """Xóa jobs cũ hơn n ngày - Có thể chạy định kỳ hoặc trong init"""
+        try:
+            cutoff_date = datetime.now() - timedelta(days=days_old)
+            jobs_to_remove = []
+            with self.lock: # Lock khi đọc để kiểm tra
+                for job_id, job_data in self.jobs.items():
+                    try:
+                        created_at = datetime.fromisoformat(job_data.get('created_at', ''))
+                        if created_at < cutoff_date:
+                            jobs_to_remove.append(job_id)
+                    except:
+                        jobs_to_remove.append(job_id)
+            
+            if jobs_to_remove:
+                with self.lock: # Lock lại khi xóa
+                    for job_id in jobs_to_remove:
+                         if job_id in self.jobs: # Kiểm tra lại trong lock
+                            del self.jobs[job_id]
+                logger.info(f"Cleaned up {len(jobs_to_remove)} old jobs from memory. Đang yêu cầu save (async)...")
+                self._request_save() # Yêu cầu lưu sau khi xóa
+        except Exception as e:
+            logger.error(f"Lỗi cleanup old jobs: {e}")
+
+    def get_statistics(self) -> Dict:
+        """Lấy thống kê jobs"""
+        try:
+            with self.lock:
+                total_jobs = len(self.jobs)
+                status_counts = {}
+                for job in self.jobs.values():
+                    status = job.get('status', 'unknown')
+                    status_counts[status] = status_counts.get(status, 0) + 1
+            return {
+                "total_jobs": total_jobs,
+                "status_breakdown": status_counts,
+                "last_updated": datetime.now().isoformat()
+            }
+        except Exception as e:
+            logger.error(f"Lỗi get statistics: {e}")
+            return {}
+
+    # --- Thêm phương thức để shutdown worker thread nếu cần ---
+    def shutdown(self):
+        """Dừng worker thread (nếu cần thiết trước khi thoát chương trình)"""
+        # Đơn giản nhất là để daemon thread tự dừng khi chương trình kết thúc.
+        # Hoặc có thể gửi một tín hiệu đặc biệt vào queue để worker thoát.
+        pass

main.py

@@ -0,0 +1,695 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form, BackgroundTasks
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List, Optional, Dict
+import os
+import uuid
+import logging
+from pathlib import Path
+import shutil
+from datetime import datetime
+import asyncio
+import json
+from enum import Enum
+import requests # Thêm import requests
+
+# Import các module tự tạo
+from audio_processor import AudioProcessor
+from source_matcher import SourceMatcher
+from video_generator_module import generate_multiple_video_versions
+from job_manager import JobManager
+
+from dotenv import load_dotenv
+import os   
+# Load biến môi trường từ .env
+load_dotenv()
+hf_token = os.getenv("HF_TOKEN")
+
+# Header với Bearer token
+headers = {
+    "Authorization": f"Bearer {hf_token}"
+}
+
+app = FastAPI(title="Video Generator API", version="1.0.0")
+
+# Cấu hình logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Khởi tạo các processor
+audio_processor = AudioProcessor()
+source_matcher = SourceMatcher(sources_root_dir="public")
+job_manager = JobManager()
+
+# Cấu hình đường dẫn
+TEMP_DIR = "temp"
+OUTPUT_DIR = "generated_video_output"
+UPLOAD_DIR = "uploads"
+PUBLIC_DIR = "public"
+EXTERNAL_AUDIO_DIR = "external_audio" # Thư mục lưu audio tải từ API bên ngoài
+
+
+ALLOWED_REFERENCE_AUDIOS = [
+    "CD team.wav", "nam tre khoe.wav", "nam-calm.wav", "nam-cham.wav",
+    "nam-nhanh.wav", "nam-tai-llieu.wav", "nam-truyen-cam.wav", "Nu nhe nhang.wav",
+    "nu-calm.wav", "nu-cham.wav", "nu-luu-loat.wav", "nu-nhan-nha.wav",
+    "nu-nhe-nhang.wav", "bongda1.wav"
+]
+
+# Hàm hỗ trợ để tạo URL cho file audio tham chiếu (giả định chúng được host trên GitHub hoặc server cục bộ)
+# Bạn cần điều chỉnh BASE_REF_AUDIO_URL cho phù hợp với nơi lưu trữ file của bạn.
+# Ví dụ nếu file nằm trong thư mục public/audio_refs/ thì có thể truy cập qua http://yourdomain.com/public/audio_refs/
+BASE_REF_AUDIO_URL = "https://github.com/TruongSinhAI/vitts/raw/refs/heads/main/" # Cần thay đổi cho phù hợp
+
+
+# Tạo các thư mục cần thiết
+for dir_path in [TEMP_DIR, OUTPUT_DIR, UPLOAD_DIR, PUBLIC_DIR, EXTERNAL_AUDIO_DIR]:
+    os.makedirs(dir_path, exist_ok=True)
+
+class JobStatus(str, Enum):
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+# Cập nhật SceneData để nhận text thay vì audio_path trực tiếp
+class SceneData(BaseModel):
+    # Ưu tiên sử dụng 'text' để tạo audio. Nếu 'text' trống, có thể dùng 'audio_path' (tùy chọn).
+    text: str
+    keywords: List[str]
+    # Giữ lại audio_path để tương thích ngược (tùy chọn)
+    audio_path: Optional[str] = None
+
+class VideoRequest(BaseModel):
+    title: str
+    scenes: List[SceneData]
+    background_music_path: Optional[str] = None
+    thumbnail_path: Optional[str] = "thumbnails/thumbnail1.png"
+    logo_path: Optional[str] = ''
+    aspect_ratio: str = "doc"
+    num_versions: int = 1
+    target_height: int = 1080
+    reference_audio_file: Optional[str] = "https://github.com/TruongSinhAI/vitts/raw/refs/heads/main/bongda1.wav"
+
+ # Tên file trong danh sách được liệt kê, ví dụ: "bongda1.wav"
+
+class JobResponse(BaseModel):
+    job_id: str
+    status: JobStatus
+    message: str
+    progress: int = 0
+    estimated_time_remaining: Optional[int] = None
+    created_at: str
+    video_paths: Optional[List[str]] = None
+    error: Optional[str] = None
+
+# --- Hàm mới để gọi API chuyển text thành audio ---
+import json # Đảm bảo import json
+
+async def text_to_audio(text: str, language: str = "vi", job_id: str = "unknown", reference_audio_file: Optional[str] = "https://github.com/TruongSinhAI/vitts/raw/refs/heads/main/bongda1.wav") -> str:
+    """Gọi API Hugging Face để chuyển text thành audio và lưu file tạm."""
+    try:
+        logger.info(f"[Job {job_id}] Chuyển text sang audio: '{text[:50]}...'")
+
+        # Payload gửi đi (giữ nguyên như cũ)
+        payload = {
+            "data": [
+                text,
+                language,
+                {"path": reference_audio_file},
+                True
+            ]
+        }
+
+        # Gửi yêu cầu
+        # Cập nhật URL API
+        r = requests.post("https://thinhlpg-vixtts-demo.hf.space/call/predict", headers=headers,json=payload)
+        r.raise_for_status()
+        event_id = r.json().get("event_id")
+        if not event_id:
+             raise Exception("Không nhận được event_id từ API Hugging Face.")
+
+        logger.info(f"[Job {job_id}] Nhận được event_id: {event_id}")
+
+        # Chờ kết quả - Cập nhật URL
+        result_url = f"https://thinhlpg-vixtts-demo.hf.space/call/predict/{event_id}"
+
+        # --- Sử dụng phương thức lấy kết quả mới ---
+        response = requests.get(result_url,headers=headers, stream=True)
+        response.raise_for_status() # Kiểm tra lỗi HTTP sớm
+
+        result_line = '' # Biến lưu dòng kết quả cuối cùng
+        # Lấy kết quả - Lặp qua từng dòng
+        for line in response.iter_lines():
+            if line:
+                decoded_line = line.decode('utf-8')
+                logger.debug(f"[Job {job_id}] Dòng phản hồi từ API: {decoded_line}")
+                result_line = decoded_line # Cập nhật dòng kết quả
+
+        if not result_line:
+            raise Exception("Không nhận được dữ liệu từ phản hồi API.")
+
+        logger.info(f"[Job {job_id}] Dữ liệu phản hồi cuối cùng: {result_line}")
+
+        # --- Phân tích phản hồi để lấy URL ---
+        # Giả định result_line chứa JSON hợp lệ
+        try:
+            audio_url = result_line.split('"url": "')[1].split('",')[0].replace("/c/file", "/file")
+            if not audio_url:
+                 # Nếu không tìm thấy theo cách trên, thử phân tích chuỗi như trong ví dụ của bạn
+                 # (Đây là cách fallback kém ổn định hơn)
+                 if '"url": "' in result_line:
+                     audio_url = result_line.split('"url": "')[1].split('",')[0]
+                     # Xử lý URL nếu cần (ví dụ: thay thế path)
+                     audio_url = audio_url.replace("/c/file", "/file")
+                 else:
+                     raise Exception("Không tìm thấy URL audio trong phản hồi.")
+        except json.JSONDecodeError:
+            # Nếu JSON không hợp lệ, thử phân tích chuỗi như ví dụ
+            logger.warning(f"[Job {job_id}] Phản hồi không phải JSON hợp lệ, thử phân tích chuỗi...")
+            if '"url": "' in result_line:
+                 audio_url = result_line.split('"url": "')[1].split('",')[0]
+                 audio_url = audio_url.replace("/c/file", "/file") # Xử lý URL
+            else:
+                 raise Exception("Phản hồi không hợp lệ và không thể trích xuất URL.")
+        # --- Kết thúc phân tích phản hồi ---
+
+        if not audio_url:
+            raise Exception("Không thể xác định URL audio từ phản hồi API.")
+
+        logger.info(f"[Job {job_id}] URL audio: {audio_url}")
+
+        # --- Tải audio về ---
+        # Tải audio (sử dụng audio_url đã xử lý)
+        audio_response = requests.get(audio_url, stream=True)
+        audio_response.raise_for_status()
+
+        # Tạo tên file duy nhất trong thư mục EXTERNAL_AUDIO_DIR
+        audio_filename = f"audio_{job_id}_{uuid.uuid4().hex[:8]}.wav"
+        audio_path = os.path.join(EXTERNAL_AUDIO_DIR, audio_filename) # Sử dụng EXTERNAL_AUDIO_DIR
+
+        with open(audio_path, "wb") as f:
+            for chunk in audio_response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+        logger.info(f"[Job {job_id}] Đã tải audio về: {audio_path}")
+        return audio_path
+        # --- Kết thúc tải audio ---
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"[Job {job_id}] Lỗi mạng khi gọi API Hugging Face: {e}")
+        raise Exception(f"Lỗi mạng khi gọi API chuyển text sang audio: {e}")
+    except Exception as e:
+        logger.error(f"[Job {job_id}] Lỗi khi chuyển text sang audio: {e}")
+        raise e # Ném lại lỗi để xử lý ở cấp cao hơn
+
+
+
+# Hàm nền để chạy async task trong executor nếu cần
+def generate_video_background_wrapper(job_id: str, request: VideoRequest):
+    import asyncio
+    asyncio.run(generate_video_background(job_id, request))
+
+async def generate_video_background(job_id: str, request: VideoRequest):
+    """
+    Background task để tạo video
+    """
+    try:
+        # Cập nhật status thành processing
+        job_manager.update_job(job_id, {
+            "status": JobStatus.PROCESSING,
+            "message": "Bắt đầu xử lý video...",
+            "progress": 0
+        })
+        temp_request_dir = os.path.join(TEMP_DIR, job_id)
+        os.makedirs(temp_request_dir, exist_ok=True)
+        logger.info(f"Background job {job_id}: Bắt đầu xử lý")
+
+        # --- Bước 0: Gộp tất cả text và keywords từ các scene ---
+        job_manager.update_job(job_id, {
+            "message": "Đang gộp nội dung từ các scene...",
+            "progress": 2,
+            "estimated_time_remaining": 600
+        })
+
+        # Gộp tất cả text từ các scene
+        combined_text_parts = []
+        all_keywords = []
+        
+        for i, scene in enumerate(request.scenes):
+            if scene.text.strip():
+                combined_text_parts.append(scene.text.strip())
+            # Gộp tất cả keywords
+            all_keywords.extend(scene.keywords)
+        
+        # Kiểm tra có text để xử lý không
+        if not combined_text_parts:
+            raise ValueError("Không có text nào để chuyển thành audio từ tất cả các scene")
+        
+        # Gộp text thành một đoạn dài, ngăn cách bằng dấu chấm và khoảng trống
+        combined_text = ". ".join(combined_text_parts)
+        
+        # Loại bỏ keywords trùng lặp và giữ thứ tự
+        unique_keywords = list(dict.fromkeys(all_keywords))  # Removes duplicates while preserving order
+        
+        logger.info(f"[Job {job_id}] Đã gộp text từ {len(request.scenes)} scene(s): '{combined_text[:100]}...'")
+        logger.info(f"[Job {job_id}] Đã gộp {len(unique_keywords)} keywords duy nhất: {unique_keywords[:10]}...")
+
+        # --- Bước 1: Chuyển text gộp thành audio (một lần duy nhất) ---
+        job_manager.update_job(job_id, {
+            "message": "Đang chuyển text gộp thành audio...",
+            "progress": 5,
+            "estimated_time_remaining": 580
+        })
+
+        # Gọi hàm async để chuyển text gộp thành audio
+        combined_audio_path = await text_to_audio(
+            combined_text,
+            language="vi",
+            job_id=job_id,
+            reference_audio_file=request.reference_audio_file # Truyền tham số mới
+        )
+        temp_audio_files = [combined_audio_path]
+
+        # --- Bước 2: Tổng hợp audio với background music (nếu có) ---
+        job_manager.update_job(job_id, {
+            "message": "Đang tổng hợp audio với nhạc nền...",
+            "progress": 15,
+            "estimated_time_remaining": 480
+        })
+        
+        # Nếu có background music, combine với audio đã tạo
+        if request.background_music_path:
+            final_audio_path = await audio_processor.combine_audios(
+                audio_paths=[combined_audio_path],
+                background_music_path=request.background_music_path,
+                output_dir=temp_request_dir
+            )
+        else:
+            # Nếu không có background music, sử dụng audio gốc
+            final_audio_path = combined_audio_path
+
+        # --- Bước 3: Tìm source media (40% progress) ---
+        job_manager.update_job(job_id, {
+            "message": "Đang tìm source media phù hợp...",
+            "progress": 30,
+            "estimated_time_remaining": 420
+        })
+        
+        # Sử dụng keywords đã gộp để tìm source media
+        source_media_paths = await source_matcher.find_matching_sources(
+            keywords=unique_keywords,
+            title=request.title
+        )
+        if not source_media_paths:
+            source_media_paths = source_matcher.get_fallback_sources()
+
+        if not source_media_paths:
+            raise ValueError("Không tìm thấy source media nào")
+
+        # --- Bước 4: Tạo video (60% - 100% progress) ---
+        job_manager.update_job(job_id, {
+            "message": "Đang tạo video... (có thể mất 5-8 phút)",
+            "progress": 50,
+            "estimated_time_remaining": 300
+        })
+        current_date = datetime.now().strftime("%Y-%m-%d")
+        
+        # Tạo video với progress callback
+        def progress_callback(current_step: int, total_steps: int):
+            progress = 50 + int((current_step / total_steps) * 50)
+            remaining_time = max(0, int((total_steps - current_step) * 30))  # Ước tính 30s/step
+            job_manager.update_job(job_id, {
+                "message": f"Đang render video... ({current_step}/{total_steps})",
+                "progress": progress,
+                "estimated_time_remaining": remaining_time
+            })
+
+        # Giả sử generate_multiple_video_versions là blocking
+        # Cần chạy trong executor để không block event loop
+        loop = asyncio.get_event_loop()
+        video_paths = await loop.run_in_executor(
+            None, # Sử dụng default executor (ThreadPoolExecutor)
+            generate_multiple_video_versions,
+            final_audio_path,  # Sử dụng audio đã combine
+            source_media_paths,
+            request.aspect_ratio,
+            request.num_versions,
+            f"video_{job_id}",
+            OUTPUT_DIR,
+            request.target_height,
+            request.thumbnail_path,
+            request.logo_path,
+            request.title,
+            current_date
+        )
+
+        # Hoàn thành (100%)
+        job_manager.update_job(job_id, {
+            "status": JobStatus.COMPLETED,
+            "message": "Tạo video thành công!",
+            "progress": 100,
+            "estimated_time_remaining": 0,
+            "video_paths": video_paths,
+            "completed_at": datetime.now().isoformat(),
+            "processing_summary": {
+                "total_scenes": len(request.scenes),
+                "combined_text_length": len(combined_text),
+                "unique_keywords_count": len(unique_keywords),
+                "audio_file": os.path.basename(final_audio_path)
+            }
+        })
+
+         # Cleanup temp files
+        shutil.rmtree(temp_request_dir, ignore_errors=True)
+        # Cleanup temp audio files (nếu có)
+        for temp_audio_file in temp_audio_files:
+             try:
+                 os.remove(temp_audio_file)
+                 logger.info(f"[Job {job_id}] Đã xóa file audio tạm: {temp_audio_file}")
+             except OSError as e:
+                 logger.warning(f"[Job {job_id}] Không thể xóa file audio tạm {temp_audio_file}: {e}")
+        logger.info(f"Background job {job_id}: Hoàn thành thành công với {len(request.scenes)} scene(s) được gộp")
+    except Exception as e:
+        error_msg = str(e)
+        logger.error(f"Background job {job_id} failed: {error_msg}")
+        job_manager.update_job(job_id, {
+            "status": JobStatus.FAILED,
+            "message": f"Lỗi tạo video: {error_msg}",
+            "progress": 0,
+            "error": error_msg,
+            "failed_at": datetime.now().isoformat()
+        })
+        # Cleanup on error
+        temp_request_dir = os.path.join(TEMP_DIR, job_id)
+        if os.path.exists(temp_request_dir):
+            shutil.rmtree(temp_request_dir, ignore_errors=True)
+        # Cleanup temp audio files on error (nếu có)
+        if 'temp_audio_files' in locals():
+            for temp_audio_file in temp_audio_files:
+                 try:
+                     os.remove(temp_audio_file)
+                     logger.info(f"[Job {job_id}] Đã xóa file audio tạm do lỗi: {temp_audio_file}")
+                 except OSError as e:
+                     logger.warning(f"[Job {job_id}] Không thể xóa file audio tạm do lỗi {temp_audio_file}: {e}")
+
+# Trong /generate-video endpoint
+@app.post("/generate-video", response_model=JobResponse)
+async def generate_video(request: VideoRequest, background_tasks: BackgroundTasks):
+    """
+    Tạo video từ title, text các cảnh, keywords và nhạc nền (Async)
+    Gộp tất cả text và keywords từ các scene để xử lý một lần
+    Trả về job_id để tracking progress
+    """
+    job_id = None # Khai báo trước để có thể dùng trong except
+    try:
+        # Tạo job ID
+        job_id = str(uuid.uuid4())
+        logger.info(f"[{job_id}] Bắt đầu tạo job với {len(request.scenes)} scene(s)")
+        
+        # Tạo job record với thông tin gộp
+        job_data = {
+            "job_id": job_id,
+            "status": JobStatus.PENDING,
+            "message": f"Job đã được tạo, đang chờ xử lý {len(request.scenes)} scene(s)...",
+            "progress": 0,
+            "created_at": datetime.now().isoformat(),
+            "request_data": request.model_dump(),
+            "estimated_time_remaining": 600,  # 10 phút
+            "scenes_count": len(request.scenes)
+        }
+        logger.info(f"[{job_id}] Dữ liệu job: {job_data}")
+        
+        # --- Thêm log trước và sau create_job ---
+        logger.info(f"[{job_id}] Đang gọi job_manager.create_job...")
+        job_manager.create_job(job_id, job_data)
+        logger.info(f"[{job_id}] job_manager.create_job hoàn tất.")
+        
+        # --- Thêm log trước và sau add_task ---
+        logger.info(f"[{job_id}] Đang thêm background task...")
+        background_tasks.add_task(generate_video_background, job_id, request)
+        logger.info(f"[{job_id}] Background task đã được thêm.")
+        
+        # --- Thêm log trước khi tạo response ---
+        logger.info(f"[{job_id}] Đang chuẩn bị JobResponse...")
+        response = JobResponse(
+            job_id=job_id,
+            status=JobStatus.PENDING,
+            message=f"Video đang được xử lý từ {len(request.scenes)} scene(s). Sử dụng job_id để kiểm tra tiến độ.",
+            progress=0,
+            estimated_time_remaining=600,
+            created_at=job_data["created_at"]
+        )
+        logger.info(f"[{job_id}] JobResponse đã được tạo: {response}")
+        logger.info(f"[{job_id}] Trả về phản hồi thành công.")
+        return response
+    except Exception as e:
+        error_msg = f"Lỗi tạo job {job_id if job_id else 'unknown'}: {str(e)}"
+        logger.error(error_msg)
+        raise HTTPException(status_code=500, detail=error_msg)
+
+@app.get("/job-status/{job_id}", response_model=JobResponse)
+async def get_job_status(job_id: str):
+    """
+    Kiểm tra trạng thái job
+    """
+    try:
+        job_data = job_manager.get_job(job_id)
+        if not job_data:
+            raise HTTPException(status_code=404, detail="Job không tồn tại")
+        return JobResponse(**job_data)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Lỗi lấy job status: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Lỗi lấy job status: {str(e)}")
+
+@app.get("/jobs")
+async def list_jobs(status: Optional[JobStatus] = None, limit: int = 20):
+    """
+    Lấy danh sách jobs
+    """
+    try:
+        jobs = job_manager.list_jobs(status=status, limit=limit)
+        return {
+            "success": True,
+            "jobs": jobs,
+            "total": len(jobs)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi lấy danh sách jobs: {str(e)}")
+
+@app.delete("/job/{job_id}")
+async def cancel_job(job_id: str):
+    """
+    Hủy job (chỉ work với job pending/processing)
+    """
+    try:
+        job_data = job_manager.get_job(job_id)
+        if not job_data:
+            raise HTTPException(status_code=404, detail="Job không tồn tại")
+        if job_data["status"] in [JobStatus.COMPLETED, JobStatus.FAILED]:
+            raise HTTPException(status_code=400, detail="Không thể hủy job đã hoàn thành/thất bại")
+
+        # Ghi chú: Việc hủy thực sự task đang chạy trong background khó thực hiện trong Python.
+        # Việc cập nhật trạng thái là cách tiếp cận phổ biến.
+        job_manager.update_job(job_id, {
+            "status": JobStatus.FAILED,
+            "message": "Job đã bị hủy bởi user",
+            "cancelled_at": datetime.now().isoformat()
+        })
+        return {"success": True, "message": "Job đã được đánh dấu là hủy"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi hủy job: {str(e)}")
+
+@app.post("/upload-audio")
+async def upload_audio(file: UploadFile = File(...)):
+    """
+    Upload file audio cho từng cảnh
+    """
+    try:
+        if not file.filename.lower().endswith(('.mp3', '.wav', '.m4a', '.aac', '.ogg')):
+            raise HTTPException(status_code=400, detail="Chỉ hỗ trợ file audio: mp3, wav, m4a, aac, ogg")
+        file_id = str(uuid.uuid4())
+        file_extension = os.path.splitext(file.filename)[1]
+        saved_filename = f"audio_{file_id}{file_extension}"
+        saved_path = os.path.join(UPLOAD_DIR, saved_filename)
+        with open(saved_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        audio_info = audio_processor.get_audio_info(saved_path)
+        return {
+            "success": True,
+            "filename": saved_filename,
+            "path": saved_path,
+            "original_name": file.filename,
+            "audio_info": audio_info
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi upload audio: {str(e)}")
+
+@app.post("/upload-source")
+async def upload_source(
+    file: UploadFile = File(...),
+    folder: str = Form("general")  # Thư mục con trong public, mặc định là "general"
+):
+    """
+    Upload source media vào thư mục public
+    """
+    try:
+        # Validate file extension
+        allowed_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.mp4', '.avi', '.mov', '.mkv'}
+        file_extension = os.path.splitext(file.filename)[1].lower()
+        if file_extension not in allowed_extensions:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Chỉ hỗ trợ file: {', '.join(allowed_extensions)}"
+            )
+        # Tạo thư mục đích trong public
+        target_folder = os.path.join(PUBLIC_DIR, folder)
+        os.makedirs(target_folder, exist_ok=True)
+        # Tạo tên file duy nhất
+        file_id = str(uuid.uuid4())
+        saved_filename = f"source_{file_id}{file_extension}"
+        saved_path = os.path.join(target_folder, saved_filename)
+        # Lưu file
+        with open(saved_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        # Refresh source matcher để nhận file mới
+        source_matcher.refresh_sources()
+        return {
+            "success": True,
+            "filename": saved_filename,
+            "path": saved_path,
+            "folder": folder,
+            "original_name": file.filename,
+            "file_size_mb": round(os.path.getsize(saved_path) / (1024 * 1024), 2),
+            "message": f"File đã được upload vào thư mục '{folder}' trong public"
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi upload source: {str(e)}")
+
+@app.get("/download-video/{filename}")
+async def download_video(filename: str):
+    """
+    Download video đã tạo
+    """
+    filename = filename.split('/')[-1]
+    logger.info(f"Filename: {filename}")
+    file_path = os.path.join(OUTPUT_DIR, filename)
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File không tồn tại")
+    return FileResponse(
+        path=file_path,
+        filename=filename,
+        media_type='video/mp4'
+    )
+
+@app.get("/download-video/generated_video_output/{filename}")
+async def download_video(filename: str):
+    """
+    Download video đã tạo
+    """
+
+    file_path = os.path.join(OUTPUT_DIR, filename)
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail="File không tồn tại")
+    return FileResponse(
+        path=file_path,
+        filename=filename,
+        media_type='video/mp4'
+    )
+
+@app.get("/available-sources")
+async def get_available_sources():
+    """
+    Lấy danh sách các source folder có sẵn trong public
+    """
+    try:
+        sources = await source_matcher.get_available_sources()
+        return {
+            "success": True,
+            "public_folder": PUBLIC_DIR,
+            "sources": sources
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi lấy danh sách sources: {str(e)}")
+
+@app.post("/scan-sources")
+async def scan_sources():
+    """
+    Rescan folder public để cập nhật danh sách sources
+    """
+    try:
+        source_matcher.refresh_sources()
+        sources = await source_matcher.get_available_sources()
+        return {
+            "success": True,
+            "message": "Đã quét lại folder public",
+            "sources": sources
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Lỗi scan sources: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """
+    Health check endpoint
+    """
+    return {
+        "status": "healthy",
+        "message": "Video Generator API is running",
+        "timestamp": datetime.now().isoformat(),
+        "public_folder": PUBLIC_DIR,
+        "sources_count": len(source_matcher.sources_cache),
+        "active_jobs": len([j for j in job_manager.list_jobs() if j["status"] == JobStatus.PROCESSING])
+    }
+
+# Cập nhật lại endpoint root để phản ánh thay đổi
+@app.get("/")
+async def root():
+    """
+    Root endpoint với thông tin API
+    """
+    return {
+        "message": "Video Generator API with Async Job Queue",
+        "version": "2.2.0", # Cập nhật phiên bản
+        "user": "vegasansaul23",
+        "features": [
+            "Async video generation",
+            "Job progress tracking",
+            "Background processing",
+            "Real-time status updates",
+            "Text-to-Audio conversion (via Hugging Face API)",
+            "Combined scene processing - gộp tất cả text và keywords"
+        ],
+        "endpoints": {
+            "docs": "/docs",
+            "generate_video": "/generate-video",
+            "job_status": "/job-status/{job_id}",
+            "jobs": "/jobs",
+            "cancel_job": "/job/{job_id}",
+            "upload_audio": "/upload-audio",
+            "upload_source": "/upload-source",
+            "available_sources": "/available-sources",
+            "download": "/download-video/{filename}"
+        },
+        "processing_info": {
+            "text_processing": "Gộp tất cả text từ các scene thành 1 đoạn",
+            "keyword_processing": "Gộp và loại bỏ keywords trùng lặp",
+            "audio_generation": "Tạo audio một lần duy nhất từ text gộp"
+        },
+        "timestamp": datetime.now().isoformat()
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info("Starting Video Generator API with Combined Scene Processing...")
+    logger.info(f"Public folder: {PUBLIC_DIR}")
+    logger.info(f"Output folder: {OUTPUT_DIR}")
+    logger.info(f"External Audio folder: {EXTERNAL_AUDIO_DIR}")
+    uvicorn.run(app, host="0.0.0.0", port=8000, timeout_keep_alive=30)

requirements.txt

@@ -0,0 +1 @@
+change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})

source_matcher.py

@@ -0,0 +1,365 @@
+import os
+import logging
+from typing import List, Dict
+import google.generativeai as genai
+from pathlib import Path
+import json
+import asyncio
+import random
+
+logger = logging.getLogger(__name__)
+
+class SourceMatcher:
+    def __init__(self, api_key: str = None, sources_root_dir: str = "public"):
+        """
+        Khởi tạo SourceMatcher
+        
+        Args:
+            api_key: Gemini API key (nếu không có sẽ lấy từ env)
+            sources_root_dir: Thư mục gốc chứa các source folder (mặc định: public)
+        """
+        # Cấu hình Gemini AI
+        if api_key:
+            genai.configure(api_key=api_key)
+        else:
+            # Lấy từ environment variable
+            api_key = os.getenv('GEMINI_API_KEY')
+            if api_key:
+                genai.configure(api_key=api_key)
+                self.model = genai.GenerativeModel('gemini-pro')
+                self.use_ai = True
+                logger.info("Gemini AI được kích hoạt")
+            else:
+                logger.warning("GEMINI_API_KEY không được cung cấp, sử dụng keyword matching đơn giản")
+                self.model = None
+                self.use_ai = False
+        
+        self.sources_root_dir = sources_root_dir
+        self.sources_cache = {}
+        
+        # Tạo folder public nếu chưa có
+        os.makedirs(self.sources_root_dir, exist_ok=True)
+        
+        # Scan available sources
+        self._scan_sources()
+    
+    def _scan_sources(self):
+        """
+        Scan tất cả các folder source có sẵn trong public
+        """
+        try:
+            self.sources_cache = {}
+            
+            if not os.path.exists(self.sources_root_dir):
+                logger.warning(f"Thư mục sources không tồn tại: {self.sources_root_dir}")
+                os.makedirs(self.sources_root_dir, exist_ok=True)
+                return
+            
+            logger.info(f"Đang scan folder: {self.sources_root_dir}")
+            
+            for item in os.listdir(self.sources_root_dir):
+                item_path = os.path.join(self.sources_root_dir, item)
+                
+                if os.path.isdir(item_path):
+                    # Tìm các file media trong folder
+                    media_files = []
+                    
+                    # Kiểm tra subfolder 'media'
+                    media_folder = os.path.join(item_path, "media")
+                    if os.path.exists(media_folder):
+                        for file in os.listdir(media_folder):
+                            file_path = os.path.join(media_folder, file)
+                            if os.path.isfile(file_path) and self._is_media_file(file_path):
+                                media_files.append(file_path)
+                    
+                    # Tìm media files trực tiếp trong folder chính
+                    for file in os.listdir(item_path):
+                        file_path = os.path.join(item_path, file)
+                        if os.path.isfile(file_path) and self._is_media_file(file_path):
+                            media_files.append(file_path)
+                    
+                    if media_files:
+                        self.sources_cache[item] = {
+                            "folder_name": item,
+                            "folder_path": item_path,
+                            "media_files": media_files,
+                            "media_count": len(media_files)
+                        }
+                        logger.info(f"✓ Tìm thấy source: {item} ({len(media_files)} media files)")
+                    else:
+                        logger.info(f"✗ Folder trống hoặc không có media: {item}")
+            
+            logger.info(f"Tổng cộng {len(self.sources_cache)} source folders có media")
+            
+            # Log chi tiết các folder được tìm thấy
+            if self.sources_cache:
+                logger.info("Chi tiết sources:")
+                for folder_name, data in self.sources_cache.items():
+                    logger.info(f"  - {folder_name}: {data['media_count']} files")
+            
+        except Exception as e:
+            logger.error(f"Lỗi khi scan sources: {str(e)}")
+    
+    def _is_media_file(self, file_path: str) -> bool:
+        """
+        Kiểm tra xem file có phải là media không
+        """
+        media_extensions = [
+            # Video formats
+            '.mp4', '.mov', '.avi', '.mkv', '.webm', '.flv', '.wmv', '.m4v',
+            # Image formats  
+            '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff', '.tif'
+        ]
+        
+        return any(file_path.lower().endswith(ext) for ext in media_extensions)
+    
+    async def find_matching_sources(
+        self, 
+        keywords: List[str], 
+        title: str = "",
+        max_sources: int = 15
+    ) -> List[str]:
+        """
+        Tìm các source media phù hợp với keywords
+        
+        Args:
+            keywords: Danh sách keywords
+            title: Tiêu đề video (optional)
+            max_sources: Số lượng source tối đa
+        
+        Returns:
+            Danh sách đường dẫn các file media phù hợp
+        """
+        try:
+            if not self.sources_cache:
+                logger.warning("Không có source nào available trong folder public")
+                return []
+            
+            logger.info(f"Tìm kiếm sources cho keywords: {keywords}")
+            logger.info(f"Title: {title}")
+            
+            if self.use_ai and self.model:
+                # Sử dụng Gemini AI
+                selected_folders = await self._ai_matching(keywords, title, max_sources)
+            else:
+                # Sử dụng keyword matching đơn giản
+                selected_folders = self._simple_keyword_matching(keywords, title)
+            
+            # Lấy media files từ các folder đã chọn
+            selected_media_files = []
+            
+            for folder_info in selected_folders:
+                folder_name = folder_info.get('folder_name', '')
+                
+                if folder_name in self.sources_cache:
+                    folder_data = self.sources_cache[folder_name]
+                    folder_files = folder_data['media_files']
+                    
+                    # Shuffle để tạo sự ngẫu nhiên
+                    random.shuffle(folder_files)
+                    selected_media_files.extend(folder_files)
+                    
+                    logger.info(
+                        f"✓ Selected folder: {folder_name} "
+                        f"(score: {folder_info.get('relevance_score', 'N/A'):.2f}) "
+                        f"- {len(folder_files)} files"
+                    )
+                else:
+                    logger.warning(f"✗ Folder không tồn tại trong cache: {folder_name}")
+            
+            # Shuffle toàn bộ danh sách để tạo sự đa dạng
+            random.shuffle(selected_media_files)
+            
+            # Giới hạn số lượng files
+            if len(selected_media_files) > max_sources * 5:
+                selected_media_files = selected_media_files[:max_sources * 5]
+            
+            logger.info(f"Tổng cộng {len(selected_media_files)} media files được chọn")
+            
+            return selected_media_files
+            
+        except Exception as e:
+            logger.error(f"Lỗi khi tìm matching sources: {str(e)}")
+            return self.get_fallback_sources()
+    
+    async def _ai_matching(self, keywords: List[str], title: str, max_sources: int) -> List[Dict]:
+        """
+        Sử dụng Gemini AI để matching
+        """
+        try:
+            source_names = list(self.sources_cache.keys())
+            
+            prompt = f"""
+Bạn là một AI chuyên phân tích và matching nội dung video cho người Việt Nam.
+
+NHIỆM VỤ: Tìm các folder source phù hợp nhất với keywords và title đã cho.
+
+THÔNG TIN INPUT:
+- Title: "{title}"
+- Keywords: {keywords}
+
+CÁC FOLDER SOURCE AVAILABLE trong thư mục public:
+{json.dumps(source_names, ensure_ascii=False, indent=2)}
+
+YÊU CẦU:
+1. Phân tích semantic meaning của title và keywords (hỗ trợ tiếng Việt)
+2. So sánh với tên các folder source
+3. Chọn tối đa {max_sources} folder phù hợp nhất
+4. Sắp xếp theo độ phù hợp (cao nhất trước)
+5. Ưu tiên folder có tên chứa keywords hoặc có ý nghĩa tương tự
+6. Xem xét cả từ khóa tiếng Việt và tiếng Anh
+
+Trả về CHÍNH XÁC theo format JSON sau:
+
+{{
+    "analysis": "Phân tích ngắn gọn về sự phù hợp",
+    "selected_folders": [
+        {{
+            "folder_name": "tên_folder_chính_xác_từ_danh_sách",
+            "relevance_score": 0.95,
+            "reason": "Lý do chọn folder này"
+        }}
+    ]
+}}
+
+LưU Ý:
+- CHỈ chọn folder names CÓ TRONG danh sách available ở trên
+- Relevance score từ 0.0 đến 1.0
+- Không tạo ra tên folder mới
+- Ưu tiên folders liên quan đến chủ đề
+"""
+            
+            logger.info("Đang phân tích sources với Gemini AI...")
+            
+            # Gọi Gemini API
+            response = self.model.generate_content(prompt)
+            response_text = response.text.strip()
+            
+            logger.info(f"Gemini response: {response_text[:200]}...")
+            
+            # Parse JSON response
+            try:
+                # Tìm và extract JSON từ response
+                start_idx = response_text.find('{')
+                end_idx = response_text.rfind('}') + 1
+                
+                if start_idx >= 0 and end_idx > start_idx:
+                    json_str = response_text[start_idx:end_idx]
+                    result = json.loads(json_str)
+                    selected_folders = result.get('selected_folders', [])
+                    
+                    logger.info(f"Gemini analysis: {result.get('analysis', 'No analysis')}")
+                    return selected_folders
+                else:
+                    raise ValueError("Không tìm thấy JSON trong response")
+                
+            except (json.JSONDecodeError, ValueError) as e:
+                logger.error(f"Lỗi parse JSON từ Gemini: {e}")
+                logger.info("Fallback to simple keyword matching")
+                return self._simple_keyword_matching(keywords, title)
+                
+        except Exception as e:
+            logger.error(f"Lỗi Gemini AI: {str(e)}")
+            return self._simple_keyword_matching(keywords, title)
+    
+    def _simple_keyword_matching(self, keywords: List[str], title: str) -> List[Dict]:
+        """
+        Fallback method: keyword matching đơn giản
+        """
+        logger.info("Sử dụng simple keyword matching...")
+        
+        all_text_lower = " ".join(keywords + [title]).lower()
+        matches = []
+        
+        for folder_name, folder_data in self.sources_cache.items():
+            folder_name_lower = folder_name.lower()
+            
+            # Tính score dựa trên số keywords match
+            score = 0
+            match_reasons = []
+            
+            # Kiểm tra từng keyword
+            for keyword in keywords:
+                keyword_lower = keyword.lower()
+                if keyword_lower in folder_name_lower:
+                    score += 0.4
+                    match_reasons.append(f"keyword '{keyword}'")
+            
+            # Kiểm tra title
+            if title and title.lower() in folder_name_lower:
+                score += 0.3
+                match_reasons.append("title")
+            
+            # Kiểm tra các từ phổ biến
+            common_terms = {
+                'sport': ['sport', 'thể thao', 'bóng đá', 'football'],
+                'news': ['news', 'tin tức', 'báo'],
+                'u23': ['u23', 'đội tuyển'],
+                'vietnam': ['vietnam', 'việt nam', 'vn'],
+                'music': ['music', 'nhạc', 'âm nhạc']
+            }
+            
+            for category, terms in common_terms.items():
+                for term in terms:
+                    if term in all_text_lower and term in folder_name_lower:
+                        score += 0.2
+                        match_reasons.append(f"{category} term")
+                        break
+            
+            if score > 0:
+                matches.append({
+                    "folder_name": folder_name,
+                    "relevance_score": min(score, 1.0),
+                    "reason": f"Keyword matching: {', '.join(match_reasons)}"
+                })
+        
+        # Sắp xếp theo score
+        matches.sort(key=lambda x: x['relevance_score'], reverse=True)
+        
+        logger.info(f"Simple matching found {len(matches)} relevant folders")
+        return matches[:10]  # Top 10
+    
+    def get_fallback_sources(self, max_files: int = 20) -> List[str]:
+        """
+        Lấy một số source ngẫu nhiên làm fallback
+        """
+        logger.info("Sử dụng fallback sources...")
+        
+        all_files = []
+        for folder_data in self.sources_cache.values():
+            all_files.extend(folder_data['media_files'])
+        
+        if all_files:
+            random.shuffle(all_files)
+            selected = all_files[:max_files]
+            logger.info(f"Fallback: chọn {len(selected)} files ngẫu nhiên")
+            return selected
+        
+        return []
+    
+    async def get_available_sources(self) -> Dict:
+        """
+        Lấy danh sách tất cả sources available
+        """
+        self._scan_sources()  # Refresh cache
+        
+        return {
+            "total_folders": len(self.sources_cache),
+            "folders": [
+                {
+                    "name": folder_name,
+                    "path": data["folder_path"],
+                    "media_count": data["media_count"],
+                    "sample_files": data["media_files"][:3]  # 3 files đầu làm sample
+                }
+                for folder_name, data in self.sources_cache.items()
+            ]
+        }
+    
+    def refresh_sources(self):
+        """
+        Refresh danh sách sources
+        """
+        logger.info("Refreshing sources cache...")
+        self._scan_sources()
+        return len(self.sources_cache)

video_generator_module.py

@@ -0,0 +1,1040 @@
+import os
+import logging
+import random
+from moviepy.editor import (
+    AudioFileClip, ImageClip, concatenate_videoclips, 
+    VideoFileClip, ColorClip, CompositeVideoClip, TextClip
+)
+from pathlib import Path
+import math
+# Thêm đoạn này vào đầu file video_generator_module.py
+import PIL.Image
+import os
+from moviepy.config import change_settings
+
+# Use system ImageMagick in Docker
+change_settings({"IMAGEMAGICK_BINARY": "/usr/bin/convert"})
+
+# Patch thuộc tính ANTIALIAS nếu thiếu
+if not hasattr(PIL.Image, 'ANTIALIAS'):
+    PIL.Image.ANTIALIAS = PIL.Image.Resampling.LANCZOS
+
+# --- CẤU HÌNH LOGGING ---
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# --- HẰNG SỐ VÀ THIẾT LẬP CHUNG ---
+DEFAULT_SAVE_DIR = "generated_video_output"
+DEFAULT_ASPECT_RATIOS = {
+    "ngang": (16, 9),   # Phổ biến cho YouTube, Facebook feed
+    "doc": (9, 16),     # Phổ biến cho TikTok, Reels, Shorts
+    "vuong": (1, 1)     # Phổ biến cho Instagram Feed, Twitter
+}
+
+# Cấu hình cho thumbnail overlay
+THUMBNAIL_SHOW_DURATION = 5.0  # 5 giây đầu
+THUMBNAIL_HEIGHT_RATIO = 1/4    # 1/3 chiều cao video (có thể bị điều chỉnh)
+LOGO_SIZE_RATIO = 0.16         # Logo chiếm 8% chiều rộng video
+LOGO_MARGIN = 20               # Margin từ góc
+TEXT_MARGIN = 20               # Margin cho text trong thumbnail
+
+# Cấu hình animation - TỐC ĐỘ CHẬM HƠN
+ZOOM_ANIMATION_DURATION = 4.0  # Tăng lên 4 giây cho animation chậm hơn
+TRANSITION_DURATION = 0.5      # Thời gian chuyển cảnh
+BOTTOM_PADDING = 160           # Padding dưới cùng (px)
+
+# --- HỖ TRỢ CHUYỂN ĐỔI TỶ LỆ KHUNG HÌNH ---
+def get_resolution(aspect_ratio_key: str, height: int = 1080) -> tuple[int, int]:
+    """
+    Trả về độ phân giải (width, height) dựa trên key tỷ lệ khung hình và chiều cao mong muốn.
+    """
+    if aspect_ratio_key not in DEFAULT_ASPECT_RATIOS:
+        raise ValueError(f"Tỷ lệ khung hình '{aspect_ratio_key}' không hỗ trợ. Hãy chọn trong: {list(DEFAULT_ASPECT_RATIOS.keys())}")
+    
+    width_ratio, height_ratio = DEFAULT_ASPECT_RATIOS[aspect_ratio_key]
+    
+    if height_ratio == 0: 
+        raise ValueError("Tỷ lệ chiều cao không được bằng 0.")
+    
+    width = int(height * width_ratio / height_ratio)
+    width = width + (width % 2) # Đảm bảo kích thước là số chẵn
+    
+    logging.info(f"Độ phân giải cho '{aspect_ratio_key}' (height={height}): ({width}, {height})")
+    return (width, height)
+
+def get_media_dimensions(clip):
+    """
+    Lấy kích thước thực tế của media clip
+    """
+    if hasattr(clip, 'w') and hasattr(clip, 'h'):
+        return clip.w, clip.h
+    elif hasattr(clip, 'size'):
+        return clip.size
+    else:
+        return None, None
+
+def calculate_aspect_ratio(width, height):
+    """
+    Tính tỷ lệ khung hình của media
+    """
+    if width and height and height != 0:
+        return width / height
+    return None
+
+def create_zoom_animation(clip, target_resolution, duration, zoom_type='in_out'):
+    """
+    Tạo hiệu ứng zoom in/out liên tục cho ảnh với FULL FILL tuyệt đối.
+    Sử dụng resize thông minh thay vì crop để tránh mất width.
+    
+    Args:
+        clip: ImageClip cần tạo animation
+        target_resolution: (width, height) của video đích  
+        duration: Thời gian hiển thị ảnh
+        zoom_type: 'in_out', 'in', 'out', 'random'
+    
+    Returns:
+        VideoClip với hiệu ứng zoom fill tuyệt đối, không mất width
+    """
+    target_width, target_height = target_resolution
+    effective_height = target_height - BOTTOM_PADDING  # Chiều cao hiệu dụng (trừ padding dưới)
+    
+    # Lấy kích thước gốc
+    original_width, original_height = get_media_dimensions(clip)
+    if not original_width or not original_height:
+        return clip.resize(target_resolution).set_duration(duration)
+    
+    logging.info(f"Zoom Animation - Original: {original_width}x{original_height}")
+    logging.info(f"Zoom Animation - Target fill area: {target_width}x{effective_height}")
+    
+    # Tính scale để FILL HOÀN TOÀN vùng hiệu dụng (sẽ crop phần thừa)
+    scale_by_width = target_width / original_width
+    scale_by_height = effective_height / original_height
+    
+    # Chọn scale LỚN HƠN để đảm bảo fill hoàn toàn không có khoảng trống
+    base_scale_to_fill = max(scale_by_width, scale_by_height)
+    
+    # Zoom range nhỏ để animation mượt và không bị crop quá nhiều
+    zoom_range = 0.08  # Giảm xuống 8% để đảm bảo luôn fill và không mất content
+    
+    if zoom_type == 'random':
+        zoom_type = random.choice(['in_out', 'in', 'out'])
+    
+    logging.info(f"Zoom Animation - Base scale to fill: {base_scale_to_fill:.3f}")
+    logging.info(f"Zoom Animation - Zoom range: {zoom_range:.2f}")
+    logging.info(f"Zoom Animation - Type: {zoom_type}, Duration: {duration:.1f}s")
+    
+    def get_zoom_factor(t):
+        """Tính zoom factor đảm bảo luôn >= base_scale_to_fill"""
+        progress = t / duration
+        
+        if zoom_type == 'in_out':
+            # Zoom in/out với sin wave, từ base_scale lên base_scale * (1 + zoom_range)
+            factor = base_scale_to_fill * (1 + zoom_range * (0.5 + 0.5 * math.sin(progress * math.pi * 2)))
+        elif zoom_type == 'in':
+            # Zoom in từ base_scale * (1 + zoom_range) về base_scale
+            factor = base_scale_to_fill * (1 + zoom_range * (1 - progress ** 0.8))
+        elif zoom_type == 'out':
+            # Zoom out từ base_scale lên base_scale * (1 + zoom_range)
+            factor = base_scale_to_fill * (1 + zoom_range * (progress ** 0.8))
+        else:
+            factor = base_scale_to_fill
+            
+        return factor
+    
+    def make_frame_at_time(t):
+        """Tạo frame tại thời điểm t - SỬ DỤNG RESIZE THÔNG MINH thay vì crop"""
+        current_scale = get_zoom_factor(t)
+        
+        # Tính kích thước sau scale để fill vùng effective
+        scaled_width = int(original_width * current_scale)
+        scaled_height = int(original_height * current_scale)
+        
+        # Đảm bảo kích thước chẵn
+        scaled_width = scaled_width + (scaled_width % 2)
+        scaled_height = scaled_height + (scaled_height % 2)
+        
+        logging.debug(f"Frame at t={t:.2f}: scale={current_scale:.3f}, size={scaled_width}x{scaled_height}")
+        
+        # CÁCH MỚI: Resize trực tiếp về target size thay vì crop
+        # Điều này sẽ giữ toàn bộ content và tỷ lệ
+        
+        # Tạo clip tạm với kích thước đã scale
+        temp_resized = clip.resize((scaled_width, scaled_height))
+        
+        # Kiểm tra xem scaled size có cover đủ target area không
+        if scaled_width >= target_width and scaled_height >= effective_height:
+            # Nếu đủ lớn, crop từ center để lấy đúng target size
+            crop_x_start = (scaled_width - target_width) // 2
+            crop_y_start = (scaled_height - effective_height) // 2
+            
+            final_clip = temp_resized.crop(
+                x1=crop_x_start,
+                y1=crop_y_start,
+                x2=crop_x_start + target_width,
+                y2=crop_y_start + effective_height
+            )
+        else:
+            # Nếu không đủ lớn (trường hợp này không nên xảy ra với scale > base_scale_to_fill)
+            # Resize force về target size
+            final_clip = temp_resized.resize((target_width, effective_height))
+        
+        # Lấy frame từ ảnh (t=0 vì là static image)
+        return final_clip.get_frame(0)
+    
+    # Tạo video clip với animation function
+    animated_clip = clip.set_duration(duration).fl(
+        lambda get_frame, t: make_frame_at_time(t),
+        apply_to=[]
+    )
+    
+    # Tạo background đen cho toàn bộ màn hình
+    background = ColorClip(
+        size=target_resolution, 
+        color=(0, 0, 0), 
+        duration=duration
+    ).set_fps(24)
+    
+    # Composite: background + animated image ở vị trí top-center
+    final_composite = CompositeVideoClip([
+        background,
+        animated_clip.set_position(("center", "top"))
+    ], size=target_resolution)
+    
+    logging.info(f"Zoom Animation - Hoàn thành với fill tuyệt đối, giữ nguyên width")
+    
+    return final_composite
+
+def create_transition_effect(clip1, clip2, transition_type='fade', duration=TRANSITION_DURATION):
+    """
+    Tạo hiệu ứng chuyển cảnh giữa hai clip.
+    """
+    if not clip1 or not clip2:
+        return [clip1, clip2] if clip1 and clip2 else ([clip1] if clip1 else [clip2])
+    
+    # Đảm bảo clips có cùng kích thước
+    if hasattr(clip1, 'size') and hasattr(clip2, 'size'):
+        target_size = clip1.size
+        if clip2.size != target_size:
+            clip2 = clip2.resize(target_size)
+    
+    if transition_type == 'fade':
+        # Fade transition
+        clip1_fade_out = clip1.fadeout(duration)
+        clip2_fade_in = clip2.fadein(duration)
+        
+        # Tạo overlap
+        clip1_trimmed = clip1_fade_out.subclip(0, clip1.duration - duration/2)
+        clip2_delayed = clip2_fade_in.set_start(clip1.duration - duration/2)
+        
+        return [clip1_trimmed, clip2_delayed]
+    
+    elif transition_type in ['slide_left', 'slide_right', 'slide_up', 'slide_down']:
+        # Slide transitions
+        target_size = clip1.size if hasattr(clip1, 'size') else (1080, 1920)
+        
+        # Xác định hướng di chuyển
+        if transition_type == 'slide_left':
+            start_pos = (target_size[0], 0)
+            end_pos = (0, 0)
+        elif transition_type == 'slide_right':
+            start_pos = (-target_size[0], 0)
+            end_pos = (0, 0)
+        elif transition_type == 'slide_up':
+            start_pos = (0, target_size[1])
+            end_pos = (0, 0)
+        else:  # slide_down
+            start_pos = (0, -target_size[1])
+            end_pos = (0, 0)
+        
+        # Tạo animation cho clip2
+        clip2_animated = (clip2
+                         .set_position(lambda t: (
+                             start_pos[0] + (end_pos[0] - start_pos[0]) * min(t/duration, 1),
+                             start_pos[1] + (end_pos[1] - start_pos[1]) * min(t/duration, 1)
+                         ))
+                         .set_start(clip1.duration - duration))
+        
+        clip1_trimmed = clip1.subclip(0, clip1.duration - duration/2)
+        
+        return [clip1_trimmed, clip2_animated]
+    
+    elif transition_type == 'zoom':
+        # Zoom transition
+        clip1_zoom_out = clip1.resize(lambda t: 1 - 0.5 * min(t/(clip1.duration), 1)).fadeout(duration)
+        clip2_zoom_in = clip2.resize(lambda t: 0.5 + 0.5 * min(t/duration, 1)).fadein(duration)
+        
+        clip1_trimmed = clip1_zoom_out.subclip(0, clip1.duration - duration/2)
+        clip2_delayed = clip2_zoom_in.set_start(clip1.duration - duration/2)
+        
+        return [clip1_trimmed, clip2_delayed]
+    
+    else:
+        # No transition
+        return [clip1, clip2]
+
+def smart_fit_and_fill(clip, target_resolution, media_type='image', fill_color=(0, 0, 0)):
+    """
+    Fit media vào target resolution mà không méo hình, và fill các vùng trống với màu nền.
+    """
+    target_width, target_height = target_resolution
+    
+    # Lấy kích thước gốc của clip
+    original_width, original_height = get_media_dimensions(clip)
+    
+    if not original_width or not original_height:
+        logging.warning(f"Không thể lấy kích thước gốc của clip, sử dụng resize thông thường")
+        return clip.resize(target_resolution)
+    
+    original_aspect_ratio = calculate_aspect_ratio(original_width, original_height)
+    target_aspect_ratio = target_width / target_height
+    
+    if not original_aspect_ratio:
+        logging.warning(f"Không thể tính tỷ lệ khung hình gốc, sử dụng resize thông thường")
+        return clip.resize(target_resolution)
+    
+    logging.info(f"Media gốc: {original_width}x{original_height} (ratio: {original_aspect_ratio:.2f})")
+    logging.info(f"Target: {target_width}x{target_height} (ratio: {target_aspect_ratio:.2f})")
+    
+    # Kiểm tra nếu tỷ lệ gần như giống nhau
+    if abs(original_aspect_ratio - target_aspect_ratio) < 0.01:
+        logging.info("Tỷ lệ khung hình gốc phù hợp, chỉ cần resize")
+        return clip.resize(target_resolution)
+    
+    # Tính toán scale để fit (không bị méo)
+    scale_by_width = target_width / original_width
+    scale_by_height = target_height / original_height
+    
+    # Chọn scale nhỏ hơn để đảm bảo fit hoàn toàn vào target
+    scale_factor = min(scale_by_width, scale_by_height)
+    
+    # Tính kích thước mới sau khi scale
+    new_width = int(original_width * scale_factor)
+    new_height = int(original_height * scale_factor)
+    
+    # Đảm bảo kích thước chẵn
+    new_width = new_width + (new_width % 2)
+    new_height = new_height + (new_height % 2)
+    
+    logging.info(f"Scale factor: {scale_factor:.3f}")
+    logging.info(f"Media sau khi fit: {new_width}x{new_height}")
+    
+    # Resize clip với tỷ lệ đã tính
+    fitted_clip = clip.resize((new_width, new_height))
+    
+    # Tính vị trí để center media trong target frame
+    x_offset = (target_width - new_width) // 2
+    y_offset = (target_height - new_height) // 2
+    
+    logging.info(f"Vị trí center: ({x_offset}, {y_offset})")
+    
+    # Tạo background với màu fill
+    duration = getattr(clip, 'duration', 1.0) if hasattr(clip, 'duration') else 1.0
+    background = ColorClip(
+        size=target_resolution, 
+        color=fill_color, 
+        duration=duration
+    ).set_fps(24)
+    
+    # Đặt vị trí cho fitted clip
+    fitted_clip = fitted_clip.set_position((x_offset, y_offset))
+    
+    # Composite background và fitted clip
+    final_clip = CompositeVideoClip([background, fitted_clip], size=target_resolution)
+    
+    return final_clip
+
+def smart_crop_to_fill(clip, target_resolution, media_type='image', fill_color=(255, 255, 255), bottom_padding: int = 160):
+    """
+    Crop phần trung tâm của clip sao cho vừa với target resolution mà không bị méo hình.
+    Phía dưới sẽ chừa ra một vùng trống (màu đen hoặc màu chỉ định) để hiển thị caption, logo,...
+    """
+    target_width, target_height = target_resolution
+    effective_crop_height = target_height - bottom_padding  # phần sẽ chứa nội dung
+
+    original_width, original_height = get_media_dimensions(clip)
+
+    if not original_width or not original_height:
+        return clip.resize(target_resolution)
+
+    target_ratio = target_width / effective_crop_height
+    original_ratio = original_width / original_height
+
+    # Crop giữ phần trung tâm
+    if original_ratio > target_ratio:
+        new_width = int(original_height * target_ratio)
+        x1 = (original_width - new_width) // 2
+        x2 = x1 + new_width
+        y1 = 0
+        y2 = original_height
+    else:
+        new_height = int(original_width / target_ratio)
+        y1 = (original_height - new_height) // 2
+        y2 = y1 + new_height
+        x1 = 0
+        x2 = original_width
+
+    cropped = clip.crop(x1=x1, y1=y1, x2=x2, y2=y2)
+    resized_cropped = cropped.resize((target_width, effective_crop_height))
+
+    # Tạo background đen (hoặc màu fill)
+    duration = getattr(clip, 'duration', 1.0)
+    background = ColorClip(size=target_resolution, color=fill_color, duration=duration).set_fps(24)
+
+    # Đặt phần crop ở top-center
+    final = CompositeVideoClip([background, resized_cropped.set_position(("center", "top"))], size=target_resolution)
+
+    return final
+
+# --- CÁC HÀM MỚI CHO THUMBNAIL OVERLAY ---
+
+def create_thumbnail_overlay(
+    thumbnail_path: str,
+    logo_path: str,
+    description: str,
+    date: str,
+    target_resolution: tuple[int, int],
+    duration: float = THUMBNAIL_SHOW_DURATION
+) -> CompositeVideoClip:
+    """
+    Tạo overlay thumbnail với logo và text cho 5 giây đầu video.
+    Thumbnail sẽ được scale để CHIỀU RỘNG luôn bao phủ đủ (có thể hi sinh chiều cao).
+    """
+    description = description.upper()
+    target_width, target_height = target_resolution
+    max_thumbnail_height = int(target_height * THUMBNAIL_HEIGHT_RATIO)
+    
+    # 1. Tạo nền trong suốt cho overlay
+    overlay_background = ColorClip(
+        size=target_resolution,
+        color=(0, 0, 0),  # Đen
+        duration=duration
+    ).set_opacity(0.3)  # Trong suốt
+    
+    overlay_clips = [overlay_background]
+    
+    # 2. Xử lý thumbnail - SCALE ĐỂ FILL WIDTH
+    actual_thumbnail_height = max_thumbnail_height  # Mặc định
+    thumbnail_y_position = target_height - max_thumbnail_height
+    
+    if thumbnail_path and os.path.exists(thumbnail_path):
+        try:
+            thumbnail_clip = ImageClip(thumbnail_path, duration=duration)
+            
+            # Lấy kích thước gốc của thumbnail
+            original_thumb_width, original_thumb_height = get_media_dimensions(thumbnail_clip)
+            
+            if original_thumb_width and original_thumb_height:
+                # SCALE ĐỂ FILL WIDTH (ưu tiên chiều rộng)
+                scale_to_fit_width = target_width / original_thumb_width
+                
+                # Tính chiều cao sau khi scale theo width
+                scaled_height = int(original_thumb_height * scale_to_fit_width)
+                
+                # Resize thumbnail để fill width
+                thumbnail_resized = thumbnail_clip.resize((target_width, scaled_height))
+                
+                # Nếu chiều cao sau scale vượt quá max_thumbnail_height, crop từ giữa
+                if scaled_height > max_thumbnail_height:
+                    # Crop từ giữa để giữ lại phần quan trọng nhất
+                    crop_start_y = (scaled_height - max_thumbnail_height) // 2
+                    crop_end_y = crop_start_y + max_thumbnail_height
+                    
+                    thumbnail_resized = thumbnail_resized.crop(
+                        x1=0, y1=crop_start_y, 
+                        x2=target_width, y2=crop_end_y
+                    )
+                    actual_thumbnail_height = max_thumbnail_height
+                    logging.info(f"Thumbnail được crop: từ {scaled_height}px xuống {max_thumbnail_height}px")
+                else:
+                    # Nếu chiều cao sau scale nhỏ hơn max, cập nhật actual height
+                    actual_thumbnail_height = scaled_height
+                    
+                # Tính lại vị trí Y dựa trên chiều cao thực tế
+                thumbnail_y_position = target_height - actual_thumbnail_height
+                
+                # Đặt vị trí thumbnail ở dưới cùng, fill width
+                thumbnail_positioned = thumbnail_resized.set_position((0, thumbnail_y_position)).set_opacity(0.8)
+                overlay_clips.append(thumbnail_positioned)
+                
+                logging.info(f"Thumbnail - Original: {original_thumb_width}x{original_thumb_height}")
+                logging.info(f"Thumbnail - Scaled: {target_width}x{scaled_height}")
+                logging.info(f"Thumbnail - Final: {target_width}x{actual_thumbnail_height}")
+                logging.info(f"Thumbnail - Position: (0, {thumbnail_y_position})")
+            else:
+                # Fallback nếu không lấy được kích thước
+                thumbnail_resized = thumbnail_clip.resize((target_width, max_thumbnail_height))
+                thumbnail_positioned = thumbnail_resized.set_position((0, thumbnail_y_position)).set_opacity(0.8)
+                overlay_clips.append(thumbnail_positioned)
+                logging.warning(f"Sử dụng fallback resize cho thumbnail: {thumbnail_path}")
+            
+        except Exception as e:
+            logging.warning(f"Không thể xử lý thumbnail '{thumbnail_path}': {e}")
+    
+    # 3. Xử lý logo - đặt ở góc phải trên
+    if logo_path and os.path.exists(logo_path):
+        try:
+            logo_clip = ImageClip(logo_path, duration=duration)
+            
+            # Resize logo theo tỷ lệ
+            logo_width = int(target_width * LOGO_SIZE_RATIO)
+            logo_resized = logo_clip.resize(width=logo_width)
+            
+            # Đặt vị trí logo ở góc phải trên
+            logo_x = target_width - logo_resized.w - LOGO_MARGIN 
+            logo_y = LOGO_MARGIN + 50
+            logo_positioned = logo_resized.set_position((logo_x, logo_y))
+            overlay_clips.append(logo_positioned)
+            
+            logging.info(f"Logo - Size: {logo_resized.w}x{logo_resized.h} - Position: ({logo_x}, {logo_y})")
+            
+        except Exception as e:
+            logging.warning(f"Không thể xử lý logo '{logo_path}': {e}")
+    
+    # 4. Thêm text description - đặt TRONG vùng thumbnail với chất lượng cao và BOLD
+    if description and description.strip():
+        try:
+            # Tính toán vị trí text trong vùng thumbnail
+            desc_y = thumbnail_y_position + TEXT_MARGIN + 40  # Bên trong thumbnail, từ trên xuống
+            
+            # Font size lớn hơn và responsive
+            font_size = max(int(target_width * 0.035), 35)  # Tăng từ 0.025 lên 0.035, minimum 50px
+            
+            # Sử dụng font BOLD
+            desc_clip = TextClip(
+                description.strip(),
+                fontsize=font_size,
+                font='Arial-Bold',  # Sử dụng Arial Bold để chữ dày
+                color='white',
+                method='caption',     
+                align='West',       # Căn trái
+                size=(target_width - 4 * TEXT_MARGIN, None)  # Tăng margin để text không bị sát mép
+            ).set_duration(duration).set_position((2 * TEXT_MARGIN, desc_y))
+            
+            overlay_clips.append(desc_clip)
+            logging.info(f"Description text - Font: Arial-Bold {font_size}px")
+            
+        except Exception as e:
+            logging.warning(f"Không thể tạo description text: {e}")
+    
+    # 5. Thêm text date - đặt ở góc phải trên của thumbnail với chất lượng cao
+    if date and date.strip():
+        try:
+            # Tính toán vị trí date ở góc phải trên của thumbnail
+            date_y = thumbnail_y_position + TEXT_MARGIN # Cùng hàng với description
+            
+            # Font size cho date
+            date_font_size = max(int(target_width * 0.025), 20)  # Tăng minimum lên 35px
+            
+            # Tạo date clip để tính toán width chính xác
+            date_clip = TextClip(
+                date.strip(),
+                fontsize=date_font_size,
+                font='Arial-Bold',  # Sử dụng Arial Bold cho date cũng
+                color='white',
+                method='label',     # Sử dụng 'label' thay vì default để tránh blur
+                align='center'
+            ).set_duration(duration)
+            
+            # Tính toán vị trí X để đặt ở góc phải
+            date_x = target_width - date_clip.w - 2 * TEXT_MARGIN
+            date_positioned = date_clip.set_position((date_x, date_y))
+            
+            overlay_clips.append(date_positioned)
+            logging.info(f"Date text - Font: Arial-Bold {date_font_size}px - Position: ({date_x}, {date_y})")
+            
+        except Exception as e:
+            logging.warning(f"Không thể tạo date text: {e}")
+    
+    # 6. Composite tất cả các elements
+    thumbnail_overlay = CompositeVideoClip(overlay_clips, size=target_resolution)
+    
+    return thumbnail_overlay
+
+def rate_media_compatibility(clip, target_aspect_ratio, media_type='image'):
+    """
+    Đánh giá độ phù hợp của media với target aspect ratio.
+    Trả về score từ 0-100, càng cao càng phù hợp.
+    """
+    original_width, original_height = get_media_dimensions(clip)
+    
+    if not original_width or not original_height:
+        return 50  # Score trung bình nếu không xác định được
+    
+    original_aspect_ratio = calculate_aspect_ratio(original_width, original_height)
+    
+    if not original_aspect_ratio:
+        return 50
+    
+    # Tính độ chênh lệch aspect ratio
+    ratio_diff = abs(original_aspect_ratio - target_aspect_ratio)
+    
+    # Score dựa trên độ chênh lệch (càng ít chênh lệch càng cao điểm)
+    base_score = max(0, 100 - (ratio_diff * 50))
+    
+    # Bonus cho video (thường linh hoạt hơn ảnh)
+    if media_type == 'video':
+        base_score += 10
+    
+    # Penalty nếu resolution quá thấp
+    min_dimension = min(original_width, original_height)
+    if min_dimension < 480:
+        base_score -= 30
+    elif min_dimension < 720:
+        base_score -= 15
+    
+    # Bonus nếu media có thể fit tốt (ít vùng trống)
+    scale_by_width = 1080 / original_width  # Giả sử target là 1080p
+    scale_by_height = 1080 / original_height
+    scale_factor = min(scale_by_width, scale_by_height)
+    
+    # Tính % diện tích media chiếm trong target frame
+    fitted_area = (original_width * scale_factor) * (original_height * scale_factor)
+    target_area = 1080 * (1080 * target_aspect_ratio if target_aspect_ratio < 1 else 1080)
+    area_ratio = fitted_area / target_area
+    
+    # Bonus nếu media chiếm nhiều diện tích (ít vùng trống)
+    if area_ratio > 0.8:
+        base_score += 15
+    elif area_ratio > 0.6:
+        base_score += 10
+    elif area_ratio < 0.3:
+        base_score -= 10
+    
+    return max(0, min(100, base_score))
+
+# --- CÁC HÀM XỬ LÝ VIDEO ---
+# (Các phần import, hằng số, hàm hỗ trợ khác giữ nguyên)
+
+# --- HÀM ĐÃ ĐƯỢC SỬA ĐỔI ---
+def create_clips_from_media_files(
+    media_files: list[str], 
+    target_duration: float, 
+    aspect_ratio_key: str, 
+    resolution: tuple[int, int]
+) -> list:
+    """
+    Chọn và tạo các clip (ảnh hoặc video) từ danh sách media,
+    ưu tiên các media có aspect ratio phù hợp.
+    LUÔN BẮT ĐẦU BẰNG MỘT ẢNH (nếu có ảnh).
+    - Video sẽ được xử lý bằng smart_crop_to_fill (cắt để lấp đầy) - KHÔNG CÓ ZOOM ANIMATION
+    - Ảnh sẽ được xử lý bằng create_zoom_animation (zoom animation động, FILL TUYỆT ĐỐI, GIỮ NGUYÊN WIDTH)
+    """
+    if not media_files:
+        logging.warning("Không có file media nào được cung cấp.")
+        return []
+    target_width, target_height = resolution
+    target_aspect_ratio = target_width / target_height
+    valid_images = []
+    valid_videos = []
+
+    # 1. Phân loại và đánh giá media
+    for media_path in media_files:
+        if not os.path.exists(media_path):
+            logging.warning(f"File media không tồn tại, bỏ qua: {media_path}")
+            continue
+        ext = media_path.lower().split('.')[-1]
+        clip_obj = None
+        media_type = None
+        try:
+            if ext in ['mp4', 'mov', 'avi', 'mkv', 'webm']:
+                clip_obj = VideoFileClip(media_path)
+                media_type = 'video'
+            elif ext in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp', 'tiff']:
+                clip_obj = ImageClip(media_path, duration=3.0) # Duration tạm thời cho ảnh
+                media_type = 'image'
+            else:
+                logging.warning(f"Định dạng file media không hỗ trợ, bỏ qua: {media_path}")
+                continue
+
+            if clip_obj:
+                 # Đánh giá độ phù hợp
+                compatibility_score = rate_media_compatibility(clip_obj, target_aspect_ratio, media_type)
+                logging.info(f"Media '{media_path}' - Type: {media_type} - Compatibility score: {compatibility_score:.1f}")
+                media_data = {
+                    'clip': clip_obj,
+                    'type': media_type,
+                    'original_clip': clip_obj,
+                    'compatibility_score': compatibility_score,
+                    'path': media_path
+                }
+                if media_type == 'image':
+                    valid_images.append(media_data)
+                else:
+                    valid_videos.append(media_data)
+        except Exception as e:
+            logging.warning(f"Không thể xử lý file media '{media_path}': {e}. Bỏ qua.")
+            if clip_obj:
+                clip_obj.close()
+
+    # Sắp xếp ảnh theo điểm phù hợp giảm dần để chọn ảnh tốt nhất làm đầu tiên
+    valid_images.sort(key=lambda x: x['compatibility_score'], reverse=True)
+
+    if not valid_images and not valid_videos:
+        logging.warning("Không tìm thấy file media nào hợp lệ sau khi xử lý.")
+        return []
+
+    # 2. Chọn clip đầu tiên (luôn là ảnh nếu có)
+    clips_for_concatenation = []
+    total_clip_duration = 0.0
+    first_clip_added = False
+
+    # Chọn ảnh đầu tiên (ảnh có điểm cao nhất)
+    if valid_images:
+        first_image_data = valid_images.pop(0) # Lấy ảnh tốt nhất ra khỏi danh sách
+        # Xác định thời lượng cho ảnh đầu tiên (ví dụ: 6-8 giây)
+        clip_duration = random.uniform(6.0, 8.0)
+        remaining_duration = target_duration - total_clip_duration
+        if clip_duration > remaining_duration:
+             clip_duration = remaining_duration
+
+        # Xử lý ảnh đầu tiên
+        zoom_type = random.choice(['in_out', 'in', 'out'])
+        processed_clip = create_zoom_animation(first_image_data['clip'], resolution, clip_duration, zoom_type)
+        clips_for_concatenation.append(processed_clip)
+        total_clip_duration += clip_duration
+        logging.info(f"[ĐẦU TIÊN] Đã thêm ảnh: {first_image_data['path']} - Duration: {clip_duration:.1f}s - Score: {first_image_data['compatibility_score']:.1f}")
+        first_clip_added = True
+        # Đảm bảo giải phóng tài nguyên cho ảnh đã chọn
+        first_image_data['clip'].close()
+
+    # 3. Kết hợp danh sách media còn lại (ảnh + video) để chọn tiếp theo
+    # Đảm bảo ảnh đầu tiên không bị chọn lại
+    remaining_media = valid_videos + valid_images # Ảnh đã chọn bị loại bỏ khỏi valid_images ở bước trên
+    if not remaining_media and not first_clip_added:
+         logging.warning("Không có media nào để thêm vào video.")
+         return clips_for_concatenation # Có thể trả về danh sách rỗng hoặc clip fallback nếu cần
+
+    # Sắp xếp media còn lại theo điểm phù hợp (cao nhất trước) để ưu tiên tốt hơn khi chọn
+    remaining_media.sort(key=lambda x: x['compatibility_score'], reverse=True)
+    # Trộn ngẫu nhiên thứ tự phát trong số các media còn lại (tuỳ chọn, có thể bỏ nếu muốn theo thứ tự điểm)
+    # random.shuffle(remaining_media)
+
+    # 4. Duyệt qua media còn lại và thêm vào danh sách phát
+    for i, media_data in enumerate(remaining_media):
+        # Kiểm tra thời lượng còn lại
+        remaining_duration = target_duration - total_clip_duration
+        if remaining_duration <= 0:
+            break
+
+        clip = media_data['clip']
+        # Lấy/gán thời lượng cho clip
+        if media_data['type'] == 'image':
+            # Đối với ảnh, tăng thời gian lên 6-8 giây để animation chậm đẹp hơn
+            clip_duration = random.uniform(6.0, 8.0)
+        else:  # video
+            # Đối với video, lấy thời lượng gốc
+            clip_duration = getattr(media_data['original_clip'], 'duration', 0)
+
+        # Nếu thời lượng còn lại ít hơn thời lượng clip, điều chỉnh
+        if clip_duration > remaining_duration:
+            clip_duration = remaining_duration
+
+        # Áp dụng xử lý khác nhau cho video và ảnh
+        final_clip = None
+        if media_data['type'] == 'video':
+            # Video: Sử dụng smart_crop_to_fill để cắt và lấp đầy - KHÔNG CÓ ZOOM ANIMATION
+            processed_clip = smart_crop_to_fill(clip, resolution, media_data['type'], fill_color=(20, 20, 20))
+            final_clip = processed_clip.set_duration(clip_duration)
+            logging.info(f"Video được xử lý bằng smart_crop_to_fill (KHÔNG CÓ ZOOM ANIMATION): {media_data['path']}")
+        else:  # image
+            # Ảnh: Sử dụng create_zoom_animation với FILL TUYỆT ĐỐI, GIỮ NGUYÊN WIDTH
+            zoom_types = ['in_out', 'in', 'out']
+            zoom_type = random.choice(zoom_types)
+            processed_clip = create_zoom_animation(clip, resolution, clip_duration, zoom_type)
+            final_clip = processed_clip
+            logging.info(f"Ảnh được xử lý bằng zoom animation FILL + GIỮ WIDTH ({zoom_type}): {media_data['path']}")
+
+        if final_clip:
+            clips_for_concatenation.append(final_clip)
+            total_clip_duration += clip_duration
+            logging.info(f"Đã thêm {media_data['type']}: {media_data['path']} - Duration: {clip_duration:.1f}s - Score: {media_data['compatibility_score']:.1f}")
+
+        # Nếu đã đủ thời lượng, dừng lại
+        if total_clip_duration >= target_duration:
+            break
+
+    # 5. Thêm hiệu ứng chuyển cảnh giữa các clips - LOẠI BỎ ZOOM TRANSITION
+    if len(clips_for_concatenation) > 1:
+        logging.info("Đang thêm hiệu ứng chuyển cảnh...")
+        # LOẠI BỎ 'zoom' ra khỏi transition_types
+        transition_types = ['fade', 'slide_left', 'slide_right']  # Không có 'zoom' nữa
+        clips_with_transitions = []
+        for i, clip in enumerate(clips_for_concatenation):
+            if i == 0:
+                # Clip đầu tiên, không cần transition
+                clips_with_transitions.append(clip)
+            else:
+                # Thêm transition với clip trước đó
+                transition_type = random.choice(transition_types)
+                prev_clip = clips_with_transitions[-1]
+                # Tạo transition effect
+                transitioned_clips = create_transition_effect(
+                    prev_clip, clip,
+                    transition_type=transition_type,
+                    duration=TRANSITION_DURATION
+                )
+                # Thay thế clip trước đó và thêm clip hiện tại
+                if len(transitioned_clips) == 2:
+                    clips_with_transitions[-1] = transitioned_clips[0]  # Clip trước đã được modify
+                    clips_with_transitions.append(transitioned_clips[1])  # Clip hiện tại với transition
+                    logging.info(f"Đã thêm transition '{transition_type}' giữa clip {i} và {i+1}")
+                else:
+                    clips_with_transitions.append(clip)
+        return clips_with_transitions
+    return clips_for_concatenation
+
+# (Các phần còn lại của file giữ nguyên)
+def create_video_from_audio_and_media(
+    audio_path: str,
+    source_media_paths: list[str], 
+    aspect_ratio_key: str,
+    output_filename: str = "output_video.mp4",
+    version: int = 1,
+    output_dir: str = DEFAULT_SAVE_DIR,
+    target_height: int = 1080,
+    # Tham số mới cho thumbnail overlay
+    thumbnail_path: str = None,
+    logo_path: str = None,
+    description: str = None,
+    date: str = None
+) -> str:
+    """
+    Tạo một phiên bản video dựa trên audio và các file media (ảnh/video).
+    Có thể thêm thumbnail overlay với logo và text trong 5 giây đầu.
+    Thumbnail sẽ được scale để fill width (có thể hi sinh height).
+    Ảnh sẽ có zoom animation động FILL TUYỆT ĐỐI, GIỮ NGUYÊN WIDTH, video giữ nguyên xử lý crop.
+    """
+    if not audio_path or not os.path.exists(audio_path):
+        raise FileNotFoundError("File audio không tồn tại hoặc đường dẫn bị thiếu.")
+    
+    if not source_media_paths:
+        raise ValueError("Cần ít nhất một file media để tạo video.")
+
+    try:
+        # 1. Lấy độ phân giải
+        resolution = get_resolution(aspect_ratio_key, height=target_height)
+        
+        # 2. Tải Audio Clip và lấy duration
+        audio_clip = AudioFileClip(audio_path)
+        audio_duration = audio_clip.duration
+        logging.info(f"Độ dài audio: {audio_duration:.2f} giây")
+        
+        # 3. Tạo các clip từ danh sách media (ảnh/video) với smart processing và animations
+        media_clips = create_clips_from_media_files(source_media_paths, audio_duration, aspect_ratio_key, resolution)
+        
+        if not media_clips:
+            logging.warning("Không có clip media nào được tạo. Sử dụng fallback.")
+            # Tạo video với nền đen nếu không có media
+            fallback_clip = ColorClip(
+                size=resolution, 
+                color=(0, 0, 0),  # Màu đen
+                duration=audio_duration
+            ).set_fps(24)
+            media_clips = [fallback_clip]
+
+        # 4. Ghép các clip đã được tạo với transitions
+        final_video_segment = concatenate_videoclips(media_clips, method="compose")
+
+        # 5. Đảm bảo duration của video khớp với audio
+        if abs(final_video_segment.duration - audio_duration) > 0.1:
+            final_video_segment = final_video_segment.set_duration(audio_duration)
+
+        # 6. Kết hợp audio vào video clip
+        final_video = final_video_segment.set_audio(audio_clip)
+        THUMBNAIL_SHOW_DURATION = audio_duration
+        # 7. Thêm thumbnail overlay nếu có đủ thông tin
+        overlay_added = False
+        if any([thumbnail_path, logo_path, description, date]):
+            try:
+                # Tạo thumbnail overlay cho 5 giây đầu
+                thumbnail_overlay = create_thumbnail_overlay(
+                    thumbnail_path=thumbnail_path,
+                    logo_path=logo_path, 
+                    description=description,
+                    date=date,
+                    target_resolution=resolution,
+                    duration=audio_duration #min(THUMBNAIL_SHOW_DURATION, audio_duration)
+                )
+                
+                # Composite overlay lên video
+                final_video = CompositeVideoClip([final_video, thumbnail_overlay], size=resolution)
+                overlay_added = True
+                logging.info(f"Đã thêm thumbnail overlay (fill width) cho {min(THUMBNAIL_SHOW_DURATION, audio_duration):.1f} giây đầu")
+                
+            except Exception as e:
+                logging.warning(f"Không thể thêm thumbnail overlay: {e}")
+        
+        if not overlay_added:
+            logging.info("Không có thumbnail overlay được thêm vào video")
+        
+        # 8. Tạo thư mục output nếu chưa tồn tại
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, f"v{version}_{output_filename}")
+        
+        # 9. Ghi file video ra định dạng MP4
+        logging.info(f"Đang ghi file video với version {version} ra: {output_path}")
+        final_video.write_videofile(
+            output_path,
+            codec='libx264',        
+            audio_codec='aac',      
+            fps=24,                 
+            threads=4,              
+            preset='ultrafast',        
+            logger='bar',           
+        )
+        logging.info(f"Tạo video thành công cho phiên bản {version}!")
+        
+        # Giải phóng tài nguyên
+        audio_clip.close()
+        final_video_segment.close()
+        final_video.close()
+        for clip in media_clips:
+            if hasattr(clip, 'close') and clip is not None: 
+                clip.close()
+            
+        return output_path
+
+    except FileNotFoundError as e:
+        logging.error(f"Lỗi file: {e}")
+        raise
+    except ValueError as e:
+        logging.error(f"Lỗi giá trị: {e}")
+        raise
+    except Exception as e:
+        logging.error(f"Lỗi không xác định khi tạo video: {e}")
+        import traceback
+        logging.error(traceback.format_exc()) 
+        raise
+
+# --- HÀM CHÍNH ĐỂ TẠO NHIỀU PHIÊN BẢN VIDEO ---
+def generate_multiple_video_versions(
+    audio_path: str,
+    source_media_paths: list[str], 
+    aspect_ratio_key: str,
+    num_versions: int = 1,
+    base_filename: str = "news_video",
+    output_dir: str = DEFAULT_SAVE_DIR,
+    target_height: int = 1080,
+    # Tham số mới cho thumbnail overlay
+    thumbnail_path: str = None,
+    logo_path: str = None,
+    description: str = None,
+    date: str = None
+) -> list[str]:
+    """
+    Tạo N phiên bản video khác nhau với các kết hợp media (ảnh/video) ngẫu nhiên.
+    Có thể thêm thumbnail overlay với logo và text trong 5 giây đầu.
+    Thumbnail sẽ được scale để fill width (có thể hi sinh height).
+    Ảnh sẽ có zoom animation động FILL TUYỆT ĐỐI, GIỮ NGUYÊN WIDTH, các clip sẽ có transitions đẹp.
+    """
+    if not audio_path or not os.path.exists(audio_path):
+        raise FileNotFoundError("File audio không tồn tại hoặc đường dẫn bị thiếu.")
+    
+    if not source_media_paths:
+        raise ValueError("Cần ít nhất một file media để tạo video.")
+        
+    if num_versions <= 0:
+        raise ValueError("Số phiên bản phải lớn hơn 0.")
+
+    generated_video_paths = []
+    
+    if aspect_ratio_key not in DEFAULT_ASPECT_RATIOS:
+         raise ValueError(f"Tỷ lệ khung hình '{aspect_ratio_key}' không hỗ trợ. Hãy chọn trong: {list(DEFAULT_ASPECT_RATIOS.keys())}")
+    
+    valid_sources = [s for s in source_media_paths if os.path.exists(s)]
+    
+    if not valid_sources:
+        raise ValueError("Không tìm thấy file media hợp lệ nào.")
+    
+    logging.info(f"Bắt đầu tạo {num_versions} phiên bản video...")
+    logging.info(f"Target aspect ratio: {DEFAULT_ASPECT_RATIOS[aspect_ratio_key]}")
+    logging.info("Chế độ xử lý: Video = smart_crop_to_fill, Ảnh = zoom animation FILL + GIỮ WIDTH")
+    logging.info("Hiệu ứng: Transitions giữa các clips + thumbnail overlay BOLD")
+    logging.info(f"Animation: Zoom range 8%, tốc độ rất chậm, luôn fill + giữ width (trừ {BOTTOM_PADDING}px dưới)")
+    
+    # Log thông tin thumbnail overlay
+    if any([thumbnail_path, logo_path, description, date]):
+        logging.info("Thumbnail overlay sẽ được thêm với:")
+        if thumbnail_path: logging.info(f"  - Thumbnail (fill width): {thumbnail_path}")
+        if logo_path: logging.info(f"  - Logo: {logo_path}")
+        if description: logging.info(f"  - Description BOLD (trong thumbnail): {description[:50]}...")
+        if date: logging.info(f"  - Date BOLD (trong thumbnail): {date}")
+        logging.info(f"  - Duration: {THUMBNAIL_SHOW_DURATION} giây đầu")
+        logging.info("  - Thumbnail scaling: Fill width, crop height if needed")
+    
+    try:
+        temp_audio_clip = AudioFileClip(audio_path)
+        audio_duration = temp_audio_clip.duration
+        temp_audio_clip.close()
+    except Exception as e:
+        raise FileNotFoundError(f"Không thể đọc file audio '{audio_path}': {e}")
+
+    for i in range(num_versions):
+        version_num = i + 1
+        try:
+            logging.info(f"\n--- ĐANG TẠO PHIÊN BẢN VIDEO THỨ {version_num} ---")
+            output_filename = f"{base_filename}_v{version_num}.mp4"
+            
+            video_path = create_video_from_audio_and_media(
+                audio_path=audio_path,
+                source_media_paths=valid_sources, 
+                aspect_ratio_key=aspect_ratio_key,
+                output_filename=output_filename,
+                version=version_num,
+                output_dir=output_dir,
+                target_height=target_height,
+                # Truyền thông tin thumbnail overlay
+                thumbnail_path=thumbnail_path,
+                logo_path=logo_path,
+                description=description,
+                date=date
+            )
+            generated_video_paths.append(video_path)
+            
+        except FileNotFoundError as e:
+            logging.error(f"Lỗi file ở phiên bản {version_num}: {e}. Bỏ qua phiên bản này.")
+        except ValueError as e:
+            logging.error(f"Lỗi giá trị ở phiên bản {version_num}: {e}. Bỏ qua phiên bản này.")
+        except Exception as e:
+            logging.error(f"Lỗi không xác định ở phiên bản {version_num}: {e}")
+            import traceback
+            logging.error(traceback.format_exc())
+    
+    logging.info(f"Hoàn tất tạo {len(generated_video_paths)} / {num_versions} phiên bản video.")
+    return generated_video_paths
+
+
+# --- KHỐI ĐỂ CHẠY THỬ NGHIỆM MODULE ---
+if __name__ == '__main__':
+    # Ví dụ sử dụng module để tạo video với thumbnail overlay và animations
+    # audio_file = "./generated_content/audio/podcast_3_1da3ae9d-df2a-400f-8168-b4976bc6e20b.wav"
+    audio_file = "generated_content/audio/news_1_b7a03e41-7a82-43fe-b343-e683aeef2c4d.wav"
+    o = './public/u23-VietNam/media/'
+    source_media = [o + 'output_00' + str(i) + '.mp4' for i in range(9)]
+    source_media.extend(['public/u23-VietNam/media/u23-viet-nam-1-1753065357.jpg', 
+                        'public/u23-VietNam/media/lich thi dau u23 viet nam.png',
+                        'public/u23-VietNam/media/993135543_164183883u23-viet-nam.jpg'])
+    
+    # Thông tin thumbnail overlay
+    thumbnail_img = "thumbnails/thumbnail1.png"
+    logo_img = "logo.png"  # Đường dẫn logo
+    desc_text = """Ban tổ chức V-League ra tối hậu thư cho Quảng Nam"""
+    date_text = "2025-07-23"
+    
+    try:
+        generated_videos = generate_multiple_video_versions(
+            audio_path=audio_file,
+            source_media_paths=source_media,
+            aspect_ratio_key="doc",
+            num_versions=1,
+            base_filename="sports_news_video",
+            output_dir=DEFAULT_SAVE_DIR,
+            target_height=1080,
+            # Thông tin thumbnail overlay
+            thumbnail_path=thumbnail_img,
+            logo_path=logo_img,
+            description=desc_text,
+            date=date_text
+        )
+        print("Các video đã được tạo thành công:", generated_videos)
+    except Exception as e:
+        logging.error(f"Lỗi khi tạo video: {e}")