Update app.py

app.py

@@ -1,179 +1,71 @@
-import os
-import shutil
-import subprocess
-import tempfile
-from pathlib import Path
-from typing import List, Tuple
-
 import gradio as gr
-
-
-# =========================================================
-# Batch Cinematic Processor
-# - Upload many videos
-# - Interpolate to 60 fps using FFmpeg minterpolate
-# - Upscale to 1440p
-# - Return a ZIP with all processed videos
-#
-# Requirements:
-#   pip install gradio
-#   ffmpeg installed and available in PATH
-#
-# Notes:
-# - No reverse is applied here.
-# - This is designed for CPU-friendly, stable batch processing.
-# =========================================================
-
-
-def run_ffmpeg(cmd: List[str]) -> None:
-    proc = subprocess.run(
-        cmd,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True,
-    )
-    if proc.returncode != 0:
-        raise RuntimeError(proc.stderr[-5000:])
-
-
-def safe_stem(path: str) -> str:
-    return Path(path).stem.replace(" ", "_")
-
-
-def process_one_video(
-    input_path: str,
-    output_dir: Path,
-    target_width: int,
-    target_height: int,
-    target_fps: int,
-    crf: int,
-    preset: str,
-) -> Path:
-    input_path = str(Path(input_path).resolve())
-    name = safe_stem(input_path)
-    output_path = output_dir / f"{name}_{target_fps}fps_{target_height}p.mp4"
-
-    # Minterpolate first, then upscale.
-    # This tends to preserve motion continuity better than upscaling first.
-    vf = (
-        f"minterpolate=fps={target_fps}:mi_mode=mci:mc_mode=aobmc:"
-        f"me_mode=bidir:me=epzs:vsbmc=1:scd=fdiff,"
-        f"scale={target_width}:{target_height}:flags=lanczos"
-    )
-
-    cmd = [
-        "ffmpeg",
-        "-y",
-        "-i", input_path,
-        "-vf", vf,
-        "-c:v", "libx264",
-        "-preset", preset,
-        "-crf", str(crf),
-        "-pix_fmt", "yuv420p",
-        "-movflags", "+faststart",
-        str(output_path),
-    ]
-
-    run_ffmpeg(cmd)
-    return output_path
-
-
-def batch_process(
-    videos: List[str],
-    target_width: int,
-    target_height: int,
-    target_fps: int,
-    crf: int,
-    preset: str,
-    progress=gr.Progress(track_tqdm=False),
-) -> Tuple[str, str]:
-    if not videos:
-        raise gr.Error("Envie pelo menos um vídeo.")
-
-    # Normalize values.
-    target_width = int(target_width)
-    target_height = int(target_height)
-    target_fps = int(target_fps)
-    crf = int(crf)
-
-    if target_width % 2 != 0:
-      target_width += 1
-    if target_height % 2 != 0:
-      target_height += 1
-
-    workdir = Path(tempfile.mkdtemp(prefix="batch_cinematic_"))
-    outdir = workdir / "outputs"
-    outdir.mkdir(parents=True, exist_ok=True)
-
-    processed_files: List[Path] = []
-    total = len(videos)
-
-    for idx, video in enumerate(videos, start=1):
-        progress((idx - 1) / total, desc=f"Processando {idx}/{total}: {Path(video).name}")
-        processed = process_one_video(
-            video,
-            outdir,
-            target_width=target_width,
-            target_height=target_height,
-            target_fps=target_fps,
-            crf=crf,
-            preset=preset,
-        )
-        processed_files.append(processed)
-
-    progress(0.95, desc="Montando ZIP...")
-    zip_base = workdir / "batch_output"
-    zip_path = shutil.make_archive(str(zip_base), "zip", root_dir=outdir)
-    progress(1.0, desc="Concluído")
-
-    summary = (
-        f"{len(processed_files)} vídeo(s) processado(s).\n"
-        f"Saída: {target_fps} fps | {target_width}x{target_height}\n"
-        f"Arquivo ZIP pronto."
-    )
-    return zip_path, summary
-
-
-with gr.Blocks(title="Batch Cinematic Processor") as demo:
-    gr.Markdown(
-        "# Batch Cinematic Processor\n"
-        "Envie vários vídeos e receba um ZIP com tudo processado em 60 fps e 1440p.\n"
-        "Sem reverse automático."
-    )
-
-    with gr.Row():
-        videos = gr.File(
-            label="Vídeos de entrada",
-            file_count="multiple",
-            type="filepath",
-            file_types=[".mp4", ".mov", ".mkv", ".webm", ".avi"],
-        )
-
-    with gr.Row():
-        target_width = gr.Number(label="Largura", value=2560, precision=0)
-        target_height = gr.Number(label="Altura", value=1440, precision=0)
-        target_fps = gr.Number(label="FPS de saída", value=60, precision=0)
-
-    with gr.Row():
-        crf = gr.Slider(label="Qualidade (CRF menor = melhor)", minimum=14, maximum=24, value=18, step=1)
-        preset = gr.Dropdown(
-            label="Preset do encoder",
-            choices=["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower"],
-            value="slow",
-        )
-
-    process_btn = gr.Button("Processar lote")
-
+import os
+import zipfile
+import cv2
+import urllib.request
+from basicsr.archs.rrdbnet_arch import RRDBNet
+from realesrgan import RealESRGANer
+
+# Baixa o modelo específico para estética anime/ilustração se ele não estiver no servidor
+model_path = 'RealESRGAN_x4plus_anime_6B.pth'
+if not os.path.isfile(model_path):
+    url = 'https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth'
+    urllib.request.urlretrieve(url, model_path)
+
+# Configura a arquitetura neural
+model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)
+
+# Inicializa o motor de Upscale
+upsampler = RealESRGANer(
+    scale=4,
+    model_path=model_path,
+    model=model,
+    half=False # Essencial manter como False para rodar no plano grátis (CPU)
+)
+
+def process_batch(files):
+    if not files:
+        return None
+        
+    out_dir = "imagens_prontas"
+    os.makedirs(out_dir, exist_ok=True)
+    
+    # Limpa a pasta antes de uma nova rodada para não misturar os lotes
+    for f in os.listdir(out_dir):
+        os.remove(os.path.join(out_dir, f))
+
+    # Processa cada imagem enviada
+    for file in files:
+        filename = os.path.basename(file.name)
+        img = cv2.imread(file.name, cv2.IMREAD_UNCHANGED)
+        
+        if img is not None:
+            # Aplica o upscale 4x
+            output, _ = upsampler.enhance(img, outscale=4)
+            cv2.imwrite(os.path.join(out_dir, filename), output)
+
+    # Cria o arquivo ZIP final
+    zip_filename = "Imagens_Alta_Resolucao.zip"
+    with zipfile.ZipFile(zip_filename, 'w') as zipf:
+        for folderName, subfolders, filenames in os.walk(out_dir):
+            for filename in filenames:
+                filePath = os.path.join(folderName, filename)
+                zipf.write(filePath, os.path.basename(filePath))
+                
+    return zip_filename
+
+# Constrói a interface visual do celular
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🚀 Upscale em Lote")
+    gr.Markdown("Envie várias imagens de uma vez. O servidor processará o upscale preservando a arte original e entregará um arquivo ZIP.")
+    
     with gr.Row():
-        zip_out = gr.File(label="ZIP final")
-        info = gr.Textbox(label="Status", lines=4)
-
-    process_btn.click(
-        fn=batch_process,
-        inputs=[videos, target_width, target_height, target_fps, crf, preset],
-        outputs=[zip_out, info],
-    )
-
-
-if __name__ == "__main__":
-    demo.launch()
+        with gr.Column():
+            image_inputs = gr.File(label="1. Selecione as imagens", file_count="multiple", type="filepath")
+            btn_process = gr.Button("2. Iniciar Upscale", variant="primary")
+        with gr.Column():
+            zip_output = gr.File(label="3. Download do ZIP Pronto")
+            
+    btn_process.click(fn=process_batch, inputs=image_inputs, outputs=zip_output)
+
+app.launch()