Update app.py

app.py

@@ -7,16 +7,13 @@ 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}")
@@ -36,18 +33,15 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
     try:
-        # Generar 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)
             temp_files.append(tmp_tts.name)
             
-            # Limitar TTS al video
             if tts_audio.duration > duracion_video:
                 tts_audio = tts_audio.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
@@ -59,11 +53,10 @@ 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))  # Audio original al 70%
-        audios.append(tts_audio.volumex(0.85).set_start(0))  # TTS al 85%
+            audios.append(audio_original.volumex(0.7))
+        audios.append(tts_audio.volumex(0.85).set_start(0))
         
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
         return audio_final
@@ -80,16 +73,13 @@ 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,
@@ -97,50 +87,29 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
-        # Redimensionar el video a una resolución estándar (1920x1080)
         target_width = 1920
         target_height = 1080
-        video_resized = video_original.resize(height=target_height)  # Ajustar altura a 1080p
-        
-        # Calcular márgenes para llenar 1920x1080
-        current_width = video_resized.w
-        current_height = video_resized.h
-        
-        if current_width < target_width:
-            # Centrar el video horizontalmente con márgenes negros
-            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 el video 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_resized = video_original.resize((target_width, target_height))
 
-        # Combinar video con audio
-        video_con_audio = video_final.set_audio(audio_final)
+        video_con_audio = video_resized.set_audio(audio_final)
         
-        # Concatenar intro + video + outro SIN alteraciones
         video_final = concatenate_videoclips(
             [intro, video_con_audio, outro],
-            method="compose",  # Evitar problemas de grid
-            padding=0  # Sin espacio entre clips
+            method="compose",
+            padding=0
         )
         
-        # Renderizar video final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
-                fps=video_original.fps,  # Mantener FPS original
+                fps=video_original.fps,
                 threads=4,
-                ffmpeg_params=["-aspect", "16:9"],  # Forzar relación de aspecto 16:9
+                ffmpeg_params=[
+                    "-aspect", "16:9",
+                    "-vf", "scale=1920:1080"
+                ],
                 verbose=False
             )
             eliminar_archivo_tiempo(tmp.name)
@@ -149,7 +118,6 @@ 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")