Update app.py

app.py

@@ -1,183 +1,82 @@
-#!/usr/bin/env python3
-"""
-BackgroundFX - Video Background Replacement with Green Screen Workflow
-Fixed for Hugging Face Space - Handles video preview issues
-FIXED: Video display issue by properly handling file stream
-Updated: 2025-08-13 - PROPER FIX: Removed restart loop but kept all advanced features
-IMPROVED: Added rembg as primary fallback when SAM2 unavailable
-"""
-
-import streamlit as st
-import cv2
-import numpy as np
-import tempfile
-import os
-from PIL import Image
-import requests
-from io import BytesIO
-import logging
-import base64
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# FIXED: Clean GPU setup without restart loop
-def setup_environment():
-    """Setup environment variables without restart loop"""
-    os.environ['OMP_NUM_THREADS'] = '4'
-    os.environ['ORT_PROVIDERS'] = 'CUDAExecutionProvider,CPUExecutionProvider'
-    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
-    os.environ['TORCH_CUDA_ARCH_LIST'] = '7.5'
-    
-    # Check GPU availability
-    try:
-        import torch
-        if torch.cuda.is_available():
-            gpu_name = torch.cuda.get_device_name(0)
-            logger.info(f"🚀 GPU: {gpu_name}")
-            torch.cuda.init()
-            torch.cuda.set_device(0)
-            dummy = torch.zeros(1).cuda()
-            del dummy
-            torch.cuda.empty_cache()
-            return True, gpu_name
-        else:
-            logger.warning("⚠️ CUDA not available")
-            return False, None
-    except ImportError:
-        logger.warning("⚠️ PyTorch not available")
-        return False, None
-
-# Initialize environment (NO RESTART LOOP!)
-CUDA_AVAILABLE, GPU_NAME = setup_environment()
-
-# Try to import SAM2 and MatAnyone (PRESERVED FROM ORIGINAL)
-try:
-    from sam2.build_sam import build_sam2_video_predictor
-    from sam2.sam2_image_predictor import SAM2ImagePredictor
-    SAM2_AVAILABLE = True
-    logger.info("✅ SAM2 loaded successfully")
-except ImportError as e:
-    SAM2_AVAILABLE = False
-    logger.warning(f"⚠️ SAM2 not available: {e}")
+# TILFØJ DISSE ÆNDRINGER TIL DIN app.py:
 
-try:
-    import matanyone
-    MATANYONE_AVAILABLE = True
-    logger.info("✅ MatAnyone loaded successfully")
-except ImportError as e:
-    MATANYONE_AVAILABLE = False
-    logger.warning(f"⚠️ MatAnyone not available: {e}")
-
-# Import rembg with proper error handling (NO RESTART!)
+# 1. RETTELSE: Rembg GPU providers (omkring linje 65)
+# ERSTAT din rembg initialization med:
 try:
     from rembg import remove, new_session
+    import onnxruntime as ort
+    
     REMBG_AVAILABLE = True
     logger.info("✅ Rembg loaded")
-    # Initialize rembg session
-    rembg_session = new_session('u2net_human_seg')
-except ImportError:
-    REMBG_AVAILABLE = False
-    rembg_session = None
-    logger.warning("⚠️ Rembg not available")
-
-# Import advanced matting libraries (PRESERVED)
-try:
-    import pymatting
-    PYMATTING_AVAILABLE = True
-    logger.info("✅ PyMatting loaded for advanced matting")
-except ImportError:
-    PYMATTING_AVAILABLE = False
-    logger.info("ℹ️ PyMatting not available")
-
-# PRESERVED: All original functions
-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 default brick wall background
-        return create_default_background()
-
-def create_default_background():
-    """Create a default brick wall background"""
-    # Create a simple brick pattern
-    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 check_premium_access():
-    """Check if user has premium access - placeholder for now"""
-    # This would integrate with your authentication system
-    return True  # For demo purposes
-
-def get_professional_backgrounds():
-    """Get professional background collection for premium users"""
-    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"
-    }
-
-def get_basic_backgrounds():
-    """Get basic background collection for free users"""
-    return {
-        "🧱 Brick Wall": "default_brick",
-        "🌫️ Soft Blur": "https://images.unsplash.com/photo-1557683316-973673baf926?w=1920&h=1080&fit=crop&blur=20",
-        "🌊 Ocean Blue": "https://images.unsplash.com/photo-1439066615861-d1af74d74000?w=1920&h=1080&fit=crop",
-        "🌿 Nature Green": "https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=1920&h=1080&fit=crop"
-    }
+    # FORCE GPU providers for ONNX
+    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'
+        ]
+        
+        # Create session with explicit GPU providers
+        rembg_session = new_session('u2net_human_seg', providers=providers)
+        
+        # VIGTIGT: Warm up the model on GPU
+        dummy_img = Image.new('RGB', (512, 512), color='white')
+        with torch.cuda.amp.autocast():  # Use mixed precision
+            _ = remove(dummy_img, session=rembg_session)
+        
+        logger.info(f"✅ Rembg GPU session initialized with providers: {providers}")
+    else:
+        rembg_session = new_session('u2net_human_seg')
+        logger.info("✅ Rembg CPU session initialized")
 
-# IMPROVED: Enhanced segmentation functions with rembg
-def segment_person_sam2(frame):
-    """Segment person using SAM2 - advanced method"""
-    try:
-        if SAM2_AVAILABLE:
-            # SAM2 implementation would go here
-            # For now, return None to fall back to other methods
-            logger.debug("SAM2 segmentation attempted")
-        return None
-    except Exception as e:
-        logger.error(f"SAM2 segmentation failed: {e}")
-        return None
-
-def segment_person_rembg(frame):
-    """Segment person using rembg - high quality fallback"""
+except ImportError as e:
+    REMBG_AVAILABLE = False
+    rembg_session = None
+    logger.warning(f"⚠️ Rembg not available: {e}")
+
+# 2. TILFØJ: Mixed precision for bedre GPU performance
+# Tilføj efter torch imports:
+if CUDA_AVAILABLE:
+    # Enable TF32 for better performance on L4
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.backends.cudnn.benchmark = True
+    torch.backends.cudnn.deterministic = False
+
+# 3. FORBEDRET: segment_person_rembg_optimized funktion
+def segment_person_rembg_optimized(frame):
+    """Optimized rembg segmentation with GPU acceleration"""
     try:
         if REMBG_AVAILABLE and rembg_session:
             # Convert frame to PIL Image
             pil_image = Image.fromarray(frame)
             
-            # Remove background using rembg
-            output = remove(pil_image, session=rembg_session, alpha_matting=True)
+            # Use GPU memory efficiently
+            if CUDA_AVAILABLE:
+                # Process with mixed precision for L4
+                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)
             
             # Extract alpha channel as mask
             output_array = np.array(output)
             if output_array.shape[2] == 4:
-                mask = output_array[:, :, 3].astype(float) / 255.0
+                mask = output_array[:, :, 3].astype(np.float32) / 255.0  # Use float32
             else:
-                # If no alpha channel, create mask from difference
-                mask = np.ones((frame.shape[0], frame.shape[1]))
+                mask = np.ones((frame.shape[0], frame.shape[1]), dtype=np.float32)
             
             return mask
         return None
@@ -185,493 +84,45 @@ def segment_person_rembg(frame):
         logger.error(f"Rembg segmentation failed: {e}")
         return None
 
-def segment_person_fallback(frame):
-    """Fallback person segmentation using color-based method"""
-    try:
-        # First try rembg if available
-        if REMBG_AVAILABLE:
-            mask = segment_person_rembg(frame)
-            if mask is not None:
-                return mask
-        
-        # Otherwise use simple skin color detection as fallback
-        hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)
-        
-        # Define skin color range
-        lower_skin = np.array([0, 20, 70])
-        upper_skin = np.array([20, 255, 255])
-        
-        mask = cv2.inRange(hsv, lower_skin, upper_skin)
-        
-        # Clean up the mask
-        kernel = np.ones((5, 5), np.uint8)
-        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
-        
-        # Convert to 0-1 range
-        return mask.astype(float) / 255
-        
-    except Exception as e:
-        logger.error(f"Fallback segmentation failed: {e}")
-        return None
-
-def insert_green_screen(frame, person_mask):
-    """Insert green screen behind person"""
-    try:
-        # Create green background
-        green_bg = np.zeros_like(frame)
-        green_bg[:, :] = [0, 255, 0]  # Pure green
-        
-        # Ensure mask is the right shape
-        if person_mask.ndim == 2:
-            person_mask = np.expand_dims(person_mask, axis=2)
-        
-        # Composite person on green background
-        result = frame * person_mask + green_bg * (1 - person_mask)
-        return result.astype(np.uint8)
-        
-    except Exception as e:
-        logger.error(f"Green screen insertion failed: {e}")
-        return frame
-
-def chroma_key_replacement(green_screen_frame, background_image):
-    """Replace green screen with background using chroma key"""
-    try:
-        # Resize background to match frame
-        h, w = green_screen_frame.shape[:2]
-        background_resized = cv2.resize(background_image, (w, h))
-        
-        # Convert to HSV for better green detection
-        hsv = cv2.cvtColor(green_screen_frame, cv2.COLOR_RGB2HSV)
-        
-        # Define green color range for chroma key
-        lower_green = np.array([40, 50, 50])
-        upper_green = np.array([80, 255, 255])
-        
-        # Create mask for green pixels
-        green_mask = cv2.inRange(hsv, lower_green, upper_green)
-        
-        # Smooth the mask
-        kernel = np.ones((3, 3), np.uint8)
-        green_mask = cv2.morphologyEx(green_mask, cv2.MORPH_CLOSE, kernel)
-        green_mask = cv2.GaussianBlur(green_mask, (5, 5), 0)
-        
-        # Normalize mask to 0-1 range
-        mask_normalized = green_mask.astype(float) / 255
-        
-        # Apply chroma key replacement
-        result = green_screen_frame.copy()
-        for c in range(3):
-            result[:, :, c] = (green_screen_frame[:, :, c] * (1 - mask_normalized) + 
-                              background_resized[:, :, c] * mask_normalized)
-        
-        return result.astype(np.uint8)
-        
-    except Exception as e:
-        logger.error(f"Chroma key replacement failed: {e}")
-        return green_screen_frame
-
-# PRESERVED: Video processing with all features
-def process_video_with_green_screen(video_path, background_url, progress_callback=None):
-    """Process video with proper green screen workflow"""
-    try:
-        # Load background image
-        background_image = load_background_image(background_url)
-        
-        # Open video
-        cap = cv2.VideoCapture(video_path)
-        
-        # Get video properties
-        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))
-        
-        # Create output video writer
-        output_path = tempfile.mktemp(suffix='.mp4')
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-        
-        frame_count = 0
-        
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # Convert BGR to RGB
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
-            # Step 1: Segment person - try methods in order
-            person_mask = None
-            method_used = "None"
-            
-            # Try SAM2 first
-            if SAM2_AVAILABLE:
-                person_mask = segment_person_sam2(frame_rgb)
-                if person_mask is not None:
-                    method_used = "SAM2"
-            
-            # Try rembg if SAM2 didn't work
-            if person_mask is None and REMBG_AVAILABLE:
-                person_mask = segment_person_rembg(frame_rgb)
-                if person_mask is not None:
-                    method_used = "Rembg"
-            
-            # Fall back to color-based method
-            if person_mask is None:
-                person_mask = segment_person_fallback(frame_rgb)
-                if person_mask is not None:
-                    method_used = "Color-based"
-            
-            if person_mask is not None:
-                # Step 2: Insert green screen
-                green_screen_frame = insert_green_screen(frame_rgb, person_mask)
-                
-                # Step 3: Chroma key replacement
-                final_frame = chroma_key_replacement(green_screen_frame, background_image)
-            else:
-                # If segmentation fails, use original frame
-                final_frame = frame_rgb
-                method_used = "No segmentation"
-            
-            # Convert back to BGR for video writer
-            final_frame_bgr = cv2.cvtColor(final_frame, cv2.COLOR_RGB2BGR)
-            out.write(final_frame_bgr)
-            
-            frame_count += 1
-            
-            # Update progress
-            if progress_callback:
-                progress = frame_count / total_frames
-                progress_callback(progress, f"Processing frame {frame_count}/{total_frames} ({method_used})")
-        
-        # Release resources
-        cap.release()
-        out.release()
-        
-        return output_path
-        
-    except Exception as e:
-        logger.error(f"Video processing failed: {e}")
-        return None
-
-def process_video_with_custom_background(video_path, background_array, progress_callback=None):
-    """Process video with custom background array"""
-    try:
-        # Open video
-        cap = cv2.VideoCapture(video_path)
-        
-        # Get video properties
-        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))
-        
-        # Resize background to match video
-        background_resized = cv2.resize(background_array, (width, height))
-        
-        # Create output video writer
-        output_path = tempfile.mktemp(suffix='.mp4')
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-        
-        frame_count = 0
-        
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # Convert BGR to RGB
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
-            # Direct background replacement using rembg if available
-            if REMBG_AVAILABLE:
-                pil_image = Image.fromarray(frame_rgb)
-                output = remove(pil_image, session=rembg_session)
-                output_array = np.array(output)
-                
-                if output_array.shape[2] == 4:
-                    # Use alpha channel for compositing
-                    alpha = output_array[:, :, 3:4] / 255.0
-                    person = output_array[:, :, :3]
-                    final_frame = person * alpha + background_resized * (1 - alpha)
-                    final_frame = final_frame.astype(np.uint8)
-                else:
-                    final_frame = output_array
-            else:
-                # Use green screen workflow
-                person_mask = segment_person_fallback(frame_rgb)
-                if person_mask is not None:
-                    green_screen_frame = insert_green_screen(frame_rgb, person_mask)
-                    final_frame = chroma_key_replacement(green_screen_frame, background_resized)
-                else:
-                    final_frame = frame_rgb
-            
-            # Convert back to BGR for video writer
-            final_frame_bgr = cv2.cvtColor(final_frame, cv2.COLOR_RGB2BGR)
-            out.write(final_frame_bgr)
-            
-            frame_count += 1
-            
-            # Update progress
-            if progress_callback:
-                progress = frame_count / total_frames
-                progress_callback(progress, f"Processing frame {frame_count}/{total_frames}")
-        
-        # Release resources
-        cap.release()
-        out.release()
-        
-        return output_path
-        
-    except Exception as e:
-        logger.error(f"Custom background video processing failed: {e}")
-        return None
-
-# PRESERVED: Streamlit UI with all features
-def main():
-    st.set_page_config(
-        page_title="BackgroundFX - Professional",
-        page_icon="🎬",
-        layout="wide",
-        initial_sidebar_state="expanded"
-    )
-    
-    st.title("🎬 BackgroundFX - Professional Video Background Replacement")
-    st.markdown("**Advanced AI-powered background replacement with green screen workflow**")
-    
-    # Show system status
-    col1, col2, col3, col4 = st.columns(4)
-    
-    with col1:
-        if CUDA_AVAILABLE:
-            st.success(f"✅ GPU: {GPU_NAME}")
-        else:
-            st.warning("⚠️ CPU Mode")
-    
-    with col2:
-        if SAM2_AVAILABLE:
-            st.success("✅ SAM2 Ready")
-        elif REMBG_AVAILABLE:
-            st.success("✅ Rembg Ready")
-        else:
-            st.info("ℹ️ Loading...")
+# 4. TILFØJ: Debug info i sidebar for at verificere GPU usage
+# Tilføj i main() funktionen efter GPU status dashboard:
+with st.sidebar:
+    st.markdown("### 🔍 GPU Debug Info")
     
-    with col3:
-        if MATANYONE_AVAILABLE:
-            st.success("✅ MatAnyone")
-        else:
-            st.info("ℹ️ MatAnyone Loading...")
-    
-    with col4:
-        if PYMATTING_AVAILABLE:
-            st.success("✅ PyMatting")
-        else:
-            st.info("ℹ️ Basic Matting")
-    
-    # Sidebar with method selection
-    with st.sidebar:
-        st.markdown("### 🛠️ Available Methods")
-        methods = []
-        
-        if SAM2_AVAILABLE:
-            methods.append("✅ SAM2 (AI Segmentation)")
-        if REMBG_AVAILABLE:
-            methods.append("✅ Rembg (High Quality)")
-        if MATANYONE_AVAILABLE:
-            methods.append("✅ MatAnyone (Virtual Try-On)")
-        if PYMATTING_AVAILABLE:
-            methods.append("✅ PyMatting (Advanced Edges)")
-        
-        methods.append("✅ Green Screen Workflow")
-        methods.append("✅ Color-based (Fallback)")
-        
-        for method in methods:
-            st.markdown(method)
-        
-        st.markdown("---")
-        st.markdown("### 📊 Processing Stats")
-        if 'frames_processed' not in st.session_state:
-            st.session_state.frames_processed = 0
-        st.metric("Frames Processed", st.session_state.frames_processed)
-    
-    # Main content
-    col1, col2 = st.columns(2)
-    
-    # Initialize session state for video persistence
-    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 the video you want to process"
-        )
-        
-        if uploaded_video:
-            # Check if this is a new video upload
-            if st.session_state.video_name != uploaded_video.name:
-                # Display video info
-                st.success(f"✅ Video uploaded: {uploaded_video.name}")
-                
-                # Read video data once and store it
-                video_bytes = uploaded_video.read()
-                
-                # Save uploaded video to persistent temp file
-                with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
-                    tmp_file.write(video_bytes)
-                    video_path = tmp_file.name
-                
-                # Store in session state for persistence
-                st.session_state.video_path = video_path
-                st.session_state.video_bytes = video_bytes
-                st.session_state.video_name = uploaded_video.name
-            
-            # Show video preview using stored bytes
-            if st.session_state.video_bytes is not None:
-                st.video(st.session_state.video_bytes)
-        
-        elif st.session_state.video_path:
-            # Show previously uploaded video info
-            st.success(f"✅ Video ready: {st.session_state.video_name}")
-            st.video(st.session_state.video_bytes)
-    
-    with col2:
-        st.markdown("### 🖼️ Background Image")
-        
-        # Background selection method
-        background_method = st.radio(
-            "Choose background method:",
-            ["📋 Preset Backgrounds", "📁 Upload Custom Image"],
-            index=0
-        )
-        
-        background_url = None
-        custom_background = None
-        
-        if background_method == "📋 Preset Backgrounds":
-            # Check premium access and get appropriate backgrounds
-            is_premium = check_premium_access()
-            
-            if is_premium:
-                background_options = get_professional_backgrounds()
-                st.info("🎨 **Professional Backgrounds** - Premium collection available!")
-            else:
-                background_options = get_basic_backgrounds()
-                st.info("🆓 **Basic Backgrounds** - Upgrade for professional collection!")
-            
-            selected_background = st.selectbox(
-                "Choose background",
-                options=list(background_options.keys()),
-                index=0
-            )
-            
-            background_url = background_options[selected_background]
-            
-            # Show background preview
-            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")
-        
-        else:  # Upload Custom Image
-            uploaded_background = st.file_uploader(
-                "Upload your background image",
-                type=['jpg', 'jpeg', 'png', 'bmp'],
-                help="Upload a custom background image (JPG, PNG, BMP)"
-            )
-            
-            if uploaded_background:
-                # Load and display custom background
-                try:
-                    custom_background = np.array(Image.open(uploaded_background).convert('RGB'))
-                    st.image(custom_background, caption="Custom Background", use_container_width=True)
-                    st.success(f"✅ Custom background uploaded: {uploaded_background.name}")
-                except Exception as e:
-                    st.error(f"Failed to load custom background: {e}")
-                    custom_background = None
+    if CUDA_AVAILABLE:
+        # Check ONNX providers
+        try:
+            import onnxruntime as ort
+            providers = ort.get_available_providers()
+            gpu_providers = [p for p in providers if 'CUDA' in p or 'Tensorrt' in p]
+            if gpu_providers:
+                st.success(f"✅ ONNX GPU: {', '.join(gpu_providers)}")
             else:
-                st.info("Please upload a background image")
+                st.error("❌ No ONNX GPU providers!")
+            st.info(f"All providers: {providers}")
+        except:
+            st.warning("ONNX Runtime not available")
+        
+        # PyTorch info
+        st.code(f"""
+PyTorch: {torch.__version__}
+CUDA: {torch.version.cuda}
+cuDNN: {torch.backends.cudnn.version()}
+TF32: {torch.backends.cuda.matmul.allow_tf32}
+        """)
     
-    # Process button
-    if (uploaded_video or st.session_state.video_path) and st.button("🎬 Process Video", type="primary"):
-        
-        # Check if background is selected
-        if background_method == "📋 Preset Backgrounds" and not background_url:
-            st.error("Please select a background first!")
-            return
-        elif background_method == "📁 Upload Custom Image" and custom_background is None:
-            st.error("Please upload a background image first!")
-            return
-        
-        # Get video path
-        video_path = st.session_state.video_path
-        
-        if video_path and os.path.exists(video_path):
-            # Create progress tracking
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-            
-            def update_progress(progress, message):
-                progress_bar.progress(progress)
-                status_text.text(message)
-            
-            try:
-                # Use the selected background
-                if background_method == "📋 Preset Backgrounds":
-                    result_path = process_video_with_green_screen(
-                        video_path, 
-                        background_url, 
-                        update_progress
-                    )
-                else:
-                    # Process with custom background
-                    result_path = process_video_with_custom_background(
-                        video_path,
-                        custom_background,
-                        update_progress
-                    )
-                
-                if result_path and os.path.exists(result_path):
-                    status_text.text("✅ Processing complete!")
-                    
-                    # Read the processed video
-                    with open(result_path, 'rb') as f:
-                        result_video = f.read()
-                    
-                    # Display result
-                    st.video(result_video)
-                    
-                    # Download button
-                    st.download_button(
-                        "💾 Download Processed Video",
-                        data=result_video,
-                        file_name="backgroundfx_result.mp4",
-                        mime="video/mp4"
-                    )
-                    
-                    # Update stats
-                    st.session_state.frames_processed += 100  # Approximate
-                    
-                    # Clean up
-                    os.unlink(result_path)
-                else:
-                    st.error("❌ Processing failed!")
-                    
-            except Exception as e:
-                st.error(f"❌ Error during processing: {str(e)}")
-                logger.error(f"Processing error: {e}")
-        else:
-            st.error("Video file not found. Please upload again.")
-
-if __name__ == "__main__":
-    main()
+    # Tilføj knap til at teste GPU allocation
+    if st.button("🧪 Test GPU Allocation"):
+        try:
+            test_size = 2  # GB
+            test_tensor = torch.zeros(
+                (test_size * 256, 1024, 1024), 
+                device='cuda', 
+                dtype=torch.float32
+            )
+            allocated = torch.cuda.memory_allocated() / 1024**3
+            st.success(f"✅ Allocated {allocated:.2f}GB on GPU!")
+            del test_tensor
+            torch.cuda.empty_cache()
+        except Exception as e:
+            st.error(f"❌ GPU allocation failed: {e}")