Update app.py

app.py

@@ -18,6 +18,9 @@ OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
+# CONSTANTES DE LIMITACIONES
+MAX_VIDEO_SIZE = 200 * 1024 * 1024  # Tamaño máximo en bytes (200MB)
+
 # Configuración de chunks
 SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
 TRANSITION_DURATION = 1.5  # Duración del efecto slide
@@ -68,13 +71,13 @@ def convertir_video(video_path):
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_converted:
             output_path = tmp_converted.name
         
-        # 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')
+        # Convertir a un formato más eficiente pero manteniendo la resolución original
+        os.system(f'ffmpeg -i "{video_path}" -c:v libx264 -crf 28 -preset ultrafast -c:a aac -b:a 96k "{output_path}" -y')
         
         # Comprobar si ahora cumple las limitaciones de tamaño
         if not validar_video(output_path):
-            # 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')
+            # Si sigue sin cumplir, aumentar la compresión pero sin cambiar la resolución
+            os.system(f'ffmpeg -i "{output_path}" -c:v libx264 -crf 32 -preset ultrafast -c:a aac -b:a 64k "{output_path}.tmp" -y')
             os.remove(output_path)
             os.rename(f"{output_path}.tmp", output_path)
         
@@ -115,14 +118,17 @@ def crear_musica_fondo(duracion_total):
         return AudioFileClip(tmp_bg.name).volumex(0.15), tmp_bg.name
 
 def create_slide_transition(clip1, clip2, duration=TRANSITION_DURATION):
+    # Obtener dimensiones de los clips
+    width, height = clip1.size
+    
     part1 = clip1.subclip(clip1.duration - duration)
     part2 = clip2.subclip(0, duration)
     transition = CompositeVideoClip([
         part1.fx(vfx.fadeout, duration),
         part2.fx(vfx.fadein, duration).set_position(
-            lambda t: ('center', MAX_RESOLUTION[1] - (MAX_RESOLUTION[1] * (t/duration)))
+            lambda t: ('center', height - (height * (t/duration)))
         )
-    ], size=MAX_RESOLUTION).set_duration(duration)  # Reducido para optimizar
+    ], size=(width, height)).set_duration(duration)
     return transition
 
 def liberar_memoria(objetos_cerrar=None):
@@ -155,13 +161,16 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
             temp_files.append(video_input)
             
         progress(0.1, desc="Preparando video")
-        # Reducir resolución para optimizar procesamiento
+        # Cargamos el video original pero respetamos su resolución
         video_original = VideoFileClip(video_input)
         duracion_video = video_original.duration
+        # Guardamos las dimensiones originales
+        original_size = video_original.size
         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")
+        logging.info(f"Resolución original: {original_size[0]}x{original_size[1]}")
         
         if duracion_video <= 0:
             raise ValueError("El video debe tener una duración mayor que cero.")
@@ -189,7 +198,6 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
             chunk_video = VideoFileClip(video_input).subclip(chunk_start, chunk_end)
             
             # Extraer la porción de audio correspondiente a este bloque
-            # FIX: Corrección para evitar acceder a tiempo más allá de la duración del audio TTS
             tts_chunk_end = min(chunk_end, tts_audio.duration)
             chunk_tts = None
             if chunk_start < tts_audio.duration:
@@ -258,9 +266,9 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         liberar_memoria([tts_audio, bg_audio])
         tts_audio = bg_audio = None
         
-        # Añadir intro y outro
+        # Añadir intro y outro - conservar resolución original para consistencia
         progress(0.85, desc="Preparando intro y outro")
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=MAX_RESOLUTION)
+        intro = VideoFileClip(INTRO_VIDEO)
         with tempfile.NamedTemporaryFile(delete=False, suffix="_intro.mp4") as tmp_intro:
             intro.write_videofile(
                 tmp_intro.name, 
@@ -274,7 +282,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
             segmentos_temp.insert(0, tmp_intro.name)  # Intro al principio
         intro.close()
         
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=MAX_RESOLUTION)
+        outro = VideoFileClip(OUTRO_VIDEO)
         with tempfile.NamedTemporaryFile(delete=False, suffix="_outro.mp4") as tmp_outro:
             outro.write_videofile(
                 tmp_outro.name, 
@@ -415,7 +423,7 @@ with gr.Blocks() as demo:
     - **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
+      - Mantiene la resolución original del video
       - Texto TTS limitado a 1000 caracteres
     - Las transiciones ocurren cada 30 segundos
     - El video contiene intro y outro predefinidos