Update app.py

app.py

@@ -27,41 +27,28 @@ for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK]:
     if not os.path.exists(file):
         raise FileNotFoundError(f"Falta: {file}")
 
-async def procesar_audio(texto, voz):
+async def procesar_audio(texto, voz, duracion_total):
     try:
         communicate = edge_tts.Communicate(texto, voz)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            await communicate.save(tmp.name)
-            return tmp.name  # Retorna solo el TTS sin procesar
-    except Exception as e:
-        logging.error(f"TTS fallido: {e}")
-        raise
-
-def mezclar_audio(tts_path, duracion_total):
-    try:
-        # Cargar TTS
-        tts = AudioSegment.from_mp3(tts_path)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
+            await communicate.save(tmp_tts.name)
+            tts_audio = AudioSegment.from_mp3(tmp_tts.name)
         
         # Preparar música de fondo en loop
-        bg = AudioSegment.from_mp3(MUSIC_BG)
-        bg = bg - 10  # 10% volumen (ajusta según necesidad)
+        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)
         
-        # Calcular repeticiones necesarias
-        repeticiones = math.ceil(duracion_total * 1000 / len(bg))
-        bg_loop = bg * repeticiones
+        # 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)
         
-        # Recortar a duración exacta
-        bg_final = bg_loop[:duracion_total*1000].fade_out(3000)
-        
-        # Combinar TTS y música
-        audio_final = bg_final.overlay(tts, position=0)
-        
-        # Guardar temporal
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            audio_final.export(tmp.name, format="mp3")
-            return tmp.name
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_mix:
+            audio_final.export(tmp_mix.name, format="mp3")
+            return tmp_mix.name
     except Exception as e:
-        logging.error(f"Error mezclando audio: {e}")
+        logging.error(f"Error procesando audio: {e}")
         raise
 
 def cortar_video(video_path, metodo="inteligente", duracion=10):
@@ -108,7 +95,7 @@ def agregar_transiciones(clips):
         raise
 
 async def procesar_video(
-    video_input, 
+    video_input,
     texto_tts,
     voz_seleccionada,
     metodo_corte,
@@ -116,7 +103,7 @@ async def procesar_video(
 ):
     temp_files = []
     try:
-        # Procesar video
+        # Procesar video principal
         clips = cortar_video(video_input, metodo_corte, duracion_corte)
         video_editado = agregar_transiciones(clips)
         
@@ -125,47 +112,44 @@ async def procesar_video(
         outro = VideoFileClip(OUTRO_VIDEO)
         video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Generar TTS
-        tts_path = await procesar_audio(texto_tts, voz_seleccionada)
-        duracion_tts = AudioFileClip(tts_path).duration
-        
-        # Calcular duración total (intro + contenido + outro)
-        duracion_total = intro.duration + video_editado.duration + outro.duration
+        # Calcular duración total para la música
+        duracion_total = video_final.duration
         
-        # Mezclar audio
-        audio_mix_path = mezclar_audio(tts_path, duracion_total)
+        # Generar audio (música en loop + TTS después de intro)
+        audio_mix_path = await procesar_audio(texto_tts, voz_seleccionada, duracion_total)
         
         # Combinar video y audio
         video_final = video_final.set_audio(AudioFileClip(audio_mix_path))
         
-        # Guardar resultado final
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
-            video_final.write_videofile(tmp.name, codec="libx264", fps=24)
-            temp_files.append(tmp.name)
-            return tmp.name
+        # Renderizar
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_out:
+            video_final.write_videofile(tmp_out.name, codec="libx264", fps=24)
+            temp_files.append(tmp_out.name)
+            return tmp_out.name
     except Exception as e:
         logging.error(f"Error general: {e}")
         raise
     finally:
-        # Eliminar temporales
-        for file in temp_files + [tts_path, audio_mix_path]:
+        # Eliminar archivos temporales
+        for file in temp_files + [getattr(video_input, 'name', None)]:
             try:
-                os.remove(file)
-            except:
-                pass
+                if file and os.path.exists(file):
+                    os.remove(file)
+            except Exception as e:
+                logging.warning(f"Error eliminando {file}: {e}")
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Video Editor IA")
     
     with gr.Tab("Principal"):
-        video_input = gr.Video(label="Subir video")
+        video_input = gr.Video(label="Subir video")  # Solo un video
         texto_tts = gr.Textbox(label="Texto para TTS", lines=3)
         voz_seleccionada = gr.Dropdown(
             label="Voz",
             choices=["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"]
         )
-        procesar_btn = gr.Button("Generar")
+        procesar_btn = gr.Button("Generar Video")
         video_output = gr.Video(label="Resultado")
     
     with gr.Tab("Ajustes"):