Update app.py

app.py

@@ -6,7 +6,6 @@ from moviepy.editor import *
 import edge_tts
 import gradio as gr
 from pydub import AudioSegment
-import psutil  # Para monitoreo de recursos
 
 # Configuración de Logs
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
@@ -25,8 +24,8 @@ for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, GLITCH_SOUND, EJEMPLO_VIDEO]:
         raise FileNotFoundError(f"Falta: {file}")
 
 # Configuración de chunks
-CHUNK_SIZE = 300  # 5 minutos por chunk (ajusta según tus recursos)
-MAX_CHUNKS = 20    # Límite máximo de chunks (previene loops infinitos)
+CHUNK_SIZE = 60  # 1 minuto por chunk (evita timeouts)
+MAX_CHUNKS = 50   # Límite máximo de chunks
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
     def eliminar():
@@ -46,7 +45,7 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
 
-        def dividir_texto(texto, max_length=3000):
+        def dividir_texto(texto, max_length=2000):  # Texto más corto por fragmento
             return [texto[i:i + max_length] for i in range(0, len(texto), max_length)]
 
         fragmentos = dividir_texto(texto)
@@ -100,7 +99,7 @@ def aplicar_glitch(video_clip):
         import numpy as np
         frame = frame.copy()
         height, width, _ = frame.shape
-        offset = np.random.randint(5, 15)
+        offset = np.random.randint(3, 8)  # Efecto menos intenso
         if height > 0:
             frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
         return frame
@@ -119,13 +118,13 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
             audio_original
         )
         
-        segment_duration = 18
-        overlap = 2
+        segment_duration = 15  # Segmentos más cortos
+        overlap = 1
         total_segments = int((duracion_chunk) // (segment_duration)) + 1
         
         segments = []
         glitch_clips = []
-        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
+        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.3)  # Sonido menos intenso
 
         current_time = 0
         for i in range(total_segments):
@@ -135,11 +134,11 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
             full_segment = chunk.subclip(current_time, end_time)
             
             if i > 0:
-                glitch_part = full_segment.subclip(0, 0.5)
+                glitch_part = full_segment.subclip(0, 0.3)  # Glitch de 0.3s
                 glitch_part = aplicar_glitch(glitch_part)
                 processed_segment = concatenate_videoclips([
                     glitch_part,
-                    full_segment.subclip(0.5)
+                    full_segment.subclip(0.3)
                 ], method="compose")
                 
                 glitch_sound_clip = glitch_sound.set_start(start_time + current_time)
@@ -157,53 +156,56 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
     except Exception as e:
         logging.error(f"Fallo procesando fragmento: {str(e)}")
         raise
+    finally:
+        try:
+            chunk.close()
+            audio_original.close()
+            audio_final.close()
+        except:
+            pass
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
         logging.info("Iniciando procesamiento de video")
-        video_original = VideoFileClip(video_input, target_resolution=(1080, 1920))
+        video_original = VideoFileClip(video_input, target_resolution=(720, 1280))  # Resolución reducida
         total_duration = video_original.duration
         
-        # Monitoreo de recursos
-        logging.info(f"Memoria inicial: {psutil.virtual_memory().percent}%")
-        logging.info(f"CPU inicial: {psutil.cpu_percent()}%")
-        
-        # Dividir en chunks
+        # Dividir en chunks pequeños
         chunks = []
         for start in range(0, int(total_duration), CHUNK_SIZE):
             end = min(start + CHUNK_SIZE, total_duration)
             chunk = video_original.subclip(start, end)
             chunks.append((start, chunk))
         
-        # Procesar cada chunk
+        # Procesar chunks secuencialmente
         processed_clips = []
         for i, (start_time, chunk) in enumerate(chunks):
             logging.info(f"Procesando chunk {i+1}/{len(chunks)}")
             processed_chunk = await procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time)
             processed_clips.append(processed_chunk)
         
-        # Combinar todos los chunks
+        # Combinar chunks
         final_video = concatenate_videoclips(processed_clips, method="compose")
         
-        # Agregar intro y outro
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(1080, 1920))
+        # Agregar intro/outro
+        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(720, 1280))
+        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(720, 1280))
         final_video = concatenate_videoclips([intro, final_video, outro], method="compose")
         
-        # Renderizado final con optimización
+        # Renderizado ultra optimizado
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             final_video.write_videofile(
                 tmp.name,
-                codec="libx264",  # Cambiado de h264_nvenc a libx264 para compatibilidad
-                preset="ultrafast",
+                codec="libx264",
                 audio_codec="aac",
-                fps=video_original.fps,
-                threads=4,
-                bitrate="5M",
+                fps=24,
+                threads=2,  # Menos hilos para evitar saturación
+                bitrate="3M",  # Bitrate reducido
                 ffmpeg_params=[
-                    "-crf", "23",
+                    "-preset", "superfast",
+                    "-crf", "28",
                     "-movflags", "+faststart",
-                    "-vf", "scale=1920:1080"
+                    "-vf", "scale=1280:720"  # Resolución 720p para mayor velocidad
                 ],
                 verbose=False
             )
@@ -255,4 +257,4 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.queue().launch()  # Corrección: Eliminados concurrency_count y max_size
+    demo.queue().launch()  # Sin parámetros no soportados