Update app.py

app.py

@@ -69,9 +69,9 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
         if tts_audio_final.duration > duracion_video:
             tts_audio_final = tts_audio_final.subclip(0, duracion_video)
 
-        # Preparar música de fondo en loop
-        bg_music = AudioSegment.from_mp3(MUSIC_BG)
+        # Preparar música de fondo en loop (OPTIMIZADO)
         needed_ms = int(duracion_video * 1000)
+        bg_music = AudioSegment.from_mp3(MUSIC_BG)
         repeticiones = needed_ms // len(bg_music) + 1
         bg_music = bg_music * repeticiones
         bg_music = bg_music[:needed_ms].fade_out(1000)
@@ -101,16 +101,17 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
                 logging.warning(f"Error limpiando {file}: {e}")
 
 def aplicar_glitch(video_clip):
-    """Aplica un efecto de glitch al video."""
+    """Aplica un efecto de glitch al video (OPTIMIZADO)"""
     def glitch_effect(frame):
         import numpy as np
         height, width, _ = frame.shape
-        offset = np.random.randint(-10, 10)
+        offset = np.random.randint(-5, 5)  # Reducido el rango de glitch
+        if offset == 0: return frame  # Evitar operaciones innecesarias
         if offset > 0:
             offset = min(offset, height)
         if offset < 0:
             offset = max(offset, -height + 1)
-        if offset!= 0 and height > 0:
+        if height > 0:
             frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
         return frame
 
@@ -118,10 +119,10 @@ def aplicar_glitch(video_clip):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
-        # Cargar componentes
-        intro = VideoFileClip(INTRO_VIDEO)
-        outro = VideoFileClip(OUTRO_VIDEO)
-        video_original = VideoFileClip(video_input)
+        # Cargar componentes con OPTIMIZACIÓN DE MEMORIA
+        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
         
         # Duración del video editado (sin intro/outro)
@@ -135,26 +136,13 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
-        # Redimensionar todos los clips a 1920x1080
-        target_width = 1920
-        target_height = 1080
-
-        # Redimensionar intro
-        intro_resized = intro.resize((target_width, target_height))
-
-        # Redimensionar outro
-        outro_resized = outro.resize((target_width, target_height))
-
-        # Redimensionar video principal
-        video_resized = video_original.resize((target_width, target_height))
-
         # Dividir el video en segmentos de 20 segundos y eliminar 2 segundos en cada corte
         segment_duration = 20
         overlap = 2  # Segundos a eliminar en cada corte
         num_segments = int(duracion_video // (segment_duration - overlap)) + 1
         segments = []
         glitch_clips = []
-        glitch_sound = AudioFileClip(GLITCH_SOUND)
+        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)  # Pre-cargado una vez
 
         start_time = 0
         for i in range(num_segments):
@@ -163,14 +151,14 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                 break
 
             # Extraer el segmento
-            segment = video_resized.subclip(start_time, end_time)
+            segment = video_original.subclip(start_time, end_time)
 
-            # Aplicar glitch al inicio del segmento (excepto el primero)
-            if i > 0:
-                glitch_segment = aplicar_glitch(segment.subclip(0, 0.5))  # Glitch de 0.5 segundos
-                glitch_sound_clip = glitch_sound.set_start(start_time).volumex(0.5)
+            # Aplicar glitch cada 2 segmentos (40 segundos) en lugar de cada 1
+            if i % 2 == 0 and i > 0:
+                glitch_segment = aplicar_glitch(segment.subclip(0, 0.3))  # Duración reducida
+                glitch_sound_clip = glitch_sound.set_start(start_time)
                 glitch_clips.append(glitch_sound_clip)
-                segment = concatenate_videoclips([glitch_segment, segment.subclip(0.5)], method="compose")
+                segment = concatenate_videoclips([glitch_segment, segment.subclip(0.3)], method="compose")
 
             segments.append(segment)
 
@@ -186,24 +174,28 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         # Combinar video con audio
         video_con_audio = video_final.set_audio(audio_final)
         
-        # Concatenar intro + video + outro SIN alteraciones
+        # Concatenar intro + video + outro
         video_final = concatenate_videoclips(
-            [intro_resized, video_con_audio, outro_resized],
-            method="compose",  # Evitar problemas de grid
-            padding=0  # Sin espacio entre clips
+            [intro, video_con_audio, outro],
+            method="compose",
+            padding=0
         )
         
-        # Renderizar video final con metadatos correctos
+        # Renderizar video final con OPTIMIZACIONES DE CODIFICACIÓN
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
-                fps=video_original.fps,  # Mantener FPS original
+                fps=video_original.fps,
                 threads=4,
+                bitrate="5M",  # Control de tamaño
                 ffmpeg_params=[
-                    "-aspect", "16:9",  # Forzar relación de aspecto
-                    "-vf", "scale=1920:1080"  # Forzar escalado explícito
+                    "-preset", "ultrafast",  # Velocidad de codificación
+                    "-crf", "23",  # Calidad estándar
+                    "-movflags", "+faststart",  # Para streaming
+                    "-aspect", "16:9",
+                    "-vf", "scale=1920:1080"
                 ],
                 verbose=False
             )