Update app.py

app.py

@@ -14,7 +14,7 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
-GLITCH_SOUND = "fxsound.mp3"  # Efecto de sonido para glitches
+GLITCH_SOUND = "fxsound.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
 # Validar existencia de archivos
@@ -23,25 +23,23 @@ 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}")
 
-def eliminar_archivo_tiempo(ruta, delay=1800):
-    def eliminar():
-        try:
-            if os.path.exists(ruta):
-                os.remove(ruta)
-                logging.info(f"Archivo eliminado: {ruta}")
-        except Exception as e:
-            logging.error(f"Error al eliminar {ruta}: {e}")
-    from threading import Timer
-    Timer(delay, eliminar).start()
+def eliminar_archivo_tiempo(ruta):
+    try:
+        if os.path.exists(ruta):
+            os.remove(ruta)
+            logging.info(f"Archivo eliminado: {ruta}")
+    except Exception as e:
+        logging.error(f"Error al eliminar {ruta}: {e}")
+    finally:
+        import gc
+        gc.collect()  # Forzar liberación de memoria
 
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
     try:
-        # Validar texto
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
 
-        # Dividir el texto en fragmentos si es demasiado largo
         def dividir_texto(texto, max_length=3000):
             return [texto[i:i + max_length] for i in range(0, len(texto), max_length)]
 
@@ -49,27 +47,18 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
         audios_tts = []
 
         for fragmento in fragmentos:
-            # Generar TTS
             communicate = edge_tts.Communicate(fragmento, voz)
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
-                try:
-                    await communicate.save(tmp_tts.name)
-                except edge_tts.exceptions.NoAudioReceived as e:
-                    logging.error(f"Error en TTS: {str(e)}")
-                    raise ValueError("No se pudo generar el audio. Verifica tu conexión o los parámetros del TTS.")
-                
+                await communicate.save(tmp_tts.name)
                 tts_audio = AudioFileClip(tmp_tts.name)
                 temp_files.append(tmp_tts.name)
                 audios_tts.append(tts_audio)
 
-        # Combinar todos los fragmentos de TTS
         tts_audio_final = concatenate_audioclips(audios_tts)
 
-        # Limitar TTS al video
         if tts_audio_final.duration > duracion_video:
             tts_audio_final = tts_audio_final.subclip(0, duracion_video)
 
-        # 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
@@ -81,11 +70,10 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
             bg_audio = AudioFileClip(tmp_bg.name).volumex(0.15)
             temp_files.append(tmp_bg.name)
 
-        # Combinar audios
         audios = [bg_audio.set_duration(duracion_video)]
         if audio_original:
-            audios.append(audio_original.volumex(0.7))  # Audio original al 70%
-        audios.append(tts_audio_final.volumex(0.85).set_start(0))  # TTS al 85%
+            audios.append(audio_original.volumex(0.7))
+        audios.append(tts_audio_final.volumex(0.85).set_start(0))
         
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
         return audio_final
@@ -101,34 +89,42 @@ 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 (OPTIMIZADO)"""
+    """Versión corregida del efecto glitch"""
     def glitch_effect(frame):
         import numpy as np
+        frame = frame.copy()  # ¡Clave para evitar el error de asignación!
         height, width, _ = frame.shape
-        offset = np.random.randint(-5, 5)  # Reducido el rango de glitch
-        if offset == 0: return frame  # Evitar operaciones innecesarias
+        offset = np.random.randint(-5, 5)
+        
+        if offset == 0 or height <= 0:
+            return frame
+            
+        offset = max(-height + 1, min(offset, height))
+        
         if offset > 0:
-            offset = min(offset, height)
-        if offset < 0:
-            offset = max(offset, -height + 1)
-        if height > 0:
             frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
+        else:
+            frame[:offset, :] = np.roll(frame[-offset:, :], -offset, axis=0)
+            
         return frame
 
     return video_clip.fl_image(glitch_effect)
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
-        # Cargar componentes con OPTIMIZACIÓN DE MEMORIA
+        # Carga optimizada con control 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)
+        # Liberar recursos inmediatamente
+        intro.reader.close()
+        outro.reader.close()
+        video_original.reader.close()
+
         duracion_video = video_original.duration
         
-        # Procesar audio
         audio_final = await procesar_audio(
             texto_tts,
             voz_seleccionada,
@@ -136,13 +132,12 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
-        # 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
+        overlap = 2
         num_segments = int(duracion_video // (segment_duration - overlap)) + 1
         segments = []
         glitch_clips = []
-        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)  # Pre-cargado una vez
+        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
 
         start_time = 0
         for i in range(num_segments):
@@ -150,60 +145,58 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             if start_time >= duracion_video:
                 break
 
-            # Extraer el segmento
             segment = video_original.subclip(start_time, end_time)
 
-            # 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
+            # Aplicar glitch solo en segmentos válidos
+            if i % 2 == 0 and i > 0 and (end_time - start_time) > 0.5:
+                glitch_segment = aplicar_glitch(segment.subclip(0, 0.3))
                 glitch_sound_clip = glitch_sound.set_start(start_time)
                 glitch_clips.append(glitch_sound_clip)
                 segment = concatenate_videoclips([glitch_segment, segment.subclip(0.3)], method="compose")
 
             segments.append(segment)
-
-            # Avanzar al siguiente segmento, eliminando 2 segundos
             start_time += segment_duration - overlap
 
-        # Combinar los segmentos procesados
         video_final = concatenate_videoclips(segments)
-
-        # Combinar audio con efectos de glitch
         audio_final = CompositeAudioClip([audio_final] + glitch_clips).set_duration(video_final.duration)
-
-        # Combinar video con audio
         video_con_audio = video_final.set_audio(audio_final)
         
-        # Concatenar intro + video + outro
-        video_final = concatenate_videoclips(
-            [intro, video_con_audio, outro],
-            method="compose",
-            padding=0
-        )
+        # Recargar intro/outro para evitar conflictos de memoria
+        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")
         
-        # Renderizar video final con OPTIMIZACIONES DE CODIFICACIÓN
+        # Renderizado optimizado
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
-                fps=video_original.fps,
+                fps=24,  # FPS fijo para estabilidad
                 threads=4,
-                bitrate="5M",  # Control de tamaño
+                bitrate="5M",
                 ffmpeg_params=[
-                    "-preset", "ultrafast",  # Velocidad de codificación
-                    "-crf", "23",  # Calidad estándar
-                    "-movflags", "+faststart",  # Para streaming
-                    "-aspect", "16:9",
+                    "-preset", "ultrafast",
+                    "-crf", "23",
+                    "-movflags", "+faststart",
                     "-vf", "scale=1920:1080"
                 ],
                 verbose=False
             )
             eliminar_archivo_tiempo(tmp.name)
             return tmp.name
+            
     except Exception as e:
         logging.error(f" fallo general: {str(e)}")
         raise
+    finally:
+        # Forzar cierre de recursos
+        try:
+            intro.close()
+            outro.close()
+            video_original.close()
+        except:
+            pass
 
 # Interfaz Gradio
 with gr.Blocks() as demo: