Upload app.py with huggingface_hub

app.py

@@ -73,7 +73,7 @@ def extract_video_path(result):
     return result
 
 def create_slideshow_video(images, duration_per_image=3.0, fps=30):
-    """Crée une vidéo diaporama à partir de plusieurs images"""
+    """Crée une vidéo diaporama animée à partir de plusieurs images"""
     import cv2
     import numpy as np
     
@@ -88,16 +88,47 @@ def create_slideshow_video(images, duration_per_image=3.0, fps=30):
     out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
     
     frames_per_image = int(duration_per_image * fps)
+    transition_frames = 30  # 1 seconde de transition
     
-    for img_path in images:
+    for i, img_path in enumerate(images):
         img = cv2.imread(img_path)
         if img is not None:
-            # Redimensionner l'image si nécessaire
             img = cv2.resize(img, (width, height))
             
-            # Écrire les frames pour cette image
-            for _ in range(frames_per_image):
-                out.write(img)
+            # Animation de zoom/pan Ken Burns effect
+            for frame in range(frames_per_image):
+                # Effet de zoom progressif
+                progress = frame / frames_per_image
+                zoom = 1.0 + 0.1 * progress  # Zoom de 0% à 10%
+                
+                # Calculer nouvelles dimensions
+                new_width = int(width * zoom)
+                new_height = int(height * zoom)
+                
+                # Redimensionner
+                zoomed = cv2.resize(img, (new_width, new_height))
+                
+                # Centrer et cropper
+                x_offset = (new_width - width) // 2
+                y_offset = (new_height - height) // 2
+                
+                if x_offset >= 0 and y_offset >= 0:
+                    cropped = zoomed[y_offset:y_offset+height, x_offset:x_offset+width]
+                else:
+                    cropped = img
+                
+                out.write(cropped)
+            
+            # Transition fade vers l'image suivante (si pas dernière image)
+            if i < len(images) - 1:
+                next_img = cv2.imread(images[i + 1])
+                if next_img is not None:
+                    next_img = cv2.resize(next_img, (width, height))
+                    
+                    for t in range(transition_frames):
+                        alpha = t / transition_frames
+                        blended = cv2.addWeighted(img, 1 - alpha, next_img, alpha, 0)
+                        out.write(blended)
     
     out.release()
     return output_path
@@ -124,6 +155,103 @@ def create_static_background_video(image_path, duration=10.0, fps=30):
     out.release()
     return output_path
 
+def get_audio_duration(audio_path):
+    """Obtient la durée d'un fichier audio en secondes"""
+    try:
+        import librosa
+        duration = librosa.get_duration(path=audio_path)
+        return duration
+    except:
+        # Fallback sans librosa
+        try:
+            import wave
+            with wave.open(audio_path, 'r') as f:
+                frames = f.getnframes()
+                rate = f.getframerate()
+                duration = frames / float(rate)
+                return duration
+        except:
+            # Fallback par défaut
+            return 10.0
+
+def create_simple_talking_avatar(avatar_image, audio_file):
+    """Crée un avatar parlant simple avec légères animations"""
+    import cv2
+    import numpy as np
+    
+    # Obtenir la durée de l'audio
+    duration = get_audio_duration(audio_file)
+    fps = 30
+    total_frames = int(duration * fps)
+    
+    output_path = tempfile.mktemp(suffix='.mp4')
+    
+    # Lire l'image d'avatar
+    img = cv2.imread(avatar_image)
+    height, width = img.shape[:2]
+    
+    # Créer le writer vidéo
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+    
+    for frame_num in range(total_frames):
+        # Créer une légère oscillation pour simuler la parole
+        scale_factor = 1.0 + 0.02 * np.sin(frame_num * 0.3)  # Oscillation douce
+        
+        # Redimensionner légèrement l'image
+        new_width = int(width * scale_factor)
+        new_height = int(height * scale_factor)
+        
+        if new_width > 0 and new_height > 0:
+            resized = cv2.resize(img, (new_width, new_height))
+            
+            # Centrer l'image redimensionnée
+            if new_width > width or new_height > height:
+                # Crop si plus grand
+                x_offset = (new_width - width) // 2
+                y_offset = (new_height - height) // 2
+                frame = resized[y_offset:y_offset+height, x_offset:x_offset+width]
+            else:
+                # Pad si plus petit
+                frame = np.zeros((height, width, 3), dtype=np.uint8)
+                x_offset = (width - new_width) // 2
+                y_offset = (height - new_height) // 2
+                frame[y_offset:y_offset+new_height, x_offset:x_offset+new_width] = resized
+        else:
+            frame = img
+        
+        out.write(frame)
+    
+    out.release()
+    
+    # Ajouter l'audio à la vidéo
+    return add_audio_to_video(output_path, audio_file)
+
+def create_static_avatar_with_audio(avatar_image, audio_file):
+    """Crée un avatar statique avec audio"""
+    duration = get_audio_duration(audio_file)
+    video_path = create_static_background_video(avatar_image, duration)
+    return add_audio_to_video(video_path, audio_file)
+
+def add_audio_to_video(video_path, audio_path):
+    """Ajoute l'audio à une vidéo (nécessite ffmpeg)"""
+    try:
+        import subprocess
+        output_path = tempfile.mktemp(suffix='.mp4')
+        
+        cmd = [
+            'ffmpeg', '-i', video_path, '-i', audio_path,
+            '-c:v', 'copy', '-c:a', 'aac', '-strict', 'experimental',
+            '-y', output_path
+        ]
+        
+        subprocess.run(cmd, check=True, capture_output=True)
+        return output_path
+    except:
+        # Si ffmpeg n'est pas disponible, retourner juste la vidéo
+        print("[DEBUG] ffmpeg non disponible, vidéo sans audio")
+        return video_path
+
 def generate_background_video(images, prompt="Smooth camera movement through the venue"):
     """
     Génère une vidéo de fond à partir des images uploadées
@@ -178,6 +306,7 @@ def generate_background_video(images, prompt="Smooth camera movement through the
 def generate_talking_avatar(avatar_image, audio_file, model_choice="LatentSync"):
     """
     Génère une vidéo d'avatar parlant à partir d'une image et d'un audio
+    Fallback vers une solution locale simple
     """
     if not avatar_image:
         return None, "Veuillez uploader une image d'avatar"
@@ -185,67 +314,41 @@ def generate_talking_avatar(avatar_image, audio_file, model_choice="LatentSync")
     if not audio_file:
         return None, "Veuillez fournir un fichier audio"
 
-    # Essayer différents espaces et API endpoints jusqu'à ce qu'un fonctionne
-    spaces_to_try = AVATAR_SPACES.get(model_choice, [])
-    errors_log = []
-    api_tests = get_avatar_api_tests(avatar_image, audio_file)
+    # 1. Solution locale : avatar qui "bouge" légèrement pendant l'audio
+    try:
+        print("[DEBUG] Génération d'avatar local...")
+        video_path = create_simple_talking_avatar(avatar_image, audio_file)
+        if video_path:
+            return video_path, "✅ Avatar parlant créé localement (solution de fallback)"
+    except Exception as e:
+        print(f"[DEBUG] Erreur avatar local: {e}")
 
+    # 2. Test rapide des APIs externes (heritage code)
+    spaces_to_try = AVATAR_SPACES.get(model_choice, [])[:1]  # Test juste le premier
+    errors_log = ["Services externes indisponibles - utilisation du fallback local"]
+    
     for space_id in spaces_to_try:
-        print(f"[DEBUG] Connexion à {space_id}...")
         try:
-            # Créer le client avec token si disponible
             if HF_TOKEN:
                 client = Client(space_id, hf_token=HF_TOKEN)
             else:
                 client = Client(space_id)
+            
+            api_tests = get_avatar_api_tests(avatar_image, audio_file)
+            api_name, test_func = api_tests[0]
+            result = test_func(client)
+            video_path = extract_video_path(result)
+            if video_path:
+                return video_path, f"✅ Avatar généré ! (Space: {space_id})"
         except Exception as e:
-            error_info = f"{space_id}: Échec de connexion - {str(e)[:100]}"
-            errors_log.append(error_info)
-            print(f"[DEBUG] ❌ {error_info}")
-            continue
-
-        for api_name, test_func in api_tests:
-            try:
-                # Essayer avec cette configuration d'API
-                print(f"[DEBUG] Test {space_id} avec config={api_name}")
-                result = test_func(client)
-
-                # Extraire le chemin vidéo depuis le résultat
-                video_path = None
-                if isinstance(result, tuple):
-                    video_path = result[0]
-                elif isinstance(result, dict):
-                    video_path = result.get('video') or result.get('path') or result.get('value')
-                elif isinstance(result, str):
-                    video_path = result
-                else:
-                    video_path = result
-
-                if video_path:
-                    print(f"[DEBUG] ✅ Succès avec {space_id}, config={api_name}")
-                    return video_path, f"✅ Avatar généré ! (Space: {space_id}, Config: {api_name or 'default'})"
-
-            except Exception as e:
-                error_msg = str(e)
-                error_info = f"{space_id} (config={api_name}): {error_msg[:200]}"
-                errors_log.append(error_info)
-                print(f"[DEBUG] ❌ {error_info}")
-
-                # Si c'est une erreur de "too many arguments" ou "api_name", essayer le suivant
-                error_keywords = ["too many", "api_name", "could not find", "connection", "not iterable", "bool", "argument"]
-                if any(x in error_msg.lower() for x in error_keywords):
-                    continue
-                elif "runtime_error" in error_msg.lower() or "invalid state" in error_msg.lower():
-                    # Ce space est en erreur, passer au suivant
-                    print(f"[DEBUG] Space {space_id} est en RUNTIME_ERROR, passage au suivant")
-                    break
-                else:
-                    # Si c'est une autre erreur sérieuse, essayer quand même les autres configs
-                    continue
+            errors_log.append(f"{space_id}: {str(e)[:50]}...")
 
-    # Si on arrive ici, aucun espace n'a fonctionné
-    error_summary = "\n".join(errors_log[-3:])  # Montrer les 3 dernières erreurs
-    return None, f"❌ Aucun service {model_choice} n'est disponible actuellement.\n\nErreurs récentes:\n{error_summary}"
+    # 3. Fallback final : avatar statique avec audio
+    try:
+        video_path = create_static_avatar_with_audio(avatar_image, audio_file)
+        return video_path, "✅ Avatar statique avec audio créé (fallback final)"
+    except Exception as e:
+        return None, f"❌ Erreur lors de la création de l'avatar: {str(e)}"
 
 def compose_videos(background_video, avatar_video, position="bottom-right", scale=0.3):
     """