Update app.py

app.py

@@ -2,8 +2,6 @@ import tempfile
 import logging
 import os
 import asyncio
-import gc
-import psutil
 from moviepy.editor import *
 import edge_tts
 import gradio as gr
@@ -18,25 +16,15 @@ OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
-# CONSTANTES DE LIMITACIONES
-MAX_VIDEO_DURATION = 300  # Máxima duración en segundos (5 minutos)
-MAX_VIDEO_SIZE = 100 * 1024 * 1024  # Tamaño máximo en bytes (100MB)
-MAX_RESOLUTION = (1280, 720)  # Resolución máxima (720p)
-
-# Configuración de chunks
-SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
-TRANSITION_DURATION = 1.5  # Duración del efecto slide
-
 # Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
 
-def mostrar_uso_memoria():
-    proceso = psutil.Process(os.getpid())
-    memoria_uso = proceso.memory_info().rss / 1024 / 1024
-    logging.info(f"Uso de memoria: {memoria_uso:.2f} MB")
+# Configuración de chunks
+SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
+TRANSITION_DURATION = 1.5  # Duración del efecto slide
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
     def eliminar():
@@ -51,22 +39,8 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 
 def validar_video(video_path):
     try:
-        # Comprobar tamaño del archivo
-        file_size = os.path.getsize(video_path)
-        if file_size > MAX_VIDEO_SIZE:
-            logging.warning(f"El video excede el tamaño máximo: {file_size/1024/1024:.2f}MB > {MAX_VIDEO_SIZE/1024/1024}MB")
-            return False
-        
-        # Validar que es un video
         clip = VideoFileClip(video_path)
-        duracion = clip.duration
         clip.close()
-        
-        # Comprobar duración
-        if duracion > MAX_VIDEO_DURATION:
-            logging.warning(f"El video excede la duración máxima: {duracion}s > {MAX_VIDEO_DURATION}s")
-            return False
-            
         return True
     except Exception as e:
         logging.error(f"El video no es válido: {e}")
@@ -76,39 +50,30 @@ def convertir_video(video_path):
     try:
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_converted:
             output_path = tmp_converted.name
-        
-        # Primero convertir a un formato más eficiente y con menor resolución
-        os.system(f'ffmpeg -i "{video_path}" -vf "scale=640:360" -c:v libx264 -crf 28 -preset ultrafast -c:a aac -b:a 96k "{output_path}" -y')
-        
-        # Comprobar si ahora cumple las limitaciones
-        if not validar_video(output_path):
-            # Si sigue sin cumplir, recortar duración
-            nuevo_clip = VideoFileClip(output_path)
-            duracion_maxima = min(nuevo_clip.duration, MAX_VIDEO_DURATION)
-            nuevo_clip = nuevo_clip.subclip(0, duracion_maxima)
-            
-            temp_recortado = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-            nuevo_clip.write_videofile(temp_recortado, codec="libx264", audio_codec="aac", 
-                                      preset="ultrafast", bitrate="1M")
-            nuevo_clip.close()
-            
-            os.remove(output_path)
-            return temp_recortado
-        
+        os.system(f'ffmpeg -i "{video_path}" -vcodec libx264 -acodec aac "{output_path}" -y')
         return output_path
     except Exception as e:
         logging.error(f"Error al convertir el video: {e}")
         raise
 
+def ajustar_resolucion(video_path):
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_resized:
+            output_path = tmp_resized.name
+        os.system(f'ffmpeg -i "{video_path}" -vf "scale=1280:720" -vcodec libx264 -acodec aac "{output_path}" -y')
+        return output_path
+    except Exception as e:
+        logging.error(f"Error al ajustar la resolución del video: {e}")
+        raise
+
 async def generar_tts(texto, voz, duracion_total):
     try:
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
-        # Limitar el texto a 500 caracteres para procesar más rápido
-        if len(texto) > 500:
-            texto = texto[:500]
-            logging.info("Texto para TTS truncado a 500 caracteres para optimizar rendimiento")
+        if len(texto) > 1000:
+            texto = texto[:1000]
         
+        # Eliminado la validación restrictiva de voces para permitir todas las que están en el dropdown
         logging.info(f"Generando TTS con voz: {voz}")
         communicate = edge_tts.Communicate(texto, voz)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
@@ -139,85 +104,44 @@ def create_slide_transition(clip1, clip2, duration=TRANSITION_DURATION):
         part2.fx(vfx.fadein, duration).set_position(
             lambda t: ('center', 720 - (720 * (t/duration)))
         )
-    ], size=(640, 360)).set_duration(duration)  # Reducido a 640x360 para optimizar
+    ], size=(1280, 720)).set_duration(duration)
     return transition
 
-def liberar_memoria(objetos_cerrar=None):
-    """Forzar liberación de memoria cerrando objetos y llamando al recolector de basura"""
-    if objetos_cerrar:
-        for obj in objetos_cerrar:
-            if obj is not None:
-                try:
-                    obj.close()
-                except:
-                    pass
-    
-    # Forzar recolección de basura
-    gc.collect()
-    mostrar_uso_memoria()
-
-async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.Progress()):
+async def procesar_video(video_input, texto_tts, voz_seleccionada):
     temp_files = []
     intro, outro, video_original = None, None, None
-    segmentos_temp = []
-    
     try:
-        mostrar_uso_memoria()
         logging.info("Iniciando procesamiento")
-        progress(0, desc="Validando video")
         
         if not validar_video(video_input):
-            progress(0.05, desc="Convirtiendo formato de video")
             video_input = convertir_video(video_input)
             temp_files.append(video_input)
-            
-        progress(0.1, desc="Preparando video")
-        # Reducir resolución para optimizar procesamiento
-        video_original = VideoFileClip(video_input)
+        
+        video_original = VideoFileClip(video_input, target_resolution=(720, 1280))
         duracion_video = video_original.duration
         
-        # Limitar duración si es necesario
-        if duracion_video > MAX_VIDEO_DURATION:
-            duracion_video = MAX_VIDEO_DURATION
-            video_original = video_original.subclip(0, duracion_video)
-            
         if duracion_video <= 0:
             raise ValueError("El video debe tener una duración mayor que cero.")
         
-        progress(0.2, desc="Generando narración (TTS)")
         tts_audio, tts_path = await generar_tts(texto_tts, voz_seleccionada, duracion_video)
-        temp_files.append(tts_path)
-        
-        progress(0.3, desc="Preparando música de fondo")
         bg_audio, bg_path = crear_musica_fondo(duracion_video)
-        temp_files.append(bg_path)
+        temp_files.extend([tts_path, bg_path])
         
-        progress(0.35, desc="Mezclando audio")
-        audio_original = video_original.audio.volumex(0.5) if video_original.audio else None
+        audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
         audios = [bg_audio.set_duration(duracion_video)]
         if audio_original:
             audios.append(audio_original)
         audios.append(tts_audio.set_start(0).volumex(0.85))
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
         
-        # Procesar por segmentos para optimizar memoria
+        video_final = video_original.copy()
         if duracion_video > SEGMENT_DURATION:
-            progress(0.4, desc="Procesando segmentos de video")
             clips = []
             num_segments = int(duracion_video // SEGMENT_DURATION) + (1 if duracion_video % SEGMENT_DURATION > 0 else 0)
-            
             for i in range(num_segments):
-                progress_val = 0.4 + (0.3 * (i / num_segments))
-                progress(progress_val, desc=f"Procesando segmento {i+1}/{num_segments}")
-                
                 start_time = i * SEGMENT_DURATION
                 end_time = min(start_time + SEGMENT_DURATION, duracion_video)
                 segment = video_original.subclip(start_time, end_time)
-                
-                # Reducir resolución si es necesario
-                if segment.size[0] > MAX_RESOLUTION[0] or segment.size[1] > MAX_RESOLUTION[1]:
-                    segment = segment.resize(height=MAX_RESOLUTION[1])
-                
                 if i == 0:
                     clips.append(segment)
                 else:
@@ -228,88 +152,48 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
                         clips[-1] = prev_segment.subclip(0, prev_end)
                     clips.append(transition)
                     clips.append(segment)
-                
-                # Liberar memoria después de cada 2 segmentos
-                if i % 2 == 1:
-                    liberar_memoria()
-                    
             video_final = concatenate_videoclips(clips, method="compose")
-        else:
-            video_final = video_original.copy()
-            
-        # Asignar audio final
-        progress(0.7, desc="Asignando audio")
-        video_final = video_final.set_audio(audio_final)
         
-        # Añadir intro y outro
-        progress(0.75, desc="Añadiendo intro y outro")
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(360, 640))  # Reducido para optimizar
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(360, 640))  # Reducido para optimizar
-        
-        # Crear el video final por partes
-        with tempfile.NamedTemporaryFile(delete=False, suffix="_intro.mp4") as tmp_intro:
-            intro.write_videofile(tmp_intro.name, codec="libx264", audio_codec="aac", 
-                                preset="ultrafast", bitrate="1M", 
-                                ffmpeg_params=["-crf", "30"])
-            segmentos_temp.append(tmp_intro.name)
-            
-        with tempfile.NamedTemporaryFile(delete=False, suffix="_main.mp4") as tmp_main:
-            video_final.write_videofile(tmp_main.name, codec="libx264", audio_codec="aac",
-                                    preset="ultrafast", bitrate="1M",
-                                    ffmpeg_params=["-crf", "30"])
-            segmentos_temp.append(tmp_main.name)
-            
-        with tempfile.NamedTemporaryFile(delete=False, suffix="_outro.mp4") as tmp_outro:
-            outro.write_videofile(tmp_outro.name, codec="libx264", audio_codec="aac",
-                                preset="ultrafast", bitrate="1M",
-                                ffmpeg_params=["-crf", "30"])
-            segmentos_temp.append(tmp_outro.name)
-        
-        # Liberar memoria antes de la unión final
-        liberar_memoria([video_original, intro, outro, video_final])
-        video_original = intro = outro = video_final = None
+        video_final = video_final.set_audio(audio_final)
+        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(720, 1280))
+        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(720, 1280))
+        video_final = concatenate_videoclips([intro, video_final, outro], method="compose")
         
-        # Unir los segmentos con ffmpeg directamente
-        progress(0.9, desc="Generando video final")
-        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as concat_file:
-            # Escribir archivo de lista para concatenación
-            for segment in segmentos_temp:
-                concat_file.write(f"file '{segment}'\n".encode())
-            concat_path = concat_file.name
-            
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_final:
-            output_path = tmp_final.name
-            os.system(f'ffmpeg -f concat -safe 0 -i "{concat_path}" -c copy "{output_path}" -y')
-            
-            # Limpiar archivos temporales
-            os.remove(concat_path)
-            for segment in segmentos_temp:
-                if os.path.exists(segment):
-                    os.remove(segment)
-            
-            eliminar_archivo_tiempo(output_path, 3600)  # Extendido a 1 hora
-            progress(1.0, desc="¡Video listo!")
-            logging.info(f"Video final guardado: {output_path}")
-            mostrar_uso_memoria()
-            return output_path
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
+            video_final.write_videofile(
+                tmp.name,
+                codec="libx264",
+                audio_codec="aac",
+                fps=24,
+                threads=2,
+                bitrate="3M",
+                ffmpeg_params=[
+                    "-preset", "ultrafast",
+                    "-crf", "28",
+                    "-movflags", "+faststart",
+                    "-vf", "scale=1280:720"
+                ],
+                verbose=False
+            )
+            eliminar_archivo_tiempo(tmp.name, 1800)
+            logging.info(f"Video final guardado: {tmp.name}")
+            return tmp.name
     except Exception as e:
         logging.error(f"Fallo general: {str(e)}")
         raise
     finally:
         try:
-            liberar_memoria([video_original, intro, outro])
+            if video_original:
+                video_original.close()
+            if intro:
+                intro.close()
+            if outro:  # Corregido: outro en lugar de otro
+                outro.close()
             for file in temp_files:
                 try:
-                    if os.path.exists(file):
-                        os.remove(file)
+                    os.remove(file)
                 except Exception as e:
                     logging.warning(f"Error limpiando {file}: {e}")
-            for segment in segmentos_temp:
-                try:
-                    if os.path.exists(segment):
-                        os.remove(segment)
-                except Exception as e:
-                    logging.warning(f"Error limpiando segmento {segment}: {e}")
         except Exception as e:
             logging.warning(f"Error al cerrar recursos: {str(e)}")
 
@@ -319,7 +203,7 @@ with gr.Blocks() as demo:
     with gr.Tab("Principal"):
         video_input = gr.Video(label="Subir video")
         texto_tts = gr.Textbox(
-            label="Texto para TTS (máx. 500 caracteres)",
+            label="Texto para TTS",
             lines=3,
             placeholder="Escribe aquí tu texto..."
         )
@@ -377,7 +261,7 @@ with gr.Blocks() as demo:
             ],
             value="es-ES-AlvaroNeural"
         )
-        procesar_btn = gr.Button("Generar Video (Modo Optimizado)")
+        procesar_btn = gr.Button("Generar Video")
         video_output = gr.Video(label="Video Procesado")
     with gr.Accordion("Ejemplos de Uso", open=False):
         gr.Examples(
@@ -393,23 +277,11 @@ with gr.Blocks() as demo:
 
     gr.Markdown("""
     ### ℹ️ Notas importantes:
-    - **Limitaciones para Hugging Face Spaces:**
-      - Máxima duración de video: 5 minutos
-      - Máximo tamaño de archivo: 100MB
-      - Resolución reducida a 640x360 para procesamiento
-      - Texto TTS limitado a 500 caracteres
-    - Las transiciones ocurren cada 30 segundos
+    - Las transiciones ocurren solamente cada 30 segundos
     - El video contiene intro y outro predefinidos
-    - El archivo generado se elimina después de 1 hora
-    - Para videos más pesados, considera usar este código localmente
+    - El archivo generado se elimina después de 30 minutos
+    - Para mejores resultados, usa videos de dimensiones 720p o 1080p
     """)
 
 if __name__ == "__main__":
-    # Instalar psutil si no está disponible
-    try:
-        import psutil
-    except ImportError:
-        os.system("pip install psutil")
-        import psutil
-        
     demo.queue().launch()