Update app.py

app.py

@@ -7,13 +7,16 @@ import edge_tts
 import gradio as gr
 from pydub import AudioSegment
 
+# Configuración de Logs
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
+# CONSTANTES DE ARCHIVOS
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
+# Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
@@ -33,15 +36,39 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
     try:
-        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)
-            temp_files.append(tmp_tts.name)
-            
-            if tts_audio.duration > duracion_video:
-                tts_audio = tts_audio.subclip(0, duracion_video)
+        # 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)]
+
+        fragmentos = dividir_texto(texto)
+        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.")
+                
+                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
         bg_music = AudioSegment.from_mp3(MUSIC_BG)
         needed_ms = int(duracion_video * 1000)
         repeticiones = needed_ms // len(bg_music) + 1
@@ -53,10 +80,11 @@ 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))
-        audios.append(tts_audio.volumex(0.85).set_start(0))
+            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%
         
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
         return audio_final
@@ -73,13 +101,16 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
+        # Cargar componentes
         intro = VideoFileClip(INTRO_VIDEO)
         outro = VideoFileClip(OUTRO_VIDEO)
         video_original = VideoFileClip(video_input)
         audio_original = video_original.audio
         
+        # Duración del video editado (sin intro/outro)
         duracion_video = video_original.duration
         
+        # Procesar audio
         audio_final = await procesar_audio(
             texto_tts,
             voz_seleccionada,
@@ -87,28 +118,54 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
+        # Redimensionar temporalmente el video a un tamaño muy grande (4000px de ancho)
+        video_temporal = video_original.resize(width=4000)
+
+        # Redimensionar nuevamente al tamaño final deseado (1920x1080)
         target_width = 1920
         target_height = 1080
-        video_resized = video_original.resize((target_width, target_height))
+        video_resized = video_temporal.resize(height=target_height)
+
+        # Manejar márgenes si es necesario
+        current_width = video_resized.w
+        current_height = video_resized.h
+        if current_width < target_width:
+            # Agregar márgenes laterales
+            margin_left = (target_width - current_width) // 2
+            margin_right = target_width - current_width - margin_left
+            video_final = video_resized.margin(
+                left=margin_left,
+                right=margin_right,
+                color=(0, 0, 0)  # Negro
+            )
+        else:
+            # Recortar horizontalmente si es más ancho que 1920
+            video_final = video_resized.crop(
+                x1=(current_width - target_width) // 2,
+                x2=current_width - (current_width - target_width) // 2
+            )
 
-        video_con_audio = video_resized.set_audio(audio_final)
+        # Combinar video con audio
+        video_con_audio = video_final.set_audio(audio_final)
         
+        # Concatenar intro + video + outro SIN alteraciones
         video_final = concatenate_videoclips(
             [intro, video_con_audio, outro],
-            method="compose",
-            padding=0
+            method="compose",  # Evitar problemas de grid
+            padding=0  # Sin espacio entre clips
         )
         
+        # Renderizar video final con metadatos correctos
         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=video_original.fps,  # Mantener FPS original
                 threads=4,
                 ffmpeg_params=[
-                    "-aspect", "16:9",
-                    "-vf", "scale=1920:1080"
+                    "-aspect", "16:9",  # Forzar relación de aspecto
+                    "-vf", "scale=1920:1080"  # Forzar escalado explícito
                 ],
                 verbose=False
             )
@@ -118,6 +175,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         logging.error(f" fallo general: {str(e)}")
         raise
 
+# Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Editor de Video con IA")