Update app.py

app.py

@@ -1,62 +1,47 @@
 import gradio as gr
-from moviepy.editor import VideoFileClip, concatenate_videoclips
-from moviepy.video.fx import speedx
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip
+from moviepy.audio.fx.all import audio_fadeout
 import random
+import subprocess
 import os
 
-# Función para procesar los videos y generar una vista previa
-def previsualizar_videos(videos, rotations, speeds):
-    previews = []
-    for idx, video_path in enumerate(videos):
-        try:
-            # Procesar el video sin cortar por ahora, solo para la vista previa
-            clip = VideoFileClip(video_path)
-
-            # Aplicar la rotación seleccionada por el usuario para cada video
-            if rotations[idx] == "90 grados":
-                clip = clip.rotate(90)
-            elif rotations[idx] == "180 grados":
-                clip = clip.rotate(180)
-            elif rotations[idx] == "270 grados":
-                clip = clip.rotate(270)
-
-            # Aplicar la velocidad seleccionada por el usuario para cada video
-            clip = speedx(clip, factor=speeds[idx])
-
-            # Generar la vista previa
-            preview_output = f"preview_{idx}.mp4"
-            clip.write_videofile(preview_output, codec="libx264", audio_codec="aac", preset="ultrafast", threads=4)
-            previews.append(preview_output)
-        except Exception as e:
-            previews.append(f"Error al procesar el video {idx+1}: {str(e)}")
-    return previews
+# Función para convertir MOV a MP4
+def convertir_mov_a_mp4(ruta_mov):
+    ruta_mp4 = ruta_mov.replace('.MOV', '.mp4')
+    subprocess.run(['ffmpeg', '-i', ruta_mov, '-vcodec', 'h264', '-acodec', 'aac', ruta_mp4], check=True)
+    return ruta_mp4
 
-# Función para generar el video final en formato 9:16
-def generar_video_final(videos, rotations, speeds, song):
+# Función para procesar los videos
+def process_videos(videos, rotations, song):
     clips = []
+    errores = []  # Para almacenar los videos que no se pudieron procesar
     
     # Procesar cada video cargado
     for idx, video_path in enumerate(videos):
         try:
-            # Procesar el video y cortar los primeros 2 segundos
-            clip = VideoFileClip(video_path).subclip(2)
-            
-            # Aplicar la rotación seleccionada por el usuario para cada video
-            if rotations[idx] == "90 grados":
-                clip = clip.rotate(90)
-            elif rotations[idx] == "180 grados":
-                clip = clip.rotate(180)
-            elif rotations[idx] == "270 grados":
-                clip = clip.rotate(270)
+            if video_path.endswith('.MOV'):
+                # Convertir MOV a MP4
+                video_path = convertir_mov_a_mp4(video_path)
+            if video_path.endswith(('.mp4')):
+                clip = VideoFileClip(video_path).subclip(2)  # Cortar los primeros 2 segundos
 
-            # Aplicar la velocidad seleccionada
-            clip = speedx(clip, factor=speeds[idx])
+                # Aplicar la rotación seleccionada por el usuario para cada video
+                if rotations[idx] == "90 grados":
+                    clip = clip.rotate(90)
+                elif rotations[idx] == "180 grados":
+                    clip = clip.rotate(180)
+                elif rotations[idx] == "270 grados":
+                    clip = clip.rotate(270)
 
-            # Cambiar a 9:16 si es necesario
-            clip = clip.resize(height=1080)
-            clips.append(clip)
+                clips.append(clip)
+            else:
+                errores.append(f"Archivo no compatible: {video_path}")
         except Exception as e:
-            return None, f"Error al procesar el video {idx+1}: {str(e)}"
+            errores.append(f"Error al procesar {video_path}: {str(e)}")
+    
+    # Si no se procesó ningún video, mostrar los errores
+    if len(clips) == 0:
+        return None, f"No se pudieron procesar los videos. Errores: {', '.join(errores)}"
     
     # Mezclar los clips en orden aleatorio
     random.shuffle(clips)
@@ -65,47 +50,35 @@ def generar_video_final(videos, rotations, speeds, song):
     try:
         final_clip = concatenate_videoclips(clips)
 
-        # Añadir la canción si se ha subido
+        # Añadir la canción y hacer que termine con un fade out
         if song:
-            song_audio = AudioFileClip(song).subclip(0, final_clip.duration)
+            song_audio = AudioFileClip(song)
+            song_audio = song_audio.subclip(0, final_clip.duration)
+            song_audio = audio_fadeout(song_audio, 3)  # Añadir fade out de 3 segundos al final de la canción
             final_clip = final_clip.set_audio(song_audio)
 
-        # Guardar el video final
-        output_path = "video_final.mp4"
-        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", preset="ultrafast", threads=4)
+        # Guardar el video resultante
+        output_path = "output_video.mp4"
+        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac")
         
-        return output_path, None
+        return output_path, None  # Devolver el archivo generado para la descarga y None para el error
     except Exception as e:
-        return None, f"Error al generar el video final: {str(e)}"
+        return None, f"Error al concatenar los clips: {str(e)}"
 
 # Crear la interfaz de Gradio
-def crear_interfaz():
-    # Subir múltiples videos a la vez
-    video_inputs = gr.Files(label="Sube todos los videos (MP4, MOV)", file_count="multiple", type="filepath")
-    
-    # Configurar sliders de rotación y velocidad para cada video
-    rotation_input = gr.Radio(["Sin rotación", "90 grados", "180 grados", "270 grados"], label="Rotar videos")
-    speed_input = gr.Slider(minimum=0.5, maximum=2.0, step=0.1, value=1.0, label="Velocidad de reproducción")
-
-    demo = gr.Interface(
-        fn=previsualizar_videos,
-        inputs=[video_inputs, rotation_input, speed_input],
-        outputs=[gr.Video(label="Previsualiza tus videos procesados")],
-        title="Previsualizar y Ajustar Rotación y Velocidad",
-        description="Sube todos los videos a la vez, ajusta la rotación y la velocidad para cada uno, y previsualiza antes de generar el video final.",
-    )
-
-    # Interfaz para generar el video final
-    final_demo = gr.Interface(
-        fn=generar_video_final,
-        inputs=[video_inputs, rotation_input, speed_input, gr.Audio(label="Sube una canción opcional")],
-        outputs=[gr.Video(label="Previsualización del video final"), gr.File(label="Descargar video final")],
-        title="Generar Video Final con Velocidad y Rotación",
-        description="Sube todos los videos a la vez, ajusta la rotación y velocidad, y combina los clips con una canción para obtener el video final en formato 9:16.",
-    )
+video_inputs = [gr.Video(label=f"Sube el video {i+1}") for i in range(5)]  # Eliminar el argumento `type`
+rotation_inputs = [gr.Radio(["Sin rotación", "90 grados", "180 grados", "270 grados"], label=f"Rotar video {i+1}") for i in range(5)]
 
-    demo.launch(share=True)
-    final_demo.launch(share=True)
+demo = gr.Interface(
+    fn=process_videos,
+    inputs=video_inputs + rotation_inputs + [gr.Audio(label="Sube una canción")],
+    outputs=[
+        gr.Video(label="Previsualiza tu video procesado"),  # Para mostrar el video en un reproductor
+        gr.File(label="Descargar video procesado")  # Para permitir la descarga del video final
+    ],
+    title="Mezclar y Unir Videos con Rotación y Música",
+    description="Sube varios videos, corta los primeros 2 segundos, ajusta la rotación de cada uno, y añade música.",
+)
 
 # Ejecutar la interfaz
-crear_interfaz()
+demo.launch(share=True)