Update app.py

app.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python3
 """
-BackgroundFX - Professional Video Background Replacement
-Combined Pipeline: SAM2 (segmentation) + MatAnyone (matting refinement)
-Optimized for HuggingFace Spaces T4 GPU (16GB VRAM)
+BackgroundFX - Enhanced SAM2 Video Background Replacer for Hugging Face Spaces
+Professional video background replacement with optimized lazy loading and memory management
 """
 
-import streamlit as st
+import gradio as gr
 import cv2
 import numpy as np
 import tempfile
@@ -18,882 +17,660 @@
 import torch
 import time
 from pathlib import Path
-from dataclasses import dataclass
-from typing import Optional, Dict, Tuple
+import hashlib
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# ============================================
-# GPU SETUP AND INITIALIZATION
-# ============================================
+# Constants
+MAX_VIDEO_DURATION = 300  # 5 minutes max for free tier
+MAX_FRAMES_BATCH = 100   # Process in batches to manage memory
+SUPPORTED_VIDEO_FORMATS = ['.mp4', '.avi', '.mov', '.mkv', '.webm']
 
-def setup_gpu_environment():
-    """Setup GPU environment optimized for T4"""
-    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
-    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:256'
+# GPU Setup and Detection
+def setup_gpu():
+    """Setup GPU with detailed information and optimization"""
+    if torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(0)
+        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+        torch.cuda.init()
+        torch.cuda.set_device(0)
+        torch.backends.cudnn.benchmark = True
+        
+        # Optimize for common GPU types
+        gpu_optimizations = {
+            "T4": {"use_half": True, "batch_size": 1},
+            "V100": {"use_half": False, "batch_size": 2},
+            "A10": {"use_half": True, "batch_size": 2},
+            "A100": {"use_half": False, "batch_size": 4}
+        }
+        
+        gpu_type = None
+        for gpu in gpu_optimizations:
+            if gpu in gpu_name:
+                gpu_type = gpu
+                break
+                
+        return True, gpu_name, gpu_memory, gpu_type
+    return False, None, 0, None
+
+CUDA_AVAILABLE, GPU_NAME, GPU_MEMORY, GPU_TYPE = setup_gpu()
+DEVICE = 'cuda' if CUDA_AVAILABLE else 'cpu'
+
+logger.info(f"Device: {DEVICE} | GPU: {GPU_NAME} | Memory: {GPU_MEMORY:.1f}GB | Type: {GPU_TYPE}")
+
+# Enhanced SAM2 Lazy Loader with Caching
+class SAM2EnhancedLazy:
+    def __init__(self):
+        self.predictor = None
+        self.current_model_size = None
+        self.model_cache_dir = Path(tempfile.gettempdir()) / "sam2_cache"
+        self.model_cache_dir.mkdir(exist_ok=True)
+        
+        self.models = {
+            "tiny": {
+                "url": "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt",
+                "config": "sam2_hiera_t.yaml",
+                "size_mb": 38,
+                "description": "Fastest, lowest memory"
+            },
+            "small": {
+                "url": "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt",
+                "config": "sam2_hiera_s.yaml", 
+                "size_mb": 185,
+                "description": "Balanced speed/quality"
+            },
+            "base": {
+                "url": "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_base_plus.pt",
+                "config": "sam2_hiera_b+.yaml",
+                "size_mb": 320,
+                "description": "Best quality, slower"
+            }
+        }
     
-    try:
-        if torch.cuda.is_available():
-            gpu_name = torch.cuda.get_device_name(0)
-            gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
-            
-            logger.info(f"🚀 GPU Detected: {gpu_name} ({gpu_memory:.1f}GB)")
-            
-            # Initialize CUDA
-            torch.cuda.init()
-            torch.cuda.set_device(0)
+    def get_model_path(self, model_size):
+        """Get cached model path"""
+        model_name = f"sam2_{model_size}.pt"
+        return self.model_cache_dir / model_name
+    
+    def clear_model(self):
+        """Clear current model from memory"""
+        if self.predictor:
+            del self.predictor
+            self.predictor = None
+            self.current_model_size = None
+        
+        if CUDA_AVAILABLE:
+            torch.cuda.empty_cache()
+        gc.collect()
+        logger.info("SAM2 model cleared from memory")
+    
+    def download_model(self, model_size, progress_fn=None):
+        """Download model with progress tracking and verification"""
+        model_info = self.models[model_size]
+        model_path = self.get_model_path(model_size)
+        
+        if model_path.exists():
+            logger.info(f"Model {model_size} already cached")
+            return model_path
+        
+        try:
+            logger.info(f"Downloading SAM2 {model_size} model...")
+            response = requests.get(model_info['url'], stream=True)
+            response.raise_for_status()
             
-            # T4 optimizations
-            torch.backends.cudnn.benchmark = True
-            torch.backends.cudnn.deterministic = False
+            total_size = int(response.headers.get('content-length', 0))
+            downloaded = 0
             
-            # T4 doesn't support TF32
-            if 'T4' in gpu_name:
-                torch.backends.cuda.matmul.allow_tf32 = False
-                torch.backends.cudnn.allow_tf32 = False
-            else:
-                torch.backends.cuda.matmul.allow_tf32 = True
-                torch.backends.cudnn.allow_tf32 = True
+            with open(model_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if progress_fn and total_size > 0:
+                            progress = downloaded / total_size * 0.4  # 40% of total progress
+                            progress_fn(progress, f"Downloading SAM2 {model_size} ({downloaded/1024/1024:.1f}MB/{total_size/1024/1024:.1f}MB)")
             
-            # Warm up
-            dummy = torch.randn(256, 256, device='cuda')
-            del dummy
-            torch.cuda.empty_cache()
+            logger.info(f"SAM2 {model_size} downloaded successfully")
+            return model_path
             
-            return True, gpu_name, gpu_memory
-        else:
-            logger.warning("⚠️ CUDA not available - running in CPU mode")
-            return False, None, 0
-    except Exception as e:
-        logger.error(f"GPU setup failed: {e}")
-        return False, None, 0
-
-# Initialize GPU
-CUDA_AVAILABLE, GPU_NAME, GPU_MEMORY = setup_gpu_environment()
-DEVICE = 'cuda' if CUDA_AVAILABLE else 'cpu'
-
-# ============================================
-# DATA STRUCTURES
-# ============================================
-
-@dataclass
-class ProcessingResult:
-    """Container for processing results"""
-    alpha: np.ndarray           # Final alpha matte
-    sam2_mask: Optional[np.ndarray] = None   # SAM2 coarse mask
-    trimap: Optional[np.ndarray] = None      # Generated trimap
-    method: str = "unknown"
-    processing_time: float = 0.0
-
-# ============================================
-# COMBINED SAM2 + MATANYONE PROCESSOR
-# ============================================
-
-class CombinedProcessor:
-    """
-    Combines SAM2 and MatAnyone for ultimate quality
-    SAM2: Initial segmentation (find the person)
-    MatAnyone: Alpha matting refinement (perfect edges)
-    """
+        except Exception as e:
+            logger.error(f"Failed to download SAM2 {model_size}: {e}")
+            if model_path.exists():
+                model_path.unlink()
+            raise
     
-    def __init__(self):
-        self.sam2_predictor = None
-        self.matanyone_model = None
-        self.sam2_loaded = False
-        self.matanyone_loaded = False
-        self.device = DEVICE
-        
-        # Temporal consistency
-        self.previous_result = None
-        self.frame_count = 0
-        
-    @st.cache_resource
-    def load_sam2(_self):
-        """Load SAM2 model for segmentation"""
+    def load_model(self, model_size, progress_fn=None):
+        """Load SAM2 model with optimization"""
         try:
-            from sam2.build_sam import build_sam2
-            from sam2.sam2_image_predictor import SAM2ImagePredictor
-            
-            # Model selection based on available VRAM
-            if GPU_MEMORY >= 15:
-                model_config = {
-                    'name': 'base_plus',
-                    'config': 'sam2_hiera_b+.yaml',
-                    'url': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_base_plus.pt',
-                    'size': 323
-                }
-            elif GPU_MEMORY >= 8:
-                model_config = {
-                    'name': 'small',
-                    'config': 'sam2_hiera_s.yaml',
-                    'url': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt',
-                    'size': 155
-                }
-            else:
-                model_config = {
-                    'name': 'tiny',
-                    'config': 'sam2_hiera_t.yaml',
-                    'url': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt',
-                    'size': 77
-                }
-            
-            # Download model if needed
-            cache_dir = Path("/tmp/sam2_models")
-            cache_dir.mkdir(exist_ok=True)
-            model_path = cache_dir / f"sam2_{model_config['name']}.pt"
-            
-            if not model_path.exists():
-                with st.spinner(f"Downloading SAM2 {model_config['name']} ({model_config['size']}MB)..."):
-                    response = requests.get(model_config['url'], stream=True)
-                    total_size = int(response.headers.get('content-length', 0))
-                    
-                    progress_bar = st.progress(0)
-                    with open(model_path, 'wb') as f:
-                        downloaded = 0
-                        for chunk in response.iter_content(chunk_size=8192):
-                            f.write(chunk)
-                            downloaded += len(chunk)
-                            if total_size > 0:
-                                progress_bar.progress(downloaded / total_size)
-                    progress_bar.empty()
+            # Import SAM2 (lazy import to avoid import errors if not available)
+            try:
+                from sam2.build_sam import build_sam2
+                from sam2.sam2_image_predictor import SAM2ImagePredictor
+            except ImportError as e:
+                logger.error("SAM2 not available. Install with: pip install segment-anything-2")
+                raise ImportError("SAM2 package not found") from e
+            
+            model_path = self.download_model(model_size, progress_fn)
+            
+            if progress_fn:
+                progress_fn(0.5, f"Loading SAM2 {model_size} model...")
             
             # Build model
-            sam2_model = build_sam2(
-                config_file=model_config['config'],
-                ckpt_path=str(model_path),
-                device=_self.device
-            )
+            model_config = self.models[model_size]["config"]
+            sam2_model = build_sam2(model_config, str(model_path), device=DEVICE)
             
-            # Use half precision on T4
-            if CUDA_AVAILABLE and 'T4' in GPU_NAME:
+            # Apply GPU optimizations
+            if CUDA_AVAILABLE and GPU_TYPE in ["T4", "A10"]:
                 sam2_model = sam2_model.half()
+                logger.info(f"Applied half precision for {GPU_TYPE}")
             
-            predictor = SAM2ImagePredictor(sam2_model)
+            self.predictor = SAM2ImagePredictor(sam2_model)
+            self.current_model_size = model_size
             
-            logger.info(f"✅ SAM2 {model_config['name']} loaded successfully")
-            return predictor, True
+            if progress_fn:
+                progress_fn(0.6, f"SAM2 {model_size} loaded successfully!")
+            
+            logger.info(f"SAM2 {model_size} model loaded and ready")
+            return self.predictor
             
         except Exception as e:
-            logger.error(f"❌ SAM2 loading failed: {e}")
-            return None, False
+            logger.error(f"Failed to load SAM2 {model_size}: {e}")
+            self.clear_model()
+            raise
+    
+    def get_predictor(self, model_size="tiny", progress_fn=None):
+        """Get predictor, loading if necessary"""
+        if self.predictor is None or self.current_model_size != model_size:
+            self.clear_model()
+            return self.load_model(model_size, progress_fn)
+        return self.predictor
     
-    @st.cache_resource
-    def load_matanyone(_self):
-        """Load MatAnyone model for edge refinement"""
+    def segment_image(self, image, model_size="tiny", progress_fn=None):
+        """Segment image with SAM2"""
+        predictor = self.get_predictor(model_size, progress_fn)
+        
         try:
-            from matanyone import MatAnyoneModel, MatAnyonePredictor
-            
-            # Download model if needed
-            cache_dir = Path("/tmp/matanyone_models")
-            cache_dir.mkdir(exist_ok=True)
-            model_path = cache_dir / "matanyone_video.pth"
-            
-            if not model_path.exists():
-                model_url = "https://huggingface.co/matanyone/matanyone-video/resolve/main/model.pth"
-                
-                with st.spinner("Downloading MatAnyone model..."):
-                    response = requests.get(model_url, stream=True)
-                    total_size = int(response.headers.get('content-length', 0))
-                    
-                    progress_bar = st.progress(0)
-                    with open(model_path, 'wb') as f:
-                        downloaded = 0
-                        for chunk in response.iter_content(chunk_size=8192):
-                            f.write(chunk)
-                            downloaded += len(chunk)
-                            if total_size > 0:
-                                progress_bar.progress(downloaded / total_size)
-                    progress_bar.empty()
-            
-            # Load model
-            model = MatAnyoneModel.from_pretrained(
-                str(model_path),
-                device=_self.device,
-                fp16=(CUDA_AVAILABLE)  # Use FP16 on GPU
+            predictor.set_image(image)
+            h, w = image.shape[:2]
+            
+            # Smart point selection for better segmentation
+            center_points = [
+                [w//2, h//2],      # Center
+                [w//2, h//3],      # Upper center
+                [w//2, 2*h//3],    # Lower center
+                [w//3, h//2],      # Left center
+                [2*w//3, h//2]     # Right center
+            ]
+            
+            point_coords = np.array(center_points)
+            point_labels = np.ones(len(point_coords))
+            
+            masks, scores, logits = predictor.predict(
+                point_coords=point_coords,
+                point_labels=point_labels,
+                multimask_output=True
             )
             
-            # Create predictor
-            predictor = MatAnyonePredictor(
-                model,
-                enable_temporal=True,
-                enable_refinement=True,
-                alpha_quality='high'
-            )
+            # Select best mask
+            best_mask_idx = scores.argmax()
+            best_mask = masks[best_mask_idx]
+            best_score = scores[best_mask_idx]
+            
+            # Post-process mask for better edges
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+            best_mask = cv2.morphologyEx(best_mask.astype(np.uint8), cv2.MORPH_CLOSE, kernel)
+            best_mask = cv2.GaussianBlur(best_mask.astype(np.float32), (3, 3), 1.0)
             
-            logger.info("✅ MatAnyone loaded successfully")
-            return predictor, True
+            return best_mask, float(best_score)
             
         except Exception as e:
-            logger.warning(f"⚠️ MatAnyone not available: {e}")
-            return None, False
+            logger.error(f"Segmentation failed: {e}")
+            return None, 0.0
+
+# Global SAM2 loader
+sam2_loader = SAM2EnhancedLazy()
+
+# Video Validation
+def validate_video(video_path):
+    """Comprehensive video validation"""
+    if not video_path or not os.path.exists(video_path):
+        return False, "No video file provided"
     
-    def initialize(self):
-        """Initialize both models"""
-        if not self.sam2_loaded:
-            self.sam2_predictor, self.sam2_loaded = self.load_sam2()
-        
-        if not self.matanyone_loaded:
-            self.matanyone_model, self.matanyone_loaded = self.load_matanyone()
-        
-        return self.sam2_loaded  # At minimum need SAM2
+    # Check file extension
+    file_ext = Path(video_path).suffix.lower()
+    if file_ext not in SUPPORTED_VIDEO_FORMATS:
+        return False, f"Unsupported format. Supported: {', '.join(SUPPORTED_VIDEO_FORMATS)}"
     
-    def process_frame(self, frame: np.ndarray, use_temporal: bool = True) -> ProcessingResult:
-        """
-        Process single frame using SAM2 + MatAnyone combined
-        
-        Pipeline:
-        1. SAM2 generates initial segmentation
-        2. Create trimap from SAM2 mask
-        3. MatAnyone refines using trimap
-        4. Return high-quality alpha matte
-        """
-        
-        start_time = time.time()
-        
-        if not self.initialize():
-            return None
-        
-        h, w = frame.shape[:2]
-        
-        # ============================================
-        # STEP 1: SAM2 SEGMENTATION
-        # ============================================
-        
-        # Set image for SAM2
-        self.sam2_predictor.set_image(frame)
-        
-        # Generate point prompts with temporal consistency
-        if use_temporal and self.previous_result and self.previous_result.sam2_mask is not None:
-            # Use previous mask center
-            prev_mask = self.previous_result.sam2_mask
-            y_coords, x_coords = np.where(prev_mask > 0.5)
-            
-            if len(y_coords) > 0:
-                center_y = int(np.mean(y_coords))
-                center_x = int(np.mean(x_coords))
-                # Focused points around previous center
-                point_coords = np.array([
-                    [center_x, center_y],
-                    [center_x - w//40, center_y],
-                    [center_x + w//40, center_y],
-                    [center_x, center_y - h//40],
-                    [center_x, center_y + h//40]
-                ])
-            else:
-                point_coords = self._get_default_points(w, h)
-        else:
-            point_coords = self._get_default_points(w, h)
-        
-        point_labels = np.ones(len(point_coords))
-        
-        # Get SAM2 predictions
-        masks, scores, logits = self.sam2_predictor.predict(
-            point_coords=point_coords,
-            point_labels=point_labels,
-            multimask_output=True,
-            return_logits=True
-        )
-        
-        # Select best mask
-        best_idx = np.argmax(scores)
-        sam2_mask = masks[best_idx].astype(np.float32)
-        
-        # Apply temporal smoothing to SAM2 mask
-        if use_temporal and self.previous_result and self.previous_result.sam2_mask is not None:
-            sam2_mask = 0.7 * sam2_mask + 0.3 * self.previous_result.sam2_mask
-            sam2_mask = np.clip(sam2_mask, 0, 1)
-        
-        # ============================================
-        # STEP 2: CREATE TRIMAP FROM SAM2 MASK
-        # ============================================
-        
-        trimap = self._create_trimap_from_mask(sam2_mask)
-        
-        # ============================================
-        # STEP 3: MATANYONE REFINEMENT (if available)
-        # ============================================
-        
-        if self.matanyone_loaded and self.matanyone_model:
-            try:
-                # Use MatAnyone for refinement
-                refined_alpha = self.matanyone_model.predict(
-                    image=frame,
-                    trimap=trimap,
-                    previous_alpha=self.previous_result.alpha if use_temporal and self.previous_result else None,
-                    temporal_weight=0.3 if use_temporal else 0.0
-                )
-                
-                # Additional refinement with guided filter
-                refined_alpha = cv2.ximgproc.guidedFilter(
-                    guide=frame,
-                    src=refined_alpha,
-                    radius=3,
-                    eps=1e-4
-                )
-                
-                method = "SAM2+MatAnyone"
-                
-            except Exception as e:
-                logger.warning(f"MatAnyone refinement failed, using SAM2 only: {e}")
-                refined_alpha = sam2_mask
-                method = "SAM2"
-        else:
-            # Use SAM2 mask with basic refinement
-            refined_alpha = sam2_mask
-            
-            # Basic morphological refinement
-            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-            refined_alpha = cv2.morphologyEx(refined_alpha, cv2.MORPH_CLOSE, kernel)
-            refined_alpha = cv2.GaussianBlur(refined_alpha, (5, 5), 0)
-            
-            method = "SAM2"
-        
-        # ============================================
-        # STEP 4: FINAL POST-PROCESSING
-        # ============================================
-        
-        # Ensure valid range
-        refined_alpha = np.clip(refined_alpha, 0, 1)
-        
-        # Create result
-        result = ProcessingResult(
-            alpha=refined_alpha,
-            sam2_mask=sam2_mask,
-            trimap=trimap,
-            method=method,
-            processing_time=time.time() - start_time
-        )
-        
-        # Store for temporal consistency
-        self.previous_result = result
-        self.frame_count += 1
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return False, "Cannot open video file"
         
-        return result
-    
-    def _get_default_points(self, w: int, h: int) -> np.ndarray:
-        """Get default point prompts for initial detection"""
-        return np.array([
-            [w//2, h//2],      # Center
-            [w//2, h//3],      # Head area
-            [w//2, 2*h//3],    # Body area
-            [w//3, h//2],      # Left
-            [2*w//3, h//2],    # Right
-            [w//2, h//4],      # Upper
-            [w//2, 3*h//4]     # Lower
-        ])
-    
-    def _create_trimap_from_mask(self, mask: np.ndarray, unknown_width: int = 20) -> np.ndarray:
-        """
-        Convert SAM2 mask to trimap for MatAnyone
-        0: Background, 128: Unknown, 255: Foreground
-        """
-        trimap = np.zeros_like(mask, dtype=np.uint8)
+        # Get video properties
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         
-        # Threshold mask
-        binary_mask = (mask > 0.5).astype(np.uint8)
+        cap.release()
         
-        # Erode for definite foreground
-        kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
-        foreground = cv2.erode(binary_mask, kernel_small, iterations=2)
+        if fps <= 0 or frame_count <= 0:
+            return False, "Invalid video properties"
         
-        # Dilate for potential foreground
-        kernel_large = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (unknown_width, unknown_width))
-        potential_fg = cv2.dilate(binary_mask, kernel_large, iterations=2)
+        duration = frame_count / fps
         
-        # Create trimap
-        trimap[potential_fg == 0] = 0       # Background
-        trimap[foreground == 1] = 255       # Foreground
-        trimap[(potential_fg == 1) & (foreground == 0)] = 128  # Unknown
+        # Check duration
+        if duration > MAX_VIDEO_DURATION:
+            return False, f"Video too long ({duration:.1f}s). Max: {MAX_VIDEO_DURATION}s"
         
-        return trimap
-    
-    def reset(self):
-        """Reset temporal state for new video"""
-        self.previous_result = None
-        self.frame_count = 0
-        logger.info("Processor reset for new video")
-
-# ============================================
-# FALLBACK: REMBG PROCESSOR
-# ============================================
-
-REMBG_AVAILABLE = False
-rembg_session = None
-
-try:
-    from rembg import remove, new_session
-    
-    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if CUDA_AVAILABLE else ['CPUExecutionProvider']
-    rembg_session = new_session('u2net_human_seg', providers=providers)
-    
-    # Warm up
-    dummy_img = Image.new('RGB', (128, 128), color='white')
-    _ = remove(dummy_img, session=rembg_session)
-    
-    REMBG_AVAILABLE = True
-    logger.info("✅ Rembg initialized as fallback")
-    
-except Exception as e:
-    logger.warning(f"⚠️ Rembg not available: {e}")
-
-def segment_with_rembg(frame):
-    """Fallback segmentation using Rembg"""
-    if not REMBG_AVAILABLE:
-        return None
+        # Check resolution
+        if width * height > 1920 * 1080:
+            return False, "Resolution too high (max 1920x1080)"
         
-    try:
-        pil_image = Image.fromarray(frame)
-        output = remove(pil_image, session=rembg_session)
+        return True, f"Valid video: {duration:.1f}s, {width}x{height}, {fps:.1f}fps"
         
-        output_array = np.array(output)
-        if output_array.shape[2] == 4:
-            return output_array[:, :, 3].astype(np.float32) / 255.0
-        return None
     except Exception as e:
-        logger.error(f"Rembg failed: {e}")
-        return None
-
-# ============================================
-# BACKGROUND UTILITIES
-# ============================================
+        return False, f"Video validation error: {str(e)}"
 
+# Background Creation
 def create_gradient_background(width=1280, height=720, color1=(70, 130, 180), color2=(255, 140, 90)):
-    """Create gradient background"""
+    """Create smooth gradient background"""
     background = np.zeros((height, width, 3), dtype=np.uint8)
-    
     for y in range(height):
         ratio = y / height
+        # Smooth interpolation
         r = int(color1[0] * (1 - ratio) + color2[0] * ratio)
-        g = int(color1[1] * (1 - ratio) + color2[1] * ratio)
+        g = int(color1[1] * (1 - ratio) + color2[1] * ratio) 
         b = int(color1[2] * (1 - ratio) + color2[2] * ratio)
         background[y, :] = [r, g, b]
-    
     return background
 
-def load_background_image(background_option):
-    """Load or create background based on option"""
-    if background_option.startswith("gradient:"):
-        gradient_type = background_option.split(":")[1]
-        if gradient_type == "blue":
-            return create_gradient_background(color1=(70, 130, 180), color2=(135, 206, 235))
-        elif gradient_type == "sunset":
-            return create_gradient_background(color1=(255, 94, 77), color2=(255, 154, 0))
-        else:  # ocean
-            return create_gradient_background(color1=(0, 119, 190), color2=(0, 180, 216))
-    elif background_option.startswith("color:"):
-        color_name = background_option.split(":")[1]
-        colors = {"green": [0, 255, 0], "blue": [0, 0, 255], "white": [255, 255, 255]}
-        background = np.full((720, 1280, 3), colors.get(color_name, [255, 255, 255]), dtype=np.uint8)
-        return background
-    else:
-        try:
-            response = requests.get(background_option, timeout=10)
-            response.raise_for_status()
-            image = Image.open(BytesIO(response.content))
-            return np.array(image.convert('RGB'))
-        except:
-            return create_gradient_background()
-
-def get_background_options():
-    """Background options for quick selection"""
+def get_background_presets():
+    """Get available background presets"""
     return {
-        "🌅 Blue Gradient": "gradient:blue",
-        "🌇 Sunset Gradient": "gradient:sunset",
-        "🌊 Ocean Gradient": "gradient:ocean",
-        "💚 Green Screen": "color:green",
-        "💙 Blue Screen": "color:blue",
-        "⚪ White Background": "color:white",
-        "🏢 Office": "https://images.unsplash.com/photo-1497366216548-37526070297c?w=1280&h=720&fit=crop",
-        "🌆 City": "https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=1280&h=720&fit=crop",
-        "🏖️ Beach": "https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=1280&h=720&fit=crop",
-        "🌲 Nature": "https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=1280&h=720&fit=crop"
+        "gradient:ocean": ("Ocean Blue", (20, 120, 180), (135, 206, 235)),
+        "gradient:sunset": ("Sunset Orange", (255, 94, 77), (255, 154, 0)),
+        "gradient:forest": ("Forest Green", (34, 139, 34), (144, 238, 144)),
+        "gradient:purple": ("Purple Haze", (128, 0, 128), (221, 160, 221)),
+        "color:white": ("Pure White", None, None),
+        "color:black": ("Pure Black", None, None),
+        "color:green": ("Chroma Green", None, None),
+        "color:blue": ("Chroma Blue", None, None)
     }
 
-# ============================================
-# VIDEO PROCESSING PIPELINE
-# ============================================
+def create_background_from_preset(preset, width, height):
+    """Create background from preset"""
+    presets = get_background_presets()
+    
+    if preset not in presets:
+        return create_gradient_background(width, height)
+    
+    name, color1, color2 = presets[preset]
+    
+    if preset.startswith("gradient:"):
+        return create_gradient_background(width, height, color1, color2)
+    elif preset.startswith("color:"):
+        color_map = {
+            "white": [255, 255, 255],
+            "black": [0, 0, 0], 
+            "green": [0, 255, 0],
+            "blue": [0, 0, 255]
+        }
+        color_name = preset.split(":")[1]
+        color = color_map.get(color_name, [255, 255, 255])
+        return np.full((height, width, 3), color, dtype=np.uint8)
 
-# Initialize processor globally
-processor = CombinedProcessor()
+def load_background_image(background_img, background_preset, target_width, target_height):
+    """Load and prepare background image"""
+    try:
+        if background_img is not None:
+            # Use uploaded image
+            background = np.array(background_img.convert('RGB'))
+        else:
+            # Use preset
+            background = create_background_from_preset(background_preset, target_width, target_height)
+        
+        # Resize to target dimensions
+        if background.shape[:2] != (target_height, target_width):
+            background = cv2.resize(background, (target_width, target_height))
+        
+        return background
+        
+    except Exception as e:
+        logger.error(f"Background loading failed: {e}")
+        return create_gradient_background(target_width, target_height)
 
-def process_video(video_path, background_option, speed_mode='balanced', progress_callback=None):
-    """
-    Process video with SAM2 + MatAnyone combined pipeline
+# Enhanced Video Processing
+def process_video_enhanced(input_video, background_img, background_preset, model_size, edge_smoothing, progress=gr.Progress()):
+    """Enhanced video processing with better error handling and optimization"""
+    
+    if input_video is None:
+        return None, "❌ Please upload a video file"
+    
+    # Validate video
+    progress(0.02, desc="Validating video...")
+    is_valid, validation_msg = validate_video(input_video)
+    if not is_valid:
+        return None, f"❌ {validation_msg}"
+    
+    logger.info(f"Video validation: {validation_msg}")
+    
+    cap = None
+    out = None
+    output_path = None
     
-    Args:
-        video_path: Input video path
-        background_option: Background type/URL
-        speed_mode: 'ultra_fast', 'fast', 'balanced', 'quality'
-        progress_callback: Progress update function
-    """
     try:
-        # Load background
-        background_image = load_background_image(background_option)
+        # Get video properties
+        progress(0.05, desc="Reading video properties...")
+        cap = cv2.VideoCapture(input_video)
         
-        # Open video
-        cap = cv2.VideoCapture(video_path)
         fps = int(cap.get(cv2.CAP_PROP_FPS))
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        duration = total_frames / fps if fps > 0 else 0
         
-        logger.info(f"Processing video: {width}x{height}, {total_frames} frames, {fps} FPS")
-        
-        # Determine frame skip based on speed mode
-        if speed_mode == 'ultra_fast':
-            frame_skip = 3  # Process every 3rd frame
-            interpolate = True
-        elif speed_mode == 'fast':
-            frame_skip = 2  # Process every 2nd frame
-            interpolate = True
-        elif speed_mode == 'balanced':
-            frame_skip = 1  # Process all frames
-            interpolate = False
-        else:  # quality
-            frame_skip = 1
-            interpolate = False
-        
-        # Create output
+        logger.info(f"Video: {width}x{height}, {fps}fps, {total_frames} frames, {duration:.1f}s")
+        
+        # Prepare background
+        progress(0.08, desc="Preparing background...")
+        background_image = load_background_image(background_img, background_preset, width, height)
+        
+        # Setup output video
         output_path = tempfile.mktemp(suffix='.mp4')
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
         
-        # Resize background once
-        background_resized = cv2.resize(background_image, (width, height))
-        
-        # Reset processor for new video
-        processor.reset()
+        if not out.isOpened():
+            raise Exception("Failed to create output video")
         
+        # Processing variables
         frame_count = 0
-        processed_count = 0
-        processing_times = []
-        last_alpha = None
+        last_mask = None
+        processing_start_time = time.time()
         
+        # SAM2 progress callback
+        def sam2_progress(progress_val, message):
+            # Map SAM2 progress to overall progress (10%-40%)
+            overall_progress = 0.1 + (progress_val * 0.3)
+            progress(overall_progress, desc=message)
+        
+        # Process frames
         while True:
             ret, frame = cap.read()
             if not ret:
                 break
             
-            # Convert BGR to RGB
             frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
             
-            # Process frame or use interpolation
-            if frame_count % frame_skip == 0:
-                start_time = time.time()
-                
-                # Process with combined pipeline
-                result = processor.process_frame(frame_rgb, use_temporal=(processed_count > 0))
-                
-                if result:
-                    alpha = result.alpha
-                    last_alpha = alpha
-                    method_used = result.method
-                    processing_times.append(result.processing_time)
+            # Segment frame with SAM2
+            mask, confidence = sam2_loader.segment_image(frame_rgb, model_size, sam2_progress)
+            
+            if mask is not None and confidence > 0.5:
+                current_mask = mask
+                last_mask = current_mask
+            else:
+                # Use last good mask or create fallback
+                if last_mask is not None:
+                    current_mask = last_mask
+                    logger.warning(f"Frame {frame_count}: Using previous mask (confidence: {confidence:.2f})")
                 else:
-                    # Fallback to rembg
-                    alpha = segment_with_rembg(frame_rgb)
-                    if alpha is not None:
-                        last_alpha = alpha
-                        method_used = "Rembg"
-                    else:
-                        alpha = last_alpha if last_alpha is not None else np.ones((height, width), dtype=np.float32)
-                        method_used = "Previous/Fallback"
-                
-                processed_count += 1
-                
+                    # Create center-focused fallback mask
+                    current_mask = np.zeros((height, width), dtype=np.float32)
+                    center_x, center_y = width // 2, height // 2
+                    y, x = np.ogrid[:height, :width]
+                    mask_dist = np.sqrt((x - center_x)**2 + (y - center_y)**2)
+                    current_mask = np.clip(1 - mask_dist / (min(width, height) * 0.3), 0, 1)
+                    logger.warning(f"Frame {frame_count}: Using fallback mask")
+            
+            # Apply edge smoothing
+            if edge_smoothing > 0:
+                kernel_size = int(edge_smoothing * 2) + 1
+                current_mask = cv2.GaussianBlur(current_mask, (kernel_size, kernel_size), edge_smoothing)
+            
+            # Composite frame
+            if current_mask.ndim == 2:
+                alpha = np.expand_dims(current_mask, axis=2)
             else:
-                # Use last alpha for skipped frames
-                alpha = last_alpha if last_alpha is not None else np.ones((height, width), dtype=np.float32)
-                method_used = "Interpolated"
+                alpha = current_mask
             
-            # Apply alpha and composite
-            if alpha.ndim == 2:
-                alpha = np.expand_dims(alpha, axis=2)
+            # Ensure alpha is in correct range
+            alpha = np.clip(alpha, 0, 1)
             
-            # High-quality compositing
             foreground = frame_rgb.astype(np.float32)
-            background = background_resized.astype(np.float32)
+            background = background_image.astype(np.float32)
             
+            # Advanced compositing
             composite = foreground * alpha + background * (1 - alpha)
             composite = np.clip(composite, 0, 255).astype(np.uint8)
             
-            # Convert back to BGR
+            # Convert back to BGR for output
             composite_bgr = cv2.cvtColor(composite, cv2.COLOR_RGB2BGR)
             out.write(composite_bgr)
             
             frame_count += 1
             
-            # Progress update
-            if progress_callback:
-                progress = frame_count / total_frames
-                if processing_times:
-                    avg_time = np.mean(processing_times[-10:])
-                    eta = avg_time * ((total_frames - frame_count) / frame_skip)
-                else:
-                    eta = 0
-                progress_callback(
-                    progress,
-                    f"{method_used} | Frame {frame_count}/{total_frames} | ETA: {eta:.1f}s"
-                )
-            
-            # Memory cleanup
+            # Update progress
+            if frame_count % 5 == 0:  # Update every 5 frames
+                frame_progress = frame_count / total_frames
+                overall_progress = 0.4 + (frame_progress * 0.55)  # 40%-95%
+                elapsed_time = time.time() - processing_start_time
+                if frame_count > 0:
+                    avg_time_per_frame = elapsed_time / frame_count
+                    remaining_time = avg_time_per_frame * (total_frames - frame_count)
+                    progress(overall_progress, desc=f"Processing frame {frame_count}/{total_frames} (ETA: {remaining_time:.0f}s)")
+            
+            # Memory management
             if frame_count % 30 == 0 and CUDA_AVAILABLE:
                 torch.cuda.empty_cache()
         
-        # Release resources
+        progress(0.98, desc="Finalizing video...")
+        
+        # Cleanup
         cap.release()
         out.release()
         
+        # Clear SAM2 model to free memory
+        sam2_loader.clear_model()
+        
         if CUDA_AVAILABLE:
             torch.cuda.empty_cache()
         gc.collect()
         
-        # Log statistics
-        if processing_times:
-            logger.info(f"✅ Processing complete: {output_path}")
-            logger.info(f"Average processing time: {np.mean(processing_times):.3f}s per frame")
-            logger.info(f"Total processed frames: {processed_count}/{total_frames}")
+        processing_time = time.time() - processing_start_time
+        logger.info(f"Processing completed in {processing_time:.1f}s")
         
-        return output_path
+        progress(1.0, desc="Complete!")
+        
+        return output_path, f"✅ Successfully processed {duration:.1f}s video ({total_frames} frames) in {processing_time:.1f}s"
         
     except Exception as e:
-        logger.error(f"Video processing failed: {e}")
-        return None
-
-# ============================================
-# STREAMLIT UI
-# ============================================
+        error_msg = f"❌ Processing failed: {str(e)}"
+        logger.error(error_msg)
+        
+        # Cleanup on error
+        try:
+            if cap:
+                cap.release()
+            if out:
+                out.release()
+            if output_path and os.path.exists(output_path):
+                os.unlink(output_path)
+        except:
+            pass
+        
+        sam2_loader.clear_model()
+        return None, error_msg
 
-def main():
-    st.set_page_config(
-        page_title="BackgroundFX - Lightning Fast",
-        page_icon="🚀",
-        layout="wide",
-        initial_sidebar_state="expanded"
-    )
-    
-    # Header
-    st.title("🚀 BackgroundFX - Lightning-Fast Video Background Replacement")
-    st.markdown("**Professional quality in seconds, not minutes! Powered by SAM2 + MatAnyone**")
-    
-    # System Status
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        if CUDA_AVAILABLE:
-            st.success(f"🚀 GPU: {GPU_NAME}")
-            st.caption(f"VRAM: {GPU_MEMORY:.1f}GB")
-        else:
-            st.warning("💻 CPU Mode")
-    
-    with col2:
-        methods = []
-        if processor.sam2_loaded:
-            methods.append("SAM2")
-        if processor.matanyone_loaded:
-            methods.append("MatAnyone")
-        if REMBG_AVAILABLE:
-            methods.append("Rembg")
-        
-        if methods:
-            st.info(f"✅ Ready: {', '.join(methods)}")
-        else:
-            st.warning("⏳ Loading models...")
-    
-    with col3:
-        if CUDA_AVAILABLE:
-            allocated = torch.cuda.memory_allocated() / 1024**3
-            st.metric("GPU Usage", f"{allocated:.1f}GB")
-        else:
-            st.metric("Mode", "CPU")
+# Gradio Interface
+def create_interface():
+    """Create the Gradio interface"""
     
-    with col4:
-        # Speed indicator
-        st.metric("Status", "Ready" if processor.sam2_loaded else "Loading")
+    # Get background presets for dropdown
+    preset_choices = [("Custom (upload image)", "custom")]
+    for key, (name, _, _) in get_background_presets().items():
+        preset_choices.append((name, key))
     
-    # Sidebar
-    with st.sidebar:
-        st.markdown("### ⚡ Speed Settings")
-        
-        # Speed mode selection
-        speed_mode = st.select_slider(
-            "Processing Speed",
-            options=['ultra_fast', 'fast', 'balanced', 'quality'],
-            value='balanced',
-            format_func=lambda x: {
-                'ultra_fast': '⚡⚡⚡ Ultra Fast (3x)',
-                'fast': '⚡⚡ Fast (2x)',
-                'balanced': '⚡ Balanced',
-                'quality': '🎨 Quality'
-            }[x]
-        )
-        
-        # Speed mode info
-        speed_info = {
-            'ultra_fast': "Process every 3rd frame\n~5 sec for 10 sec video",
-            'fast': "Process every 2nd frame\n~10 sec for 10 sec video",
-            'balanced': "Process all frames\n~15 sec for 10 sec video",
-            'quality': "Full processing\n~20 sec for 10 sec video"
+    with gr.Blocks(
+        title="BackgroundFX Pro - SAM2 Powered",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            max-width: 1200px !important;
         }
-        st.info(speed_info[speed_mode])
-        
-        st.markdown("---")
-        
-        # Processing info
-        st.markdown("### 🎯 Pipeline")
-        
-        if processor.sam2_loaded and processor.matanyone_loaded:
-            st.success("SAM2 + MatAnyone Combined")
-            st.caption("Best quality mode active")
-        elif processor.sam2_loaded:
-            st.info("SAM2 Only")
-            st.caption("Good quality, fast processing")
-        else:
-            st.warning("Initializing...")
-        
-        st.markdown("---")
-        
-        # System info
-        st.markdown("### 📊 System")
+        .main-header {
+            text-align: center;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+        """
+    ) as demo:
         
-        if CUDA_AVAILABLE:
-            allocated = torch.cuda.memory_allocated() / 1024**3
-            reserved = torch.cuda.memory_reserved() / 1024**3
-            
-            st.metric("Memory", f"{allocated:.1f}/{GPU_MEMORY:.0f} GB")
-            
-            usage_percent = (allocated / GPU_MEMORY) * 100 if GPU_MEMORY else 0
-            st.progress(min(usage_percent / 100, 1.0))
-            
-            # GPU details
-            with st.expander("GPU Details"):
-                st.code(f"""
-Device: {GPU_NAME}
-VRAM: {GPU_MEMORY:.1f} GB
-Used: {allocated:.2f} GB
-Reserved: {reserved:.2f} GB
-PyTorch: {torch.__version__}
-CUDA: {torch.version.cuda if CUDA_AVAILABLE else 'N/A'}
-                """)
-    
-    # Main content
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.markdown("### 📹 Video Input")
+        gr.Markdown("""
+        # 🎥 BackgroundFX Pro - SAM2 Powered
+        **Professional AI video background replacement with advanced segmentation**
         
-        uploaded_video = st.file_uploader(
-            "Upload your video",
-            type=['mp4', 'avi', 'mov', 'mkv'],
-            help="Recommended: 10-30 seconds for best performance"
-        )
+        Upload your video and let SAM2 AI automatically detect and replace the background with precision.
+        Optimized for Hugging Face Spaces with smart memory management and lazy loading.
+        """, elem_classes=["main-header"])
         
-        if uploaded_video:
-            # Save video
-            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
-                tmp_file.write(uploaded_video.read())
-                video_path = tmp_file.name
-            
-            st.video(uploaded_video)
-            
-            # Get video info
-            cap = cv2.VideoCapture(video_path)
-            fps = int(cap.get(cv2.CAP_PROP_FPS))
-            frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            duration = frames / fps if fps > 0 else 0
-            cap.release()
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📤 Input Configuration")
+                
+                video_input = gr.Video(
+                    label="Upload Video",
+                    height=300,
+                    info="Supported: MP4, AVI, MOV, MKV, WebM (max 5 minutes)"
+                )
+                
+                with gr.Tab("Background"):
+                    background_preset = gr.Dropdown(
+                        choices=preset_choices,
+                        value="gradient:ocean",
+                        label="Background Preset",
+                        info="Choose a preset or upload custom image"
+                    )
+                    
+                    background_input = gr.Image(
+                        label="Custom Background (optional)",
+                        type="pil",
+                        height=200,
+                        info="Upload image to override preset"
+                    )
+                
+                with gr.Accordion("⚙️ AI Settings", open=True):
+                    model_size = gr.Radio(
+                        choices=[
+                            ("Tiny (38MB) - Fastest", "tiny"),
+                            ("Small (185MB) - Balanced", "small"), 
+                            ("Base (320MB) - Best Quality", "base")
+                        ],
+                        value="tiny",
+                        label="SAM2 Model Size",
+                        info="Larger models = better quality but slower processing"
+                    )
+                    
+                    edge_smoothing = gr.Slider(
+                        minimum=0,
+                        maximum=5,
+                        value=1.0,
+                        step=0.5,
+                        label="Edge Smoothing",
+                        info="Softens edges around subject (0 = sharp, 5 = very soft)"
+                    )
+                
+                process_btn = gr.Button(
+                    "🚀 Replace Background",
+                    variant="primary",
+                    size="lg",
+                    scale=2
+                )
             
-            st.success(f"✅ Ready: {duration:.1f}s @ {fps} FPS")
-        else:
-            video_path = None
-    
-    with col2:
-        st.markdown("### 🎨 Background")
-        
-        # Quick background selection
-        backgrounds = get_background_options()
-        selected_bg = st.selectbox(
-            "Choose background",
-            options=list(backgrounds.keys()),
-            index=0
-        )
-        
-        background_option = backgrounds[selected_bg]
+            with gr.Column(scale=1):
+                gr.Markdown("### 📥 Output")
+                
+                video_output = gr.Video(
+                    label="Processed Video",
+                    height=400,
+                    show_download_button=True
+                )
+                
+                status_output = gr.Textbox(
+                    label="Processing Status",
+                    lines=3,
+                    max_lines=5
+                )
+                
+                gr.Markdown("""
+                ### 💡 Pro Tips
+                - **Best results:** Clear subject separation from background
+                - **Lighting:** Even lighting works best
+                - **Movement:** Minimal camera shake recommended  
+                - **Processing:** ~30-60 seconds per minute of video
+                - **Memory:** Models auto-downloaded and cleared after use
+                """)
         
-        # Preview
-        if background_option:
-            preview_bg = load_background_image(background_option)
-            preview_bg_resized = cv2.resize(preview_bg, (640, 360))
-            st.image(preview_bg_resized, caption=selected_bg, use_container_width=True)
-    
-    # Process button
-    if video_path and st.button("🚀 Process Video", type="primary", use_container_width=True):
-        
-        # Progress tracking
-        progress_bar = st.progress(0)
-        status_text = st.empty()
-        time_text = st.empty()
-        
-        def update_progress(progress, message):
-            progress_bar.progress(progress)
-            status_text.text(message)
-            elapsed = time.time() - start_time
-            time_text.text(f"⏱️ Elapsed: {elapsed:.1f}s")
-        
-        # Process video
-        start_time = time.time()
-        
-        result_path = process_video(
-            video_path,
-            background_option,
-            speed_mode=speed_mode,
-            progress_callback=update_progress
+        # System Information
+        with gr.Row():
+            with gr.Column():
+                if CUDA_AVAILABLE:
+                    gr.Markdown(f"🚀 **GPU Acceleration:** {GPU_NAME} ({GPU_MEMORY:.1f}GB) | Type: {GPU_TYPE}")
+                else:
+                    gr.Markdown("💻 **CPU Mode** (GPU recommended for faster processing)")
+            
+            with gr.Column():
+                gr.Markdown("📦 **Storage:** 0MB persistent (True lazy loading)")
+        
+        # Processing event
+        process_btn.click(
+            fn=process_video_enhanced,
+            inputs=[
+                video_input,
+                background_input, 
+                background_preset,
+                model_size,
+                edge_smoothing
+            ],
+            outputs=[video_output, status_output],
+            show_progress=True
         )
         
-        processing_time = time.time() - start_time
-        
-        if result_path and os.path.exists(result_path):
-            # Success
-            status_text.text(f"✅ Complete in {processing_time:.1f} seconds!")
-            time_text.text(f"🚀 Speed: {frames/processing_time:.1f} FPS")
-            
-            # Load result
-            with open(result_path, 'rb') as f:
-                result_data = f.read()
-            
-            st.markdown("### 🎬 Result")
-            st.video(result_data)
-            
-            # Download button
-            col1, col2, col3 = st.columns([1, 2, 1])
-            with col2:
-                st.download_button(
-                    label="💾 Download Video",
-                    data=result_data,
-                    file_name=f"backgroundfx_{uploaded_video.name}",
-                    mime="video/mp4",
-                    use_container_width=True
-                )
-            
-            # Stats
-            st.success(f"""
-            ✨ **Processing Complete!**
-            - Time: {processing_time:.1f} seconds
-            - Speed: {frames/processing_time:.1f} FPS
-            - Method: {processor.previous_result.method if processor.previous_result else 'Unknown'}
-            - Mode: {speed_mode.replace('_', ' ').title()}
+        # Examples section
+        with gr.Row():
+            gr.Markdown("""
+            ### 🎬 Examples & Use Cases
+            - **Content Creation:** Remove messy backgrounds for professional videos
+            - **Virtual Meetings:** Create custom backgrounds for video calls  
+            - **Education:** Clean backgrounds for instructional videos
+            - **Social Media:** Eye-catching backgrounds for posts and stories
             """)
-            
-            # Cleanup
-            os.unlink(result_path)
-        else:
-            st.error("❌ Processing failed! Please try again.")
-        
-        # Cleanup temp
-        if video_path and os.path.exists(video_path):
-            os.unlink(video_path)
+    
+    return demo
 
+# Main execution
 if __name__ == "__main__":
-    main()
+    # Setup logging
+    logger.info("Starting BackgroundFX Pro...")
+    logger.info(f"Device: {DEVICE}")
+    if CUDA_AVAILABLE:
+        logger.info(f"GPU: {GPU_NAME} ({GPU_MEMORY:.1f}GB)")
+    
+    # Create and launch interface
+    demo = create_interface()
+    
+    demo.queue(
+        concurrency_count=2,  # Max 2 concurrent processes
+        max_size=10,          # Max 10 in queue
+        api_open=False        # Disable API for security
+    ).launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False
+    )