Upload 3 files

README.md

@@ -21,7 +21,8 @@ A Hugging Face Space for generating a video from:
 
 - a required start image;
 - an optional end image; and
-- a text prompt describing the action, subject motion, and camera movement.
+- a text prompt describing the action, subject motion, and camera movement;
+- a selectable duration of 1, 2, or 3 seconds.
 
 The app uses [`Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers`](https://huggingface.co/Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers). When no end image is supplied, the same pipeline runs in regular image-to-video mode.
 
@@ -32,4 +33,4 @@ The app uses [`Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers`](https://huggingface.co/W
 3. Select **ZeroGPU** in **Settings → Hardware**.
 4. Wait for the model weights to download on the first build/request.
 
-The model is large. CPU-only hardware is not supported. The app requests ZeroGPU's 96 GB `xlarge` tier while a generation is running; usage remains subject to Hugging Face's daily ZeroGPU quota and queue.
+The model is large. CPU-only hardware is not supported. The app requests ZeroGPU's 96 GB `xlarge` tier while a generation is running and dynamically scales the reservation with the selected duration, resolution, and step count. Usage remains subject to Hugging Face's daily ZeroGPU quota and queue.

app.py

@@ -16,6 +16,7 @@ from transformers import CLIPVisionModel
 
 
 MODEL_ID = "Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers"
+VIDEO_FPS = 16
 OUTPUT_DIR = Path("outputs")
 OUTPUT_DIR.mkdir(exist_ok=True)
 
@@ -88,14 +89,38 @@ def prepare_frame(image: Image.Image, max_area: int, size=None):
     return ImageOps.fit(image, size, method=Image.Resampling.LANCZOS), size
 
 
-@spaces.GPU(size="xlarge", duration=12)
+def seconds_to_frames(duration_seconds):
+    """Wan accepts 4k+1 frame counts; whole seconds at 16 fps fit exactly."""
+    seconds = max(1, min(3, int(duration_seconds)))
+    return seconds * VIDEO_FPS + 1
+
+
+def estimate_gpu_duration(
+    _start_image,
+    _end_image,
+    _prompt,
+    _negative_prompt,
+    resolution,
+    duration_seconds,
+    steps,
+    _guidance,
+    _seed,
+):
+    """Reserve only the free ZeroGPU time appropriate for this request."""
+    seconds = max(1, min(3, int(duration_seconds)))
+    resolution_factor = 1.6 if resolution == "720p (best quality)" else 1.0
+    estimate = (8 + 7 * seconds) * (int(steps) / 8) * resolution_factor
+    return max(12, min(60, int(round(estimate))))
+
+
+@spaces.GPU(size="xlarge", duration=estimate_gpu_duration)
 def generate_video(
     start_image,
     end_image,
     prompt,
     negative_prompt,
     resolution,
-    num_frames,
+    duration_seconds,
     steps,
     guidance,
     seed,
@@ -120,6 +145,8 @@ def generate_video(
         last_frame = first_frame.copy()
 
     width, height = target_size
+    duration_seconds = max(1, min(3, int(duration_seconds)))
+    num_frames = seconds_to_frames(duration_seconds)
     actual_seed = random.randint(0, 2**31 - 1) if int(seed) < 0 else int(seed)
     generator = torch.Generator(device="cpu").manual_seed(actual_seed)
 
@@ -144,7 +171,7 @@ def generate_video(
                 generator=generator,
                 callback_on_step_end=update_progress,
             ).frames[0]
-        export_to_video(frames, str(output_path), fps=16)
+        export_to_video(frames, str(output_path), fps=VIDEO_FPS)
     except torch.cuda.OutOfMemoryError as exc:
         gc.collect()
         torch.cuda.empty_cache()
@@ -152,7 +179,10 @@ def generate_video(
 
     progress(1, desc="Video ready")
     mode = "start → end" if has_end_frame else "loop"
-    info = f"Seed **{actual_seed}** · {width}×{height} · {num_frames} frames · {mode} mode"
+    info = (
+        f"Seed **{actual_seed}** · {width}×{height} · "
+        f"{duration_seconds}s ({num_frames} frames at {VIDEO_FPS} fps) · {mode} mode"
+    )
     return str(output_path), info, actual_seed
 
 
@@ -217,7 +247,14 @@ with gr.Blocks(css=CSS, title="Between Frames · Image to Video") as demo:
                 negative_prompt = gr.Textbox(label="Negative prompt", value=NEGATIVE_PROMPT, lines=2)
                 with gr.Row():
                     resolution = gr.Radio(list(RESOLUTIONS), value="480p (faster)", label="Resolution")
-                    num_frames = gr.Dropdown([17, 33], value=17, label="Frames (16 fps)")
+                    duration_seconds = gr.Slider(
+                        1,
+                        3,
+                        value=1,
+                        step=1,
+                        label="Video duration (seconds)",
+                        info="Longer videos use more of the free daily GPU quota.",
+                    )
                 with gr.Row():
                     steps = gr.Slider(8, 16, value=8, step=1, label="Inference steps")
                     guidance = gr.Slider(1, 6, value=1.0, step=0.1, label="Prompt guidance")
@@ -231,7 +268,17 @@ with gr.Blocks(css=CSS, title="Between Frames · Image to Video") as demo:
 
     gr.HTML('<div class="footer-note">Large video models need a GPU. 720p generation can take several minutes.</div>')
 
-    inputs = [start_image, end_image, prompt, negative_prompt, resolution, num_frames, steps, guidance, seed]
+    inputs = [
+        start_image,
+        end_image,
+        prompt,
+        negative_prompt,
+        resolution,
+        duration_seconds,
+        steps,
+        guidance,
+        seed,
+    ]
     generate_btn.click(
         fn=generate_video,
         inputs=inputs,

test_app.py

@@ -1,6 +1,6 @@
 from PIL import Image
 
-from app import prepare_frame
+from app import estimate_gpu_duration, prepare_frame, seconds_to_frames
 
 
 def test_prepare_frame_uses_multiple_of_sixteen():
@@ -19,3 +19,17 @@ def test_end_frame_matches_start_geometry():
     prepared_end, _ = prepare_frame(end, 480 * 832, target_size)
 
     assert prepared_end.size == target_size
+
+
+def test_duration_seconds_map_to_wan_frame_counts():
+    assert seconds_to_frames(1) == 17
+    assert seconds_to_frames(2) == 33
+    assert seconds_to_frames(3) == 49
+
+
+def test_gpu_reservation_scales_with_duration():
+    one_second = estimate_gpu_duration(None, None, "", "", "480p (faster)", 1, 8, 1.0, -1)
+    three_seconds = estimate_gpu_duration(None, None, "", "", "480p (faster)", 3, 8, 1.0, -1)
+
+    assert one_second == 15
+    assert three_seconds == 29