Update app.py

app.py

@@ -1,51 +1,62 @@
 import gradio as gr
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip
-from moviepy.audio.fx.all import audio_fadeout
+from moviepy.editor import VideoFileClip, concatenate_videoclips
+from moviepy.video.fx import speedx
 import random
-import subprocess
 import os
 
-# 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 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 procesar los videos
-def process_videos(videos, rotate_option, song):
+# Función para generar el video final en formato 9:16
+def generar_video_final(videos, rotations, speeds, song):
     clips = []
-    errores = []  # Para almacenar los videos que no se pudieron procesar
     
     # Procesar cada video cargado
-    for video_path in videos:
+    for idx, video_path in enumerate(videos):
         try:
-            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).without_audio()  # Eliminar el audio original del video
+            # 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)
 
-                # Recortar el video a los primeros 3 segundos
-                if clip.duration > 3:
-                    clip = clip.subclip(0, 3)
+            # Aplicar la velocidad seleccionada
+            clip = speedx(clip, factor=speeds[idx])
 
-                # Aplicar la rotación según la opción seleccionada
-                if rotate_option == "90 grados":
-                    clip = clip.rotate(90)
-                elif rotate_option == "180 grados":
-                    clip = clip.rotate(180)
-                elif rotate_option == "270 grados":
-                    clip = clip.rotate(270)
-
-                clips.append(clip)
-            else:
-                errores.append(f"Archivo no compatible: {video_path}")
+            # Cambiar a 9:16 si es necesario
+            clip = clip.resize(height=1080)
+            clips.append(clip)
         except Exception as 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, None  # Devolver None para ambas salidas si hay errores
+            return None, f"Error al procesar el video {idx+1}: {str(e)}"
     
     # Mezclar los clips en orden aleatorio
     random.shuffle(clips)
@@ -54,37 +65,44 @@ def process_videos(videos, rotate_option, song):
     try:
         final_clip = concatenate_videoclips(clips)
 
-        # Añadir la canción y hacer que termine con un fade out
+        # Añadir la canción si se ha subido
         if song:
-            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
+            song_audio = AudioFileClip(song).subclip(0, final_clip.duration)
             final_clip = final_clip.set_audio(song_audio)
 
-        # Guardar el video resultante
-        output_path = "output_video.mp4"
-        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac")
+        # Guardar el video final
+        output_path = "video_final.mp4"
+        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", preset="ultrafast", threads=4)
         
-        # Devolver la ruta del video para previsualización y descarga
-        return output_path, output_path
+        return output_path, None
     except Exception as e:
-        return None, None  # Devolver None en caso de errores
+        return None, f"Error al generar el video final: {str(e)}"
 
 # Crear la interfaz de Gradio
-demo = gr.Interface(
-    fn=process_videos,
-    inputs=[
-        gr.Files(label="Sube tus videos (MP4, MOV)", file_count="multiple", type="filepath"),
-        gr.Radio(["Sin rotación", "90 grados", "180 grados", "270 grados"], label="Rotar video"),
-        gr.Audio(label="Sube una canción", type="filepath")  # Añadir un campo para subir la 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, recórtalos, mézclalos, reemplaza el audio con una canción y aplica una rotación.",
-)
+def crear_interfaz():
+    video_inputs = [gr.Video(label=f"Sube el video {i+1}") for i in range(5)]
+    rotation_inputs = [gr.Radio(["Sin rotación", "90 grados", "180 grados", "270 grados"], label=f"Rotar video {i+1}") for i in range(5)]
+    speed_inputs = [gr.Slider(minimum=0.5, maximum=2.0, step=0.1, value=1.0, label=f"Velocidad video {i+1}") for i in range(5)]
+
+    demo = gr.Interface(
+        fn=previsualizar_videos,
+        inputs=video_inputs + rotation_inputs + speed_inputs,
+        outputs=[gr.Video(label=f"Vista previa {i+1}") for i in range(5)],
+        title="Previsualizar y Rotar Videos con Velocidad",
+        description="Sube tus videos, ajusta la rotación y velocidad si es necesario, y previsualiza cada uno antes de generar el video final.",
+    )
+
+    # Interfaz para generar el video final
+    final_demo = gr.Interface(
+        fn=generar_video_final,
+        inputs=video_inputs + rotation_inputs + speed_inputs + [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 tus videos, ajusta la rotación y velocidad, y combina los clips con una canción para obtener el video final en formato 9:16.",
+    )
+
+    demo.launch(share=True)
+    final_demo.launch(share=True)
 
 # Ejecutar la interfaz
-demo.launch(share=True)
+crear_interfaz()