full-lipsync-youtube (#9)

- lipsync - fullvideo - youtube (5e11afae8f27e0ca3f8530731610d7b91c2ff0f3)

app.py

@@ -97,7 +97,7 @@ with gr.Blocks(css=css) as demo:
             with gr.Column():
                 gr.HTML("""
                 <div>
-                    <span style="font-size: 20px;">🎬 Final Output Video</span><br>
+                    <span style="font-size: 20px;">🎬 Final Output (YouTube)</span><br>
                 </div>
                 """)
                 final_video = gr.Video(label="Final Output", height=512)
@@ -105,31 +105,19 @@ with gr.Blocks(css=css) as demo:
         gr.HTML("<h3>Processing Steps</h3>")
         with gr.Row():
             with gr.Column():
-                gr.HTML('<p style="margin: 0; color: #666;">1. Original (Looped)</p>')
-                video_looped_output = gr.Video(label="Original Video", height=256)
+                gr.HTML('<p style="margin: 0; color: #666;">1. Normalized Video</p>')
+                video_normalized_output = gr.Video(label="Normalized Video", height=256)
             with gr.Column():
-                gr.HTML('<p style="margin: 0; color: #666;">2. Face Cropped</p>')
-                face_cropped_output = gr.Video(label="Face Cropped", height=256)
-            with gr.Column():
-                gr.HTML('<p style="margin: 0; color: #666;">3. Lipsynced Face</p>')
-                lipsynced_face_output = gr.Video(label="Lipsynced Face", height=256)
-
-        with gr.Row():
-            with gr.Column():
-                gr.HTML(
-                    '<p style="margin: 0; color: #666;">4. Lipsynced Full (Blended)</p>'
-                )
-                lipsynced_full_output = gr.Video(label="Lipsynced Full", height=256)
+                gr.HTML('<p style="margin: 0; color: #666;">2. Lipsynced Video</p>')
+                lipsynced_video_output = gr.Video(label="Lipsynced Video", height=256)
 
     lipsync_only_btn.click(
         fn=lipsync_with_audio_target,
         inputs=[video_input, audio_input, session_state, crop_size_radio],
         outputs=[
             final_video,
-            video_looped_output,
-            face_cropped_output,
-            lipsynced_face_output,
-            lipsynced_full_output,
+            video_normalized_output,
+            lipsynced_video_output,
         ],
     )
 

audio_processing.py

@@ -28,20 +28,77 @@ def get_audio_duration(audio_path: str) -> float:
     return float(result.stdout.strip())
 
 
-def prepare_target_audio(audio_path: str, output_dir: str) -> tuple:
-    """Prepare target audio for lipsync
+# def prepare_target_audio(audio_path: str, output_dir: str) -> tuple:
+#     """Prepare target audio for lipsync (DEPRECATED - use prepare_audio_for_lipsync instead)
+#
+#     Args:
+#         audio_path: Path to target audio
+#         output_dir: Output directory
+#
+#     Returns:
+#         (audio_16k_path, audio_upsampled_path)
+#     """
+#     audio_16k = os.path.join(output_dir, "audio_16k.wav")
+#     audio_upsampled = os.path.join(output_dir, "audio_upsampled.wav")
+#
+#     ffmpeg1 = FFmpeg(
+#         inputs={audio_path: None},
+#         outputs={
+#             audio_16k: [
+#                 "-ar",
+#                 "16000",
+#                 "-ac",
+#                 "1",
+#                 "-acodec",
+#                 "pcm_s16le",
+#                 "-loglevel",
+#                 "error",
+#                 "-y",
+#             ]
+#         },
+#     )
+#     try:
+#         ffmpeg1.run()
+#     except FFRuntimeError as e:
+#         raise Exception(f"FFmpeg failed to convert to 16k: {e}")
+#
+#     ffmpeg2 = FFmpeg(
+#         inputs={audio_16k: None},
+#         outputs={
+#             audio_upsampled: [
+#                 "-ar",
+#                 "48000",
+#                 "-ac",
+#                 "1",
+#                 "-acodec",
+#                 "pcm_s16le",
+#                 "-loglevel",
+#                 "error",
+#                 "-y",
+#             ]
+#         },
+#     )
+#     try:
+#         ffmpeg2.run()
+#     except FFRuntimeError as e:
+#         raise Exception(f"FFmpeg failed to upsample to 48k: {e}")
+#
+#     return audio_16k, audio_upsampled
+
+
+def prepare_audio_for_lipsync(audio_path: str, output_dir: str) -> str:
+    """Chuẩn bị audio 16kHz mono cho lipsync pipeline
 
     Args:
-        audio_path: Path to target audio
+        audio_path: Path audio gốc
         output_dir: Output directory
 
     Returns:
-        (audio_16k_path, audio_upsampled_path)
+        Path audio 16k WAV
     """
     audio_16k = os.path.join(output_dir, "audio_16k.wav")
-    audio_upsampled = os.path.join(output_dir, "audio_upsampled.wav")
 
-    ffmpeg1 = FFmpeg(
+    ffmpeg = FFmpeg(
         inputs={audio_path: None},
         outputs={
             audio_16k: [
@@ -58,20 +115,43 @@ def prepare_target_audio(audio_path: str, output_dir: str) -> tuple:
         },
     )
     try:
-        ffmpeg1.run()
+        ffmpeg.run()
     except FFRuntimeError as e:
         raise Exception(f"FFmpeg failed to convert to 16k: {e}")
 
-    ffmpeg2 = FFmpeg(
-        inputs={audio_16k: None},
+    return audio_16k
+
+
+def prepare_audio_for_youtube_aac(audio_path: str, output_dir: str) -> str:
+    """Chuẩn bị audio theo chuẩn YouTube (AAC)
+
+    Args:
+        audio_path: Path audio gốc
+        output_dir: Output directory
+
+    Returns:
+        Path audio YouTube (AAC)
+    """
+    from config import (
+        YOUTUBE_AUDIO_CODEC,
+        YOUTUBE_AUDIO_BITRATE,
+        YOUTUBE_AUDIO_SAMPLE_RATE,
+    )
+
+    output_path = os.path.join(output_dir, "audio_youtube.aac")
+
+    ffmpeg = FFmpeg(
+        inputs={audio_path: None},
         outputs={
-            audio_upsampled: [
+            output_path: [
                 "-ar",
-                "48000",
+                str(YOUTUBE_AUDIO_SAMPLE_RATE),
                 "-ac",
-                "1",
+                "2",
                 "-acodec",
-                "pcm_s16le",
+                YOUTUBE_AUDIO_CODEC,
+                "-b:a",
+                YOUTUBE_AUDIO_BITRATE,
                 "-loglevel",
                 "error",
                 "-y",
@@ -79,11 +159,11 @@ def prepare_target_audio(audio_path: str, output_dir: str) -> tuple:
         },
     )
     try:
-        ffmpeg2.run()
+        ffmpeg.run()
     except FFRuntimeError as e:
-        raise Exception(f"FFmpeg failed to upsample to 48k: {e}")
+        raise Exception(f"FFmpeg failed to prepare audio for YouTube: {e}")
 
-    return audio_16k, audio_upsampled
+    return output_path
 
 
 def prepare_audio_for_youtube(audio_path: str, output_dir: str) -> str:

face_processing.py

@@ -1,577 +1,585 @@
-"""Face detection and region extraction for lipsync optimization"""
-
-import os
-import math
-import logging
-from typing import List, Dict, Tuple, Optional
-
-import cv2
-import numpy as np
-import mediapipe as mp
-from ffmpy import FFmpeg, FFRuntimeError
-
-from video_processing import get_video_info
-
-logger = logging.getLogger(__name__)
-
-
-class FaceDetectionError(Exception):
-    """Custom exception for face detection errors"""
-
-    pass
-
-
-def sample_frames_from_video(
-    video_path: str, output_dir: str, sample_count: int = 5
-) -> List[Tuple[int, str]]:
-    """Extract uniform sample frames from video using OpenCV CUDA (HuggingFace)
-
-    Args:
-        video_path: Path to video
-        output_dir: Directory to save extracted frames
-        sample_count: Number of frames to sample
-
-    Returns:
-        List of (frame_index, frame_path) tuples
-    """
-    video_info = get_video_info(video_path)
-    fps = video_info["fps"]
-    duration = video_info["duration"]
-    total_frames = int(duration * fps)
-
-    frames_dir = os.path.join(output_dir, "sampled_frames")
-    os.makedirs(frames_dir, exist_ok=True)
-
-    if total_frames <= sample_count:
-        frame_indices = list(range(total_frames))
-    else:
-        frame_indices = [
-            int(i * total_frames / sample_count) for i in range(sample_count)
-        ]
-
-    extracted_frames = []
-    cap = cv2.VideoCapture(video_path)
-
-    try:
-        for idx, frame_idx in enumerate(frame_indices):
-            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
-            ret, frame = cap.read()
-
-            if not ret or frame is None:
-                logger.warning(f"Failed to read frame {frame_idx}")
-                continue
-
-            frame_path = os.path.join(frames_dir, f"frame_{idx:04d}.jpg")
-            cv2.imwrite(frame_path, frame, [cv2.IMWRITE_JPEG_QUALITY, 90])
-            extracted_frames.append((frame_idx, frame_path))
-    finally:
-        cap.release()
-
-    logger.info(f"Extracted {len(extracted_frames)} frames from {video_path}")
-    return extracted_frames
-
-
-def detect_faces_in_frames(
-    extracted_frames: List[Tuple[int, str]],
-    min_confidence: float = 0.5,
-    min_face_pixels: int = 100,
-) -> List[Dict]:
-    """Detect faces in all sampled frames using MediaPipe Face Detection API
-
-    Args:
-        extracted_frames: List of (frame_index, frame_path) tuples
-        min_confidence: Minimum detection confidence (0-1)
-        min_face_pixels: Minimum face size in pixels
-
-    Returns:
-        List of detections: [{"frame_idx", "confidence", "bbox": (x, y, w, h)}]
-    """
-    detections = []
-
-    with mp.solutions.face_detection.FaceDetection(
-        model_selection=0, min_detection_confidence=min_confidence
-    ) as face_detection:
-        for frame_idx, frame_path in extracted_frames:
-            frame = cv2.imread(frame_path)
-            if frame is None:
-                logger.warning(f"Failed to read frame: {frame_path}")
-                continue
-
-            h, w = frame.shape[:2]
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-
-            results = face_detection.process(frame_rgb)
-
-            if results.detections:
-                for detection in results.detections:
-                    bbox = detection.location_data.relative_bounding_box
-
-                    x = int(bbox.xmin * w)
-                    y = int(bbox.ymin * h)
-                    face_w = int(bbox.width * w)
-                    face_h = int(bbox.height * h)
-
-                    x = max(0, x)
-                    y = max(0, y)
-                    face_w = min(w - x, face_w)
-                    face_h = min(h - y, face_h)
-
-                    confidence = detection.score[0] if detection.score else 0.0
-
-                    if face_w >= min_face_pixels and face_h >= min_face_pixels:
-                        detections.append(
-                            {
-                                "frame_idx": frame_idx,
-                                "confidence": float(confidence),
-                                "bbox": (x, y, face_w, face_h),
-                            }
-                        )
-
-    logger.info(f"Detected {len(detections)} faces in {len(extracted_frames)} frames")
-    return detections
-
-
-def cluster_face_detections(
-    detections: List[Dict], max_distance: int = 100
-) -> List[List[Dict]]:
-    """Group face detections belonging to the same person using clustering
-
-    Args:
-        detections: List of face detections
-        max_distance: Maximum distance (pixels) to consider detections as same person
-
-    Returns:
-        List of clusters (each cluster is a list of detections)
-    """
-    if not detections:
-        return []
-
-    clusters = []
-    visited = set()
-
-    for i, det_i in enumerate(detections):
-        if i in visited:
-            continue
-
-        x_i, y_i, w_i, h_i = det_i["bbox"]
-        center_i = (x_i + w_i / 2, y_i + h_i / 2)
-
-        cluster = [det_i]
-        visited.add(i)
-
-        for j, det_j in enumerate(detections):
-            if j in visited:
-                continue
-
-            x_j, y_j, w_j, h_j = det_j["bbox"]
-            center_j = (x_j + w_j / 2, y_j + h_j / 2)
-
-            distance = math.sqrt(
-                (center_i[0] - center_j[0]) ** 2 + (center_i[1] - center_j[1]) ** 2
-            )
-
-            if distance < max_distance:
-                cluster.append(det_j)
-                visited.add(j)
-
-        clusters.append(cluster)
-
-    logger.info(f"Clustered {len(detections)} detections into {len(clusters)} clusters")
-    return clusters
-
-
-def select_best_cluster(clusters: List[List[Dict]]) -> Optional[List[Dict]]:
-    """Select the best face cluster (highest frequency)
-
-    Args:
-        clusters: List of clusters
-
-    Returns:
-        Best cluster (most frequent) or None
-    """
-    if not clusters:
-        return None
-
-    scored_clusters = [(len(cluster), cluster) for cluster in clusters]
-    scored_clusters.sort(key=lambda x: x[0], reverse=True)
-
-    best_cluster = scored_clusters[0][1]
-    logger.info(f"Selected best cluster with {len(best_cluster)} detections")
-    return best_cluster
-
-
-def verify_face_stability(
-    cluster: List[Dict], max_movement_percent: float = 0.3
-) -> bool:
-    """Verify face doesn't move too much between frames
-
-    Args:
-        cluster: Face detections for the same person
-        max_movement_percent: Max movement as percentage of average face size
-
-    Returns:
-        True if face is stable, False otherwise
-    """
-    if len(cluster) < 2:
-        return True
-
-    centers = []
-    sizes = []
-
-    for det in cluster:
-        x, y, w, h = det["bbox"]
-        centers.append((x + w / 2, y + h / 2))
-        sizes.append(w * h)
-
-    avg_size = sum(sizes) / len(sizes)
-    avg_face_dim = math.sqrt(avg_size)
-    max_allowed_movement = avg_face_dim * max_movement_percent
-
-    for i in range(len(centers) - 1):
-        dx = abs(centers[i + 1][0] - centers[i][0])
-        dy = abs(centers[i + 1][1] - centers[i][1])
-        movement = math.sqrt(dx**2 + dy**2)
-
-        if movement > max_allowed_movement:
-            logger.warning(
-                f"Face movement {movement:.1f}px > {max_allowed_movement:.1f}px"
-            )
-            return False
-
-    return True
-
-
-def calculate_face_bbox_from_cluster(cluster: List[Dict]) -> Dict:
-    """Calculate average face bounding box from cluster
-
-    Args:
-        cluster: Face detections for the same person
-
-    Returns:
-        Dict: {"x", "y", "width", "height"}
-    """
-    weighted_x = 0
-    weighted_y = 0
-    weighted_w = 0
-    weighted_h = 0
-    total_weight = 0
-
-    for det in cluster:
-        x, y, w, h = det["bbox"]
-        weight = det["confidence"]
-        weighted_x += x * weight
-        weighted_y += y * weight
-        weighted_w += w * weight
-        weighted_h += h * weight
-        total_weight += weight
-
-    avg_bbox = {
-        "x": int(weighted_x / total_weight),
-        "y": int(weighted_y / total_weight),
-        "width": int(weighted_w / total_weight),
-        "height": int(weighted_h / total_weight),
-    }
-
-    return avg_bbox
-
-
-def calculate_safe_crop_size(
-    face_bbox: Dict, video_width: int, video_height: int, crop_size: int = 512
-) -> Dict:
-    """Calculate safe crop region ensuring face is inside
-
-    Args:
-        face_bbox: Face bounding box {"x", "y", "width", "height"}
-        video_width: Video width
-        video_height: Video height
-        crop_size: Size of crop region (default: 512)
-
-    Returns:
-        Dict: {"x", "y", "width", "height"}
-    """
-    crop_half = crop_size // 2
-
-    face_center_x = face_bbox["x"] + face_bbox["width"] / 2
-    face_center_y = face_bbox["y"] + face_bbox["height"] / 2
-
-    crop_x = int(face_center_x - crop_half)
-    crop_y = int(face_center_y - crop_half)
-
-    crop_x = max(0, crop_x)
-    crop_y = max(0, crop_y)
-    crop_x = min(video_width - crop_size, crop_x)
-    crop_y = min(video_height - crop_size, crop_y)
-
-    face_right = face_bbox["x"] + face_bbox["width"]
-    face_bottom = face_bbox["y"] + face_bbox["height"]
-    crop_right = crop_x + crop_size
-    crop_bottom = crop_y + crop_size
-
-    if (
-        face_bbox["x"] < crop_x
-        or face_bbox["y"] < crop_y
-        or face_right > crop_right
-        or face_bottom > crop_bottom
-    ):
-        if face_bbox["x"] < crop_x:
-            crop_x = face_bbox["x"]
-        elif face_right > crop_right:
-            crop_x = face_right - crop_size
-
-        if face_bbox["y"] < crop_y:
-            crop_y = face_bbox["y"]
-        elif face_bottom > crop_bottom:
-            crop_y = face_bottom - crop_size
-
-        crop_x = max(0, crop_x)
-        crop_y = max(0, crop_y)
-        crop_x = min(video_width - crop_size, crop_x)
-        crop_y = min(video_height - crop_size, crop_y)
-
-    return {"x": crop_x, "y": crop_y, "width": crop_size, "height": crop_size}
-
-
-def detect_face_region(
-    video_path: str,
-    output_dir: str,
-    crop_size: int = 512,
-    sample_count: int = 20,
-    min_confidence: float = 0.5,
-    min_face_pixels: int = 100,
-    max_face_movement_percent: float = 0.3,
-) -> Dict:
-    """Main function: Detect face and calculate safe crop
-
-    Args:
-        video_path: Path to video
-        output_dir: Directory for temporary files
-        crop_size: Size of crop region (default: 512)
-        sample_count: Number of frames to sample (default: 20)
-        min_confidence: Minimum detection confidence
-        min_face_pixels: Minimum face size in pixels
-        max_face_movement_percent: Max allowed face movement
-
-    Returns:
-        Dict: {"x", "y", "width", "height", "face_bbox"}
-
-    Raises:
-        FaceDetectionError: If face detection fails
-    """
-    try:
-        logger.info(f"Starting face detection for: {video_path}")
-        video_info = get_video_info(video_path)
-        video_w, video_h = video_info["width"], video_info["height"]
-        logger.info(
-            f"Video: {video_w}x{video_h}, {video_info['fps']:.1f}fps, {video_info['duration']:.1f}s"
-        )
-
-        if video_w < crop_size or video_h < crop_size:
-            raise FaceDetectionError(
-                f"Video resolution {video_w}x{video_h} < {crop_size}x{crop_size}. "
-                f"Please upload higher resolution video."
-            )
-
-        extracted_frames = sample_frames_from_video(
-            video_path, output_dir, sample_count
-        )
-        logger.info(f"Sampled {len(extracted_frames)} frames for detection")
-
-        detections = detect_faces_in_frames(
-            extracted_frames, min_confidence, min_face_pixels
-        )
-
-        if not detections:
-            raise FaceDetectionError(
-                f"No face detected in {sample_count} sampled frames. "
-                f"Please upload a video with a visible face."
-            )
-
-        logger.info(f"Found {len(detections)} face detections")
-
-        frames_with_face = len(set(d["frame_idx"] for d in detections))
-        face_coverage = frames_with_face / len(extracted_frames)
-        logger.info(
-            f"Face coverage: {frames_with_face}/{len(extracted_frames)} ({face_coverage * 100:.1f}%)"
-        )
-
-        if face_coverage < 0.5:
-            raise FaceDetectionError(
-                f"Face detected in only {frames_with_face}/{len(extracted_frames)} frames "
-                f"({face_coverage * 100:.1f}%). "
-                f"Please upload a video with a visible face."
-            )
-
-        clusters = cluster_face_detections(detections)
-        logger.info(f"Grouped into {len(clusters)} face clusters")
-
-        best_cluster = select_best_cluster(clusters)
-
-        if best_cluster is None:
-            raise FaceDetectionError(
-                f"Failed to identify main face in video. "
-                f"Please upload a video with a clear, visible face."
-            )
-
-        logger.info(f"Selected main face cluster with {len(best_cluster)} detections")
-
-        if not verify_face_stability(best_cluster, max_face_movement_percent):
-            raise FaceDetectionError(
-                f"Face moves too much between frames. "
-                f"Please upload a video with a stable face position."
-            )
-
-        logger.info("Face stability check passed")
-
-        face_bbox = calculate_face_bbox_from_cluster(best_cluster)
-        crop_bbox = calculate_safe_crop_size(face_bbox, video_w, video_h, crop_size)
-
-        crop_bbox["face_bbox"] = face_bbox
-
-        logger.info(
-            f"Face detected at ({face_bbox['x']}, {face_bbox['y']}) "
-            f"size {face_bbox['width']}x{face_bbox['height']}, "
-            f"crop at ({crop_bbox['x']}, {crop_bbox['y']})"
-        )
-        logger.info("Face detection completed successfully")
-
-        return crop_bbox
-
-    except FaceDetectionError:
-        raise
-    except Exception as e:
-        logger.error(f"Face detection failed: {e}")
-        raise FaceDetectionError(f"Face detection failed: {str(e)}")
-
-
-def crop_video_to_size(
-    video_path: str, crop_bbox: Dict, output_dir: str, crop_size: int = 512
-) -> str:
-    """Crop video to specified size using calculated bbox
-
-    Args:
-        video_path: Path to input video
-        crop_bbox: Crop region {"x", "y", "width", "height"}
-        output_dir: Directory to save output
-        crop_size: Size of crop region (default: 512)
-
-    Returns:
-        Path to cropped video
-    """
-    output_path = os.path.join(output_dir, f"face_cropped_{crop_size}x{crop_size}.mp4")
-
-    logger.info(
-        f"Crop box: x={crop_bbox['x']}, y={crop_bbox['y']}, "
-        f"width={crop_bbox['width']}, height={crop_bbox['height']}"
-    )
-
-    ffmpeg = FFmpeg(
-        inputs={video_path: None},
-        outputs={
-            output_path: [
-                "-vf",
-                f"crop={crop_bbox['width']}:{crop_bbox['height']}:{crop_bbox['x']}:{crop_bbox['y']}",
-                "-c:v",
-                "libx264",
-                "-preset",
-                "slow",
-                "-crf",
-                "18",
-                "-profile:v",
-                "high",
-                "-pix_fmt",
-                "yuv420p",
-                "-c:a",
-                "copy",
-                "-loglevel",
-                "error",
-                "-y",
-            ]
-        },
-    )
-    try:
-        ffmpeg.run()
-    except FFRuntimeError as e:
-        logger.error(f"FFmpeg failed: {e}")
-        raise
-    logger.info(f"Cropped video to {crop_size}x{crop_size}: {output_path}")
-    return output_path
-
-
-def blend_face_into_original(
-    original_video: str,
-    face_video: str,
-    crop_bbox: Dict,
-    output_dir: str,
-    lipsynced_info: Dict | None = None,
-    feather: int = 15,
-) -> str:
-    """Blend face video back into original video with edge feather only
-
-    Args:
-        original_video: Path to original video
-        face_video: Path to lipsynced face video (cropped)
-        crop_bbox: Crop region {"x", "y", "width", "height"}
-        output_dir: Directory to save output
-        lipsynced_info: Info of lipsynced video {"width", "height"} (optional)
-        feather: Feather radius for smooth blending at edges
-
-    Returns:
-        Path to blended video
-    """
-    output_path = os.path.join(output_dir, "face_blended.mp4")
-
-    overlay_x = crop_bbox["x"]
-    overlay_y = crop_bbox["y"]
-
-    if lipsynced_info:
-        face_width = lipsynced_info["width"]
-        face_height = lipsynced_info["height"]
-        logger.info(
-            f"Blending {face_width}x{face_height} at ({overlay_x}, {overlay_y}) "
-            f"(crop_bbox: {crop_bbox})"
-        )
-    else:
-        face_width = crop_bbox["width"]
-        face_height = crop_bbox["height"]
-        logger.info(f"Blending at ({overlay_x}, {overlay_y})")
-
-    mask_w = face_width
-    mask_h = face_height
-
-    feather_radius = 50
-
-    ffmpeg = FFmpeg(
-        inputs={original_video: None, face_video: None},
-        outputs={
-            output_path: [
-                "-filter_complex",
-                f"[0:v][1:v]overlay={overlay_x}:{overlay_y}",
-                "-c:v",
-                "libx264",
-                "-preset",
-                "slow",
-                "-crf",
-                "18",
-                "-profile:v",
-                "high",
-                "-pix_fmt",
-                "yuv420p",
-                "-threads",
-                "0",
-                "-movflags",
-                "+faststart",
-                "-c:a",
-                "copy",
-                "-loglevel",
-                "error",
-                "-y",
-            ]
-        },
-    )
-    try:
-        ffmpeg.run()
-    except FFRuntimeError as e:
-        logger.error(f"FFmpeg failed: {e}")
-        raise
-    logger.info(f"Blended face into original: {output_path}")
-    return output_path
+"""Face detection and region extraction for lipsync optimization (DEPRECATED - Pipeline handles this automatically)"""
+
+# NOTE: All functions in this module are DEPRECATED.
+# The lipsync pipeline (latentsync/pipelines/lipsync_pipeline.py) now handles:
+# - Face detection
+# - Affine transformation
+# - Crop
+# - Restore
+# These functions are kept for reference but not used in the new workflow.
+
+# import os
+# import math
+# import logging
+# from typing import List, Dict, Tuple, Optional
+#
+# import cv2
+# import numpy as np
+# import mediapipe as mp
+# from ffmpy import FFmpeg, FFRuntimeError
+#
+# from video_processing import get_video_info
+#
+# logger = logging.getLogger(__name__)
+#
+#
+# class FaceDetectionError(Exception):
+#     """Custom exception for face detection errors"""
+#
+#     pass
+#
+#
+# def sample_frames_from_video(
+#     video_path: str, output_dir: str, sample_count: int = 5
+# ) -> List[Tuple[int, str]]:
+#     """Extract uniform sample frames from video using OpenCV CUDA (HuggingFace)
+#
+#     Args:
+#         video_path: Path to video
+#         output_dir: Directory to save extracted frames
+#         sample_count: Number of frames to sample
+#
+#     Returns:
+#         List of (frame_index, frame_path) tuples
+#     """
+#     video_info = get_video_info(video_path)
+#     fps = video_info["fps"]
+#     duration = video_info["duration"]
+#     total_frames = int(duration * fps)
+#
+#     frames_dir = os.path.join(output_dir, "sampled_frames")
+#     os.makedirs(frames_dir, exist_ok=True)
+#
+#     if total_frames <= sample_count:
+#         frame_indices = list(range(total_frames))
+#     else:
+#         frame_indices = [
+#             int(i * total_frames / sample_count) for i in range(sample_count)
+#         ]
+#
+#     extracted_frames = []
+#     cap = cv2.VideoCapture(video_path)
+#
+#     try:
+#         for idx, frame_idx in enumerate(frame_indices):
+#             cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+#             ret, frame = cap.read()
+#
+#             if not ret or frame is None:
+#                 logger.warning(f"Failed to read frame {frame_idx}")
+#                 continue
+#
+#             frame_path = os.path.join(frames_dir, f"frame_{idx:04d}.jpg")
+#             cv2.imwrite(frame_path, frame, [cv2.IMWRITE_JPEG_QUALITY, 90])
+#             extracted_frames.append((frame_idx, frame_path))
+#     finally:
+#         cap.release()
+#
+#     logger.info(f"Extracted {len(extracted_frames)} frames from {video_path}")
+#     return extracted_frames
+#
+#
+# def detect_faces_in_frames(
+#     extracted_frames: List[Tuple[int, str]],
+#     min_confidence: float = 0.5,
+#     min_face_pixels: int = 100,
+# ) -> List[Dict]:
+#     """Detect faces in all sampled frames using MediaPipe Face Detection API
+#
+#     Args:
+#         extracted_frames: List of (frame_index, frame_path) tuples
+#         min_confidence: Minimum detection confidence (0-1)
+#         min_face_pixels: Minimum face size in pixels
+#
+#     Returns:
+#         List of detections: [{"frame_idx", "confidence", "bbox": (x, y, w, h)}]
+#     """
+#     detections = []
+#
+#     with mp.solutions.face_detection.FaceDetection(
+#         model_selection=0, min_detection_confidence=min_confidence
+#     ) as face_detection:
+#         for frame_idx, frame_path in extracted_frames:
+#             frame = cv2.imread(frame_path)
+#             if frame is None:
+#                 logger.warning(f"Failed to read frame: {frame_path}")
+#                 continue
+#
+#             h, w = frame.shape[:2]
+#             frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+#
+#             results = face_detection.process(frame_rgb)
+#
+#             if results.detections:
+#                 for detection in results.detections:
+#                     bbox = detection.location_data.relative_bounding_box
+#
+#                     x = int(bbox.xmin * w)
+#                     y = int(bbox.ymin * h)
+#                     face_w = int(bbox.width * w)
+#                     face_h = int(bbox.height * h)
+#
+#                     x = max(0, x)
+#                     y = max(0, y)
+#                     face_w = min(w - x, face_w)
+#                     face_h = min(h - y, face_h)
+#
+#                     confidence = detection.score[0] if detection.score else 0.0
+#
+#                     if face_w >= min_face_pixels and face_h >= min_face_pixels:
+#                         detections.append(
+#                             {
+#                                 "frame_idx": frame_idx,
+#                                 "confidence": float(confidence),
+#                                 "bbox": (x, y, face_w, face_h),
+#                             }
+#                         )
+#
+#     logger.info(f"Detected {len(detections)} faces in {len(extracted_frames)} frames")
+#     return detections
+#
+#
+# def cluster_face_detections(
+#     detections: List[Dict], max_distance: int = 100
+# ) -> List[List[Dict]]:
+#     """Group face detections belonging to the same person using clustering
+#
+#     Args:
+#         detections: List of face detections
+#         max_distance: Maximum distance (pixels) to consider detections as same person
+#
+#     Returns:
+#         List of clusters (each cluster is a list of detections)
+#     """
+#     if not detections:
+#         return []
+#
+#     clusters = []
+#     visited = set()
+#
+#     for i, det_i in enumerate(detections):
+#         if i in visited:
+#             continue
+#
+#         x_i, y_i, w_i, h_i = det_i["bbox"]
+#         center_i = (x_i + w_i / 2, y_i + h_i / 2)
+#
+#         cluster = [det_i]
+#         visited.add(i)
+#
+#         for j, det_j in enumerate(detections):
+#             if j in visited:
+#                 continue
+#
+#             x_j, y_j, w_j, h_j = det_j["bbox"]
+#             center_j = (x_j + w_j / 2, y_j + h_j / 2)
+#
+#             distance = math.sqrt(
+#                 (center_i[0] - center_j[0]) ** 2 + (center_i[1] - center_j[1]) ** 2
+#             )
+#
+#             if distance < max_distance:
+#                 cluster.append(det_j)
+#                 visited.add(j)
+#
+#         clusters.append(cluster)
+#
+#     logger.info(f"Clustered {len(detections)} detections into {len(clusters)} clusters")
+#     return clusters
+#
+#
+# def select_best_cluster(clusters: List[List[Dict]]) -> Optional[List[Dict]]:
+#     """Select the best face cluster (highest frequency)
+#
+#     Args:
+#         clusters: List of clusters
+#
+#     Returns:
+#         Best cluster (most frequent) or None
+#     """
+#     if not clusters:
+#         return None
+#
+#     scored_clusters = [(len(cluster), cluster) for cluster in clusters]
+#     scored_clusters.sort(key=lambda x: x[0], reverse=True)
+#
+#     best_cluster = scored_clusters[0][1]
+#     logger.info(f"Selected best cluster with {len(best_cluster)} detections")
+#     return best_cluster
+#
+#
+# def verify_face_stability(
+#     cluster: List[Dict], max_movement_percent: float = 0.3
+# ) -> bool:
+#     """Verify face doesn't move too much between frames
+#
+#     Args:
+#         cluster: Face detections for the same person
+#         max_movement_percent: Max movement as percentage of average face size
+#
+#     Returns:
+#         True if face is stable, False otherwise
+#     """
+#     if len(cluster) < 2:
+#         return True
+#
+#     centers = []
+#     sizes = []
+#
+#     for det in cluster:
+#         x, y, w, h = det["bbox"]
+#         centers.append((x + w / 2, y + h / 2))
+#         sizes.append(w * h)
+#
+#     avg_size = sum(sizes) / len(sizes)
+#     avg_face_dim = math.sqrt(avg_size)
+#     max_allowed_movement = avg_face_dim * max_movement_percent
+#
+#     for i in range(len(centers) - 1):
+#         dx = abs(centers[i + 1][0] - centers[i][0])
+#         dy = abs(centers[i + 1][1] - centers[i][1])
+#         movement = math.sqrt(dx**2 + dy**2)
+#
+#         if movement > max_allowed_movement:
+#             logger.warning(
+#                 f"Face movement {movement:.1f}px > {max_allowed_movement:.1f}px"
+#             )
+#             return False
+#
+#     return True
+#
+#
+# def calculate_face_bbox_from_cluster(cluster: List[Dict]) -> Dict:
+#     """Calculate average face bounding box from cluster
+#
+#     Args:
+#         cluster: Face detections for the same person
+#
+#     Returns:
+#         Dict: {"x", "y", "width", "height"}
+#     """
+#     weighted_x = 0
+#     weighted_y = 0
+#     weighted_w = 0
+#     weighted_h = 0
+#     total_weight = 0
+#
+#     for det in cluster:
+#         x, y, w, h = det["bbox"]
+#         weight = det["confidence"]
+#         weighted_x += x * weight
+#         weighted_y += y * weight
+#         weighted_w += w * weight
+#         weighted_h += h * weight
+#         total_weight += weight
+#
+#     avg_bbox = {
+#         "x": int(weighted_x / total_weight),
+#         "y": int(weighted_y / total_weight),
+#         "width": int(weighted_w / total_weight),
+#         "height": int(weighted_h / total_weight),
+#     }
+#
+#     return avg_bbox
+#
+#
+# def calculate_safe_crop_size(
+#     face_bbox: Dict, video_width: int, video_height: int, crop_size: int = 512
+# ) -> Dict:
+#     """Calculate safe crop region ensuring face is inside
+#
+#     Args:
+#         face_bbox: Face bounding box {"x", "y", "width", "height"}
+#         video_width: Video width
+#         video_height: Video height
+#         crop_size: Size of crop region (default: 512)
+#
+#     Returns:
+#         Dict: {"x", "y", "width", "height"}
+#     """
+#     crop_half = crop_size // 2
+#
+#     face_center_x = face_bbox["x"] + face_bbox["width"] / 2
+#     face_center_y = face_bbox["y"] + face_bbox["height"] / 2
+#
+#     crop_x = int(face_center_x - crop_half)
+#     crop_y = int(face_center_y - crop_half)
+#
+#     crop_x = max(0, crop_x)
+#     crop_y = max(0, crop_y)
+#     crop_x = min(video_width - crop_size, crop_x)
+#     crop_y = min(video_height - crop_size, crop_y)
+#
+#     face_right = face_bbox["x"] + face_bbox["width"]
+#     face_bottom = face_bbox["y"] + face_bbox["height"]
+#     crop_right = crop_x + crop_size
+#     crop_bottom = crop_y + crop_size
+#
+#     if (
+#         face_bbox["x"] < crop_x
+#         or face_bbox["y"] < crop_y
+#         or face_right > crop_right
+#         or face_bottom > crop_bottom
+#     ):
+#         if face_bbox["x"] < crop_x:
+#             crop_x = face_bbox["x"]
+#         elif face_right > crop_right:
+#             crop_x = face_right - crop_size
+#
+#         if face_bbox["y"] < crop_y:
+#             crop_y = face_bbox["y"]
+#         elif face_bottom > crop_bottom:
+#             crop_y = face_bottom - crop_size
+#
+#         crop_x = max(0, crop_x)
+#         crop_y = max(0, crop_y)
+#         crop_x = min(video_width - crop_size, crop_x)
+#         crop_y = min(video_height - crop_size, crop_y)
+#
+#     return {"x": crop_x, "y": crop_y, "width": crop_size, "height": crop_size}
+#
+#
+# def detect_face_region(
+#     video_path: str,
+#     output_dir: str,
+#     crop_size: int = 512,
+#     sample_count: int = 20,
+#     min_confidence: float = 0.5,
+#     min_face_pixels: int = 100,
+#     max_face_movement_percent: float = 0.3,
+# ) -> Dict:
+#     """Main function: Detect face and calculate safe crop (DEPRECATED - Pipeline handles this)
+#
+#     Args:
+#         video_path: Path to video
+#         output_dir: Directory for temporary files
+#         crop_size: Size of crop region (default: 512)
+#         sample_count: Number of frames to sample (default: 20)
+#         min_confidence: Minimum detection confidence
+#         min_face_pixels: Minimum face size in pixels
+#         max_face_movement_percent: Max allowed face movement
+#
+#     Returns:
+#         Dict: {"x", "y", "width", "height", "face_bbox"}
+#
+#     Raises:
+#         FaceDetectionError: If face detection fails
+#     """
+#     try:
+#         logger.info(f"Starting face detection for: {video_path}")
+#         video_info = get_video_info(video_path)
+#         video_w, video_h = video_info["width"], video_info["height"]
+#         logger.info(
+#             f"Video: {video_w}x{video_h}, {video_info['fps']:.1f}fps, {video_info['duration']:.1f}s"
+#         )
+#
+#         if video_w < crop_size or video_h < crop_size:
+#             raise FaceDetectionError(
+#                 f"Video resolution {video_w}x{video_h} < {crop_size}x{crop_size}. "
+#                 f"Please upload higher resolution video."
+#             )
+#
+#         extracted_frames = sample_frames_from_video(
+#             video_path, output_dir, sample_count
+#         )
+#         logger.info(f"Sampled {len(extracted_frames)} frames for detection")
+#
+#         detections = detect_faces_in_frames(
+#             extracted_frames, min_confidence, min_face_pixels
+#         )
+#
+#         if not detections:
+#             raise FaceDetectionError(
+#                 f"No face detected in {sample_count} sampled frames. "
+#                 f"Please upload a video with a visible face."
+#             )
+#
+#         logger.info(f"Found {len(detections)} face detections")
+#
+#         frames_with_face = len(set(d["frame_idx"] for d in detections))
+#         face_coverage = frames_with_face / len(extracted_frames)
+#         logger.info(
+#             f"Face coverage: {frames_with_face}/{len(extracted_frames)} ({face_coverage * 100:.1f}%)"
+#         )
+#
+#         if face_coverage < 0.5:
+#             raise FaceDetectionError(
+#                 f"Face detected in only {frames_with_face}/{len(extracted_frames)} frames "
+#                 f"({face_coverage * 100:.1f}%). "
+#                 f"Please upload a video with a visible face."
+#             )
+#
+#         clusters = cluster_face_detections(detections)
+#         logger.info(f"Grouped into {len(clusters)} face clusters")
+#
+#         best_cluster = select_best_cluster(clusters)
+#
+#         if best_cluster is None:
+#             raise FaceDetectionError(
+#                 f"Failed to identify main face in video. "
+#                 f"Please upload a video with a clear, visible face."
+#             )
+#
+#         logger.info(f"Selected main face cluster with {len(best_cluster)} detections")
+#
+#         if not verify_face_stability(best_cluster, max_face_movement_percent):
+#             raise FaceDetectionError(
+#                 f"Face moves too much between frames. "
+#                 f"Please upload a video with a stable face position."
+#             )
+#
+#         logger.info("Face stability check passed")
+#
+#         face_bbox = calculate_face_bbox_from_cluster(best_cluster)
+#         crop_bbox = calculate_safe_crop_size(face_bbox, video_w, video_h, crop_size)
+#
+#         crop_bbox["face_bbox"] = face_bbox
+#
+#         logger.info(
+#             f"Face detected at ({face_bbox['x']}, {face_bbox['y']}) "
+#             f"size {face_bbox['width']}x{face_bbox['height']}, "
+#             f"crop at ({crop_bbox['x']}, {crop_bbox['y']})"
+#         )
+#         logger.info("Face detection completed successfully")
+#
+#         return crop_bbox
+#
+#     except FaceDetectionError:
+#         raise
+#     except Exception as e:
+#         logger.error(f"Face detection failed: {e}")
+#         raise FaceDetectionError(f"Face detection failed: {str(e)}")
+#
+#
+# def crop_video_to_size(
+#     video_path: str, crop_bbox: Dict, output_dir: str, crop_size: int = 512
+# ) -> str:
+#     """Crop video to specified size using calculated bbox (DEPRECATED - Pipeline handles this)
+#
+#     Args:
+#         video_path: Path to input video
+#         crop_bbox: Crop region {"x", "y", "width", "height"}
+#         output_dir: Directory to save output
+#         crop_size: Size of crop region (default: 512)
+#
+#     Returns:
+#         Path to cropped video
+#     """
+#     output_path = os.path.join(output_dir, f"face_cropped_{crop_size}x{crop_size}.mp4")
+#
+#     logger.info(
+#         f"Crop box: x={crop_bbox['x']}, y={crop_bbox['y']}, "
+#         f"width={crop_bbox['width']}, height={crop_bbox['height']}"
+#     )
+#
+#     ffmpeg = FFmpeg(
+#         inputs={video_path: None},
+#         outputs={
+#             output_path: [
+#                 "-vf",
+#                 f"crop={crop_bbox['width']}:{crop_bbox['height']}:{crop_bbox['x']}:{crop_bbox['y']}",
+#                 "-c:v",
+#                 "libx264",
+#                 "-preset",
+#                 "slow",
+#                 "-crf",
+#                 "18",
+#                 "-profile:v",
+#                 "high",
+#                 "-pix_fmt",
+#                 "yuv420p",
+#                 "-c:a",
+#                 "copy",
+#                 "-loglevel",
+#                 "error",
+#                 "-y",
+#             ]
+#         },
+#     )
+#     try:
+#         ffmpeg.run()
+#     except FFRuntimeError as e:
+#         logger.error(f"FFmpeg failed: {e}")
+#         raise
+#     logger.info(f"Cropped video to {crop_size}x{crop_size}: {output_path}")
+#     return output_path
+#
+#
+# def blend_face_into_original(
+#     original_video: str,
+#     face_video: str,
+#     crop_bbox: Dict,
+#     output_dir: str,
+#     lipsynced_info: Dict | None = None,
+#     feather: int = 15,
+# ) -> str:
+#     """Blend face video back into original video with edge feather only (DEPRECATED - Pipeline handles this)
+#
+#     Args:
+#         original_video: Path to original video
+#         face_video: Path to lipsynced face video (cropped)
+#         crop_bbox: Crop region {"x", "y", "width", "height"}
+#         output_dir: Directory to save output
+#         lipsynced_info: Info of lipsynced video {"width", "height"} (optional)
+#         feather: Feather radius for smooth blending at edges
+#
+#     Returns:
+#         Path to blended video
+#     """
+#     output_path = os.path.join(output_dir, "face_blended.mp4")
+#
+#     overlay_x = crop_bbox["x"]
+#     overlay_y = crop_bbox["y"]
+#
+#     if lipsynced_info:
+#         face_width = lipsynced_info["width"]
+#         face_height = lipsynced_info["height"]
+#         logger.info(
+#             f"Blending {face_width}x{face_height} at ({overlay_x}, {overlay_y}) "
+#             f"(crop_bbox: {crop_bbox})"
+#         )
+#     else:
+#         face_width = crop_bbox["width"]
+#         face_height = crop_bbox["height"]
+#         logger.info(f"Blending at ({overlay_x}, {overlay_y})")
+#
+#     mask_w = face_width
+#     mask_h = face_height
+#
+#     feather_radius = 50
+#
+#     ffmpeg = FFmpeg(
+#         inputs={original_video: None, face_video: None},
+#         outputs={
+#             output_path: [
+#                 "-filter_complex",
+#                 f"[0:v][1:v]overlay={overlay_x}:{overlay_y}",
+#                 "-c:v",
+#                 "libx264",
+#                 "-preset",
+#                 "slow",
+#                 "-crf",
+#                 "18",
+#                 "-profile:v",
+#                 "high",
+#                 "-pix_fmt",
+#                 "yuv420p",
+#                 "-threads",
+#                 "0",
+#                 "-movflags",
+#                 "+faststart",
+#                 "-c:a",
+#                 "copy",
+#                 "-loglevel",
+#                 "error",
+#                 "-y",
+#             ]
+#         },
+#     )
+#     try:
+#         ffmpeg.run()
+#     except FFRuntimeError as e:
+#         logger.error(f"FFmpeg failed: {e}")
+#         raise
+#     logger.info(f"Blended face into original: {output_path}")
+#     return output_path

processing.py

@@ -12,22 +12,16 @@ import torch
 
 from audio_processing import (
     get_audio_duration,
-    prepare_target_audio,
+    prepare_audio_for_lipsync,
+    prepare_audio_for_youtube_aac,
     prepare_audio_for_youtube,
 )
 from config import PROCESSED_RESULTS_DIR
-from face_processing import (
-    blend_face_into_original,
-    calculate_safe_crop_size,
-    crop_video_to_size,
-    detect_face_region,
-    FaceDetectionError,
-)
 from lipsync_processing import apply_lipsync_to_video, get_video_info
 from time_util import timer
 from utils import setup_output_dir
 from video_processing import (
-    loop_video_to_match_audio,
+    normalize_video_for_youtube,
     merge_audio_video,
 )
 
@@ -88,31 +82,270 @@ def validate_input(video_file, audio_file):
     return video_path, audio_path
 
 
-def process_lipsync_with_audio_target(
+# def process_lipsync_with_audio_target(
+#     video_file,
+#     audio_file,
+#     session_id=None,
+#     crop_size=256,
+#     progress=gr.Progress(track_tqdm=True),
+# ):
+#     """Lipsync video source với audio target (DEPRECATED - use process_lipsync_with_audio_target_new)
+#
+#     Args:
+#         video_file: Path to video source
+#         audio_file: Path to audio target (English only)
+#         session_id: Session identifier
+#         crop_size: Size of crop region (256 or 512)
+#         progress: Progress tracking object
+#
+#     Returns:
+#         Tuple of (final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full)
+#     """
+#     video_looped = None
+#     face_cropped = None
+#     lipsynced_face = None
+#     lipsynced_full = None
+#     final_video = None
+#     error_msg = None
+#
+#     try:
+#         video_path, audio_path = validate_input(video_file, audio_file)
+#
+#         output_dir = setup_output_dir(session_id)
+#
+#         logger.info(f"Memory at start: {get_memory_usage()}")
+#
+#         audio_duration = get_audio_duration(audio_path)
+#
+#         progress(0.1, desc="🎬 Đang chuẩn bị video...")
+#         logger.info(f"Memory before video loop: {get_memory_usage()}")
+#
+#         with timer("Looping/cropping video to match audio"):
+#             try:
+#                 video_looped = loop_video_to_match_audio(
+#                     video_path, audio_duration, output_dir
+#                 )
+#             except Exception as e:
+#                 error_msg = f"Video loop failed: {str(e)}"
+#                 logger.error(error_msg)
+#                 traceback.print_exc()
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         gc.collect()
+#         logger.info(f"Memory after video loop: {get_memory_usage()}")
+#
+#         progress(0.2, desc="👤 Đang phát hiện khuôn mặt...")
+#         with timer("Detecting face"):
+#             try:
+#                 face_bbox = detect_face_region(video_looped, output_dir, crop_size)
+#             except FaceDetectionError as e:
+#                 error_msg = str(e)
+#                 logger.error(f"Face detection failed: {e}")
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         gc.collect()
+#         logger.info(f"Memory after face detection: {get_memory_usage()}")
+#
+#         actual_crop_size = crop_size * 2
+#         progress(
+#             0.25, desc=f"👤 Đang tính lại crop {actual_crop_size}x{actual_crop_size}..."
+#         )
+#         with timer(
+#             f"Recalculating crop bbox for {actual_crop_size}x{actual_crop_size}"
+#         ):
+#             from video_processing import get_video_info
+#
+#             try:
+#                 video_info = get_video_info(video_looped)
+#                 crop_bbox = calculate_safe_crop_size(
+#                     face_bbox["face_bbox"],
+#                     video_info["width"],
+#                     video_info["height"],
+#                     actual_crop_size,
+#                 )
+#             except Exception as e:
+#                 error_msg = f"Calculate crop bbox failed: {str(e)}"
+#                 logger.error(error_msg)
+#                 traceback.print_exc()
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         progress(
+#             0.3, desc=f"✂️ Đang crop video {actual_crop_size}x{actual_crop_size}..."
+#         )
+#         with timer(f"Cropping video to {actual_crop_size}x{actual_crop_size}"):
+#             try:
+#                 face_cropped = crop_video_to_size(
+#                     video_looped, crop_bbox, output_dir, actual_crop_size
+#                 )
+#             except Exception as e:
+#                 error_msg = f"Crop video failed: {str(e)}"
+#                 logger.error(error_msg)
+#                 traceback.print_exc()
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         gc.collect()
+#         logger.info(f"Memory after crop: {get_memory_usage()}")
+#
+#         progress(0.4, desc="🎵 Đang xử lý audio...")
+#         logger.info(f"Memory before audio prep: {get_memory_usage()}")
+#
+#         with timer("Preparing target audio"):
+#             try:
+#                 audio_16k, audio_upsampled = prepare_target_audio(
+#                     audio_path, output_dir
+#                 )
+#             except Exception as e:
+#                 error_msg = f"Prepare audio failed: {str(e)}"
+#                 logger.error(error_msg)
+#                 traceback.print_exc()
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         gc.collect()
+#         logger.info(f"Memory after audio prep: {get_memory_usage()}")
+#
+#         progress(0.6, desc="👄 Đang lipsync...")
+#
+#         video_info = get_video_info(face_cropped)
+#         logger.info(
+#             f"Starting lipsync: video={face_cropped}, audio_16k={audio_16k}, output={output_dir}"
+#         )
+#         logger.info(
+#             f"Video info: {video_info['width']}x{video_info['height']}, {video_info['fps']:.1f}fps, {video_info['duration']:.1f}s"
+#         )
+#         logger.info(f"Memory before lipsync: {get_memory_usage()}")
+#
+#         with timer("Applying lipsync"):
+#             try:
+#                 lipsynced_face, lipsynced_info = apply_lipsync_to_video(
+#                     face_cropped, audio_16k, output_dir, crop_size
+#                 )
+#                 logger.info(
+#                     f"Lipsynced video size: {lipsynced_info['width']}x{lipsynced_info['height']}"
+#                 )
+#             except Exception as e:
+#                 error_msg = f"Lipsync failed: {str(e)}"
+#                 logger.error(f"Lipsync failed with error: {type(e).__name__}: {e}")
+#                 logger.error(f"Memory after crash: {get_memory_usage()}")
+#                 traceback.print_exc()
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         gc.collect()
+#         logger.info(f"Memory after lipsync: {get_memory_usage()}")
+#
+#         progress(0.8, desc="🔀 Đang ghép video...")
+#         with timer("Blending face into original"):
+#             try:
+#                 lipsynced_full = blend_face_into_original(
+#                     video_looped, lipsynced_face, crop_bbox, output_dir, lipsynced_info
+#                 )
+#             except Exception as e:
+#                 error_msg = f"Blend video failed: {str(e)}"
+#                 logger.error(error_msg)
+#                 traceback.print_exc()
+#                 return (
+#                     final_video,
+#                     video_looped,
+#                     face_cropped,
+#                     lipsynced_face,
+#                     lipsynced_full,
+#                 )
+#
+#         gc.collect()
+#         logger.info(f"Memory after blend: {get_memory_usage()}")
+#
+#         progress(0.9, desc="🔗 Đang ghép audio...")
+#         try:
+#             audio_final = prepare_audio_for_youtube(audio_upsampled, output_dir)
+#             final_video = merge_audio_video(lipsynced_full, audio_final, output_dir)
+#         except Exception as e:
+#             error_msg = f"Merge audio failed: {str(e)}"
+#             logger.error(error_msg)
+#             traceback.print_exc()
+#             return (
+#                 final_video,
+#                 video_looped,
+#                 face_cropped,
+#                 lipsynced_face,
+#                 lipsynced_full,
+#             )
+#
+#         progress(1.0, desc="✅ Hoàn tất!")
+#         logger.info(f"Memory at end: {get_memory_usage()}")
+#
+#         return final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full
+#
+#     except Exception as e:
+#         print(f"ERROR in process_lipsync_with_audio_target: {e}")
+#         traceback.print_exc()
+#         return final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full
+
+
+def process_lipsync_with_audio_target_new(
     video_file,
     audio_file,
     session_id=None,
     crop_size=256,
     progress=gr.Progress(track_tqdm=True),
 ):
-    """Lipsync video source với audio target
+    """Workflow mới: Chuẩn hóa YouTube rồi lipsync
+
+    Steps:
+    1. Validate inputs
+    2. Chuẩn hóa video YouTube (loop/crop + re-encode)
+    3. Chuẩn hóa audio YouTube (AAC 320k)
+    4. Chuẩn bị audio 16k cho lipsync
+    5. Lipsync pipeline (tự detect/crop/lipsync/restore)
+    6. Merge audio YouTube + video lipsynced
 
     Args:
         video_file: Path to video source
         audio_file: Path to audio target (English only)
         session_id: Session identifier
-        crop_size: Size of crop region (256 or 512)
+        crop_size: Size cho lipsync (256 or 512)
         progress: Progress tracking object
 
     Returns:
-        Tuple of (final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full)
+        Tuple of (final_video, video_normalized, lipsynced_video)
     """
-    video_looped = None
-    face_cropped = None
-    lipsynced_face = None
-    lipsynced_full = None
+    video_normalized = None
+    lipsynced_video = None
     final_video = None
-    error_msg = None
 
     try:
         video_path, audio_path = validate_input(video_file, audio_file)
@@ -122,204 +355,105 @@ def process_lipsync_with_audio_target(
         logger.info(f"Memory at start: {get_memory_usage()}")
 
         audio_duration = get_audio_duration(audio_path)
+        logger.info(f"Audio duration: {audio_duration:.2f}s")
 
-        progress(0.1, desc="🎬 Đang chuẩn bị video...")
-        logger.info(f"Memory before video loop: {get_memory_usage()}")
+        progress(0.15, desc="🎬 Đang chuẩn hóa video YouTube...")
+        logger.info(f"Memory before video normalization: {get_memory_usage()}")
 
-        with timer("Looping/cropping video to match audio"):
+        with timer("Normalizing video for YouTube"):
             try:
-                video_looped = loop_video_to_match_audio(
+                video_normalized = normalize_video_for_youtube(
                     video_path, audio_duration, output_dir
                 )
+                video_info = get_video_info(video_normalized)
+                logger.info(
+                    f"Normalized video: {video_info['width']}x{video_info['height']}, "
+                    f"{video_info['fps']:.1f}fps, {video_info['duration']:.1f}s"
+                )
             except Exception as e:
-                error_msg = f"Video loop failed: {str(e)}"
-                logger.error(error_msg)
+                logger.error(f"Video normalization failed: {str(e)}")
                 traceback.print_exc()
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
+                return final_video, video_normalized, lipsynced_video
 
         gc.collect()
-        logger.info(f"Memory after video loop: {get_memory_usage()}")
+        logger.info(f"Memory after video normalization: {get_memory_usage()}")
 
-        progress(0.2, desc="👤 Đang phát hiện khuôn mặt...")
-        with timer("Detecting face"):
-            try:
-                face_bbox = detect_face_region(video_looped, output_dir, crop_size)
-            except FaceDetectionError as e:
-                error_msg = str(e)
-                logger.error(f"Face detection failed: {e}")
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
-
-        gc.collect()
-        logger.info(f"Memory after face detection: {get_memory_usage()}")
-
-        actual_crop_size = crop_size * 2
-        progress(
-            0.25, desc=f"👤 Đang tính lại crop {actual_crop_size}x{actual_crop_size}..."
-        )
-        with timer(
-            f"Recalculating crop bbox for {actual_crop_size}x{actual_crop_size}"
-        ):
-            from video_processing import get_video_info
+        progress(0.25, desc="🎵 Đang chuẩn hóa audio YouTube...")
+        logger.info(f"Memory before audio normalization: {get_memory_usage()}")
 
+        with timer("Normalizing audio for YouTube"):
             try:
-                video_info = get_video_info(video_looped)
-                crop_bbox = calculate_safe_crop_size(
-                    face_bbox["face_bbox"],
-                    video_info["width"],
-                    video_info["height"],
-                    actual_crop_size,
-                )
+                audio_youtube = prepare_audio_for_youtube_aac(audio_path, output_dir)
+                logger.info(f"Audio YouTube: {audio_youtube}")
             except Exception as e:
-                error_msg = f"Calculate crop bbox failed: {str(e)}"
-                logger.error(error_msg)
+                logger.error(f"Audio normalization failed: {str(e)}")
                 traceback.print_exc()
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
-
-        progress(
-            0.3, desc=f"✂️ Đang crop video {actual_crop_size}x{actual_crop_size}..."
-        )
-        with timer(f"Cropping video to {actual_crop_size}x{actual_crop_size}"):
-            try:
-                face_cropped = crop_video_to_size(
-                    video_looped, crop_bbox, output_dir, actual_crop_size
-                )
-            except Exception as e:
-                error_msg = f"Crop video failed: {str(e)}"
-                logger.error(error_msg)
-                traceback.print_exc()
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
+                return final_video, video_normalized, lipsynced_video
 
         gc.collect()
-        logger.info(f"Memory after crop: {get_memory_usage()}")
+        logger.info(f"Memory after audio normalization: {get_memory_usage()}")
 
-        progress(0.4, desc="🎵 Đang xử lý audio...")
-        logger.info(f"Memory before audio prep: {get_memory_usage()}")
+        progress(0.35, desc="🔊 Đang chuẩn bị audio cho lipsync...")
 
-        with timer("Preparing target audio"):
+        with timer("Preparing audio for lipsync"):
             try:
-                audio_16k, audio_upsampled = prepare_target_audio(
-                    audio_path, output_dir
-                )
+                audio_16k = prepare_audio_for_lipsync(audio_path, output_dir)
+                logger.info(f"Audio 16k for lipsync: {audio_16k}")
             except Exception as e:
-                error_msg = f"Prepare audio failed: {str(e)}"
-                logger.error(error_msg)
+                logger.error(f"Audio lipsync preparation failed: {str(e)}")
                 traceback.print_exc()
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
+                return final_video, video_normalized, lipsynced_video
 
         gc.collect()
-        logger.info(f"Memory after audio prep: {get_memory_usage()}")
+        logger.info(f"Memory after audio preparation: {get_memory_usage()}")
 
-        progress(0.6, desc="👄 Đang lipsync...")
+        progress(0.55, desc="👄 Đang lipsync...")
 
-        video_info = get_video_info(face_cropped)
         logger.info(
-            f"Starting lipsync: video={face_cropped}, audio_16k={audio_16k}, output={output_dir}"
-        )
-        logger.info(
-            f"Video info: {video_info['width']}x{video_info['height']}, {video_info['fps']:.1f}fps, {video_info['duration']:.1f}s"
+            f"Starting lipsync: video={video_normalized}, audio_16k={audio_16k}, output={output_dir}"
         )
         logger.info(f"Memory before lipsync: {get_memory_usage()}")
 
         with timer("Applying lipsync"):
             try:
-                lipsynced_face, lipsynced_info = apply_lipsync_to_video(
-                    face_cropped, audio_16k, output_dir, crop_size
+                lipsynced_video, lipsynced_info = apply_lipsync_to_video(
+                    video_normalized, audio_16k, output_dir, crop_size
                 )
                 logger.info(
-                    f"Lipsynced video size: {lipsynced_info['width']}x{lipsynced_info['height']}"
+                    f"Lipsynced video: {lipsynced_video}, size: {lipsynced_info['width']}x{lipsynced_info['height']}"
                 )
             except Exception as e:
-                error_msg = f"Lipsync failed: {str(e)}"
                 logger.error(f"Lipsync failed with error: {type(e).__name__}: {e}")
                 logger.error(f"Memory after crash: {get_memory_usage()}")
                 traceback.print_exc()
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
+                return final_video, video_normalized, lipsynced_video
 
         gc.collect()
         logger.info(f"Memory after lipsync: {get_memory_usage()}")
 
-        progress(0.8, desc="🔀 Đang ghép video...")
-        with timer("Blending face into original"):
+        progress(0.85, desc="🔗 Đang ghép audio YouTube...")
+        logger.info(f"Memory before merge: {get_memory_usage()}")
+
+        with timer("Merging audio and video"):
             try:
-                lipsynced_full = blend_face_into_original(
-                    video_looped, lipsynced_face, crop_bbox, output_dir, lipsynced_info
+                final_video = merge_audio_video(
+                    lipsynced_video, audio_youtube, output_dir
                 )
+                logger.info(f"Final video: {final_video}")
             except Exception as e:
-                error_msg = f"Blend video failed: {str(e)}"
-                logger.error(error_msg)
+                logger.error(f"Merge audio failed: {str(e)}")
                 traceback.print_exc()
-                return (
-                    final_video,
-                    video_looped,
-                    face_cropped,
-                    lipsynced_face,
-                    lipsynced_full,
-                )
-
-        gc.collect()
-        logger.info(f"Memory after blend: {get_memory_usage()}")
-
-        progress(0.9, desc="🔗 Đang ghép audio...")
-        try:
-            audio_final = prepare_audio_for_youtube(audio_upsampled, output_dir)
-            final_video = merge_audio_video(lipsynced_full, audio_final, output_dir)
-        except Exception as e:
-            error_msg = f"Merge audio failed: {str(e)}"
-            logger.error(error_msg)
-            traceback.print_exc()
-            return (
-                final_video,
-                video_looped,
-                face_cropped,
-                lipsynced_face,
-                lipsynced_full,
-            )
+                return final_video, video_normalized, lipsynced_video
 
         progress(1.0, desc="✅ Hoàn tất!")
         logger.info(f"Memory at end: {get_memory_usage()}")
 
-        return final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full
+        return final_video, video_normalized, lipsynced_video
 
     except Exception as e:
-        print(f"ERROR in process_lipsync_with_audio_target: {e}")
+        print(f"ERROR in process_lipsync_with_audio_target_new: {e}")
         traceback.print_exc()
-        return final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full
+        return final_video, video_normalized, lipsynced_video
 
 
 @spaces.GPU(duration=600)
@@ -333,12 +467,12 @@ def lipsync_with_audio_target(
     """Wrapper for Gradio: Lipsync video source with audio target (English only)
 
     Returns:
-        Tuple of (final_video, video_looped, face_cropped, lipsynced_face, lipsynced_full)
+        Tuple of (final_video, video_normalized, lipsynced_video)
     """
     if video_file is None:
         raise gr.Error("Please upload a video source.")
     if audio_file is None:
         raise gr.Error("Please upload a target audio.")
-    return process_lipsync_with_audio_target(
+    return process_lipsync_with_audio_target_new(
         video_file, audio_file, session_id, crop_size, progress
     )

video_processing.py

@@ -18,24 +18,54 @@ from config import (
 )
 
 
-def crop_video_duration(video_path: str, duration: int, output_dir: str) -> str:
-    """Crop video to specified duration using FFmpeg
+# def crop_video_duration(video_path: str, duration: int, output_dir: str) -> str:
+#     """Crop video to specified duration using FFmpeg (DEPRECATED - merged into normalize_video_for_youtube)
+#
+#     Args:
+#         video_path: Path to input video
+#         duration: Duration in seconds
+#         output_dir: Directory to save cropped video
+#
+#     Returns:
+#         Path to cropped video
+#     """
+#     cropped_video_path = os.path.join(output_dir, "input_cropped.mp4")
+#     ffmpeg = FFmpeg(
+#         inputs={video_path: None},
+#         outputs={
+#             cropped_video_path: [
+#                 "-t",
+#                 f"{duration}",
+#                 "-c",
+#                 "copy",
+#                 "-loglevel",
+#                 "error",
+#                 "-y",
+#             ]
+#         },
+#     )
+#     try:
+#         ffmpeg.run()
+#     except FFRuntimeError as e:
+#         raise Exception(f"FFmpeg failed: {e}")
+#     return cropped_video_path
+
+
+def loop_video(video_path: str, output_path: str, loop_count: int) -> str:
+    """Loop video bằng stream_loop với copy codec
 
     Args:
-        video_path: Path to input video
-        duration: Duration in seconds
-        output_dir: Directory to save cropped video
+        video_path: Path video gốc
+        output_path: Path output video đã loop
+        loop_count: Số lần loop
 
     Returns:
-        Path to cropped video
+        Path video đã loop
     """
-    cropped_video_path = os.path.join(output_dir, "input_cropped.mp4")
     ffmpeg = FFmpeg(
-        inputs={video_path: None},
+        inputs={video_path: ["-stream_loop", f"{loop_count}"]},
         outputs={
-            cropped_video_path: [
-                "-t",
-                f"{duration}",
+            output_path: [
                 "-c",
                 "copy",
                 "-loglevel",
@@ -47,8 +77,91 @@ def crop_video_duration(video_path: str, duration: int, output_dir: str) -> str:
     try:
         ffmpeg.run()
     except FFRuntimeError as e:
-        raise Exception(f"FFmpeg failed: {e}")
-    return cropped_video_path
+        raise Exception(f"FFmpeg failed to loop video: {e}")
+    return output_path
+
+
+def encode_video_for_youtube(
+    video_path: str, output_path: str, duration: float | None = None
+) -> str:
+    """Encode video theo tiêu chuẩn YouTube
+
+    Args:
+        video_path: Path video input
+        output_path: Path output video
+        duration: Duration crop (None = không crop)
+
+    Returns:
+        Path video đã encode
+    """
+    ffmpeg_args = [
+        "-c:v",
+        "libx264",
+        "-preset",
+        YOUTUBE_VIDEO_PRESET,
+        "-crf",
+        str(YOUTUBE_VIDEO_CRF),
+        "-profile:v",
+        YOUTUBE_VIDEO_PROFILE,
+        "-level",
+        YOUTUBE_VIDEO_LEVEL,
+        "-pix_fmt",
+        YOUTUBE_VIDEO_PIX_FMT,
+        "-c:a",
+        "copy",
+        "-movflags",
+        "+faststart",
+        "-loglevel",
+        "error",
+        "-y",
+    ]
+
+    if duration is not None:
+        ffmpeg_args = ["-t", f"{duration}"] + ffmpeg_args
+
+    ffmpeg = FFmpeg(
+        inputs={video_path: None},
+        outputs={output_path: ffmpeg_args},
+    )
+    try:
+        ffmpeg.run()
+    except FFRuntimeError as e:
+        raise Exception(f"FFmpeg failed to encode video: {e}")
+    return output_path
+
+
+def normalize_video_for_youtube(
+    video_path: str, audio_duration: float, output_dir: str
+) -> str:
+    """Chuẩn hóa video theo tiêu chuẩn YouTube
+
+    - Loop nếu ngắn hơn audio, crop nếu dài hơn
+    - Re-encode: libx264, preset slow, CRF 18, profile high, level 4.2, yuv420p
+
+    Args:
+        video_path: Path video gốc
+        audio_duration: Duration audio (seconds)
+        output_dir: Output directory
+
+    Returns:
+        Path video đã chuẩn hóa
+    """
+    video_info = get_video_info(video_path)
+    video_duration = video_info["duration"]
+
+    output_path = os.path.join(output_dir, "video_normalized.mp4")
+
+    if video_duration >= audio_duration:
+        encode_video_for_youtube(video_path, output_path, audio_duration)
+    else:
+        loop_count = int(audio_duration // video_duration) + 1
+        temp_looped = os.path.join(output_dir, "video_looped_temp.mp4")
+
+        loop_video(video_path, temp_looped, loop_count)
+        encode_video_for_youtube(temp_looped, output_path, audio_duration)
+        os.remove(temp_looped)
+
+    return output_path
 
 
 def merge_audio_video(video_path: str, audio_path: str, output_dir: str) -> str: