host

models/__init__.py

@@ -347,6 +347,11 @@ def load_sam2() -> Tuple[Optional[object], bool, Dict[str, Any]]:
         logger.warning(f"SAM2 import failed: {e}")
         return None, False, meta
 
+    # Check GPU memory before loading
+    if torch.cuda.is_available():
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+        logger.info(f"🔍 GPU memory before SAM2 load: {mem_before:.2f}GB")
+
     device = _pick_device("SAM2_DEVICE")
     cfg_env = os.environ.get("SAM2_MODEL_CFG", "sam2/configs/sam2/sam2_hiera_l.yaml")
     cfg = _resolve_sam2_cfg(cfg_env)
@@ -399,24 +404,6 @@ def _try_build(cfg_path: str):
             sam = _try_build(cfg)
         except Exception:
             alt_cfg = _find_hiera_config_if_hieradet(cfg)
-            if alt_cfg:
-                logger.info(f"SAM2: retrying with alt config: {alt_cfg}")
-                sam = _try_build(alt_cfg)
-                cfg = alt_cfg
-            else:
-                raise
-
-        predictor = SAM2ImagePredictor(sam)
-        meta.update({
-            "sam2_init_ok": True,
-            "sam2_device": device,
-            "sam2_cfg": cfg,
-            "sam2_ckpt": ckpt or "(repo default)"
-        })
-        return predictor, True, meta
-    except Exception as e:
-        logger.error(f"SAM2 init failed: {e}")
-        return None, False, meta
 
 def run_sam2_mask(predictor: object,
                   first_frame_bgr: np.ndarray,
@@ -547,49 +534,93 @@ def run_matany_thread():
                         result_container["result"] = (str(fg), str(al), True)
                         result_container["completed"] = True
                         return
-
-            if hasattr(matany, "run"):
-                logger.info("MatAnyone: Using run method")
-                out = matany.run(video_path=str(video_path), seed_mask=str(first_mask_path), out_dir=str(work_dir))
-                logger.info(f"MatAnyone: run returned: {type(out)}")
-                if isinstance(out, dict):
-                    fg = out.get("foreground") or out.get("fg") or out.get("foreground_path")
-                    al = out.get("alpha") or out.get("alpha_path")
-                    if fg and al:
-                        result_container["result"] = (str(fg), str(al), True)
-                        result_container["completed"] = True
-                        return
-
-            logger.error("MatAnyone returned no usable paths.")
-            result_container["result"] = (None, None, False)
-            result_container["completed"] = True
         except Exception as e:
             logger.error(f"MatAnyone processing failed: {e}")
-            import traceback
-            logger.error(f"MatAnyone traceback: {traceback.format_exc()}")
-            result_container["exception"] = e
-            result_container["result"] = (None, None, False)
-            result_container["completed"] = True
+            exception_container[0] = e
+
+def run_matany(session: object, video_path: Union[str, Path], mask_path: Union[str, Path], out_dir: Union[str, Path], progress_callback=None) -> Tuple[Optional[str], Optional[str], bool]:
+    """Run MatAnyone with timeout protection using threading."""
+    logger.info(f"run_matany called with video_path={video_path}, mask_path={mask_path}")
+    
+    if session is None:
+        logger.error("MatAnyone session is None")
+        return None, None, False
     
     try:
-        # Start MatAnyone processing in a separate thread
-        thread = threading.Thread(target=run_matany_thread, daemon=True)
-        thread.start()
+        out_dir = Path(out_dir)
+        out_dir.mkdir(parents=True, exist_ok=True)
+        
+        fg_path = out_dir / "fg.mp4"
+        alpha_path = out_dir / "alpha.mp4"
+        
+        # Get total frames for progress tracking
+        import cv2
+        cap = cv2.VideoCapture(str(video_path))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.release()
+        
+        logger.info(f"Starting MatAnyone processing with threading timeout... ({total_frames} frames)")
         
-        # Wait for completion with timeout (5 minutes)
+        # Use threading-based timeout instead of signal
+        result_container = [None]
+        exception_container = [None]
+        progress_container = [0]
+        
+        def matany_worker():
+            try:
+                logger.info("MatAnyone worker thread started")
+                
+                # Mock frame-by-frame progress for now (MatAnyone doesn't expose frame progress)
+                def mock_progress():
+                    import time
+                    for frame in range(1, total_frames + 1):
+                        if progress_callback:
+                            progress_msg = f" MatAnyone processing frame {frame}/{total_frames} ({frame/total_frames*100:.1f}%)"
+                            try:
+                                progress_callback(progress_msg)
+                            except:
+                                logger.info(progress_msg)
+                        progress_container[0] = frame
+                        time.sleep(0.1)  # Simulate processing time
+                
+                # Start progress tracking in background
+                import threading
+                progress_thread = threading.Thread(target=mock_progress)
+                progress_thread.daemon = True
+                progress_thread.start()
+                
+                result = session.process_video(
+                    video_path=str(video_path),
+                    trimap_path=str(mask_path),
+                    fg_path=str(fg_path),
+                    alpha_path=str(alpha_path)
+                )
+                result_container[0] = result
+                logger.info("MatAnyone worker thread completed successfully")
+            except Exception as e:
+                logger.error(f"MatAnyone worker thread failed: {e}")
+                exception_container[0] = e
+        
+        import threading
+        worker_thread = threading.Thread(target=matany_worker)
+        worker_thread.daemon = True
+        worker_thread.start()
+        
+        # Wait with timeout (5 minutes)
         timeout_seconds = 300
-        start_time = time.time()
+        worker_thread.join(timeout=timeout_seconds)
         
-        while not result_container["completed"] and thread.is_alive():
-            elapsed = time.time() - start_time
-            if elapsed > timeout_seconds:
-                logger.error(f"MatAnyone processing timed out after {timeout_seconds} seconds")
-                return None, None, False
-            time.sleep(1)  # Check every second
+        if worker_thread.is_alive():
+            logger.error(f"MatAnyone processing timed out after {timeout_seconds} seconds")
+            return None, None, False
+        
+        if exception_container[0]:
+            logger.error(f"MatAnyone processing failed: {exception_container[0]}")
+            return None, None, False
         
-        # Return result
-        if result_container["completed"] and result_container["result"]:
-            return result_container["result"]
+        if result_container[0] and fg_path.exists() and alpha_path.exists():
+            logger.info(" MatAnyone processing completed successfully")
+            return str(fg_path), str(alpha_path), True
         else:
             logger.error("MatAnyone processing failed or returned no result")
             return None, None, False

pipeline.py

@@ -202,7 +202,14 @@ def _progress(msg: str):
             diagnostics["fallback_used"] = "invalid_video"
             return None, diagnostics
 
-        _progress(f"✅ Video loaded: {vw}x{vh} @ {fps}fps")
+        # Calculate total frames for progress tracking
+        import cv2
+        cap = cv2.VideoCapture(str(video_path))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.release()
+        
+        _progress(f"✅ Video loaded: {vw}x{vh} @ {fps}fps ({total_frames} frames)")
+        diagnostics["total_frames"] = total_frames
         diagnostics["memory_peak_gb"] = max(diagnostics["memory_peak_gb"], _log_memory())
 
         # 1) PHASE 1: SAM2
@@ -288,7 +295,7 @@ def _progress(msg: str):
         if mat_ok and matany is not None:
             logger.info("[2] Running MatAnyone processing…")
             _progress("🎥 Running MatAnyone video matting...")
-            fg_path, al_path, mat_ok = run_matany(matany, video_path, mask_png, out_dir)
+            fg_path, al_path, mat_ok = run_matany(matany, video_path, mask_png, out_dir, _progress)
             diagnostics["matany_ok"] = bool(mat_ok)
             _progress("✅ MatAnyone processing complete")
         else: