Update app.py

app.py

@@ -1,797 +1,622 @@
 #!/usr/bin/env python3
 """
-BackgroundFX - BUILD-SAFE RAM ANNIHILATOR
-Now with defensive imports and gradual RAM buildup!
-Still targets 32GB RAM + 24GB VRAM but won't crash on build
+VideoBackgroundFX - SAM2 GPU-Optimized Video Background Replacement
+HuggingFace Space Deployment with L4 GPU Support
+Updated: 2025-08-13 - SAM2 Integration
 """
 
 import streamlit as st
-import numpy as np
 import cv2
-import time
-import threading
-import logging
-import sys
-import psutil
-import GPUtil
-import gc
-from datetime import datetime
+import numpy as np
 import tempfile
 import os
-from PIL import Image, ImageFilter, ImageEnhance, ImageOps
-import io
-import random
-import queue
-import hashlib
-import json
-from pathlib import Path
+from PIL import Image
+import requests
+from io import BytesIO
+import logging
+import base64
+import gc
+import torch
+import psutil
 
-# Setup logging
+# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Defensive imports
-TORCH_AVAILABLE = False
-TRANSFORMERS_AVAILABLE = False
-REMBG_AVAILABLE = False
-TIMM_AVAILABLE = False
-SEGMENT_AVAILABLE = False
+# GPU Environment Setup
+def setup_gpu_environment():
+    """Setup GPU environment for L4 optimization"""
+    os.environ['OMP_NUM_THREADS'] = '8'
+    os.environ['ORT_PROVIDERS'] = 'CUDAExecutionProvider,CPUExecutionProvider'
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    os.environ['TORCH_CUDA_ARCH_LIST'] = '8.9'  # L4 architecture
+    os.environ['CUDA_LAUNCH_BLOCKING'] = '0'
+    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:512'
+    
+    try:
+        if torch.cuda.is_available():
+            device_count = torch.cuda.device_count()
+            gpu_name = torch.cuda.get_device_name(0)
+            gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+            
+            logger.info(f"🚀 GPU: {gpu_name} ({gpu_memory:.1f}GB)")
+            
+            # Initialize CUDA context
+            torch.cuda.init()
+            torch.cuda.set_device(0)
+            
+            # Enable optimizations for L4
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.deterministic = False
+            
+            # Set memory fraction
+            torch.cuda.set_per_process_memory_fraction(0.8)
+            
+            # Warm up GPU
+            dummy = torch.randn(1024, 1024, device='cuda')
+            dummy = dummy @ dummy.T
+            del dummy
+            torch.cuda.empty_cache()
+            
+            return True, gpu_name, gpu_memory
+        else:
+            logger.warning("⚠️ CUDA not available")
+            return False, None, 0
+    except Exception as e:
+        logger.error(f"GPU setup failed: {e}")
+        return False, None, 0
 
-try:
-    import torch
-    TORCH_AVAILABLE = True
-    logger.info("✅ PyTorch available")
-except ImportError:
-    logger.warning("❌ PyTorch not available")
+# Initialize GPU
+CUDA_AVAILABLE, GPU_NAME, GPU_MEMORY = setup_gpu_environment()
 
+# SAM2 Integration
 try:
-    import transformers
-    TRANSFORMERS_AVAILABLE = True
-    logger.info("✅ Transformers available")
-except ImportError:
-    logger.warning("❌ Transformers not available")
+    from segment_anything import sam_model_registry, SamPredictor
+    SAM_AVAILABLE = True
+    logger.info("✅ SAM loaded successfully")
+    
+    # Initialize SAM with downloaded checkpoint
+    sam_checkpoint = "sam_vit_h_4b8939.pth"
+    model_type = "vit_h"
+    
+    if os.path.exists(sam_checkpoint) and CUDA_AVAILABLE:
+        sam = sam_model_registry[model_type](checkpoint=sam_checkpoint)
+        sam.to(device='cuda')
+        sam_predictor = SamPredictor(sam)
+        logger.info("✅ SAM2 GPU predictor initialized")
+    else:
+        sam_predictor = None
+        if not os.path.exists(sam_checkpoint):
+            logger.warning(f"⚠️ SAM checkpoint not found: {sam_checkpoint}")
+        
+except ImportError as e:
+    SAM_AVAILABLE = False
+    sam_predictor = None
+    logger.warning(f"⚠️ SAM not available: {e}")
 
+# Rembg with GPU optimization
 try:
-    from rembg import new_session
+    from rembg import remove, new_session
+    import onnxruntime as ort
+    
     REMBG_AVAILABLE = True
-    logger.info("✅ Rembg available")
-except ImportError:
-    logger.warning("❌ Rembg not available")
+    logger.info("✅ Rembg loaded")
+    
+    if CUDA_AVAILABLE:
+        providers = [
+            ('CUDAExecutionProvider', {
+                'device_id': 0,
+                'arena_extend_strategy': 'kSameAsRequested',
+                'gpu_mem_limit': 20 * 1024 * 1024 * 1024,  # 20GB for L4
+                'cudnn_conv_algo_search': 'HEURISTIC',
+            }),
+            'CPUExecutionProvider'
+        ]
+        
+        rembg_session = new_session('u2net_human_seg', providers=providers)
+        
+        # Warm up
+        dummy_img = Image.new('RGB', (512, 512), color='white')
+        with torch.cuda.amp.autocast():
+            _ = remove(dummy_img, session=rembg_session)
+        
+        logger.info("✅ Rembg GPU session initialized")
+    else:
+        rembg_session = new_session('u2net_human_seg')
+        logger.info("✅ Rembg CPU session initialized")
 
-try:
-    import timm
-    TIMM_AVAILABLE = True
-    logger.info("✅ Timm available")
-except ImportError:
-    logger.warning("❌ Timm not available")
+except ImportError as e:
+    REMBG_AVAILABLE = False
+    rembg_session = None
+    logger.warning(f"⚠️ Rembg not available: {e}")
 
+# OpenCV GPU check
 try:
-    from segment_anything import sam_model_registry, SamPredictor
-    SEGMENT_AVAILABLE = True
-    logger.info("✅ Segment Anything available")
-except ImportError:
-    logger.warning("❌ Segment Anything not available")
+    if cv2.cuda.getCudaEnabledDeviceCount() > 0:
+        logger.info(f"✅ OpenCV CUDA devices: {cv2.cuda.getCudaEnabledDeviceCount()}")
+        OPENCV_GPU = True
+    else:
+        OPENCV_GPU = False
+        logger.warning("⚠️ OpenCV CUDA not available")
+except:
+    OPENCV_GPU = False
+    logger.warning("⚠️ OpenCV CUDA not available")
 
-# Constants
-ENABLE_16K = st.secrets.get("ENABLE_16K", True)
-ENABLE_AI_TRAINING = st.secrets.get("ENABLE_AI_TRAINING", True)
-ENABLE_INFINITE_HISTORY = st.secrets.get("ENABLE_INFINITE_HISTORY", True)
-TARGET_RAM_GB = 32
-TARGET_VRAM_GB = 24
+# Memory management
+def optimize_memory():
+    """Optimize memory usage"""
+    if CUDA_AVAILABLE:
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+    gc.collect()
 
-class RAMMonster:
-    """Memory allocation monster - gradual buildup edition"""
-    
-    def __init__(self):
-        self.arrays = {}
-        self.cache = {}
-        self.history = []
-        self.training_data = []
-        self.start_time = time.time()
-        self.allocation_phase = 0
-        logger.info("🦾 RAM Monster initialized - Gradual Mode")
-        
-    def allocate_base_memory(self):
-        """Gradually allocate base memory arrays"""
-        try:
-            phase = self.allocation_phase
+def get_memory_usage():
+    """Get current memory usage"""
+    stats = {}
+    if CUDA_AVAILABLE:
+        stats['gpu_allocated'] = torch.cuda.memory_allocated() / 1024**3
+        stats['gpu_reserved'] = torch.cuda.memory_reserved() / 1024**3
+        stats['gpu_free'] = GPU_MEMORY - stats['gpu_reserved']
+    else:
+        stats['gpu_allocated'] = 0
+        stats['gpu_reserved'] = 0
+        stats['gpu_free'] = 0
+    
+    # System RAM
+    ram = psutil.virtual_memory()
+    stats['ram_used'] = ram.used / 1024**3
+    stats['ram_total'] = ram.total / 1024**3
+    stats['ram_percent'] = ram.percent
+    
+    return stats
+
+# Background loading
+def load_background_image(background_url):
+    """Load background image from URL"""
+    try:
+        if background_url == "default_brick":
+            return create_default_background()
+        
+        response = requests.get(background_url)
+        response.raise_for_status()
+        image = Image.open(BytesIO(response.content))
+        return np.array(image.convert('RGB'))
+    except Exception as e:
+        logger.error(f"Failed to load background image: {e}")
+        return create_default_background()
+
+def create_default_background():
+    """Create a default brick wall background"""
+    background = np.zeros((720, 1280, 3), dtype=np.uint8)
+    background[:, :] = [139, 69, 19]  # Brown color
+    
+    # Add brick pattern
+    for y in range(0, 720, 60):
+        for x in range(0, 1280, 120):
+            cv2.rectangle(background, (x, y), (x+115, y+55), (160, 82, 45), -1)
+            cv2.rectangle(background, (x, y), (x+115, y+55), (101, 67, 33), 2)
+    
+    return background
+
+def get_professional_backgrounds():
+    """Get professional background collection"""
+    return {
+        "🏢 Modern Office": "https://images.unsplash.com/photo-1497366216548-37526070297c?w=1920&h=1080&fit=crop",
+        "🌆 City Skyline": "https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=1920&h=1080&fit=crop",
+        "🏖️ Tropical Beach": "https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=1920&h=1080&fit=crop",
+        "🌲 Forest Path": "https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=1920&h=1080&fit=crop",
+        "🎨 Abstract Blue": "https://images.unsplash.com/photo-1557683316-973673baf926?w=1920&h=1080&fit=crop",
+        "🏔️ Mountain View": "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=1920&h=1080&fit=crop",
+        "🌅 Sunset Gradient": "https://images.unsplash.com/photo-1495616811223-4d98c6e9c869?w=1920&h=1080&fit=crop",
+        "💼 Executive Suite": "https://images.unsplash.com/photo-1497366811353-6870744d04b2?w=1920&h=1080&fit=crop"
+    }
+
+# SAM2 Segmentation
+def segment_person_sam2(frame):
+    """SAM2 GPU-accelerated segmentation"""
+    try:
+        if SAM_AVAILABLE and sam_predictor and CUDA_AVAILABLE:
+            # Set image for SAM
+            sam_predictor.set_image(frame)
             
-            if phase == 0:
-                # Phase 0: Start small - 2GB
-                self.arrays['initial'] = np.zeros((1024, 1024, 512), dtype=np.float32)
-                logger.info(f"Phase 0: Allocated 2GB")
-                
-            elif phase == 1:
-                # Phase 1: Add 4GB
-                self.arrays['4k_batch'] = np.zeros((10, 2160, 3840, 3), dtype=np.uint8)
-                logger.info(f"Phase 1: Added 4GB (6GB total)")
-                
-            elif phase == 2:
-                # Phase 2: Add 6GB
-                self.arrays['8k_batch'] = np.zeros((10, 4320, 7680, 3), dtype=np.uint8)
-                logger.info(f"Phase 2: Added 6GB (12GB total)")
-                
-            elif phase == 3:
-                # Phase 3: Add 8GB
-                self.arrays['cache_pool'] = np.zeros((2048, 1024, 1024), dtype=np.float32)
-                logger.info(f"Phase 3: Added 8GB (20GB total)")
-                
-            elif phase == 4:
-                # Phase 4: Add 12GB - GO BIG!
-                self.arrays['16k_buffer'] = np.zeros((5, 8640, 15360, 3), dtype=np.uint8)
-                logger.info(f"Phase 4: Added 12GB (32GB total) - MAX REACHED!")
-                
-            self.allocation_phase += 1
-            return True
+            # Get image center as prompt (simple heuristic)
+            h, w = frame.shape[:2]
+            input_point = np.array([[w//2, h//2]])
+            input_label = np.array([1])
             
-        except MemoryError:
-            logger.warning(f"Memory allocation failed at phase {phase}")
-            return False
-    
-    def duplicate_everything(self):
-        """Create copies of all arrays"""
-        for key in list(self.arrays.keys()):
-            if not key.endswith('_copy'):
-                try:
-                    self.arrays[f"{key}_copy"] = np.copy(self.arrays[key])
-                    self.arrays[f"{key}_copy2"] = np.copy(self.arrays[key])
-                    logger.info(f"Duplicated {key} (2x copies)")
-                except MemoryError:
-                    logger.warning(f"Could not duplicate {key}")
-    
-    def add_to_infinite_history(self, data):
-        """Never delete history"""
-        self.history.append({
-            'timestamp': time.time(),
-            'data': np.copy(data) if isinstance(data, np.ndarray) else data,
-            'hash': hashlib.md5(str(data).encode()).hexdigest(),
-            'metadata': {'size': sys.getsizeof(data)}
-        })
-        logger.info(f"History size: {len(self.history)} items")
-    
-    def cache_forever(self, key, data):
-        """Cache data permanently"""
-        if key not in self.cache:
-            self.cache[key] = []
-        self.cache[key].append({
-            'data': np.copy(data) if isinstance(data, np.ndarray) else data,
-            'timestamp': time.time(),
-            'access_count': 0
-        })
-        return len(self.cache[key])
-    
-    def get_ram_usage(self):
-        """Get current RAM usage"""
-        process = psutil.Process()
-        return process.memory_info().rss / (1024 ** 3)  # GB
-
-class SixteenKVideoProcessor:
-    """Process video at 16K resolution"""
-    
-    def __init__(self, ram_monster):
-        self.ram_monster = ram_monster
-        self.width_16k = 15360 if ENABLE_16K else 7680  # Start at 8K if careful
-        self.height_16k = 8640 if ENABLE_16K else 4320
-        self.buffers = {}
-        self.processing_queue = queue.Queue()
-        logger.info(f"16K Processor initialized: {self.width_16k}x{self.height_16k}")
-        
-    def create_16k_buffer(self, frames=10):
-        """Create massive 16K video buffer"""
-        try:
-            buffer = np.zeros((frames, self.height_16k, self.width_16k, 3), dtype=np.uint8)
-            self.buffers[f'16k_{time.time()}'] = buffer
-            self.ram_monster.cache_forever('16k_buffer', buffer)
-            logger.info(f"Created 16K buffer: {buffer.nbytes / (1024**3):.2f} GB")
-            return buffer
-        except MemoryError:
-            logger.warning("Could not create 16K buffer, falling back to 8K")
-            return self.create_8k_buffer(frames)
-    
-    def create_8k_buffer(self, frames=10):
-        """Fallback to 8K if 16K fails"""
-        buffer = np.zeros((frames, 4320, 7680, 3), dtype=np.uint8)
-        self.buffers[f'8k_{time.time()}'] = buffer
-        return buffer
-    
-    def upscale_to_16k(self, frame):
-        """Upscale frame to 16K using multiple algorithms"""
-        if frame is None:
-            return None
+            # Predict mask
+            with torch.no_grad():
+                masks, scores, logits = sam_predictor.predict(
+                    point_coords=input_point,
+                    point_labels=input_label,
+                    multimask_output=True,
+                )
             
-        # Store original
-        self.ram_monster.add_to_infinite_history(frame)
+            # Use best mask
+            best_mask = masks[np.argmax(scores)]
+            return best_mask.astype(np.float32)
         
-        # Multiple upscaling methods
-        methods = []
-        
-        # Method 1: OpenCV resize
-        up1 = cv2.resize(frame, (self.width_16k, self.height_16k), 
-                        interpolation=cv2.INTER_CUBIC)
-        methods.append(up1)
-        self.ram_monster.cache_forever('upscale_cubic', up1)
-        
-        # Method 2: Lanczos
-        up2 = cv2.resize(frame, (self.width_16k, self.height_16k), 
-                        interpolation=cv2.INTER_LANCZOS4)
-        methods.append(up2)
-        self.ram_monster.cache_forever('upscale_lanczos', up2)
-        
-        # Method 3: Linear + sharpen
-        up3 = cv2.resize(frame, (self.width_16k, self.height_16k), 
-                        interpolation=cv2.INTER_LINEAR)
-        kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
-        up3 = cv2.filter2D(up3, -1, kernel)
-        methods.append(up3)
-        self.ram_monster.cache_forever('upscale_sharp', up3)
-        
-        # Keep all versions in memory
-        for i, method in enumerate(methods):
-            self.buffers[f'method_{i}_{time.time()}'] = method
+        return None
+    except Exception as e:
+        logger.error(f"SAM2 segmentation failed: {e}")
+        return None
+
+# Rembg Segmentation
+def segment_person_rembg(frame):
+    """Rembg GPU-optimized segmentation"""
+    try:
+        if REMBG_AVAILABLE and rembg_session:
+            pil_image = Image.fromarray(frame)
+            
+            if CUDA_AVAILABLE:
+                with torch.cuda.amp.autocast():
+                    output = remove(
+                        pil_image, 
+                        session=rembg_session,
+                        alpha_matting=True,
+                        alpha_matting_foreground_threshold=240,
+                        alpha_matting_background_threshold=10,
+                        alpha_matting_erode_size=10
+                    )
+            else:
+                output = remove(pil_image, session=rembg_session, alpha_matting=True)
+            
+            output_array = np.array(output)
+            if output_array.shape[2] == 4:
+                mask = output_array[:, :, 3].astype(np.float32) / 255.0
+            else:
+                mask = np.ones((frame.shape[0], frame.shape[1]), dtype=np.float32)
             
-        return methods[0]  # Return first method
+            return mask
+        return None
+    except Exception as e:
+        logger.error(f"Rembg segmentation failed: {e}")
+        return None
 
-class AITrainingSimulator:
-    """Simulate AI model training in background"""
-    
-    def __init__(self, ram_monster):
-        self.ram_monster = ram_monster
-        self.models = {}
-        self.training_threads = []
-        self.is_training = False
-        logger.info("AI Training Simulator initialized")
-        
-    def create_fake_model(self, name, size_gb=1):
-        """Create a fake neural network that uses memory"""
-        layers = []
-        remaining = size_gb * 1024 * 1024 * 1024  # bytes
-        
-        while remaining > 0:
-            layer_size = min(remaining, 500 * 1024 * 1024)  # 500MB chunks
-            layer = np.random.randn(layer_size // 4).astype(np.float32)
-            layers.append(layer)
-            remaining -= layer_size
+# OpenCV GPU Segmentation
+def segment_person_opencv_gpu(frame):
+    """OpenCV GPU segmentation"""
+    try:
+        if OPENCV_GPU:
+            gpu_frame = cv2.cuda_GpuMat()
+            gpu_frame.upload(frame)
             
-        self.models[name] = layers
-        self.ram_monster.cache_forever(f'model_{name}', layers)
-        logger.info(f"Created fake model '{name}': {size_gb} GB")
-        return layers
-    
-    def train_forever(self, model_name):
-        """Simulate training that never stops"""
-        if model_name not in self.models:
-            self.create_fake_model(model_name)
+            gpu_hsv = cv2.cuda.cvtColor(gpu_frame, cv2.COLOR_RGB2HSV)
             
-        self.is_training = True
-        iteration = 0
-        
-        while self.is_training:
-            # Fake gradient computation
-            for layer in self.models[model_name]:
-                gradient = np.random.randn(*layer.shape).astype(np.float32)
-                layer += gradient * 0.0001  # Fake weight update
-                
-                # Store gradients too (more memory!)
-                self.ram_monster.cache_forever(
-                    f'gradient_{model_name}_{iteration}', 
-                    gradient
-                )
+            lower_skin = np.array([0, 20, 70])
+            upper_skin = np.array([20, 255, 255])
             
-            iteration += 1
-            if iteration % 100 == 0:
-                logger.info(f"Training iteration {iteration} for {model_name}")
-                # Create checkpoint (more memory!)
-                checkpoint = [np.copy(layer) for layer in self.models[model_name]]
-                self.ram_monster.cache_forever(f'checkpoint_{iteration}', checkpoint)
+            gpu_mask = cv2.cuda.inRange(gpu_hsv, lower_skin, upper_skin)
             
-            time.sleep(0.1)  # Don't burn CPU too hard
-    
-    def start_training(self):
-        """Start multiple training threads"""
-        if ENABLE_AI_TRAINING:
-            models = ['vision_16k', 'super_resolution', 'depth_estimation']
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+            gpu_mask = cv2.cuda.morphologyEx(gpu_mask, cv2.MORPH_CLOSE, kernel)
+            gpu_mask = cv2.cuda.morphologyEx(gpu_mask, cv2.MORPH_OPEN, kernel)
             
-            for model in models:
-                thread = threading.Thread(
-                    target=self.train_forever, 
-                    args=(model,),
-                    daemon=True
-                )
-                thread.start()
-                self.training_threads.append(thread)
-                logger.info(f"Started training thread for {model}")
-
-@st.cache_resource
-def create_model_zoo():
-    """Load ALL possible models multiple times - BUILD SAFE VERSION"""
-    logger.info("🦁 Creating Model Zoo - Build Safe Mode...")
-    zoo = {}
-    
-    # Background removal models - SAFE IMPORT
-    if REMBG_AVAILABLE:
-        try:
-            from rembg import remove  # Import only after check!
-            models = ['u2net', 'u2netp', 'u2net_human_seg']
-            for model in models:
-                for i in range(3):  # Load each model 3 times
-                    key = f"{model}_v{i}"
-                    try:
-                        session = new_session(model)
-                        zoo[key] = session
-                        logger.info(f"Loaded {key}")
-                    except Exception as e:
-                        logger.warning(f"Could not load {key}: {e}")
-        except ImportError:
-            logger.warning("Could not import remove from rembg")
-    
-    # Vision transformers - SAFE
-    if TRANSFORMERS_AVAILABLE and TORCH_AVAILABLE:
-        try:
-            from transformers import AutoModel, AutoProcessor
-            vit_models = [
-                'google/vit-base-patch16-224',
-                'facebook/deit-base-patch16-224',
-                'microsoft/resnet-50'
-            ]
-            for model_name in vit_models:
-                for i in range(2):
-                    try:
-                        model = AutoModel.from_pretrained(model_name)
-                        processor = AutoProcessor.from_pretrained(model_name)
-                        zoo[f"{model_name.split('/')[-1]}_v{i}"] = (model, processor)
-                        logger.info(f"Loaded {model_name} v{i}")
-                    except Exception as e:
-                        logger.warning(f"Could not load {model_name}: {e}")
-        except Exception as e:
-            logger.warning(f"Could not load vision transformers: {e}")
-    
-    # Timm models - SAFE
-    if TIMM_AVAILABLE and TORCH_AVAILABLE:
-        try:
-            timm_models = ['resnet50', 'efficientnet_b0', 'mobilenetv3_large_100']
-            for model_name in timm_models:
-                for i in range(2):
-                    try:
-                        model = timm.create_model(model_name, pretrained=True)
-                        zoo[f"timm_{model_name}_v{i}"] = model
-                        logger.info(f"Loaded timm {model_name} v{i}")
-                    except Exception as e:
-                        logger.warning(f"Could not load timm {model_name}: {e}")
-        except Exception as e:
-            logger.warning(f"Could not load timm models: {e}")
-    
-    # Segment Anything - SAFE
-    if SEGMENT_AVAILABLE and TORCH_AVAILABLE:
-        try:
-            sam_checkpoints = ['sam_vit_b', 'sam_vit_l', 'sam_vit_h']
-            for checkpoint in sam_checkpoints:
-                try:
-                    # Would need actual checkpoint files
-                    zoo[f"sam_{checkpoint}"] = f"Placeholder for {checkpoint}"
-                    logger.info(f"Loaded SAM {checkpoint}")
-                except Exception as e:
-                    logger.warning(f"Could not load SAM {checkpoint}: {e}")
-        except Exception as e:
-            logger.warning(f"Could not load SAM models: {e}")
-    
-    logger.info(f"Model Zoo created with {len(zoo)} models")
-    return zoo
+            mask = gpu_mask.download()
+            
+            del gpu_frame, gpu_hsv, gpu_mask
+            
+            return mask.astype(float) / 255
+        else:
+            return segment_person_fallback_cpu(frame)
+    except Exception as e:
+        logger.error(f"OpenCV GPU segmentation failed: {e}")
+        return segment_person_fallback_cpu(frame)
 
-@st.cache_resource
-def load_all_libraries():
-    """Preload as many libraries as possible"""
-    libraries = []
-    
-    # Try to import everything
-    imports = [
-        'pandas', 'sklearn', 'scipy', 'matplotlib', 'seaborn',
-        'plotly', 'networkx', 'nltk', 'spacy', 'gensim',
-        'xgboost', 'lightgbm', 'catboost', 'tensorflow',
-        'keras', 'jax', 'optax', 'flax', 'datasets',
-        'tokenizers', 'accelerate', 'peft', 'bitsandbytes'
-    ]
-    
-    for lib in imports:
-        try:
-            module = __import__(lib)
-            libraries.append(module)
-            logger.info(f"Loaded {lib}")
-        except ImportError:
-            logger.debug(f"Could not load {lib}")
-    
-    return libraries
+def segment_person_fallback_cpu(frame):
+    """CPU fallback segmentation"""
+    try:
+        hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)
+        lower_skin = np.array([0, 20, 70])
+        upper_skin = np.array([20, 255, 255])
+        mask = cv2.inRange(hsv, lower_skin, upper_skin)
+        
+        kernel = np.ones((5, 5), np.uint8)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+        
+        return mask.astype(float) / 255
+    except Exception as e:
+        logger.error(f"CPU fallback segmentation failed: {e}")
+        return None
 
-class GPUMaximizer:
-    """Use all available GPU memory"""
-    
-    def __init__(self):
-        self.tensors = []
-        self.models = []
-        
-    def allocate_vram(self):
-        """Allocate as much VRAM as possible"""
-        if not TORCH_AVAILABLE:
-            logger.warning("PyTorch not available for GPU allocation")
-            return
+# Video Processing
+def process_video_gpu_optimized(video_path, background_url, progress_callback=None):
+    """GPU-optimized video processing"""
+    try:
+        background_image = load_background_image(background_url)
+        
+        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))
+        
+        logger.info(f"Processing video: {width}x{height}, {total_frames} frames, {fps} FPS")
+        
+        output_path = tempfile.mktemp(suffix='.mp4')
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        
+        background_resized = cv2.resize(background_image, (width, height))
+        
+        frame_count = 0
+        batch_size = 4 if CUDA_AVAILABLE else 1
+        frame_batch = []
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                if frame_batch:
+                    processed_batch = process_frame_batch(frame_batch, background_resized)
+                    for processed_frame in processed_batch:
+                        out.write(processed_frame)
+                break
             
-        try:
-            import torch
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frame_batch.append(frame_rgb)
             
-            if torch.cuda.is_available():
-                device = torch.device('cuda')
-                
-                # Get available VRAM
-                gpu = GPUtil.getGPUs()[0]
-                available_vram = gpu.memoryFree
+            if len(frame_batch) >= batch_size:
+                processed_batch = process_frame_batch(frame_batch, background_resized)
                 
-                # Allocate in chunks
-                chunk_size = 1024 * 1024 * 1024  # 1GB chunks
-                allocated = 0
-                
-                while allocated < TARGET_VRAM_GB * 1024:
-                    try:
-                        tensor = torch.zeros(
-                            chunk_size // 4, 
-                            dtype=torch.float32, 
-                            device=device
+                for processed_frame in processed_batch:
+                    out.write(processed_frame)
+                    frame_count += 1
+                    
+                    if progress_callback:
+                        progress = frame_count / total_frames
+                        memory_stats = get_memory_usage()
+                        progress_callback(
+                            progress, 
+                            f"GPU Processing: {frame_count}/{total_frames} | "
+                            f"GPU: {memory_stats['gpu_allocated']:.1f}GB | "
+                            f"RAM: {memory_stats['ram_percent']:.1f}%"
                         )
-                        self.tensors.append(tensor)
-                        allocated += chunk_size / (1024 * 1024)  # MB
-                        logger.info(f"Allocated {allocated:.0f} MB on GPU")
-                    except RuntimeError:
-                        logger.info(f"GPU allocation stopped at {allocated:.0f} MB")
-                        break
-                        
-                # Load some models to GPU
-                if TRANSFORMERS_AVAILABLE:
-                    try:
-                        from transformers import AutoModel
-                        model = AutoModel.from_pretrained('bert-base-uncased')
-                        model = model.to(device)
-                        self.models.append(model)
-                        logger.info("Loaded BERT to GPU")
-                    except Exception as e:
-                        logger.warning(f"Could not load model to GPU: {e}")
-                        
-        except Exception as e:
-            logger.warning(f"GPU allocation failed: {e}")
+                
+                frame_batch = []
+                optimize_memory()
+        
+        cap.release()
+        out.release()
+        optimize_memory()
+        
+        logger.info(f"Video processing complete: {output_path}")
+        return output_path
+        
+    except Exception as e:
+        logger.error(f"GPU video processing failed: {e}")
+        return None
 
-def create_background_threads(ram_monster, video_processor, ai_trainer):
-    """Create all background threads"""
-    threads = []
-    
-    # Memory allocation thread
-    def allocate_memory_gradually():
-        while ram_monster.allocation_phase < 5:
-            if ram_monster.allocate_base_memory():
-                time.sleep(2)  # Wait 2 seconds between phases
-            else:
-                break
-        ram_monster.duplicate_everything()
-    
-    threads.append(threading.Thread(target=allocate_memory_gradually, daemon=True))
-    
-    # History accumulation thread
-    def accumulate_history():
-        while True:
-            data = np.random.randn(1000, 1000).astype(np.float32)
-            ram_monster.add_to_infinite_history(data)
-            time.sleep(1)
-    
-    if ENABLE_INFINITE_HISTORY:
-        threads.append(threading.Thread(target=accumulate_history, daemon=True))
-    
-    # 16K processing thread
-    def process_16k():
-        while True:
-            frame = np.random.randint(0, 255, (1080, 1920, 3), dtype=np.uint8)
-            video_processor.upscale_to_16k(frame)
-            time.sleep(2)
+def process_frame_batch(frame_batch, background_resized):
+    """Process batch of frames"""
+    processed_frames = []
     
-    if ENABLE_16K:
-        threads.append(threading.Thread(target=process_16k, daemon=True))
-    
-    # Start all threads
-    for thread in threads:
-        thread.start()
+    for frame in frame_batch:
+        person_mask = None
+        method_used = "None"
+        
+        # Try SAM2 first
+        if SAM_AVAILABLE and CUDA_AVAILABLE:
+            person_mask = segment_person_sam2(frame)
+            if person_mask is not None:
+                method_used = "SAM2-GPU"
+        
+        # Try Rembg
+        if person_mask is None and REMBG_AVAILABLE:
+            person_mask = segment_person_rembg(frame)
+            if person_mask is not None:
+                method_used = "Rembg-GPU"
         
-    return threads
+        # Try OpenCV GPU
+        if person_mask is None and OPENCV_GPU:
+            person_mask = segment_person_opencv_gpu(frame)
+            if person_mask is not None:
+                method_used = "OpenCV-GPU"
+        
+        # CPU fallback
+        if person_mask is None:
+            person_mask = segment_person_fallback_cpu(frame)
+            method_used = "CPU-Fallback"
+        
+        if person_mask is not None:
+            if person_mask.ndim == 2:
+                person_mask = np.expand_dims(person_mask, axis=2)
+            
+            final_frame = frame * person_mask + background_resized * (1 - person_mask)
+            final_frame = final_frame.astype(np.uint8)
+        else:
+            final_frame = frame
+        
+        final_frame_bgr = cv2.cvtColor(final_frame, cv2.COLOR_RGB2BGR)
+        processed_frames.append(final_frame_bgr)
+    
+    return processed_frames
 
+# Streamlit UI
 def main():
     st.set_page_config(
-        page_title="BackgroundFX - RAM Monster Edition",
-        page_icon="🔥",
-        layout="wide"
+        page_title="VideoBackgroundFX - SAM2 GPU",
+        page_icon="🚀",
+        layout="wide",
+        initial_sidebar_state="expanded"
     )
     
-    st.title("🔥 BackgroundFX - ULTIMATE RAM DESTROYER 🔥")
-    st.caption("Now with Build-Safe Gradual Memory Allocation!")
-    
-    # Initialize systems
-    if 'ram_monster' not in st.session_state:
-        with st.spinner("🚀 Initializing RAM Monster..."):
-            st.session_state.ram_monster = RAMMonster()
-            st.session_state.video_processor = SixteenKVideoProcessor(st.session_state.ram_monster)
-            st.session_state.ai_trainer = AITrainingSimulator(st.session_state.ram_monster)
-            st.session_state.gpu_maximizer = GPUMaximizer()
-            st.session_state.model_zoo = create_model_zoo()
-            st.session_state.libraries = load_all_libraries()
-            
-            # Start background processes
-            st.session_state.threads = create_background_threads(
-                st.session_state.ram_monster,
-                st.session_state.video_processor,
-                st.session_state.ai_trainer
-            )
-            
-            # Start AI training
-            st.session_state.ai_trainer.start_training()
-            
-            # Allocate GPU memory
-            st.session_state.gpu_maximizer.allocate_vram()
-    
-    # Live RAM ticker
-    ram_placeholder = st.empty()
-    
-    def update_ram_ticker():
-        while True:
-            ram_usage = st.session_state.ram_monster.get_ram_usage()
-            
-            # Get GPU usage
-            gpu_usage = 0
-            try:
-                gpus = GPUtil.getGPUs()
-                if gpus:
-                    gpu_usage = gpus[0].memoryUsed
-            except:
-                pass
-            
-            ram_placeholder.metric(
-                "RAM Monster Status",
-                f"RAM: {ram_usage:.2f} GB | GPU: {gpu_usage:.0f} MB",
-                f"Phase: {st.session_state.ram_monster.allocation_phase}/5"
-            )
-            time.sleep(1)
-    
-    # Start RAM ticker thread
-    ticker_thread = threading.Thread(target=update_ram_ticker, daemon=True)
-    ticker_thread.start()
-    
-    # UI Tabs
-    tab1, tab2, tab3, tab4, tab5 = st.tabs([
-        "🎬 Background Removal", 
-        "🎮 16K Processing", 
-        "🤖 AI Training", 
-        "📊 Memory Stats",
-        "🔬 Experiments"
-    ])
-    
-    with tab1:
-        st.header("Background Removal Suite")
+    st.title("🚀 VideoBackgroundFX - SAM2 GPU-Optimized")
+    st.markdown("**High-performance video background replacement with SAM2 & GPU acceleration**")
+    
+    # GPU Status Dashboard
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        if CUDA_AVAILABLE:
+            st.success(f"🚀 GPU: {GPU_NAME}")
+            st.caption(f"{GPU_MEMORY:.1f}GB VRAM")
+        else:
+            st.warning("⚠️ CPU Mode")
+    
+    with col2:
+        if SAM_AVAILABLE and CUDA_AVAILABLE:
+            st.success("✅ SAM2-GPU")
+        elif REMBG_AVAILABLE:
+            st.success("✅ Rembg-GPU")
+        else:
+            st.warning("⚠️ Basic Mode")
+    
+    with col3:
+        if OPENCV_GPU:
+            st.success("✅ OpenCV-GPU")
+        else:
+            st.info("ℹ️ OpenCV-CPU")
+    
+    with col4:
+        memory_stats = get_memory_usage()
+        if CUDA_AVAILABLE:
+            st.metric("GPU Memory", f"{memory_stats['gpu_allocated']:.1f}GB")
+        else:
+            st.info("CPU Processing")
+    
+    # Sidebar monitoring
+    with st.sidebar:
+        st.markdown("### 🚀 System Performance")
         
-        col1, col2 = st.columns(2)
-        with col1:
-            uploaded_file = st.file_uploader("Choose an image...", type=['png', 'jpg', 'jpeg'])
-            
-            if st.button("Process with ALL Models"):
-                if uploaded_file and REMBG_AVAILABLE:
-                    from rembg import remove
-                    
-                    # Process with all models
-                    image = Image.open(uploaded_file)
-                    
-                    # Store original multiple times
-                    for i in range(10):
-                        st.session_state.ram_monster.cache_forever(f'original_{i}', np.array(image))
-                    
-                    # Process with each model
-                    for model_key in st.session_state.model_zoo:
-                        if 'u2net' in model_key:
-                            output = remove(image, session=st.session_state.model_zoo[model_key])
-                            st.session_state.ram_monster.cache_forever(f'removed_{model_key}', np.array(output))
-                            with col2:
-                                st.image(output, caption=f"Processed with {model_key}")
-                else:
-                    st.warning("Upload an image first or rembg not available")
+        memory_stats = get_memory_usage()
         
-        with col2:
-            st.info(f"Models loaded: {len(st.session_state.model_zoo)}")
-            st.info(f"Cache size: {len(st.session_state.ram_monster.cache)} categories")
-    
-    with tab2:
-        st.header("16K Video Processing")
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("Create 16K Buffer"):
-                buffer = st.session_state.video_processor.create_16k_buffer()
-                st.success(f"Created buffer: {buffer.shape}")
+        if CUDA_AVAILABLE:
+            st.metric("GPU Allocated", f"{memory_stats['gpu_allocated']:.2f}GB")
+            st.metric("GPU Reserved", f"{memory_stats['gpu_reserved']:.2f}GB")
+            st.metric("GPU Free", f"{memory_stats['gpu_free']:.2f}GB")
             
-            if st.button("Generate & Upscale Random Frames"):
-                progress = st.progress(0)
-                for i in range(10):
-                    frame = np.random.randint(0, 255, (1080, 1920, 3), dtype=np.uint8)
-                    upscaled = st.session_state.video_processor.upscale_to_16k(frame)
-                    progress.progress((i + 1) / 10)
-                st.success("Generated 10 16K frames!")
-        
-        with col2:
-            st.info(f"Buffers in memory: {len(st.session_state.video_processor.buffers)}")
-            total_buffer_size = sum(
-                b.nbytes for b in st.session_state.video_processor.buffers.values()
-            ) / (1024**3)
-            st.metric("Buffer Memory", f"{total_buffer_size:.2f} GB")
-    
-    with tab3:
-        st.header("AI Training Simulator")
+            usage_percent = (memory_stats['gpu_reserved'] / GPU_MEMORY) * 100
+            st.progress(usage_percent / 100)
+            st.caption(f"{usage_percent:.1f}% GPU Memory Used")
         
-        col1, col2 = st.columns(2)
-        with col1:
-            model_name = st.text_input("Model name", "custom_model")
-            model_size = st.slider("Model size (GB)", 1, 5, 2)
-            
-            if st.button("Create & Train Model"):
-                st.session_state.ai_trainer.create_fake_model(model_name, model_size)
-                thread = threading.Thread(
-                    target=st.session_state.ai_trainer.train_forever,
-                    args=(model_name,),
-                    daemon=True
-                )
-                thread.start()
-                st.success(f"Started training {model_name}")
+        st.metric("RAM Used", f"{memory_stats['ram_used']:.1f}GB")
+        st.metric("RAM Total", f"{memory_stats['ram_total']:.1f}GB")
+        st.progress(memory_stats['ram_percent'] / 100)
+        st.caption(f"{memory_stats['ram_percent']:.1f}% RAM Used")
         
-        with col2:
-            st.info(f"Models training: {len(st.session_state.ai_trainer.models)}")
-            st.info(f"Active threads: {len(st.session_state.ai_trainer.training_threads)}")
-            
-            if st.button("Stop All Training"):
-                st.session_state.ai_trainer.is_training = False
-                st.success("Training stopped")
-    
-    with tab4:
-        st.header("📊 Memory Statistics")
-        
-        # Refresh button
-        if st.button("🔄 Refresh Stats"):
-            st.rerun()
+        st.markdown("---")
+        st.markdown("### 🛠️ Processing Methods")
+        methods = []
         
-        col1, col2, col3 = st.columns(3)
+        if SAM_AVAILABLE and CUDA_AVAILABLE:
+            methods.append("🚀 SAM2-GPU (Ultra Precise)")
+        if REMBG_AVAILABLE:
+            methods.append("✅ Rembg-GPU (High Quality)")
+        if OPENCV_GPU:
+            methods.append("⚡ OpenCV-GPU (Fast)")
+        methods.append("💻 CPU Fallback")
         
-        with col1:
-            st.metric("RAM Usage", f"{st.session_state.ram_monster.get_ram_usage():.2f} GB")
-            st.metric("Target RAM", f"{TARGET_RAM_GB} GB")
-            st.metric("Arrays", len(st.session_state.ram_monster.arrays))
+        for method in methods:
+            st.markdown(method)
+    
+    # Main interface
+    col1, col2 = st.columns(2)
+    
+    # Initialize session state
+    if 'video_path' not in st.session_state:
+        st.session_state.video_path = None
+    if 'video_bytes' not in st.session_state:
+        st.session_state.video_bytes = None
+    if 'video_name' not in st.session_state:
+        st.session_state.video_name = None
+    
+    with col1:
+        st.markdown("### 📹 Upload Video")
+        uploaded_video = st.file_uploader(
+            "Choose a video file", 
+            type=['mp4', 'avi', 'mov', 'mkv'],
+            help="Upload video for SAM2 GPU processing"
+        )
         
-        with col2:
-            st.metric("Cache Entries", len(st.session_state.ram_monster.cache))
-            st.metric("History Items", len(st.session_state.ram_monster.history))
-            st.metric("Training Data", len(st.session_state.ram_monster.training_data))
+        if uploaded_video:
+            if st.session_state.video_name != uploaded_video.name:
+                st.success(f"✅ Video uploaded: {uploaded_video.name}")
+                
+                video_bytes = uploaded_video.read()
+                
+                with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
+                    tmp_file.write(video_bytes)
+                    video_path = tmp_file.name
+                
+                st.session_state.video_path = video_path
+                st.session_state.video_bytes = video_bytes
+                st.session_state.video_name = uploaded_video.name
+            
+            if st.session_state.video_bytes is not None:
+                st.video(st.session_state.video_bytes)
         
-        with col3:
-            try:
-                gpus = GPUtil.getGPUs()
-                if gpus:
-                    gpu = gpus[0]
-                    st.metric("GPU Memory Used", f"{gpu.memoryUsed:.0f} MB")
-                    st.metric("GPU Memory Free", f"{gpu.memoryFree:.0f} MB")
-                    st.metric("GPU Utilization", f"{gpu.load * 100:.1f}%")
-            except:
-                st.info("No GPU detected")
-        
-        # Detailed breakdown
-        st.subheader("Memory Breakdown")
-        breakdown = []
-        for key, value in st.session_state.ram_monster.arrays.items():
-            if isinstance(value, np.ndarray):
-                size_gb = value.nbytes / (1024**3)
-                breakdown.append({"Array": key, "Size (GB)": f"{size_gb:.3f}", "Shape": str(value.shape)})
-        
-        if breakdown:
-            st.dataframe(breakdown)
+        elif st.session_state.video_path:
+            st.success(f"✅ Video ready: {st.session_state.video_name}")
+            st.video(st.session_state.video_bytes)
     
-    with tab5:
-        st.header("🔬 Extreme Experiments")
+    with col2:
+        st.markdown("### 🖼️ Background Selection")
         
-        st.warning("⚠️ These will likely crash the app!")
+        background_options = get_professional_backgrounds()
+        selected_background = st.selectbox(
+            "Choose background",
+            options=list(background_options.keys()),
+            index=0
+        )
         
-        col1, col2 = st.columns(2)
+        background_url = background_options[selected_background]
         
-        with col1:
-            st.subheader("Memory Bombs")
-            
-            if st.button("💣 32GB Instant Allocation"):
-                try:
-                    bomb = np.zeros((8192, 1024, 1024), dtype=np.float32)
-                    st.session_state.ram_monster.arrays['32gb_bomb'] = bomb
-                    st.success("32GB allocated instantly!")
-                except MemoryError:
-                    st.error("Memory allocation failed!")
-            
-            if st.button("🔄 Infinite Loop Allocation"):
-                with st.spinner("Allocating until crash..."):
-                    i = 0
-                    while True:
-                        try:
-                            arr = np.zeros((1024, 1024, 256), dtype=np.float32)
-                            st.session_state.ram_monster.cache_forever(f'infinite_{i}', arr)
-                            i += 1
-                            if i % 10 == 0:
-                                st.write(f"Allocated {i} GB...")
-                        except MemoryError:
-                            st.error(f"Crashed after {i} GB")
-                            break
-        
-        with col2:
-            st.subheader("GPU Stress Tests")
+        try:
+            background_image = load_background_image(background_url)
+            st.image(background_image, caption=f"Background: {selected_background}", use_container_width=True)
+        except:
+            st.error("Failed to load background image")
+    
+    # Processing button
+    if (uploaded_video or st.session_state.video_path) and st.button("🚀 Process with SAM2", type="primary"):
+        video_path = st.session_state.video_path
+        
+        if video_path and os.path.exists(video_path):
+            progress_bar = st.progress(0)
+            status_text = st.empty()
             
-            if st.button("🎮 Max GPU Allocation"):
-                if TORCH_AVAILABLE:
-                    import torch
-                    if torch.cuda.is_available():
-                        try:
-                            # Allocate all available VRAM
-                            total = 0
-                            tensors = []
-                            while total < 24 * 1024:  # 24GB
-                                t = torch.zeros(256, 1024, 1024, device='cuda')
-                                tensors.append(t)
-                                total += 1024  # 1GB
-                                st.write(f"Allocated {total / 1024:.1f} GB on GPU")
-                        except RuntimeError as e:
-                            st.error(f"GPU allocation failed: {e}")
-                else:
-                    st.warning("PyTorch not available")
+            def update_progress(progress, message):
+                progress_bar.progress(progress)
+                status_text.text(message)
             
-            if st.button("🧠 Train 10 Models Simultaneously"):
-                for i in range(10):
-                    model_name = f"stress_model_{i}"
-                    st.session_state.ai_trainer.create_fake_model(model_name, 1)
-                    thread = threading.Thread(
-                        target=st.session_state.ai_trainer.train_forever,
-                        args=(model_name,),
-                        daemon=True
-                    )
-                    thread.start()
-                st.success("Started 10 training threads!")
-        
-        st.divider()
-        
-        # Final boss
-        if st.checkbox("☠️ ENABLE FINAL BOSS MODE"):
-            if st.button("💀 ACTIVATE EVERYTHING AT ONCE"):
-                st.balloons()
-                st.error("INITIATING TOTAL SYSTEM DESTRUCTION...")
-                
-                # Start everything
-                threads = []
-                
-                # Allocate maximum memory
-                for i in range(5):
-                    threads.append(threading.Thread(
-                        target=lambda: st.session_state.ram_monster.allocate_base_memory(),
-                        daemon=True
-                    ))
-                
-                # Train 20 models
-                for i in range(20):
-                    threads.append(threading.Thread(
-                        target=st.session_state.ai_trainer.train_forever,
-                        args=(f"destroyer_{i}",),
-                        daemon=True
-                    ))
-                
-                # Process 16K video
-                for i in range(5):
-                    threads.append(threading.Thread(
-                        target=lambda: st.session_state.video_processor.create_16k_buffer(30),
-                        daemon=True
-                    ))
-                
-                # Start all threads
-                for t in threads:
-                    t.start()
+            try:
+                result_path = process_video_gpu_optimized(
+                    video_path, 
+                    background_url, 
+                    update_progress
+                )
                 
-                st.error("🔥 ALL SYSTEMS ENGAGED - GOODBYE! 🔥")
+                if result_path and os.path.exists(result_path):
+                    status_text.text("✅ SAM2 processing complete!")
+                    
+                    with open(result_path, 'rb') as f:
+                        result_video = f.read()
+                    
+                    st.video(result_video)
+                    
+                    st.download_button(
+                        "💾 Download SAM2 Processed Video",
+                        data=result_video,
+                        file_name="sam2_backgroundfx_result.mp4",
+                        mime="video/mp4"
+                    )
+                    
+                    final_stats = get_memory_usage()
+                    st.success(f"🚀 SAM2 processing complete! GPU: {final_stats['gpu_allocated']:.2f}GB, RAM: {final_stats['ram_percent']:.1f}%")
+                    
+                    os.unlink(result_path)
+                else:
+                    st.error("❌ SAM2 processing failed!")
+                    
+            except Exception as e:
+                st.error(f"❌ Error during SAM2 processing: {str(e)}")
+                logger.error(f"SAM2 processing error: {e}")
+        else:
+            st.error("Video file not found. Please upload again.")
 
 if __name__ == "__main__":
-    main()
+    main()