Upload 3 files

README.md

@@ -1,31 +1,35 @@
 ---
-title: Cobalt API
+title: Video Upscaler 4K
 emoji: 🎬
 colorFrom: blue
 colorTo: purple
-sdk: docker
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
-license: mit
 ---
 
-# Cobalt API - YouTube Video Downloader
+# 🎬 Video Upscaler to Ultra HD (4K)
 
-This is a self-hosted Cobalt API instance for downloading YouTube videos with Hindi audio.
+Upload any video and upscale it to:
+- 720p (HD)
+- 1080p (Full HD)
+- 1440p (2K)
+- 2160p (4K Ultra HD)
 
-## API Endpoint
+## Features:
+- High-quality **Lanczos scaling** algorithm
+- Multiple quality presets (Fast, Balanced, Best)
+- CPU-optimized (works on free HuggingFace Spaces)
 
-POST to `/` with JSON body:
+## Usage:
+1. Upload your video
+2. Select target resolution
+3. Choose quality preset
+4. Click "Upscale Video"
+5. Download the result!
 
-```json
-{
-  "url": "https://youtube.com/watch?v=VIDEO_ID",
-  "youtubeDubLang": "hi"
-}
-```
-
-## Features
-
-- Free to use
-- No authentication required
-- Hindi dubbed audio support
-- 1080p video quality
+## Technical Details:
+- Uses FFmpeg with lanczos filter for best upscaling quality
+- x264 encoder with configurable CRF
+- Audio preserved at 192kbps AAC

app.py

@@ -0,0 +1,182 @@
+"""
+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).
+"""
+
+import gradio as gr
+import subprocess
+import os
+import tempfile
+import shutil
+
+# Upscale resolutions
+RESOLUTIONS = {
+    "720p (HD)": "1280:720",
+    "1080p (Full HD)": "1920:1080",
+    "1440p (2K)": "2560:1440",
+    "2160p (4K Ultra HD)": "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
+
+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
+        
+        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:]}"
+            
+    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.
+        
+        **Supported:** MP4, MKV, AVI, MOV, WEBM
+        
+        **Note:** Processing time depends on video length. ~2-5 minutes per minute of video.
+        """)
+        
+        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"
+                )
+                
+                quality = gr.Dropdown(
+                    choices=["Fast (Lower Quality)", "Balanced", "Best Quality (Slow)"],
+                    value="Balanced",
+                    label="⚙️ Quality Preset"
+                )
+                
+                upscale_btn = gr.Button("🚀 Upscale Video", variant="primary", size="lg")
+            
+            with gr.Column(scale=1):
+                output_video = gr.Video(label="📥 Upscaled Video")
+                status_text = gr.Textbox(label="📊 Status", lines=3)
+        
+        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
+        
+        ---
+        *Powered by FFmpeg with Lanczos scaling algorithm*
+        """)
+        
+        # Event handlers
+        upscale_btn.click(
+            fn=upscale_video,
+            inputs=[input_video, target_res, quality],
+            outputs=[output_video, status_text]
+        )
+    
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0
+ffmpeg-python