Update app.py

app.py

@@ -14,10 +14,11 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
+FX_GLITCH = "glitch.mp4"  # Video con efecto glitch de 0.5 segundos
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
 # Validar existencia de archivos
-for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
+for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_GLITCH, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
@@ -33,45 +34,37 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
     from threading import Timer
     Timer(delay, eliminar).start()
 
-def validar_texto(texto):
-    texto_limpio = texto.strip()
-    if len(texto_limpio) < 3:
-        raise gr.Error("⚠️ El texto debe tener al menos 3 caracteres")
-    if any(c in texto_limpio for c in ["|", "\n", "\r"]):
-        raise gr.Error("⚠️ Caracteres no permitidos detectados")
-
-async def procesar_audio(texto, voz, duracion_video_editado, duracion_intro):
+async def procesar_audio(texto, voz, duracion_video):
     temp_files = []
     try:
-        validar_texto(texto)
+        # 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 tiempo disponible después de la intro
-            if tts_audio.duration > duracion_video_editado:
-                tts_audio = tts_audio.subclip(0, duracion_video_editado)
+            # 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_editado * 1000)
+        needed_ms = int(duracion_video * 1000)
         repeticiones = needed_ms // len(bg_music) + 1
         bg_music = bg_music * repeticiones
-        bg_music = bg_music[:needed_ms].fade_out(5000)
+        bg_music = bg_music[:needed_ms].fade_out(1000)
         
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_bg:
             bg_music.export(tmp_bg.name, format="mp3")
-            bg_audio = AudioFileClip(tmp_bg.name).volumex(0.15)
+            bg_audio = AudioFileClip(tmp_bg.name).volumex(0.2)
             temp_files.append(tmp_bg.name)
 
         # Combinar audios
         audio_final = CompositeAudioClip([
-            bg_audio.set_duration(duracion_video_editado),
-            tts_audio.volumex(0.85).set_start(0)  # Comienza al inicio del video editado
-        ]).set_duration(duracion_video_editado)
+            bg_audio.set_duration(duracion_video),
+            tts_audio.volumex(0.8).set_start(0)
+        ]).set_duration(duracion_video)
         
         return audio_final
     
@@ -85,6 +78,18 @@ async def procesar_audio(texto, voz, duracion_video_editado, duracion_intro):
             except Exception as e:
                 logging.warning(f"Error limpiando {file}: {e}")
 
+def agregar_glitch(video, intervalo=40):
+    """Agrega glitch cada X segundos sin alterar el video"""
+    duracion = video.duration
+    glitch = VideoFileClip(FX_GLITCH).set_duration(0.5)
+    
+    # Crear clips de glitch en los intervalos
+    glitches = []
+    for t in range(intervalo, math.ceil(duracion), intervalo):
+        glitches.append(glitch.set_start(t).set_pos("center"))
+    
+    return CompositeVideoClip([video] + glitches)
+
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
         # Cargar componentes
@@ -92,25 +97,19 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         outro = VideoFileClip(OUTRO_VIDEO)
         video_original = VideoFileClip(video_input)
         
-        # Duraciones
-        duracion_intro = intro.duration
-        duracion_video_editado = video_original.duration
+        # Duración total del video editado
+        duracion_video = video_original.duration
         
         # Procesar audio
-        audio_final = await procesar_audio(
-            texto_tts,
-            voz_seleccionada,
-            duracion_video_editado,
-            duracion_intro
-        )
+        audio_final = await procesar_audio(texto_tts, voz_seleccionada, duracion_video)
         
-        # Combinar video original con audio
-        video_con_audio = video_original.set_audio(audio_final)
+        # Agregar glitch al video original
+        video_con_glitch = agregar_glitch(video_original, intervalo=40)
         
-        # Concatenar intro + video + outro
+        # Combinar con intro/outro
         video_final = concatenate_videoclips(
-            [intro, video_con_audio, outro],
-            method="chain"  # Evita el efecto grid
+            [intro, video_con_glitch, outro],
+            method="chain"
         )
         
         # Renderizar video final