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"  # Efecto de sonido para glitches
+GLITCH_SOUND = "fxsound.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
 # Validar existencia de archivos
@@ -37,11 +37,10 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
     try:
-        # Validar texto
+        logging.info("Iniciando procesamiento de audio")
         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)]
 
@@ -49,29 +48,20 @@ 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:
-                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.")
-                
+                await communicate.save(tmp_tts.name)
                 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)
+        bg_music = AudioSegment.from_mp3(MUSIC_BG)
         repeticiones = needed_ms // len(bg_music) + 1
         bg_music = bg_music * repeticiones
         bg_music = bg_music[:needed_ms].fade_out(1000)
@@ -81,17 +71,17 @@ 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_final.volumex(0.85).set_start(0))  # TTS al 85%
+            audios.append(audio_original.volumex(0.7))
+        audios.append(tts_audio_final.volumex(0.85).set_start(0))
         
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
+        logging.info("Audio procesado exitosamente")
         return audio_final
     
     except Exception as e:
-        logging.error(f" fallo en audio: {str(e)}")
+        logging.error(f"Fallo en procesamiento de audio: {str(e)}")
         raise
     finally:
         for file in temp_files:
@@ -101,16 +91,12 @@ 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()
         height, width, _ = frame.shape
-        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:
+        offset = np.random.randint(5, 15)
+        if height > 0:
             frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
         return frame
 
@@ -118,16 +104,19 @@ def aplicar_glitch(video_clip):
 
 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)
+        logging.info("Iniciando procesamiento de video")
+        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))
         audio_original = video_original.audio
         
-        # Duración del video editado (sin intro/outro)
+        intro.reader.close()
+        outro.reader.close()
+        video_original.reader.close()
+
         duracion_video = video_original.duration
+        logging.info(f"Duración del video original: {duracion_video}s")
         
-        # Procesar audio
         audio_final = await procesar_audio(
             texto_tts,
             voz_seleccionada,
@@ -135,85 +124,74 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
-        # 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
+        segment_duration = 18
+        overlap = 2
+        total_segments = int((duracion_video) // (segment_duration)) + 1
+        
         segments = []
         glitch_clips = []
-        glitch_sound = AudioFileClip(GLITCH_SOUND)
+        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
 
         start_time = 0
-        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)
+        for i in range(total_segments):
+            end_time = start_time + segment_duration + overlap
+            end_time = min(end_time, duracion_video)
+            
+            full_segment = video_original.subclip(start_time, end_time)
+            
             if i > 0:
-                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_part = full_segment.subclip(0, 0.5)
+                glitch_part = aplicar_glitch(glitch_part)
+                processed_segment = concatenate_videoclips([
+                    glitch_part,
+                    full_segment.subclip(0.5)
+                ], method="compose")
+                
+                glitch_sound_clip = glitch_sound.set_start(start_time)
                 glitch_clips.append(glitch_sound_clip)
-                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
+            else:
+                processed_segment = full_segment
 
-        # Combinar los segmentos procesados
-        video_final = concatenate_videoclips(segments)
+            segments.append(processed_segment)
+            start_time += segment_duration
 
-        # Combinar audio con efectos de glitch
-        audio_final = CompositeAudioClip([audio_final] + glitch_clips).set_duration(video_final.duration)
-
-        # Combinar video con audio
+        video_final = concatenate_videoclips(segments, method="compose")
         video_con_audio = video_final.set_audio(audio_final)
         
-        # 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
-        )
+        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")
         
-        # 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,  # Mantener FPS original
+                fps=video_original.fps,
                 threads=4,
+                bitrate="5M",
                 ffmpeg_params=[
-                    "-aspect", "16:9",  # Forzar relación de aspecto
-                    "-vf", "scale=1920:1080"  # Forzar escalado explícito
+                    "-preset", "ultrafast",
+                    "-crf", "23",
+                    "-movflags", "+faststart",
+                    "-vf", "scale=1920:1080"
                 ],
                 verbose=False
             )
-            # eliminar_archivo_tiempo(tmp.name)  # Comentar o eliminar esta línea
+            eliminar_archivo_tiempo(tmp.name, 1800)
+            logging.info(f"Video procesado guardado en: {tmp.name}")
             return tmp.name
+            
     except Exception as e:
-        logging.error(f" fallo general: {str(e)}")
+        logging.error(f"Fallo general en procesamiento: {str(e)}")
         raise
+    finally:
+        try:
+            intro.close()
+            outro.close()
+            video_original.close()
+        except:
+            pass
 
 # Interfaz Gradio
 with gr.Blocks() as demo: