Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 from tts_module import get_voices, text_to_speech  # Usamos el tts_module.py actualizado
 from pexels_api import search_pexels
-from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips
+from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips, concatenate_videoclips
 
 import asyncio
 import os
@@ -16,18 +16,18 @@ def install(package):
 
 try:
     # Intentar importar moviepy.editor
-    from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips
+    from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips, concatenate_videoclips
     print("MoviePy.editor está instalado correctamente.")
 except ImportError:
     print("Instalando MoviePy...")
     install("moviepy==1.0.3")  # Forzar instalación de la versión compatible
     try:
-        from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips
+        from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips, concatenate_videoclips
         print("MoviePy.editor instalado con éxito después de la reinstalación.")
     except ImportError:
         raise ImportError("Error crítico: No se pudo instalar moviepy.editor. Verifica las dependencias.")
 
-# Ajustar música de fondo
+# Ajustar música de fondo (repetición automática)
 def adjust_background_music(video_duration, music_file):
     music = AudioFileClip(music_file)
     if music.duration < video_duration:
@@ -36,56 +36,117 @@ def adjust_background_music(video_duration, music_file):
         music = concatenate_audioclips(music_clips)
     if music.duration > video_duration:
         music = music.subclip(0, video_duration)
-    music = music.volumex(0.2)
+    music = music.volumex(0.2)  # Reducir volumen al 20%
     return music
 
-# Combinar audio, video y música
+# Concatenar múltiples videos de Pexels con redimensión a 1920x1080
+def concatenate_pexels_videos(text, num_videos=5):
+    sentences = [sentence.strip() for sentence in text.split(".") if sentence.strip()]
+    video_links = []
+
+    for sentence in sentences:
+        try:
+            links = search_pexels(sentence, num_results=num_videos)
+            if links:
+                video_links.append(links[0])  # Usamos el primer video encontrado para cada frase
+        except Exception as e:
+            print(f"Error al buscar video para la frase '{sentence}': {e}")
+            continue
+
+    if not video_links:
+        raise Exception("No se encontraron videos relevantes para el texto proporcionado.")
+
+    video_clips = []
+    target_width, target_height = 1920, 1080  # Resolución estándar 16:9
+
+    for link in video_links:
+        video_response = requests.get(link)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
+            tmp_video.write(video_response.content)
+            clip = VideoFileClip(tmp_video.name)
+
+            # Redimensionar el video a 1920x1080 manteniendo la relación de aspecto
+            if clip.size[0] / clip.size[1] > target_width / target_height:
+                # Si es más ancho, recortar los lados
+                new_width = int(clip.size[1] * (target_width / target_height))
+                clip = clip.crop(x1=(clip.size[0] - new_width) // 2, y1=0, x2=(clip.size[0] + new_width) // 2, y2=clip.size[1])
+            else:
+                # Si es más alto, recortar arriba y abajo
+                new_height = int(clip.size[0] * (target_height / target_width))
+                clip = clip.crop(x1=0, y1=(clip.size[1] - new_height) // 2, x2=clip.size[0], y2=(clip.size[1] + new_height) // 2)
+
+            # Redimensionar explícitamente a 1920x1080
+            clip = clip.resize((target_width, target_height))
+            video_clips.append(clip)
+
+    # Concatenar videos
+    final_clip = concatenate_videoclips(video_clips, method="compose")
+    return final_clip
+
+# Combinar audio, video y música con fade out solo en el video y la música
 def combine_audio_video(audio_file, video_clip, music_clip=None):
     audio_clip = AudioFileClip(audio_file)
+
+    # Duración total: speech + 5 segundos para fade out
+    total_duration = audio_clip.duration + 5
+
+    # Extender la duración del video si es más corto que el audio + fade out
+    if video_clip.duration < total_duration:
+        video_clip = video_clip.loop(duration=total_duration)  # Repetir el video si es necesario
+
+    # Aplicar fade out solo al video
+    video_clip = video_clip.set_duration(total_duration).fadeout(5)
+
+    # Combinar audio y video
     final_clip = video_clip.set_audio(audio_clip)
+
+    # Añadir música de fondo si aplica
     if music_clip:
+        # Extender la música para que coincida con la duración total
+        if music_clip.duration < total_duration:
+            repetitions = int(total_duration / music_clip.duration) + 1
+            music_clips = [music_clip] * repetitions
+            music_clip = concatenate_audioclips(music_clips)
+        if music_clip.duration > total_duration:
+            music_clip = music_clip.subclip(0, total_duration)
+
+        # Aplicar fade out a la música
+        music_clip = music_clip.audio_fadeout(5)
+
+        # Combinar audio principal, música y video
         final_clip = final_clip.set_audio(CompositeAudioClip([audio_clip, music_clip]))
+
+    # Exportar el video final
     output_path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-    final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac")
+    final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", fps=24)
     return output_path
 
 # Función principal
-def process_input(text, txt_file, mp3_file, prompt, selected_voice, rate, pitch):
+def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch):
     try:
         if text.strip():
             final_text = text
         elif txt_file is not None:
             final_text = txt_file.decode("utf-8")
-        elif prompt.strip():
-            final_text = "Generated text from prompt"
         else:
-            return "No input provided", None
+            return "No input provided"
 
         # Obtener voces disponibles
         voices = asyncio.run(get_voices())
         if selected_voice not in voices:
-            return f"La voz '{selected_voice}' no es válida. Por favor, seleccione una de las siguientes voces: {', '.join(voices.keys())}", None
+            return f"La voz '{selected_voice}' no es válida. Por favor, seleccione una de las siguientes voces: {', '.join(voices.keys())}"
 
         # Generar audio con edge_tts
         try:
             audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
         except Exception as e:
-            return f"Error con la voz seleccionada: {e}", None
+            return f"Error con la voz seleccionada: {e}"
 
-        # Buscar video en Pexels
-        query = final_text.split(".")[0]
+        # Concatenar múltiples videos de Pexels basados en el texto
         try:
-            video_links = search_pexels(query, num_results=1)
-            if not video_links:
-                return "No se encontraron videos en Pexels", None
+            video_clip = concatenate_pexels_videos(final_text, num_videos=5)
         except Exception as e:
-            return f"Error al buscar videos en Pexels: {e}", None
-
-        # Descargar video de Pexels
-        video_response = requests.get(video_links[0])
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
-            tmp_video.write(video_response.content)
-            video_clip = VideoFileClip(tmp_video.name)
+            return f"Error al buscar videos en Pexels: {e}"
 
         # Ajustar música de fondo
         if mp3_file is not None:
@@ -93,12 +154,12 @@ def process_input(text, txt_file, mp3_file, prompt, selected_voice, rate, pitch)
         else:
             music_clip = None
 
-        # Combinar audio, video y música
+        # Combinar audio, video y música con fade out solo en el video y la música
         final_video = combine_audio_video(audio_file, video_clip, music_clip)
         return final_video
 
     except Exception as e:
-        return f"Error durante el procesamiento: {e}", None
+        return f"Error durante el procesamiento: {e}"
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -108,7 +169,6 @@ with gr.Blocks() as demo:
             text_input = gr.Textbox(label="Write your text here", lines=5)
             txt_file_input = gr.File(label="Or upload a .txt file", file_types=[".txt"])
             mp3_file_input = gr.File(label="Upload background music (.mp3)", file_types=[".mp3"])
-            prompt_input = gr.Textbox(label="Or enter a prompt to generate text")
             voices = asyncio.run(get_voices())  # Obtener voces disponibles
             voice_dropdown = gr.Dropdown(choices=list(voices.keys()), label="Select Voice")
             rate_slider = gr.Slider(minimum=-50, maximum=50, value=0, label="Speech Rate Adjustment (%)", step=1)
@@ -120,7 +180,7 @@ with gr.Blocks() as demo:
     btn = gr.Button("Generate Video")
     btn.click(
         process_input,
-        inputs=[text_input, txt_file_input, mp3_file_input, prompt_input, voice_dropdown, rate_slider, pitch_slider],
+        inputs=[text_input, txt_file_input, mp3_file_input, voice_dropdown, rate_slider, pitch_slider],
         outputs=output_video
     )