Update app.py

app.py

@@ -14,7 +14,7 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
-GLITCH_SOUND = "fxsound.mp3"
+GLITCH_SOUND = "fxsound.mp3"  # Efecto de sonido para glitches
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
 # Validar existencia de archivos
@@ -37,9 +37,11 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
     try:
+        # 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)]
 
@@ -47,20 +49,29 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
         audios_tts = []
 
         for fragmento in fragmentos:
+            # Generar TTS
             communicate = edge_tts.Communicate(fragmento, voz)
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
-                await communicate.save(tmp_tts.name)
+                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)
 
-        needed_ms = int(duracion_video * 1000)
+        # 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
         bg_music = bg_music * repeticiones
         bg_music = bg_music[:needed_ms].fade_out(1000)
@@ -70,10 +81,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_final.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
@@ -89,12 +101,16 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
                 logging.warning(f"Error limpiando {file}: {e}")
 
 def aplicar_glitch(video_clip):
+    """Aplica un efecto de glitch al video."""
     def glitch_effect(frame):
         import numpy as np
-        frame = frame.copy()  # Corrección clave para evitar errores
         height, width, _ = frame.shape
-        offset = np.random.randint(5, 15)
-        if height > 0:
+        offset = np.random.randint(-10, 10)
+        if offset > 0:
+            offset = min(offset, height)
+        if offset < 0:
+            offset = max(offset, -height + 1)
+        if offset!= 0 and height > 0:
             frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
         return frame
 
@@ -102,19 +118,16 @@ def aplicar_glitch(video_clip):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
-        # Carga optimizada
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(1080, 1920))
-        video_original = VideoFileClip(video_input, target_resolution=(1080, 1920))
+        # Cargar componentes
+        intro = VideoFileClip(INTRO_VIDEO)
+        outro = VideoFileClip(OUTRO_VIDEO)
+        video_original = VideoFileClip(video_input)
         audio_original = video_original.audio
         
-        # Liberar recursos
-        intro.reader.close()
-        outro.reader.close()
-        video_original.reader.close()
-
+        # Duración del video editado (sin intro/outro)
         duracion_video = video_original.duration
         
+        # Procesar audio
         audio_final = await procesar_audio(
             texto_tts,
             voz_seleccionada,
@@ -122,83 +135,85 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
-        # Configuración de cortes dinámicos
-        segment_duration = 18  # Duración visible del segmento
-        overlap = 2  # Segundos eliminados en cada corte
-        total_segments = int((duracion_video) // (segment_duration)) + 1
-        
+        # Redimensionar todos los clips a 1920x1080
+        target_width = 1920
+        target_height = 1080
+
+        # Redimensionar intro
+        intro_resized = intro.resize((target_width, target_height))
+
+        # Redimensionar outro
+        outro_resized = outro.resize((target_width, target_height))
+
+        # Redimensionar video principal
+        video_resized = video_original.resize((target_width, target_height))
+
+        # Dividir el video en segmentos de 20 segundos y eliminar 2 segundos en cada corte
+        segment_duration = 20
+        overlap = 2  # Segundos a eliminar en cada corte
+        num_segments = int(duracion_video // (segment_duration - overlap)) + 1
         segments = []
         glitch_clips = []
-        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
+        glitch_sound = AudioFileClip(GLITCH_SOUND)
 
         start_time = 0
-        for i in range(total_segments):
-            end_time = start_time + segment_duration + overlap
-            end_time = min(end_time, duracion_video)
-            
-            # Extraer segmento completo
-            full_segment = video_original.subclip(start_time, end_time)
-            
-            # Aplicar transición/glitch
+        for i in range(num_segments):
+            end_time = min(start_time + segment_duration, duracion_video)
+            if start_time >= duracion_video:
+                break
+
+            # Extraer el segmento de video y audio
+            segment = video_resized.subclip(start_time, end_time)
+            segment_audio = audio_original.subclip(start_time, end_time) # cortar el audio con el video
+            segment = segment.set_audio(segment_audio) # asignando el audio cortado al video
+
+            # Aplicar glitch al inicio del segmento (excepto el primero)
             if i > 0:
-                # Tomar 0.5 segundos para glitch
-                glitch_part = full_segment.subclip(0, 0.5)
-                glitch_part = aplicar_glitch(glitch_part)
-                
-                # Combinar con el resto del segmento
-                processed_segment = concatenate_videoclips([
-                    glitch_part,
-                    full_segment.subclip(0.5)
-                ], method="compose")
-                
-                # Agregar sonido de glitch
-                glitch_sound_clip = glitch_sound.set_start(start_time)
+                glitch_segment = aplicar_glitch(segment.subclip(0, 0.5))  # Glitch de 0.5 segundos
+                glitch_sound_clip = glitch_sound.set_start(start_time).volumex(0.5)
                 glitch_clips.append(glitch_sound_clip)
-            else:
-                processed_segment = full_segment
+                segment = concatenate_videoclips([glitch_segment, segment.subclip(0.5)], method="compose")
+
+            segments.append(segment)
+
+            # Avanzar al siguiente segmento, eliminando 2 segundos
+            start_time += segment_duration - overlap
 
-            segments.append(processed_segment)
-            start_time += segment_duration  # Avanzar sin los 2 segundos de overlap
+        # Combinar los segmentos procesados
+        video_final = concatenate_videoclips(segments)
 
-        # Combinar todos los segmentos
-        video_final = concatenate_videoclips(segments, method="compose")
+        # Combinar audio con efectos de glitch
+        audio_final = CompositeAudioClip([audio_final] + glitch_clips).set_duration(video_final.duration)
+
+        # Combinar video con audio
         video_con_audio = video_final.set_audio(audio_final)
         
-        # Agregar intro y outro
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(1080, 1920))
-        video_final = concatenate_videoclips([intro, video_con_audio, outro], method="compose")
+        # Concatenar intro + video + outro SIN alteraciones
+        video_final = concatenate_videoclips(
+            [intro_resized, video_con_audio, outro_resized],
+            method="compose",  # Evitar problemas de grid
+            padding=0  # Sin espacio entre clips
+        )
         
-        # Renderizado final
+        # 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,
-                bitrate="5M",
                 ffmpeg_params=[
-                    "-preset", "ultrafast",
-                    "-crf", "23",
-                    "-movflags", "+faststart",
-                    "-vf", "scale=1920:1080"
+                    "-aspect", "16:9",  # Forzar relación de aspecto
+                    "-vf", "scale=1920:1080"  # Forzar escalado explícito
                 ],
                 verbose=False
             )
-            eliminar_archivo_tiempo(tmp.name, 1800)
+            eliminar_archivo_tiempo(tmp.name)
             return tmp.name
-            
     except Exception as e:
         logging.error(f" fallo general: {str(e)}")
         raise
-    finally:
-        try:
-            intro.close()
-            outro.close()
-            video_original.close()
-        except:
-            pass
 
 # Interfaz Gradio
 with gr.Blocks() as demo: