Update app.py

app.py

@@ -859,7 +859,7 @@ def animate_image_fade(img: np.ndarray, dur: float, out: Path, fps: int = 24) ->
 
 def concat_media(file_paths: List[str], output_path: Path, media_type: str):
     """
-    Concatenate multiple media files using FFmpeg.
+    Concatenate multiple media files using FFmpeg with proper sync handling.
     
     Args:
         file_paths (List[str]): List of input file paths
@@ -875,35 +875,152 @@ def concat_media(file_paths: List[str], output_path: Path, media_type: str):
         
         with open(list_file, 'w') as f:
             for path in file_paths:
-                # Escape path for FFmpeg
-                escaped_path = str(path).replace('\\', '\\\\').replace("'", "\\'")
+                # Escape path for FFmpeg and ensure it exists
+                if not Path(path).exists():
+                    continue
+                escaped_path = str(path).replace('\\', '/').replace("'", "\\'")
                 f.write(f"file '{escaped_path}'\n")
         
-        # Build FFmpeg command
+        # Build FFmpeg command with proper codec settings
         cmd = [
             "ffmpeg", "-y", "-f", "concat", "-safe", "0",
             "-i", str(list_file)
         ]
         
         if media_type == "video":
-            cmd.extend(["-c", "copy"])
+            # For video: copy streams without re-encoding to preserve timing
+            cmd.extend(["-c:v", "copy", "-avoid_negative_ts", "make_zero"])
         else:  # audio
-            cmd.extend(["-c:a", "aac"])
+            # For audio: ensure consistent sample rate and format
+            cmd.extend([
+                "-c:a", "aac", 
+                "-ar", "44100",  # Consistent sample rate
+                "-ac", "2",      # Stereo
+                "-b:a", "128k"   # Consistent bitrate
+            ])
             
         cmd.append(str(output_path))
         
         # Execute FFmpeg command
-        subprocess.run(cmd, check=True, capture_output=True)
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
         
         # Clean up temporary file
         list_file.unlink(missing_ok=True)
         
+    except subprocess.CalledProcessError as e:
+        print(f"FFmpeg concatenation failed: {e.stderr}")
+        # Create a fallback if concatenation fails
+        if file_paths and Path(file_paths[0]).exists():
+            # Just copy the first file as a fallback
+            import shutil
+            shutil.copy2(file_paths[0], str(output_path))
     except Exception as e:
         print(f"Media concatenation failed: {e}")
         # Create a fallback if concatenation fails
-        if file_paths:
-            # Just copy the first file as a fallback
-            subprocess.run(["cp", file_paths[0], str(output_path)], check=False)
+        if file_paths and Path(file_paths[0]).exists():
+            import shutil
+            shutil.copy2(file_paths[0], str(output_path))
+
+
+def generate_video(buf: bytes, name: str, ctx: str, key: str):
+    """ENHANCED: Better video generation with reliable charts and FIXED AUDIO SYNC"""
+    try: 
+        subprocess.run(["ffmpeg", "-version"], check=True, capture_output=True)
+    except Exception: 
+        st.error("🔴 FFmpeg not available — cannot render video.")
+        return None
+
+    df, err = load_dataframe_safely(buf, name)
+    if err: 
+        st.error(err)
+        return None
+
+    llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", google_api_key=API_KEY, temperature=0.2)
+    
+    # ENHANCED: Better context for video generation
+    ctx_dict = {
+        "shape": df.shape, 
+        "columns": list(df.columns), 
+        "user_ctx": ctx or "General business analysis",
+        "full_dataframe": df.to_dict("records"),
+        "data_types": {col: str(dtype) for col, dtype in df.dtypes.to_dict().items()},
+        "numeric_summary": {col: {stat: float(val) for stat, val in stats.items()} for col, stats in df.describe().to_dict().items()} if len(df.select_dtypes(include=["number"]).columns) > 0 else {},
+    }
+    
+    script = llm.invoke(build_story_prompt(ctx_dict)).content
+    scenes = [s.strip() for s in script.split("[SCENE_BREAK]") if s.strip()]
+
+    # ENHANCED: Better chart generation for video
+    chart_generator = create_chart_generator(llm, df)
+    
+    video_parts, audio_parts, temps = [], [], []
+    
+    for idx, sc in enumerate(scenes[:VIDEO_SCENES]):
+        st.progress((idx + 1) / VIDEO_SCENES, text=f"Rendering Scene {idx + 1}/{VIDEO_SCENES}")
+        descs, narrative = extract_chart_tags(sc), clean_narration(sc)
+        
+        # FIXED: Generate audio first to get exact duration
+        audio_bytes, _ = deepgram_tts(narrative)
+        mp3 = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp3"
+        
+        if audio_bytes: 
+            mp3.write_bytes(audio_bytes)
+            # Get the EXACT duration of the generated audio
+            dur = audio_duration(str(mp3))
+            if dur <= 0:  # Fallback if duration detection fails
+                dur = 5.0
+        else: 
+            dur = 5.0
+            generate_silence_mp3(dur, mp3)
+        
+        audio_parts.append(str(mp3))
+        temps.append(mp3)
+
+        # FIXED: Create video with EXACT same duration as audio
+        mp4 = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
+        
+        if descs: 
+            safe_chart(descs[0], df, dur, mp4)
+        else:
+            img = generate_image_from_prompt(narrative)
+            img_cv = cv2.cvtColor(np.array(img.resize((WIDTH, HEIGHT))), cv2.COLOR_RGB2BGR)
+            animate_image_fade(img_cv, dur, mp4)
+        
+        video_parts.append(str(mp4))
+        temps.append(mp4)
+
+    # FIXED: Create concatenated files with proper sync
+    silent_vid = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp4"
+    audio_mix = Path(tempfile.gettempdir()) / f"{uuid.uuid4()}.mp3"
+    
+    # Concatenate video and audio separately first
+    concat_media(video_parts, silent_vid, "video")
+    concat_media(audio_parts, audio_mix, "audio")
+    
+    # FIXED: Final merge with proper sync settings
+    final_vid = Path(tempfile.gettempdir()) / f"{key}.mp4"
+    
+    # Enhanced FFmpeg command for perfect sync
+    subprocess.run([
+        "ffmpeg", "-y", 
+        "-i", str(silent_vid),  # Video input
+        "-i", str(audio_mix),   # Audio input
+        "-c:v", "libx264",      # Video codec (re-encode for compatibility)
+        "-c:a", "aac",          # Audio codec
+        "-map", "0:v:0",        # Map first video stream
+        "-map", "1:a:0",        # Map first audio stream
+        "-shortest",            # End when shortest stream ends
+        "-avoid_negative_ts", "make_zero",  # Fix timestamp issues
+        "-fflags", "+genpts",   # Generate presentation timestamps
+        "-r", str(FPS),         # Ensure consistent framerate
+        str(final_vid)
+    ], check=True, capture_output=True)
+    
+    # Clean up temporary files
+    for p in temps + [silent_vid, audio_mix]: 
+        p.unlink(missing_ok=True)
+    
+    return str(final_vid)
 
 # ─── ENHANCED MAIN FUNCTIONS (DROP-IN REPLACEMENTS) ────────────────────────────