Update app.py

app.py

@@ -24,8 +24,8 @@ for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, GLITCH_SOUND, EJEMPLO_VIDEO]:
         raise FileNotFoundError(f"Falta: {file}")
 
 # Configuración de chunks
-CHUNK_SIZE = 60  # 1 minuto por chunk (evita timeouts)
-MAX_CHUNKS = 50   # Límite máximo de chunks
+CHUNK_SIZE = 60  # 1 minuto por chunk
+MAX_CHUNKS = 50
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
     def eliminar():
@@ -45,7 +45,7 @@ async def procesar_audio(texto, voz, duracion_video, audio_original):
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
 
-        def dividir_texto(texto, max_length=2000):  # Texto más corto por fragmento
+        def dividir_texto(texto, max_length=2000):
             return [texto[i:i + max_length] for i in range(0, len(texto), max_length)]
 
         fragmentos = dividir_texto(texto)
@@ -99,8 +99,8 @@ def aplicar_glitch(video_clip):
         import numpy as np
         frame = frame.copy()
         height, width, _ = frame.shape
-        offset = np.random.randint(3, 8)  # Efecto menos intenso
-        if height > 0:
+        offset = np.random.randint(3, 8)
+        if height > 0 and offset != 0:
             frame[offset:, :] = np.roll(frame[:-offset, :], -offset, axis=0)
         return frame
 
@@ -118,27 +118,31 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
             audio_original
         )
         
-        segment_duration = 15  # Segmentos más cortos
-        overlap = 1
-        total_segments = int((duracion_chunk) // (segment_duration)) + 1
+        segment_duration = 18  # Duración visible del segmento
+        overlap = 2            # Segundos eliminados en cada corte
+        total_segments = int((duracion_chunk - overlap) // (segment_duration - overlap)) + 1
         
         segments = []
         glitch_clips = []
-        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.3)  # Sonido menos intenso
+        glitch_sound = AudioFileClip(GLITCH_SOUND).volumex(0.5)
 
         current_time = 0
         for i in range(total_segments):
-            end_time = current_time + segment_duration + overlap
-            end_time = min(end_time, duracion_chunk)
-            
+            # Calcular tiempo final del segmento
+            end_time = current_time + segment_duration
+            if end_time > duracion_chunk:
+                break  # ← **Corrección clave**
+                
+            # Extraer segmento completo
             full_segment = chunk.subclip(current_time, end_time)
             
-            if i > 0:
-                glitch_part = full_segment.subclip(0, 0.3)  # Glitch de 0.3s
+            # Aplicar glitch solo si hay suficiente duración
+            if i > 0 and full_segment.duration >= 0.5:  # ← **Validación añadida**
+                glitch_part = full_segment.subclip(0, 0.5)
                 glitch_part = aplicar_glitch(glitch_part)
                 processed_segment = concatenate_videoclips([
                     glitch_part,
-                    full_segment.subclip(0.3)
+                    full_segment.subclip(0.5)
                 ], method="compose")
                 
                 glitch_sound_clip = glitch_sound.set_start(start_time + current_time)
@@ -147,7 +151,7 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
                 processed_segment = full_segment
 
             segments.append(processed_segment)
-            current_time += segment_duration
+            current_time += (segment_duration - overlap)  # ← **Ajuste de avance**
 
         video_chunk = concatenate_videoclips(segments, method="compose")
         video_chunk = video_chunk.set_audio(audio_final)
@@ -167,7 +171,7 @@ async def procesar_fragmento(chunk, texto_tts, voz_seleccionada, start_time):
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
         logging.info("Iniciando procesamiento de video")
-        video_original = VideoFileClip(video_input, target_resolution=(720, 1280))  # Resolución reducida
+        video_original = VideoFileClip(video_input, target_resolution=(720, 1280))
         total_duration = video_original.duration
         
         # Dividir en chunks pequeños
@@ -177,7 +181,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
             chunk = video_original.subclip(start, end)
             chunks.append((start, chunk))
         
-        # Procesar chunks secuencialmente
+        # Procesar cada chunk
         processed_clips = []
         for i, (start_time, chunk) in enumerate(chunks):
             logging.info(f"Procesando chunk {i+1}/{len(chunks)}")
@@ -187,25 +191,25 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         # Combinar chunks
         final_video = concatenate_videoclips(processed_clips, method="compose")
         
-        # Agregar intro/outro
+        # Agregar intro y outro
         intro = VideoFileClip(INTRO_VIDEO, target_resolution=(720, 1280))
         outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(720, 1280))
         final_video = concatenate_videoclips([intro, final_video, outro], method="compose")
         
-        # Renderizado ultra optimizado
+        # Renderizado final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             final_video.write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
                 fps=24,
-                threads=2,  # Menos hilos para evitar saturación
-                bitrate="3M",  # Bitrate reducido
+                threads=2,
+                bitrate="3M",
                 ffmpeg_params=[
-                    "-preset", "superfast",
+                    "-preset", "ultrafast",
                     "-crf", "28",
                     "-movflags", "+faststart",
-                    "-vf", "scale=1280:720"  # Resolución 720p para mayor velocidad
+                    "-vf", "scale=1280:720"
                 ],
                 verbose=False
             )
@@ -257,4 +261,4 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.queue().launch()  # Sin parámetros no soportados
+    demo.queue().launch()