Update app.py

app.py

@@ -1,104 +1,88 @@
+import os
 import math
 import tempfile
 import logging
 from PIL import Image
-import os
-import asyncio
+from pydub import AudioSegment
 from moviepy.editor import (
     VideoFileClip, AudioFileClip, ImageClip,
-    concatenate_videoclips, CompositeVideoClip, CompositeAudioClip
+    concatenate_videoclips, CompositeVideoClip
 )
 import edge_tts
 import gradio as gr
-from pydub import AudioSegment
-
-# PATCH PARA PILLOW 10+ (crítico)
-Image.ANTIALIAS = Image.Resampling.LANCZOS  # Parche antes de importar MoviePy
+import asyncio
 
-# Configuración de Logs
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+# PATCH PARA PILLOW 10+
+Image.ANTIALIAS = Image.Resampling.LANCZOS
 
-# CONSTANTES DE ARCHIVOS (sin cambios en los nombres)
+# CONFIGURACIÓN
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 FX_SOUND = "fxsound.mp3"
 WATERMARK = "watermark.png"
 
-# Validar existencia de archivos obligatorios
+# Validar archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK]:
     if not os.path.exists(file):
-        logging.error(f"Falta archivo necesario: {file}")
-        raise FileNotFoundError(f"Falta archivo necesario: {file}")
+        raise FileNotFoundError(f"Falta: {file}")
+
+async def procesar_audio(texto, voz, duracion_total):
+    try:
+        communicate = edge_tts.Communicate(texto, voz)
+        
+        # Generar TTS en WAV (formato sin compresión)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_wav:
+            await communicate.save(tmp_wav.name)
+            tts_audio = AudioSegment.from_wav(tmp_wav.name)
+        
+        # Preparar música de fondo en loop
+        bg_music = AudioSegment.from_mp3(MUSIC_BG) - 10  # 10% volumen
+        repeticiones = math.ceil(duracion_total * 1000 / len(bg_music))
+        bg_music_loop = bg_music * repeticiones
+        bg_music_final = bg_music_loop[:duracion_total*1000].fade_out(3000)
+        
+        # Combinar TTS (después de la intro) con música
+        intro_duration = VideoFileClip(INTRO_VIDEO).duration * 1000  # Duración en ms
+        audio_final = bg_music_final.overlay(tts_audio, position=intro_duration)
+        
+        # Exportar directamente como MP3 con parámetros robustos
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_mp3:
+            audio_final.export(
+                tmp_mp3.name,
+                format="mp3",
+                parameters=["-ac", "2", "-ar", "44100", "-b:a", "320k"]
+            )
+            return tmp_mp3.name
+    except Exception as e:
+        logging.error(f"Error procesando audio: {e}")
+        raise
 
 def cortar_video(video_path, metodo="inteligente", duracion=10):
     try:
-        logging.info("Iniciando corte de video...")
         video = VideoFileClip(video_path)
         if metodo == "manual":
-            clips = [video.subclip(i * duracion, (i + 1) * duracion)
-                     for i in range(math.ceil(video.duration / duracion))]
-            logging.info(f"Video cortado en {len(clips)} clips manuales.")
-            return clips
+            return [
+                video.subclip(i*duracion, (i+1)*duracion)
+                for i in range(math.ceil(video.duration/duracion))
+            ]
         
-        # Simulación básica de cortes automáticos (puedes mejorar esto con VAD)
+        # Simulación de cortes automáticos
         clips = []
         ultimo_corte = 0
         for i in range(1, math.ceil(video.duration)):
             if i % 5 == 0:  # Simulación de pausas
                 clips.append(video.subclip(ultimo_corte, i))
                 ultimo_corte = i
-        logging.info(f"Video cortado en {len(clips)} clips automáticos.")
-        return clips
+        return clips if clips else [video]
     except Exception as e:
-        logging.error(f"Error al cortar video: {e}")
-        raise
-
-async def procesar_audio(texto, voz, duracion_total, duracion_intro, duracion_video_editado):
-    try:
-        logging.info("Generando TTS y mezclando audio...")
-        communicate = edge_tts.Communicate(texto, voz)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            await communicate.save(tmp.name)  # Usar await en lugar de asyncio.run()
-            tts_audio = AudioFileClip(tmp.name)
-        
-        # Duración natural del TTS
-        tts_duration = tts_audio.duration
-        
-        # Ajustar TTS para que dure solo lo que dura el video editado
-        if tts_duration > duracion_video_editado:
-            tts_audio = tts_audio.subclip(0, duracion_video_editado)
-        
-        # Mezclar con música de fondo
-        bg_music = AudioSegment.from_mp3(MUSIC_BG)
-        if len(bg_music) < duracion_total * 1000:
-            bg_music = bg_music * math.ceil(duracion_total * 1000 / len(bg_music))
-        bg_music = bg_music[:duracion_total * 1000].fade_out(3000)
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            bg_music.export(tmp.name, format="mp3")
-            bg_audio = AudioFileClip(tmp.name).volumex(0.10)
-        
-        # Combinar audios: bg_audio en toda la duración, tts_audio después del intro
-        audio_final = CompositeAudioClip([
-            bg_audio,
-            tts_audio.volumex(0.9).set_start(duracion_intro)
-        ])
-        
-        logging.info("Audio procesado correctamente.")
-        return audio_final
-    except Exception as e:
-        logging.error(f"Error al procesar audio: {e}")
+        logging.error(f"Error cortando video: {e}")
         raise
 
 def agregar_transiciones(clips):
     try:
-        logging.info("Agregando transiciones...")
         fx_audio = AudioFileClip(FX_SOUND).set_duration(2.5)
-        transicion = ImageClip(WATERMARK).set_duration(2.5)
-        
-        # Redimensionar la transición
-        transicion = transicion.resize(height=clips[0].h).set_position(("center", 0.1))
+        transicion = ImageClip(WATERMARK).set_duration(2.5).resize(height=clips[0].h).set_position(("center", 0.1))
         
         clips_con_fx = []
         for i, clip in enumerate(clips):
@@ -106,19 +90,19 @@ def agregar_transiciones(clips):
             clip_watermarked = CompositeVideoClip([clip, transicion])
             clips_con_fx.append(clip_watermarked)
             
-            if i < len(clips) - 1:
+            # Agregar transición entre clips
+            if i < len(clips)-1:
                 clips_con_fx.append(
                     CompositeVideoClip([transicion.set_position("center")])
                     .set_audio(fx_audio)
                 )
-        logging.info("Transiciones agregadas correctamente.")
         return concatenate_videoclips(clips_con_fx)
     except Exception as e:
-        logging.error(f"Error al agregar transiciones: {e}")
+        logging.error(f"Error en transiciones: {e}")
         raise
 
 async def procesar_video(
-    video_input, 
+    video_input,
     texto_tts,
     voz_seleccionada,
     metodo_corte,
@@ -126,46 +110,45 @@ async def procesar_video(
 ):
     temp_files = []
     try:
-        logging.info("Iniciando procesamiento de video...")
         # Procesar video principal
         clips = cortar_video(video_input, metodo_corte, duracion_corte)
         video_editado = agregar_transiciones(clips)
         
-        # Cargar intro y outro
+        # Agregar intro/outro
         intro = VideoFileClip(INTRO_VIDEO)
         outro = VideoFileClip(OUTRO_VIDEO)
-        
-        # Calcular duraciones
-        duracion_intro = intro.duration
-        duracion_video_editado = video_editado.duration
-        duracion_total = duracion_intro + duracion_video_editado + outro.duration
-        
-        # Concatenar intro, video editado y outro
         video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Procesar audio
-        audio_final = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, duracion_intro, duracion_video_editado)
+        # Calcular duración total para la música
+        duracion_total = video_final.duration
         
-        # Combinar y renderizar
-        video_final = video_final.set_audio(audio_final)
+        # Generar audio (música en loop + TTS después de intro)
+        audio_mix_path = await procesar_audio(texto_tts, voz_seleccionada, duracion_total)
         
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
-            video_final.write_videofile(tmp.name, codec="libx264", fps=24)
-            logging.info("Video procesado y guardado temporalmente.")
-            temp_files.append(tmp.name)
-            return tmp.name
+        # Combinar video y audio
+        video_final = video_final.set_audio(AudioFileClip(audio_mix_path))
+        
+        # Renderizar
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_out:
+            video_final.write_videofile(
+                tmp_out.name,
+                codec="libx264",
+                audio_codec="aac",
+                fps=24
+            )
+            temp_files.append(tmp_out.name)
+            return tmp_out.name
     except Exception as e:
-        logging.error(f"Error durante el procesamiento: {e}")
+        logging.error(f"Error general: {e}")
         raise
     finally:
         # Eliminar archivos temporales
-        for file in temp_files:
+        for file in temp_files + [getattr(video_input, 'name', None)]:
             try:
-                if os.path.exists(file):
+                if file and os.path.exists(file):
                     os.remove(file)
-                    logging.info(f"Archivo temporal eliminado: {file}")
             except Exception as e:
-                logging.warning(f"No se pudo eliminar el archivo temporal {file}: {e}")
+                logging.warning(f"Error eliminando {file}: {e}")
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -175,7 +158,7 @@ with gr.Blocks() as demo:
         video_input = gr.Video(label="Subir video")
         texto_tts = gr.Textbox(label="Texto para TTS", lines=3)
         voz_seleccionada = gr.Dropdown(
-            label="Seleccionar voz",
+            label="Voz",
             choices=["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"]
         )
         procesar_btn = gr.Button("Generar Video")
@@ -184,26 +167,16 @@ with gr.Blocks() as demo:
     with gr.Tab("Ajustes"):
         metodo_corte = gr.Radio(
             ["inteligente", "manual"],
-            label="Método de cortes",
+            label="Método de corte",
             value="inteligente"
         )
-        duracion_corte = gr.Slider(
-            1, 60, 10,
-            label="Segundos por corte (solo manual)"
-        )
+        duracion_corte = gr.Slider(1, 60, 10, label="Duración por corte (solo manual)")
 
     procesar_btn.click(
         procesar_video,
-        inputs=[
-            video_input,
-            texto_tts,
-            voz_seleccionada,
-            metodo_corte,
-            duracion_corte
-        ],
+        inputs=[video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte],
         outputs=video_output
     )
 
 if __name__ == "__main__":
-    logging.info("Iniciando aplicación Gradio...")
     demo.queue().launch()