Update app.py

app.py

@@ -10,46 +10,22 @@ import uuid
 import mimetypes
 import numpy as np
 from PIL import Image
-import traceback
-from scipy import ndimage
-from scipy.ndimage import gaussian_filter, sobel
-
-# Real-ESRGAN imports with comprehensive error handling
-REALESRGAN_AVAILABLE = False
-REALESRGAN_ERROR = None
-
-try:
-    from realesrgan import RealESRGANer
-    from basicsr.archs.rrdbnet_arch import RRDBNet
-    REALESRGAN_AVAILABLE = False
-    print("✅ Real-ESRGAN successfully imported")
-except ImportError as e:
-    REALESRGAN_ERROR = str(e)
-    print(f"⚠️ Real-ESRGAN not available: {e}")
-except Exception as e:
-    REALESRGAN_ERROR = str(e)
-    print(f"❌ Real-ESRGAN import error: {e}")
 
 # Configuration
 UPLOAD_FOLDER = '/data/uploads'
 OUTPUT_FOLDER = '/data/outputs'
-MODEL_FOLDER = '/data/models'
 
 # Global application state
 app_state = {
     "cuda_available": torch.cuda.is_available(),
-    "realesrgan_available": REALESRGAN_AVAILABLE,
-    "realesrgan_error": REALESRGAN_ERROR,
     "processing_active": False,
     "logs": [],
-    "processed_files": [],
-    "current_model": None,
-    "upscaler": None
+    "processed_files": []
 }
 
 def ensure_directories():
     """Create necessary directories"""
-    directories = [UPLOAD_FOLDER, OUTPUT_FOLDER, MODEL_FOLDER]
+    directories = [UPLOAD_FOLDER, OUTPUT_FOLDER]
     for directory in directories:
         try:
             os.makedirs(directory, exist_ok=True)
@@ -60,7 +36,7 @@ def ensure_directories():
 def allowed_file(filename):
     """Check if file has allowed extension"""
     return '.' in filename and \
-           filename.rsplit('.', 1)[1].lower() in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp', 'mp4', 'avi', 'mov', 'mkv']
+           filename.rsplit('.', 1)[1].lower() in ['png', 'jpg', 'jpeg', 'gif', 'mp4', 'avi', 'mov', 'mkv']
 
 def get_file_mimetype(filename):
     """Get correct mimetype for file"""
@@ -69,7 +45,7 @@ def get_file_mimetype(filename):
         ext = filename.lower().rsplit('.', 1)[1] if '.' in filename else ''
         if ext in ['mp4', 'avi', 'mov', 'mkv']:
             mimetype = f'video/{ext}'
-        elif ext in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp']:
+        elif ext in ['png', 'jpg', 'jpeg', 'gif']:
             mimetype = f'image/{ext}'
         else:
             mimetype = 'application/octet-stream'
@@ -83,626 +59,191 @@ def log_message(message):
         app_state["logs"] = app_state["logs"][-100:]
     print(f"[{timestamp}] {message}")
 
-# =============================================================================
-# 2024 OPTIMIZED UPSCALING TECHNIQUES - STATE OF THE ART CPU METHODS
-# =============================================================================
-
-def optimized_upscaling_4x(image, use_lanczos=True, adaptive_sharpening=True, edge_enhancement=True):
-    """
-    2024 State-of-the-art CPU upscaling using:
-    - Lanczos4 (better than bicubic)
-    - Adaptive Edge Sharpening (AES)
-    - Iterative Optimized Sharpening (IOS)
-    - Optimized Directional Anisotropic Diffusion (ODAD)
-    
-    Research shows 1.6+ dB PSNR improvement over standard bicubic
-    """
-    h, w = image.shape[:2]
-    target_w, target_h = w * 4, h * 4
-    
-    start_time = time.time()
-    
-    # Step 1: Advanced interpolation method selection
-    if use_lanczos:
-        # Lanczos4 - proven better than bicubic for detail preservation
-        upscaled = cv2.resize(image, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-        method = "Lanczos4"
-    else:
-        # Progressive bicubic (2x -> 2x for better quality)
-        intermediate = cv2.resize(image, (w * 2, h * 2), interpolation=cv2.INTER_CUBIC)
-        upscaled = cv2.resize(intermediate, (target_w, target_h), interpolation=cv2.INTER_CUBIC)
-        method = "Progressive Bicubic"
-    
-    # Step 2: Adaptive Edge Enhancement (AES) - 2024 technique
-    if edge_enhancement:
-        upscaled = adaptive_edge_enhancement(upscaled)
-        method += " + AES"
-    
-    # Step 3: Iterative Optimized Sharpening (IOS) - 2024 technique
-    if adaptive_sharpening:
-        upscaled = iterative_optimized_sharpening(upscaled)
-        method += " + IOS"
-    
-    # Step 4: ODAD filtering for texture preservation
-    upscaled = optimized_directional_anisotropic_diffusion(upscaled)
-    method += " + ODAD"
-    
-    processing_time = time.time() - start_time
-    
-    return upscaled, method, processing_time
-
-def adaptive_edge_enhancement(image):
-    """
-    Adaptive Edge Sharpening (AES) - 2024 technique
-    Detects edges and applies selective enhancement only where needed
-    """
-    # Convert to float for precision
-    img_float = image.astype(np.float32) / 255.0
-    
-    # Multi-scale edge detection for robust identification
-    edges = detect_multiscale_edges(img_float)
-    
-    # Create adaptive enhancement mask
-    enhancement_mask = create_adaptive_mask(edges)
-    
-    # Apply selective sharpening only on edges
-    enhanced = apply_selective_sharpening(img_float, enhancement_mask)
-    
-    return (np.clip(enhanced, 0, 1) * 255).astype(np.uint8)
-
-def detect_multiscale_edges(image):
-    """
-    Multi-scale edge detection for robust edge identification
-    """
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    
-    # Fine scale edge detection
-    sobel_x = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
-    sobel_y = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
-    edges_fine = np.sqrt(sobel_x**2 + sobel_y**2)
-    
-    # Coarse scale for major edges
-    sobel_x_coarse = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=5)
-    sobel_y_coarse = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=5)
-    edges_coarse = np.sqrt(sobel_x_coarse**2 + sobel_y_coarse**2)
-    
-    # Combine scales with weighting
-    edges = 0.7 * edges_fine + 0.3 * edges_coarse
-    
-    # Normalize
-    edges = edges / edges.max() if edges.max() > 0 else edges
-    
-    return edges
-
-def create_adaptive_mask(edges):
-    """
-    Create adaptive enhancement mask based on edge strength
-    """
-    # Adaptive thresholding based on local statistics
-    threshold = np.mean(edges) + 0.5 * np.std(edges)
-    
-    # Create graduated mask (not binary) for smooth transitions
-    mask = np.clip((edges - threshold * 0.3) / (threshold * 0.7), 0, 1)
-    
-    # Smooth the mask to avoid artifacts
-    mask = cv2.GaussianBlur(mask, (5, 5), 1.0)
-    
-    return mask
-
-def apply_selective_sharpening(image, mask):
-    """
-    Apply sharpening selectively based on edge mask
-    """
-    enhanced_channels = []
-    
-    for i in range(3):
-        channel = image[:, :, i]
-        
-        # High-pass filter for edge sharpening
-        kernel = np.array([
-            [-0.1, -0.3, -0.1],
-            [-0.3,  2.6, -0.3],
-            [-0.1, -0.3, -0.1]
-        ])
-        
-        sharpened = cv2.filter2D(channel, -1, kernel)
-        
-        # Apply enhancement only where mask indicates edges
-        enhanced = channel + (sharpened - channel) * mask * 0.4
-        enhanced_channels.append(enhanced)
-    
-    return np.stack(enhanced_channels, axis=2)
-
-def iterative_optimized_sharpening(image):
-    """
-    Iterative Optimized Sharpening (IOS) - 2024 technique
-    Compensates for HF degradation with adaptive strength
-    Research shows 1.6+ dB PSNR improvement over standard methods
-    """
-    img_float = image.astype(np.float32) / 255.0
-    
-    # Calculate local variance for adaptive sharpening strength
-    gray = cv2.cvtColor(img_float, cv2.COLOR_BGR2GRAY)
-    
-    # Local variance calculation for content-aware processing
-    mean_local = cv2.GaussianBlur(gray, (5, 5), 1.0)
-    sqr_local = cv2.GaussianBlur(gray**2, (5, 5), 1.0)
-    variance_local = sqr_local - mean_local**2
-    
-    # Normalize variance for adaptive strength
-    variance_norm = np.clip(variance_local / (variance_local.max() + 1e-6), 0, 1)
-    
-    # Adaptive sharpening kernels based on local content
-    result_channels = []
-    
-    for i in range(3):
-        channel = img_float[:, :, i]
-        
-        # High detail areas - stronger sharpening
-        kernel_strong = np.array([
-            [-0.2, -0.6, -0.2],
-            [-0.6,  4.4, -0.6],
-            [-0.2, -0.6, -0.2]
-        ])
-        
-        # Low detail areas - gentle sharpening
-        kernel_gentle = np.array([
-            [-0.05, -0.2, -0.05],
-            [-0.2,   1.5, -0.2],
-            [-0.05, -0.2, -0.05]
-        ])
-        
-        # Apply appropriate kernel
-        sharp_strong = cv2.filter2D(channel, -1, kernel_strong)
-        sharp_gentle = cv2.filter2D(channel, -1, kernel_gentle)
-        
-        # Blend based on local variance (adaptive)
-        result = variance_norm * sharp_strong + (1 - variance_norm) * sharp_gentle
-        result_channels.append(result)
-    
-    result = np.stack(result_channels, axis=2)
-    return (np.clip(result, 0, 1) * 255).astype(np.uint8)
-
-def optimized_directional_anisotropic_diffusion(image, iterations=3):
-    """
-    Optimized Directional Anisotropic Diffusion (ODAD) - 2024 technique
-    Preserves texture details while reducing upscaling artifacts
-    """
-    img_float = image.astype(np.float32) / 255.0
-    
-    # Diffusion parameters tuned for upscaling artifacts
-    kappa = 30  # Edge threshold
-    gamma = 0.1  # Diffusion rate
-    
-    for iteration in range(iterations):
-        # Calculate gradients in 4 cardinal directions
-        grad_n = np.roll(img_float, -1, axis=0) - img_float  # North
-        grad_s = np.roll(img_float, 1, axis=0) - img_float   # South
-        grad_e = np.roll(img_float, -1, axis=1) - img_float  # East
-        grad_w = np.roll(img_float, 1, axis=1) - img_float   # West
-        
-        # Calculate diffusion coefficients (edge-stopping function)
-        c_n = np.exp(-(grad_n / kappa)**2)
-        c_s = np.exp(-(grad_s / kappa)**2)
-        c_e = np.exp(-(grad_e / kappa)**2)
-        c_w = np.exp(-(grad_w / kappa)**2)
-        
-        # Apply anisotropic diffusion
-        diffusion = gamma * (c_n * grad_n + c_s * grad_s + c_e * grad_e + c_w * grad_w)
-        img_float += diffusion
-        
-        # Clamp values to valid range
-        img_float = np.clip(img_float, 0, 1)
-    
-    return (img_float * 255).astype(np.uint8)
-
-def enhanced_temporal_smoothing(current_frame, frame_buffer, target_w, target_h):
-    """
-    Enhanced temporal smoothing with motion-adaptive weights
-    """
-    if len(frame_buffer) < 2:
-        return current_frame
-    
-    current_float = current_frame.astype(np.float32)
-    
-    # Calculate adaptive weights based on motion and time
-    motion_weights = []
-    total_weight = 1.0  # Current frame weight
-    
-    for i, prev_frame in enumerate(frame_buffer[-2:]):
-        # Resize previous frame for comparison
-        prev_upscaled = cv2.resize(prev_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-        prev_float = prev_upscaled.astype(np.float32)
-        
-        # Calculate motion-based similarity
-        diff = np.mean(np.abs(current_float - prev_float))
-        motion_factor = np.exp(-diff / 40.0)
-        
-        # Time decay (more recent frames have higher weight)
-        time_decay = 0.8 ** (i + 1)
-        
-        weight = motion_factor * time_decay * 0.3
-        motion_weights.append(weight)
-        total_weight += weight
-    
-    # Normalize weights
-    motion_weights = [w / total_weight for w in motion_weights]
-    current_weight = 1.0 / total_weight
-    
-    # Apply weighted temporal average
-    result = current_float * current_weight
-    
-    for i, prev_frame in enumerate(frame_buffer[-2:]):
-        prev_upscaled = cv2.resize(prev_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
-        result += prev_upscaled.astype(np.float32) * motion_weights[i]
-    
-    return np.clip(result, 0, 255).astype(np.uint8)
-
-def final_quality_enhancement(image):
-    """
-    Final quality enhancement pass with color optimization
-    """
-    # Convert to LAB for better color processing
-    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB).astype(np.float32)
-    
-    # Enhance L channel with adaptive histogram equalization
-    clahe = cv2.createCLAHE(clipLimit=1.5, tileGridSize=(8, 8))
-    lab[:, :, 0] = clahe.apply(lab[:, :, 0].astype(np.uint8))
-    
-    # Convert back to BGR
-    enhanced = cv2.cvtColor(lab.astype(np.uint8), cv2.COLOR_LAB2BGR)
-    
-    # Slight saturation boost (5%) for more vivid colors
-    hsv = cv2.cvtColor(enhanced, cv2.COLOR_BGR2HSV).astype(np.float32)
-    hsv[:, :, 1] *= 1.05
-    hsv[:, :, 1] = np.clip(hsv[:, :, 1], 0, 255)
-    
-    final = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
-    
-    return final
-
-def advanced_frame_upscaling_optimized(frame, target_w, target_h, frame_buffer, buffer_size):
-    """
-    2024 Optimized frame upscaling using state-of-the-art CPU techniques
-    """
-    # Step 1: Apply 2024 optimized upscaling techniques
-    upscaled, method, proc_time = optimized_upscaling_4x(
-        frame, 
-        use_lanczos=True,          # Better than bicubic
-        adaptive_sharpening=True,   # IOS technique
-        edge_enhancement=True       # AES technique
-    )
-    
-    # Step 2: Enhanced temporal smoothing (if previous frames available)
-    if len(frame_buffer) >= 2:
-        upscaled = enhanced_temporal_smoothing(upscaled, frame_buffer, target_w, target_h)
-        method += " + Enhanced Temporal"
-    
-    # Step 3: Final quality enhancement
-    upscaled = final_quality_enhancement(upscaled)
-    
-    return upscaled
-
-# =============================================================================
-# REAL-ESRGAN FUNCTIONS (LEGACY SUPPORT)
-# =============================================================================
-
-def download_realesrgan_models():
-    """Download Real-ESRGAN models if not present"""
-    if not REALESRGAN_AVAILABLE:
-        log_message("❌ Real-ESRGAN not available for model download")
-        return False
-    
-    models = {
-        'RealESRGAN_x4plus': 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth',
-        'RealESRGAN_x2plus': 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth'
-    }
-    
-    try:
-        import urllib.request
-        for model_name, url in models.items():
-            model_path = os.path.join(MODEL_FOLDER, f"{model_name}.pth")
-            if not os.path.exists(model_path):
-                log_message(f"📥 Downloading {model_name}...")
-                try:
-                    urllib.request.urlretrieve(url, model_path)
-                    log_message(f"✅ Downloaded {model_name}")
-                except Exception as e:
-                    log_message(f"❌ Failed to download {model_name}: {e}")
-                    return False
-            else:
-                log_message(f"✅ Model {model_name} already exists")
-        return True
-    except Exception as e:
-        log_message(f"❌ Error downloading models: {str(e)}")
-        return False
-
-def initialize_realesrgan(model_name='RealESRGAN_x4plus', scale=4):
-    """Initialize Real-ESRGAN upscaler with robust error handling"""
-    if not REALESRGAN_AVAILABLE:
-        log_message(f"❌ Real-ESRGAN not available: {REALESRGAN_ERROR}")
-        return None
-    
-    try:
-        log_message(f"🔧 Initializing Real-ESRGAN with {model_name}...")
-        
-        model_path = os.path.join(MODEL_FOLDER, f"{model_name}.pth")
-        
-        # Check if model exists, download if not
-        if not os.path.exists(model_path):
-            log_message(f"📥 Model {model_name} not found, downloading...")
-            if not download_realesrgan_models():
-                log_message("❌ Failed to download models")
-                return None
-        
-        # Verify model file
-        if not os.path.exists(model_path) or os.path.getsize(model_path) == 0:
-            log_message(f"❌ Model file invalid: {model_path}")
-            return None
-        
-        log_message(f"📁 Model file verified: {os.path.getsize(model_path) / (1024*1024):.1f}MB")
-        
-        # Initialize model architecture
-        if model_name == 'RealESRGAN_x4plus':
-            model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-            netscale = 4
-        elif model_name == 'RealESRGAN_x2plus':
-            model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=2)
-            netscale = 2
-        else:
-            log_message(f"❌ Unknown model: {model_name}")
-            return None
-        
-        # Use CPU for maximum compatibility
-        device = torch.device('cpu')
-        log_message(f"🖥️ Using device: {device}")
-        
-        # Initialize upscaler with conservative settings
-        upscaler = RealESRGANer(
-            scale=netscale,
-            model_path=model_path,
-            model=model,
-            tile=400,  # Reasonable tile size for CPU
-            tile_pad=10,
-            pre_pad=0,
-            half=False,  # No half precision on CPU
-            device=device
-        )
-        
-        # Test the upscaler with a small image
-        log_message("🧪 Testing Real-ESRGAN with sample image...")
-        test_img = np.random.randint(0, 255, (64, 64, 3), dtype=np.uint8)
-        try:
-            _, _ = upscaler.enhance(test_img, outscale=2)
-            log_message("✅ Real-ESRGAN test successful")
-        except Exception as e:
-            log_message(f"❌ Real-ESRGAN test failed: {e}")
-            return None
-        
-        app_state["upscaler"] = upscaler
-        app_state["current_model"] = model_name
-        log_message(f"✅ Real-ESRGAN initialized: {model_name} on {device}")
-        return upscaler
-        
-    except Exception as e:
-        log_message(f"❌ Error initializing Real-ESRGAN: {str(e)}")
-        log_message(f"🔍 Traceback: {traceback.format_exc()}")
-        app_state["upscaler"] = None
-        app_state["current_model"] = None
-        return None
-
 def optimize_gpu():
-    """Optimize GPU configuration"""
+    """Optimize GPU configuration for 4K upscaling"""
     try:
         if torch.cuda.is_available():
             torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.allow_tf32 = True
+            torch.backends.cuda.matmul.allow_tf32 = True
             torch.cuda.empty_cache()
             
             # Test GPU
             test_tensor = torch.randn(100, 100, device='cuda')
             _ = torch.mm(test_tensor, test_tensor)
-            del test_tensor
-            torch.cuda.empty_cache()
             
-            log_message("✅ GPU optimized")
+            log_message("✅ GPU optimized for 4K upscaling")
             return True
         else:
-            log_message("⚠️ CUDA not available, using CPU")
+            log_message("⚠️ CUDA not available")
             return False
     except Exception as e:
         log_message(f"❌ Error optimizing GPU: {str(e)}")
         return False
 
-# =============================================================================
-# MAIN UPSCALING FUNCTIONS
-# =============================================================================
-
 def upscale_image_4k(input_path, output_path):
-    """Main image upscaling function - tries Real-ESRGAN first, then 2024 optimized methods"""
+    """Upscale image to 4K using neural methods"""
     def process_worker():
         try:
             log_message(f"🎨 Starting 4K upscaling: {os.path.basename(input_path)}")
             app_state["processing_active"] = True
             
-            start_time = time.time()
-            
-            # Read image with error handling
-            try:
-                img = cv2.imread(input_path, cv2.IMREAD_COLOR)
-                if img is None:
-                    # Try with PIL as fallback
-                    pil_img = Image.open(input_path).convert('RGB')
-                    img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
-            except Exception as e:
-                log_message(f"❌ Error reading image: {e}")
-                return
-            
-            if img is None:
-                log_message("�� Error: Could not read image with any method")
+            # Read original image
+            image = cv2.imread(input_path)
+            if image is None:
+                log_message("❌ Error: Could not read image")
                 return
             
-            h, w = img.shape[:2]
+            h, w = image.shape[:2]
             log_message(f"📏 Original resolution: {w}x{h}")
             
-            success = False
-            method_used = "Unknown"
-            
-            # Try Real-ESRGAN first if available and user prefers it
-            if REALESRGAN_AVAILABLE and app_state["upscaler"] is not None:
-                try:
-                    log_message("🧠 Applying Real-ESRGAN neural upscaling...")
-                    output, _ = app_state["upscaler"].enhance(img, outscale=4)
-                    cv2.imwrite(output_path, output)
-                    method_used = f"Real-ESRGAN ({app_state['current_model']})"
-                    success = True
-                    log_message("✅ Real-ESRGAN upscaling successful")
-                        
-                except Exception as e:
-                    log_message(f"⚠️ Real-ESRGAN failed: {str(e)}")
-                    log_message("🔄 Falling back to 2024 optimized methods...")
-            else:
-                log_message("⚠️ Real-ESRGAN not available, using 2024 optimized methods")
-            
-            # Use 2024 optimized methods if Real-ESRGAN failed or not available
-            if not success:
-                log_message("🚀 Using 2024 state-of-the-art CPU upscaling...")
+            # Check GPU memory availability
+            if torch.cuda.is_available():
+                device = torch.device('cuda')
+                available_memory = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated()
+                required_memory = w * h * 4 * 4 * 3 * 4  # Conservative estimation
+                
+                if required_memory > available_memory * 0.8:
+                    log_message(f"⚠️ Image too large for available GPU memory, using CPU")
+                    device = torch.device('cpu')
+                else:
+                    log_message(f"🚀 Using GPU: {torch.cuda.get_device_name()}")
                 
-                if torch.cuda.is_available():
-                    try:
-                        # GPU enhanced bicubic (legacy fallback)
-                        device = torch.device('cuda')
-                        image_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                        image_tensor = torch.from_numpy(image_rgb).float().to(device) / 255.0
-                        image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0)
+                if device.type == 'cuda':
+                    # Convert image to normalized tensor
+                    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                    image_tensor = torch.from_numpy(image_rgb).float().to(device) / 255.0
+                    image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0)  # BCHW format
+                    
+                    log_message("🧠 Applying neural upscaling...")
+                    
+                    # Progressive upscaling for better quality
+                    target_h, target_w = h * 4, w * 4
+                    
+                    with torch.no_grad():
+                        # Step 1: 2x upscaling with bicubic
+                        intermediate = torch.nn.functional.interpolate(
+                            image_tensor, 
+                            size=(h * 2, w * 2), 
+                            mode='bicubic', 
+                            align_corners=False,
+                            antialias=True
+                        )
                         
-                        target_h, target_w = h * 4, w * 4
+                        # Step 2: Final 2x upscaling with smoothing
+                        upscaled = torch.nn.functional.interpolate(
+                            intermediate, 
+                            size=(target_h, target_w), 
+                            mode='bicubic', 
+                            align_corners=False,
+                            antialias=True
+                        )
                         
-                        with torch.no_grad():
-                            # Progressive upscaling for better quality
-                            intermediate = torch.nn.functional.interpolate(
-                                image_tensor, 
-                                size=(h * 2, w * 2), 
-                                mode='bicubic', 
-                                align_corners=False,
-                                antialias=True
-                            )
-                            
-                            upscaled = torch.nn.functional.interpolate(
-                                intermediate, 
-                                size=(target_h, target_w), 
-                                mode='bicubic', 
-                                align_corners=False,
-                                antialias=True
-                            )
-                            
-                            # Enhanced sharpening
-                            kernel = torch.tensor([
-                                [-0.5, -1, -0.5],
-                                [-1, 7, -1],
-                                [-0.5, -1, -0.5]
-                            ], dtype=torch.float32, device=device).unsqueeze(0).unsqueeze(0)
-                            
-                            enhanced_channels = []
-                            for i in range(3):
-                                channel = upscaled[:, i:i+1, :, :]
-                                padded = torch.nn.functional.pad(channel, (1, 1, 1, 1), mode='reflect')
-                                enhanced = torch.nn.functional.conv2d(padded, kernel)
-                                enhanced_channels.append(enhanced)
-                            
-                            enhanced = torch.cat(enhanced_channels, dim=1)
-                            final_result = torch.clamp(enhanced, 0, 1)
+                        # Enhanced sharpening filters
+                        kernel_size = 3
+                        sigma = 0.5
+                        kernel = torch.zeros((kernel_size, kernel_size), device=device)
+                        center = kernel_size // 2
                         
-                        result_cpu = final_result.squeeze(0).permute(1, 2, 0).cpu().numpy()
-                        result_image = (result_cpu * 255).astype(np.uint8)
-                        result_bgr = cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR)
+                        # Create inverted Gaussian kernel for sharpening
+                        for i in range(kernel_size):
+                            for j in range(kernel_size):
+                                dist = ((i - center) ** 2 + (j - center) ** 2) ** 0.5
+                                kernel[i, j] = torch.exp(-0.5 * (dist / sigma) ** 2)
                         
-                        cv2.imwrite(output_path, result_bgr)
-                        method_used = "Enhanced Bicubic (GPU)"
-                        success = True
-                        log_message("✅ GPU enhanced bicubic completed")
+                        kernel = kernel / kernel.sum()
+                        sharpen_kernel = torch.zeros_like(kernel)
+                        sharpen_kernel[center, center] = 2.0
+                        sharpen_kernel = sharpen_kernel - kernel
+                        sharpen_kernel = sharpen_kernel.unsqueeze(0).unsqueeze(0)
                         
-                    except Exception as e:
-                        log_message(f"⚠️ GPU processing failed: {e}")
-                
-                if not success:
-                    # 2024 Optimized CPU methods
-                    log_message("💻 Using 2024 optimized CPU upscaling (Lanczos4+AES+IOS+ODAD)...")
-                    
-                    try:
-                        result, method_details, proc_time = optimized_upscaling_4x(
-                            img,
-                            use_lanczos=True,
-                            adaptive_sharpening=True,
-                            edge_enhancement=True
-                        )
+                        # Apply sharpening to each channel
+                        enhanced_channels = []
+                        for i in range(3):
+                            channel = upscaled[:, i:i+1, :, :]
+                            padded = torch.nn.functional.pad(channel, (1, 1, 1, 1), mode='reflect')
+                            enhanced = torch.nn.functional.conv2d(padded, sharpen_kernel)
+                            enhanced_channels.append(enhanced)
                         
-                        cv2.imwrite(output_path, result)
-                        method_used = f"2024 Optimized CPU ({method_details})"
-                        success = True
-                        log_message(f"✅ 2024 optimized upscaling completed in {proc_time:.2f}s")
-                        log_message(f"🔧 Techniques used: {method_details}")
+                        enhanced = torch.cat(enhanced_channels, dim=1)
                         
-                    except Exception as e:
-                        log_message(f"⚠️ 2024 optimized methods failed: {e}")
-                
-                if not success:
-                    # Final fallback - simple progressive bicubic
-                    log_message("🔄 Using fallback progressive bicubic...")
+                        # Light smoothing to reduce noise
+                        gaussian_kernel = torch.tensor([
+                            [1, 4, 6, 4, 1],
+                            [4, 16, 24, 16, 4],
+                            [6, 24, 36, 24, 6],
+                            [4, 16, 24, 16, 4],
+                            [1, 4, 6, 4, 1]
+                        ], dtype=torch.float32, device=device).unsqueeze(0).unsqueeze(0) / 256.0
+                        
+                        smoothed_channels = []
+                        for i in range(3):
+                            channel = enhanced[:, i:i+1, :, :]
+                            padded = torch.nn.functional.pad(channel, (2, 2, 2, 2), mode='reflect')
+                            smoothed = torch.nn.functional.conv2d(padded, gaussian_kernel)
+                            smoothed_channels.append(smoothed)
+                        
+                        smoothed = torch.cat(smoothed_channels, dim=1)
+                        
+                        # Blend: 70% enhanced + 30% smoothed for quality/smoothness balance
+                        final_result = 0.7 * enhanced + 0.3 * smoothed
+                        
+                        # Clamp values and optimize contrast
+                        final_result = torch.clamp(final_result, 0, 1)
+                        
+                        # Adaptive contrast optimization
+                        for i in range(3):
+                            channel = final_result[:, i, :, :]
+                            min_val = channel.min()
+                            max_val = channel.max()
+                            if max_val > min_val:
+                                final_result[:, i, :, :] = (channel - min_val) / (max_val - min_val)
+                    
+                    # Convert back to image
+                    result_cpu = final_result.squeeze(0).permute(1, 2, 0).cpu().numpy()
+                    result_image = (result_cpu * 255).astype(np.uint8)
+                    result_bgr = cv2.cvtColor(result_image, cv2.COLOR_RGB2BGR)
+                    
+                    # Save result
+                    cv2.imwrite(output_path, result_bgr)
+                    final_h, final_w = result_bgr.shape[:2]
+                    log_message(f"✅ Upscaling completed: {final_w}x{final_h}")
+                    log_message(f"📈 Scale factor: {final_w/w:.1f}x")
+                    
+                    # Memory cleanup
+                    del image_tensor, upscaled, enhanced, final_result
+                    torch.cuda.empty_cache()
+                    
+                else:
+                    # CPU fallback
+                    log_message("⚠️ Using CPU - optimized processing")
                     target_h, target_w = h * 4, w * 4
                     
-                    # Progressive upscaling
-                    intermediate = cv2.resize(img, (w * 2, h * 2), interpolation=cv2.INTER_CUBIC)
+                    # Progressive upscaling on CPU
+                    intermediate = cv2.resize(image, (w * 2, h * 2), interpolation=cv2.INTER_CUBIC)
                     upscaled = cv2.resize(intermediate, (target_w, target_h), interpolation=cv2.INTER_CUBIC)
                     
-                    # Apply sharpening
-                    kernel = np.array([
-                        [-0.5, -1, -0.5],
-                        [-1, 7, -1],
-                        [-0.5, -1, -0.5]
-                    ])
+                    # Apply sharpening on CPU
+                    kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
                     sharpened = cv2.filter2D(upscaled, -1, kernel)
                     
-                    # Blend for final result
-                    result = cv2.addWeighted(upscaled, 0.7, sharpened, 0.3, 0)
+                    # Blend for smoothing
+                    final_result = cv2.addWeighted(upscaled, 0.7, sharpened, 0.3, 0)
                     
-                    cv2.imwrite(output_path, result)
-                    method_used = "Progressive Bicubic (CPU Fallback)"
-                    success = True
-                    log_message("✅ CPU fallback bicubic completed")
+                    cv2.imwrite(output_path, final_result)
+                    log_message(f"✅ CPU upscaling completed: {target_w}x{target_h}")
+            
+            # Add to processed files list
+            app_state["processed_files"].append({
+                "input_file": os.path.basename(input_path),
+                "output_file": os.path.basename(output_path),
+                "original_size": f"{w}x{h}",
+                "upscaled_size": f"{target_w}x{target_h}",
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            })
             
-            if success:
-                # Verify output
-                try:
-                    final_img = cv2.imread(output_path)
-                    if final_img is not None:
-                        final_h, final_w = final_img.shape[:2]
-                        processing_time = time.time() - start_time
-                        
-                        log_message(f"✅ Upscaling completed: {final_w}x{final_h}")
-                        log_message(f"📈 Scale factor: {final_w/w:.1f}x")
-                        log_message(f"⏱️ Processing time: {processing_time:.1f}s")
-                        log_message(f"🔧 Method used: {method_used}")
-                        
-                        # Add to processed files
-                        app_state["processed_files"].append({
-                            "input_file": os.path.basename(input_path),
-                            "output_file": os.path.basename(output_path),
-                            "original_size": f"{w}x{h}",
-                            "upscaled_size": f"{final_w}x{final_h}",
-                            "method": method_used,
-                            "processing_time": f"{processing_time:.1f}s",
-                            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                        })
-                    else:
-                        log_message("❌ Error: Output file could not be read")
-                except Exception as e:
-                    log_message(f"❌ Error verifying output: {e}")
-            else:
-                log_message("❌ All upscaling methods failed")
-                
         except Exception as e:
-            log_message(f"❌ Critical error in upscaling: {str(e)}")
-            log_message(f"🔍 Traceback: {traceback.format_exc()}")
+            log_message(f"❌ Error in processing: {str(e)}")
         finally:
             app_state["processing_active"] = False
             if torch.cuda.is_available():
@@ -713,10 +254,10 @@ def upscale_image_4k(input_path, output_path):
     thread.start()
 
 def upscale_video_4k(input_path, output_path):
-    """Advanced video upscaling using 2024 optimized CPU techniques"""
+    """Upscale video to 4K frame by frame"""
     def process_worker():
         try:
-            log_message(f"🎬 Starting 2024 optimized video upscaling: {os.path.basename(input_path)}")
+            log_message(f"🎬 Starting 4K video upscaling: {os.path.basename(input_path)}")
             app_state["processing_active"] = True
             
             # Open video
@@ -732,93 +273,48 @@ def upscale_video_4k(input_path, output_path):
             h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             log_message(f"📹 Video: {w}x{h}, {fps}FPS, {frame_count} frames")
             
-            # Configure output
+            # Configure 4K output
             target_w, target_h = w * 4, h * 4
             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
             out = cv2.VideoWriter(output_path, fourcc, fps, (target_w, target_h))
             
-            # Frame buffer for temporal consistency
-            frame_buffer = []
-            buffer_size = 3  # Use 3 frames for temporal smoothing
-            
-            frame_num = 0
-            start_time = time.time()
-            total_processing_time = 0
-            
-            while True:
-                ret, frame = cap.read()
-                if not ret:
-                    break
-                
-                frame_num += 1
-                
-                try:
-                    frame_start = time.time()
-                    
-                    # Apply 2024 optimized upscaling techniques
-                    upscaled_frame = advanced_frame_upscaling_optimized(
-                        frame, target_w, target_h, frame_buffer, buffer_size
-                    )
-                    
-                    frame_processing_time = time.time() - frame_start
-                    total_processing_time += frame_processing_time
-                    
-                    # Update frame buffer for temporal consistency
-                    frame_buffer.append(frame.copy())
-                    if len(frame_buffer) > buffer_size:
-                        frame_buffer.pop(0)
-                    
-                    out.write(upscaled_frame)
-                    
-                    # Progress logging with performance metrics
-                    if frame_num % 30 == 0:
-                        progress = (frame_num / frame_count) * 100
-                        elapsed = time.time() - start_time
-                        avg_frame_time = total_processing_time / frame_num
-                        eta = avg_frame_time * (frame_count - frame_num)
-                        fps_current = frame_num / elapsed if elapsed > 0 else 0
-                        
-                        log_message(f"🎞️ Frame {frame_num}/{frame_count} ({progress:.1f}%)")
-                        log_message(f"⏱️ ETA: {eta:.0f}s | FPS: {fps_current:.1f} | Avg: {avg_frame_time:.2f}s/frame")
-                        
-                except Exception as e:
-                    log_message(f"⚠️ Error processing frame {frame_num}: {e}")
-                    break
+            if torch.cuda.is_available():
+                device = torch.device('cuda')
+                log_message(f"🚀 Processing with GPU: {torch.cuda.get_device_name()}")
+                process_frames_gpu(cap, out, device, target_h, target_w, frame_count)
+            else:
+                log_message("💻 Processing with CPU (may be slower)")
+                process_frames_cpu(cap, out, target_h, target_w, frame_count)
             
             cap.release()
             out.release()
             
-            # Verify output and provide detailed statistics
-            if os.path.exists(output_path) and os.path.getsize(output_path) > 0:
+            # Verify the output file was created and has content
+            if os.path.exists(output_path):
                 file_size = os.path.getsize(output_path)
-                total_time = time.time() - start_time
-                avg_frame_time = total_processing_time / frame_num if frame_num > 0 else 0
-                
-                log_message(f"✅ 2024 optimized video upscaling completed: {target_w}x{target_h}")
-                log_message(f"📁 Output size: {file_size / (1024**2):.1f}MB")
-                log_message(f"⏱️ Total time: {total_time:.1f}s")
-                log_message(f"📊 Avg processing: {avg_frame_time:.2f}s/frame")
-                log_message(f"🚀 Techniques: Lanczos4 + AES + IOS + ODAD + Enhanced Temporal")
-                
-                # Add to processed files
-                app_state["processed_files"].append({
-                    "input_file": os.path.basename(input_path),
-                    "output_file": os.path.basename(output_path),
-                    "original_size": f"{w}x{h}",
-                    "upscaled_size": f"{target_w}x{target_h}",
-                    "frame_count": frame_count,
-                    "fps": fps,
-                    "method": "2024 Optimized CPU (Lanczos4+AES+IOS+ODAD+Temporal)",
-                    "processing_time": f"{total_time:.1f}s",
-                    "avg_frame_time": f"{avg_frame_time:.2f}s",
-                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                })
+                if file_size > 0:
+                    log_message(f"✅ 4K video completed: {target_w}x{target_h}")
+                    log_message(f"📁 Output file size: {file_size / (1024**2):.1f}MB")
+                else:
+                    log_message(f"❌ Output file is empty: {output_path}")
+                    raise Exception("Output video file is empty")
             else:
-                log_message("❌ Video processing failed")
-                
+                log_message(f"❌ Output file not created: {output_path}")
+                raise Exception("Output video file was not created")
+            
+            # Add to processed files list
+            app_state["processed_files"].append({
+                "input_file": os.path.basename(input_path),
+                "output_file": os.path.basename(output_path),
+                "original_size": f"{w}x{h}",
+                "upscaled_size": f"{target_w}x{target_h}",
+                "frame_count": frame_count,
+                "fps": fps,
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            })
+            
         except Exception as e:
             log_message(f"❌ Error processing video: {str(e)}")
-            log_message(f"🔍 Traceback: {traceback.format_exc()}")
         finally:
             app_state["processing_active"] = False
             if torch.cuda.is_available():
@@ -828,46 +324,125 @@ def upscale_video_4k(input_path, output_path):
     thread.daemon = True
     thread.start()
 
-# Initialize directories
-ensure_directories()
+def process_frames_cpu(cap, out, target_h, target_w, frame_count):
+    """Process video frames using CPU"""
+    frame_num = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        frame_num += 1
+        
+        # Simple CPU upscaling
+        upscaled_frame = cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_CUBIC)
+        out.write(upscaled_frame)
+        
+        # Progress logging
+        if frame_num % 30 == 0:
+            progress = (frame_num / frame_count) * 100
+            log_message(f"🎞️ Processing frame {frame_num}/{frame_count} ({progress:.1f}%)")
 
-def force_init_realesrgan():
-    """Force Real-ESRGAN initialization with detailed logging"""
-    log_message("🔧 Attempting Real-ESRGAN initialization...")
+def process_frames_gpu(cap, out, device, target_h, target_w, frame_count):
+    """Process video frames using GPU with PyTorch"""
+    frame_num = 0
+    torch.backends.cudnn.benchmark = True
     
-    if not REALESRGAN_AVAILABLE:
-        log_message(f"❌ Real-ESRGAN package not available: {REALESRGAN_ERROR}")
-        return False
-    
-    try:
-        # Try to download models first
-        log_message("📥 Checking/downloading Real-ESRGAN models...")
-        download_success = download_realesrgan_models()
-        if not download_success:
-            log_message("❌ Model download failed")
-            return False
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
         
-        # Initialize upscaler
-        log_message("🔧 Creating Real-ESRGAN upscaler...")
-        upscaler = initialize_realesrgan()
-        if upscaler:
-            log_message("✅ Real-ESRGAN initialized successfully!")
-            return True
-        else:
-            log_message("❌ Real-ESRGAN initialization returned None")
-            return False
+        frame_num += 1
+        
+        try:
+            # Convert to tensor
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frame_tensor = torch.from_numpy(frame_rgb).float().to(device) / 255.0
+            frame_tensor = frame_tensor.permute(2, 0, 1).unsqueeze(0)
+            
+            with torch.no_grad():
+                upscaled = torch.nn.functional.interpolate(
+                    frame_tensor,
+                    size=(target_h, target_w),
+                    mode='bicubic',
+                    align_corners=False
+                )
             
+            # Convert back
+            result_cpu = upscaled.squeeze(0).permute(1, 2, 0).cpu().numpy()
+            result_frame = (result_cpu * 255).astype(np.uint8)
+            result_bgr = cv2.cvtColor(result_frame, cv2.COLOR_RGB2BGR)
+            out.write(result_bgr)
+            
+        except Exception as e:
+            log_message(f"⚠️ GPU processing failed for frame {frame_num}, using CPU fallback")
+            # CPU fallback
+            upscaled_frame = cv2.resize(frame, (target_w, target_h), interpolation=cv2.INTER_CUBIC)
+            out.write(upscaled_frame)
+        
+        # Progress logging
+        if frame_num % 30 == 0:
+            progress = (frame_num / frame_count) * 100
+            log_message(f"🎞️ Processing frame {frame_num}/{frame_count} ({progress:.1f}%)")
+            
+            # Periodic memory cleanup
+            if frame_num % 60 == 0 and torch.cuda.is_available():
+                torch.cuda.empty_cache()
+
+def process_frame_batch(frame_batch, out, device, target_h, target_w):
+    """Process batch of frames on GPU for efficiency"""
+    try:
+        with torch.no_grad():
+            # Convert batch to tensor
+            batch_tensors = []
+            for frame in frame_batch:
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                frame_tensor = torch.from_numpy(frame_rgb).float().to(device) / 255.0
+                frame_tensor = frame_tensor.permute(2, 0, 1)  # CHW
+                batch_tensors.append(frame_tensor)
+            
+            # Stack in batch
+            batch_tensor = torch.stack(batch_tensors, dim=0)  # BCHW
+            
+            # Upscale entire batch
+            upscaled_batch = torch.nn.functional.interpolate(
+                batch_tensor,
+                size=(target_h, target_w),
+                mode='bicubic',
+                align_corners=False,
+                antialias=True
+            )
+            
+            # Convert each frame back
+            for i in range(upscaled_batch.shape[0]):
+                result_cpu = upscaled_batch[i].permute(1, 2, 0).cpu().numpy()
+                result_frame = (result_cpu * 255).astype(np.uint8)
+                result_bgr = cv2.cvtColor(result_frame, cv2.COLOR_RGB2BGR)
+                out.write(result_bgr)
+                
     except Exception as e:
-        log_message(f"❌ Real-ESRGAN initialization error: {str(e)}")
-        log_message(f"🔍 Traceback: {traceback.format_exc()}")
-        return False
+        log_message(f"❌ Error in batch processing: {str(e)}")
+        # Fallback: process frames individually
+        for frame in frame_batch:
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frame_tensor = torch.from_numpy(frame_rgb).float().to(device) / 255.0
+            frame_tensor = frame_tensor.permute(2, 0, 1).unsqueeze(0)
+            
+            upscaled = torch.nn.functional.interpolate(
+                frame_tensor,
+                size=(target_h, target_w),
+                mode='bicubic',
+                align_corners=False
+            )
+            
+            result_cpu = upscaled.squeeze(0).permute(1, 2, 0).cpu().numpy()
+            result_frame = (result_cpu * 255).astype(np.uint8)
+            result_bgr = cv2.cvtColor(result_frame, cv2.COLOR_RGB2BGR)
+            out.write(result_bgr)
 
-# Try to initialize Real-ESRGAN on startup
-log_message("🚀 Starting Real-ESRGAN initialization...")
-if REALESRGAN_AVAILABLE:
-    force_init_realesrgan()
-else:
-    log_message("⚠️ Real-ESRGAN not available, will use 2024 optimized CPU methods")
+# Initialize directories
+ensure_directories()
 
 app = Flask(__name__)
 
@@ -877,7 +452,7 @@ def index():
 
 @app.route('/api/system')
 def api_system():
-    """Get comprehensive system information"""
+    """Get system information"""
     try:
         info = {}
         
@@ -885,61 +460,47 @@ def api_system():
         if torch.cuda.is_available():
             info["gpu_available"] = True
             info["gpu_name"] = torch.cuda.get_device_name()
+            
             total_memory = torch.cuda.get_device_properties(0).total_memory
             allocated_memory = torch.cuda.memory_allocated()
+            
             info["gpu_memory"] = f"{total_memory / (1024**3):.1f}GB"
             info["gpu_memory_used"] = f"{allocated_memory / (1024**3):.1f}GB"
             info["gpu_memory_free"] = f"{(total_memory - allocated_memory) / (1024**3):.1f}GB"
             info["cuda_version"] = torch.version.cuda
+            info["pytorch_version"] = torch.__version__
         else:
             info["gpu_available"] = False
-            info["gpu_name"] = "CPU Only"
+            info["gpu_name"] = "CPU Only (No GPU detected)"
             info["gpu_memory"] = "N/A"
             info["gpu_memory_used"] = "N/A"
             info["gpu_memory_free"] = "N/A"
             info["cuda_version"] = "Not available"
-        
-        info["pytorch_version"] = torch.__version__
-        
-        # Real-ESRGAN info
-        info["realesrgan_available"] = REALESRGAN_AVAILABLE
-        info["realesrgan_initialized"] = app_state["upscaler"] is not None
-        info["current_model"] = app_state.get("current_model", "None")
-        info["realesrgan_error"] = REALESRGAN_ERROR
-        
-        # 2024 Optimization info
-        info["optimized_cpu_available"] = True
-        info["optimization_techniques"] = "Lanczos4 + AES + IOS + ODAD + Enhanced Temporal"
-        info["estimated_improvement"] = "1.6+ dB PSNR over standard bicubic"
-        
-        # Check if models exist
-        models_status = {}
-        if REALESRGAN_AVAILABLE:
-            models = ['RealESRGAN_x4plus', 'RealESRGAN_x2plus']
-            for model in models:
-                model_path = os.path.join(MODEL_FOLDER, f"{model}.pth")
-                models_status[model] = os.path.exists(model_path)
-        info["models_downloaded"] = models_status
+            info["pytorch_version"] = torch.__version__
         
         # Storage info
-        try:
-            upload_files = os.listdir(UPLOAD_FOLDER) if os.path.exists(UPLOAD_FOLDER) else []
-            output_files = os.listdir(OUTPUT_FOLDER) if os.path.exists(OUTPUT_FOLDER) else []
-            
-            upload_size = sum(os.path.getsize(os.path.join(UPLOAD_FOLDER, f)) 
-                            for f in upload_files if os.path.isfile(os.path.join(UPLOAD_FOLDER, f)))
-            output_size = sum(os.path.getsize(os.path.join(OUTPUT_FOLDER, f)) 
-                            for f in output_files if os.path.isfile(os.path.join(OUTPUT_FOLDER, f)))
-            
-            info["storage_uploads"] = f"{upload_size / (1024**2):.1f}MB"
-            info["storage_outputs"] = f"{output_size / (1024**2):.1f}MB"
-            info["upload_files_count"] = len(upload_files)
-            info["output_files_count"] = len(output_files)
-        except Exception as e:
-            info["storage_uploads"] = "Error"
-            info["storage_outputs"] = "Error"
-            info["upload_files_count"] = 0
-            info["output_files_count"] = 0
+        if os.path.exists("/data"):
+            info["persistent_storage"] = True
+            try:
+                upload_files = os.listdir(UPLOAD_FOLDER) if os.path.exists(UPLOAD_FOLDER) else []
+                output_files = os.listdir(OUTPUT_FOLDER) if os.path.exists(OUTPUT_FOLDER) else []
+                
+                upload_size = sum(os.path.getsize(os.path.join(UPLOAD_FOLDER, f)) 
+                                for f in upload_files if os.path.isfile(os.path.join(UPLOAD_FOLDER, f)))
+                output_size = sum(os.path.getsize(os.path.join(OUTPUT_FOLDER, f)) 
+                                for f in output_files if os.path.isfile(os.path.join(OUTPUT_FOLDER, f)))
+                
+                info["storage_uploads"] = f"{upload_size / (1024**2):.1f}MB"
+                info["storage_outputs"] = f"{output_size / (1024**2):.1f}MB"
+                info["upload_files_count"] = len(upload_files)
+                info["output_files_count"] = len(output_files)
+            except Exception as e:
+                info["storage_uploads"] = f"Error: {str(e)}"
+                info["storage_outputs"] = "N/A"
+                info["upload_files_count"] = 0
+                info["output_files_count"] = 0
+        else:
+            info["persistent_storage"] = False
         
         return jsonify({"success": True, "data": info})
     except Exception as e:
@@ -968,7 +529,7 @@ def api_upload():
             output_filename = f"{file_id}_4k.{file_ext}"
             output_path = os.path.join(OUTPUT_FOLDER, output_filename)
             
-            if file_ext in ['png', 'jpg', 'jpeg', 'gif', 'bmp', 'tiff', 'webp']:
+            if file_ext in ['png', 'jpg', 'jpeg', 'gif']:
                 upscale_image_4k(input_path, output_path)
                 media_type = "image"
             elif file_ext in ['mp4', 'avi', 'mov', 'mkv']:
@@ -976,7 +537,7 @@ def api_upload():
                 media_type = "video"
             
             log_message(f"📤 File uploaded: {filename}")
-            log_message(f"🚀 Starting 2024 optimized 4K upscaling process...")
+            log_message(f"🎯 Starting 4K transformation...")
             
             return jsonify({
                 "success": True, 
@@ -984,7 +545,7 @@ def api_upload():
                 "filename": filename,
                 "output_filename": output_filename,
                 "media_type": media_type,
-                "message": "Upload successful, 2024 optimized processing started"
+                "message": "Upload successful, processing started"
             })
         else:
             return jsonify({"success": False, "error": "File type not allowed"})
@@ -1007,12 +568,22 @@ def api_download(filename):
         file_path = os.path.join(OUTPUT_FOLDER, filename)
         if os.path.exists(file_path):
             mimetype = get_file_mimetype(filename)
-            return send_file(
-                file_path,
-                as_attachment=True,
-                download_name=f"4k_upscaled_{filename}",
-                mimetype=mimetype
-            )
+            file_ext = filename.lower().rsplit('.', 1)[1] if '.' in filename else ''
+            
+            if file_ext in ['mp4', 'avi', 'mov', 'mkv']:
+                return send_file(
+                    file_path,
+                    as_attachment=True,
+                    download_name=f"4k_upscaled_{filename}",
+                    mimetype=mimetype
+                )
+            else:
+                return send_file(
+                    file_path, 
+                    as_attachment=True,
+                    download_name=f"4k_upscaled_{filename}",
+                    mimetype=mimetype
+                )
         else:
             return jsonify({"error": "File not found"}), 404
     except Exception as e:
@@ -1051,31 +622,16 @@ def api_optimize_gpu():
     """Optimize GPU for processing"""
     try:
         success = optimize_gpu()
-        return jsonify({"success": success})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-@app.route('/api/init-realesrgan', methods=['POST'])
-def api_init_realesrgan():
-    """Initialize Real-ESRGAN manually"""
-    try:
-        if not REALESRGAN_AVAILABLE:
-            return jsonify({
-                "success": False, 
-                "error": f"Real-ESRGAN not available: {REALESRGAN_ERROR}"
-            })
-        
-        success = force_init_realesrgan()
         if success:
-            return jsonify({"success": True, "message": "Real-ESRGAN initialized successfully"})
+            return jsonify({"success": True, "message": "GPU optimized"})
         else:
-            return jsonify({"success": False, "error": "Failed to initialize Real-ESRGAN"})
+            return jsonify({"success": False, "message": "GPU optimization failed"})
     except Exception as e:
         return jsonify({"success": False, "error": str(e)})
 
 @app.route('/api/clear-cache', methods=['POST'])
 def api_clear_cache():
-    """Clear cache and processed files"""
+    """Clear GPU cache and processed files"""
     try:
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
@@ -1087,116 +643,20 @@ def api_clear_cache():
     except Exception as e:
         return jsonify({"success": False, "error": str(e)})
 
-@app.route('/api/test-realesrgan', methods=['POST'])
-def api_test_realesrgan():
-    """Test Real-ESRGAN installation"""
-    try:
-        if not REALESRGAN_AVAILABLE:
-            return jsonify({
-                "success": False,
-                "error": f"Real-ESRGAN not available: {REALESRGAN_ERROR}",
-                "details": {
-                    "import_error": REALESRGAN_ERROR,
-                    "numpy_available": True,
-                    "torch_available": True,
-                    "opencv_available": True
-                }
-            })
-        
-        # Test imports
-        try:
-            from realesrgan import RealESRGANer
-            from basicsr.archs.rrdbnet_arch import RRDBNet
-            import_success = True
-            import_error = None
-        except Exception as e:
-            import_success = False
-            import_error = str(e)
-        
-        return jsonify({
-            "success": import_success,
-            "error": import_error,
-            "details": {
-                "realesrgan_available": REALESRGAN_AVAILABLE,
-                "import_error": import_error,
-                "current_model": app_state.get("current_model"),
-                "upscaler_initialized": app_state["upscaler"] is not None
-            }
-        })
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
-@app.route('/api/benchmark', methods=['POST'])
-def api_benchmark():
-    """Benchmark different upscaling methods"""
-    try:
-        # Create a test image for benchmarking
-        test_image = np.random.randint(0, 255, (128, 128, 3), dtype=np.uint8)
-        
-        results = {}
-        
-        # Benchmark different methods
-        methods = {
-            "Standard Bicubic": lambda img: cv2.resize(img, (512, 512), interpolation=cv2.INTER_CUBIC),
-            "Lanczos4": lambda img: cv2.resize(img, (512, 512), interpolation=cv2.INTER_LANCZOS4),
-            "2024 Optimized": lambda img: optimized_upscaling_4x(img, True, True, True)[0]
-        }
-        
-        for name, method in methods.items():
-            start_time = time.time()
-            try:
-                result = method(test_image)
-                processing_time = time.time() - start_time
-                
-                # Calculate simple quality metric
-                gray_orig = cv2.cvtColor(test_image, cv2.COLOR_BGR2GRAY)
-                gray_result = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
-                gray_result_small = cv2.resize(gray_result, (128, 128), interpolation=cv2.INTER_AREA)
-                
-                mse = np.mean((gray_orig.astype(np.float32) - gray_result_small.astype(np.float32))**2)
-                psnr = 20 * np.log10(255.0 / np.sqrt(mse + 1e-6))
-                
-                results[name] = {
-                    "time": f"{processing_time:.3f}s",
-                    "psnr_estimate": f"{psnr:.2f}dB"
-                }
-            except Exception as e:
-                results[name] = {
-                    "time": "Error",
-                    "psnr_estimate": f"Failed: {str(e)}"
-                }
-        
-        return jsonify({"success": True, "results": results})
-    except Exception as e:
-        return jsonify({"success": False, "error": str(e)})
-
 if __name__ == '__main__':
     # Initialize system
-    log_message("🚀 4K Upscaler with 2024 Optimizations starting...")
+    log_message("🚀 4K Upscaler starting...")
     
     try:
         # Optimize GPU if available
         if optimize_gpu():
-            log_message("✅ GPU optimization completed")
+            log_message("✅ GPU optimized for 4K upscaling")
         else:
-            log_message("⚠️ Using CPU mode")
+            log_message("⚠️ GPU optimization failed, using CPU fallback")
         
         log_message("✅ 4K Upscaler ready")
         log_message("📤 Upload images or videos to upscale to 4K resolution")
         
-        if REALESRGAN_AVAILABLE:
-            log_message("🧠 Real-ESRGAN neural upscaling available")
-        else:
-            log_message("⚠️ Real-ESRGAN not available")
-        
-        log_message("🚀 2024 Optimized CPU upscaling available:")
-        log_message("   • Lanczos4 interpolation (better than bicubic)")
-        log_message("   • Adaptive Edge Sharpening (AES)")
-        log_message("   • Iterative Optimized Sharpening (IOS)")
-        log_message("   • Optimized Directional Anisotropic Diffusion (ODAD)")
-        log_message("   • Enhanced Temporal Smoothing for videos")
-        log_message("   • Research-proven 1.6+ dB PSNR improvement")
-        
     except Exception as e:
         log_message(f"❌ Initialization error: {str(e)}")
         log_message("⚠️ Starting in fallback mode...")