Vendor RIFE into repo

SPACE_DEPLOYMENT.md

@@ -38,7 +38,7 @@ Useful environment variables:
 - `LANCE_GPUS`: comma-separated GPU IDs, for example `0` or `0,1`
 - `LANCE_QUEUE_SIZE`: Gradio queue size
 - `LANCE_GRADIO_TMP_ROOT`: output and temporary file directory
-- `LANCE_ZEROGPU_MAX_DURATION_SECONDS`: fixed `@spaces.GPU` duration request in seconds for all tasks (default: 300)
+- `LANCE_ZEROGPU_MAX_DURATION_SECONDS`: upper bound for the task-aware `@spaces.GPU` duration request in seconds (default cap: 300)
 - `LANCE_INSTALL_FLASH_ATTN_ON_STARTUP`: set to `1` to install the pinned flash-attn wheel during Space startup instead of inside the GPU reservation (the wheel matches Python 3.10.13 and torch 2.8.0)
 - `LANCE_PREFETCH_MODEL_ASSETS`: set to `0` to skip CPU-side model prefetch at startup
 - `LANCE_PREFETCH_MODEL_VARIANTS`: comma-separated model variants to prefetch, for example `video,image`

app.py

@@ -5,6 +5,7 @@ import base64
 import concurrent.futures
 import gc
 import html
+import math
 import json
 import os
 import random
@@ -3214,8 +3215,89 @@ def is_pipeline_pool_ready_for_task(task: str) -> bool:
 
 
 def finalize_zerogpu_duration(estimated_seconds: float, task: str) -> int:
-    """Retained for compatibility with earlier duration logic."""
-    return clamp_zerogpu_duration(ZERO_GPU_RUN_TASK_DURATION_SECONDS)
+    """Clamp a heuristic duration to the deployment cap with a small safety margin."""
+    task_key = normalize_task(task)
+    raw_seconds = float(estimated_seconds)
+    if raw_seconds <= 0:
+        raw_seconds = _estimate_zerogpu_duration_seconds(
+            task_key,
+            prompt="",
+            system_prompt=None,
+            input_video=None,
+            input_image=None,
+            height=0,
+            width=0,
+            num_frames=0,
+            seed=0,
+            resolution="",
+            validation_num_timesteps=0,
+            validation_timestep_shift=0.0,
+            cfg_text_scale=0.0,
+            enable_frame_interpolation=False,
+        )
+    return clamp_zerogpu_duration(math.ceil(raw_seconds * 1.15) + 5)
+
+
+def _estimate_zerogpu_duration_seconds(
+    task: str,
+    prompt: str,
+    system_prompt: Optional[str],
+    input_video: Optional[str],
+    input_image: Optional[str],
+    height: int,
+    width: int,
+    num_frames: int,
+    seed: int,
+    resolution: str,
+    validation_num_timesteps: int,
+    validation_timestep_shift: float,
+    cfg_text_scale: float,
+    enable_frame_interpolation: bool,
+) -> int:
+    internal_task = normalize_task(task)
+    prompt_length = len((prompt or "").strip())
+    has_video_input = bool((input_video or "").strip())
+    has_image_input = bool((input_image or "").strip())
+    is_video_task = internal_task in {TASK_T2V, TASK_VIDEO_EDIT, TASK_X2T_VIDEO}
+    is_image_task = internal_task in {TASK_T2I, TASK_IMAGE_EDIT, TASK_X2T_IMAGE}
+
+    if internal_task == TASK_T2I:
+        return 150
+
+    if internal_task == TASK_IMAGE_EDIT:
+        return 150
+
+    if internal_task == TASK_X2T_IMAGE:
+        return 150
+
+    if internal_task == TASK_X2T_VIDEO:
+        return 200
+
+    if internal_task == TASK_VIDEO_EDIT:
+        base = 300
+        base += min(48, max(0, num_frames - 37) // 2)
+        base += 32 if enable_frame_interpolation else 0
+        base += 20 if has_video_input else 0
+        base += 16 if resolution == "video_480p" else 0
+        return base
+
+    if internal_task == TASK_T2V:
+        base = 224 if resolution == "video_360p" else 264
+        base += min(56, max(0, num_frames - 37) // 2)
+        base += 28 if enable_frame_interpolation else 0
+        base += min(20, prompt_length // 260)
+        return base
+
+    if is_video_task:
+        base = 240
+        base += min(40, max(0, num_frames - 37) // 2)
+        base += 24 if enable_frame_interpolation else 0
+        return base
+
+    if is_image_task:
+        return 120
+
+    return 160
 
 
 def get_run_task_gpu_duration(
@@ -3234,8 +3316,23 @@ def get_run_task_gpu_duration(
     cfg_text_scale: float,
     enable_frame_interpolation: bool,
 ) -> int:
-    """Return a fixed ZeroGPU reservation duration for compatibility."""
-    return ZERO_GPU_RUN_TASK_DURATION_SECONDS
+    estimated_seconds = _estimate_zerogpu_duration_seconds(
+        task=task,
+        prompt=prompt,
+        system_prompt=system_prompt,
+        input_video=input_video,
+        input_image=input_image,
+        height=height,
+        width=width,
+        num_frames=num_frames,
+        seed=seed,
+        resolution=resolution,
+        validation_num_timesteps=validation_num_timesteps,
+        validation_timestep_shift=validation_timestep_shift,
+        cfg_text_scale=cfg_text_scale,
+        enable_frame_interpolation=enable_frame_interpolation,
+    )
+    return finalize_zerogpu_duration(estimated_seconds, task)
 
 
 def get_pipeline_pool(task: str) -> PipelinePool:
@@ -3265,7 +3362,7 @@ def get_pipeline_pool(task: str) -> PipelinePool:
         return ACTIVE_PIPELINE_POOL
 
 
-@spaces.GPU(size="large", duration=ZERO_GPU_RUN_TASK_DURATION_SECONDS)
+@spaces.GPU(size="large", duration=get_run_task_gpu_duration)
 def run_task(
     task: str,
     prompt: str,
@@ -3548,6 +3645,7 @@ def build_demo() -> gr.Blocks:
                             show_label=False,
                             choices=VIDEO_RESOLUTION_DISPLAY_CHOICES,
                             value=DEFAULT_RESOLUTION,
+                            allow_custom_value=True,
                             elem_classes=["generation-control"],
                         )
                 height = gr.Number(value=DEFAULT_HEIGHT, precision=0, visible=False)