Update app.py

app.py

@@ -6,6 +6,7 @@ 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")
@@ -23,6 +24,10 @@ for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, GLITCH_SOUND, EJEMPLO_VIDEO]:
         logging.error(f"Falta archivo necesario: {file}")
         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)
+
 def eliminar_archivo_tiempo(ruta, delay=1800):
     def eliminar():
         try:
@@ -102,42 +107,32 @@ def aplicar_glitch(video_clip):
 
     return video_clip.fl_image(glitch_effect)
 
-async def procesar_video(video_input, texto_tts, voz_seleccionada):
+async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
     try:
-        logging.info("Iniciando procesamiento de video")
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(1080, 1920))
-        video_original = VideoFileClip(video_input, target_resolution=(1080, 1920))
-        audio_original = video_original.audio
-        
-        intro.reader.close()
-        outro.reader.close()
-        video_original.reader.close()
-
-        duracion_video = video_original.duration
-        logging.info(f"Duración del video original: {duracion_video}s")
+        audio_original = chunk.audio
+        duracion_chunk = chunk.duration
         
         audio_final = await procesar_audio(
             texto_tts,
             voz_seleccionada,
-            duracion_video,
+            duracion_chunk,
             audio_original
         )
         
         segment_duration = 18
         overlap = 2
-        total_segments = int((duracion_video) // (segment_duration)) + 1
+        total_segments = int((duracion_chunk) // (segment_duration)) + 1
         
         segments = []
         glitch_clips = []
         glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
 
-        start_time = 0
+        current_time = 0
         for i in range(total_segments):
-            end_time = start_time + segment_duration + overlap
-            end_time = min(end_time, duracion_video)
+            end_time = current_time + segment_duration + overlap
+            end_time = min(end_time, duracion_chunk)
             
-            full_segment = video_original.subclip(start_time, end_time)
+            full_segment = chunk.subclip(current_time, end_time)
             
             if i > 0:
                 glitch_part = full_segment.subclip(0, 0.5)
@@ -147,49 +142,83 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                     full_segment.subclip(0.5)
                 ], method="compose")
                 
-                glitch_sound_clip = glitch_sound.set_start(start_time)
+                glitch_sound_clip = glitch_sound.set_start(start_time + current_time)
                 glitch_clips.append(glitch_sound_clip)
             else:
                 processed_segment = full_segment
 
             segments.append(processed_segment)
-            start_time += segment_duration
+            current_time += segment_duration
+
+        video_chunk = concatenate_videoclips(segments, method="compose")
+        video_chunk = video_chunk.set_audio(audio_final)
+        return video_chunk
+            
+    except Exception as e:
+        logging.error(f"Fallo procesando fragmento: {str(e)}")
+        raise
 
-        video_final = concatenate_videoclips(segments, method="compose")
-        video_con_audio = video_final.set_audio(audio_final)
+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))
+        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
+        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
+        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
+        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))
-        video_final = concatenate_videoclips([intro, video_con_audio, outro], method="compose")
+        final_video = concatenate_videoclips([intro, final_video, outro], method="compose")
         
+        # Renderizado final con optimización
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
-            video_final.write_videofile(
+            final_video.write_videofile(
                 tmp.name,
-                codec="libx264",
+                codec="h264_nvenc",  # Usa GPU si está disponible
+                preset="p7",
                 audio_codec="aac",
                 fps=video_original.fps,
-                threads=4,
-                bitrate="5M",
+                threads=8,
+                bitrate="8M",
                 ffmpeg_params=[
-                    "-preset", "ultrafast",
-                    "-crf", "23",
+                    "-crf", "28",
                     "-movflags", "+faststart",
                     "-vf", "scale=1920:1080"
                 ],
                 verbose=False
             )
             eliminar_archivo_tiempo(tmp.name, 1800)
-            logging.info(f"Video procesado guardado en: {tmp.name}")
+            logging.info(f"Video final guardado: {tmp.name}")
             return tmp.name
             
     except Exception as e:
-        logging.error(f"Fallo general en procesamiento: {str(e)}")
+        logging.error(f"Fallo general: {str(e)}")
         raise
     finally:
         try:
+            video_original.close()
             intro.close()
             outro.close()
-            video_original.close()
         except:
             pass
 
@@ -226,4 +255,8 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.queue().launch()
+    demo.queue(
+        concurrency_count=1,
+        max_size=20,
+        server_timeout=3600  # Timeout de 1 hora
+    ).launch()