Update app.py

app.py

@@ -38,13 +38,14 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
     from threading import Timer
     Timer(delay, eliminar).start()
 
-async def procesar_audio(texto, voz, duracion_video, audio_original=None):
+async def procesar_audio_tts(texto, voz, duracion_video):
     temp_files = []
     try:
-        logging.info("Iniciando procesamiento de audio")
+        logging.info("Iniciando procesamiento de TTS")
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
 
+        # Dividir texto en fragmentos manejables
         def dividir_texto(texto, max_length=2000):
             return [texto[i:i + max_length] for i in range(0, len(texto), max_length)]
 
@@ -64,65 +65,55 @@ async def procesar_audio(texto, voz, duracion_video, audio_original=None):
         if tts_audio_final.duration > duracion_video:
             tts_audio_final = tts_audio_final.subclip(0, duracion_video)
 
-        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)
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_bg:
-            bg_music.export(tmp_bg.name, format="mp3")
-            bg_audio = AudioFileClip(tmp_bg.name).volumex(0.15)
-            temp_files.append(tmp_bg.name)
-
-        audios = [bg_audio.set_duration(duracion_video)]
-        if audio_original:
-            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)
-        logging.info("Audio procesado exitosamente")
-        return audio_final, temp_files  # Retornamos los archivos temporales para limpieza
+        logging.info("TTS procesado exitosamente")
+        return tts_audio_final, temp_files
     
     except Exception as e:
-        logging.error(f"Fallo en procesamiento de audio: {str(e)}")
+        logging.error(f"Fallo en procesamiento de TTS: {str(e)}")
         raise
-
-def aplicar_glitch(video_clip):
-    def glitch_effect(frame):
-        import numpy as np
-        frame = frame.copy()
-        height, width, _ = frame.shape
-        offset = np.random.randint(3, 8)
-        if height > 0 and offset != 0:
-            frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
-        return frame
-
-    return video_clip.fl_image(glitch_effect)
+    finally:
+        for file in temp_files:
+            try:
+                os.remove(file)
+            except Exception as e:
+                logging.warning(f"Error limpiando {file}: {e}")
+
+def crear_musica_fondo(duracion_video):
+    """Crea un loop continuo de música de fondo."""
+    bg_music = AudioSegment.from_mp3(MUSIC_BG)
+    needed_ms = int(duracion_video * 1000)
+    repeticiones = needed_ms // len(bg_music) + 1
+    bg_music = bg_music * repeticiones
+    bg_music = bg_music[:needed_ms].fade_out(1000)
+    
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_bg:
+        bg_music.export(tmp_bg.name, format="mp3")
+        return AudioFileClip(tmp_bg.name).volumex(0.15), tmp_bg.name
 
 async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
-    temp_files = []
     try:
-        audio_original = chunk.audio
         duracion_chunk = chunk.duration
         
-        # Si el chunk es demasiado corto, devolver sin procesar
-        if duracion_chunk <= 18:
-            audio_final, temp_files = await procesar_audio(
-                texto_tts,
-                voz_seleccionada,
-                duracion_chunk,
-                audio_original
-            )
-            return chunk.set_audio(audio_final), temp_files
-        
-        audio_final, temp_files = await procesar_audio(
+        # Procesar TTS para este chunk
+        tts_audio_final, tts_temp_files = await procesar_audio_tts(
             texto_tts,
             voz_seleccionada,
-            duracion_chunk,
-            audio_original
+            duracion_chunk
         )
         
+        # Crear música de fondo continua
+        bg_audio, bg_temp_file = crear_musica_fondo(duracion_chunk)
+        
+        # Combinar pistas de audio
+        audio_original = chunk.audio
+        audios = [bg_audio.set_duration(duracion_chunk)]
+        if audio_original:
+            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_chunk)
+        
+        # Dividir el chunk en segmentos con transiciones
         segment_duration = 18
         overlap = 2
         segments = []
@@ -132,13 +123,14 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
         current_time = 0
         while current_time < duracion_chunk:
             end_time = current_time + segment_duration
-            end_time = min(end_time, duracion_chunk)
+            if end_time > duracion_chunk:
+                break  # Terminar si ya no hay suficiente tiempo
             
             full_segment = chunk.subclip(current_time, end_time)
             
             if current_time > 0 and full_segment.duration >= 0.5:
                 glitch_part = full_segment.subclip(0, 0.5)
-                glitch_part = aplicar_glitch(glitch_part)
+                glitch_part = glitch_part.fx(vfx.glitch, intensity=0.1)
                 processed_segment = concatenate_videoclips([
                     glitch_part,
                     full_segment.subclip(0.5)
@@ -154,7 +146,7 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
 
         video_chunk = concatenate_videoclips(segments, method="compose")
         video_chunk = video_chunk.set_audio(audio_final)
-        return video_chunk, temp_files
+        return video_chunk, tts_temp_files + [bg_temp_file]
             
     except Exception as e:
         logging.error(f"Fallo procesando fragmento: {str(e)}")
@@ -216,7 +208,6 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         raise
     finally:
         try:
-            # Cerrar recursos solo después de completar todo el procesamiento
             video_original.close()
             intro.close()
             outro.close()