Update app.py

app.py

@@ -14,7 +14,7 @@ import onnxruntime as ort
 
 
 # ============================================================
-# CONFIGURATION
+# CONFIG
 # ============================================================
 
 MODEL_PATH = "wav2lip_models/wav2lip_gan.onnx"
@@ -46,22 +46,29 @@ FACE_MODEL_URL = (
 
 
 # ============================================================
-# DIRECTORIES
+# QUALITY SETTINGS
 # ============================================================
 
-os.makedirs(
-    OUTPUT_DIR,
-    exist_ok=True
-)
+# Lower value preserves original face texture.
+# Higher value = stronger generated lips.
+BLEND_STRENGTH = 0.50
 
-os.makedirs(
-    FACE_DIR,
-    exist_ok=True
-)
+# Temporal stabilization.
+# 0.25-0.40 is good for natural lip movement.
+TEMPORAL_ALPHA = 0.35
+
+# Face tracking.
+FACE_SMOOTHING = 0.15
+
+# Re-detect face every N seconds.
+REDETECT_SECONDS = 0.50
+
+# Padding around detected face.
+FACE_PADDING = 0.18
 
 
 # ============================================================
-# AUDIO
+# AUDIO SETTINGS
 # ============================================================
 
 SAMPLE_RATE = 16000
@@ -80,43 +87,33 @@ FMAX = 7600
 
 MEL_STEP_SIZE = 16
 
+# Wav2Lip uses approximately 80 mel frames/sec.
 MEL_FPS = 80.0
 
 
 # ============================================================
-# FACE
+# OUTPUT SETTINGS
 # ============================================================
 
-FACE_CONFIDENCE = 0.50
-
-FACE_PADDING = 0.08
-
-FACE_SMOOTHING = 0.20
-
-REDETECT_SECONDS = 0.30
-
-
-# ============================================================
-# MOUTH
-# ============================================================
+CRF = 17
 
-# Keep this moderate.
-# Too high = generated mouth becomes obvious.
-BLEND_STRENGTH = 0.62
+PRESET = "medium"
 
 
 # ============================================================
-# VIDEO ENCODING
+# DIRECTORIES
 # ============================================================
 
-CRF = 17
-
-PRESET = "medium"
+os.makedirs(
+    OUTPUT_DIR,
+    exist_ok=True
+)
 
+os.makedirs(
+    FACE_DIR,
+    exist_ok=True
+)
 
-# ============================================================
-# PRINT
-# ============================================================
 
 print("=" * 70)
 print("Wav2Lip High Quality Lip Sync")
@@ -130,15 +127,16 @@ print("=" * 70)
 if not os.path.exists(MODEL_PATH):
 
     raise FileNotFoundError(
-        "\n\nWav2Lip model not found:\n"
+        "\n\n"
+        "Wav2Lip ONNX model not found:\n"
         f"{MODEL_PATH}\n\n"
-        "Your Space should contain:\n"
+        "Expected structure:\n"
         "wav2lip_models/wav2lip_gan.onnx\n"
     )
 
 
 # ============================================================
-# ONNX PROVIDER
+# ONNX PROVIDERS
 # ============================================================
 
 available_providers = (
@@ -166,25 +164,22 @@ print(
 
 
 # ============================================================
-# LOAD MODEL
+# LOAD ONNX MODEL
 # ============================================================
 
 print(
     "Loading Wav2Lip ONNX model..."
 )
 
-
 SESSION = ort.InferenceSession(
     MODEL_PATH,
     providers=ONNX_PROVIDERS
 )
 
-
 print(
     "Model loaded successfully."
 )
 
-
 print(
     "Model inputs:"
 )
@@ -198,7 +193,6 @@ for inp in SESSION.get_inputs():
         inp.type
     )
 
-
 print(
     "Model outputs:"
 )
@@ -214,7 +208,7 @@ for out in SESSION.get_outputs():
 
 
 # ============================================================
-# DOWNLOAD FACE MODEL
+# DOWNLOAD FACE DETECTOR
 # ============================================================
 
 def download_file(url, path):
@@ -253,49 +247,51 @@ print(
     "Loading OpenCV DNN face detector..."
 )
 
-
 FACE_DETECTOR = cv2.dnn.readNetFromCaffe(
     FACE_PROTO,
     FACE_MODEL
 )
 
-
 print(
     "Face detector loaded."
 )
 
 
 # ============================================================
-# TEMPORAL MOUTH SMOOTHER
+# TEMPORAL SMOOTHER
 # ============================================================
 
 class MouthTemporalSmoother:
 
     def __init__(
         self,
-        alpha=0.65
+        alpha=0.35
     ):
 
         self.alpha = alpha
 
         self.previous = None
 
+
     def reset(self):
 
         self.previous = None
 
+
     def smooth(
         self,
         generated,
         mask
     ):
 
-        current = (
-            generated.astype(
-                np.float32
-            )
+        current = generated.astype(
+            np.float32
         )
 
+        # ----------------------------------------------------
+        # First frame
+        # ----------------------------------------------------
+
         if self.previous is None:
 
             self.previous = current.copy()
@@ -303,34 +299,89 @@ class MouthTemporalSmoother:
             return generated
 
 
-        previous = self.previous
+        # ----------------------------------------------------
+        # CRITICAL FIX
+        #
+        # Previous face crop can have different dimensions.
+        #
+        # Example:
+        #
+        # 1033 x 1033
+        # 1055 x 1055
+        #
+        # Resize previous frame before blending.
+        # ----------------------------------------------------
+
+        if (
+            self.previous.shape[:2]
+            !=
+            current.shape[:2]
+        ):
+
+            self.previous = cv2.resize(
+                self.previous,
+                (
+                    current.shape[1],
+                    current.shape[0]
+                ),
+                interpolation=cv2.INTER_LINEAR
+            )
+
+            self.previous = (
+                self.previous.astype(
+                    np.float32
+                )
+            )
+
+
+        # ----------------------------------------------------
+        # Ensure mask matches current frame.
+        # ----------------------------------------------------
+
+        if (
+            mask.shape[:2]
+            !=
+            current.shape[:2]
+        ):
+
+            mask = cv2.resize(
+                mask.astype(
+                    np.float32
+                ),
+                (
+                    current.shape[1],
+                    current.shape[0]
+                ),
+                interpolation=cv2.INTER_LINEAR
+            )
 
 
         # ----------------------------------------------------
-        # Temporal smoothing
+        # Temporal smoothing.
         #
-        # Do not completely replace current frame.
-        # This keeps lip motion responsive to audio.
+        # This removes the "shadow moving over lips".
         # ----------------------------------------------------
 
         smoothed = (
-            previous * self.alpha
+            self.previous
+            *
+            self.alpha
             +
-            current * (
-                1.0 - self.alpha
+            current
+            *
+            (
+                1.0
+                -
+                self.alpha
             )
         )
 
 
         # ----------------------------------------------------
-        # Only stabilize mouth region.
+        # Only stabilize mouth.
         # ----------------------------------------------------
 
-        m = mask[
-            :,
-            :,
-            None
-        ]
+        m = mask[..., None]
 
 
         result = (
@@ -342,10 +393,7 @@ class MouthTemporalSmoother:
         )
 
 
-        self.previous = result.copy()
-
-
-        return np.clip(
+        result = np.clip(
             result,
             0,
             255
@@ -354,13 +402,23 @@ class MouthTemporalSmoother:
         )
 
 
+        self.previous = (
+            result.astype(
+                np.float32
+            )
+        )
+
+
+        return result
+
+
 MOUTH_SMOOTHER = MouthTemporalSmoother(
-    alpha=0.55
+    alpha=TEMPORAL_ALPHA
 )
 
 
 # ============================================================
-# AUDIO
+# LOAD AUDIO
 # ============================================================
 
 def load_audio(
@@ -379,31 +437,30 @@ def load_audio(
             "Could not load audio."
         )
 
-
     if len(audio) == 0:
 
         raise RuntimeError(
             "Audio file is empty."
         )
 
-
     audio = audio.astype(
         np.float32
     )
 
-
     duration = (
         len(audio)
         /
         SAMPLE_RATE
     )
 
-
-    return audio, duration
+    return (
+        audio,
+        duration
+    )
 
 
 # ============================================================
-# MEL SPECTROGRAM
+# CREATE MEL
 # ============================================================
 
 def make_mel(
@@ -424,18 +481,15 @@ def make_mel(
         center=True
     )
 
-
     mel = np.maximum(
         mel,
         1e-5
     )
 
-
     mel = np.log10(
         mel
     )
 
-
     return mel.astype(
         np.float32
     )
@@ -449,7 +503,9 @@ def detect_face(
     frame
 ):
 
-    h, w = frame.shape[:2]
+    frame_h, frame_w = (
+        frame.shape[:2]
+    )
 
 
     blob = cv2.dnn.blobFromImage(
@@ -494,7 +550,7 @@ def detect_face(
         )
 
 
-        if confidence < FACE_CONFIDENCE:
+        if confidence < 0.50:
 
             continue
 
@@ -509,10 +565,10 @@ def detect_face(
             *
             np.array(
                 [
-                    w,
-                    h,
-                    w,
-                    h
+                    frame_w,
+                    frame_h,
+                    frame_w,
+                    frame_h
                 ]
             )
         )
@@ -529,7 +585,7 @@ def detect_face(
             0,
             min(
                 x1,
-                w - 1
+                frame_w - 1
             )
         )
 
@@ -537,7 +593,7 @@ def detect_face(
             0,
             min(
                 y1,
-                h - 1
+                frame_h - 1
             )
         )
 
@@ -545,7 +601,7 @@ def detect_face(
             0,
             min(
                 x2,
-                w
+                frame_w
             )
         )
 
@@ -553,7 +609,7 @@ def detect_face(
             0,
             min(
                 y2,
-                h
+                frame_h
             )
         )
 
@@ -568,7 +624,11 @@ def detect_face(
             continue
 
 
-        area = bw * bh
+        area = (
+            bw
+            *
+            bh
+        )
 
 
         score = (
@@ -596,7 +656,7 @@ def detect_face(
 
 
 # ============================================================
-# INITIAL FACE
+# FIND INITIAL FACE
 # ============================================================
 
 def find_initial_face(
@@ -627,7 +687,7 @@ def find_initial_face(
         cap.release()
 
         raise RuntimeError(
-            "Video contains no frames."
+            "Video has no frames."
         )
 
 
@@ -687,7 +747,7 @@ def find_initial_face(
     if not boxes:
 
         raise RuntimeError(
-            "No face detected in the video."
+            "No face detected in video."
         )
 
 
@@ -711,7 +771,7 @@ def find_initial_face(
 
 
 # ============================================================
-# SMOOTH FACE BOX
+# SMOOTH FACE POSITION
 # ============================================================
 
 def smooth_face(
@@ -759,27 +819,20 @@ def smooth_face(
 
 
 # ============================================================
-# FACE CROP
+# FIXED CROP SIZE
 # ============================================================
 
-def make_crop(
-    frame,
-    face_box
+def create_fixed_crop_size(
+    face_box,
+    frame_width,
+    frame_height
 ):
 
-    frame_h, frame_w = (
-        frame.shape[:2]
-    )
-
-
     x, y, w, h = face_box
 
 
     size = int(
-        max(
-            w,
-            h
-        )
+        max(w, h)
         *
         (
             1.0
@@ -789,69 +842,116 @@ def make_crop(
     )
 
 
+    size = max(
+        size,
+        256
+    )
+
+
     size = min(
         size,
-        frame_w,
-        frame_h
+        frame_width,
+        frame_height
+    )
+
+
+    return int(
+        size
+    )
+
+
+# ============================================================
+# GET FIXED FACE CROP
+# ============================================================
+
+def get_fixed_face_crop(
+    frame,
+    face_box,
+    crop_size
+):
+
+    frame_h, frame_w = (
+        frame.shape[:2]
+    )
+
+
+    x_face, y_face, w_face, h_face = (
+        face_box
     )
 
 
+    # --------------------------------------------------------
+    # Face center
+    # --------------------------------------------------------
+
     cx = (
-        x
+        x_face
         +
-        w / 2.0
+        w_face / 2.0
     )
 
 
     cy = (
-        y
+        y_face
         +
-        h / 2.0
+        h_face / 2.0
     )
 
 
-    x1 = int(
+    # Small upward correction.
+    cy -= h_face * 0.02
+
+
+    # --------------------------------------------------------
+    # Fixed-size crop.
+    # --------------------------------------------------------
+
+    x = int(
         cx
         -
-        size / 2
+        crop_size / 2
     )
 
 
-    y1 = int(
+    y = int(
         cy
         -
-        size / 2
+        crop_size / 2
     )
 
 
-    x1 = max(
+    # --------------------------------------------------------
+    # Keep inside frame.
+    # --------------------------------------------------------
+
+    x = max(
         0,
         min(
-            x1,
-            frame_w - size
+            x,
+            frame_w - crop_size
         )
     )
 
 
-    y1 = max(
+    y = max(
         0,
         min(
-            y1,
-            frame_h - size
+            y,
+            frame_h - crop_size
         )
     )
 
 
     return (
-        int(x1),
-        int(y1),
-        int(size),
-        int(size)
+        int(x),
+        int(y),
+        int(crop_size),
+        int(crop_size)
     )
 
 
 # ============================================================
-# WAV2LIP
+# WAV2LIP INFERENCE
 # ============================================================
 
 def run_wav2lip(
@@ -860,14 +960,7 @@ def run_wav2lip(
 ):
 
     # ========================================================
-    # CRITICAL COLOR FIX
-    #
-    # OpenCV:
-    #     BGR
-    #
-    # Wav2Lip:
-    #     RGB
-    #
+    # BGR -> RGB
     # ========================================================
 
     face_rgb = cv2.cvtColor(
@@ -903,11 +996,7 @@ def run_wav2lip(
     # ========================================================
     # 6 CHANNEL INPUT
     #
-    # masked RGB
-    # +
-    # original RGB
-    #
-    # => 6 channels
+    # masked RGB + original RGB
     # ========================================================
 
     input_image = np.concatenate(
@@ -986,7 +1075,7 @@ def run_wav2lip(
 
 
     # ========================================================
-    # OUTPUT SHAPE
+    # OUTPUT
     # ========================================================
 
     if prediction.ndim == 4:
@@ -996,10 +1085,12 @@ def run_wav2lip(
 
     if prediction.shape[0] == 3:
 
-        prediction = prediction.transpose(
-            1,
-            2,
-            0
+        prediction = (
+            prediction.transpose(
+                1,
+                2,
+                0
+            )
         )
 
     else:
@@ -1011,7 +1102,7 @@ def run_wav2lip(
 
 
     # ========================================================
-    # RGB OUTPUT
+    # 0-1 -> 0-255
     # ========================================================
 
     prediction = np.clip(
@@ -1058,20 +1149,42 @@ def create_mouth_mask(
     ]
 
 
-    # ========================================================
-    # MOUTH CENTER
-    #
-    # Tight mask avoids coloring cheeks/nose.
-    # ========================================================
+    # --------------------------------------------------------
+    # Mouth center.
+    # --------------------------------------------------------
 
-    cx = width * 0.50
+    cx = (
+        width
+        *
+        0.50
+    )
 
-    cy = height * 0.715
 
+    cy = (
+        height
+        *
+        0.715
+    )
 
-    rx = width * 0.29
 
-    ry = height * 0.17
+    # --------------------------------------------------------
+    # Tighter mouth area.
+    #
+    # This is important for removing the moving shadow.
+    # --------------------------------------------------------
+
+    rx = (
+        width
+        *
+        0.25
+    )
+
+
+    ry = (
+        height
+        *
+        0.13
+    )
 
 
     distance = (
@@ -1094,21 +1207,25 @@ def create_mouth_mask(
     mask = np.exp(
         -distance
         *
-        2.8
+        2.6
     )
 
 
-    # ========================================================
-    # HARD LIMIT
-    # ========================================================
+    # --------------------------------------------------------
+    # Restrict mouth.
+    # --------------------------------------------------------
 
     top = int(
-        height * 0.55
+        height
+        *
+        0.57
     )
 
 
     bottom = int(
-        height * 0.90
+        height
+        *
+        0.87
     )
 
 
@@ -1124,28 +1241,26 @@ def create_mouth_mask(
     ] = 0
 
 
-    # ========================================================
-    # REDUCE OUTER EDGE
-    #
-    # This preserves original lip boundary.
-    # ========================================================
+    # --------------------------------------------------------
+    # Soft threshold.
+    # --------------------------------------------------------
 
     mask = np.clip(
         (
             mask
             -
-            0.10
+            0.08
         )
         /
-        0.90,
+        0.92,
         0,
         1
     )
 
 
-    # ========================================================
-    # SMOOTHSTEP
-    # ========================================================
+    # --------------------------------------------------------
+    # Smoothstep.
+    # --------------------------------------------------------
 
     mask = (
         mask
@@ -1162,23 +1277,23 @@ def create_mouth_mask(
     )
 
 
-    # ========================================================
-    # FEATHER
-    # ========================================================
+    # --------------------------------------------------------
+    # Feather.
+    # --------------------------------------------------------
 
     mask = cv2.GaussianBlur(
         mask.astype(
             np.float32
         ),
         (0, 0),
-        3.0
+        2.5
     )
 
 
     return np.clip(
         mask,
-        0.0,
-        1.0
+        0,
+        1
     )
 
 
@@ -1192,6 +1307,10 @@ def correct_generated_color(
     mask
 ):
 
+    # --------------------------------------------------------
+    # BGR -> LAB
+    # --------------------------------------------------------
+
     original_lab = cv2.cvtColor(
         original_bgr,
         cv2.COLOR_BGR2LAB
@@ -1208,10 +1327,6 @@ def correct_generated_color(
     )
 
 
-    # ========================================================
-    # STRONG MOUTH AREA
-    # ========================================================
-
     strong = (
         mask > 0.45
     )
@@ -1224,9 +1339,9 @@ def correct_generated_color(
         return generated_bgr
 
 
-    # ========================================================
+    # --------------------------------------------------------
     # LUMINANCE
-    # ========================================================
+    # --------------------------------------------------------
 
     original_l = np.median(
         original_lab[
@@ -1257,14 +1372,11 @@ def correct_generated_color(
     ) * 0.30
 
 
-    # ========================================================
-    # COLOR CHANNELS
-    #
-    # Small correction only.
+    # --------------------------------------------------------
+    # COLOR
     #
-    # This prevents blue/purple tint while retaining
-    # natural generated lip color.
-    # ========================================================
+    # Prevent blue/purple mouth.
+    # --------------------------------------------------------
 
     for channel in (
         1,
@@ -1307,10 +1419,6 @@ def correct_generated_color(
         )
 
 
-    # ========================================================
-    # CLAMP
-    # ========================================================
-
     generated_lab = np.clip(
         generated_lab,
         0,
@@ -1320,9 +1428,9 @@ def correct_generated_color(
     )
 
 
-    # ========================================================
+    # --------------------------------------------------------
     # LAB -> BGR
-    # ========================================================
+    # --------------------------------------------------------
 
     corrected = cv2.cvtColor(
         generated_lab,
@@ -1334,7 +1442,7 @@ def correct_generated_color(
 
 
 # ============================================================
-# MOUTH BLENDING
+# FINAL FACE BLENDING
 # ============================================================
 
 def blend_face(
@@ -1347,20 +1455,23 @@ def blend_face(
     )
 
 
-    # ========================================================
-    # RESIZE GENERATED FACE
-    # ========================================================
+    # --------------------------------------------------------
+    # Resize generated face.
+    # --------------------------------------------------------
 
     generated_bgr = cv2.resize(
         generated_bgr,
-        (w, h),
+        (
+            w,
+            h
+        ),
         interpolation=cv2.INTER_CUBIC
     )
 
 
-    # ========================================================
-    # PRECISE MOUTH MASK
-    # ========================================================
+    # --------------------------------------------------------
+    # Mouth mask.
+    # --------------------------------------------------------
 
     mask = create_mouth_mask(
         h,
@@ -1368,9 +1479,9 @@ def blend_face(
     )
 
 
-    # ========================================================
-    # COLOR CORRECTION
-    # ========================================================
+    # --------------------------------------------------------
+    # Color correction.
+    # --------------------------------------------------------
 
     generated_bgr = (
         correct_generated_color(
@@ -1381,14 +1492,16 @@ def blend_face(
     )
 
 
-    # ========================================================
-    # TEMPORAL STABILIZATION
+    # --------------------------------------------------------
+    # Temporal stabilization.
     #
-    # This reduces the moving "shadow" around lips.
-    # ========================================================
+    # Only apply it to mouth region.
+    # --------------------------------------------------------
 
     temporal_mask = np.clip(
-        mask * 0.75,
+        mask
+        *
+        0.60,
         0,
         1
     )
@@ -1402,11 +1515,9 @@ def blend_face(
     )
 
 
-    # ========================================================
-    # FINAL BLEND
-    #
-    # Keep original texture.
-    # ========================================================
+    # --------------------------------------------------------
+    # Final blending.
+    # --------------------------------------------------------
 
     alpha = (
         mask
@@ -1451,7 +1562,7 @@ def blend_face(
     )
 
 
-    return np.clip(
+    result = np.clip(
         result,
         0,
         255
@@ -1460,6 +1571,9 @@ def blend_face(
     )
 
 
+    return result
+
+
 # ============================================================
 # FFMPEG
 # ============================================================
@@ -1482,7 +1596,7 @@ def get_ffmpeg():
 
 
 # ============================================================
-# AUDIO MUX
+# ADD AUDIO
 # ============================================================
 
 def mux_audio(
@@ -1496,6 +1610,7 @@ def mux_audio(
 
     command = [
         ffmpeg,
+
         "-y",
 
         "-i",
@@ -1622,7 +1737,7 @@ def process_video(
 ):
 
     # ========================================================
-    # RESET TEMPORAL STATE
+    # RESET TEMPORAL MEMORY
     # ========================================================
 
     MOUTH_SMOOTHER.reset()
@@ -1738,7 +1853,7 @@ def process_video(
 
 
         # ====================================================
-        # VIDEO
+        # OPEN VIDEO
         # ====================================================
 
         progress(
@@ -1811,7 +1926,7 @@ def process_video(
 
 
         # ====================================================
-        # FACE
+        # FIND FACE
         # ====================================================
 
         progress(
@@ -1833,6 +1948,32 @@ def process_video(
         )
 
 
+        # ====================================================
+        # FIX CROP SIZE
+        #
+        # THIS PREVENTS:
+        #
+        # 1033x1033
+        # 1055x1055
+        #
+        # broadcasting error.
+        # ====================================================
+
+        fixed_crop_size = (
+            create_fixed_crop_size(
+                current_face,
+                width,
+                height
+            )
+        )
+
+
+        print(
+            "Fixed face crop size:",
+            fixed_crop_size
+        )
+
+
         # ====================================================
         # VIDEO WRITER
         # ====================================================
@@ -1865,7 +2006,7 @@ def process_video(
 
 
         # ====================================================
-        # FRAME COUNT
+        # PROCESS ONLY AUDIO DURATION
         # ====================================================
 
         audio_frame_count = int(
@@ -1884,9 +2025,7 @@ def process_video(
 
 
         # ====================================================
-        # MEL TIMING
-        #
-        # 80 mel frames / second
+        # AUDIO -> VIDEO FRAME TIMING
         # ====================================================
 
         mel_idx_multiplier = (
@@ -1903,7 +2042,7 @@ def process_video(
 
 
         # ====================================================
-        # FACE REDETECTION
+        # FACE REDETECTION INTERVAL
         # ====================================================
 
         redetect_every = max(
@@ -1917,7 +2056,7 @@ def process_video(
 
 
         # ====================================================
-        # PROCESS FRAMES
+        # PROCESS
         # ====================================================
 
         for frame_index in range(
@@ -1964,13 +2103,14 @@ def process_video(
 
 
             # =================================================
-            # FACE CROP
+            # FIXED-SIZE CROP
             # =================================================
 
             x, y, crop_w, crop_h = (
-                make_crop(
+                get_fixed_face_crop(
                     frame,
-                    current_face
+                    current_face,
+                    fixed_crop_size
                 )
             )
 
@@ -1991,7 +2131,7 @@ def process_video(
 
 
             # =================================================
-            # MEL WINDOW
+            # MEL INDEX
             # =================================================
 
             mel_start = int(
@@ -2029,12 +2169,16 @@ def process_video(
 
 
             # =================================================
-            # EXACT 80 x 16
+            # EXACT 80x16
             # =================================================
 
             if mel_chunk.shape[1] < 16:
 
-                if mel_chunk.shape[1] == 0:
+                if (
+                    mel_chunk.shape[1]
+                    ==
+                    0
+                ):
 
                     mel_chunk = np.zeros(
                         (
@@ -2092,7 +2236,7 @@ def process_video(
 
 
             # =================================================
-            # IMPROVED MOUTH
+            # QUALITY BLEND
             # =================================================
 
             result_face = (
@@ -2165,7 +2309,7 @@ def process_video(
 
 
         # ====================================================
-        # AUDIO
+        # ADD AUDIO
         # ====================================================
 
         progress(
@@ -2182,7 +2326,7 @@ def process_video(
 
 
         # ====================================================
-        # COMPLETE
+        # FINISHED
         # ====================================================
 
         progress(
@@ -2204,20 +2348,22 @@ def process_video(
 
         status = (
             "## ✅ Lip Sync Completed\n\n"
-            f"**Resolution:** "
+            f"**Source resolution:** "
             f"`{width} × {height}`\n\n"
             f"**FPS:** "
             f"`{fps:.2f}`\n\n"
-            f"**Audio:** "
+            f"**Audio duration:** "
             f"`{audio_duration:.2f}s`\n\n"
-            f"**Frames:** "
+            f"**Frames processed:** "
             f"`{frames_to_process}`\n\n"
-            "**RGB/BGR correction:** ✅\n\n"
-            "**Blue-mouth correction:** ✅\n\n"
-            "**Temporal lip stabilization:** ✅\n\n"
-            "**Mouth-edge smoothing:** ✅\n\n"
-            "**LAB color matching:** ✅\n\n"
+            f"**Fixed face crop:** "
+            f"`{fixed_crop_size} × {fixed_crop_size}`\n\n"
+            "**Lip color correction:** ✅\n\n"
+            "**Blue-mouth protection:** ✅\n\n"
+            "**Mouth shadow reduction:** ✅\n\n"
+            "**Temporal stabilization:** ✅\n\n"
             "**Face tracking:** ✅\n\n"
+            "**Original skin texture:** preserved\n\n"
             f"**Output size:** "
             f"`{output_size:.2f} MB`"
         )
@@ -2285,7 +2431,7 @@ CSS = """
 
 
 # ============================================================
-# GRADIO UI
+# GRADIO APP
 # ============================================================
 
 with gr.Blocks(
@@ -2297,22 +2443,24 @@ with gr.Blocks(
 # 🎬 Wav2Lip AI — High Quality Lip Sync
 
 Upload a source video and target speech audio.
-The AI synchronizes the visible mouth with the target audio.
+The AI will synchronize the mouth with the target audio.
 """
     )
 
 
     gr.Markdown(
         """
-### Improved mouth processing
-
-- 🎯 Precise mouth region
-- 🎨 RGB/BGR color correction
-- 🌈 LAB color stabilization
-- 🎞️ Temporal lip stabilization
-- 👄 Original lip texture preservation
-- 🎥 Face tracking
+### ✨ Processing improvements
+
+- 👄 More natural visible lips
+- 🎞️ Temporal mouth stabilization
+- 🌈 Blue/purple mouth correction
+- 🧴 Reduced lip shadow/flicker
+- 🎯 Tight mouth mask
+- 🎨 LAB color matching
+- 🎥 Stable face tracking
 - 🔊 Accurate audio/mel timing
+- 💎 Original skin texture preserved
 """
     )
 
@@ -2370,23 +2518,22 @@ The AI synchronizes the visible mouth with the target audio.
 
     gr.Markdown(
         """
-### Recommended input
+### 📌 Best results
 
-✅ Face looking toward camera  
-✅ Lips clearly visible  
-✅ Good lighting  
-✅ Minimal motion blur  
-✅ 720p or higher source video  
-✅ Clean speech audio  
+- Face looking toward camera
+- Lips clearly visible
+- Good lighting
+- Minimal motion blur
+- Clear speech
+- 720p or higher source
 
-**Note:** The optional text is only displayed as a reference.
-The uploaded audio is what controls the lip movement.
+The **audio controls the lip movement**. The optional text is only displayed as a reference.
 """
     )
 
 
     # ========================================================
-    # EVENT
+    # BUTTON
     # ========================================================
 
     generate_button.click(