Upload 4 files

Dockerfile

@@ -1,18 +1,21 @@
-FROM python:3.12-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
-# Install system dependencies
+# Install FFmpeg
 RUN apt-get update && apt-get install -y \
     ffmpeg \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy requirements and install
+# Install Python dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy app
-COPY . .
+COPY app.py .
 
-# Run the app
+# Expose port
+EXPOSE 7860
+
+# Run
 CMD ["python", "app.py"]

README.md

@@ -20,13 +20,7 @@ Upload any video and upscale it to:
 - High-quality **Lanczos scaling** algorithm
 - Multiple quality presets (Fast, Balanced, Best)
 - CPU-optimized (works on free HuggingFace Spaces)
-
-## Usage:
-1. Upload your video
-2. Select target resolution
-3. Choose quality preset
-4. Click "Upscale Video"
-5. Download the result!
+- Built with FastAPI (fast and reliable)
 
 ## Technical Details:
 - Uses FFmpeg with lanczos filter for best upscaling quality

app.py

@@ -1,181 +1,330 @@
 """
-Video Upscaler - HuggingFace Spaces
-Upscale videos to Ultra HD (4K) using FFmpeg with high-quality lanczos scaling.
-Optimized for CPU-only environments (2 CPU, 16GB RAM).
+Video Upscaler - HuggingFace Spaces (FastAPI + HTML)
+Simple, reliable video upscaling using FFmpeg.
+No Gradio - cleaner and fewer dependencies.
 """
 
-import gradio as gr
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
 import subprocess
 import os
 import tempfile
 import shutil
+import uuid
+
+app = FastAPI(title="Video Upscaler 4K")
 
 # Upscale resolutions
 RESOLUTIONS = {
-    "720p (HD)": "1280:720",
-    "1080p (Full HD)": "1920:1080",
-    "1440p (2K)": "2560:1440",
-    "2160p (4K Ultra HD)": "3840:2160",
+    "720p": (1280, 720),
+    "1080p": (1920, 1080),
+    "1440p": (2560, 1440),
+    "2160p": (3840, 2160),
 }
 
-def get_video_info(input_path):
-    """Get video duration and resolution using ffprobe."""
-    cmd = [
-        'ffprobe', '-v', 'error',
-        '-select_streams', 'v:0',
-        '-show_entries', 'stream=width,height,duration',
-        '-show_entries', 'format=duration',
-        '-of', 'csv=p=0',
-        input_path
-    ]
-    try:
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
-        output = result.stdout.strip().split('\n')
-        # Parse width, height
-        if output and ',' in output[0]:
-            parts = output[0].split(',')
-            width, height = int(parts[0]), int(parts[1])
-            return width, height
-    except:
-        pass
-    return None, None
+# Create temp directory for outputs
+OUTPUT_DIR = "/tmp/upscaled"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-def upscale_video(input_video, target_resolution, quality_preset):
-    """
-    Upscale video to target resolution using FFmpeg.
-    
-    Args:
-        input_video: Path to input video file
-        target_resolution: Target resolution string (e.g., "3840:2160")
-        quality_preset: Encoding quality preset
-    
-    Returns:
-        Path to upscaled video
-    """
-    if input_video is None:
-        return None, "❌ Please upload a video first!"
-    
-    # Get target dimensions
-    target_dims = RESOLUTIONS.get(target_resolution, "3840:2160")
-    target_width, target_height = map(int, target_dims.split(':'))
-    
-    # Get input video info
-    input_width, input_height = get_video_info(input_video)
-    
-    if input_width and input_height:
-        if input_width >= target_width and input_height >= target_height:
-            return None, f"⚠️ Video already {input_width}x{input_height}. No upscaling needed!"
-    
-    # Create output path
-    output_dir = tempfile.mkdtemp()
-    output_path = os.path.join(output_dir, "upscaled_video.mp4")
-    
-    # Quality settings based on preset
-    quality_settings = {
-        "Fast (Lower Quality)": ["-crf", "23", "-preset", "fast"],
-        "Balanced": ["-crf", "18", "-preset", "medium"],
-        "Best Quality (Slow)": ["-crf", "15", "-preset", "slow"],
-    }
-    
-    crf_preset = quality_settings.get(quality_preset, quality_settings["Balanced"])
-    
-    # FFmpeg command for high-quality upscaling
-    cmd = [
-        'ffmpeg', '-y',
-        '-i', input_video,
-        # Video scaling with lanczos (highest quality scaling algorithm)
-        '-vf', f'scale={target_width}:{target_height}:flags=lanczos',
-        # Video codec settings
-        '-c:v', 'libx264',
-        *crf_preset,
-        # Audio copy (no re-encoding)
-        '-c:a', 'aac', '-b:a', '192k',
-        # Output format
-        '-movflags', '+faststart',
-        output_path
-    ]
-    
-    try:
-        # Run FFmpeg
-        process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
-        
-        stdout, stderr = process.communicate(timeout=3600)  # 1 hour timeout
+HTML_PAGE = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>🎬 Video Upscaler 4K</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: 'Segoe UI', system-ui, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 50%, #0f3460 100%);
+            min-height: 100vh;
+            color: #fff;
+            padding: 20px;
+        }
+        .container {
+            max-width: 600px;
+            margin: 0 auto;
+            background: rgba(255,255,255,0.1);
+            backdrop-filter: blur(10px);
+            border-radius: 20px;
+            padding: 30px;
+            box-shadow: 0 8px 32px rgba(0,0,0,0.3);
+        }
+        h1 {
+            text-align: center;
+            margin-bottom: 10px;
+            font-size: 2em;
+        }
+        .subtitle {
+            text-align: center;
+            color: #aaa;
+            margin-bottom: 30px;
+        }
+        .form-group {
+            margin-bottom: 20px;
+        }
+        label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 500;
+        }
+        input[type="file"] {
+            width: 100%;
+            padding: 15px;
+            background: rgba(255,255,255,0.1);
+            border: 2px dashed #666;
+            border-radius: 10px;
+            color: #fff;
+            cursor: pointer;
+        }
+        input[type="file"]:hover {
+            border-color: #00d9ff;
+        }
+        select {
+            width: 100%;
+            padding: 12px;
+            border-radius: 8px;
+            border: none;
+            background: rgba(255,255,255,0.2);
+            color: #fff;
+            font-size: 16px;
+        }
+        select option {
+            background: #1a1a2e;
+            color: #fff;
+        }
+        button {
+            width: 100%;
+            padding: 15px;
+            background: linear-gradient(135deg, #00d9ff, #0066ff);
+            border: none;
+            border-radius: 10px;
+            color: #fff;
+            font-size: 18px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: transform 0.2s, box-shadow 0.2s;
+        }
+        button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 20px rgba(0,217,255,0.4);
+        }
+        button:disabled {
+            background: #555;
+            cursor: not-allowed;
+            transform: none;
+        }
+        .status {
+            margin-top: 20px;
+            padding: 15px;
+            border-radius: 10px;
+            text-align: center;
+            display: none;
+        }
+        .status.show { display: block; }
+        .status.processing {
+            background: rgba(255,193,7,0.2);
+            border: 1px solid #ffc107;
+        }
+        .status.success {
+            background: rgba(40,167,69,0.2);
+            border: 1px solid #28a745;
+        }
+        .status.error {
+            background: rgba(220,53,69,0.2);
+            border: 1px solid #dc3545;
+        }
+        .download-link {
+            display: inline-block;
+            margin-top: 10px;
+            padding: 10px 20px;
+            background: #28a745;
+            color: #fff;
+            text-decoration: none;
+            border-radius: 8px;
+        }
+        .tips {
+            margin-top: 30px;
+            padding: 15px;
+            background: rgba(255,255,255,0.05);
+            border-radius: 10px;
+            font-size: 14px;
+            color: #aaa;
+        }
+        .tips h3 { color: #fff; margin-bottom: 10px; }
+        .tips li { margin: 5px 0; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🎬 Video Upscaler 4K</h1>
+        <p class="subtitle">Upscale your videos to Ultra HD quality</p>
         
-        if process.returncode == 0 and os.path.exists(output_path):
-            file_size_mb = os.path.getsize(output_path) / (1024 * 1024)
-            status = f"✅ Success! Upscaled to {target_width}x{target_height}\n📁 File size: {file_size_mb:.1f} MB"
-            return output_path, status
-        else:
-            return None, f"❌ FFmpeg error:\n{stderr[-500:]}"
+        <form id="uploadForm" enctype="multipart/form-data">
+            <div class="form-group">
+                <label>📤 Upload Video (MP4, MKV, AVI, MOV)</label>
+                <input type="file" name="video" id="videoInput" accept="video/*" required>
+            </div>
             
-    except subprocess.TimeoutExpired:
-        process.kill()
-        return None, "❌ Process timed out (>1 hour). Try a shorter video."
-    except Exception as e:
-        return None, f"❌ Error: {str(e)}"
-
-def create_interface():
-    """Create Gradio interface."""
-    
-    with gr.Blocks(title="🎬 Video Upscaler", theme=gr.themes.Soft()) as app:
-        gr.Markdown("""
-        # 🎬 Video Upscaler to Ultra HD (4K)
-        
-        Upload a video and upscale it to higher resolution using high-quality lanczos scaling.
+            <div class="form-group">
+                <label>🎯 Target Resolution</label>
+                <select name="resolution" id="resolution">
+                    <option value="720p">720p (HD)</option>
+                    <option value="1080p">1080p (Full HD)</option>
+                    <option value="1440p">1440p (2K)</option>
+                    <option value="2160p" selected>2160p (4K Ultra HD)</option>
+                </select>
+            </div>
+            
+            <div class="form-group">
+                <label>⚙️ Quality</label>
+                <select name="quality" id="quality">
+                    <option value="fast">Fast (Lower Quality)</option>
+                    <option value="balanced" selected>Balanced</option>
+                    <option value="best">Best Quality (Slow)</option>
+                </select>
+            </div>
+            
+            <button type="submit" id="submitBtn">🚀 Upscale Video</button>
+        </form>
         
-        **Supported:** MP4, MKV, AVI, MOV, WEBM
+        <div id="status" class="status"></div>
         
-        **Note:** Processing time depends on video length. ~2-5 minutes per minute of video.
-        """)
+        <div class="tips">
+            <h3>💡 Tips:</h3>
+            <ul>
+                <li>4K (2160p) = 3840x2160 pixels</li>
+                <li>Processing time: ~2-5 min per minute of video</li>
+                <li>Best Quality uses CRF 15 (near-lossless)</li>
+                <li>Max file size: 100MB for free tier</li>
+            </ul>
+        </div>
+    </div>
+    
+    <script>
+        const form = document.getElementById('uploadForm');
+        const statusDiv = document.getElementById('status');
+        const submitBtn = document.getElementById('submitBtn');
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                input_video = gr.Video(label="📤 Upload Video")
-                
-                target_res = gr.Dropdown(
-                    choices=list(RESOLUTIONS.keys()),
-                    value="2160p (4K Ultra HD)",
-                    label="🎯 Target Resolution"
-                )
+        form.addEventListener('submit', async (e) => {
+            e.preventDefault();
+            
+            const formData = new FormData(form);
+            
+            submitBtn.disabled = true;
+            submitBtn.textContent = '⏳ Processing...';
+            statusDiv.className = 'status show processing';
+            statusDiv.innerHTML = '⏳ Uploading and processing... This may take a few minutes.';
+            
+            try {
+                const response = await fetch('/upscale', {
+                    method: 'POST',
+                    body: formData
+                });
                 
-                quality = gr.Dropdown(
-                    choices=["Fast (Lower Quality)", "Balanced", "Best Quality (Slow)"],
-                    value="Balanced",
-                    label="⚙️ Quality Preset"
-                )
+                const result = await response.json();
                 
-                upscale_btn = gr.Button("🚀 Upscale Video", variant="primary", size="lg")
+                if (result.success) {
+                    statusDiv.className = 'status show success';
+                    statusDiv.innerHTML = `
+                        ✅ Success! Video upscaled to ${result.resolution}<br>
+                        📁 Size: ${result.size_mb} MB<br>
+                        <a href="${result.download_url}" class="download-link" download>📥 Download Video</a>
+                    `;
+                } else {
+                    statusDiv.className = 'status show error';
+                    statusDiv.innerHTML = '❌ Error: ' + result.error;
+                }
+            } catch (error) {
+                statusDiv.className = 'status show error';
+                statusDiv.innerHTML = '❌ Error: ' + error.message;
+            }
             
-            with gr.Column(scale=1):
-                output_video = gr.Video(label="📥 Upscaled Video")
-                status_text = gr.Textbox(label="📊 Status", lines=3)
+            submitBtn.disabled = false;
+            submitBtn.textContent = '🚀 Upscale Video';
+        });
+    </script>
+</body>
+</html>
+"""
+
+@app.get("/", response_class=HTMLResponse)
+async def home():
+    return HTML_PAGE
+
+@app.post("/upscale")
+async def upscale_video(
+    video: UploadFile = File(...),
+    resolution: str = Form("2160p"),
+    quality: str = Form("balanced")
+):
+    try:
+        # Get target dimensions
+        if resolution not in RESOLUTIONS:
+            resolution = "2160p"
+        width, height = RESOLUTIONS[resolution]
         
-        gr.Markdown("""
-        ---
-        ### 💡 Tips:
-        - **4K (2160p)**: Best for large screens, 4x resolution of 1080p
-        - **2K (1440p)**: Good balance of quality and file size
-        - **Best Quality (Slow)**: Use CRF 15, takes longer but looks amazing
-        - For very long videos, consider processing in parts
+        # Quality settings
+        quality_map = {
+            "fast": ("23", "fast"),
+            "balanced": ("18", "medium"),
+            "best": ("15", "slow")
+        }
+        crf, preset = quality_map.get(quality, ("18", "medium"))
         
-        ---
-        *Powered by FFmpeg with Lanczos scaling algorithm*
-        """)
+        # Save uploaded file
+        upload_id = str(uuid.uuid4())[:8]
+        input_path = f"/tmp/input_{upload_id}.mp4"
+        output_path = f"{OUTPUT_DIR}/upscaled_{upload_id}.mp4"
         
-        # Event handlers
-        upscale_btn.click(
-            fn=upscale_video,
-            inputs=[input_video, target_res, quality],
-            outputs=[output_video, status_text]
-        )
-    
-    return app
+        with open(input_path, "wb") as f:
+            content = await video.read()
+            f.write(content)
+        
+        # FFmpeg command for high-quality upscaling
+        cmd = [
+            'ffmpeg', '-y',
+            '-i', input_path,
+            '-vf', f'scale={width}:{height}:flags=lanczos',
+            '-c:v', 'libx264',
+            '-crf', crf,
+            '-preset', preset,
+            '-c:a', 'aac', '-b:a', '192k',
+            '-movflags', '+faststart',
+            output_path
+        ]
+        
+        # Run FFmpeg
+        process = subprocess.run(cmd, capture_output=True, text=True, timeout=3600)
+        
+        # Clean up input
+        os.remove(input_path)
+        
+        if process.returncode == 0 and os.path.exists(output_path):
+            size_mb = round(os.path.getsize(output_path) / (1024 * 1024), 1)
+            return {
+                "success": True,
+                "resolution": f"{width}x{height}",
+                "size_mb": size_mb,
+                "download_url": f"/download/{upload_id}"
+            }
+        else:
+            return {"success": False, "error": "FFmpeg processing failed"}
+            
+    except subprocess.TimeoutExpired:
+        return {"success": False, "error": "Processing timeout (>1 hour)"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+@app.get("/download/{upload_id}")
+async def download_file(upload_id: str):
+    file_path = f"{OUTPUT_DIR}/upscaled_{upload_id}.mp4"
+    if os.path.exists(file_path):
+        return FileResponse(file_path, filename=f"upscaled_{upload_id}.mp4", media_type="video/mp4")
+    return {"error": "File not found"}
 
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,4 +1,3 @@
-gradio==4.44.1
-gradio_client==1.3.0
-huggingface_hub==0.25.2
-ffmpeg-python
+fastapi
+uvicorn
+python-multipart