Update processing/two_stage/two_stage_processor.py

processing/two_stage/two_stage_processor.py

@@ -1,26 +1,25 @@
 #!/usr/bin/env python3
 """
-Two-Stage Green-Screen Processing System  ✅ 2025-08-29
+Two-Stage Green-Screen Processing System ✅ 2025-08-29
 Stage 1: Original → keyed background (auto-selected colour)
-Stage 2: Keyed video → final composite  (hybrid chroma + segmentation rescue)
-
+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
 """
 from __future__ import annotations
-
 import cv2, numpy as np, os, gc, pickle, logging, tempfile, traceback, threading
 from pathlib import Path
-from typing import Optional, Dict, Any, Callable, Tuple, List
-
 from utils.cv_processing import segment_person_hq, refine_mask_hq
-
+from quality_manager import quality_manager  # New quality manager import
 # Project logger if available
 try:
     from utils.logger import get_logger
     logger = get_logger(__name__)
 except Exception:
     logger = logging.getLogger(__name__)
-
 # ---------------------------------------------------------------------------
 # Local video-writer helper with frame count guarantee
 # ---------------------------------------------------------------------------
@@ -34,7 +33,6 @@ def create_video_writer(output_path: str, fps: float, width: int, height: int, p
             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():
@@ -49,28 +47,27 @@ def create_video_writer(output_path: str, fps: float, width: int, height: int, p
     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:
@@ -81,7 +78,7 @@ def write(self, frame):
                 logger.warning(f"Frame write failed: {e}")
                 return False
         return True
-    
+   
     def release(self):
         """Flush remaining frames and close"""
         # Write any remaining buffered frames
@@ -92,14 +89,31 @@ def release(self):
                 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)
@@ -107,7 +121,6 @@ def release(self):
                 logger.error("WARNING: Output file is empty!")
             else:
                 logger.info(f"Output file size: {size:,} bytes")
-
 # ---------------------------------------------------------------------------
 # Key-colour helpers (fast, no external deps)
 # ---------------------------------------------------------------------------
@@ -115,32 +128,27 @@ 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},
+        "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"]
@@ -150,49 +158,14 @@ def _choose_best_key_color(frame_bgr: np.ndarray, mask_uint8: np.ndarray) -> dic
         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},
+    '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},
 }
-
-# ---------------------------------------------------------------------------
-# ENHANCED Quality profiles with clear differentiation
-# ---------------------------------------------------------------------------
-QUALITY_PROFILES: Dict[str, Dict[str, Any]] = {
-    "speed": dict(
-        refine_stride=10,  # Refine every 10th frame only
-        spill=0.15,        # Minimal spill work
-        edge_softness=1,   # Basic edges
-        mix=0.50,          # 50/50 chroma/segmentation
-        dilate=1,          # Minimal morphology
-        blur=0,            # No blur
-        bg_sigma=0.0       # No background blur
-    ),
-    "balanced": dict(
-        refine_stride=3,   # Refine every 3rd frame
-        spill=0.35,        # Moderate spill removal
-        edge_softness=2,   # Smooth edges
-        mix=0.70,          # Favor segmentation (70%)
-        dilate=2,          # Some hole filling
-        blur=1,            # Light feathering
-        bg_sigma=0.8       # Subtle background blur
-    ),
-    "max": dict(
-        refine_stride=1,   # Refine EVERY frame
-        spill=0.50,        # Strong spill removal
-        edge_softness=3,   # Very smooth edges
-        mix=0.85,          # Heavy segmentation bias (85%)
-        dilate=3,          # Strong hole filling
-        blur=2,            # More feathering
-        bg_sigma=1.5       # Visible background blur
-    ),
-}
-
 # ---------------------------------------------------------------------------
 # Two-Stage Processor
 # ---------------------------------------------------------------------------
@@ -202,29 +175,18 @@ def __init__(self, sam2_predictor=None, matanyone_model=None):
         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
-        
+        self._alpha_prev: Optional[np.ndarray] = None # temporal smoothing
+       
         # Frame tracking
         self.total_frames_processed = 0
         self.frames_refined = 0
-
-        # Quality selection at construction
-        qname = os.getenv("BFX_QUALITY", "balanced").strip().lower()
-        if qname not in QUALITY_PROFILES:
-            qname = "balanced"
-        self.quality = qname
-        self.q = QUALITY_PROFILES[qname]
-        
-        # Log quality details
-        logger.info(f"TwoStageProcessor quality='{self.quality}' ⇒ refine_every={self.q['refine_stride']}, "
-                   f"spill={self.q['spill']:.2f}, mix={self.q['mix']:.2f}, bg_blur={self.q['bg_sigma']:.1f}")
+       
+        # 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:
@@ -232,20 +194,6 @@ def _unwrap_sam2(self, predictor):
         if hasattr(predictor, 'sam_predictor'):
             return predictor.sam_predictor
         return predictor
-
-    def _refresh_quality_from_env(self):
-        """Pick up UI changes to BFX_QUALITY without rebuilding models."""
-        qname = os.getenv("BFX_QUALITY", self.quality).strip().lower()
-        if qname not in QUALITY_PROFILES:
-            qname = "balanced"
-        if qname != getattr(self, "quality", None) or not hasattr(self, "q"):
-            old_quality = self.quality
-            self.quality = qname
-            self.q = QUALITY_PROFILES[qname]
-            logger.info(f"Quality switched from '{old_quality}' to '{self.quality}' ⇒ "
-                       f"refine_every={self.q['refine_stride']}, spill={self.q['spill']:.2f}, "
-                       f"mix={self.q['mix']:.2f}, bg_blur={self.q['bg_sigma']:.1f}")
-
     def _get_mask(self, frame: np.ndarray) -> np.ndarray:
         """Get segmentation mask using SAM2 (delegates to project helper)."""
         if self.sam2 is None:
@@ -253,7 +201,6 @@ def _get_mask(self, frame: np.ndarray) -> np.ndarray:
             gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
             _, mask = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
             return mask
-
         try:
             mask = segment_person_hq(frame, self.sam2)
             # segment_person_hq returns either uint8(0..255) or float(0..1) in most builds
@@ -263,7 +210,6 @@ def _get_mask(self, frame: np.ndarray) -> np.ndarray:
             gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
             _, mask = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
             return mask
-
     @staticmethod
     def _to_binary_mask(mask: np.ndarray) -> Optional[np.ndarray]:
         """Convert mask to uint8(0..255)."""
@@ -275,7 +221,6 @@ def _to_binary_mask(mask: np.ndarray) -> Optional[np.ndarray]:
             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)."""
@@ -287,14 +232,13 @@ def _to_float01(mask: np.ndarray, h: int = None, w: int = None) -> Optional[np.n
         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)
-
-    def _apply_greenscreen_hard(self, frame: np.ndarray, mask: np.ndarray, bg: np.ndarray) -> np.ndarray:
+    @staticmethod
+    def _apply_greenscreen_hard(frame: np.ndarray, mask: np.ndarray, bg: np.ndarray) -> np.ndarray:
         """Apply hard greenscreen compositing."""
         mask_3ch = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR) if mask.ndim == 2 else mask
         mask_norm = mask_3ch.astype(np.float32) / 255.0
         result = frame * mask_norm + bg * (1 - mask_norm)
         return result.astype(np.uint8)
-
     # -------- improved spill suppression (preserves luminance & skin) --------
     def _suppress_green_spill(self, frame: np.ndarray, amount: float = 0.35) -> np.ndarray:
         """
@@ -305,11 +249,10 @@ def _suppress_green_spill(self, frame: np.ndarray, amount: float = 0.35) -> np.n
         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
+        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:
         """
@@ -319,11 +262,9 @@ def _refine_alpha_edges(self, frame_bgr: np.ndarray, alpha_u8: np.ndarray, radiu
         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))
@@ -331,9 +272,7 @@ def _refine_alpha_edges(self, frame_bgr: np.ndarray, alpha_u8: np.ndarray, radiu
             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:
         """
@@ -341,14 +280,12 @@ def _soft_key_mask(self, frame_bgr: np.ndarray, key_bgr: np.ndarray, tol: int =
         """
         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)
+        alpha = 255.0 * np.clip((d - tol) / (tol*1.7), 0.0, 1.0) # far from key = keep (255)
         return alpha.astype(np.uint8)
-
     # --------------------- MatAnyone bootstrap ----------------------
     def _bootstrap_matanyone_if_needed(self, frame_bgr: np.ndarray, coarse_mask: np.ndarray):
         """
@@ -361,94 +298,80 @@ def _bootstrap_matanyone_if_needed(self, frame_bgr: np.ndarray, coarse_mask: np.
             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 alpha
+            _ = self.matanyone(rgb, mask_f) # boot only; ignore returned returned alpha
             self._mat_bootstrapped = True
             logger.info("MatAnyone session bootstrapped with first-frame mask.")
         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
-            
-        stride = max(1, int(self.q.get("refine_stride", 3)))
-        return (frame_idx % stride) == 0
-
+           
+        return quality_manager.should_refine_frame(frame_idx)
     # ---------------------------------------------------------------------
-    # Stage 1 – Original → keyed (green/blue/…)  -- chooses colour on 1st frame
+    # 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"
+        key_color_mode: str = "auto", # "auto" | "green" | "blue" | "cyan" | "magenta"
         progress_callback: Optional[Callable[[float, str], None]] = None,
-        stop_event: Optional["threading.Event"] = 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
-
         try:
             # pick up any new quality selection
-            self._refresh_quality_from_env()
-
+            quality_manager.load_profile()  # Refresh
+            self.q = quality_manager.get_params()
             _prog(0.0, "Stage 1: opening video…")
             cap = cv2.VideoCapture(video_path)
             if not cap.isOpened():
                 return None, "Could not open input video"
-
-            fps   = cap.get(cv2.CAP_PROP_FPS) or 25.0
+            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))
-
+            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)  # default
+            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
-
+            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:
                     break
-
                 # --- SAM2 segmentation ---
                 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":
@@ -460,33 +383,28 @@ def _prog(p, d):
                             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:
                         mask = refine_mask_hq(frame, mask, self.matanyone, fallback_enabled=True)
                         self.frames_refined += 1
-                        logger.debug(f"Frame {frame_idx}: Refined (quality={self.quality})")
+                        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}")
                 else:
-                    logger.debug(f"Frame {frame_idx}: Skipped refinement (cadence={self.q['refine_stride']})")
-
+                    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})")
-
             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")
@@ -495,24 +413,21 @@ def _prog(p, d):
                 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)"
             )
-
         except Exception as e:
             logger.error(f"Stage 1 error: {e}\n{traceback.format_exc()}")
             return None, f"Stage 1 failed: {e}"
-
     # ---------------------------------------------------------------------
-    # Stage 2 – keyed video → final composite  (hybrid matte)
+    # Stage 2 – keyed video → final composite (hybrid matte)
     # ---------------------------------------------------------------------
     def stage2_greenscreen_to_final(
         self,
@@ -522,31 +437,27 @@ def stage2_greenscreen_to_final(
         *,
         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
+        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
-
         try:
             # pick up any new quality selection
-            self._refresh_quality_from_env()
-
+            quality_manager.load_profile()
+            self.q = quality_manager.get_params()
             _prog(0.0, "Stage 2: opening keyed video…")
             cap = cv2.VideoCapture(gs_path)
             if not cap.isOpened():
                 return None, "Could not open keyed video"
-
-            fps   = cap.get(cv2.CAP_PROP_FPS) or 25.0
+            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))
-
+            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)
@@ -556,21 +467,18 @@ def _prog(p, d):
                 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.get("bg_sigma", 0.0))
+            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:
@@ -581,29 +489,23 @@ def _prog(p, d):
                     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(settings.get('tolerance', 38))  # keep user tolerance
-            edge_softness = int(self.q.get('edge_softness', settings.get('edge_softness', 2)))
-            spill_suppression = float(self.q.get('spill', settings.get('spill_suppression', 0.35)))
-
+            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
-
+            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:
                     break
-
                 # Apply chroma keying with optional mask assistance
                 if masks and frame_idx < len(masks):
                     mask = masks[frame_idx]
@@ -623,34 +525,28 @@ def _prog(p, d):
                         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 '?'}")
-
             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)"
-
         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))
@@ -660,23 +556,19 @@ def _chroma_key_composite(self, frame, bg, *, tolerance=38, edge_softness=2, spi
             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
         mask_3ch = cv2.cvtColor(alpha, cv2.COLOR_GRAY2BGR).astype(np.float32) / 255.0
         out = frame.astype(np.float32) * mask_3ch + bg.astype(np.float32) * (1.0 - mask_3ch)
         return np.clip(out, 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(
@@ -688,27 +580,22 @@ def _hybrid_composite(self, frame, bg, mask, *, tolerance=38, edge_softness=2, s
         )
         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.get("dilate", 0))
+        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.get("blur", 0))
+        b = int(self.q['mask_blur'])
         if b > 0:
             m = cv2.GaussianBlur(m, (2*b+1, 2*b+1), 0)
-
         m3 = cv2.cvtColor(m, cv2.COLOR_GRAY2BGR) if m.ndim == 2 else m
         m3f = (m3.astype(np.float32) / 255.0)
-
         seg_comp = frame.astype(np.float32) * m3f + bg.astype(np.float32) * (1.0 - m3f)
-
-        mix = float(self.q.get("mix", 0.7))  # weight towards segmentation on "max"
+        mix = float(self.q['hybrid_mix']) # weight towards segmentation on "max"
         out = chroma_result.astype(np.float32) * (1.0 - mix) + seg_comp * mix
         return np.clip(out, 0, 255).astype(np.uint8)
-
     # ---------------------------------------------------------------------
     # Combined pipeline
     # ---------------------------------------------------------------------
@@ -721,73 +608,59 @@ def process_full_pipeline(
         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], str]:
-        """Run both stages in sequence."""
-
+        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
+            else: # Stage 2
                 actual_pct = 0.5 + pct * 0.5
-
             if progress_callback:
                 try:
                     progress_callback(actual_pct, desc)
                 except Exception:
                     pass
-
         try:
-            # pick up any new quality selection once per run
-            self._refresh_quality_from_env()
-
+            # 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
-            temp_gs_path = tempfile.mktemp(suffix="_greenscreen.mp4")
+            # 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, temp_gs_path,
+                video_path, green_path,
                 key_color_mode=key_color_mode,
                 progress_callback=_combined_progress,
                 stop_event=stop_event
             )
             if stage1_result is None:
-                return None, stage1_msg
-
+                return None, None, stage1_msg
             # 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(
-                stage1_result["path"], background, output_path,
+                green_path, background, output_path,
                 chroma_settings=chroma_settings,
                 progress_callback=_combined_progress,
                 stop_event=stop_event,
                 key_bgr=key_bgr,
             )
-
-            # Clean up temp file
-            try:
-                os.remove(temp_gs_path)
-            except Exception:
-                pass
-
             # Report quality impact
-            logger.info(f"Pipeline complete with quality='{self.quality}': "
+            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, stage2_msg
-
+            return final_path, green_path, stage2_msg
         except Exception as e:
             logger.error(f"Full pipeline error: {e}\n{traceback.format_exc()}")
-            return None, f"Pipeline failed: {e}"
+            return None, None, f"Pipeline failed: {e}"