Update app.py

app.py

@@ -1,20 +1,25 @@
 #!/usr/bin/env python3
 """
-Video Background Replacement - Main Application
-Refactored version with improved error handling, memory management, and configuration
+Video Background Replacement - Main Application Entry Point
+Refactored modular architecture - orchestrates specialized components
+
+This file has been refactored from a monolithic 600+ line structure into
+a clean orchestration layer that coordinates specialized modules:
+- config: Application configuration and environment variables
+- device_manager: Hardware detection and optimization
+- memory_manager: Memory and GPU resource management
+- model_loader: AI model loading and validation
+- video_processor: Core video processing pipeline
+- audio_processor: Audio track handling and FFmpeg operations
+- progress_tracker: Progress monitoring and ETA calculations
+- exceptions: Custom exception classes for better error handling
 """
 
 import os
-import cv2
-import numpy as np
-import torch
-import time
 import logging
 import threading
-import subprocess
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, Callable
-from dataclasses import dataclass
 
 # Configure logging
 logging.basicConfig(
@@ -23,7 +28,7 @@
 )
 logger = logging.getLogger(__name__)
 
-# Apply Gradio schema patch early
+# Apply Gradio schema patch early (before other imports)
 try:
     import gradio_client.utils as gc_utils
     original_get_type = gc_utils.get_type
@@ -44,7 +49,17 @@ def patched_get_type(schema):
 except Exception as e:
     logger.error(f"Gradio patch failed: {e}")
 
-# Import core modules
+# Import modular components
+from config import ProcessingConfig
+from device_manager import DeviceManager
+from memory_manager import MemoryManager
+from model_loader import ModelLoader
+from video_processor import CoreVideoProcessor
+from audio_processor import AudioProcessor
+from progress_tracker import ProgressTracker
+from exceptions import VideoProcessingError, ModelLoadingError, DeviceError
+
+# Import utilities (existing)
 from utilities import (
     segment_person_hq,
     refine_mask_hq,
@@ -54,6 +69,7 @@ def patched_get_type(schema):
     validate_video_file
 )
 
+# Import two-stage processor if available
 try:
     from two_stage_processor import TwoStageProcessor, CHROMA_PRESETS
     TWO_STAGE_AVAILABLE = True
@@ -61,273 +77,82 @@ def patched_get_type(schema):
     TWO_STAGE_AVAILABLE = False
     CHROMA_PRESETS = {'standard': {}}
 
-# Configuration
-@dataclass
-class ProcessingConfig:
-    keyframe_interval: int = int(os.getenv('KEYFRAME_INTERVAL', '5'))
-    frame_skip: int = int(os.getenv('FRAME_SKIP', '1'))
-    memory_cleanup_interval: int = int(os.getenv('MEMORY_CLEANUP_INTERVAL', '30'))
-    max_video_length: int = int(os.getenv('MAX_VIDEO_LENGTH', '300'))  # seconds
-    quality_preset: str = os.getenv('QUALITY_PRESET', 'balanced')
-
-class DeviceManager:
-    """Manage device detection and switching"""
-    
-    @staticmethod
-    def get_optimal_device():
-        if torch.cuda.is_available():
-            try:
-                # Test CUDA functionality
-                test_tensor = torch.tensor([1.0], device='cuda')
-                del test_tensor
-                torch.cuda.empty_cache()
-                device = torch.device("cuda")
-                logger.info(f"Using GPU: {torch.cuda.get_device_name(0)}")
-                return device
-            except Exception as e:
-                logger.warning(f"CUDA test failed: {e}, falling back to CPU")
-        
-        logger.info("Using CPU device")
-        return torch.device("cpu")
-
-class MemoryManager:
-    """Enhanced memory management"""
-    
-    def __init__(self, device):
-        self.device = device
-        self.gpu_available = device.type == 'cuda'
-        
-    def cleanup_aggressive(self):
-        import gc
-        gc.collect()
-        if self.gpu_available:
-            torch.cuda.empty_cache()
-            torch.cuda.synchronize()
-    
-    def get_memory_usage(self):
-        usage = {}
-        if self.gpu_available:
-            gpu_memory = torch.cuda.get_device_properties(0).total_memory
-            gpu_allocated = torch.cuda.memory_allocated(0)
-            usage['gpu_percent'] = (gpu_allocated / gpu_memory) * 100
-            usage['gpu_allocated_gb'] = gpu_allocated / (1024**3)
-        return usage
-
-class ProgressTracker:
-    """Enhanced progress tracking with detailed statistics"""
-    
-    def __init__(self, total_frames: int, callback: Optional[Callable] = None):
-        self.total_frames = total_frames
-        self.callback = callback
-        self.start_time = time.time()
-        self.processed_frames = 0
-        self.frame_times = []
-        
-    def update(self, frame_number: int, stage: str = ""):
-        current_time = time.time()
-        self.processed_frames = frame_number
-        
-        elapsed_time = current_time - self.start_time
-        current_fps = self.processed_frames / elapsed_time if elapsed_time > 0 else 0
-        
-        remaining_frames = self.total_frames - self.processed_frames
-        eta_seconds = remaining_frames / current_fps if current_fps > 0 else 0
-        
-        progress_pct = self.processed_frames / self.total_frames if self.total_frames > 0 else 0
-        
-        message = (
-            f"Frame {self.processed_frames}/{self.total_frames} | "
-            f"Elapsed: {self._format_time(elapsed_time)} | "
-            f"Speed: {current_fps:.1f} fps | "
-            f"ETA: {self._format_time(eta_seconds)}"
-        )
-        
-        if stage:
-            message = f"{stage} | {message}"
-            
-        if self.callback:
-            try:
-                self.callback(progress_pct, message)
-            except Exception as e:
-                logger.warning(f"Progress callback failed: {e}")
-    
-    def _format_time(self, seconds: float) -> str:
-        if seconds < 60:
-            return f"{int(seconds)}s"
-        elif seconds < 3600:
-            return f"{int(seconds//60)}m {int(seconds%60)}s"
-        else:
-            hours = int(seconds // 3600)
-            minutes = int((seconds % 3600) // 60)
-            return f"{hours}h {minutes}m"
-
 class VideoProcessor:
-    """Main video processing class with error recovery"""
+    """
+    Main video processing orchestrator - coordinates all specialized components
+    """
     
     def __init__(self):
-        self.device = DeviceManager.get_optimal_device()
-        self.memory_manager = MemoryManager(self.device)
+        """Initialize the video processor with all required components"""
         self.config = ProcessingConfig()
-        self.sam2_predictor = None
-        self.matanyone_model = None
+        self.device_manager = DeviceManager()
+        self.memory_manager = MemoryManager(self.device_manager.get_optimal_device())
+        self.model_loader = ModelLoader(self.device_manager.get_optimal_device())
+        self.audio_processor = AudioProcessor()
+        
+        # Initialize core processor (will be set up after models load)
+        self.core_processor = None
         self.two_stage_processor = None
+        
+        # State management
         self.models_loaded = False
         self.loading_lock = threading.Lock()
         self.cancel_event = threading.Event()
         
+        logger.info(f"VideoProcessor initialized on device: {self.device_manager.get_optimal_device()}")
+    
     def load_models(self, progress_callback: Optional[Callable] = None) -> str:
-        """Load AI models with comprehensive validation"""
+        """Load and validate all AI models"""
         with self.loading_lock:
             if self.models_loaded:
                 return "Models already loaded and validated"
             
             try:
                 self.cancel_event.clear()
-                start_time = time.time()
                 
                 if progress_callback:
-                    progress_callback(0.0, f"Starting model loading on {self.device}")
+                    progress_callback(0.0, f"Starting model loading on {self.device_manager.get_optimal_device()}")
                 
-                # Load SAM2
-                self.sam2_predictor = self._load_sam2(progress_callback)
-                if self.cancel_event.is_set():
-                    return "Model loading cancelled"
+                # Load models using the specialized loader
+                sam2_predictor, matanyone_model = self.model_loader.load_all_models(
+                    progress_callback=progress_callback,
+                    cancel_event=self.cancel_event
+                )
                 
-                # Load MatAnyone
-                self.matanyone_model = self._load_matanyone(progress_callback)
                 if self.cancel_event.is_set():
                     return "Model loading cancelled"
                 
+                # Initialize core processor with loaded models
+                self.core_processor = CoreVideoProcessor(
+                    sam2_predictor=sam2_predictor,
+                    matanyone_model=matanyone_model,
+                    config=self.config,
+                    memory_manager=self.memory_manager
+                )
+                
                 # Initialize two-stage processor if available
-                if TWO_STAGE_AVAILABLE:
+                if TWO_STAGE_AVAILABLE and sam2_predictor and matanyone_model:
                     try:
-                        self.two_stage_processor = TwoStageProcessor(
-                            self.sam2_predictor, self.matanyone_model
-                        )
+                        self.two_stage_processor = TwoStageProcessor(sam2_predictor, matanyone_model)
                         logger.info("Two-stage processor initialized")
                     except Exception as e:
                         logger.warning(f"Two-stage processor init failed: {e}")
                 
                 self.models_loaded = True
-                load_time = time.time() - start_time
-                
-                message = f"Models loaded successfully in {load_time:.1f}s on {self.device}"
-                if TWO_STAGE_AVAILABLE:
-                    message += " (Two-stage mode available)"
-                    
+                message = self.model_loader.get_load_summary()
                 logger.info(message)
                 return message
                 
-            except Exception as e:
+            except ModelLoadingError as e:
                 self.models_loaded = False
                 error_msg = f"Model loading failed: {str(e)}"
                 logger.error(error_msg)
                 return error_msg
-    
-    def _load_sam2(self, progress_callback: Optional[Callable]) -> Any:
-        """Load SAM2 predictor with validation"""
-        if progress_callback:
-            progress_callback(0.1, "Loading SAM2...")
-            
-        try:
-            from huggingface_hub import hf_hub_download
-            from sam2.build_sam import build_sam2
-            from sam2.sam2_image_predictor import SAM2ImagePredictor
-            
-            # Download checkpoint
-            checkpoint_path = hf_hub_download(
-                repo_id="facebook/sam2-hiera-large",
-                filename="sam2_hiera_large.pt",
-                cache_dir=str(Path("/tmp/model_cache/sam2_checkpoint")),
-                force_download=False
-            )
-            
-            # Build model
-            sam2_model = build_sam2("sam2_hiera_l.yaml", checkpoint_path)
-            sam2_model.to(self.device)
-            sam2_model.eval()
-            predictor = SAM2ImagePredictor(sam2_model)
-            
-            # Validate with test
-            test_image = np.zeros((256, 256, 3), dtype=np.uint8)
-            predictor.set_image(test_image)
-            test_points = np.array([[128.0, 128.0]], dtype=np.float32)
-            test_labels = np.array([1], dtype=np.int32)
-            
-            with torch.no_grad():
-                masks, scores, _ = predictor.predict(
-                    point_coords=test_points,
-                    point_labels=test_labels,
-                    multimask_output=False
-                )
-            
-            if masks is None or len(masks) == 0:
-                raise Exception("SAM2 validation failed")
-                
-            if progress_callback:
-                progress_callback(0.5, "SAM2 loaded and validated")
-                
-            return predictor
-            
-        except Exception as e:
-            logger.error(f"SAM2 loading failed: {e}")
-            raise
-    
-    def _load_matanyone(self, progress_callback: Optional[Callable]) -> Any:
-        """Load MatAnyone processor for Python 3.10"""
-        if progress_callback:
-            progress_callback(0.6, "Loading MatAnyone...")
-            
-        try:
-            # Import MatAnyone - Python 3.10 compatible
-            try:
-                from matanyone import InferenceCore
-                processor = InferenceCore("PeiqingYang/MatAnyone")
-                logger.info("MatAnyone loaded via InferenceCore")
-            except ImportError:
-                try:
-                    # Alternative import path
-                    import matanyone
-                    processor = matanyone.load_model("PeiqingYang/MatAnyone")
-                    logger.info("MatAnyone loaded via direct import")
-                except ImportError as e:
-                    logger.error(f"MatAnyone import failed: {e}")
-                    logger.error("Ensure all dependencies are installed: timm>=0.9.16, einops==0.8.0")
-                    return None
-            
-            # Test MatAnyone functionality
-            test_image = np.zeros((256, 256, 3), dtype=np.uint8)
-            test_mask = np.zeros((256, 256), dtype=np.uint8)
-            test_mask[64:192, 64:192] = 255
-            
-            try:
-                if hasattr(processor, 'infer'):
-                    test_result = processor.infer(test_image, test_mask)
-                elif hasattr(processor, 'process'):
-                    test_result = processor.process(test_image, test_mask)
-                elif callable(processor):
-                    test_result = processor(test_image, test_mask)
-                else:
-                    logger.warning("MatAnyone processor has unknown interface")
-                    return processor  # Return anyway, utilities will handle
-                
-                if test_result is not None:
-                    logger.info("MatAnyone test successful")
-                else:
-                    logger.warning("MatAnyone test returned None")
-                
-            except Exception as test_error:
-                logger.warning(f"MatAnyone test failed: {test_error}")
-                # Still return processor - might work in actual use
-            
-            if progress_callback:
-                progress_callback(0.9, "MatAnyone loaded successfully")
-                
-            return processor
-            
-        except Exception as e:
-            logger.error(f"MatAnyone loading failed: {e}")
-            return None
+            except Exception as e:
+                self.models_loaded = False
+                error_msg = f"Unexpected error during model loading: {str(e)}"
+                logger.error(error_msg)
+                return error_msg
     
     def process_video(
         self,
@@ -340,20 +165,21 @@ def process_video(
         preview_mask: bool = False,
         preview_greenscreen: bool = False
     ) -> Tuple[Optional[str], str]:
-        """Process video with comprehensive error handling"""
+        """Process video with the specified parameters"""
         
-        if not self.models_loaded:
+        if not self.models_loaded or not self.core_processor:
             return None, "Models not loaded. Please load models first."
         
         if self.cancel_event.is_set():
             return None, "Processing cancelled"
         
-        # Validate input
+        # Validate input file
         is_valid, validation_msg = validate_video_file(video_path)
         if not is_valid:
             return None, f"Invalid video: {validation_msg}"
         
         try:
+            # Route to appropriate processing method
             if use_two_stage and TWO_STAGE_AVAILABLE and self.two_stage_processor:
                 return self._process_two_stage(
                     video_path, background_choice, custom_background_path,
@@ -365,9 +191,12 @@ def process_video(
                     progress_callback, preview_mask, preview_greenscreen
                 )
                 
-        except Exception as e:
+        except VideoProcessingError as e:
             logger.error(f"Video processing failed: {e}")
             return None, f"Processing failed: {str(e)}"
+        except Exception as e:
+            logger.error(f"Unexpected error during video processing: {e}")
+            return None, f"Unexpected error: {str(e)}"
     
     def _process_single_stage(
         self,
@@ -378,115 +207,39 @@ def _process_single_stage(
         preview_mask: bool,
         preview_greenscreen: bool
     ) -> Tuple[Optional[str], str]:
-        """Single-stage video processing"""
-        
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return None, "Could not open video file"
-        
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        
-        # Prepare background
-        background = self._prepare_background(
-            background_choice, custom_background_path, frame_width, frame_height
+        """Process video using single-stage pipeline"""
+        
+        # Process video using core processor
+        processed_video_path, process_message = self.core_processor.process_video(
+            video_path=video_path,
+            background_choice=background_choice,
+            custom_background_path=custom_background_path,
+            progress_callback=progress_callback,
+            cancel_event=self.cancel_event,
+            preview_mask=preview_mask,
+            preview_greenscreen=preview_greenscreen
         )
-        if background is None:
-            cap.release()
-            return None, "Failed to prepare background"
         
-        # Setup output
-        timestamp = int(time.time())
-        output_path = f"/tmp/output_{timestamp}.mp4"
-        
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
-        
-        if not out.isOpened():
-            cap.release()
-            return None, "Could not create output video"
-        
-        # Process frames
-        progress_tracker = ProgressTracker(total_frames, progress_callback)
-        frame_count = 0
-        successful_frames = 0
-        last_refined_mask = None
+        if processed_video_path is None:
+            return None, process_message
         
-        try:
-            while True:
-                if self.cancel_event.is_set():
-                    break
-                
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                
-                try:
-                    progress_tracker.update(frame_count, "Processing")
-                    
-                    # Segmentation
-                    mask = segment_person_hq(frame, self.sam2_predictor)
-                    
-                    # Mask refinement (keyframe-based)
-                    if (frame_count % self.config.keyframe_interval == 0) or (last_refined_mask is None):
-                        refined_mask = refine_mask_hq(frame, mask, self.matanyone_model)
-                        last_refined_mask = refined_mask.copy()
-                    else:
-                        # Blend with previous refined mask for temporal consistency
-                        alpha = 0.7
-                        refined_mask = cv2.addWeighted(mask, alpha, last_refined_mask, 1-alpha, 0)
-                    
-                    # Generate output based on mode
-                    if preview_mask:
-                        result_frame = self._create_mask_preview(frame, refined_mask)
-                    elif preview_greenscreen:
-                        result_frame = self._create_greenscreen_preview(frame, refined_mask)
-                    else:
-                        result_frame = replace_background_hq(frame, refined_mask, background)
-                    
-                    out.write(result_frame)
-                    successful_frames += 1
-                    
-                except Exception as frame_error:
-                    logger.warning(f"Frame {frame_count} processing failed: {frame_error}")
-                    out.write(frame)  # Write original frame as fallback
-                
-                frame_count += 1
-                
-                # Memory cleanup
-                if frame_count % self.config.memory_cleanup_interval == 0:
-                    self.memory_manager.cleanup_aggressive()
-            
-        finally:
-            cap.release()
-            out.release()
-        
-        if self.cancel_event.is_set():
-            try:
-                os.remove(output_path)
-            except:
-                pass
-            return None, "Processing cancelled"
-        
-        if successful_frames == 0:
-            return None, "No frames processed successfully"
-        
-        # Add audio if not preview mode
+        # Add audio if not in preview mode
         if not (preview_mask or preview_greenscreen):
-            final_output = self._add_audio(video_path, output_path)
+            final_video_path = self.audio_processor.add_audio_to_video(
+                original_video=video_path,
+                processed_video=processed_video_path
+            )
         else:
-            final_output = output_path
+            final_video_path = processed_video_path
         
         success_msg = (
-            f"Success! Processed {successful_frames}/{frame_count} frames\n"
+            f"{process_message}\n"
             f"Background: {background_choice}\n"
             f"Mode: Single-stage\n"
-            f"Device: {self.device}"
+            f"Device: {self.device_manager.get_optimal_device()}"
         )
         
-        return final_output, success_msg
+        return final_video_path, success_msg
     
     def _process_two_stage(
         self,
@@ -496,21 +249,24 @@ def _process_two_stage(
         progress_callback: Optional[Callable],
         chroma_preset: str
     ) -> Tuple[Optional[str], str]:
-        """Two-stage processing using green screen intermediate"""
+        """Process video using two-stage pipeline"""
         
+        # Get video dimensions for background preparation
+        import cv2
         cap = cv2.VideoCapture(video_path)
         frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         cap.release()
         
-        # Prepare background
-        background = self._prepare_background(
+        # Prepare background using core processor
+        background = self.core_processor.prepare_background(
             background_choice, custom_background_path, frame_width, frame_height
         )
         if background is None:
             return None, "Failed to prepare background"
         
         # Process with two-stage pipeline
+        import time
         timestamp = int(time.time())
         final_output = f"/tmp/twostage_final_{timestamp}.mp4"
         
@@ -532,117 +288,49 @@ def _process_two_stage(
             f"Background: {background_choice}\n"
             f"Preset: {chroma_preset}\n"
             f"Quality: Cinema-grade\n"
-            f"Device: {self.device}"
+            f"Device: {self.device_manager.get_optimal_device()}"
         )
         
         return result, success_msg
     
-    def _prepare_background(
-        self,
-        background_choice: str,
-        custom_background_path: Optional[str],
-        width: int,
-        height: int
-    ) -> Optional[np.ndarray]:
-        """Prepare background image"""
-        
-        if background_choice == "custom" and custom_background_path:
-            if not os.path.exists(custom_background_path):
-                logger.error(f"Custom background not found: {custom_background_path}")
-                return None
-            
-            background = cv2.imread(custom_background_path)
-            if background is None:
-                logger.error("Could not read custom background")
-                return None
-        else:
-            if background_choice not in PROFESSIONAL_BACKGROUNDS:
-                logger.error(f"Unknown background: {background_choice}")
-                return None
-            
-            bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
-            background = create_professional_background(bg_config, width, height)
-        
-        return cv2.resize(background, (width, height))
-    
-    def _create_mask_preview(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
-        """Create mask preview visualization"""
-        mask_vis = np.zeros_like(frame)
-        mask_vis[..., 1] = mask  # Green channel
-        return mask_vis
-    
-    def _create_greenscreen_preview(self, frame: np.ndarray, mask: np.ndarray) -> np.ndarray:
-        """Create green screen preview"""
-        green_bg = np.zeros_like(frame)
-        green_bg[:, :] = [0, 255, 0]  # Pure green
-        
-        mask_3ch = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)
-        mask_norm = mask_3ch.astype(float) / 255
-        
-        return (frame * mask_norm + green_bg * (1 - mask_norm)).astype(np.uint8)
-    
-    def _add_audio(self, input_video: str, processed_video: str) -> str:
-        """Add audio from original video to processed video"""
-        timestamp = int(time.time())
-        final_output = f"/tmp/final_with_audio_{timestamp}.mp4"
-        
-        try:
-            # Check if input has audio
-            result = subprocess.run([
-                'ffprobe', '-v', 'quiet', '-select_streams', 'a:0',
-                '-show_entries', 'stream=codec_name', '-of', 'csv=p=0', input_video
-            ], capture_output=True, text=True, timeout=30)
-            
-            if result.returncode != 0:
-                logger.info("Input video has no audio")
-                return processed_video
-            
-            # Add audio
-            result = subprocess.run([
-                'ffmpeg', '-y', '-i', processed_video, '-i', input_video,
-                '-c:v', 'copy', '-c:a', 'aac', '-b:a', '192k',
-                '-map', '0:v:0', '-map', '1:a:0', '-shortest', final_output
-            ], capture_output=True, text=True, timeout=300)
-            
-            if result.returncode == 0 and os.path.exists(final_output):
-                try:
-                    os.remove(processed_video)
-                except:
-                    pass
-                return final_output
-            else:
-                logger.warning("Audio processing failed, using video without audio")
-                return processed_video
-                
-        except Exception as e:
-            logger.warning(f"Audio processing error: {e}")
-            return processed_video
-    
     def get_status(self) -> Dict[str, Any]:
-        """Get current processor status"""
-        return {
+        """Get comprehensive status of all components"""
+        base_status = {
             'models_loaded': self.models_loaded,
-            'sam2_available': self.sam2_predictor is not None,
-            'matanyone_available': self.matanyone_model is not None,
             'two_stage_available': TWO_STAGE_AVAILABLE and self.two_stage_processor is not None,
-            'device': str(self.device),
+            'device': str(self.device_manager.get_optimal_device()),
             'memory_usage': self.memory_manager.get_memory_usage(),
-            'config': {
-                'keyframe_interval': self.config.keyframe_interval,
-                'quality_preset': self.config.quality_preset
-            }
+            'config': self.config.to_dict()
         }
+        
+        # Add model-specific status if available
+        if self.model_loader:
+            base_status.update(self.model_loader.get_status())
+        
+        # Add processing status if available
+        if self.core_processor:
+            base_status.update(self.core_processor.get_status())
+        
+        return base_status
     
     def cancel_processing(self):
-        """Cancel current processing"""
+        """Cancel any ongoing processing"""
         self.cancel_event.set()
         logger.info("Processing cancellation requested")
+    
+    def cleanup_resources(self):
+        """Clean up all resources"""
+        self.memory_manager.cleanup_aggressive()
+        if self.model_loader:
+            self.model_loader.cleanup()
+        logger.info("Resources cleaned up")
 
-# Global processor instance
+# Global processor instance for application
 processor = VideoProcessor()
 
-# Compatibility functions for existing UI
+# Backward compatibility functions for existing UI
 def load_models_with_validation(progress_callback: Optional[Callable] = None) -> str:
+    """Load models with validation - backward compatibility wrapper"""
     return processor.load_models(progress_callback)
 
 def process_video_fixed(
@@ -655,6 +343,7 @@ def process_video_fixed(
     preview_mask: bool = False,
     preview_greenscreen: bool = False
 ) -> Tuple[Optional[str], str]:
+    """Process video - backward compatibility wrapper"""
     return processor.process_video(
         video_path, background_choice, custom_background_path,
         progress_callback, use_two_stage, chroma_preset,
@@ -662,9 +351,11 @@ def process_video_fixed(
     )
 
 def get_model_status() -> Dict[str, Any]:
+    """Get model status - backward compatibility wrapper"""
     return processor.get_status()
 
 def get_cache_status() -> Dict[str, Any]:
+    """Get cache status - backward compatibility wrapper"""
     return processor.get_status()
 
 # For backward compatibility
@@ -674,8 +365,9 @@ def main():
     """Main application entry point"""
     try:
         logger.info("Starting Video Background Replacement application")
-        logger.info(f"Device: {processor.device}")
+        logger.info(f"Device: {processor.device_manager.get_optimal_device()}")
         logger.info(f"Two-stage available: {TWO_STAGE_AVAILABLE}")
+        logger.info("Modular architecture loaded successfully")
         
         # Import and create UI
         from ui_components import create_interface
@@ -693,6 +385,9 @@ def main():
     except Exception as e:
         logger.error(f"Application startup failed: {e}")
         raise
+    finally:
+        # Cleanup on exit
+        processor.cleanup_resources()
 
 if __name__ == "__main__":
     main()