Update app.py

app.py

@@ -24,7 +24,6 @@ for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, GLITCH_SOUND, EJEMPLO_VIDEO]:
         raise FileNotFoundError(f"Falta: {file}")
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
-    """Elimina el archivo después de 'delay' segundos (30 minutos por defecto)"""
     def eliminar():
         try:
             if os.path.exists(ruta):
@@ -36,7 +35,7 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
             import gc
             gc.collect()
     from threading import Timer
-    Timer(delay, eliminar).start()  # ← Timer restaurado con 30 minutos de espera
+    Timer(delay, eliminar).start()
 
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
@@ -92,28 +91,6 @@ 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):
-    """Versión corregida del efecto glitch"""
-    def glitch_effect(frame):
-        import numpy as np
-        frame = frame.copy()
-        height, width, _ = frame.shape
-        offset = np.random.randint(-5, 5)
-        
-        if offset == 0 or height <= 0:
-            return frame
-            
-        offset = max(-height + 1, min(offset, height))
-        
-        if offset > 0:
-            frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
-        else:
-            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:
         intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
@@ -134,34 +111,42 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             audio_original
         )
         
-        segment_duration = 20
-        overlap = 2
-        num_segments = int(duracion_video // (segment_duration - overlap)) + 1
+        # Configuración de cortes dinámicos
+        segment_duration = 18  # Duración real visible
+        overlap = 2  # Segundos eliminados en cada corte
+        total_segments = int((duracion_video - overlap) // (segment_duration)) + 1
+        
         segments = []
-        glitch_clips = []
-        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
-
-            segment = video_original.subclip(start_time, end_time)
-
-            if i % 2 == 0 and i > 0 and (end_time - start_time) > 0.5:
-                glitch_segment = aplicar_glitch(segment.subclip(0, 0.3))
-                glitch_sound_clip = glitch_sound.set_start(start_time)
-                glitch_clips.append(glitch_sound_clip)
-                segment = concatenate_videoclips([glitch_segment, segment.subclip(0.3)], method="compose")
-
-            segments.append(segment)
-            start_time += segment_duration - overlap
-
-        video_final = concatenate_videoclips(segments)
-        audio_final = CompositeAudioClip([audio_final] + glitch_clips).set_duration(video_final.duration)
+        
+        for _ 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
+                
+            segments.append(combined)
+            start_time += segment_duration  # Avanzar sin los 2 segundos de overlap
+
+        video_final = concatenate_videoclips(segments, method="compose")
         video_con_audio = video_final.set_audio(audio_final)
         
+        # Recargar intro/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")
@@ -171,7 +156,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
-                fps=24,
+                fps=video_original.fps,
                 threads=4,
                 bitrate="5M",
                 ffmpeg_params=[
@@ -182,7 +167,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                 ],
                 verbose=False
             )
-            eliminar_archivo_tiempo(tmp.name, 1800)  # ← Ahora se eliminan a los 30 minutos
+            eliminar_archivo_tiempo(tmp.name, 1800)
             return tmp.name
             
     except Exception as e: