vidaio: upload miner files

chute_config.yml

@@ -0,0 +1,35 @@
+Image:
+  from_base: parachutes/python:3.12-cu13
+  set_user: chutes
+  run_command:
+    - uv pip install meson==1.5.1
+  set_user: root
+  run_command:
+    # Core build tools + runtime deps
+    - apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y software-properties-common curl build-essential cmake ninja-build nasm g++ pkg-config git wget unzip perl libx264-dev libx265-dev libvpx-dev nvidia-cuda-dev nvidia-cuda-toolkit python3-pip python3-venv && rm -rf /var/lib/apt/lists/*
+
+    # Install nv-codec-headers (pinned commit)
+    - wget -q https://github.com/FFmpeg/nv-codec-headers/archive/876af32a202d0de83bd1d36fe74ee0f7fcf86b0d.zip && unzip -q 876af32a202d0de83bd1d36fe74ee0f7fcf86b0d.zip && cd nv-codec-headers-876af32a202d0de83bd1d36fe74ee0f7fcf86b0d && make && make install && cd .. && rm -rf nv-codec-headers-* 876af32a202d0de83bd1d36fe74ee0f7fcf86b0d.zip
+
+    # Build dav1d v1.4.2 (AV1 decoder)
+    - git clone --branch 1.4.2 --depth 1 https://code.videolan.org/videolan/dav1d.git && cd dav1d && mkdir build && cd build && meson setup .. --default-library=static --buildtype release && ninja && ninja install && ldconfig && cd ../.. && rm -rf dav1d
+
+    # Build ffmpeg (pinned commit 33b215d) with CUDA + NVENC + NVDEC + x264 + x265 + dav1d
+    - export PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:/usr/local/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH" && git init ffmpeg && cd ffmpeg && git remote add origin https://github.com/FFmpeg/FFmpeg.git && git fetch --depth 1 origin 33b215d1554a14e87416a24f8e6034312e629af7 && git checkout FETCH_HEAD && ./configure --enable-gpl --enable-libx264 --enable-libx265 --enable-libvpx --enable-libdav1d --enable-nonfree --enable-cuda-nvcc --enable-nvenc --enable-nvdec --extra-cflags="-I/usr/local/cuda/include" --extra-ldflags="-L/usr/local/cuda/lib64" --disable-static --enable-shared --nvccflags="-gencode arch=compute_75,code=sm_75 -gencode arch=compute_75,code=compute_75 -O2" && make -j$(nproc) && make install && ldconfig && cd .. && rm -rf ffmpeg
+
+  set_user: chutes
+  run_command:
+    - uv pip install --upgrade setuptools wheel
+    - uv pip install huggingface_hub==0.19.4 minio
+  set_user: chutes
+  set_workdir: /app
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 16
+
+Chute:
+  shutdown_after_seconds: 600
+  concurrency: 1
+  max_instances: 3
+  scaling_threshold: 0.5

miner.py

@@ -0,0 +1,75 @@
+from pathlib import Path
+import shutil
+import subprocess
+import re
+import time
+
+
+class Miner:
+    """
+    Minimal upscaling miner using ffmpeg with NVENC GPU acceleration.
+    Uses CUDA hardware decoding, scale_cuda for GPU-based scaling,
+    and NVENC for hardware encoding.
+    Miners should fork this and improve upon it.
+
+    Required interface:
+    - Class must be named `Miner`
+    - __init__(self, path_hf_repo: Path) -> None
+    - process_video(self, input_path: Path, task_type: str) -> Path
+    - File must be named `miner.py` in the root of the HF repo
+    """
+
+    def __init__(self, path_hf_repo: Path) -> None:
+        self.repo_path = path_hf_repo
+
+    def __repr__(self) -> str:
+        return "UpscalingMiner(ffmpeg+nvenc)"
+
+    @staticmethod
+    def _run_cmd(cmd: list[str], step_name: str) -> None:
+        print(f"[miner] Running {step_name}: {' '.join(cmd)}")
+        start = time.time()
+        # NOTE: `close_fds` is required for Chutes, else it would trigger `aegis[integ] FATAL: security violation (secure authorization fd not valid)`
+        result = subprocess.run(cmd, capture_output=True, text=True, close_fds=False)
+        elapsed = time.time() - start
+        if result.stdout:
+            print(f"[miner] {step_name} stdout:\n{result.stdout}")
+        if result.stderr:
+            print(f"[miner] {step_name} stderr:\n{result.stderr}")
+        if result.returncode != 0:
+            raise subprocess.CalledProcessError(
+                result.returncode, cmd, result.stdout, result.stderr
+            )
+        print(f"[miner] {step_name} completed in {elapsed:.2f}s (exit code {result.returncode})")
+
+    def process_video(self, input_path: Path, task_type: str) -> Path:
+        scale_factor = 4 if task_type == "SD24K" else 2
+        output_path = input_path.with_name(f"{input_path.stem}_upscaled.mp4")
+
+        print(f"[miner] process_video called: input={input_path}, task_type={task_type}, scale={scale_factor}")
+        print(f"[miner] Input file exists: {input_path.exists()}, size: {input_path.stat().st_size if input_path.exists() else 'N/A'} bytes")
+
+        # Check tool availability
+        ffmpeg_path = shutil.which("ffmpeg")
+        print(f"[miner] ffmpeg location: {ffmpeg_path or 'NOT FOUND'}")
+
+        # Use hevc_nvenc to avoid h264_nvenc 4096px width limit
+        codec = "hevc_nvenc"
+
+        # GPU-accelerated upscale: CUDA decode -> scale_cuda -> NVENC encode
+        self._run_cmd(
+            [
+                "ffmpeg",
+                "-hwaccel", "cuda",
+                "-hwaccel_output_format", "cuda",
+                "-i", str(input_path),
+                "-vf", f"scale_cuda=iw*{scale_factor}:ih*{scale_factor}",
+                "-c:v", codec, "-preset", "p4", "-cq", "23",
+                "-c:a", "copy",
+                str(output_path),
+            ],
+            step_name="ffmpeg-nvenc-upscale",
+        )
+        print(f"[miner] Upscaled file exists: {output_path.exists()}, size: {output_path.stat().st_size if output_path.exists() else 'N/A'} bytes")
+
+        return output_path