initial commit

Dockerfile

@@ -0,0 +1,37 @@
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.10
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libgl1-mesa-dev \
+    libgles2-mesa-dev \
+    libglu1-mesa-dev \
+    build-essential \
+    cmake \
+    freeglut3-dev \
+    libglfw3-dev \
+    libglew-dev \
+    libsdl2-dev \
+    libjpeg-dev \
+    libpng-dev \
+    libfreetype6-dev \
+    mesa-utils \
+    libgl1-mesa-dri \
+    libgl1-mesa-glx \
+    curl \
+    python3-dev \
+    libpq-dev \
+    libasound2-dev \
+    portaudio19-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+WORKDIR /app
+
+# Download and install the depthflow binary
+RUN curl -L -o /usr/local/bin/depthflow https://github.com/BrokenSource/DepthFlow/releases/latest/download/depthflow-cpu-linux-amd64-latest.bin
+RUN chmod +x /usr/local/bin/depthflow
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,8 @@
+---
+title: DeepFlow
+emoji: 🌊
+colorFrom: purple
+colorTo: gray
+sdk: docker
+app_port: 8000
+---

main.py

@@ -0,0 +1,147 @@
+import os
+import tempfile
+import requests
+from mimetypes import guess_extension
+from PIL import Image
+from io import BytesIO
+import subprocess
+from fastapi import FastAPI, UploadFile, File, HTTPException, Response, Request
+from typing import List, Optional
+import asyncio, aiofiles
+from fastapi.responses import StreamingResponse, FileResponse
+
+app = FastAPI()
+
+
+def download_image(image_url: str):
+    # Create a temporary directory
+    temp_dir = tempfile.mkdtemp()
+
+    # Get the image content
+    response = requests.get(image_url)
+    response.raise_for_status()
+
+    # Detect the image type
+    image = Image.open(BytesIO(response.content))
+    image_format = image.format.lower()
+    image_extension = guess_extension(f"image/{image_format}")
+
+    if image_extension is None:
+        raise ValueError("Cannot detect image file type.")
+
+    # Define the image file path
+    image_path = os.path.join(temp_dir, f"image{image_extension}")
+
+    # Save the image file
+    with open(image_path, "wb") as image_file:
+        image_file.write(response.content)
+
+    # Return the image path and dimensions
+    return image_path, image.size
+
+
+def make_effect(
+    image_link: str,
+    filename: str,
+    frame_rate: int,
+    duration: int,
+    quality: int,
+    ssaa: float,
+    raw: bool,
+):
+    # Download the image and get its dimensions
+    image_path, (width, height) = download_image(image_url=image_link)
+    print(f"Image path: {image_path}, Width: {width}, Height: {height}", "#" * 100)
+
+    # Define the output video file path
+    destination = os.path.join("/tmp/Video", filename)
+
+    # Create the destination directory if it doesn't exist
+    os.makedirs(os.path.dirname(destination), exist_ok=True)
+
+    # Build the depthflow command
+    command = [
+        "depthflow",
+        "input",
+        "-i",
+        image_path,
+        "main",
+        "-f",
+        str(frame_rate),
+        "-t",
+        str(duration),
+        "--width",
+        str(width),
+        "--height",
+        str(height),
+        "--quality",
+        str(quality),
+        "--ssaa",
+        str(ssaa),
+        "--benchmark",
+    ]
+
+    if raw:
+        command.append("--raw")
+
+    command.extend(["--output", destination])
+
+    # Execute the depthflow command
+    subprocess.run(command, check=True)
+
+    return destination
+
+
+@app.post("/generate_video")
+async def generate_video(
+    image_link: str = UploadFile(File(...), alias="image_link"),
+    filename: str = "output.mp4",
+    frame_rate: int = 30,
+    duration: int = 3,
+    quality: int = 10,
+    ssaa: float = 0.75,
+    raw: bool = True,
+):
+    try:
+        output_path = await make_effect(
+            image_link, filename, frame_rate, duration, quality, ssaa, raw
+        )
+        return {"output_file": filename}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.get("/download/{filename}")
+async def download_video(filename: str, request: Request):
+    video_directory = "/tmp/Video"
+    video_path = os.path.join(video_directory, filename)
+    if not os.path.isfile(video_path):
+        raise HTTPException(status_code=404, detail="Video not found")
+
+    range_header = request.headers.get("Range", None)
+    video_size = os.path.getsize(video_path)
+
+    if range_header:
+        start, end = range_header.strip().split("=")[1].split("-")
+        start = int(start)
+        end = video_size if end == "" else int(end)
+
+        headers = {
+            "Content-Range": f"bytes {start}-{end}/{video_size}",
+            "Accept-Ranges": "bytes",
+        }
+
+        content = read_file_range(video_path, start, end)
+        return StreamingResponse(content, media_type="video/mp4", headers=headers)
+
+    return FileResponse(video_path, media_type="video/mp4")
+
+
+async def read_file_range(path, start, end):
+    async with aiofiles.open(path, "rb") as file:
+        await file.seek(start)
+        while True:
+            data = await file.read(1024 * 1024)  # read in chunks of 1MB
+            if not data or await file.tell() > end:
+                break
+            yield data

requirements.txt

@@ -0,0 +1,6 @@
+fastapi
+pydantic
+requests
+Pillow
+numpy
+aiofiles