Update app.py

app.py

@@ -1,38 +1,34 @@
 #!/usr/bin/env python3
 """
-Final Fixed Video Background Replacement
-Uses proper functions from utilities.py to avoid transparency issues
-NEW: Added automatic device detection for Hugging Face Spaces compatibility,
-     improved error handling, and better resource management
-FIXED: All issues identified by Grok4 - robust error handling, variable scope, codec fallbacks
-FIXED: Added SSR mode disable for Gradio compatibility
-FIXED: Audio preservation - no more missing audio in processed videos
-UPDATE: Enhanced logging for initialization errors, isolated matanyone imports to avoid GUI crashes
+Video Background Replacement - Main Application
+Refactored version with improved error handling, memory management, and configuration
 """
+
+import os
 import cv2
 import numpy as np
-from pathlib import Path
 import torch
-import traceback
 import time
-import shutil
-import gc
+import logging
 import threading
 import subprocess
-from typing import Optional, Tuple, Dict, Any
-import logging
-from huggingface_hub import hf_hub_download
-import os
+from pathlib import Path
+from typing import Optional, Tuple, Dict, Any, Callable
+from dataclasses import dataclass
 
-# ============================================================================ #
-# CRITICAL: GRADIO SCHEMA VALIDATION FIX - MUST BE FIRST
-# ============================================================================ #
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Apply Gradio schema patch early
 try:
     import gradio_client.utils as gc_utils
     original_get_type = gc_utils.get_type
     
     def patched_get_type(schema):
-        """Fixed get_type function that handles boolean schemas properly"""
         if not isinstance(schema, dict):
             if isinstance(schema, bool):
                 return "boolean"
@@ -40,843 +36,625 @@ def patched_get_type(schema):
                 return "string"
             if isinstance(schema, (int, float)):
                 return "number"
-            return "string"  # fallback
-        
-        # If it's a dict, use original function
+            return "string"
         return original_get_type(schema)
     
     gc_utils.get_type = patched_get_type
-    print("✅ CRITICAL: Gradio schema patch applied successfully!")
-    
-except (ImportError, AttributeError) as e:
-    print(f"❌ CRITICAL: Gradio patch failed: {e}")
+    logger.info("Gradio schema patch applied successfully")
+except Exception as e:
     logger.error(f"Gradio patch failed: {e}")
 
-# Import utilities - CRITICAL: Use these functions, don't duplicate!
+# Import core modules
 from utilities import (
     segment_person_hq,
     refine_mask_hq,
-    enhance_mask_opencv,
     replace_background_hq,
     create_professional_background,
     PROFESSIONAL_BACKGROUNDS,
     validate_video_file
 )
 
-# Import two-stage processor if available
 try:
     from two_stage_processor import TwoStageProcessor, CHROMA_PRESETS
     TWO_STAGE_AVAILABLE = True
-    logger.info("Two-stage processor available")
-except ImportError as e:
+except ImportError:
     TWO_STAGE_AVAILABLE = False
-    logger.warning(f"Two-stage processor not available: {e}")
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ============================================================================ #
-# OPTIMIZATION SETTINGS
-# ============================================================================ #
-KEYFRAME_INTERVAL = 5  # Process MatAnyone every 5th frame
-FRAME_SKIP = 1        # Process every frame (set to 2 for every other frame)
-MEMORY_CLEANUP_INTERVAL = 30  # Clean memory every 30 frames
-
-# ============================================================================ #
-# MODEL CACHING SYSTEM
-# ============================================================================ #
-CACHE_DIR = Path("/tmp/model_cache")
-CACHE_DIR.mkdir(exist_ok=True, parents=True)
-
-# ============================================================================ #
-# GLOBAL MODEL STATE
-# ============================================================================ #
-sam2_predictor = None
-matanyone_model = None
-models_loaded = False
-loading_lock = threading.Lock()
-two_stage_processor = None
-PROCESS_CANCELLED = threading.Event()
-
-# ============================================================================ #
-# DEVICE DETECTION FOR HUGGING FACE SPACES - ROBUST
-# ============================================================================ #
-def get_device():
-    """Automatically detect the best available device (CPU or GPU) with robust error handling"""
-    try:
+    CHROMA_PRESETS = {'standard': {}}
+
+# Configuration
+@dataclass
+class ProcessingConfig:
+    keyframe_interval: int = int(os.getenv('KEYFRAME_INTERVAL', '5'))
+    frame_skip: int = int(os.getenv('FRAME_SKIP', '1'))
+    memory_cleanup_interval: int = int(os.getenv('MEMORY_CLEANUP_INTERVAL', '30'))
+    max_video_length: int = int(os.getenv('MAX_VIDEO_LENGTH', '300'))  # seconds
+    quality_preset: str = os.getenv('QUALITY_PRESET', 'balanced')
+
+class DeviceManager:
+    """Manage device detection and switching"""
+    
+    @staticmethod
+    def get_optimal_device():
         if torch.cuda.is_available():
             try:
-                device_name = torch.cuda.get_device_name(0)
-                logger.info(f"Using GPU: {device_name}")
-            except Exception as e:
-                logger.warning(f"Could not get GPU name: {e}, but CUDA is available")
-                device_name = "CUDA GPU"
-            
-            try:
+                # Test CUDA functionality
                 test_tensor = torch.tensor([1.0], device='cuda')
                 del test_tensor
                 torch.cuda.empty_cache()
-                return torch.device("cuda")
+                device = torch.device("cuda")
+                logger.info(f"Using GPU: {torch.cuda.get_device_name(0)}")
+                return device
             except Exception as e:
-                logger.error(f"CUDA test failed: {e}, falling back to CPU")
-                return torch.device("cpu")
-        else:
-            logger.info("Using CPU (no GPU available)")
-            return torch.device("cpu")
-    except Exception as e:
-        logger.error(f"Device detection failed: {e}, defaulting to CPU")
+                logger.warning(f"CUDA test failed: {e}, falling back to CPU")
+        
+        logger.info("Using CPU device")
         return torch.device("cpu")
 
-# Set the device globally
-DEVICE = get_device()
-
-# ============================================================================ #
-# ROBUST FFMPEG OPERATIONS
-# ============================================================================ #
-def run_ffmpeg_command(command_args: list, description: str = "FFmpeg operation") -> bool:
-    """Run ffmpeg command with proper error handling"""
-    try:
-        logger.info(f"Running {description}: {' '.join(command_args)}")
-        result = subprocess.run(
-            command_args,
-            check=True,
-            capture_output=True,
-            text=True,
-            timeout=300  # 5 minute timeout
+class MemoryManager:
+    """Enhanced memory management"""
+    
+    def __init__(self, device):
+        self.device = device
+        self.gpu_available = device.type == 'cuda'
+        
+    def cleanup_aggressive(self):
+        import gc
+        gc.collect()
+        if self.gpu_available:
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+    
+    def get_memory_usage(self):
+        usage = {}
+        if self.gpu_available:
+            gpu_memory = torch.cuda.get_device_properties(0).total_memory
+            gpu_allocated = torch.cuda.memory_allocated(0)
+            usage['gpu_percent'] = (gpu_allocated / gpu_memory) * 100
+            usage['gpu_allocated_gb'] = gpu_allocated / (1024**3)
+        return usage
+
+class ProgressTracker:
+    """Enhanced progress tracking with detailed statistics"""
+    
+    def __init__(self, total_frames: int, callback: Optional[Callable] = None):
+        self.total_frames = total_frames
+        self.callback = callback
+        self.start_time = time.time()
+        self.processed_frames = 0
+        self.frame_times = []
+        
+    def update(self, frame_number: int, stage: str = ""):
+        current_time = time.time()
+        self.processed_frames = frame_number
+        
+        elapsed_time = current_time - self.start_time
+        current_fps = self.processed_frames / elapsed_time if elapsed_time > 0 else 0
+        
+        remaining_frames = self.total_frames - self.processed_frames
+        eta_seconds = remaining_frames / current_fps if current_fps > 0 else 0
+        
+        progress_pct = self.processed_frames / self.total_frames if self.total_frames > 0 else 0
+        
+        message = (
+            f"Frame {self.processed_frames}/{self.total_frames} | "
+            f"Elapsed: {self._format_time(elapsed_time)} | "
+            f"Speed: {current_fps:.1f} fps | "
+            f"ETA: {self._format_time(eta_seconds)}"
         )
-        logger.info(f"{description} completed successfully")
-        return True
-    except subprocess.CalledProcessError as e:
-        logger.error(f"{description} failed with exit code {e.returncode}")
-        logger.error(f"STDERR: {e.stderr}")
-        return False
-    except subprocess.TimeoutExpired:
-        logger.error(f"{description} timed out")
-        return False
-    except Exception as e:
-        logger.error(f"{description} failed: {e}")
-        return False
+        
+        if stage:
+            message = f"{stage} | {message}"
+            
+        if self.callback:
+            try:
+                self.callback(progress_pct, message)
+            except Exception as e:
+                logger.warning(f"Progress callback failed: {e}")
+    
+    def _format_time(self, seconds: float) -> str:
+        if seconds < 60:
+            return f"{int(seconds)}s"
+        elif seconds < 3600:
+            return f"{int(seconds//60)}m {int(seconds%60)}s"
+        else:
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            return f"{hours}h {minutes}m"
 
-# ============================================================================ #
-# ROBUST VIDEO WRITER WITH CODEC FALLBACK
-# ============================================================================ #
-def create_video_writer(output_path: str, fps: float, width: int, height: int) -> Tuple[Optional[cv2.VideoWriter], Optional[str]]:
-    """Create video writer with codec fallback"""
-    codecs_to_try = [
-        ('mp4v', '.mp4'),  # Most compatible
-        ('avc1', '.mp4'),  # H.264 if available
-        ('XVID', '.avi'),  # Fallback
-    ]
+class VideoProcessor:
+    """Main video processing class with error recovery"""
     
-    for fourcc_str, ext in codecs_to_try:
-        try:
-            fourcc = cv2.VideoWriter_fourcc(*fourcc_str)
-            if not output_path.endswith(ext):
-                base = os.path.splitext(output_path)[0]
-                test_path = base + ext
-            else:
-                test_path = output_path
+    def __init__(self):
+        self.device = DeviceManager.get_optimal_device()
+        self.memory_manager = MemoryManager(self.device)
+        self.config = ProcessingConfig()
+        self.sam2_predictor = None
+        self.matanyone_model = None
+        self.two_stage_processor = None
+        self.models_loaded = False
+        self.loading_lock = threading.Lock()
+        self.cancel_event = threading.Event()
+        
+    def load_models(self, progress_callback: Optional[Callable] = None) -> str:
+        """Load AI models with comprehensive validation"""
+        with self.loading_lock:
+            if self.models_loaded:
+                return "Models already loaded and validated"
+            
+            try:
+                self.cancel_event.clear()
+                start_time = time.time()
                 
-            writer = cv2.VideoWriter(test_path, fourcc, fps, (width, height))
-            if writer.isOpened():
-                logger.info(f"Successfully created video writer with {fourcc_str} codec")
-                return writer, test_path
-            else:
-                writer.release()
-        except Exception as e:
-            logger.warning(f"Failed to create writer with {fourcc_str}: {e}")
+                if progress_callback:
+                    progress_callback(0.0, f"Starting model loading on {self.device}")
+                
+                # Load SAM2
+                self.sam2_predictor = self._load_sam2(progress_callback)
+                if self.cancel_event.is_set():
+                    return "Model loading cancelled"
+                
+                # Load MatAnyone
+                self.matanyone_model = self._load_matanyone(progress_callback)
+                if self.cancel_event.is_set():
+                    return "Model loading cancelled"
+                
+                # Initialize two-stage processor if available
+                if TWO_STAGE_AVAILABLE:
+                    try:
+                        self.two_stage_processor = TwoStageProcessor(
+                            self.sam2_predictor, self.matanyone_model
+                        )
+                        logger.info("Two-stage processor initialized")
+                    except Exception as e:
+                        logger.warning(f"Two-stage processor init failed: {e}")
+                
+                self.models_loaded = True
+                load_time = time.time() - start_time
+                
+                message = f"Models loaded successfully in {load_time:.1f}s on {self.device}"
+                if TWO_STAGE_AVAILABLE:
+                    message += " (Two-stage mode available)"
+                    
+                logger.info(message)
+                return message
+                
+            except Exception as e:
+                self.models_loaded = False
+                error_msg = f"Model loading failed: {str(e)}"
+                logger.error(error_msg)
+                return error_msg
     
-    logger.error("All video codecs failed")
-    return None, None
-
-# ============================================================================ #
-# SAM2 LOADER WITH VALIDATION - ROBUST
-# ============================================================================ #
-def load_sam2_predictor_fixed(device: torch.device = DEVICE, progress_callback: Optional[callable] = None) -> Any:
-    """Load SAM2 with proper error handling and validation"""
-    def _prog(pct: float, desc: str):
+    def _load_sam2(self, progress_callback: Optional[Callable]) -> Any:
+        """Load SAM2 predictor with validation"""
         if progress_callback:
-            progress_callback(pct, desc)
-
-        if "Frame" in desc and "|" in desc:
-            parts = desc.split("|")
-            frame_info = parts[0].strip() if len(parts) > 0 else ""
-            time_info = parts[1].strip() if len(parts) > 1 else ""
-            fps_info = parts[2].strip() if len(parts) > 2 else ""
-            eta_info = parts[3].strip() if len(parts) > 3 else ""
-            display_text = f"""📊 PROCESSING STATUS
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎬 {frame_info}
-⏱️ Elapsed: {time_info}
-⚡ Speed: {fps_info}
-🎯 {eta_info}
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-📈 Progress: {pct*100:.1f}%"""
-            try:
-                with open("/tmp/processing_info.txt", 'w') as f:
-                    f.write(display_text)
-            except Exception as e:
-                logger.warning(f"Error writing processing info: {e}")
-
-    try:
-        _prog(0.1, "Initializing SAM2...")
-
-        hf_token = os.getenv('HF_TOKEN')
-        if not hf_token:
-            logger.warning("No HF_TOKEN found, downloads may be rate limited")
-
+            progress_callback(0.1, "Loading SAM2...")
+            
         try:
+            from huggingface_hub import hf_hub_download
+            from sam2.build_sam import build_sam2
+            from sam2.sam2_image_predictor import SAM2ImagePredictor
+            
+            # Download checkpoint
             checkpoint_path = hf_hub_download(
                 repo_id="facebook/sam2-hiera-large",
                 filename="sam2_hiera_large.pt",
-                cache_dir=str(CACHE_DIR / "sam2_checkpoint"),
-                force_download=False,
-                token=hf_token
+                cache_dir=str(Path("/tmp/model_cache/sam2_checkpoint")),
+                force_download=False
             )
-            logger.info(f"SAM2 checkpoint downloaded to {checkpoint_path}")
-        except Exception as e:
-            logger.error(f"Failed to download SAM2 checkpoint: {e}")
-            raise Exception(f"SAM2 checkpoint download failed: {e}")
-
-        try:
-            from sam2.build_sam import build_sam2
-            from sam2.sam2_image_predictor import SAM2ImagePredictor
-            logger.info("SAM2 modules imported successfully")
-        except ImportError as e:
-            logger.error(f"SAM2 import failed: {e}")
-            raise Exception(f"SAM2 import failed: {e}. Make sure SAM2 is properly installed.")
-
-        try:
+            
+            # Build model
             sam2_model = build_sam2("sam2_hiera_l.yaml", checkpoint_path)
-            sam2_model.to(device)
+            sam2_model.to(self.device)
             sam2_model.eval()
             predictor = SAM2ImagePredictor(sam2_model)
-            logger.info(f"SAM2 model built and moved to {device}")
-        except Exception as e:
-            logger.error(f"SAM2 model creation failed: {e}")
-            raise Exception(f"SAM2 model creation failed: {e}")
-
-        _prog(0.8, "Testing SAM2 functionality...")
-        test_image = np.zeros((256, 256, 3), dtype=np.uint8)
-        predictor.set_image(test_image)
-        
-        test_points = np.array([[128.0, 128.0]], dtype=np.float32)
-        test_labels = np.array([1], dtype=np.int32)
-        
-        try:
+            
+            # Validate with test
+            test_image = np.zeros((256, 256, 3), dtype=np.uint8)
+            predictor.set_image(test_image)
+            test_points = np.array([[128.0, 128.0]], dtype=np.float32)
+            test_labels = np.array([1], dtype=np.int32)
+            
             with torch.no_grad():
                 masks, scores, _ = predictor.predict(
                     point_coords=test_points,
                     point_labels=test_labels,
                     multimask_output=False
                 )
+            
+            if masks is None or len(masks) == 0:
+                raise Exception("SAM2 validation failed")
+                
+            if progress_callback:
+                progress_callback(0.5, "SAM2 loaded and validated")
+                
+            return predictor
+            
         except Exception as e:
-            logger.error(f"SAM2 prediction test failed: {e}")
-            raise Exception(f"SAM2 prediction test failed: {e}")
-
-        if masks is None or len(masks) == 0:
-            logger.error("SAM2 predictor test failed - no masks generated")
-            raise Exception("SAM2 predictor test failed - no masks generated")
-
-        _prog(1.0, "SAM2 loaded and validated successfully!")
-        logger.info(f"SAM2 predictor loaded and tested successfully on {device}")
-        return predictor
-
-    except Exception as e:
-        logger.error(f"SAM2 loading failed: {str(e)}")
-        logger.error(f"Full traceback: {traceback.format_exc()}")
-        raise Exception(f"SAM2 loading failed: {str(e)}")
-
-# ============================================================================ #
-# MATANYONE LOADER WITH VALIDATION - ROBUST
-# ============================================================================ #
-def load_matanyone_fixed(progress_callback: Optional[callable] = None) -> Any:
-    """Load MatAnyone with proper error handling and validation"""
-    def _prog(pct: float, desc: str):
+            logger.error(f"SAM2 loading failed: {e}")
+            raise
+    
+    def _load_matanyone(self, progress_callback: Optional[Callable]) -> Any:
+        """Load MatAnyone processor with validation"""
         if progress_callback:
-            progress_callback(pct, desc)
-
-    try:
-        _prog(0.2, "Loading MatAnyone...")
-
+            progress_callback(0.6, "Loading MatAnyone...")
+            
         try:
             from matanyone import InferenceCore
-            logger.info("Successfully imported MatAnyone InferenceCore")
-        except ImportError as e:
-            logger.error(f"MatAnyone import failed: {e}")
-            raise Exception(f"MatAnyone import failed: {e}. Make sure MatAnyone is properly installed.")
-
-        try:
             processor = InferenceCore("PeiqingYang/MatAnyone")
-            logger.info("MatAnyone InferenceCore initialized")
-        except Exception as e:
-            logger.error(f"MatAnyone model loading failed: {e}")
-            raise Exception(f"MatAnyone model loading failed: {e}")
-
-        _prog(0.8, "Testing MatAnyone functionality...")
-        test_image = np.zeros((256, 256, 3), dtype=np.uint8)
-        test_mask = np.zeros((256, 256), dtype=np.uint8)
-        test_mask[64:192, 64:192] = 255
-
-        try:
-            if hasattr(processor, 'process') or hasattr(processor, '__call__'):
-                logger.info("MatAnyone processor interface detected")
-            else:
-                logger.warning("MatAnyone interface unclear, will use fallback refinement")
-        except Exception as test_e:
-            logger.warning(f"MatAnyone test failed: {test_e}, will use enhanced OpenCV")
-
-        _prog(1.0, "MatAnyone loaded successfully!")
-        logger.info(f"MatAnyone processor loaded successfully on {DEVICE}")
-        return processor
-
-    except Exception as e:
-        logger.error(f"MatAnyone loading failed: {str(e)}")
-        logger.error(f"Full traceback: {traceback.format_exc()}")
-        raise Exception(f"MatAnyone loading failed: {str(e)}")
-
-# ============================================================================ #
-# MODEL MANAGEMENT FUNCTIONS
-# ============================================================================ #
-def get_model_status() -> Dict[str, str]:
-    """Return current model status for UI"""
-    global sam2_predictor, matanyone_model, models_loaded
-    return {
-        'sam2': 'Ready' if sam2_predictor is not None else 'Not loaded',
-        'matanyone': 'Ready' if matanyone_model is not None else 'Not loaded',
-        'validated': models_loaded,
-        'device': str(DEVICE)
-    }
-
-def get_cache_status() -> Dict[str, Any]:
-    """Get current cache status"""
-    return {
-        "sam2_loaded": sam2_predictor is not None,
-        "matanyone_loaded": matanyone_model is not None,
-        "models_validated": models_loaded,
-        "two_stage_available": TWO_STAGE_AVAILABLE,
-        "device": str(DEVICE)
-    }
-
-def load_models_with_validation(progress_callback: Optional[callable] = None) -> str:
-    """Load models with comprehensive validation"""
-    global sam2_predictor, matanyone_model, models_loaded, two_stage_processor, PROCESS_CANCELLED
-
-    with loading_lock:
-        if models_loaded and not PROCESS_CANCELLED.is_set():
-            logger.info("Models already loaded and validated")
-            return "Models already loaded and validated"
-
-        try:
-            PROCESS_CANCELLED.clear()
-            start_time = time.time()
-            logger.info(f"Starting model loading on {DEVICE}")
-
+            
             if progress_callback:
-                progress_callback(0.0, f"Starting model loading on {DEVICE}...")
-
-            sam2_predictor = load_sam2_predictor_fixed(device=DEVICE, progress_callback=progress_callback)
-
-            if PROCESS_CANCELLED.is_set():
-                logger.info("Model loading cancelled by user")
-                return "Model loading cancelled by user"
-
-            matanyone_model = load_matanyone_fixed(progress_callback=progress_callback)
-
-            if PROCESS_CANCELLED.is_set():
-                logger.info("Model loading cancelled by user")
-                return "Model loading cancelled by user"
-
-            models_loaded = True
-
-            if TWO_STAGE_AVAILABLE:
-                try:
-                    two_stage_processor = TwoStageProcessor(sam2_predictor, matanyone_model)
-                    logger.info("Two-stage processor initialized")
-                except Exception as e:
-                    logger.warning(f"Two-stage processor initialization failed: {e}")
-                    TWO_STAGE_AVAILABLE = False
-
-            load_time = time.time() - start_time
-            message = f"SUCCESS: SAM2 + MatAnyone loaded and validated in {load_time:.1f}s on {DEVICE}"
-            if TWO_STAGE_AVAILABLE:
-                message += " (Two-stage mode available)"
-            logger.info(message)
-            return message
-
+                progress_callback(0.9, "MatAnyone loaded successfully")
+                
+            return processor
+            
         except Exception as e:
-            models_loaded = False
-            error_msg = f"Model loading failed: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
-
-# ============================================================================ #
-# MAIN VIDEO PROCESSING - USING UTILITIES FUNCTIONS - ROBUST
-# ============================================================================ #
-def process_video_fixed(
-    video_path: str,
-    background_choice: str,
-    custom_background_path: Optional[str],
-    progress_callback: Optional[callable] = None,
-    use_two_stage: bool = False,
-    chroma_preset: str = "standard",
-    preview_mask: bool = False,
-    preview_greenscreen: bool = False
-) -> Tuple[Optional[str], str]:
-    """Optimized video processing using proper functions from utilities - ROBUST VERSION"""
-    global PROCESS_CANCELLED
-
-    if PROCESS_CANCELLED.is_set():
-        logger.info("Processing cancelled by user")
-        return None, "Processing cancelled by user"
-
-    if not models_loaded:
-        logger.error("Models not loaded")
-        return None, "Models not loaded. Call load_models_with_validation() first."
-
-    if not video_path or not os.path.exists(video_path):
-        logger.error(f"Video file not found: {video_path}")
-        return None, f"Video file not found: {video_path}"
-
-    is_valid, validation_msg = validate_video_file(video_path)
-    if not is_valid:
-        logger.error(f"Invalid video: {validation_msg}")
-        return None, f"Invalid video: {validation_msg}"
-
-    def _prog(pct: float, desc: str):
-        if PROCESS_CANCELLED.is_set():
-            raise Exception("Processing cancelled by user")
-
-        if progress_callback:
-            progress_callback(pct, desc)
-
-        if "Frame" in desc and "|" in desc:
-            parts = desc.split("|")
-            frame_info = parts[0].strip() if len(parts) > 0 else ""
-            time_info = parts[1].strip() if len(parts) > 1 else ""
-            fps_info = parts[2].strip() if len(parts) > 2 else ""
-            eta_info = parts[3].strip() if len(parts) > 3 else ""
-
-            display_text = f"""📊 PROCESSING STATUS
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-🎬 {frame_info}
-⏱️ Elapsed: {time_info}
-⚡ Speed: {fps_info}
-🎯 {eta_info}
-━━━━━━━━━━━━━━━━━━━━━━━━━━
-📈 Progress: {pct*100:.1f}%"""
-            try:
-                with open("/tmp/processing_info.txt", 'w') as f:
-                    f.write(display_text)
-            except Exception as e:
-                logger.warning(f"Error writing processing info: {e}")
-
-    try:
-        _prog(0.0, f"Starting {'TWO-STAGE' if use_two_stage else 'SINGLE-STAGE'} processing on {DEVICE}...")
-
-        if use_two_stage:
-            if not TWO_STAGE_AVAILABLE:
-                logger.error("Two-stage mode not available")
-                return None, "Two-stage mode not available. Please add two_stage_processor.py file."
-
-            if two_stage_processor is None:
-                logger.error("Two-stage processor not initialized")
-                return None, "Two-stage processor not initialized. Please reload models."
-
-            _prog(0.05, "Starting TWO-STAGE green screen processing...")
-
-            cap = cv2.VideoCapture(video_path)
-            frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-            frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-            cap.release()
-
-            if background_choice == "custom" and custom_background_path:
-                if not os.path.exists(custom_background_path):
-                    logger.error(f"Custom background not found: {custom_background_path}")
-                    return None, f"Custom background not found: {custom_background_path}"
-
-                background = cv2.imread(custom_background_path)
-                if background is None:
-                    logger.error("Could not read custom background image")
-                    return None, "Could not read custom background image."
-                background_name = "Custom Image"
+            logger.warning(f"MatAnyone loading failed: {e}")
+            # Return None to use fallback refinement
+            return None
+    
+    def process_video(
+        self,
+        video_path: str,
+        background_choice: str,
+        custom_background_path: Optional[str] = None,
+        progress_callback: Optional[Callable] = None,
+        use_two_stage: bool = False,
+        chroma_preset: str = "standard",
+        preview_mask: bool = False,
+        preview_greenscreen: bool = False
+    ) -> Tuple[Optional[str], str]:
+        """Process video with comprehensive error handling"""
+        
+        if not self.models_loaded:
+            return None, "Models not loaded. Please load models first."
+        
+        if self.cancel_event.is_set():
+            return None, "Processing cancelled"
+        
+        # Validate input
+        is_valid, validation_msg = validate_video_file(video_path)
+        if not is_valid:
+            return None, f"Invalid video: {validation_msg}"
+        
+        try:
+            if use_two_stage and TWO_STAGE_AVAILABLE and self.two_stage_processor:
+                return self._process_two_stage(
+                    video_path, background_choice, custom_background_path,
+                    progress_callback, chroma_preset
+                )
             else:
-                if background_choice in PROFESSIONAL_BACKGROUNDS:
-                    bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
-                    background = create_professional_background(bg_config, frame_width, frame_height)
-                    background_name = bg_config["name"]
-                else:
-                    logger.error(f"Invalid background selection: {background_choice}")
-                    return None, f"Invalid background selection: {background_choice}"
-
-            chroma_settings = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS['standard'])
-
-            timestamp = int(time.time())
-            final_output = f"/tmp/twostage_final_{timestamp}.mp4"
-
-            result, message = two_stage_processor.process_full_pipeline(
-                video_path,
-                background,
-                final_output,
-                chroma_settings=chroma_settings,
-                progress_callback=_prog
-            )
-
-            if PROCESS_CANCELLED.is_set():
-                logger.info("Processing cancelled by user")
-                return None, "Processing cancelled by user"
-
-            if result is None:
-                logger.error(f"Two-stage processing failed: {message}")
-                return None, message
-
-            _prog(0.9, "Adding audio...")
-            final_with_audio = f"/tmp/twostage_audio_{timestamp}.mp4"
-
-            audio_check_success = run_ffmpeg_command([
-                'ffprobe', '-v', 'quiet', '-select_streams', 'a:0', 
-                '-show_entries', 'stream=codec_name', '-of', 'csv=p=0', video_path
-            ], "Checking for audio stream")
-
-            if audio_check_success:
-                audio_success = run_ffmpeg_command([
-                    'ffmpeg', '-y', '-i', final_output, '-i', video_path,
-                    '-c:v', 'copy',
-                    '-c:a', 'aac', '-b:a', '192k', '-ac', '2', '-ar', '48000',
-                    '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_with_audio
-                ], "Two-stage audio processing with original audio")
+                return self._process_single_stage(
+                    video_path, background_choice, custom_background_path,
+                    progress_callback, preview_mask, preview_greenscreen
+                )
                 
-                if not audio_success or not os.path.exists(final_with_audio):
-                    logger.warning("Failed with original audio, trying fallback method...")
-                    audio_success = run_ffmpeg_command([
-                        'ffmpeg', '-y', '-i', video_path, '-i', final_output,
-                        '-c:v', 'libx264', '-crf', '18', '-preset', 'fast',
-                        '-c:a', 'copy',
-                        '-map', '1:v:0', '-map', '0:a:0', '-shortest', final_with_audio
-                    ], "Fallback two-stage audio processing")
-            else:
-                logger.info("Input video has no audio stream")
-                try:
-                    shutil.copy2(final_output, final_with_audio)
-                    audio_success = True
-                except Exception as e:
-                    logger.error(f"Failed to copy video: {e}")
-                    audio_success = False
-                    final_with_audio = final_output
-
-            if audio_success and os.path.exists(final_with_audio):
-                try:
-                    os.remove(final_output)
-                except:
-                    pass
-                final_output = final_with_audio
-            else:
-                logger.warning("Audio processing failed, using video without audio")
-
-            _prog(1.0, "TWO-STAGE processing complete!")
-
-            success_message = (
-                f"TWO-STAGE Success!\n"
-                f"Background: {background_name}\n"
-                f"Method: Green Screen Chroma Key\n"
-                f"Preset: {chroma_preset}\n"
-                f"Quality: Professional cinema-grade\n"
-                f"Device: {DEVICE}"
-            )
-
-            return final_output, success_message
-
-        _prog(0.05, f"Starting SINGLE-STAGE processing on {DEVICE}...")
-
+        except Exception as e:
+            logger.error(f"Video processing failed: {e}")
+            return None, f"Processing failed: {str(e)}"
+    
+    def _process_single_stage(
+        self,
+        video_path: str,
+        background_choice: str,
+        custom_background_path: Optional[str],
+        progress_callback: Optional[Callable],
+        preview_mask: bool,
+        preview_greenscreen: bool
+    ) -> Tuple[Optional[str], str]:
+        """Single-stage video processing"""
+        
         cap = cv2.VideoCapture(video_path)
         if not cap.isOpened():
-            logger.error("Could not open video file")
-            return None, "Could not open video file."
-
+            return None, "Could not open video file"
+        
         fps = cap.get(cv2.CAP_PROP_FPS)
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-        if total_frames == 0:
-            cap.release()
-            logger.error("Video appears to be empty")
-            return None, "Video appears to be empty."
-
-        logger.info(f"Video info: {frame_width}x{frame_height}, {fps}fps, {total_frames} frames, processing on {DEVICE}")
-
-        background = None
-        background_name = ""
-
-        if background_choice == "custom" and custom_background_path:
-            if not os.path.exists(custom_background_path):
-                cap.release()
-                logger.error(f"Custom background not found: {custom_background_path}")
-                return None, f"Custom background not found: {custom_background_path}"
-
-            background = cv2.imread(custom_background_path)
-            if background is None:
-                cap.release()
-                logger.error("Could not read custom background image")
-                return None, "Could not read custom background image."
-            background_name = "Custom Image"
-        else:
-            if background_choice in PROFESSIONAL_BACKGROUNDS:
-                bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
-                background = create_professional_background(bg_config, frame_width, frame_height)
-                background_name = bg_config["name"]
-            else:
-                cap.release()
-                logger.error(f"Invalid background selection: {background_choice}")
-                return None, f"Invalid background selection: {background_choice}"
-
+        
+        # Prepare background
+        background = self._prepare_background(
+            background_choice, custom_background_path, frame_width, frame_height
+        )
         if background is None:
             cap.release()
-            logger.error("Failed to create background")
-            return None, "Failed to create background."
-
+            return None, "Failed to prepare background"
+        
+        # Setup output
         timestamp = int(time.time())
-
-        _prog(0.1, f"Processing {total_frames} frames with {'TWO-STAGE' if use_two_stage else 'SINGLE-STAGE'} processing on {DEVICE}...")
-
-        if preview_mask or preview_greenscreen:
-            output_path = f"/tmp/preview_{timestamp}.mp4"
-        else:
-            output_path = f"/tmp/output_{timestamp}.mp4"
-
-        final_writer, actual_output_path = create_video_writer(output_path, fps, frame_width, frame_height)
-        if final_writer is None:
+        output_path = f"/tmp/output_{timestamp}.mp4"
+        
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
+        
+        if not out.isOpened():
             cap.release()
-            logger.error("Could not create output video file with any codec")
-            return None, "Could not create output video file with any codec."
-
-        output_path = actual_output_path
-
+            return None, "Could not create output video"
+        
+        # Process frames
+        progress_tracker = ProgressTracker(total_frames, progress_callback)
         frame_count = 0
         successful_frames = 0
         last_refined_mask = None
-
-        start_time = time.time()
-
+        
         try:
             while True:
-                if PROCESS_CANCELLED.is_set():
+                if self.cancel_event.is_set():
                     break
-
+                
                 ret, frame = cap.read()
                 if not ret:
                     break
-
-                if frame_count % FRAME_SKIP != 0:
-                    frame_count += 1
-                    continue
-
+                
                 try:
-                    elapsed_time = time.time() - start_time
-                    current_fps = frame_count / elapsed_time if elapsed_time > 0 else 0
-                    remaining_frames = total_frames - frame_count
-                    eta_seconds = remaining_frames / current_fps if current_fps > 0 else 0
-                    eta_display = f"{int(eta_seconds//60)}m {int(eta_seconds%60)}s" if eta_seconds > 60 else f"{int(eta_seconds)}s"
-
-                    progress_msg = f"Frame {frame_count + 1}/{total_frames} | {elapsed_time:.1f}s | {current_fps:.1f} fps | ETA: {eta_display} | Device: {DEVICE}"
-
-                    logger.info(progress_msg)
-                    pct = min(1.0, 0.1 + (frame_count / max(1, total_frames)) * 0.8)
-                    _prog(pct, progress_msg)
-
-                    mask = segment_person_hq(frame, sam2_predictor)
-
-                    if preview_mask:
-                        mask_vis = np.zeros_like(frame)
-                        mask_vis[..., 1] = mask
-                        final_writer.write(mask_vis.astype(np.uint8))
-                        frame_count += 1
-                        continue
-
-                    if (frame_count % KEYFRAME_INTERVAL == 0) or (last_refined_mask is None):
-                        refined_mask = refine_mask_hq(frame, mask, matanyone_model)
+                    progress_tracker.update(frame_count, "Processing")
+                    
+                    # Segmentation
+                    mask = segment_person_hq(frame, self.sam2_predictor)
+                    
+                    # Mask refinement (keyframe-based)
+                    if (frame_count % self.config.keyframe_interval == 0) or (last_refined_mask is None):
+                        refined_mask = refine_mask_hq(frame, mask, self.matanyone_model)
                         last_refined_mask = refined_mask.copy()
-                        logger.info(f"Keyframe refinement at frame {frame_count} on {DEVICE}")
                     else:
+                        # Blend with previous refined mask for temporal consistency
                         alpha = 0.7
                         refined_mask = cv2.addWeighted(mask, alpha, last_refined_mask, 1-alpha, 0)
-
-                    if preview_greenscreen:
-                        green_bg = np.zeros_like(frame)
-                        green_bg[:, :] = [0, 255, 0]
-                        preview_frame = frame.copy()
-                        mask_3ch = cv2.cvtColor(refined_mask, cv2.COLOR_GRAY2BGR)
-                        mask_norm = mask_3ch.astype(float) / 255
-                        preview_frame = preview_frame * mask_norm + green_bg * (1 - mask_norm)
-                        final_writer.write(preview_frame.astype(np.uint8))
-                        frame_count += 1
-                        continue
-
-                    result_frame = replace_background_hq(frame, refined_mask, background)
-                    final_writer.write(result_frame.astype(np.uint8))
+                    
+                    # Generate output based on mode
+                    if preview_mask:
+                        result_frame = self._create_mask_preview(frame, refined_mask)
+                    elif preview_greenscreen:
+                        result_frame = self._create_greenscreen_preview(frame, refined_mask)
+                    else:
+                        result_frame = replace_background_hq(frame, refined_mask, background)
+                    
+                    out.write(result_frame)
                     successful_frames += 1
-
+                    
                 except Exception as frame_error:
-                    logger.warning(f"Error processing frame {frame_count}: {frame_error}")
-                    final_writer.write(frame)
-
+                    logger.warning(f"Frame {frame_count} processing failed: {frame_error}")
+                    out.write(frame)  # Write original frame as fallback
+                
                 frame_count += 1
-
-                if frame_count % MEMORY_CLEANUP_INTERVAL == 0:
-                    gc.collect()
-                    if DEVICE.type == 'cuda':
-                        torch.cuda.empty_cache()
-                    elapsed = time.time() - start_time
-                    fps_actual = frame_count / elapsed
-                    eta = (total_frames - frame_count) / fps_actual if fps_actual > 0 else 0
-                    logger.info(f"Progress: {frame_count}/{total_frames}, FPS: {fps_actual:.1f}, ETA: {eta:.0f}s, Device: {DEVICE}")
-
+                
+                # Memory cleanup
+                if frame_count % self.config.memory_cleanup_interval == 0:
+                    self.memory_manager.cleanup_aggressive()
+            
         finally:
             cap.release()
-            final_writer.release()
-
-        if PROCESS_CANCELLED.is_set():
-            _prog(0.95, "Cleaning up cancelled process...")
+            out.release()
+        
+        if self.cancel_event.is_set():
             try:
-                if os.path.exists(output_path):
-                    os.remove(output_path)
+                os.remove(output_path)
             except:
                 pass
-            logger.info("Processing cancelled by user")
-            return None, "Processing cancelled by user"
-
+            return None, "Processing cancelled"
+        
         if successful_frames == 0:
-            logger.error("No frames were processed successfully with AI")
-            return None, "No frames were processed successfully with AI."
-
-        total_time = time.time() - start_time
-        avg_fps = frame_count / total_time if total_time > 0 else 0
-
-        _prog(0.9, "Finalizing output...")
-
-        if preview_mask or preview_greenscreen:
+            return None, "No frames processed successfully"
+        
+        # Add audio if not preview mode
+        if not (preview_mask or preview_greenscreen):
+            final_output = self._add_audio(video_path, output_path)
+        else:
             final_output = output_path
+        
+        success_msg = (
+            f"Success! Processed {successful_frames}/{frame_count} frames\n"
+            f"Background: {background_choice}\n"
+            f"Mode: Single-stage\n"
+            f"Device: {self.device}"
+        )
+        
+        return final_output, success_msg
+    
+    def _process_two_stage(
+        self,
+        video_path: str,
+        background_choice: str,
+        custom_background_path: Optional[str],
+        progress_callback: Optional[Callable],
+        chroma_preset: str
+    ) -> Tuple[Optional[str], str]:
+        """Two-stage processing using green screen intermediate"""
+        
+        cap = cv2.VideoCapture(video_path)
+        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        cap.release()
+        
+        # Prepare background
+        background = self._prepare_background(
+            background_choice, custom_background_path, frame_width, frame_height
+        )
+        if background is None:
+            return None, "Failed to prepare background"
+        
+        # Process with two-stage pipeline
+        timestamp = int(time.time())
+        final_output = f"/tmp/twostage_final_{timestamp}.mp4"
+        
+        chroma_settings = CHROMA_PRESETS.get(chroma_preset, CHROMA_PRESETS['standard'])
+        
+        result, message = self.two_stage_processor.process_full_pipeline(
+            video_path,
+            background,
+            final_output,
+            chroma_settings=chroma_settings,
+            progress_callback=progress_callback
+        )
+        
+        if result is None:
+            return None, message
+        
+        success_msg = (
+            f"Two-stage success!\n"
+            f"Background: {background_choice}\n"
+            f"Preset: {chroma_preset}\n"
+            f"Quality: Cinema-grade\n"
+            f"Device: {self.device}"
+        )
+        
+        return result, success_msg
+    
+    def _prepare_background(
+        self,
+        background_choice: str,
+        custom_background_path: Optional[str],
+        width: int,
+        height: int
+    ) -> Optional[np.ndarray]:
+        """Prepare background image"""
+        
+        if background_choice == "custom" and custom_background_path:
+            if not os.path.exists(custom_background_path):
+                logger.error(f"Custom background not found: {custom_background_path}")
+                return None
+            
+            background = cv2.imread(custom_background_path)
+            if background is None:
+                logger.error("Could not read custom background")
+                return None
         else:
-            _prog(0.9, "Adding audio...")
-            final_output = f"/tmp/final_{timestamp}.mp4"
-
-            audio_check_success = run_ffmpeg_command([
-                'ffprobe', '-v', 'quiet', '-select_streams', 'a:0', 
-                '-show_entries', 'stream=codec_name', '-of', 'csv=p=0', video_path
-            ], "Checking for audio stream")
-
-            if audio_check_success:
-                audio_success = run_ffmpeg_command([
-                    'ffmpeg', '-y', '-i', output_path, '-i', video_path,
-                    '-c:v', 'copy',
-                    '-c:a', 'aac', '-b:a', '192k', '-ac', '2', '-ar', '48000',
-                    '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_output
-                ], "Audio processing with original audio")
-                
-                if not audio_success or not os.path.exists(final_output):
-                    logger.warning("Failed with original audio, trying fallback method...")
-                    audio_success = run_ffmpeg_command([
-                        'ffmpeg', '-y', '-i', video_path, '-i', output_path,
-                        '-c:v', 'libx264', '-crf', '18', '-preset', 'fast',
-                        '-c:a', 'copy',
-                        '-map', '1:v:0', '-map', '0:a:0', '-shortest', final_output
-                    ], "Fallback audio processing")
-            else:
-                logger.info("Input video has no audio stream")
+            if background_choice not in PROFESSIONAL_BACKGROUNDS:
+                logger.error(f"Unknown background: {background_choice}")
+                return None
+            
+            bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
+            background = create_professional_background(bg_config, width, height)
+        
+        return cv2.resize(background, (width, height))
+    
+    def _create_mask_preview(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        """Create mask preview visualization"""
+        mask_vis = np.zeros_like(frame)
+        mask_vis[..., 1] = mask  # Green channel
+        return mask_vis
+    
+    def _create_greenscreen_preview(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        """Create green screen preview"""
+        green_bg = np.zeros_like(frame)
+        green_bg[:, :] = [0, 255, 0]  # Pure green
+        
+        mask_3ch = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
+        mask_norm = mask_3ch.astype(float) / 255
+        
+        return (frame * mask_norm + green_bg * (1 - mask_norm)).astype(np.uint8)
+    
+    def _add_audio(self, input_video: str, processed_video: str) -> str:
+        """Add audio from original video to processed video"""
+        timestamp = int(time.time())
+        final_output = f"/tmp/final_with_audio_{timestamp}.mp4"
+        
+        try:
+            # Check if input has audio
+            result = subprocess.run([
+                'ffprobe', '-v', 'quiet', '-select_streams', 'a:0',
+                '-show_entries', 'stream=codec_name', '-of', 'csv=p=0', input_video
+            ], capture_output=True, text=True, timeout=30)
+            
+            if result.returncode != 0:
+                logger.info("Input video has no audio")
+                return processed_video
+            
+            # Add audio
+            result = subprocess.run([
+                'ffmpeg', '-y', '-i', processed_video, '-i', input_video,
+                '-c:v', 'copy', '-c:a', 'aac', '-b:a', '192k',
+                '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_output
+            ], capture_output=True, text=True, timeout=300)
+            
+            if result.returncode == 0 and os.path.exists(final_output):
                 try:
-                    shutil.copy2(output_path, final_output)
-                    audio_success = True
-                except Exception as e:
-                    logger.error(f"Failed to copy video: {e}")
-                    audio_success = False
-                    final_output = output_path
+                    os.remove(processed_video)
+                except:
+                    pass
+                return final_output
+            else:
+                logger.warning("Audio processing failed, using video without audio")
+                return processed_video
+                
+        except Exception as e:
+            logger.warning(f"Audio processing error: {e}")
+            return processed_video
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get current processor status"""
+        return {
+            'models_loaded': self.models_loaded,
+            'sam2_available': self.sam2_predictor is not None,
+            'matanyone_available': self.matanyone_model is not None,
+            'two_stage_available': TWO_STAGE_AVAILABLE and self.two_stage_processor is not None,
+            'device': str(self.device),
+            'memory_usage': self.memory_manager.get_memory_usage(),
+            'config': {
+                'keyframe_interval': self.config.keyframe_interval,
+                'quality_preset': self.config.quality_preset
+            }
+        }
+    
+    def cancel_processing(self):
+        """Cancel current processing"""
+        self.cancel_event.set()
+        logger.info("Processing cancellation requested")
 
-            if not audio_success or not os.path.exists(final_output):
-                logger.warning("All audio processing failed, using video without audio")
-                try:
-                    shutil.copy2(output_path, final_output)
-                except Exception as e:
-                    logger.error(f"Failed to copy video: {e}")
-                    final_output = output_path
+# Global processor instance
+processor = VideoProcessor()
 
-            try:
-                if os.path.exists(output_path) and output_path != final_output:
-                    os.remove(output_path)
-            except Exception as e:
-                logger.warning(f"Cleanup error: {e}")
+# Compatibility functions for existing UI
+def load_models_with_validation(progress_callback: Optional[Callable] = None) -> str:
+    return processor.load_models(progress_callback)
 
-        _prog(1.0, "Processing complete!")
+def process_video_fixed(
+    video_path: str,
+    background_choice: str,
+    custom_background_path: Optional[str],
+    progress_callback: Optional[Callable] = None,
+    use_two_stage: bool = False,
+    chroma_preset: str = "standard",
+    preview_mask: bool = False,
+    preview_greenscreen: bool = False
+) -> Tuple[Optional[str], str]:
+    return processor.process_video(
+        video_path, background_choice, custom_background_path,
+        progress_callback, use_two_stage, chroma_preset,
+        preview_mask, preview_greenscreen
+    )
 
-        success_message = (
-            f"Success!\n"
-            f"Background: {background_name}\n"
-            f"Resolution: {frame_width}x{frame_height}\n"
-            f"Total frames: {frame_count}\n"
-            f"Successfully processed: {successful_frames}\n"
-            f"Processing time: {total_time:.1f}s\n"
-            f"Average FPS: {avg_fps:.1f}\n"
-            f"Keyframe interval: {KEYFRAME_INTERVAL}\n"
-            f"Mode: {'TWO-STAGE' if use_two_stage else 'SINGLE-STAGE'}\n"
-            f"Device: {DEVICE}"
-        )
+def get_model_status() -> Dict[str, Any]:
+    return processor.get_status()
 
-        return final_output, success_message
+def get_cache_status() -> Dict[str, Any]:
+    return processor.get_status()
 
-    except Exception as e:
-        logger.error(f"Processing error: {traceback.format_exc()}")
-        return None, f"Processing Error: {str(e)}"
+# For backward compatibility
+PROCESS_CANCELLED = processor.cancel_event
 
-# ============================================================================ #
-# MAIN - IMPORT UI COMPONENTS
-# ============================================================================ #
 def main():
+    """Main application entry point"""
     try:
-        print("===== FINAL FIXED VIDEO BACKGROUND REPLACEMENT =====")
-        print(f"Keyframe interval: {KEYFRAME_INTERVAL} frames")
-        print(f"Frame skip: {FRAME_SKIP} (1=all frames, 2=every other)")
-        print(f"Two-stage mode: {'AVAILABLE' if TWO_STAGE_AVAILABLE else 'NOT AVAILABLE'}")
-        print(f"Device: {DEVICE}")
-        print("Loading UI components...")
-
-        try:
-            from ui_components import create_interface
-            logger.info("Successfully imported ui_components")
-        except ImportError as e:
-            logger.error(f"Failed to import ui_components: {e}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            raise Exception(f"UI components import failed: {e}")
-
-        os.makedirs("/tmp/MyAvatar/My_Videos/", exist_ok=True)
-        CACHE_DIR.mkdir(exist_ok=True, parents=True)
-
-        print("Creating interface...")
-        try:
-            demo = create_interface()
-            logger.info("Gradio interface created successfully")
-        except Exception as e:
-            logger.error(f"Failed to create Gradio interface: {e}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            raise Exception(f"Gradio interface creation failed: {e}")
-
-        print("Launching...")
-        try:
-            demo.queue().launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                share=True,
-                show_error=True,
-                debug=True
-            )
-            logger.info("Gradio server launched successfully")
-        except Exception as e:
-            logger.error(f"Gradio launch failed: {e}")
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            raise Exception(f"Gradio launch failed: {e}")
-
+        logger.info("Starting Video Background Replacement application")
+        logger.info(f"Device: {processor.device}")
+        logger.info(f"Two-stage available: {TWO_STAGE_AVAILABLE}")
+        
+        # Import and create UI
+        from ui_components import create_interface
+        demo = create_interface()
+        
+        # Launch application
+        demo.queue().launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True,
+            debug=False
+        )
+        
     except Exception as e:
-        logger.error(f"Startup failed: {e}")
-        logger.error(f"Full traceback: {traceback.format_exc()}")
-        print(f"Startup failed: {e}")
+        logger.error(f"Application startup failed: {e}")
         raise
 
 if __name__ == "__main__":