Update app.py

app.py

@@ -4,7 +4,7 @@ from pixabay_api import search_pixabay
 from moviepy.editor import (
     AudioFileClip, VideoFileClip, CompositeAudioClip,
     concatenate_audioclips, concatenate_videoclips, vfx, CompositeVideoClip,
-    ColorClip
+    ColorClip, ImageClip
 )
 import asyncio
 import os
@@ -29,42 +29,64 @@ os.makedirs(output_folder, exist_ok=True)
 # ID de la carpeta de destino en Google Drive
 FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"  # Reemplaza con tu ID de carpeta
 
-def resize_and_blur_video(clip, target_width=1920, target_height=1080):
-    """Redimensiona el video al tamaño 1080p (16:9) y aplica desenfoque si es necesario."""
+def resize_and_add_background(clip, target_width=1920, target_height=1080, background_url="https://wallpaperaccess.com/full/231401.jpg"):
+    """
+    Redimensiona el video al tamaño 1080p (16:9) y añade una imagen de fondo descargada desde una URL.
+
+    :param clip: VideoFileClip original.
+    :param target_width: Ancho objetivo del video final (por defecto: 1920).
+    :param target_height: Alto objetivo del video final (por defecto: 1080).
+    :param background_url: URL de la imagen de fondo.
+    :return: VideoFileClip procesado con fondo agregado.
+    """
     try:
         w, h = clip.size
         current_aspect_ratio = w / h
         target_aspect_ratio = target_width / target_height
 
-        if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
-            # Si la relación de aspecto ya es cercana a 16:9, solo redimensionamos
-            return clip.resize((target_width, target_height))
+        # Descargar la imagen de fondo desde la URL
+        response = requests.get(background_url)
+        if response.status_code != 200:
+            print("Error al descargar la imagen de fondo, usando un fondo negro.")
+            background = (
+                ImageClip(
+                    np.zeros((target_height, target_width, 3), dtype=np.uint8),
+                    duration=clip.duration,
+                )
+                .set_duration(clip.duration)
+                .resize((target_width, target_height))
+            )
+        else:
+            image_data = BytesIO(response.content)
+            background = (
+                ImageClip(image_data)
+                .set_duration(clip.duration)
+                .resize((target_width, target_height))
+            )
 
-        # Crear un fondo borroso con las dimensiones objetivo
-        background = ColorClip(size=(target_width, target_height), color=[0, 0, 0]).set_duration(clip.duration)
-        try:
-            background = background.fx(vfx.blur, sigma=50)
-        except Exception as e:
-            print(f"Error al aplicar blur: {e}")
-
-        # Redimensionar el video original para mantener su proporción
-        if current_aspect_ratio < target_aspect_ratio:  # Video vertical
-            new_height = target_height
-            new_width = int(new_height * current_aspect_ratio)
-            x_center = (target_width - new_width) / 2
-            resized_clip = clip.resize(width=new_width).set_position((x_center, 0))
-        else:  # Video horizontal
-            new_width = target_width
-            new_height = int(new_width / current_aspect_ratio)
-            y_center = (target_height - new_height) / 2
-            resized_clip = clip.resize(height=new_height).set_position((0, y_center))
-
-        # Combinar el fondo borroso con el video redimensionado
+        # Si el video ya tiene una relación de aspecto cercana a 16:9, solo redimensionarlo
+        if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
+            resized_clip = clip.resize((target_width, target_height))
+        else:
+            # Redimensionar el video manteniendo su proporción y centrarlo sobre el fondo
+            if current_aspect_ratio < target_aspect_ratio:  # Video vertical
+                new_height = target_height
+                new_width = int(new_height * current_aspect_ratio)
+                x_center = (target_width - new_width) / 2
+                resized_clip = clip.resize(width=new_width).set_position((x_center, 0))
+            else:  # Video horizontal
+                new_width = target_width
+                new_height = int(new_width / current_aspect_ratio)
+                y_center = (target_height - new_height) / 2
+                resized_clip = clip.resize(height=new_height).set_position((0, y_center))
+
+        # Combinar el fondo con el video redimensionado
         return CompositeVideoClip([background, resized_clip], size=(target_width, target_height))
     except Exception as e:
-        print(f"Error en resize_and_blur_video: {e}")
+        print(f"Error en resize_and_add_background: {e}")
         return clip
 
+
 def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
     """Concatena videos de Pixabay basados en palabras clave."""
     keyword_list = [keyword.strip() for keyword in keywords.split(",") if keyword.strip()]
@@ -88,7 +110,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
                 tmp_video.write(video_response.content)
                 clip = VideoFileClip(tmp_video.name)
-                processed_clip = resize_and_blur_video(clip)
+                processed_clip = resize_and_add_background(clip)  # Usa la nueva función
                 video_clips.append(processed_clip)
                 os.unlink(tmp_video.name)  # Limpiamos el archivo temporal
         except Exception as e:
@@ -100,6 +122,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
     random.shuffle(video_clips)
     return concatenate_videoclips(video_clips, method="compose")
 
+
 def adjust_background_music(video_duration, music_file):
     """Ajusta la música de fondo para que coincida con la duración del video."""
     try:
@@ -114,6 +137,7 @@ def adjust_background_music(video_duration, music_file):
         print(f"Error ajustando música: {e}")
         return None
 
+
 def combine_audio_video(audio_file, video_clip, music_clip=None):
     """Combina el audio y el video en un archivo final."""
     try:
@@ -151,6 +175,7 @@ def combine_audio_video(audio_file, video_clip, music_clip=None):
             final_clip.close()
         return None
 
+
 def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keywords):
     """Procesa la entrada del usuario y genera el video final."""
     try:
@@ -189,6 +214,7 @@ def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keyword
         print(f"Error durante el procesamiento: {e}")
         return None
 
+
 # Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Text-to-Video Generator")
@@ -219,4 +245,4 @@ with gr.Blocks() as demo:
 port = int(os.getenv("PORT", 7860))
 
 # Lanzar la aplicación
-demo.launch(server_name="0.0.0.0", server_port=port, share=True, show_error=True)
+demo.launch(server_name="0.0.0.0", server_port=port, share=True, show_error=True, enable_queue=True)