Update app.py

app.py

@@ -1,8 +1,9 @@
 # app.py
-# A Gradio Space that (1) extracts frames with FFmpeg and (2) upscales each frame with Real-ESRGAN.
-# - CPU-friendly (works without GPU). GPU will be faster if available.
-# - Choose extraction mode, then choose upscale model/scale, JPG quality, and get a ZIP of upscaled frames.
-# - Shows both the FFmpeg command and the ESRGAN settings used.
+# A Gradio Space that (1) extracts frames with FFmpeg and (2) upscales frames with Real-ESRGAN.
+# NEW: You can now also upload existing images directly to the Upscale tab (no video needed).
+# - CPU-friendly (GPU optional)
+# - Exact ffmpeg command preview
+# - ZIP download for results
 
 import os
 import io
@@ -18,6 +19,8 @@ from pathlib import Path
 from typing import List, Optional
 
 import gradio as gr
+import numpy as np
+from PIL import Image
 
 # ─────────────────────────────────────────────────────────────
 # FFmpeg detection
@@ -141,7 +144,7 @@ def build_ffmpeg_command(
     return cmd
 
 # ─────────────────────────────────────────────────────────────
-# Real-ESRGAN setup (CPU-friendly)
+# Real-ESRGAN setup (CPU/GPU)
 # ─────────────────────────────────────────────────────────────
 try:
     from realesrgan import RealESRGANer
@@ -155,32 +158,23 @@ def get_realesrganer(model_name: str, scale: int, tile: int, half: bool, device:
     if not _HAVE_REALESRGAN:
         raise RuntimeError("realesrgan is not installed. Check requirements.txt")
     # Model selection
-    if model_name == "x4plus":
-        model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
-        model_scale = 4
-        netscale = 4
-        model_path = None  # let the lib auto-download
-    elif model_name == "x4plus-anime":
+    if model_name in ("x4plus", "x4plus-anime"):
         model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
         model_scale = 4
-        netscale = 4
-        model_path = None
     elif model_name == "x2plus":
         model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=2)
         model_scale = 2
-        netscale = 2
-        model_path = None
     else:
-        raise ValueError("Unknown model")
+        raise ValueError("Unknown Real-ESRGAN model")
 
     if scale not in (2, 4):
         scale = model_scale
 
     upsampler = RealESRGANer(
         scale=model_scale,
-        model_path=model_path,
+        model_path=None,  # let library fetch weights
         model=model,
-        tile=tile,
+        tile=tile or 0,
         tile_pad=10,
         pre_pad=0,
         half=half,
@@ -192,33 +186,30 @@ def get_realesrganer(model_name: str, scale: int, tile: int, half: bool, device:
 def upscale_images(img_paths: List[Path], out_dir: Path, model_name: str, scale: int, tile: int, precision: str, progress=gr.Progress(track_tqdm=True)) -> List[str]:
     device = "cuda" if os.environ.get("CUDA_VISIBLE_DEVICES") else "cpu"
     half = (precision == "half") and (device == "cuda")
-
     upsampler, model_scale = get_realesrganer(model_name, scale, tile, half, device=device)
 
     out_paths: List[str] = []
     for i, p in enumerate(img_paths, 1):
         try:
-            from PIL import Image
             img = Image.open(p).convert("RGB")
             output, _ = upsampler.enhance(np.array(img), outscale=scale)
             out_img = Image.fromarray(output)
             out_file = out_dir / p.name
+            # Save as JPG by extension; keep name but force .jpg to be consistent
+            if out_file.suffix.lower() not in [".jpg", ".jpeg"]:
+                out_file = out_file.with_suffix(".jpg")
             out_img.save(out_file, quality=95)
             out_paths.append(str(out_file))
         except Exception as e:
-            # Skip problematic files, continue
             print(f"Upscale failed for {p}: {e}")
         progress(i / max(1, len(img_paths)))
     return out_paths
 
-# numpy import (used above)
-import numpy as np
-
 # ─────────────────────────────────────────────────────────────
-# Pipeline: extract → upscale → zip
+# Pipelines
 # ─────────────────────────────────────────────────────────────
 
-def run_pipeline(
+def run_video_pipeline(
     video: gr.File | None,
     mode: str,
     every_seconds: float,
@@ -233,7 +224,6 @@ def run_pipeline(
     scene_detect: bool,
     scene_thresh: float,
     prefix: str,
-    # Upscale
     do_upscale: bool,
     model_name: str,
     scale: int,
@@ -254,6 +244,10 @@ def run_pipeline(
     raw_dir.mkdir(parents=True, exist_ok=True)
     up_dir.mkdir(parents=True, exist_ok=True)
 
+    # Default prefix from input filename if blank
+    if not prefix or not prefix.strip():
+        prefix = Path(video.name).stem
+
     # Build and run FFmpeg
     pattern = str(raw_dir / f"{prefix}_%05d.{out_format}")
     cmd = build_ffmpeg_command(
@@ -303,6 +297,48 @@ def run_pipeline(
     return gallery, str(zip_path), detail, "", cmd_preview
 
 
+def run_image_upscale_pipeline(
+    images: List[gr.File] | None,
+    model_name: str,
+    scale: int,
+    tile: int,
+    precision: str,
+    prefix: str,
+):
+    if not images:
+        return None, None, "Upload one or more images.", ""
+    if not _HAVE_REALESRGAN:
+        return None, None, "realesrgan is not installed (see requirements.txt)", ""
+
+    work = Path(tempfile.mkdtemp(prefix="imgup_"))
+    in_dir = work / "input"
+    out_dir = work / "upscaled"
+    in_dir.mkdir(parents=True, exist_ok=True)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # Save uploads into a temp folder with cleaned names
+    img_paths: List[Path] = []
+    for f in images:
+        p = Path(f.name)
+        name = p.name
+        if prefix and prefix.strip():
+            # keep original number if present else add incremental index
+            name = f"{prefix}_{name}"
+        dst = in_dir / name
+        shutil.copy2(p, dst)
+        img_paths.append(dst)
+
+    up_paths = upscale_images(img_paths, out_dir, model_name, scale, tile, precision)
+    gallery = up_paths[:60]
+
+    zip_path = work / "upscaled_images.zip"
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for p in sorted(out_dir.glob("*")):
+            zf.write(p, p.name)
+
+    detail = f"Images upscaled: {len(up_paths)} | Model: {model_name} | Scale: x{scale} | Tile: {tile} | Precision: {precision}"
+    return gallery, str(zip_path), detail, ""
+
 # ─────────────────────────────────────────────────────────────
 # UI
 # ─────────────────────────────────────────────────────────────
@@ -314,78 +350,118 @@ def build_ui():
     """) as demo:
         gr.Markdown("""
         <div class="cf-title">Video → JPG → Upscale (FFmpeg + Real-ESRGAN)</div>
-        Upload a video, extract frames, and optionally upscale each image.
+        Extract frames from video or upload images directly, then upscale with Real-ESRGAN.
         """)
 
-        with gr.Row():
-            video = gr.File(label="Upload video", file_types=[".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"], type="filepath")
-
-        with gr.Accordion("Extraction", open=True):
-            with gr.Row():
-                mode = gr.Dropdown(["Every N seconds", "Every Nth frame", "Exact FPS", "All frames"], value="Every N seconds", label="Mode")
-                every_seconds = gr.Number(value=1.0, label="Every N seconds")
-                nth_frame = gr.Number(value=30, label="Every Nth frame")
-                exact_fps = gr.Number(value=1.0, label="Exact FPS")
-            with gr.Row():
-                start_time = gr.Textbox(value="", label="Start (HH:MM:SS.mmm)")
-                end_time = gr.Textbox(value="", label="End (HH:MM:SS.mmm)")
-                long_side = gr.Number(value=0, label="Resize long side px (0 = none)")
-            with gr.Row():
-                out_format = gr.Dropdown(["jpg", "png"], value="jpg", label="Output format")
-                jpg_quality = gr.Slider(2, 31, value=3, step=1, label="JPG quality (2=best)")
-                png_level = gr.Slider(0, 9, value=2, step=1, label="PNG compression level")
-            with gr.Row():
-                scene_detect = gr.Checkbox(False, label="Scene-change detect")
-                scene_thresh = gr.Slider(0.0, 1.0, value=0.3, step=0.01, label="Scene threshold")
-                prefix = gr.Textbox(value="frame", label="Filename prefix")
-
-        with gr.Accordion("Upscaling", open=True):
-            with gr.Row():
-                do_upscale = gr.Checkbox(True, label="Upscale frames with Real-ESRGAN")
-                model_name = gr.Dropdown(["x4plus", "x4plus-anime", "x2plus"], value="x4plus", label="Model")
-                scale = gr.Dropdown([2, 4], value=4, label="Output scale")
-            with gr.Row():
-                tile = gr.Number(value=0, label="Tile size (0 = auto)")  # tiling reduces RAM; try 256/512 on GPU, 0 for auto
-                precision = gr.Dropdown(["auto", "half", "full"], value="auto", label="Precision (GPU=half, CPU=full)")
-
-        run_btn = gr.Button("Run: Extract → (Upscale) → ZIP", variant="primary")
-        gallery = gr.Gallery(label="Preview (first 60)", columns=6, height=300)
-        zip_out = gr.File(label="Download ZIP")
-        details = gr.Markdown("Ready.")
-
-        with gr.Accordion("Show FFmpeg command", open=False):
-            cmd_preview = gr.Textbox(label="ffmpeg command", lines=4, elem_classes=["cmdbox"])
-        if MISSING_MSG:
-            gr.Markdown(f"<span style='color:#b45309'>{MISSING_MSG}</span>")
-
-        def _toggle(mode_val, fmt):
-            return (
-                gr.update(visible=(mode_val == "Every N seconds")),
-                gr.update(visible=(mode_val == "Every Nth frame")),
-                gr.update(visible=(mode_val == "Exact FPS")),
-                gr.update(visible=(fmt == "jpg")),
-                gr.update(visible=(fmt == "png")),
-            )
-
-        mode.change(_toggle, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
-        out_format.change(_toggle, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
-        demo.load(_toggle, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
-
-        run_btn.click(
-            run_pipeline,
-            inputs=[
-                video, mode, every_seconds, nth_frame, exact_fps,
-                start_time, end_time, long_side, out_format, jpg_quality, png_level,
-                scene_detect, scene_thresh, prefix,
-                do_upscale, model_name, scale, tile, precision,
-            ],
-            outputs=[gallery, zip_out, details, gr.Textbox(), cmd_preview],
-            api_name="extract_and_upscale",
-        )
+        with gr.Tabs():
+            # Tab 1: Video → Frames → (Upscale)
+            with gr.Tab("Video pipeline"):
+                with gr.Row():
+                    video = gr.File(label="Upload video", file_types=[".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"], type="filepath")
+                with gr.Accordion("Extraction", open=True):
+                    with gr.Row():
+                        mode = gr.Dropdown(["Every N seconds", "Every Nth frame", "Exact FPS", "All frames"], value="Every N seconds", label="Mode")
+                        every_seconds = gr.Number(value=1.0, label="Every N seconds")
+                        nth_frame = gr.Number(value=30, label="Every Nth frame")
+                        exact_fps = gr.Number(value=1.0, label="Exact FPS")
+                    with gr.Row():
+                        start_time = gr.Textbox(value="", label="Start (HH:MM:SS.mmm)")
+                        end_time = gr.Textbox(value="", label="End (HH:MM:SS.mmm)")
+                        long_side = gr.Number(value=0, label="Resize long side px (0 = none)")
+                    with gr.Row():
+                        out_format = gr.Dropdown(["jpg", "png"], value="jpg", label="Output format")
+                        jpg_quality = gr.Slider(2, 31, value=3, step=1, label="JPG quality (2=best)")
+                        png_level = gr.Slider(0, 9, value=2, step=1, label="PNG compression level")
+                    with gr.Row():
+                        scene_detect = gr.Checkbox(False, label="Scene-change detect")
+                        scene_thresh = gr.Slider(0.0, 1.0, value=0.3, step=0.01, label="Scene threshold")
+                        prefix_vid = gr.Textbox(value="", label="Filename prefix (defaults to input file name)")
+                with gr.Accordion("Upscaling", open=True):
+                    with gr.Row():
+                        do_upscale = gr.Checkbox(True, label="Upscale frames with Real-ESRGAN")
+                        model_name = gr.Dropdown(["x4plus", "x4plus-anime", "x2plus"], value="x4plus", label="Model")
+                        scale = gr.Dropdown([2, 4], value=4, label="Output scale")
+                    with gr.Row():
+                        tile = gr.Number(value=0, label="Tile size (0 = auto)")  # tiling reduces RAM; try 256/512 on GPU, 0 for auto
+                        precision = gr.Dropdown(["auto", "half", "full"], value="auto", label="Precision (GPU=half, CPU=full)")
+
+                run_btn = gr.Button("Run: Extract → (Upscale) → ZIP", variant="primary")
+                gallery = gr.Gallery(label="Preview (first 60)", columns=6, height=300)
+                zip_out = gr.File(label="Download ZIP")
+                details = gr.Markdown("Ready.")
+                with gr.Accordion("Show FFmpeg command", open=False):
+                    cmd_preview = gr.Textbox(label="ffmpeg command", lines=4, elem_classes=["cmdbox"])
+                if MISSING_MSG:
+                    gr.Markdown(f"<span style='color:#b45309'>{MISSING_MSG}</span>")
+
+                def _toggle(mode_val, fmt):
+                    return (
+                        gr.update(visible=(mode_val == "Every N seconds")),
+                        gr.update(visible=(mode_val == "Every Nth frame")),
+                        gr.update(visible=(mode_val == "Exact FPS")),
+                        gr.update(visible=(fmt == "jpg")),
+                        gr.update(visible=(fmt == "png")),
+                    )
+
+                mode.change(_toggle, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
+                out_format.change(_toggle, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
+                demo.load(_toggle, [mode, out_format], [every_seconds, nth_frame, exact_fps, jpg_quality, png_level])
+
+                run_btn.click(
+                    run_video_pipeline,
+                    inputs=[
+                        video, mode, every_seconds, nth_frame, exact_fps,
+                        start_time, end_time, long_side, out_format, jpg_quality, png_level,
+                        scene_detect, scene_thresh, prefix_vid,
+                        do_upscale, model_name, scale, tile, precision,
+                    ],
+                    outputs=[gallery, zip_out, details, gr.Textbox(), cmd_preview],
+                    api_name="extract_and_upscale",
+                )
+
+            # Tab 2: Upscale images directly
+            with gr.Tab("Upscale images"):
+                with gr.Row():
+                    imgs = gr.Files(label="Upload images (JPG/PNG)", file_types=[".jpg", ".jpeg", ".png"], type="filepath")
+                with gr.Row():
+                    model_name_i = gr.Dropdown(["x4plus", "x4plus-anime", "x2plus"], value="x4plus", label="Model")
+                    scale_i = gr.Dropdown([2, 4], value=4, label="Output scale")
+                    tile_i = gr.Number(value=0, label="Tile size (0 = auto)")
+                    precision_i = gr.Dropdown(["auto", "half", "full"], value="auto", label="Precision (GPU=half, CPU=full)")
+                with gr.Row():
+                    prefix_img = gr.Textbox(value="", label="Optional filename prefix (adds prefix_ to each output)")
+                run_btn_i = gr.Button("Run: Upscale → ZIP", variant="primary")
+                gallery_i = gr.Gallery(label="Preview (first 60)", columns=6, height=300)
+                zip_out_i = gr.File(label="Download ZIP")
+                details_i = gr.Markdown("Ready.")
+
+                run_btn_i.click(
+                    run_image_upscale_pipeline,
+                    inputs=[imgs, model_name_i, scale_i, tile_i, precision_i, prefix_img],
+                    outputs=[gallery_i, zip_out_i, details_i, gr.Textbox()],
+                    api_name="upscale_images_only",
+                )
 
     return demo
 
 
 if __name__ == "__main__":
     demo = build_ui()
-    demo.queue().launch()
+    demo.queue().launch()
+
+# ─────────────────────────────────────────────────────────────
+# packages.txt (no comments, one per line)
+# ffmpeg
+# libsm6
+# libxext6
+# ─────────────────────────────────────────────────────────────
+
+# ─────────────────────────────────────────────────────────────
+# requirements.txt
+# gradio==5.44.1
+# realesrgan==0.3.0
+# basicsr==1.4.2
+# opencv-python-headless==4.10.0.84
+# numpy
+# torch==2.2.2
+# ─────────────────────────────────────────────────────────────