Update app.py

app.py

@@ -14,11 +14,10 @@ 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"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
 # Validar existencia de archivos
-for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, GLITCH_SOUND, EJEMPLO_VIDEO]:
+for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
@@ -38,50 +37,26 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
     from threading import Timer
     Timer(delay, eliminar).start()
 
-async def procesar_audio_tts(texto, voz, duracion_video):
-    temp_files = []
+async def generar_tts(texto, voz, duracion_total):
     try:
-        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)]
-
-        fragmentos = dividir_texto(texto)
-        audios_tts = []
-
-        for fragmento in fragmentos:
-            communicate = edge_tts.Communicate(fragmento, voz)
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
-                await communicate.save(tmp_tts.name)
-                tts_audio = AudioFileClip(tmp_tts.name)
-                temp_files.append(tmp_tts.name)
-                audios_tts.append(tts_audio)
-
-        tts_audio_final = concatenate_audioclips(audios_tts)
-
-        if tts_audio_final.duration > duracion_video:
-            tts_audio_final = tts_audio_final.subclip(0, duracion_video)
-
-        logging.info("TTS procesado exitosamente")
-        return tts_audio_final, temp_files
-    
+        logging.info("Generando TTS")
+        communicate = edge_tts.Communicate(texto, voz)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
+            await communicate.save(tmp_tts.name)
+            tts_audio = AudioFileClip(tmp_tts.name)
+            
+            # Asegurar que el TTS no exceda la duración del video
+            if tts_audio.duration > duracion_total:
+                tts_audio = tts_audio.subclip(0, duracion_total)
+                
+            return tts_audio, tmp_tts.name
     except Exception as e:
-        logging.error(f"Fallo en procesamiento de TTS: {str(e)}")
+        logging.error(f"Fallo en TTS: {str(e)}")
         raise
-    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."""
+def crear_musica_fondo(duracion_total):
     bg_music = AudioSegment.from_mp3(MUSIC_BG)
-    needed_ms = int(duracion_video * 1000)
+    needed_ms = int(duracion_total * 1000)
     repeticiones = needed_ms // len(bg_music) + 1
     bg_music = bg_music * repeticiones
     bg_music = bg_music[:needed_ms].fade_out(1000)
@@ -90,91 +65,51 @@ def crear_musica_fondo(duracion_video):
         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):
-    try:
-        duracion_chunk = chunk.duration
-        
-        # Procesar TTS para este chunk
-        tts_audio_final, tts_temp_files = await procesar_audio_tts(
-            texto_tts,
-            voz_seleccionada,
-            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 cortes de 2 segundos
-        segment_duration = 18
-        overlap = 2
-        segments = []
-
-        current_time = 0
-        while current_time < duracion_chunk:
-            end_time = current_time + segment_duration
-            end_time = min(end_time, duracion_chunk)
-            
-            full_segment = chunk.subclip(current_time, end_time)
-            segments.append(full_segment)
-            current_time += (segment_duration - overlap)
-
-        # Asegurar que haya al menos un segmento
-        if not segments:
-            logging.warning("Chunk demasiado corto, devolviendo el chunk original.")
-            video_chunk = chunk.set_audio(audio_final)
-        else:
-            video_chunk = concatenate_videoclips(segments, method="compose")
-            video_chunk = video_chunk.set_audio(audio_final)
-        
-        return video_chunk, tts_temp_files + [bg_temp_file]
-            
-    except Exception as e:
-        logging.error(f"Fallo procesando fragmento: {str(e)}")
-        raise
-
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     temp_files = []
-    intro, outro = None, None  # Inicializar variables para evitar errores
+    intro, outro, video_original = None, None, None
     try:
-        logging.info("Iniciando procesamiento de video")
+        logging.info("Iniciando procesamiento")
         video_original = VideoFileClip(video_input, target_resolution=(720, 1280))
-        total_duration = video_original.duration
+        duracion_video = video_original.duration
+        
+        # Generar TTS y música de fondo para todo el video
+        tts_audio, tts_path = await generar_tts(texto_tts, voz_seleccionada, duracion_video)
+        bg_audio, bg_path = crear_musica_fondo(duracion_video)
+        temp_files.extend([tts_path, bg_path])
+        
+        # Combinar audios
+        audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
+        audios = [bg_audio.set_duration(duracion_video)]
+        if audio_original:
+            audios.append(audio_original)
+        audios.append(tts_audio.set_start(0).volumex(0.85))
+        audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
         
-        # Dividir en chunks
+        # Dividir video en chunks para procesamiento
         chunks = []
-        for start in range(0, int(total_duration), CHUNK_SIZE):
-            end = min(start + CHUNK_SIZE, total_duration)
+        for start in range(0, int(duracion_video), CHUNK_SIZE):
+            end = min(start + CHUNK_SIZE, duracion_video)
             chunk = video_original.subclip(start, end)
-            chunks.append((start, chunk))
+            chunks.append(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, chunk_temp_files = await procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time)
-            processed_clips.append(processed_chunk)
-            temp_files.extend(chunk_temp_files)
+        for chunk in chunks:
+            processed_clips.append(chunk)
         
-        # Combinar chunks
-        final_video = concatenate_videoclips(processed_clips, method="compose")
+        # Combinar chunks (sin efectos)
+        video_final = concatenate_videoclips(processed_clips, method="compose")
+        video_final = video_final.set_audio(audio_final)
         
         # Agregar intro y 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")
+        video_final = concatenate_videoclips([intro, video_final, outro], method="compose")
         
         # Renderizado final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
-            final_video.write_videofile(
+            video_final.write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",