Update app.py

app.py

@@ -5,10 +5,7 @@ import os
 import asyncio
 import time
 from threading import Timer
-from moviepy.editor import (
-    VideoFileClip, AudioFileClip, ImageClip,
-    concatenate_videoclips, CompositeVideoClip, CompositeAudioClip
-)
+from moviepy.editor import *
 import edge_tts
 import gradio as gr
 from pydub import AudioSegment
@@ -22,190 +19,161 @@ OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 FX_SOUND = "fxsound.mp3"
 WATERMARK = "watermark.png"
-EJEMPLO_VIDEO = "ejemplo.mp4"  # Video de ejemplo en el root
+EJEMPLO_VIDEO = "ejemplo.mp4"
 
-# Validar existencia de archivos obligatorios
+# Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK, EJEMPLO_VIDEO]:
     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}")
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
-    """Elimina un archivo después de 'delay' segundos (30 minutos por defecto)."""
+    """Elimina archivos después de 30 minutos"""
     def eliminar():
         try:
             if os.path.exists(ruta):
                 os.remove(ruta)
-                logging.info(f"Archivo eliminado por timer: {ruta}")
+                logging.info(f"Archivo eliminado: {ruta}")
         except Exception as e:
             logging.error(f"Error al eliminar {ruta}: {e}")
     Timer(delay, eliminar).start()
 
-def cortar_video(video_path, metodo="inteligente", duracion=10):
-    """Corta el video en clips según el método especificado."""
-    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
-        
-        # Método "inteligente" simplificado (cortes cada 5 segundos)
-        clips = []
-        ultimo_corte = 0
-        for i in range(1, math.ceil(video.duration)):
-            if i % 5 == 0:
-                clips.append(video.subclip(ultimo_corte, i))
-                ultimo_corte = i
-        if ultimo_corte < video.duration:
-            clips.append(video.subclip(ultimo_corte, video.duration))
-        logging.info(f"Video cortado en {len(clips)} clips automáticos.")
-        return clips
-    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):
-    """Genera el TTS y mezcla con la música de fondo."""
+async def procesar_audio(texto, voz, duracion_total, duracion_intro):
+    """Genera TTS y mezcla con música"""
     temp_files = []
     try:
-        logging.info("Generando TTS y mezclando audio...")
+        # Generar TTS
         communicate = edge_tts.Communicate(texto, voz)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
             await communicate.save(tmp.name)
             tts_audio = AudioFileClip(tmp.name)
             temp_files.append(tmp.name)
         
-        # Ajustar duración del TTS
-        if tts_audio.duration > duracion_video_editado:
-            tts_audio = tts_audio.subclip(0, duracion_video_editado)
-        
-        # Preparar música de fondo
+        # Preparar música de fondo en loop
         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)
+        bg_music = bg_music * (duracion_total // len(bg_music) + 1)
+        bg_music = bg_music[:duracion_total * 1000].fade_out(5000)
         
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
             bg_music.export(tmp.name, format="mp3")
-            bg_audio = AudioFileClip(tmp.name).volumex(0.10)
+            bg_audio = AudioFileClip(tmp.name).volumex(0.15)
             temp_files.append(tmp.name)
         
         # Combinar audios
         audio_final = CompositeAudioClip([
             bg_audio,
-            tts_audio.volumex(0.9).set_start(duracion_intro)
+            tts_audio.volumex(0.85).set_start(duracion_intro)
         ])
-        logging.info("Audio procesado correctamente.")
         return audio_final
-    except Exception as e:
-        logging.error(f"Error al procesar audio: {e}")
-        raise
     finally:
-        # Eliminar archivos temporales de audio inmediatamente
         for file in temp_files:
             try:
-                if os.path.exists(file):
-                    os.remove(file)
-                    logging.info(f"Archivo temporal de audio eliminado: {file}")
-            except Exception as e:
-                logging.warning(f"No se pudo eliminar el archivo temporal {file}: {e}")
+                os.remove(file)
+            except: pass
 
 def agregar_transiciones(clips):
-    """Agrega transiciones con watermark y sonido FX entre clips."""
+    """Transiciones suaves cada 40 segundos"""
     try:
-        logging.info("Agregando transiciones...")
-        fx_audio = AudioFileClip(FX_SOUND).set_duration(2.5)
-        transicion = ImageClip(WATERMARK).set_duration(2.5).resize(height=clips[0].h).set_position(("center", 0.1))
+        transicion_fx = AudioFileClip(FX_SOUND).subclip(0, 0.5)
+        watermark = (ImageClip(WATERMARK)
+                    .set_duration(0.5)
+                    .resize(height=50)
+                    .margin(right=10, bottom=10, opacity=0)
+                    .set_pos(("right", "bottom")))
         
-        clips_con_fx = []
+        clips_finales = []
         for i, clip in enumerate(clips):
-            clip_watermarked = CompositeVideoClip([clip, transicion])
-            clips_con_fx.append(clip_watermarked)
-            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)
+            # Añadir watermark al clip principal
+            clip_watermarked = CompositeVideoClip([clip, watermark])
+            
+            # Agregar transición cada 40 segundos
+            if i > 0 and i % 40 == 0:
+                transicion = CompositeVideoClip([watermark.set_duration(0.5)]).set_audio(transicion_fx)
+                clips_finales.append(transicion)
+            
+            clips_finales.append(clip_watermarked)
+        
+        return concatenate_videoclips(clips_finales, method="compose")
     except Exception as e:
-        logging.error(f"Error al agregar transiciones: {e}")
-        raise
+        logging.error(f"Error en transiciones: {e}")
+        return concatenate_videoclips(clips)
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte):
-    """Procesa el video completo con intro, cortes, TTS y outro."""
     try:
-        logging.info("Iniciando procesamiento de video...")
-        # Cortar y editar video
-        clips = cortar_video(video_input, metodo_corte, duracion_corte)
+        # Cargar video original con su audio
+        video_original = VideoFileClip(video_input)
+        audio_original = video_original.audio.volumex(0.7)  # Conservar audio original al 70%
+        
+        # Cortar video según método
+        clips = []
+        if metodo_corte == "manual":
+            for i in range(math.ceil(video_original.duration / duracion_corte)):
+                clips.append(video_original.subclip(i*duracion_corte, (i+1)*duracion_corte))
+        else:
+            # Cortes automáticos cada 40 segundos para transiciones
+            clips = [video_original.subclip(i, i+40) for i in range(0, math.ceil(video_original.duration), 40)]
+        
+        # Procesar transiciones
         video_editado = agregar_transiciones(clips)
         
-        # Cargar intro y outro
+        # Combinar con 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 clips
         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)
+        # Procesar audio completo
+        duracion_total = video_final.duration
+        audio_tts_bg = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, intro.duration)
         
-        # Renderizar video final como archivo temporal accesible para Gradio
+        # Combinar TODOS los audios
+        audio_final = CompositeAudioClip([
+            audio_original.set_duration(video_final.duration),
+            audio_tts_bg
+        ])
+        
+        # Renderizar video final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.set_audio(audio_final).write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
-                temp_audiofile="temp-audio.m4a",
-                remove_temp=True,
-                fps=24
+                fps=24,
+                threads=4
             )
-            output_path = tmp.name
-        
-        # Programar eliminación del video en 30 minutos
-        eliminar_archivo_tiempo(output_path, delay=1800)
-        logging.info(f"Video temporal listo para Gradio: {output_path}")
-        return output_path
+            eliminar_archivo_tiempo(tmp.name)
+            return tmp.name
     except Exception as e:
-        logging.error(f"Error durante el procesamiento: {e}")
+        logging.error(f"Error procesando video: {e}")
         raise
 
-# Interfaz Gradio con ejemplo de uso
+# Interfaz Gradio
 with gr.Blocks() as demo:
-    gr.Markdown("# Video Editor IA")
+    gr.Markdown("# Editor de Video con IA")
     
     with gr.Tab("Principal"):
-        video_input = gr.Video(label="Subir video", value=EJEMPLO_VIDEO)  # Video de ejemplo
+        video_input = gr.Video(label="Subir video", value=EJEMPLO_VIDEO)
         texto_tts = gr.Textbox(
             label="Texto para TTS",
             lines=3,
-            value="hola esto es una prueba suscribete al canal ya empieza el video"  # Texto de ejemplo
+            value="¡Hola! Esto es una prueba. Suscríbete al canal y activa la campanita."
         )
         voz_seleccionada = gr.Dropdown(
-            label="Seleccionar voz",
+            label="Voz",
             choices=["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"],
             value="es-ES-AlvaroNeural"
         )
         procesar_btn = gr.Button("Generar Video")
-        video_output = gr.Video(label="Resultado")
+        video_output = gr.Video(label="Video Procesado")
     
     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)"
+            label="Segundos por corte (manual)"
         )
 
     procesar_btn.click(
@@ -215,5 +183,4 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    logging.info("Iniciando aplicación Gradio...")
     demo.queue().launch()