Update app.py

app.py

@@ -31,9 +31,6 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
                 logging.info(f"Archivo eliminado: {ruta}")
         except Exception as e:
             logging.error(f"Error al eliminar {ruta}: {e}")
-        finally:
-            import gc
-            gc.collect()
     from threading import Timer
     Timer(delay, eliminar).start()
 
@@ -91,13 +88,27 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
             except Exception as e:
                 logging.warning(f"Error limpiando {file}: {e}")
 
+def aplicar_glitch(video_clip):
+    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:
+            frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
+        return frame
+
+    return video_clip.fl_image(glitch_effect)
+
 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))
         audio_original = video_original.audio
         
+        # Liberar recursos
         intro.reader.close()
         outro.reader.close()
         video_original.reader.close()
@@ -112,45 +123,53 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         )
         
         # Configuración de cortes dinámicos
-        segment_duration = 18  # Duración real visible
+        segment_duration = 18  # Duración visible del segmento
         overlap = 2  # Segundos eliminados en cada corte
-        total_segments = int((duracion_video - overlap) // (segment_duration)) + 1
+        total_segments = int((duracion_video) // (segment_duration)) + 1
         
         segments = []
+        glitch_clips = []
+        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
+
         start_time = 0
-        
-        for _ in range(total_segments):
+        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)
             
-            # Cortar los primeros 0.5 segundos para transición
-            if start_time > 0:
-                transition = full_segment.subclip(0, 0.5).speedx(1.5)  # Efecto rápido
-                main_segment = full_segment.subclip(0.5)
-            else:
-                transition = None
-                main_segment = full_segment
-            
-            # Combinar transición y segmento principal
-            if transition:
-                combined = concatenate_videoclips([transition, main_segment], method="compose")
-            else:
-                combined = main_segment
+            # Aplicar transición/glitch
+            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")
                 
-            segments.append(combined)
+                # Agregar sonido de glitch
+                glitch_sound_clip = glitch_sound.set_start(start_time)
+                glitch_clips.append(glitch_sound_clip)
+            else:
+                processed_segment = full_segment
+
+            segments.append(processed_segment)
             start_time += segment_duration  # Avanzar sin los 2 segundos de overlap
 
+        # Combinar todos los segmentos
         video_final = concatenate_videoclips(segments, method="compose")
         video_con_audio = video_final.set_audio(audio_final)
         
-        # Recargar intro/outro
+        # 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")
         
+        # Renderizado final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.write_videofile(
                 tmp.name,