Update app.py

app.py

@@ -19,13 +19,13 @@ MUSIC_BG = "musicafondo.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
 # CONSTANTES DE LIMITACIONES
-MAX_VIDEO_DURATION = 300  # Máxima duración en segundos (5 minutos)
-MAX_VIDEO_SIZE = 100 * 1024 * 1024  # Tamaño máximo en bytes (100MB)
-MAX_RESOLUTION = (1280, 720)  # Resolución máxima (720p)
+MAX_VIDEO_SIZE = 200 * 1024 * 1024  # Tamaño máximo en bytes (200MB)
+MAX_RESOLUTION = (640, 360)  # Resolución máxima (360p para optimizar)
 
 # Configuración de chunks
 SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
 TRANSITION_DURATION = 1.5  # Duración del efecto slide
+PROCESSING_CHUNK = 120  # Procesar en bloques de 2 minutos para optimizar memoria
 
 # Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
@@ -38,7 +38,7 @@ def mostrar_uso_memoria():
     memoria_uso = proceso.memory_info().rss / 1024 / 1024
     logging.info(f"Uso de memoria: {memoria_uso:.2f} MB")
 
-def eliminar_archivo_tiempo(ruta, delay=1800):
+def eliminar_archivo_tiempo(ruta, delay=3600):
     def eliminar():
         try:
             if os.path.exists(ruta):
@@ -61,11 +61,6 @@ def validar_video(video_path):
         clip = VideoFileClip(video_path)
         duracion = clip.duration
         clip.close()
-        
-        # Comprobar duración
-        if duracion > MAX_VIDEO_DURATION:
-            logging.warning(f"El video excede la duración máxima: {duracion}s > {MAX_VIDEO_DURATION}s")
-            return False
             
         return True
     except Exception as e:
@@ -77,23 +72,15 @@ def convertir_video(video_path):
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_converted:
             output_path = tmp_converted.name
         
-        # Primero convertir a un formato más eficiente y con menor resolución
-        os.system(f'ffmpeg -i "{video_path}" -vf "scale=640:360" -c:v libx264 -crf 28 -preset ultrafast -c:a aac -b:a 96k "{output_path}" -y')
+        # Convertir a un formato más eficiente y con menor resolución para optimizar
+        os.system(f'ffmpeg -i "{video_path}" -vf "scale={MAX_RESOLUTION[0]}:{MAX_RESOLUTION[1]}" -c:v libx264 -crf 28 -preset ultrafast -c:a aac -b:a 96k "{output_path}" -y')
         
-        # Comprobar si ahora cumple las limitaciones
+        # Comprobar si ahora cumple las limitaciones de tamaño
         if not validar_video(output_path):
-            # Si sigue sin cumplir, recortar duración
-            nuevo_clip = VideoFileClip(output_path)
-            duracion_maxima = min(nuevo_clip.duration, MAX_VIDEO_DURATION)
-            nuevo_clip = nuevo_clip.subclip(0, duracion_maxima)
-            
-            temp_recortado = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-            nuevo_clip.write_videofile(temp_recortado, codec="libx264", audio_codec="aac", 
-                                      preset="ultrafast", bitrate="1M")
-            nuevo_clip.close()
-            
+            # Si sigue sin cumplir, aumentar la compresión
+            os.system(f'ffmpeg -i "{output_path}" -vf "scale={MAX_RESOLUTION[0]}:{MAX_RESOLUTION[1]}" -c:v libx264 -crf 32 -preset ultrafast -c:a aac -b:a 64k "{output_path}.tmp" -y')
             os.remove(output_path)
-            return temp_recortado
+            os.rename(f"{output_path}.tmp", output_path)
         
         return output_path
     except Exception as e:
@@ -104,10 +91,10 @@ async def generar_tts(texto, voz, duracion_total):
     try:
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
-        # Limitar el texto a 500 caracteres para procesar más rápido
-        if len(texto) > 500:
-            texto = texto[:500]
-            logging.info("Texto para TTS truncado a 500 caracteres para optimizar rendimiento")
+        # Limitar el texto a 1000 caracteres para procesar más rápido
+        if len(texto) > 1000:
+            texto = texto[:1000]
+            logging.info("Texto para TTS truncado a 1000 caracteres para optimizar rendimiento")
         
         logging.info(f"Generando TTS con voz: {voz}")
         communicate = edge_tts.Communicate(texto, voz)
@@ -137,9 +124,9 @@ def create_slide_transition(clip1, clip2, duration=TRANSITION_DURATION):
     transition = CompositeVideoClip([
         part1.fx(vfx.fadeout, duration),
         part2.fx(vfx.fadein, duration).set_position(
-            lambda t: ('center', 720 - (720 * (t/duration)))
+            lambda t: ('center', MAX_RESOLUTION[1] - (MAX_RESOLUTION[1] * (t/duration)))
         )
-    ], size=(640, 360)).set_duration(duration)  # Reducido a 640x360 para optimizar
+    ], size=MAX_RESOLUTION).set_duration(duration)  # Reducido para optimizar
     return transition
 
 def liberar_memoria(objetos_cerrar=None):
@@ -167,7 +154,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         progress(0, desc="Validando video")
         
         if not validar_video(video_input):
-            progress(0.05, desc="Convirtiendo formato de video")
+            progress(0.05, desc="Optimizando formato de video")
             video_input = convertir_video(video_input)
             temp_files.append(video_input)
             
@@ -175,12 +162,11 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         # Reducir resolución para optimizar procesamiento
         video_original = VideoFileClip(video_input)
         duracion_video = video_original.duration
+        video_original.close()  # Cerrar para liberar memoria
+        
+        # Información importante sobre el video original
+        logging.info(f"Duración total del video: {duracion_video} segundos")
         
-        # Limitar duración si es necesario
-        if duracion_video > MAX_VIDEO_DURATION:
-            duracion_video = MAX_VIDEO_DURATION
-            video_original = video_original.subclip(0, duracion_video)
-            
         if duracion_video <= 0:
             raise ValueError("El video debe tener una duración mayor que cero.")
         
@@ -192,84 +178,116 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         bg_audio, bg_path = crear_musica_fondo(duracion_video)
         temp_files.append(bg_path)
         
-        progress(0.35, desc="Mezclando audio")
-        audio_original = video_original.audio.volumex(0.5) if video_original.audio else None
-        audios = [bg_audio.set_duration(duracion_video)]
-        if audio_original:
-            audios.append(audio_original)
-        audios.append(tts_audio.set_start(0).volumex(0.85))
-        audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
+        # Procesar por bloques para optimizar memoria
+        num_chunks = int(duracion_video // PROCESSING_CHUNK) + (1 if duracion_video % PROCESSING_CHUNK > 0 else 0)
+        logging.info(f"Procesando video en {num_chunks} bloques")
         
-        # Procesar por segmentos para optimizar memoria
-        if duracion_video > SEGMENT_DURATION:
-            progress(0.4, desc="Procesando segmentos de video")
-            clips = []
-            num_segments = int(duracion_video // SEGMENT_DURATION) + (1 if duracion_video % SEGMENT_DURATION > 0 else 0)
+        for chunk_idx in range(num_chunks):
+            chunk_start = chunk_idx * PROCESSING_CHUNK
+            chunk_end = min((chunk_idx + 1) * PROCESSING_CHUNK, duracion_video)
             
-            for i in range(num_segments):
-                progress_val = 0.4 + (0.3 * (i / num_segments))
-                progress(progress_val, desc=f"Procesando segmento {i+1}/{num_segments}")
-                
-                start_time = i * SEGMENT_DURATION
-                end_time = min(start_time + SEGMENT_DURATION, duracion_video)
-                segment = video_original.subclip(start_time, end_time)
-                
-                # Reducir resolución si es necesario
-                if segment.size[0] > MAX_RESOLUTION[0] or segment.size[1] > MAX_RESOLUTION[1]:
-                    segment = segment.resize(height=MAX_RESOLUTION[1])
-                
-                if i == 0:
-                    clips.append(segment)
-                else:
-                    prev_segment = clips[-1]
-                    transition = create_slide_transition(prev_segment, segment)
-                    prev_end = prev_segment.duration - TRANSITION_DURATION
-                    if prev_end > 0:
-                        clips[-1] = prev_segment.subclip(0, prev_end)
-                    clips.append(transition)
-                    clips.append(segment)
+            progress(0.35 + (0.45 * chunk_idx / num_chunks), 
+                    desc=f"Procesando bloque {chunk_idx+1}/{num_chunks} ({chunk_start:.1f}s - {chunk_end:.1f}s)")
+            
+            # Cargar solo la porción del video que necesitamos
+            chunk_video = VideoFileClip(video_input).subclip(chunk_start, chunk_end)
+            
+            # Extraer la porción de audio correspondiente a este bloque
+            chunk_tts = tts_audio.subclip(chunk_start, chunk_end) if chunk_start < tts_audio.duration else None
+            chunk_bg = bg_audio.subclip(chunk_start, chunk_end)
+            
+            # Crear la mezcla de audio para este bloque
+            audio_chunks = [chunk_bg]
+            if chunk_video.audio:
+                audio_chunks.append(chunk_video.audio.volumex(0.5))
+            if chunk_tts:
+                audio_chunks.append(chunk_tts.volumex(0.85))
+            
+            chunk_audio_final = CompositeAudioClip(audio_chunks)
+            chunk_video = chunk_video.set_audio(chunk_audio_final)
+            
+            # Procesar las transiciones dentro de este chunk si es necesario
+            if chunk_end - chunk_start > SEGMENT_DURATION:
+                segments_in_chunk = []
+                segments_count = int((chunk_end - chunk_start) // SEGMENT_DURATION) + \
+                                (1 if (chunk_end - chunk_start) % SEGMENT_DURATION > 0 else 0)
                 
-                # Liberar memoria después de cada 2 segmentos
-                if i % 2 == 1:
-                    liberar_memoria()
+                for i in range(segments_count):
+                    seg_start = i * SEGMENT_DURATION
+                    seg_end = min(seg_start + SEGMENT_DURATION, chunk_end - chunk_start)
+                    segment = chunk_video.subclip(seg_start, seg_end)
                     
-            video_final = concatenate_videoclips(clips, method="compose")
-        else:
-            video_final = video_original.copy()
+                    if i == 0:
+                        segments_in_chunk.append(segment)
+                    else:
+                        prev_segment = segments_in_chunk[-1]
+                        transition = create_slide_transition(prev_segment, segment)
+                        
+                        prev_end = prev_segment.duration - TRANSITION_DURATION
+                        if prev_end > 0:
+                            segments_in_chunk[-1] = prev_segment.subclip(0, prev_end)
+                        
+                        segments_in_chunk.append(transition)
+                        segments_in_chunk.append(segment)
+                
+                chunk_processed = concatenate_videoclips(segments_in_chunk, method="compose")
+            else:
+                chunk_processed = chunk_video
+            
+            # Guardar este chunk procesado como archivo temporal
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f"_chunk{chunk_idx}.mp4") as chunk_file:
+                chunk_path = chunk_file.name
+                chunk_processed.write_videofile(
+                    chunk_path,
+                    codec="libx264", 
+                    audio_codec="aac",
+                    preset="ultrafast",
+                    bitrate="1M",
+                    ffmpeg_params=["-crf", "28"],
+                    verbose=False
+                )
+                segmentos_temp.append(chunk_path)
             
-        # Asignar audio final
-        progress(0.7, desc="Asignando audio")
-        video_final = video_final.set_audio(audio_final)
+            # Liberar memoria
+            chunk_video.close()
+            chunk_processed.close()
+            liberar_memoria()
         
-        # Añadir intro y outro
-        progress(0.75, desc="Añadiendo intro y outro")
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(360, 640))  # Reducido para optimizar
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(360, 640))  # Reducido para optimizar
+        # Liberar memoria antes de procesar intro/outro
+        liberar_memoria([tts_audio, bg_audio])
+        tts_audio = bg_audio = None
         
-        # Crear el video final por partes
+        # Añadir intro y outro
+        progress(0.85, desc="Preparando intro y outro")
+        intro = VideoFileClip(INTRO_VIDEO, target_resolution=MAX_RESOLUTION)
         with tempfile.NamedTemporaryFile(delete=False, suffix="_intro.mp4") as tmp_intro:
-            intro.write_videofile(tmp_intro.name, codec="libx264", audio_codec="aac", 
-                                preset="ultrafast", bitrate="1M", 
-                                ffmpeg_params=["-crf", "30"])
-            segmentos_temp.append(tmp_intro.name)
-            
-        with tempfile.NamedTemporaryFile(delete=False, suffix="_main.mp4") as tmp_main:
-            video_final.write_videofile(tmp_main.name, codec="libx264", audio_codec="aac",
-                                    preset="ultrafast", bitrate="1M",
-                                    ffmpeg_params=["-crf", "30"])
-            segmentos_temp.append(tmp_main.name)
-            
-        with tempfile.NamedTemporaryFile(delete=False, suffix="_outro.mp4") as tmp_outro:
-            outro.write_videofile(tmp_outro.name, codec="libx264", audio_codec="aac",
-                                preset="ultrafast", bitrate="1M",
-                                ffmpeg_params=["-crf", "30"])
-            segmentos_temp.append(tmp_outro.name)
+            intro.write_videofile(
+                tmp_intro.name, 
+                codec="libx264", 
+                audio_codec="aac", 
+                preset="ultrafast", 
+                bitrate="1M",
+                ffmpeg_params=["-crf", "28"],
+                verbose=False
+            )
+            segmentos_temp.insert(0, tmp_intro.name)  # Intro al principio
+        intro.close()
         
-        # Liberar memoria antes de la unión final
-        liberar_memoria([video_original, intro, outro, video_final])
-        video_original = intro = outro = video_final = None
+        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=MAX_RESOLUTION)
+        with tempfile.NamedTemporaryFile(delete=False, suffix="_outro.mp4") as tmp_outro:
+            outro.write_videofile(
+                tmp_outro.name, 
+                codec="libx264", 
+                audio_codec="aac", 
+                preset="ultrafast", 
+                bitrate="1M",
+                ffmpeg_params=["-crf", "28"],
+                verbose=False
+            )
+            segmentos_temp.append(tmp_outro.name)  # Outro al final
+        outro.close()
         
-        # Unir los segmentos con ffmpeg directamente
+        # Unir todos los segmentos con ffmpeg
         progress(0.9, desc="Generando video final")
         with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as concat_file:
             # Escribir archivo de lista para concatenación
@@ -287,7 +305,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
                 if os.path.exists(segment):
                     os.remove(segment)
             
-            eliminar_archivo_tiempo(output_path, 3600)  # Extendido a 1 hora
+            eliminar_archivo_tiempo(output_path, 3600)  # Eliminación después de 1 hora
             progress(1.0, desc="¡Video listo!")
             logging.info(f"Video final guardado: {output_path}")
             mostrar_uso_memoria()
@@ -319,7 +337,7 @@ with gr.Blocks() as demo:
     with gr.Tab("Principal"):
         video_input = gr.Video(label="Subir video")
         texto_tts = gr.Textbox(
-            label="Texto para TTS (máx. 500 caracteres)",
+            label="Texto para TTS (máx. 1000 caracteres)",
             lines=3,
             placeholder="Escribe aquí tu texto..."
         )
@@ -393,15 +411,15 @@ with gr.Blocks() as demo:
 
     gr.Markdown("""
     ### ℹ️ Notas importantes:
-    - **Limitaciones para Hugging Face Spaces:**
-      - Máxima duración de video: 5 minutos
-      - Máximo tamaño de archivo: 100MB
-      - Resolución reducida a 640x360 para procesamiento
-      - Texto TTS limitado a 500 caracteres
+    - **Optimizaciones para Hugging Face Spaces:**
+      - Procesamiento por bloques para videos largos
+      - Máximo tamaño de archivo: 200MB
+      - Resolución reducida a 640x360 para procesamiento más rápido
+      - Texto TTS limitado a 1000 caracteres
     - Las transiciones ocurren cada 30 segundos
     - El video contiene intro y outro predefinidos
     - El archivo generado se elimina después de 1 hora
-    - Para videos más pesados, considera usar este código localmente
+    - Para videos de alta calidad, considera usar este código localmente
     """)
 
 if __name__ == "__main__":