Update app.py

app.py

@@ -151,33 +151,51 @@ class WatermarkRemover:
             
             cap = cv2.VideoCapture(video_path)
             if not cap.isOpened():
-                return None, "Error: No se pudo abrir el video"
+                return None, "❌ Error: No se pudo abrir el video"
             
             # Propiedades del video
             fps = int(cap.get(cv2.CAP_PROP_FPS))
+            if fps == 0:
+                fps = 30  # fallback
+            
             width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
             height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
             
+            # Limitar tamaño para evitar timeouts en HuggingFace
+            max_resolution = 1280
+            scale = 1.0
+            if width > max_resolution or height > max_resolution:
+                scale = max_resolution / max(width, height)
+                width = int(width * scale)
+                height = int(height * scale)
+            
             progress(0.05, desc="Analizando marca de agua...")
             
-            # Leer muestra de frames para detectar marca de agua
+            # Leer muestra reducida de frames
             sample_frames = []
-            sample_size = min(30, total_frames)
+            sample_size = min(20, total_frames)  # Reducido para más velocidad
+            
             for i in range(sample_size):
                 frame_idx = int(i * total_frames / sample_size)
                 cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
                 ret, frame = cap.read()
                 if ret:
+                    if scale != 1.0:
+                        frame = cv2.resize(frame, (width, height))
                     sample_frames.append(frame)
             
+            if len(sample_frames) == 0:
+                cap.release()
+                return None, "❌ No se pudieron leer frames del video"
+            
             # Detectar máscara base de marca de agua
             base_watermark_mask = self.detect_moving_watermark(sample_frames)
             
-            # Encontrar puntos característicos en la marca de agua para tracking
+            # Encontrar puntos característicos
             mask_points = cv2.goodFeaturesToTrack(
                 base_watermark_mask,
-                maxCorners=50,
+                maxCorners=30,  # Reducido para rendimiento
                 qualityLevel=0.01,
                 minDistance=10
             )
@@ -191,22 +209,31 @@ class WatermarkRemover:
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             output_path = self.temp_dir / f"cleaned_{timestamp}.mp4"
             
-            # Usar x264 para mejor compresión
+            # Usar MP4V codec (más compatible)
             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
             out = cv2.VideoWriter(str(output_path), fourcc, fps, (width, height))
             
+            if not out.isOpened():
+                cap.release()
+                return None, "❌ Error al crear archivo de salida"
+            
             prev_gray = None
             tracked_points = mask_points
             frame_count = 0
+            update_interval = max(1, total_frames // 50)  # Actualizar progreso cada 2%
             
             while True:
                 ret, frame = cap.read()
                 if not ret:
                     break
                 
+                # Redimensionar si es necesario
+                if scale != 1.0:
+                    frame = cv2.resize(frame, (width, height))
+                
                 curr_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                 
-                # Actualizar tracking de la marca de agua
+                # Actualizar tracking
                 if prev_gray is not None and tracked_points is not None:
                     tracked_points = self.track_watermark_position(
                         prev_gray, curr_gray, tracked_points
@@ -226,45 +253,27 @@ class WatermarkRemover:
                 prev_gray = curr_gray
                 frame_count += 1
                 
-                # Re-detectar puntos cada 30 frames para mantener tracking
-                if frame_count % 30 == 0:
-                    tracked_points = cv2.goodFeaturesToTrack(
-                        base_watermark_mask,
-                        maxCorners=50,
-                        qualityLevel=0.01,
-                        minDistance=10
-                    )
+                # Re-detectar puntos cada 30 frames
+                if frame_count % 30 == 0 and mask_points is not None:
+                    tracked_points = mask_points.copy()
                 
-                if frame_count % 10 == 0:
+                # Actualizar progreso menos frecuentemente
+                if frame_count % update_interval == 0:
                     progress_val = 0.1 + (0.85 * frame_count / total_frames)
-                    progress(progress_val, desc=f"Frame {frame_count}/{total_frames}")
+                    progress(progress_val, desc=f"Procesando: {frame_count}/{total_frames}")
             
             cap.release()
             out.release()
             
-            progress(0.95, desc="Optimizando video...")
-            
-            # Recodificar con ffmpeg si está disponible
-            final_output = self.temp_dir / f"final_{timestamp}.mp4"
-            try:
-                subprocess.run([
-                    'ffmpeg', '-i', str(output_path),
-                    '-c:v', 'libx264', '-crf', '23',
-                    '-preset', 'medium', '-c:a', 'copy',
-                    '-y', str(final_output)
-                ], check=True, capture_output=True, timeout=300)
-                
-                output_path.unlink()  # Eliminar temporal
-                output_path = final_output
-            except:
-                pass  # Si ffmpeg falla, usar el video original
-            
             progress(1.0, desc="¡Completado!")
             
-            return str(output_path), f"✅ Video procesado: {frame_count} frames\n🎯 Marca de agua eliminada"
+            return str(output_path), f"✅ Video procesado: {frame_count} frames\n🎯 Resolución: {width}x{height}\n⏱️ FPS: {fps}"
         
         except Exception as e:
-            return None, f"❌ Error: {str(e)}"
+            import traceback
+            error_msg = f"❌ Error: {str(e)}\n{traceback.format_exc()}"
+            print(error_msg)
+            return None, error_msg
 
 # Crear instancia del removedor
 remover = WatermarkRemover()
@@ -290,12 +299,16 @@ with gr.Blocks(title="Eliminador de Marcas de Agua - REAL", theme=gr.themes.Soft
     - 🧹 Limpieza automática de archivos (cada 2 horas)
     
     ---
+    ⚠️ **Límites en HuggingFace Spaces:** Videos > 1280p se redimensionan automáticamente
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 📥 Entrada")
-            video_input = gr.Video(label="Video con Marca de Agua")
+            video_input = gr.Video(
+                label="Video con Marca de Agua",
+                format="mp4"
+            )
             
             sensitivity = gr.Slider(
                 minimum=10,
@@ -310,9 +323,10 @@ with gr.Blocks(title="Eliminador de Marcas de Agua - REAL", theme=gr.themes.Soft
             
             gr.Markdown("""
             ### 💡 Tips:
-            - Sube videos claros
-            - Si no detecta la marca, aumenta sensibilidad
-            - El proceso toma tiempo según duración del video
+            - Videos cortos (< 3 min) procesan más rápido
+            - Formatos: MP4, AVI, MOV, MKV
+            - Si falla la carga, comprime el video primero
+            - Aumenta sensibilidad si no detecta la marca
             """)
         
         with gr.Column(scale=1):
@@ -342,4 +356,7 @@ with gr.Blocks(title="Eliminador de Marcas de Agua - REAL", theme=gr.themes.Soft
     """)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.queue(max_size=5).launch(
+        server_name="0.0.0.0",
+        server_port=7860
+    )