Update app.py

app.py

@@ -60,7 +60,6 @@ def download_weights():
     """
     Downloads pre-trained weights from Hugging Face Hub if they don't exist locally.
     """
-    # A simple check for a key file to see if the download is likely complete
     motion_model_file = os.path.join(WEIGHTS_DIR, "moda", "net-200.pth")
     
     if not os.path.exists(motion_model_file):
@@ -97,20 +96,16 @@ def ensure_wav_format(audio_path, max_duration_ms=300000): # Increased to 5 minu
     
     try:
         print(f"Loading and processing audio from: {audio_path}")
-        # Load the audio file (supports wav, mp3, m4a, etc.)
         audio = AudioSegment.from_file(audio_path)
         
-        # Trim if the audio exceeds the limit
         if len(audio) > max_duration_ms:
             print(f"Audio is {len(audio)/1000:.2f}s, trimming to {max_duration_ms/1000:.2f}s")
             audio = audio[:max_duration_ms]
         else:
             print(f"Audio is {len(audio)/1000:.2f}s (under the {max_duration_ms/1000:.2f}s limit)")
         
-        # Create a temporary WAV file
         with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_file:
             wav_path = tmp_file.name
-            # Export as WAV with standard settings
             audio.export(
                 wav_path,
                 format='wav',
@@ -152,62 +147,57 @@ def extract_last_frame(video_path, output_image_path):
 
 def concatenate_videos_ffmpeg(video_paths, full_audio_path, output_path):
     """
-    Stitches multiple video files together (video track only) and overlays the original full audio track.
-    This bypasses any pops or sync problems at the chunk boundaries.
+    Stitches multiple video files together using FFMPEG concat filter (with full re-encoding).
+    Standardizes dimensions to 512x512, sets SAR to 1, and forces a strict 25 FPS timebase.
+    Finally overlays the clean original audio track.
     """
-    # Create the text file listing all videos
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False, encoding='utf-8') as f:
-        for p in video_paths:
-            # Format absolute path with forward slashes and escape single quotes
-            abs_path = os.path.abspath(p).replace('\\', '/')
-            safe_path = abs_path.replace("'", "'\\''")
-            f.write(f"file '{safe_path}'\n")
-        list_file_path = f.name
-        
     temp_video_only = os.path.join(os.path.dirname(output_path), "temp_video_only.mp4")
+    num_inputs = len(video_paths)
         
     try:
-        # Step 1: Concatenate video tracks only (discard original segment audios to avoid jumps)
-        cmd_copy = [
-            'ffmpeg', '-y',
-            '-f', 'concat',
-            '-safe', '0',
-            '-i', list_file_path,
-            '-an',             # Discard segment audios completely
-            '-c:v', 'copy',    # Direct stream copy (instant & lossless)
+        # Build the FFMPEG command with input files
+        cmd_concat = ['ffmpeg', '-y']
+        for p in video_paths:
+            cmd_concat.extend(['-i', str(p)])
+            
+        # Construct the complex filter: scale to 512x512, set SAR, and concatenate
+        filter_parts = []
+        concat_inputs = []
+        for i in range(num_inputs):
+            filter_parts.append(f"[{i}:v]scale=512:512,setsar=1[v{i}]")
+            concat_inputs.append(f"[v{i}]")
+            
+        concat_inputs_str = "".join(concat_inputs)
+        filter_parts.append(f"{concat_inputs_str}concat=n={num_inputs}:v=1:a=0[v]")
+        filter_complex_str = "; ".join(filter_parts)
+        
+        # Output setup for high compatibility (H.264, YUV420p, strict 25 FPS)
+        cmd_concat.extend([
+            '-filter_complex', filter_complex_str,
+            '-map', '[v]',
+            '-c:v', 'libx264',
+            '-preset', 'medium',
+            '-crf', '18',           # High quality output
+            '-pix_fmt', 'yuv420p',  # High compatibility pixel format
+            '-r', '25',             # Strictly 25 fps matching default output
             temp_video_only
-        ]
-        print(f"Executing lossless FFMPEG video concat (no-audio): {' '.join(cmd_copy)}")
-        result = subprocess.run(cmd_copy, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        ])
         
-        if result.returncode != 0:
-            print("Lossless video-only concatenation failed. Retrying with full video re-encoding...")
-            # Fallback path: video re-encoding (robust)
-            cmd_reencode = [
-                'ffmpeg', '-y',
-                '-f', 'concat',
-                '-safe', '0',
-                '-i', list_file_path,
-                '-an',
-                '-c:v', 'libx264',
-                '-pix_fmt', 'yuv420p',
-                temp_video_only
-            ]
-            print(f"Executing FFMPEG video-only re-encode: {' '.join(cmd_reencode)}")
-            result_re = subprocess.run(cmd_reencode, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            if result_re.returncode != 0:
-                raise Exception(f"FFMPEG video concatenation failed: {result_re.stderr.decode('utf-8')}")
+        print(f"Executing video concat filter: {' '.join(cmd_concat)}")
+        result_concat = subprocess.run(cmd_concat, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        if result_concat.returncode != 0:
+            raise Exception(f"FFMPEG video-only concat filter failed: {result_concat.stderr.decode('utf-8')}")
         
-        # Step 2: Merge the concatenated video track with the complete original audio file
+        # Step 2: Merge the newly rendered video with the complete original audio file
         cmd_merge = [
             'ffmpeg', '-y',
             '-i', temp_video_only,
             '-i', str(full_audio_path),
-            '-map', '0:v:0',    # Use video from concatenated file
-            '-map', '1:a:0',    # Use audio from original full wav file
-            '-c:v', 'copy',     # Keep video intact
+            '-map', '0:v:0',    # Map video from temp file
+            '-map', '1:a:0',    # Map audio from original full wav file
+            '-c:v', 'copy',     # Direct copy of the already encoded video
             '-c:a', 'aac',      # Encode original audio to standard clean AAC
-            '-shortest',        # Sync to the shortest stream duration
+            '-shortest',        # Sync to shortest stream
             str(output_path)
         ]
         print(f"Applying final original audio track: {' '.join(cmd_merge)}")
@@ -216,9 +206,7 @@ def concatenate_videos_ffmpeg(video_paths, full_audio_path, output_path):
             raise Exception(f"FFMPEG audio replacement failed: {result_merge.stderr.decode('utf-8')}")
                 
     finally:
-        # Clean up temporary files
-        if os.path.exists(list_file_path):
-            os.remove(list_file_path)
+        # Clean up temporary video file
         if os.path.exists(temp_video_only):
             try:
                 os.remove(temp_video_only)
@@ -251,8 +239,8 @@ emo_name_to_id = {v: k for k, v in emo_map.items()}
 @spaces.GPU(duration=120)
 def generate_motion(source_image_path, driving_audio_path, emotion_name, cfg_scale, progress=gr.Progress(track_tqdm=True)):
     """
-    Generates talking head video. For inputs longer than 15 seconds, it automatically
-    chunks the audio into 15-second blocks, processes them sequentially using the
+    Generates talking head video. For inputs longer than 7 seconds, it automatically
+    chunks the audio into 7-second blocks, processes them sequentially using the
     last frame of the previous block as the next source image, and then merges them.
     """
     if pipeline is None:
@@ -284,8 +272,8 @@ def generate_motion(source_image_path, driving_audio_path, emotion_name, cfg_sca
     print(f"  Emotion: {emotion_name} (ID: {emotion_id})")
     print(f"  CFG Scale: {cfg_scale}")
 
-    # Chunk settings - Increased to 15 seconds to avoid splitting common video lengths entirely
-    CHUNK_SIZE_MS = 15000  # 15 seconds
+    # Chunk settings
+    CHUNK_SIZE_MS = 7000  # 7 seconds
     temp_wav_files = []
     temp_frame_files = []
     video_chunks_paths = []
@@ -296,7 +284,7 @@ def generate_motion(source_image_path, driving_audio_path, emotion_name, cfg_sca
         audio = AudioSegment.from_file(wav_audio_path)
         audio_duration_ms = len(audio)
         
-        # Slice audio into segments of max 15 seconds
+        # Slice audio into segments of max 7 seconds
         audio_chunks = []
         for i in range(0, audio_duration_ms, CHUNK_SIZE_MS):
             audio_chunks.append(audio[i : i + CHUNK_SIZE_MS])
@@ -329,7 +317,7 @@ def generate_motion(source_image_path, driving_audio_path, emotion_name, cfg_sca
                 cfg_scale=float(cfg_scale),
                 emo=emotion_id,
                 save_dir=run_output_dir,
-                smooth=True, # ENABLED: Uses Kalman filter to smooth face movements and prevent jumping
+                smooth=False, # Disable smoothing for a faster demo
                 silent_audio_path=DEFAULT_SILENT_AUDIO_PATH,
             )
             
@@ -362,12 +350,12 @@ def generate_motion(source_image_path, driving_audio_path, emotion_name, cfg_sca
                     print("Falling back to the original source image for the next segment.")
                     current_image_path = source_image_path
 
-        # 4. Merge all generated chunks and lay the original full audio track on top
+        # 4. Merge all generated chunks and overlay the original full audio track
         progress(0.95, desc="Merging segments and applying original audio...")
         final_video_name = f"final_{timestamp}.mp4"
         final_path = Path(os.path.join(run_output_dir, final_video_name))
         
-        # We always run this function (even for 1 chunk) to ensure the original, clean, high-quality WAV audio is perfectly mapped on the video
+        # Force re-encoding merge to ensure absolute smooth transitions without lag
         concatenate_videos_ffmpeg(video_chunks_paths, wav_audio_path, final_path)
             
     except Exception as e: