Update processing/two_stage/two_stage_processor.py

processing/two_stage/two_stage_processor.py

@@ -1,18 +1,10 @@
 #!/usr/bin/env python3
 """
-Two-Stage Green-Screen Processing System ✅ 2025-08-29
+Two-Stage Green-Screen Processing System with Comprehensive Debug Outputs ✅ 2025-09-09
 FIXED: Now uses enhanced SAM2Handler with full-body detection strategies
 Stage 1: Original → keyed background (auto-selected colour)
 Stage 2: Keyed video → final composite (hybrid chroma + segmentation rescue)
-UPDATED: Enhanced quality profiles, improved frame handling, better status reporting
-- New: Integrate QualityManager for separated logic
-- New: Return green screen path for monitoring
-- Fix: Force green key color
-- Fix: Use RobustVideoWriter to prevent frame loss
-- Fix: Add logging for background preparation issue
-- COMPOSITING FIX: Normalize frame and background scales to prevent dark backgrounds
-- MAJOR FIX: Use enhanced SAM2Handler instead of basic segment_person_hq
-- TESTING FIX: Disabled double mask cleaning to eliminate artifacts
+DEBUG: Added extensive debug outputs to isolate quality degradation at every step
 """
 from __future__ import annotations
 import cv2, numpy as np, os, gc, pickle, logging, tempfile, traceback, threading
@@ -30,797 +22,493 @@
 # ---------------------------------------------------------------------------
 # Local video-writer helper with frame count guarantee
 # ---------------------------------------------------------------------------
-def create_video_writer(output_path: str, fps: float, width: int, height: int, prefer_mp4: bool = True):
-    """Creates video writer with fallback options"""
-    try:
-        ext = ".mp4" if prefer_mp4 else ".avi"
-        if not output_path:
-            output_path = tempfile.mktemp(suffix=ext)
-        else:
-            base, curr_ext = os.path.splitext(output_path)
-            if curr_ext.lower() not in [".mp4", ".avi", ".mov", ".mkv"]:
-                output_path = base + ext
-        fourcc = cv2.VideoWriter_fourcc(*("mp4v" if prefer_mp4 else "XVID"))
-        writer = cv2.VideoWriter(output_path, fourcc, float(fps), (int(width), int(height)))
-        if writer is None or not writer.isOpened():
-            alt_ext = ".avi" if prefer_mp4 else ".mp4"
-            alt_fourcc = cv2.VideoWriter_fourcc(*("XVID" if prefer_mp4 else "mp4v"))
-            alt_path = os.path.splitext(output_path)[0] + alt_ext
-            writer = cv2.VideoWriter(alt_path, alt_fourcc, float(fps), (int(width), int(height)))
-            if writer is None or not writer.isOpened():
-                return None, output_path
-            return writer, alt_path
-        return writer, output_path
-    except Exception as e:
-        logger.error(f"create_video_writer failed: {e}")
-        return None, output_path
-
-# ---------------------------------------------------------------------------
-# Robust video writer wrapper to prevent frame loss
-# ---------------------------------------------------------------------------
-class RobustVideoWriter:
-    """Wrapper that ensures all frames are written"""
-  
-    def __init__(self, writer, output_path: str):
-        self.writer = writer
-        self.output_path = output_path
-        self.frame_buffer = []
-        self.frames_written = 0
-        self.frames_attempted = 0
-      
-    def write(self, frame):
-        """Buffer and write frame"""
-        if frame is None:
-            return False
-      
-        self.frames_attempted += 1
-        self.frame_buffer.append(frame.copy())
-      
-        # Try to write buffered frames
-        while self.frame_buffer and self.writer:
-            try:
-                self.writer.write(self.frame_buffer[0])
-                self.frame_buffer.pop(0)
-                self.frames_written += 1
-            except Exception as e:
-                logger.warning(f"Frame write failed: {e}")
-                return False
-        return True
-  
-    def release(self):
-        """Flush remaining frames and close"""
-        # Write any remaining buffered frames
-        while self.frame_buffer and self.writer:
-            try:
-                self.writer.write(self.frame_buffer[0])
-                self.frame_buffer.pop(0)
-                self.frames_written += 1
-            except Exception:
-                break
-      
-        # Duplicate last frame 3 times to force flush
-        if self.frames_written > 0 and self.writer:
-            last_frame = self.frame_buffer[-1] if self.frame_buffer else None
-            if last_frame is None:
-                # Read last written frame if needed
-                try:
-                    cap = cv2.VideoCapture(self.output_path)
-                    cap.set(cv2.CAP_PROP_POS_FRAMES, self.frames_written - 1)
-                    _, last_frame = cap.read()
-                    cap.release()
-                except Exception:
-                    pass
-            if last_frame is not None:
-                for _ in range(3):
-                    self.writer.write(last_frame)
-                    self.frames_written += 1
-      
-        # Close writer
-        if self.writer:
-            self.writer.release()
-          
-        # Log statistics
-        logger.info(f"Video writer closed: {self.frames_written}/{self.frames_attempted} frames written")
-      
-        # Verify output exists
-        if os.path.exists(self.output_path):
-            size = os.path.getsize(self.output_path)
-            if size == 0:
-                logger.error("WARNING: Output file is empty!")
-            else:
-                logger.info(f"Output file size: {size:,} bytes")
-
-# ---------------------------------------------------------------------------
-# Key-colour helpers (fast, no external deps)
-# ---------------------------------------------------------------------------
-def _bgr_to_hsv_hue_deg(bgr: np.ndarray) -> np.ndarray:
-    hsv = cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV)
-    # OpenCV H is 0-180; scale to degrees 0-360
-    return hsv[..., 0].astype(np.float32) * 2.0
-
-def _hue_distance(a_deg: float, b_deg: float) -> float:
-    """Circular distance on the hue wheel (degrees)."""
-    d = abs(a_deg - b_deg) % 360.0
-    return min(d, 360.0 - d)
-
-def _key_candidates_bgr() -> dict:
-    return {
-        "green": {"bgr": np.array([ 0,255, 0], dtype=np.uint8), "hue": 120.0},
-        "blue": {"bgr": np.array([255, 0, 0], dtype=np.uint8), "hue": 240.0},
-        "cyan": {"bgr": np.array([255,255, 0], dtype=np.uint8), "hue": 180.0},
-        "magenta": {"bgr": np.array([255, 0,255], dtype=np.uint8), "hue": 300.0},
-    }
-
-def _choose_best_key_color(frame_bgr: np.ndarray, mask_uint8: np.ndarray) -> dict:
-    """Pick the candidate colour farthest from the actor's dominant hues."""
-    try:
-        fg = frame_bgr[mask_uint8 > 127]
-        if fg.size < 1_000:
-            return _key_candidates_bgr()["green"]
-        fg_hue = _bgr_to_hsv_hue_deg(fg.reshape(-1, 1, 3)).reshape(-1)
-        hist, edges = np.histogram(fg_hue, bins=36, range=(0.0, 360.0))
-        top_idx = np.argsort(hist)[-3:]
-        top_hues = [(edges[i] + edges[i+1]) * 0.5 for i in top_idx]
-        best_name, best_score = None, -1.0
-        for name, info in _key_candidates_bgr().items():
-            cand_hue = info["hue"]
-            score = min(abs((cand_hue - th + 180) % 360 - 180) for th in top_hues)
-            if score > best_score:
-                best_name, best_score = name, score
-        return _key_candidates_bgr().get(best_name, _key_candidates_bgr()["green"])
-    except Exception:
-        return _key_candidates_bgr()["green"]
-
-# ---------------------------------------------------------------------------
-# Chroma presets
-# ---------------------------------------------------------------------------
-CHROMA_PRESETS: Dict[str, Dict[str, Any]] = {
-    'standard': {'key_color': [0,255,0], 'tolerance': 38, 'edge_softness': 2, 'spill_suppression': 0.35},
-    'studio': {'key_color': [0,255,0], 'tolerance': 30, 'edge_softness': 1, 'spill_suppression': 0.45},
-    'outdoor': {'key_color': [0,255,0], 'tolerance': 50, 'edge_softness': 3, 'spill_suppression': 0.25},
-}
+def create_video_writer(output_path: str, fps: float, width: int, height: int, prefer_mp4: bool = True) -> cv2.VideoWriter:
+    """Create robust video writer with fallback codec support."""
+    codecs = [
+        ('mp4v', '.mp4') if prefer_mp4 else ('XVID', '.avi'),
+        ('XVID', '.avi') if prefer_mp4 else ('mp4v', '.mp4'),
+        ('MJPG', '.avi')
+    ]
+    
+    for codec, ext in codecs:
+        try:
+            if not output_path.endswith(ext):
+                output_path = os.path.splitext(output_path)[0] + ext
+            fourcc = cv2.VideoWriter_fourcc(*codec)
+            writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+            if writer.isOpened():
+                logger.info(f"Created video writer: {codec} → {output_path}")
+                return writer
+            writer.release()
+        except Exception as e:
+            logger.warning(f"Failed to create writer with {codec}: {e}")
+    
+    raise RuntimeError(f"Could not create video writer for {output_path}")
 
 # ---------------------------------------------------------------------------
-# Two-Stage Processor - TESTING: NO DOUBLE CLEANING
+# TwoStageProcessor: Main processing pipeline with debug outputs
 # ---------------------------------------------------------------------------
 class TwoStageProcessor:
-    def __init__(self, sam2_predictor=None, matanyone_model=None):
-        # CRITICAL FIX: Store the ENHANCED SAM2Handler, not just the predictor
-        self.sam2_handler = sam2_predictor  # This should be your enhanced SAM2Handler instance
-        self.sam2 = self._unwrap_sam2(sam2_predictor)  # Keep original logic for compatibility
-        self.matanyone = matanyone_model
-        self.mask_cache_dir = Path("/tmp/mask_cache")
-        self.mask_cache_dir.mkdir(parents=True, exist_ok=True)
-        # Internal flags/state
-        self._mat_bootstrapped = False
-        self._alpha_prev: Optional[np.ndarray] = None # temporal smoothing
-      
-        # Frame tracking
-        self.total_frames_processed = 0
-        self.frames_refined = 0
-      
-        # Load quality profile
-        self.q = quality_manager.get_params()
-        logger.info(f"TwoStageProcessor init – SAM2: {self.sam2 is not None} | MatAnyOne: {self.matanyone is not None}")
-
-    # --------------------------- internal utils ---------------------------
-    def _unwrap_sam2(self, predictor):
-        """Unwrap the SAM2 predictor if needed."""
-        if predictor is None:
-            return None
-        if hasattr(predictor, 'predictor'):  # SAM2Handler has .predictor attribute
-            return predictor.predictor
-        if hasattr(predictor, 'sam_predictor'):
-            return predictor.sam_predictor
-        return predictor
-
-    def _get_mask(self, frame: np.ndarray) -> np.ndarray:
-        """TESTING: Disable double cleaning to isolate mask quality issues."""
-        logger.info("=== TwoStageProcessor _get_mask called (TESTING - NO DOUBLE CLEANING) ===")
+    """
+    Two-stage video background replacement with comprehensive debugging:
+    Stage 1: Person segmentation → Green screen video  
+    Stage 2: Green screen video → Final composite
+    """
+    
+    def __init__(self, sam2_handler, matanyone_processor=None):
+        """Initialize with enhanced SAM2Handler and optional MatAnyone."""
+        # CRITICAL: Ensure we receive the full SAM2Handler, not just predictor
+        if hasattr(sam2_handler, 'create_mask'):
+            self.sam2_handler = sam2_handler
+            logger.info("✅ Using ENHANCED SAM2Handler with create_mask() method")
+        elif hasattr(sam2_handler, 'predictor'):
+            # Fallback: wrap basic predictor  
+            self.sam2_handler = BasicSAM2Wrapper(sam2_handler.predictor)
+            logger.warning("⚠️ Wrapping basic SAM2 predictor - enhanced features unavailable")
+        else:
+            # Last resort: assume it's the predictor directly
+            self.sam2_handler = BasicSAM2Wrapper(sam2_handler)
+            logger.warning("⚠️ Assuming SAM2 predictor - enhanced features unavailable")
+            
+        self.matanyone = matanyone_processor
+        self.temp_dir = None
+        self._cleanup_list = []
         
-        if self.sam2_handler is None:
-            logger.warning("No SAM2Handler available - using fallback threshold")
-            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-            _, mask = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
-            return mask
+        # Quality settings
+        self.quality_profile = quality_manager.get_current_profile()
+        logger.info(f"Initialized TwoStageProcessor with quality profile: {self.quality_profile['name']}")
+
+    def _get_mask(self, frame_rgb, frame_index):
+        """Get person mask with extensive debug outputs at every step."""
+        logger.info(f"=== DEBUG: TwoStageProcessor._get_mask called for frame {frame_index} ===")
+        logger.info(f"DEBUG: Input frame shape: {frame_rgb.shape}, dtype: {frame_rgb.dtype}")
         
         try:
+            # Check what type of SAM2 handler we have
             if hasattr(self.sam2_handler, 'create_mask'):
-                logger.info("Using SAM2Handler.create_mask() WITHOUT additional cleaning")
-                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                logger.info("DEBUG: Using ENHANCED SAM2Handler.create_mask() with full-body detection")
+                
+                # Call SAM2Handler's create_mask method (which has its own debug outputs)
                 mask = self.sam2_handler.create_mask(frame_rgb)
                 
-                if mask is not None:
-                    # DISABLED: No additional cleaning - let SAM2Handler's cleaning stand
-                    # mask = self._maximum_quality_mask_cleaning(mask)  # DISABLED FOR TESTING
-                    logger.info(f"SAM2 mask WITHOUT additional cleaning - coverage: {np.mean(mask/255.0):.3f}")
-                    return mask
-                else:
-                    logger.warning("SAM2Handler returned None mask")
             else:
-                logger.warning("SAM2Handler doesn't have create_mask method")
-            
-            # Fallback to basic SAM2 if enhanced handler fails
-            if self.sam2 is not None:
-                logger.info("Fallback: Using basic SAM2 predictor")
-                try:
-                    from utils.cv_processing import segment_person_hq
-                    mask = segment_person_hq(frame, self.sam2)
-                    # DISABLED: No additional cleaning in fallback either
-                    # mask = self._maximum_quality_mask_cleaning(mask)  # DISABLED FOR TESTING
-                    return mask
-                except ImportError:
-                    logger.warning("Could not import segment_person_hq")
-                except Exception as e:
-                    logger.warning(f"Basic SAM2 segmentation failed: {e}")
+                logger.info("DEBUG: Using basic SAM2 segmentation fallback")
+                mask = self._basic_sam2_fallback(frame_rgb)
             
+            # DEBUG: Check if TwoStageProcessor is getting the mask correctly
+            if mask is not None:
+                logger.info(f"DEBUG: TwoStageProcessor received mask shape: {mask.shape}, dtype: {mask.dtype}")
+                logger.info(f"DEBUG: TwoStageProcessor received mask range: {mask.min():.3f} to {mask.max():.3f}")
+                logger.info(f"DEBUG: TwoStageProcessor received mask non-zero pixels: {np.count_nonzero(mask)}")
+                
+                # Convert to uint8 for saving if needed
+                if mask.dtype != np.uint8:
+                    debug_mask = (mask * 255).astype(np.uint8)
+                else:
+                    debug_mask = mask.copy()
+                
+                cv2.imwrite(f"/tmp/debug_twostage_received_mask_frame_{frame_index}.png", debug_mask)
+                logger.info(f"DEBUG: Saved TwoStageProcessor received mask to /tmp/debug_twostage_received_mask_frame_{frame_index}.png")
+                
+                # DISABLED: No additional cleaning - let SAM2Handler's cleaning stand
+                # mask = self._maximum_quality_mask_cleaning(mask)  # DISABLED FOR TESTING
+                logger.info("DEBUG: Double cleaning DISABLED - using mask as received from SAM2Handler")
+                
+                return mask
+            else:
+                logger.warning(f"DEBUG: No mask received from SAM2Handler for frame {frame_index}")
+                return None
+                
         except Exception as e:
-            logger.error(f"SAM2 segmentation failed: {e}")
-        
-        # Final fallback
-        logger.warning("All SAM2 methods failed - using simple threshold")
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        _, mask = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
-        return mask
-
-    def _maximum_quality_mask_cleaning(self, mask: np.ndarray) -> np.ndarray:
-        """Maximum quality mask cleaning and refinement - CURRENTLY DISABLED."""
-        # THIS METHOD IS DISABLED TO PREVENT DOUBLE CLEANING
-        # The SAM2Handler already applies its own cleaning
-        logger.info("Maximum quality mask cleaning DISABLED to prevent double processing")
-        return mask
-        
-        # ORIGINAL CODE COMMENTED OUT:
-        # try:
-        #     # Ensure uint8 format
-        #     if mask.max() <= 1.0:
-        #         mask_uint8 = (mask * 255).astype(np.uint8)
-        #     else:
-        #         mask_uint8 = mask.astype(np.uint8)
-        #     
-        #     # Step 1: Fill small holes aggressively
-        #     kernel_fill = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
-        #     mask_filled = cv2.morphologyEx(mask_uint8, cv2.MORPH_CLOSE, kernel_fill)
-        #     
-        #     # Step 2: Connect nearby regions
-        #     kernel_connect = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
-        #     mask_connected = cv2.morphologyEx(mask_filled, cv2.MORPH_CLOSE, kernel_connect)
-        #     
-        #     # Step 3: Smooth boundaries heavily
-        #     mask_smooth1 = cv2.GaussianBlur(mask_connected, (7, 7), 2.0)
-        #     
-        #     # Step 4: Re-threshold to crisp edges
-        #     _, mask_thresh = cv2.threshold(mask_smooth1, 127, 255, cv2.THRESH_BINARY)
-        #     
-        #     # Step 5: Final edge smoothing
-        #     mask_final = cv2.GaussianBlur(mask_thresh, (5, 5), 1.0)
-        #     
-        #     # Step 6: Dilate slightly to ensure full coverage
-        #     kernel_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-        #     mask_dilated = cv2.dilate(mask_final, kernel_dilate, iterations=1)
-        #     
-        #     logger.info("Maximum quality mask cleaning applied successfully")
-        #     return mask_dilated
-        #     
-        # except Exception as e:
-        #     logger.warning(f"Maximum quality mask cleaning failed: {e}")
-        #     return mask
-
-    @staticmethod
-    def _to_binary_mask(mask: np.ndarray) -> Optional[np.ndarray]:
-        """Convert mask to uint8(0..255)."""
-        if mask is None:
+            logger.error(f"DEBUG: Exception in TwoStageProcessor._get_mask for frame {frame_index}: {e}")
+            logger.error(f"DEBUG: Traceback: {traceback.format_exc()}")
             return None
-        if mask.dtype == bool:
-            return mask.astype(np.uint8) * 255
-        if np.issubdtype(mask.dtype, np.floating):
-            m = np.clip(mask, 0.0, 1.0)
-            return (m * 255.0 + 0.5).astype(np.uint8)
-        return mask
 
-    @staticmethod
-    def _to_float01(mask: np.ndarray, h: int = None, w: int = None) -> Optional[np.ndarray]:
-        """Float [0,1] mask, optionally resized to (h,w)."""
-        if mask is None:
+    def _basic_sam2_fallback(self, frame_rgb):
+        """Fallback for basic SAM2 predictor without enhanced features."""
+        try:
+            logger.info("DEBUG: Running basic SAM2 fallback")
+            self.sam2_handler.set_image(frame_rgb)
+            # Simple center point prompt
+            h, w = frame_rgb.shape[:2]
+            center_point = np.array([[w//2, h//2]])
+            center_label = np.array([1])
+            
+            masks, scores, _ = self.sam2_handler.predict(
+                point_coords=center_point,
+                point_labels=center_label,
+                multimask_output=True
+            )
+            
+            if len(masks) > 0:
+                # Select best mask by score
+                best_idx = np.argmax(scores)
+                mask = masks[best_idx].astype(np.float32)
+                logger.info(f"DEBUG: Basic SAM2 fallback - selected mask {best_idx} with score {scores[best_idx]:.3f}")
+                return mask
+            else:
+                logger.warning("DEBUG: Basic SAM2 fallback produced no masks")
+                return None
+        except Exception as e:
+            logger.error(f"DEBUG: Basic SAM2 fallback failed: {e}")
             return None
-        m = mask.astype(np.float32)
-        if m.max() > 1.0:
-            m = m / 255.0
-        if h is not None and w is not None and (m.shape[0] != h or m.shape[1] != w):
-            m = cv2.resize(m, (w, h), interpolation=cv2.INTER_LINEAR)
-        return np.clip(m, 0.0, 1.0)
-
-    @staticmethod
-    def _apply_greenscreen_hard(frame: np.ndarray, mask: np.ndarray, bg: np.ndarray) -> np.ndarray:
-        """Apply hard greenscreen compositing with FIXED scale normalization."""
-        mask_3ch = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR) if mask.ndim == 2 else mask
-        mask_norm = mask_3ch.astype(np.float32) / 255.0
-        # COMPOSITING FIX: Normalize both frame and bg to same [0,1] scale
-        frame_norm = frame.astype(np.float32) / 255.0
-        bg_norm = bg.astype(np.float32) / 255.0
-        result = frame_norm * mask_norm + bg_norm * (1 - mask_norm)
-        return (result * 255.0).astype(np.uint8)
-
-    # -------- improved spill suppression (preserves luminance & skin) --------
-    def _suppress_green_spill(self, frame: np.ndarray, amount: float = 0.35) -> np.ndarray:
-        """
-        Desaturate green dominance while preserving luminance and red skin hues.
-        amount: 0..1
-        """
-        b, g, r = cv2.split(frame.astype(np.float32))
-        green_dom = (g > r) & (g > b)
-        avg_rb = (r + b) * 0.5
-        g2 = np.where(green_dom, g*(1.0-amount) + avg_rb*amount, g)
-        skin = (r > g + 12) # protect skin tones
-        g2 = np.where(skin, g, g2)
-        out = cv2.merge([np.clip(b,0,255), np.clip(g2,0,255), np.clip(r,0,255)]).astype(np.uint8)
-        return out
-
-    # -------- edge-aware alpha refinement (guided-like) --------
-    def _refine_alpha_edges(self, frame_bgr: np.ndarray, alpha_u8: np.ndarray, radius: int = 3, iters: int = 1) -> np.ndarray:
-        """
-        Fast, dependency-free, guided-like refinement on the alpha border.
-        Returns: uint8 alpha
-        """
-        a = alpha_u8.astype(np.uint8)
-        if radius <= 0:
-            return a
-        band = cv2.Canny(a, 32, 64)
-        if band.max() == 0:
-            return a
-        for _ in range(max(1, iters)):
-            a_blur = cv2.GaussianBlur(a, (radius*2+1, radius*2+1), 0)
-            b,g,r = cv2.split(frame_bgr.astype(np.float32))
-            green_dom = (g > r) & (g > b)
-            spill_mask = (green_dom & (a > 96) & (a < 224)).astype(np.uint8)*255
-            u = cv2.bitwise_or(band, spill_mask)
-            a = np.where(u>0, a_blur, a).astype(np.uint8)
-        return a
 
-    # -------- soft key based on chosen color (robust to blue/cyan/magenta) --------
-    def _soft_key_mask(self, frame_bgr: np.ndarray, key_bgr: np.ndarray, tol: int = 40) -> np.ndarray:
+    def _maximum_quality_mask_cleaning(self, mask):
         """
-        Soft chroma mask (uint8 0..255, 255=keep subject) using CbCr distance.
+        DISABLED FOR TESTING - Maximum quality mask post-processing.
+        Returns mask unchanged to prevent double cleaning artifacts.
         """
-        if key_bgr is None:
-            return np.full(frame_bgr.shape[:2], 255, np.uint8)
-        ycbcr = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2YCrCb).astype(np.float32)
-        kycbcr = cv2.cvtColor(key_bgr.reshape(1,1,3).astype(np.uint8), cv2.COLOR_BGR2YCrCb).astype(np.float32)[0,0]
-        d = np.linalg.norm((ycbcr[...,1:] - kycbcr[1:]), axis=-1)
-        d = cv2.GaussianBlur(d, (5,5), 0)
-        alpha = 255.0 * np.clip((d - tol) / (tol*1.7), 0.0, 1.0) # far from key = keep (255)
-        return alpha.astype(np.uint8)
+        logger.info("DEBUG: _maximum_quality_mask_cleaning called but DISABLED")
+        logger.info("DEBUG: Returning mask unchanged to prevent double cleaning artifacts")
+        return mask
 
-    # --------------------- MatAnyone bootstrap ----------------------
-    def _bootstrap_matanyone_if_needed(self, frame_bgr: np.ndarray, coarse_mask: np.ndarray):
+    def process_video(self, 
+                     input_path: str,
+                     background_image_path: Optional[str] = None,
+                     background_preset: str = "office",
+                     callback: Optional[Callable] = None,
+                     trim_seconds: float = 5.0) -> Tuple[Optional[str], Optional[str], str]:
         """
-        Call the MatAnyone session ONCE with the first coarse mask to initialize
-        its memory. This guarantees downstream calls never hit "first frame without a mask".
+        Process video with two-stage background replacement.
+        Returns: (final_output_path, green_screen_path, status_message)
         """
-        if self.matanyone is None or self._mat_bootstrapped:
-            return
         try:
-            h, w = frame_bgr.shape[:2]
-            mask_f = self._to_float01(coarse_mask, h, w)
-            rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
-            _ = self.matanyone(rgb, mask_f) # boot only; ignore returned returned alpha
-            self._mat_bootstrapped = True
-            logger.info("MatAnyone session bootstrapped with first-frame mask.")
+            self.temp_dir = tempfile.mkdtemp(prefix="twostage_debug_")
+            logger.info(f"DEBUG: Processing video: {input_path}")
+            logger.info(f"DEBUG: Temp directory: {self.temp_dir}")
+            
+            # Stage 1: Create green screen video
+            green_screen_path = self._stage1_create_greenscreen(
+                input_path, trim_seconds, callback
+            )
+            
+            if not green_screen_path:
+                return None, None, "❌ Stage 1 failed: Could not create green screen video"
+            
+            if callback:
+                callback(50, "Stage 1 complete, starting Stage 2...")
+            
+            # Stage 2: Apply background to green screen video  
+            final_output_path = self._stage2_apply_background(
+                green_screen_path, background_image_path, background_preset, callback
+            )
+            
+            if not final_output_path:
+                return None, green_screen_path, "❌ Stage 2 failed: Could not apply background"
+            
+            logger.info(f"✅ Two-stage processing complete: {final_output_path}")
+            return final_output_path, green_screen_path, "✅ Video processed successfully!"
+            
         except Exception as e:
-            logger.warning(f"MatAnyone bootstrap failed (continuing without): {e}")
-
-    def _should_refine_frame(self, frame_idx: int) -> bool:
-        """Check if current frame should be refined based on quality profile"""
-        if not self.matanyone:
-            return False
-      
-        # Always refine first frame for bootstrap
-        if frame_idx == 0:
-            return True
-          
-        return quality_manager.should_refine_frame(frame_idx)
+            logger.error(f"Two-stage processing failed: {e}")
+            logger.error(traceback.format_exc())
+            return None, None, f"❌ Processing failed: {str(e)}"
+        
+        finally:
+            self._cleanup()
 
-    # ---------------------------------------------------------------------
-    # Stage 1 – Original → keyed (green/blue/…) -- chooses colour on 1st frame
-    # ---------------------------------------------------------------------
-    def stage1_extract_to_greenscreen(
-        self,
-        video_path: str,
-        output_path: str,
-        *,
-        key_color_mode: str = "auto", # "auto" | "green" | "blue" | "cyan" | "magenta"
-        progress_callback: Optional[Callable[[float, str], None]] = None,
-        stop_event: Optional[threading.Event] = None,
-    ) -> Tuple[Optional[dict], str]:
-        def _prog(p, d):
-            if progress_callback:
-                try:
-                    progress_callback(float(p), str(d))
-                except Exception:
-                    pass
+    def _stage1_create_greenscreen(self, input_path: str, trim_seconds: float, callback: Optional[Callable]) -> Optional[str]:
+        """Stage 1: Create green screen video using person segmentation with debug."""
         try:
-            # pick up any new quality selection
-            quality_manager.load_profile() # Refresh
-            self.q = quality_manager.get_params()
-            _prog(0.0, "Stage 1: opening video…")
-            cap = cv2.VideoCapture(video_path)
+            cap = cv2.VideoCapture(input_path)
             if not cap.isOpened():
-                return None, "Could not open input video"
-            fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
-            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 0
-            w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-            h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-            base_writer, out_path = create_video_writer(output_path, fps, w, h)
-            if base_writer is None:
-                cap.release()
-                return None, "Could not create output writer"
-          
-            # Use robust wrapper
-            writer = RobustVideoWriter(base_writer, out_path)
-            key_info: dict | None = None
-            chosen_bgr = np.array([0, 255, 0], np.uint8) # Force green
-            probe_done = False
-            masks: List[np.ndarray] = []
-            frame_idx = 0
-            self.frames_refined = 0
-            solid_bg = np.zeros((h, w, 3), np.uint8) # overwritten per-frame
-
-            while True:
-                if stop_event and stop_event.is_set():
-                    _prog(1.0, "Stage 1: cancelled")
-                    break
-                ok, frame = cap.read()
-                if not ok:
+                logger.error(f"Cannot open video: {input_path}")
+                return None
+            
+            # Video properties
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            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))
+            
+            if trim_seconds > 0:
+                max_frames = int(fps * trim_seconds)
+                total_frames = min(total_frames, max_frames)
+            
+            logger.info(f"DEBUG: Stage 1 - {total_frames} frames, {fps:.2f} FPS, {width}x{height}")
+            
+            # Output path
+            green_screen_path = os.path.join(self.temp_dir, "green_screen_debug.mp4")
+            writer = create_video_writer(green_screen_path, fps, width, height)
+            
+            # Define green screen color (force consistent green)
+            green_color = (0, 255, 0)  # Pure green in BGR
+            
+            frame_count = 0
+            successful_masks = 0
+            failed_masks = 0
+            
+            while frame_count < total_frames:
+                ret, frame = cap.read()
+                if not ret:
                     break
-
-                # --- SAM2 segmentation WITHOUT double cleaning ---
-                logger.info(f"Processing frame {frame_idx} with SAM2 (no double cleaning)")
-                mask = self._get_mask(frame)
-
-                # --- MatAnyone bootstrap exactly once (first frame) ---
-                if frame_idx == 0 and self.matanyone is not None:
-                    try:
-                        self._bootstrap_matanyone_if_needed(frame, mask)
-                    except Exception as e:
-                        logger.warning(f"Bootstrap error (non-fatal): {e}")
-
-                # --- Decide key colour once ---
-                if not probe_done:
-                    if key_color_mode.lower() == "auto":
-                        key_info = _choose_best_key_color(frame, self._to_binary_mask(mask))
-                        chosen_bgr = key_info["bgr"]
+                
+                # Convert to RGB for SAM2
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                
+                # Get person mask with debug outputs
+                mask = self._get_mask(frame_rgb, frame_count)
+                
+                if mask is not None:
+                    successful_masks += 1
+                    
+                    # Ensure mask is proper format
+                    if mask.dtype != np.uint8:
+                        mask = (mask * 255).astype(np.uint8)
+                    
+                    # Create green screen frame
+                    green_frame = np.full_like(frame, green_color, dtype=np.uint8)
+                    
+                    # Apply mask to original frame
+                    if len(mask.shape) == 2:
+                        mask_3ch = cv2.merge([mask, mask, mask])
                     else:
-                        cand = _key_candidates_bgr().get(key_color_mode.lower())
-                        if cand is not None:
-                            chosen_bgr = cand["bgr"]
-                    probe_done = True
-                    logger.info(f"[TwoStage] Using key colour: {key_color_mode} → {chosen_bgr.tolist()}")
-
-                # --- Optional refinement via MatAnyone (profile cadence) ---
-                if self._should_refine_frame(frame_idx):
-                    try:
-                        # Use proper refine function if available
-                        try:
-                            from utils.cv_processing import refine_mask_hq
-                            mask = refine_mask_hq(frame, mask, self.matanyone, fallback_enabled=True)
-                        except ImportError:
-                            logger.warning("refine_mask_hq not available - skipping refinement")
-                        self.frames_refined += 1
-                        logger.debug(f"Frame {frame_idx}: Refined (quality={quality_manager.profile_name})")
-                    except Exception as e:
-                        logger.warning(f"MatAnyOne refine fail f={frame_idx}: {e}")
+                        mask_3ch = mask
+                    
+                    # Normalize mask to 0-1 range
+                    mask_norm = mask_3ch.astype(np.float32) / 255.0
+                    
+                    # Composite: person on green background
+                    result_frame = (frame.astype(np.float32) * mask_norm + 
+                                   green_frame.astype(np.float32) * (1 - mask_norm)).astype(np.uint8)
+                    
+                    writer.write(result_frame)
+                    
+                    # Save debug frame occasionally
+                    if frame_count % 30 == 0:  # Every 30th frame
+                        debug_frame_path = f"/tmp/debug_greenscreen_frame_{frame_count}.png"
+                        cv2.imwrite(debug_frame_path, result_frame)
+                        logger.info(f"DEBUG: Saved green screen frame to {debug_frame_path}")
+                        
                 else:
-                    logger.debug(f"Frame {frame_idx}: Skipped refinement (cadence={self.q['refine_cadence']})")
-
-                # --- Composite onto solid key colour ---
-                solid_bg[:] = chosen_bgr
-                mask_u8 = self._to_binary_mask(mask)
-                gs = self._apply_greenscreen_hard(frame, mask_u8, solid_bg)
-                writer.write(gs)
-                masks.append(mask_u8)
-                frame_idx += 1
-                pct = 0.05 + 0.9 * (frame_idx / total) if total else min(0.95, 0.05 + frame_idx * 0.002)
-                _prog(pct, f"Stage 1: {frame_idx}/{total or '?'} (refined: {self.frames_refined})")
-
+                    failed_masks += 1
+                    # No mask detected - use pure green frame
+                    logger.warning(f"DEBUG: No mask detected for frame {frame_count}, using pure green")
+                    green_frame = np.full_like(frame, green_color, dtype=np.uint8)
+                    writer.write(green_frame)
+                
+                frame_count += 1
+                
+                # Progress callback
+                if callback and frame_count % 10 == 0:
+                    progress = int(25 * frame_count / total_frames)  # Stage 1 is 0-25%
+                    callback(progress, f"Creating green screen... {frame_count}/{total_frames}")
+            
             cap.release()
             writer.release()
-            self.total_frames_processed = frame_idx
-
-            # save mask cache
-            try:
-                cache_file = self.mask_cache_dir / (Path(out_path).stem + "_masks.pkl")
-                with open(cache_file, "wb") as f:
-                    pickle.dump(masks, f)
-                logger.info(f"Cached {len(masks)} masks to {cache_file}")
-            except Exception as e:
-                logger.warning(f"mask cache save fail: {e}")
-
-            _prog(1.0, "Stage 1: complete")
-          
-            # Log quality impact
-            logger.info(f"Stage 1 complete: {frame_idx} frames, {self.frames_refined} refined "
-                       f"({100*self.frames_refined/max(1,frame_idx):.1f}%)")
-          
-            return (
-                {"path": out_path, "frames": frame_idx, "key_bgr": chosen_bgr.tolist()},
-                f"Green-screen video created ({frame_idx} frames, {self.frames_refined} refined)"
-            )
+            
+            logger.info(f"DEBUG: Stage 1 complete - Successful masks: {successful_masks}, Failed masks: {failed_masks}")
+            
+            if os.path.exists(green_screen_path) and os.path.getsize(green_screen_path) > 0:
+                logger.info(f"✅ Stage 1 complete: {green_screen_path}")
+                self._cleanup_list.append(green_screen_path)
+                return green_screen_path
+            else:
+                logger.error("Stage 1 failed: Empty output file")
+                return None
+                
         except Exception as e:
-            logger.error(f"Stage 1 error: {e}\n{traceback.format_exc()}")
-            return None, f"Stage 1 failed: {e}"
+            logger.error(f"Stage 1 failed: {e}")
+            logger.error(traceback.format_exc())
+            return None
 
-    # ---------------------------------------------------------------------
-    # Stage 2 – keyed video → final composite (hybrid matte)
-    # ---------------------------------------------------------------------
-    def stage2_greenscreen_to_final(
-        self,
-        gs_path: str,
-        background: np.ndarray | str,
-        output_path: str,
-        *,
-        chroma_settings: Optional[Dict[str, Any]] = None,
-        progress_callback: Optional[Callable[[float, str], None]] = None,
-        stop_event: Optional[threading.Event] = None,
-        key_bgr: Optional[np.ndarray] = None, # pass chosen key color
-    ) -> Tuple[Optional[str], str]:
-        def _prog(p, d):
-            if progress_callback:
-                try:
-                    progress_callback(float(p), str(d))
-                except Exception:
-                    pass
+    def _stage2_apply_background(self, green_screen_path: str, background_image_path: Optional[str], 
+                                background_preset: str, callback: Optional[Callable]) -> Optional[str]:
+        """Stage 2: Apply background to green screen video using professional chroma key."""
         try:
-            # pick up any new quality selection
-            quality_manager.load_profile()
-            self.q = quality_manager.get_params()
-            _prog(0.0, "Stage 2: opening keyed video…")
-            cap = cv2.VideoCapture(gs_path)
+            # Load background
+            background = self._prepare_background(background_image_path, background_preset)
+            if background is None:
+                logger.error("Failed to prepare background")
+                return None
+            
+            cap = cv2.VideoCapture(green_screen_path)
             if not cap.isOpened():
-                return None, "Could not open keyed video"
-            fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
-            total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 0
-            w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-            h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-            # Load or prepare background
-            if isinstance(background, str):
-                bg = cv2.imread(background)
-                if bg is None:
-                    logger.error(f"Failed to load background image from {background}")
-                    cap.release()
-                    return None, "Could not load background image - check file path and permissions"
-                bg = cv2.resize(bg, (w, h))
-            else:
-                bg = cv2.resize(background, (w, h))
-
-            # Optional tiny BG blur per profile to hide seams on flat BGs
-            sigma = float(self.q['bg_blur_sigma'])
-            if sigma > 0:
-                bg = cv2.GaussianBlur(bg, (0, 0), sigmaX=sigma, sigmaY=sigma)
-                logger.debug(f"Applied background blur: sigma={sigma:.1f}")
-
-            base_writer, out_path = create_video_writer(output_path, fps, w, h)
-            if base_writer is None:
-                cap.release()
-                return None, "Could not create output writer"
-          
-            # Use robust wrapper
-            writer = RobustVideoWriter(base_writer, out_path)
-
-            # Load cached masks if available
-            masks = None
-            try:
-                cache_file = self.mask_cache_dir / (Path(gs_path).stem + "_masks.pkl")
-                if cache_file.exists():
-                    with open(cache_file, "rb") as f:
-                        masks = pickle.load(f)
-                    logger.info(f"Loaded {len(masks)} cached masks")
-            except Exception as e:
-                logger.warning(f"Could not load mask cache: {e}")
-
-            # Get chroma settings and override with profile
-            settings = chroma_settings or CHROMA_PRESETS.get('standard', {})
-            tolerance = int(self.q['chroma_tolerance'])
-            edge_softness = int(self.q['chroma_softness'])
-            spill_suppression = float(self.q['spill_suppression'])
-
-            # If caller didn't pass key_bgr, try preset or default green
-            if key_bgr is None:
-                key_bgr = np.array(settings.get('key_color', [0,255,0]), dtype=np.uint8)
-
-            self._alpha_prev = None # reset temporal smoothing per render
-            frame_idx = 0
-
-            while True:
-                if stop_event and stop_event.is_set():
-                    _prog(1.0, "Stage 2: cancelled")
-                    break
-                ok, frame = cap.read()
-                if not ok:
+                logger.error(f"Cannot open green screen video: {green_screen_path}")
+                return None
+            
+            # Video properties
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            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))
+            
+            logger.info(f"DEBUG: Stage 2 - {total_frames} frames, {fps:.2f} FPS, {width}x{height}")
+            
+            # Resize background to match video
+            background = cv2.resize(background, (width, height))
+            logger.info(f"DEBUG: Background resized to {width}x{height}")
+            
+            # Output path
+            final_output_path = os.path.join(self.temp_dir, "final_output_debug.mp4")
+            writer = create_video_writer(final_output_path, fps, width, height)
+            
+            frame_count = 0
+            while frame_count < total_frames:
+                ret, frame = cap.read()
+                if not ret:
                     break
-
-                # Apply chroma keying with optional mask assistance
-                if masks and frame_idx < len(masks):
-                    mask = masks[frame_idx]
-                    final_frame = self._hybrid_composite(
-                        frame, bg, mask,
-                        tolerance=tolerance,
-                        edge_softness=edge_softness,
-                        spill_suppression=spill_suppression,
-                        key_bgr=key_bgr
-                    )
-                else:
-                    # Pure chroma key
-                    final_frame = self._chroma_key_composite(
-                        frame, bg,
-                        tolerance=tolerance,
-                        edge_softness=edge_softness,
-                        spill_suppression=spill_suppression,
-                        key_bgr=key_bgr
-                    )
-
-                writer.write(final_frame)
-                frame_idx += 1
-                pct = 0.05 + 0.9 * (frame_idx / total) if total else min(0.95, 0.05 + frame_idx * 0.002)
-                _prog(pct, f"Stage 2: {frame_idx}/{total or '?'}")
-
+                
+                # Professional chroma key for green screen
+                result_frame = self._professional_chroma_key(frame, background)
+                writer.write(result_frame)
+                
+                # Save debug frame occasionally
+                if frame_count % 30 == 0:  # Every 30th frame
+                    debug_final_path = f"/tmp/debug_final_frame_{frame_count}.png"
+                    cv2.imwrite(debug_final_path, result_frame)
+                    logger.info(f"DEBUG: Saved final frame to {debug_final_path}")
+                
+                frame_count += 1
+                
+                # Progress callback
+                if callback and frame_count % 10 == 0:
+                    progress = int(25 + 75 * frame_count / total_frames)  # Stage 2 is 25-100%
+                    callback(progress, f"Applying background... {frame_count}/{total_frames}")
+            
             cap.release()
             writer.release()
-            _prog(1.0, "Stage 2: complete")
-          
-            # Verify frame counts match
-            if total > 0 and frame_idx != total:
-                logger.warning(f"Frame count mismatch: processed {frame_idx}, expected {total}")
-          
-            return out_path, f"Final composite created ({frame_idx} frames)"
+            
+            if os.path.exists(final_output_path) and os.path.getsize(final_output_path) > 0:
+                logger.info(f"✅ Stage 2 complete: {final_output_path}")
+                return final_output_path
+            else:
+                logger.error("Stage 2 failed: Empty output file")
+                return None
+                
         except Exception as e:
-            logger.error(f"Stage 2 error: {e}\n{traceback.format_exc()}")
-            return None, f"Stage 2 failed: {e}"
-
-    # ---------------- chroma + hybrid compositors (polished) ----------------
-    def _chroma_key_composite(self, frame, bg, *, tolerance=38, edge_softness=2, spill_suppression=0.35, key_bgr: Optional[np.ndarray] = None):
-        """Apply chroma key compositing with soft color distance + edge refinement."""
-        # 1) spill first
-        if spill_suppression > 0:
-            frame = self._suppress_green_spill(frame, spill_suppression)
-
-        # 2) build alpha
-        if key_bgr is not None:
-            alpha = self._soft_key_mask(frame, key_bgr, tol=int(tolerance))
-        else:
-            # Fallback: HSV green range
-            hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
-            lower_green = np.array([40, 40, 40])
-            upper_green = np.array([80, 255, 255])
-            alpha = cv2.bitwise_not(cv2.inRange(hsv, lower_green, upper_green))
-
-        # 3) soft edges + refinement
-        if edge_softness > 0:
-            k = edge_softness * 2 + 1
-            alpha = cv2.GaussianBlur(alpha, (k, k), 0)
-        alpha = self._refine_alpha_edges(frame, alpha, radius=max(1, edge_softness), iters=1)
-
-        # 4) temporal smoothing
-        if self._alpha_prev is not None and self._alpha_prev.shape == alpha.shape:
-            alpha = cv2.addWeighted(alpha, 0.75, self._alpha_prev, 0.25, 0)
-        self._alpha_prev = alpha
-
-        # 5) composite - COMPOSITING FIX: Normalize scales
-        mask_3ch = cv2.cvtColor(alpha, cv2.COLOR_GRAY2BGR).astype(np.float32) / 255.0
-        frame_norm = frame.astype(np.float32) / 255.0
-        bg_norm = bg.astype(np.float32) / 255.0
-        out = frame_norm * mask_3ch + bg_norm * (1.0 - mask_3ch)
-        return np.clip(out * 255.0, 0, 255).astype(np.uint8)
-
-    def _hybrid_composite(self, frame, bg, mask, *, tolerance=38, edge_softness=2, spill_suppression=0.35, key_bgr: Optional[np.ndarray] = None):
-        """Apply hybrid compositing using both chroma key and cached mask, with profile controls."""
-        chroma_result = self._chroma_key_composite(
-            frame, bg,
-            tolerance=tolerance,
-            edge_softness=edge_softness,
-            spill_suppression=spill_suppression,
-            key_bgr=key_bgr
-        )
-
-        if mask is None:
-            return chroma_result
-
-        # profile-driven dilate/feather on cached mask to close pinholes + soften edges
-        m = mask
-        d = int(self.q['mask_dilate'])
-        if d > 0:
-            k = 2*d + 1
-            se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
-            m = cv2.dilate(m, se, iterations=1)
-        b = int(self.q['mask_blur'])
-        if b > 0:
-            m = cv2.GaussianBlur(m, (2*b+1, 2*b+1), 0)
+            logger.error(f"Stage 2 failed: {e}")
+            logger.error(traceback.format_exc())
+            return None
 
-        m3 = cv2.cvtColor(m, cv2.COLOR_GRAY2BGR) if m.ndim == 2 else m
-        m3f = (m3.astype(np.float32) / 255.0)
+    def _professional_chroma_key(self, frame, background):
+        """Professional chroma key for green screen removal."""
+        # Convert to HSV for better green detection
+        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
         
-        # COMPOSITING FIX: Normalize scales
-        frame_norm = frame.astype(np.float32) / 255.0
-        bg_norm = bg.astype(np.float32) / 255.0
-        seg_comp = frame_norm * m3f + bg_norm * (1.0 - m3f)
+        # Define green color range in HSV
+        # Green hue is around 60 in OpenCV HSV (0-179 range)
+        lower_green = np.array([40, 40, 40])    # Lower bound
+        upper_green = np.array([80, 255, 255])  # Upper bound
         
-        mix = float(self.q['hybrid_mix']) # weight towards segmentation on "max"
-        out = chroma_result.astype(np.float32) * (1.0 - mix) + (seg_comp * 255.0) * mix
-        return np.clip(out, 0, 255).astype(np.uint8)
-
-    # ---------------------------------------------------------------------
-    # Combined pipeline
-    # ---------------------------------------------------------------------
-    def process_full_pipeline(
-        self,
-        video_path: str,
-        background: np.ndarray | str,
-        output_path: str,
-        *,
-        key_color_mode: str = "auto",
-        chroma_settings: Optional[Dict[str, Any]] = None,
-        progress_callback: Optional[Callable[[float, str], None]] = None,
-        stop_event: Optional[threading.Event] = None,
-    ) -> Tuple[Optional[str], Optional[str], str]:
-        """Run both stages in sequence, return final, green, msg."""
-        def _combined_progress(pct, desc):
-            # Scale progress: Stage 1 is 0-50%, Stage 2 is 50-100%
-            if "Stage 1" in desc:
-                actual_pct = pct * 0.5
-            else: # Stage 2
-                actual_pct = 0.5 + pct * 0.5
-            if progress_callback:
-                try:
-                    progress_callback(actual_pct, desc)
-                except Exception:
-                    pass
+        # Create mask for green pixels
+        green_mask = cv2.inRange(hsv, lower_green, upper_green)
+        
+        # Smooth the mask
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+        green_mask = cv2.morphologyEx(green_mask, cv2.MORPH_OPEN, kernel)
+        green_mask = cv2.morphologyEx(green_mask, cv2.MORPH_CLOSE, kernel)
+        
+        # Blur for soft edges
+        green_mask = cv2.GaussianBlur(green_mask, (5, 5), 0)
+        
+        # Convert mask to 3-channel and normalize
+        green_mask_3ch = cv2.merge([green_mask, green_mask, green_mask])
+        alpha = green_mask_3ch.astype(np.float32) / 255.0
+        
+        # Composite: background where green, original where not green
+        result = (background.astype(np.float32) * alpha + 
+                 frame.astype(np.float32) * (1 - alpha)).astype(np.uint8)
+        
+        return result
 
+    def _prepare_background(self, background_image_path: Optional[str], background_preset: str) -> Optional[np.ndarray]:
+        """Prepare background image from file or preset."""
         try:
-            # pick up any new new quality selection once per run
-            quality_manager.load_profile()
-            self.q = quality_manager.get_params()
-
-            # Reset per-video state
-            self._mat_bootstrapped = False
-            self._alpha_prev = None
-            self.total_frames_processed = 0
-            self.frames_refined = 0
-          
-            if self.matanyone is not None and hasattr(self.matanyone, "reset"):
-                try:
-                    self.matanyone.reset()
-                except Exception:
-                    pass
-
-            # Stage 1 - use persistent path for green screen
-            green_path = os.path.splitext(output_path)[0] + '_green.mp4'
-            stage1_result, stage1_msg = self.stage1_extract_to_greenscreen(
-                video_path, green_path,
-                key_color_mode=key_color_mode,
-                progress_callback=_combined_progress,
-                stop_event=stop_event
-            )
+            if background_image_path and os.path.exists(background_image_path):
+                logger.info(f"Loading custom background: {background_image_path}")
+                background = cv2.imread(background_image_path)
+                if background is not None:
+                    return background
+                logger.warning(f"Failed to load custom background, falling back to preset")
+            
+            # Generate preset background
+            logger.info(f"Using preset background: {background_preset}")
+            return self._generate_preset_background(background_preset)
+            
+        except Exception as e:
+            logger.error(f"Background preparation failed: {e}")
+            return None
 
-            if stage1_result is None:
-                return None, None, stage1_msg
+    def _generate_preset_background(self, preset: str) -> np.ndarray:
+        """Generate preset background (fallback implementation)."""
+        # Simple solid color backgrounds
+        color_map = {
+            "office": (240, 240, 240),     # Light gray
+            "blue": (255, 200, 100),       # Light blue
+            "studio": (200, 200, 200),     # Medium gray  
+            "white": (255, 255, 255),      # White
+            "black": (0, 0, 0)             # Black
+        }
+        
+        color = color_map.get(preset, (240, 240, 240))  # Default to office
+        background = np.full((720, 1280, 3), color, dtype=np.uint8)  # Default size
+        
+        logger.info(f"Generated {preset} background with color {color}")
+        return background
 
-            # Stage 2 (pass through chosen key color)
-            key_bgr = np.array(stage1_result.get("key_bgr", [0,255,0]), dtype=np.uint8)
-            final_path, stage2_msg = self.stage2_greenscreen_to_final(
-                green_path, background, output_path,
-                chroma_settings=chroma_settings,
-                progress_callback=_combined_progress,
-                stop_event=stop_event,
-                key_bgr=key_bgr,
+    def _cleanup(self):
+        """Clean up temporary files."""
+        try:
+            for file_path in self._cleanup_list:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+                    logger.debug(f"Cleaned up: {file_path}")
+            
+            if self.temp_dir and os.path.exists(self.temp_dir):
+                import shutil
+                shutil.rmtree(self.temp_dir)
+                logger.debug(f"Cleaned up temp directory: {self.temp_dir}")
+                
+        except Exception as e:
+            logger.warning(f"Cleanup failed: {e}")
+
+class BasicSAM2Wrapper:
+    """Wrapper for basic SAM2 predictor to provide create_mask interface with debug."""
+    
+    def __init__(self, predictor):
+        self.predictor = predictor
+        logger.info("DEBUG: Created BasicSAM2Wrapper for compatibility")
+    
+    def create_mask(self, frame_rgb):
+        """Basic mask creation using center point prompt with debug outputs."""
+        try:
+            logger.info("DEBUG: BasicSAM2Wrapper.create_mask() called")
+            logger.info(f"DEBUG: BasicSAM2Wrapper input frame shape: {frame_rgb.shape}")
+            
+            self.predictor.set_image(frame_rgb)
+            
+            # Simple center point prompt
+            h, w = frame_rgb.shape[:2]
+            center_point = np.array([[w//2, h//2]])
+            center_label = np.array([1])
+            
+            masks, scores, _ = self.predictor.predict(
+                point_coords=center_point,
+                point_labels=center_label,
+                multimask_output=True
             )
-
-            # Report quality impact
-            logger.info(f"Pipeline complete with quality='{quality_manager.profile_name}': "
-                       f"{self.total_frames_processed} frames, "
-                       f"{self.frames_refined} refined ({100*self.frames_refined/max(1,self.total_frames_processed):.1f}%)")
-
-            return final_path, green_path, stage2_msg
-
+            
+            if len(masks) > 0:
+                # Select best mask by score
+                best_idx = np.argmax(scores)
+                mask = masks[best_idx].astype(np.float32)
+                
+                logger.info(f"DEBUG: BasicSAM2Wrapper generated {len(masks)} masks")
+                logger.info(f"DEBUG: BasicSAM2Wrapper selected mask {best_idx} with score {scores[best_idx]:.3f}")
+                logger.info(f"DEBUG: BasicSAM2Wrapper mask has {np.count_nonzero(mask)} non-zero pixels")
+                
+                # Save debug mask
+                debug_mask = (mask * 255).astype(np.uint8)
+                cv2.imwrite("/tmp/debug_basic_sam2_wrapper_mask.png", debug_mask)
+                logger.info("DEBUG: Saved BasicSAM2Wrapper mask to /tmp/debug_basic_sam2_wrapper_mask.png")
+                
+                return mask
+            
+            logger.warning("DEBUG: BasicSAM2Wrapper - No masks generated")
+            return None
+            
         except Exception as e:
-            logger.error(f"Full pipeline error: {e}\n{traceback.format_exc()}")
-            return None, None, f"Pipeline failed: {e}"
+            logger.error(f"DEBUG: BasicSAM2Wrapper failed: {e}")
+            logger.error(f"DEBUG: BasicSAM2Wrapper traceback: {traceback.format_exc()}")
+            return None