Update app.py

app.py

@@ -59,6 +59,8 @@ def validar_video(video_path):
         # Validar que es un video
         clip = VideoFileClip(video_path)
         duracion = clip.duration
+        fps = clip.fps
+        logging.info(f"Video validado: duración={duracion}s, fps={fps}")
         clip.close()
             
         return True
@@ -66,18 +68,37 @@ def validar_video(video_path):
         logging.error(f"El video no es válido: {e}")
         return False
 
+def obtener_info_video(video_path):
+    """Obtiene información básica del video como FPS, duración y tamaño"""
+    try:
+        clip = VideoFileClip(video_path)
+        info = {
+            "fps": clip.fps,
+            "duration": clip.duration,
+            "size": clip.size
+        }
+        clip.close()
+        return info
+    except Exception as e:
+        logging.error(f"Error al obtener info del video: {e}")
+        return {"fps": 30, "duration": 0, "size": (640, 360)}  # valores por defecto
+
 def convertir_video(video_path):
     try:
+        # Obtener FPS del video original para mantenerlo
+        info = obtener_info_video(video_path)
+        fps = info["fps"] if info["fps"] else 30  # Valor por defecto si no se puede determinar
+        
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_converted:
             output_path = tmp_converted.name
         
-        # 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')
+        # Convertir a un formato más eficiente pero manteniendo la resolución original Y el framerate
+        os.system(f'ffmpeg -i "{video_path}" -c:v libx264 -crf 28 -preset ultrafast -r {fps} -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 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.system(f'ffmpeg -i "{output_path}" -c:v libx264 -crf 32 -preset ultrafast -r {fps} -c:a aac -b:a 64k "{output_path}.tmp" -y')
             os.remove(output_path)
             os.rename(f"{output_path}.tmp", output_path)
         
@@ -155,6 +176,11 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         logging.info("Iniciando procesamiento")
         progress(0, desc="Validando video")
         
+        # Obtener información del video original
+        original_info = obtener_info_video(video_input)
+        original_fps = original_info["fps"]
+        logging.info(f"Video original - FPS: {original_fps}, Tamaño: {original_info['size']}")
+        
         if not validar_video(video_input):
             progress(0.05, desc="Optimizando formato de video")
             video_input = convertir_video(video_input)
@@ -197,6 +223,11 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
             # Cargar solo la porción del video que necesitamos
             chunk_video = VideoFileClip(video_input).subclip(chunk_start, chunk_end)
             
+            # Aseguramos que el framerate se mantiene en todos los clips
+            if original_fps and chunk_video.fps != original_fps:
+                logging.info(f"Ajustando FPS del chunk {chunk_idx+1} a {original_fps}")
+                chunk_video = chunk_video.set_fps(original_fps)
+            
             # Extraer la porción de audio correspondiente a este bloque
             tts_chunk_end = min(chunk_end, tts_audio.duration)
             chunk_tts = None
@@ -252,6 +283,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
                     audio_codec="aac",
                     preset="ultrafast",
                     bitrate="1M",
+                    fps=original_fps,  # Asegurar que se mantiene el FPS original
                     ffmpeg_params=["-crf", "28"],
                     verbose=False
                 )
@@ -268,13 +300,20 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         
         # Añadir intro y outro - conservar resolución original para consistencia
         progress(0.85, desc="Preparando intro y outro")
+        
+        # Procesamiento del intro
         intro = VideoFileClip(INTRO_VIDEO)
+        # Asegurar que se utiliza el mismo FPS que el video original
+        if original_fps and intro.fps != original_fps:
+            intro = intro.set_fps(original_fps)
+            
         with tempfile.NamedTemporaryFile(delete=False, suffix="_intro.mp4") as tmp_intro:
             intro.write_videofile(
                 tmp_intro.name, 
                 codec="libx264", 
                 audio_codec="aac", 
-                preset="ultrafast", 
+                preset="ultrafast",
+                fps=original_fps,  # Usar FPS original
                 bitrate="1M",
                 ffmpeg_params=["-crf", "28"],
                 verbose=False
@@ -282,13 +321,19 @@ 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()
         
+        # Procesamiento del outro
         outro = VideoFileClip(OUTRO_VIDEO)
+        # Asegurar que se utiliza el mismo FPS que el video original
+        if original_fps and outro.fps != original_fps:
+            outro = outro.set_fps(original_fps)
+            
         with tempfile.NamedTemporaryFile(delete=False, suffix="_outro.mp4") as tmp_outro:
             outro.write_videofile(
                 tmp_outro.name, 
                 codec="libx264", 
                 audio_codec="aac", 
                 preset="ultrafast", 
+                fps=original_fps,  # Usar FPS original
                 bitrate="1M",
                 ffmpeg_params=["-crf", "28"],
                 verbose=False
@@ -298,15 +343,21 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
         
         # Unir todos los segmentos con ffmpeg
         progress(0.9, desc="Generando video final")
+        
+        # Crear un archivo de metadatos para ffmpeg
         with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as concat_file:
             # Escribir archivo de lista para concatenación
             for segment in segmentos_temp:
                 concat_file.write(f"file '{segment}'\n".encode())
             concat_path = concat_file.name
-            
+        
+        # Usar FFmpeg para concatenar todos los segmentos
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_final:
             output_path = tmp_final.name
-            os.system(f'ffmpeg -f concat -safe 0 -i "{concat_path}" -c copy "{output_path}" -y')
+            # Usar el parámetro -vsync para asegurar que se mantiene la sincronización de video
+            cmd = f'ffmpeg -f concat -safe 0 -i "{concat_path}" -vsync cfr -c copy "{output_path}" -y'
+            logging.info(f"Ejecutando comando FFmpeg: {cmd}")
+            os.system(cmd)
             
             # Limpiar archivos temporales
             os.remove(concat_path)
@@ -314,6 +365,13 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.P
                 if os.path.exists(segment):
                     os.remove(segment)
             
+            # Verificar que el video final tiene la duración esperada
+            try:
+                final_info = obtener_info_video(output_path)
+                logging.info(f"Video final - Duración: {final_info['duration']}s, FPS: {final_info['fps']}")
+            except Exception as e:
+                logging.error(f"No se pudo verificar el video final: {e}")
+            
             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}")
@@ -424,6 +482,7 @@ with gr.Blocks() as demo:
       - Procesamiento por bloques para videos largos
       - Máximo tamaño de archivo: 200MB
       - Mantiene la resolución original del video
+      - Mantiene la velocidad original del video (FPS)
       - Texto TTS limitado a 1000 caracteres
     - Las transiciones ocurren cada 30 segundos
     - El video contiene intro y outro predefinidos