Upload 9 files

README.md

@@ -1,13 +1,73 @@
 ---
-title: Wan2.2 14B Fast Preview
-emoji: 🐌
-colorFrom: yellow
+title: Dream Motion Pro - Wan 2.2
+author: dream2589632147
+emoji: 🎬
+colorFrom: indigo
 colorTo: pink
 sdk: gradio
 sdk_version: 6.0.1
 app_file: app.py
 pinned: false
-short_description: generate a video from an image with a text prompt
+short_description: Fast Wan 2.2 image-to-video with first/last frames
+models:
+  - TestOrganizationPleaseIgnore/WAMU-Merge-MotionBoost_WAN2.2_I2V_LIGHTNING
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Dream Motion Pro — Wan 2.2
+
+Create cinematic videos from a single image or guide the animation with both a **first frame and a last frame**.
+
+## Main features
+
+- Single-image Image-to-Video mode
+- First + Last Frame mode
+- Wan 2.2 14B Lightning/MotionBoost checkpoint
+- FP8 transformer quantization
+- AOTI-compiled transformer blocks for ZeroGPU
+- Fast, Balanced and High Quality profiles
+- Natural, Cinematic, Portrait, Product Ad, Dynamic and Anime motion styles
+- Identity-preservation prompt controls
+- Automatic professional prompt enhancement
+- Landscape, portrait, square and social-media aspect ratios
+- Optional RIFE interpolation to 32 or 64 FPS
+- Seed control and repeatable generations
+- Extract any generated video frame and use it as the next first image
+
+## Space variables
+
+Add these in **Settings → Variables and secrets**:
+
+| Variable | Required | Purpose |
+|---|---:|---|
+| `REPO_ID` | Recommended | Model repository. Default: `TestOrganizationPleaseIgnore/WAMU-Merge-MotionBoost_WAN2.2_I2V_LIGHTNING` |
+| `ENABLE_AOTI` | No | Set to `false` only for troubleshooting. Default: `true` |
+| `AOTI_REPO` | No | AOTI package repository |
+| `ENABLE_VAE_TILING` | No | Set to `true` if VAE memory becomes a problem |
+| `MAX_GPU_SECONDS` | No | Maximum requested ZeroGPU duration. Default: `300` |
+| `RUNPOD_URL` | No | Shows a RunPod button beneath the generated video |
+| `SUPPORT_URL` | No | Shows a support/PayPal button beneath the generated video |
+
+## Recommended defaults
+
+- **Quality Mode:** Balanced
+- **Duration:** 3.5 seconds
+- **Output FPS:** 16
+- **Steps:** 6
+- **Guidance:** 1.0 / 1.0
+- **Scheduler:** UniPCMultistep
+- **Flow Shift:** 3.0
+
+Lightning checkpoints usually perform best at approximately **4–8 inference steps**. Raising the steps or guidance unnecessarily increases GPU time and may reduce motion quality.
+
+## First + Last Frame mode
+
+Both images are normalized to the same dimensions. The last image is center-cropped to match the prepared first frame so the pipeline receives a consistent resolution.
+
+This release intentionally supports **one image** or **first + last frames only**. It does not include a three-frame mode.
+
+## Notes
+
+- 32 and 64 FPS outputs use RIFE after the base 16 FPS generation.
+- Higher FPS improves playback smoothness but does not create additional semantic motion.
+- A clear, high-resolution source image and one main action generally produce the most stable result.
+- Generate multiple seeds when choosing a final result.

aoti.py

@@ -1,13 +1,13 @@
-"""
-"""
+"""Compatibility helper for loading AOTI-compiled repeated transformer blocks."""
 
 from typing import cast
 
 import torch
 from huggingface_hub import hf_hub_download
-from spaces.zero.torch.aoti import ZeroGPUCompiledModel
-from spaces.zero.torch.aoti import ZeroGPUWeights
-from torch._functorch._aot_autograd.subclass_parametrization import unwrap_tensor_subclass_parameters
+from spaces.zero.torch.aoti import ZeroGPUCompiledModel, ZeroGPUWeights
+from torch._functorch._aot_autograd.subclass_parametrization import (
+    unwrap_tensor_subclass_parameters,
+)
 
 
 def _shallow_clone_module(module: torch.nn.Module) -> torch.nn.Module:
@@ -15,21 +15,34 @@ def _shallow_clone_module(module: torch.nn.Module) -> torch.nn.Module:
     clone.__dict__ = module.__dict__.copy()
     clone._parameters = module._parameters.copy()
     clone._buffers = module._buffers.copy()
-    clone._modules = {k: _shallow_clone_module(v) for k, v in module._modules.items() if v is not None}
+    clone._modules = {
+        name: _shallow_clone_module(child)
+        for name, child in module._modules.items()
+        if child is not None
+    }
     return clone
 
 
-def aoti_blocks_load(module: torch.nn.Module, repo_id: str, variant: str | None = None):
+def aoti_blocks_load(
+    module: torch.nn.Module,
+    repo_id: str,
+    variant: str | None = None,
+) -> None:
     repeated_blocks = cast(list[str], module._repeated_blocks)
-    aoti_files = {name: hf_hub_download(
-        repo_id=repo_id,
-        filename='package.pt2',
-        subfolder=name if variant is None else f'{name}.{variant}',
-    ) for name in repeated_blocks}
+    aoti_files = {
+        name: hf_hub_download(
+            repo_id=repo_id,
+            filename="package.pt2",
+            subfolder=name if variant is None else f"{name}.{variant}",
+        )
+        for name in repeated_blocks
+    }
+
     for block_name, aoti_file in aoti_files.items():
         for block in module.modules():
-            if block.__class__.__name__ == block_name:
-                block_ = _shallow_clone_module(block)
-                unwrap_tensor_subclass_parameters(block_)
-                weights = ZeroGPUWeights(block_.state_dict())
-                block.forward = ZeroGPUCompiledModel(aoti_file, weights)
+            if block.__class__.__name__ != block_name:
+                continue
+            cloned_block = _shallow_clone_module(block)
+            unwrap_tensor_subclass_parameters(cloned_block)
+            weights = ZeroGPUWeights(cloned_block.state_dict())
+            block.forward = ZeroGPUCompiledModel(aoti_file, weights)

app.py

@@ -1,273 +1,95 @@
-import os; os.system('pip install --upgrade --no-deps spaces')
-import spaces
-import shutil
-import subprocess
-import sys
+from __future__ import annotations
+
 import copy
+import gc
+import os
 import random
+import sys
 import tempfile
-import warnings
 import time
-import gc
 import uuid
-from tqdm import tqdm
+import warnings
+import zipfile
+from pathlib import Path
+from typing import Any
+
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+
 import cv2
+import gradio as gr
 import numpy as np
+import spaces
 import torch
 import torch._dynamo
-from huggingface_hub import list_models
+from huggingface_hub import hf_hub_download
+from PIL import Image, ImageOps
 from torch.nn import functional as F
-from PIL import Image
+from torchao.quantization import (
+    Float8DynamicActivationFloat8WeightConfig,
+    Int8WeightOnlyConfig,
+    quantize_,
+)
+from tqdm import tqdm
 
-import gradio as gr
 from diffusers import (
-    FlowMatchEulerDiscreteScheduler,
-    SASolverScheduler,
     DEISMultistepScheduler,
     DPMSolverMultistepInverseScheduler,
-    UniPCMultistepScheduler,
     DPMSolverMultistepScheduler,
     DPMSolverSinglestepScheduler,
+    FlowMatchEulerDiscreteScheduler,
+    SASolverScheduler,
+    UniPCMultistepScheduler,
 )
 from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
 from diffusers.utils.export_utils import export_to_video
 
-from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig, Int8WeightOnlyConfig
-import aoti
-
-os.environ["TOKENIZERS_PARALLELISM"] = "true"
 warnings.filterwarnings("ignore")
-IS_ZERO_GPU = bool(os.getenv("SPACES_ZERO_GPU"))
-
-# if IS_ZERO_GPU:
-#     print("Loading...")
-#     subprocess.run("rm -rf /data-nvme/zerogpu-offload/*", env={}, shell=True)
 
-# --- FRAME EXTRACTION JS & LOGIC ---
+# -----------------------------------------------------------------------------
+# Configuration
+# -----------------------------------------------------------------------------
 
-# JS to grab timestamp from the output video
-get_timestamp_js = """
-function() {
-    // Select the video element specifically inside the component with id 'generated-video'
-    const video = document.querySelector('#generated-video video');
-    
-    if (video) {
-        console.log("Video found! Time: " + video.currentTime);
-        return video.currentTime;
-    } else {
-        console.log("No video element found.");
-        return 0;
-    }
+DEFAULT_MODEL_ID = (
+    "TestOrganizationPleaseIgnore/"
+    "WAMU-Merge-MotionBoost_WAN2.2_I2V_LIGHTNING"
+)
+MODEL_ID = os.getenv("REPO_ID", DEFAULT_MODEL_ID).strip() or DEFAULT_MODEL_ID
+AOTI_REPO = os.getenv(
+    "AOTI_REPO", "cbensimon/WanTransformer3DModel-sm120-cu130-raa"
+).strip()
+ENABLE_AOTI = os.getenv("ENABLE_AOTI", "true").lower() not in {"0", "false", "no"}
+ENABLE_VAE_TILING = os.getenv("ENABLE_VAE_TILING", "false").lower() in {
+    "1",
+    "true",
+    "yes",
 }
-"""
-
-
-def extract_frame(video_path, timestamp):
-    # Safety check: if no video is present
-    if not video_path:
-        return None
-    
-    print(f"Extracting frame at timestamp: {timestamp}") 
-    
-    cap = cv2.VideoCapture(video_path)
-    
-    if not cap.isOpened():
-        return None
-
-    # Calculate frame number
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    target_frame_num = int(float(timestamp) * fps)
-    
-    # Cap total frames to prevent errors at the very end of video
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-    if target_frame_num >= total_frames:
-        target_frame_num = total_frames - 1
-    
-    # Set position
-    cap.set(cv2.CAP_PROP_POS_FRAMES, target_frame_num)
-    ret, frame = cap.read()
-    cap.release()
-    
-    if ret:
-        # Convert from BGR (OpenCV) to RGB (Gradio)
-        # Gradio Image component handles Numpy array -> PIL conversion automatically
-        return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    
-    return None
-
-# --- END FRAME EXTRACTION LOGIC ---
-
-
-def clear_vram():
-    gc.collect()
-    torch.cuda.empty_cache()
-
-
-# RIFE
-if not os.path.exists("RIFEv4.26_0921.zip"):
-    print("Downloading RIFE Model...")
-    subprocess.run([
-        "wget", "-q",
-        "https://huggingface.co/r3gm/RIFE/resolve/main/RIFEv4.26_0921.zip",
-        "-O", "RIFEv4.26_0921.zip"
-    ], check=True)
-    subprocess.run(["unzip", "-o", "RIFEv4.26_0921.zip"], check=True)
-
-# sys.path.append(os.getcwd())
-
-from train_log.RIFE_HDv3 import Model
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-rife_model = Model()
-rife_model.load_model("train_log", -1)
-rife_model.eval()
-
+RUNPOD_URL = os.getenv("RUNPOD_URL", "").strip()
+SUPPORT_URL = os.getenv("SUPPORT_URL", "").strip()
+MAX_GPU_SECONDS = int(os.getenv("MAX_GPU_SECONDS", "300"))
 
-@torch.no_grad()
-def interpolate_bits(frames_np, multiplier=2, scale=1.0):
-    """
-    Interpolation maintaining Numpy Float 0-1 format.
-    Args:
-        frames_np: Numpy Array (Time, Height, Width, Channels) - Float32 [0.0, 1.0]
-        multiplier: int (2, 4, 8)
-    Returns:
-        List of Numpy Arrays (Height, Width, Channels) - Float32 [0.0, 1.0]
-    """
-    
-    # Handle input shape
-    if isinstance(frames_np, list):
-        # Convert list of arrays to one big array for easier shape handling if needed, 
-        # but here we just grab dims from first frame
-        T = len(frames_np)
-        H, W, C = frames_np[0].shape
-    else:
-        T, H, W, C = frames_np.shape
-
-    # 1. No Interpolation Case
-    if multiplier < 2:
-        # Just convert 4D array to list of 3D arrays
-        if isinstance(frames_np, np.ndarray):
-            return list(frames_np)
-        return frames_np
-
-    n_interp = multiplier - 1
-    
-    # Pre-calc padding for RIFE (requires dimensions divisible by 32/scale)
-    tmp = max(128, int(128 / scale))
-    ph = ((H - 1) // tmp + 1) * tmp
-    pw = ((W - 1) // tmp + 1) * tmp
-    padding = (0, pw - W, 0, ph - H)
-
-    # Helper: Numpy (H, W, C) Float -> Tensor (1, C, H, W) Half
-    def to_tensor(frame_np):
-        # frame_np is float32 0-1
-        t = torch.from_numpy(frame_np).to(device)
-        # HWC -> CHW
-        t = t.permute(2, 0, 1).unsqueeze(0)
-        return F.pad(t, padding).half()
-
-    # Helper: Tensor (1, C, H, W) Half -> Numpy (H, W, C) Float
-    def from_tensor(tensor):
-        # Crop padding
-        t = tensor[0, :, :H, :W]
-        # CHW -> HWC
-        t = t.permute(1, 2, 0)
-        # Keep as float32, range 0-1
-        return t.float().cpu().numpy()
-
-    def make_inference(I0, I1, n):
-        if rife_model.version >= 3.9:
-            res = []
-            for i in range(n):
-                res.append(rife_model.inference(I0, I1, (i+1) * 1. / (n+1), scale))
-            return res
-        else:
-            middle = rife_model.inference(I0, I1, scale)
-            if n == 1:
-                return [middle]
-            first_half = make_inference(I0, middle, n=n//2)
-            second_half = make_inference(middle, I1, n=n//2)
-            if n % 2:
-                return [*first_half, middle, *second_half]
-            else:
-                return [*first_half, *second_half]
-
-    output_frames = []
-
-    # Process Frames
-    # Load first frame into GPU
-    I1 = to_tensor(frames_np[0])
-
-    total_steps = T - 1
-
-    with tqdm(total=total_steps, desc="Interpolating", unit="frame") as pbar:
-    
-        for i in range(total_steps):
-            I0 = I1
-            # Add original frame to output
-            output_frames.append(from_tensor(I0))
-    
-            # Load next frame
-            I1 = to_tensor(frames_np[i+1])
-    
-            # Generate intermediate frames
-            mid_tensors = make_inference(I0, I1, n_interp)
-    
-            # Append intermediate frames
-            for mid in mid_tensors:
-                output_frames.append(from_tensor(mid))
-
-            if (i + 1) % 50 == 0:
-                pbar.update(50)
-        pbar.update(total_steps % 50)
-        
-        # Add the very last frame
-        output_frames.append(from_tensor(I1))
-    
-    # Cleanup
-    del I0, I1, mid_tensors
-    torch.cuda.empty_cache()
-
-    return output_frames
-
-
-# WAN
-
-ORG_NAME = "TestOrganizationPleaseIgnore"
-# MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
-MODEL_ID = os.getenv("REPO_ID") or random.choice(
-    list(list_models(author=ORG_NAME, filter='diffusers:WanImageToVideoPipeline'))
-).modelId
-CACHE_DIR = os.path.expanduser("~/.cache/huggingface/")
-
-LORA_MODELS = [
-    # {
-    #     "repo_id": "lkzd7/WAN2.2_LoraSet_NSFW",
-    #     "high_tr": "wan2.2_i2v_high_ulitmate_pussy_asshole.safetensors",
-    #     "low_tr": "wan2.2_i2v_low_ulitmate_pussy_asshole.safetensors",
-    #     "high_scale": 0.5,
-    #     "low_scale": 0.5
-    # },
-    {
-        "repo_id": "jsoren/test_lora",
-        "high_tr": "DR34ML4Y_I2V_14B_HIGH_V2.safetensors",
-        "low_tr": "DR34ML4Y_I2V_14B_LOW_V2.safetensors",
-        "high_scale": 1.2,
-        "low_scale": 0.8
-    },
-]
+IS_ZERO_GPU = bool(os.getenv("SPACES_ZERO_GPU"))
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 MAX_DIM = 832
 MIN_DIM = 480
 SQUARE_DIM = 640
 MULTIPLE_OF = 16
-MAX_SEED = np.iinfo(np.int32).max
-
-FIXED_FPS = 16
-MIN_FRAMES_MODEL = 8
-MAX_FRAMES_MODEL = 160
-
-MIN_DURATION = round(MIN_FRAMES_MODEL / FIXED_FPS, 1)
-MAX_DURATION = round(MAX_FRAMES_MODEL / FIXED_FPS, 1)
+BASE_FPS = 16
+MIN_MODEL_FRAMES = 9
+MAX_MODEL_FRAMES = 161
+MIN_DURATION = round((MIN_MODEL_FRAMES - 1) / BASE_FPS, 1)
+MAX_DURATION = round((MAX_MODEL_FRAMES - 1) / BASE_FPS, 1)
+MAX_SEED = int(np.iinfo(np.int32).max)
+
+ASPECT_DIMENSIONS: dict[str, tuple[int, int] | None] = {
+    "Auto (keep source ratio)": None,
+    "Landscape 16:9": (832, 480),
+    "Portrait 9:16": (480, 832),
+    "Square 1:1": (640, 640),
+    "Portrait 4:5": (512, 640),
+    "Landscape 3:2": (768, 512),
+}
 
 SCHEDULER_MAP = {
     "FlowMatchEulerDiscrete": FlowMatchEulerDiscreteScheduler,
@@ -279,454 +101,969 @@ SCHEDULER_MAP = {
     "DPMSolverSinglestep": DPMSolverSinglestepScheduler,
 }
 
-pipe = WanImageToVideoPipeline.from_pretrained(
-    MODEL_ID,
-    torch_dtype=torch.bfloat16,
-).to('cuda')
-original_scheduler = copy.deepcopy(pipe.scheduler)
-
-for i, lora in enumerate(LORA_MODELS):
-    name_high_tr = lora["high_tr"].split(".")[0].split("/")[-1] + "Hh"
-    name_low_tr = lora["low_tr"].split(".")[0].split("/")[-1] + "Ll"
-    
-    try: 
-        pipe.load_lora_weights(
-            lora["repo_id"],
-            weight_name=lora["high_tr"],
-            adapter_name=name_high_tr
-        )
-    
-        kwargs_lora = {"load_into_transformer_2": True}
-        pipe.load_lora_weights(
-            lora["repo_id"],
-            weight_name=lora["low_tr"],
-            adapter_name=name_low_tr,
-            **kwargs_lora
-        )
-    
-        pipe.set_adapters([name_high_tr, name_low_tr], adapter_weights=[1.0, 1.0])
-    
-        pipe.fuse_lora(adapter_names=[name_high_tr], lora_scale=lora["high_scale"], components=["transformer"])
-        pipe.fuse_lora(adapter_names=[name_low_tr], lora_scale=lora["low_scale"], components=["transformer_2"])
-    
-        pipe.unload_lora_weights()
-
-        print(f"Applied: {lora['high_tr']}, hs={lora['high_scale']}/ls={lora['low_scale']}, {i+1}/{len(LORA_MODELS)}") 
-    except Exception as e:
-        print("Error:", str(e))
-        print("Failed LoRA:", name_high_tr)
-        pipe.unload_lora_weights()
-
-# if os.path.exists(CACHE_DIR):
-#     shutil.rmtree(CACHE_DIR)
-#     print("Deleted Hugging Face cache.")
-# else:
-#     print("No hub cache found.")
-
-quantize_(pipe.text_encoder, Int8WeightOnlyConfig())
-torch._dynamo.reset()
-quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig())
-torch._dynamo.reset()
-quantize_(pipe.transformer_2, Float8DynamicActivationFloat8WeightConfig())
-torch._dynamo.reset()
-
-spaces.aoti_load(
-    module=pipe.transformer,
-    repo_id='cbensimon/WanTransformer3DModel-sm120-cu130-raa',
+QUALITY_PROFILES = {
+    "Fast Preview": {"steps": 4, "quality": 5, "flow_shift": 3.0},
+    "Balanced": {"steps": 6, "quality": 7, "flow_shift": 3.0},
+    "High Quality": {"steps": 8, "quality": 8, "flow_shift": 3.5},
+}
+
+MOTION_STYLE_PROMPTS = {
+    "Natural": "natural realistic movement, physically plausible motion, stable composition",
+    "Cinematic": "cinematic motion, elegant pacing, dramatic depth, premium film look",
+    "Portrait": "subtle facial expression, natural blinking, gentle head movement, stable facial identity",
+    "Product Ad": "premium product commercial, controlled motion, clean composition, polished advertising look",
+    "Dynamic": "energetic movement, stronger motion, dramatic action, coherent fast pacing",
+    "Anime": "fluid anime-style animation, clean line consistency, expressive but stable movement",
+}
+
+CAMERA_PROMPTS = {
+    "Static": "locked-off camera, stable framing",
+    "Slow Push In": "slow smooth camera push-in",
+    "Slow Pull Back": "slow smooth camera pull-back",
+    "Pan Left": "slow cinematic camera pan to the left",
+    "Pan Right": "slow cinematic camera pan to the right",
+    "Orbit": "smooth controlled camera orbit around the subject",
+    "Handheld": "subtle realistic handheld camera movement",
+}
+
+MOTION_LEVEL_PROMPTS = {
+    "Low": "minimal subtle motion, preserve the original composition",
+    "Medium": "moderate natural motion with stable details",
+    "High": "strong visible motion while keeping the subject coherent",
+}
+
+DEFAULT_PROMPT = "Make this image come alive with smooth, realistic motion."
+DEFAULT_NEGATIVE_PROMPT = (
+    "overexposed, oversaturated, static frame, blurry details, low quality, worst quality, "
+    "jpeg artifacts, text, subtitles, watermark, logo, deformed face, identity drift, "
+    "bad anatomy, malformed limbs, extra fingers, fused fingers, duplicated person, "
+    "warped body, flicker, jitter, unstable background, abrupt camera movement, reverse walking, "
+    "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 最差质量, 低质量, 多余的手指, "
+    "画得不好的手部, 画得不好的脸部, 畸形的, 静止不动的画面, 杂乱的背景"
+)
+
+IDENTITY_PROMPT = (
+    "preserve the exact facial identity, facial structure, hairstyle, skin tone, clothing, "
+    "body proportions and distinguishing features throughout the video"
 )
-spaces.aoti_load(
-    module=pipe.transformer_2,
-    repo_id='cbensimon/WanTransformer3DModel-sm120-cu130-raa',
+IDENTITY_NEGATIVE = (
+    "face morphing, changing identity, changing hairstyle, changing clothes, distorted eyes, "
+    "asymmetric face, duplicated facial features"
 )
 
-# pipe.vae.enable_slicing()
-# pipe.vae.enable_tiling()
+# -----------------------------------------------------------------------------
+# Model loading: Wan 2.2 + FP8 + AOTI
+# -----------------------------------------------------------------------------
+
+if torch.cuda.is_available():
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.set_float32_matmul_precision("high")
+
+
+def _load_aoti_component(module: torch.nn.Module, repo_id: str) -> None:
+    """Load an AOTI package while remaining compatible with different spaces builds."""
+    if hasattr(spaces, "aoti_load"):
+        spaces.aoti_load(module=module, repo_id=repo_id)
+        return
+
+    from aoti import aoti_blocks_load
+
+    aoti_blocks_load(module=module, repo_id=repo_id)
+
+
+def load_pipeline() -> WanImageToVideoPipeline:
+    print(f"Loading model: {MODEL_ID}")
+    pipeline = WanImageToVideoPipeline.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.bfloat16,
+    ).to("cuda")
+
+    # The selected WAMU repository is already a merged Lightning/MotionBoost model.
+    # Do not fuse a second Lightning LoRA here; that can reduce quality and consistency.
+    print("Quantizing text encoder to INT8...")
+    quantize_(pipeline.text_encoder, Int8WeightOnlyConfig())
+    torch._dynamo.reset()
+
+    print("Quantizing high-noise transformer to FP8...")
+    quantize_(pipeline.transformer, Float8DynamicActivationFloat8WeightConfig())
+    torch._dynamo.reset()
+
+    print("Quantizing low-noise transformer to FP8...")
+    quantize_(pipeline.transformer_2, Float8DynamicActivationFloat8WeightConfig())
+    torch._dynamo.reset()
+
+    if ENABLE_AOTI:
+        print(f"Loading AOTI packages from: {AOTI_REPO}")
+        _load_aoti_component(pipeline.transformer, AOTI_REPO)
+        _load_aoti_component(pipeline.transformer_2, AOTI_REPO)
+
+    if ENABLE_VAE_TILING:
+        try:
+            pipeline.vae.enable_slicing()
+            pipeline.vae.enable_tiling()
+            print("VAE slicing and tiling enabled.")
+        except Exception as exc:
+            print(f"VAE tiling could not be enabled: {exc}")
+
+    return pipeline
+
+
+pipe = load_pipeline()
+ORIGINAL_SCHEDULER = copy.deepcopy(pipe.scheduler)
 
-default_prompt_i2v = "make this image come alive, cinematic motion, smooth animation"
-default_negative_prompt = "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, 整体发灰, 最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余的手指, 画得不好的手部, 画得不好的脸部, 畸形的, 毁容的, 形态畸形的肢体, 手指融合, 静止不动的画面, 杂乱的背景, 三条腿, 背景人很多, 倒着走"
+# -----------------------------------------------------------------------------
+# Optional RIFE interpolation, loaded lazily only when 32/64 FPS is requested
+# -----------------------------------------------------------------------------
 
+RIFE_REPO = "r3gm/RIFE"
+RIFE_FILENAME = "RIFEv4.26_0921.zip"
+RIFE_MODEL: Any | None = None
 
-def model_title():
-    repo_name = MODEL_ID.split('/')[-1].replace("_", " ")
-    url = f"https://huggingface.co/{MODEL_ID}"
-    return f"## This space is currently running [{repo_name}]({url}) 🐢"
 
+def ensure_rife_model() -> Any:
+    global RIFE_MODEL
+    if RIFE_MODEL is not None:
+        return RIFE_MODEL
 
-def resize_image(image: Image.Image) -> Image.Image:
+    if not Path("train_log/RIFE_HDv3.py").exists():
+        print("Downloading RIFE frame-interpolation model...")
+        archive = hf_hub_download(repo_id=RIFE_REPO, filename=RIFE_FILENAME)
+        with zipfile.ZipFile(archive, "r") as zip_ref:
+            zip_ref.extractall(".")
+
+    if os.getcwd() not in sys.path:
+        sys.path.insert(0, os.getcwd())
+
+    from train_log.RIFE_HDv3 import Model
+
+    model = Model()
+    model.load_model("train_log", -1)
+    model.eval()
+    RIFE_MODEL = model
+    return RIFE_MODEL
+
+
+@torch.no_grad()
+def interpolate_frames(
+    frames_np: np.ndarray | list[np.ndarray],
+    multiplier: int = 2,
+    scale: float = 1.0,
+) -> list[np.ndarray]:
+    if multiplier < 2:
+        return list(frames_np)
+
+    model = ensure_rife_model()
+    model.device()
+    model.flownet = model.flownet.half()
+
+    if isinstance(frames_np, list):
+        total_frames = len(frames_np)
+        height, width, _ = frames_np[0].shape
+    else:
+        total_frames, height, width, _ = frames_np.shape
+
+    interpolation_count = multiplier - 1
+    block = max(128, int(128 / scale))
+    padded_height = ((height - 1) // block + 1) * block
+    padded_width = ((width - 1) // block + 1) * block
+    padding = (0, padded_width - width, 0, padded_height - height)
+
+    def to_tensor(frame: np.ndarray) -> torch.Tensor:
+        tensor = torch.from_numpy(frame).to(DEVICE)
+        tensor = tensor.permute(2, 0, 1).unsqueeze(0)
+        return F.pad(tensor, padding).half()
+
+    def to_numpy(tensor: torch.Tensor) -> np.ndarray:
+        tensor = tensor[0, :, :height, :width].permute(1, 2, 0)
+        return tensor.float().cpu().numpy()
+
+    def infer_between(first: torch.Tensor, second: torch.Tensor, count: int) -> list[torch.Tensor]:
+        if model.version >= 3.9:
+            return [
+                model.inference(first, second, (index + 1) / (count + 1), scale)
+                for index in range(count)
+            ]
+
+        middle = model.inference(first, second, scale)
+        if count == 1:
+            return [middle]
+        first_half = infer_between(first, middle, count // 2)
+        second_half = infer_between(middle, second, count // 2)
+        if count % 2:
+            return [*first_half, middle, *second_half]
+        return [*first_half, *second_half]
+
+    output: list[np.ndarray] = []
+    next_tensor = to_tensor(frames_np[0])
+
+    with tqdm(total=total_frames - 1, desc="Frame interpolation", unit="frame") as bar:
+        for index in range(total_frames - 1):
+            current_tensor = next_tensor
+            output.append(to_numpy(current_tensor))
+            next_tensor = to_tensor(frames_np[index + 1])
+            for middle_tensor in infer_between(
+                current_tensor, next_tensor, interpolation_count
+            ):
+                output.append(to_numpy(middle_tensor))
+            bar.update(1)
+
+        output.append(to_numpy(next_tensor))
+
+    try:
+        model.flownet.to("cpu")
+    except Exception:
+        pass
+    clear_vram()
+    return output
+
+# -----------------------------------------------------------------------------
+# Image, prompt and scheduler helpers
+# -----------------------------------------------------------------------------
+
+
+def clear_vram() -> None:
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+def normalize_image(image: Image.Image) -> Image.Image:
+    return ImageOps.exif_transpose(image).convert("RGB")
+
+
+def center_crop_resize(image: Image.Image, size: tuple[int, int]) -> Image.Image:
+    image = normalize_image(image)
+    target_width, target_height = size
+    width, height = image.size
+    scale = max(target_width / width, target_height / height)
+    resized_width = max(target_width, round(width * scale))
+    resized_height = max(target_height, round(height * scale))
+    image = image.resize((resized_width, resized_height), Image.Resampling.LANCZOS)
+    left = (resized_width - target_width) // 2
+    top = (resized_height - target_height) // 2
+    return image.crop((left, top, left + target_width, top + target_height))
+
+
+def resize_auto(image: Image.Image) -> Image.Image:
+    image = normalize_image(image)
     width, height = image.size
+
     if width == height:
-        return image.resize((SQUARE_DIM, SQUARE_DIM), Image.LANCZOS)
-    
+        return image.resize((SQUARE_DIM, SQUARE_DIM), Image.Resampling.LANCZOS)
+
     aspect_ratio = width / height
-    MAX_ASPECT_RATIO = MAX_DIM / MIN_DIM
-    MIN_ASPECT_RATIO = MIN_DIM / MAX_DIM
+    maximum_ratio = MAX_DIM / MIN_DIM
+    minimum_ratio = MIN_DIM / MAX_DIM
+    source = image
 
-    image_to_resize = image
-    if aspect_ratio > MAX_ASPECT_RATIO:
-        target_w, target_h = MAX_DIM, MIN_DIM
-        crop_width = int(round(height * MAX_ASPECT_RATIO))
+    if aspect_ratio > maximum_ratio:
+        target_width, target_height = MAX_DIM, MIN_DIM
+        crop_width = round(height * maximum_ratio)
         left = (width - crop_width) // 2
-        image_to_resize = image.crop((left, 0, left + crop_width, height))
-    elif aspect_ratio < MIN_ASPECT_RATIO:
-        target_w, target_h = MIN_DIM, MAX_DIM
-        crop_height = int(round(width / MIN_ASPECT_RATIO))
+        source = image.crop((left, 0, left + crop_width, height))
+    elif aspect_ratio < minimum_ratio:
+        target_width, target_height = MIN_DIM, MAX_DIM
+        crop_height = round(width / minimum_ratio)
         top = (height - crop_height) // 2
-        image_to_resize = image.crop((0, top, width, top + crop_height))
+        source = image.crop((0, top, width, top + crop_height))
+    elif width > height:
+        target_width = MAX_DIM
+        target_height = round(target_width / aspect_ratio)
     else:
-        if width > height:
-            target_w = MAX_DIM
-            target_h = int(round(target_w / aspect_ratio))
-        else:
-            target_h = MAX_DIM
-            target_w = int(round(target_h * aspect_ratio))
+        target_height = MAX_DIM
+        target_width = round(target_height * aspect_ratio)
+
+    final_width = round(target_width / MULTIPLE_OF) * MULTIPLE_OF
+    final_height = round(target_height / MULTIPLE_OF) * MULTIPLE_OF
+    final_width = max(MIN_DIM, min(MAX_DIM, final_width))
+    final_height = max(MIN_DIM, min(MAX_DIM, final_height))
+    return source.resize((final_width, final_height), Image.Resampling.LANCZOS)
+
+
+def prepare_first_frame(image: Image.Image, aspect_ratio: str) -> Image.Image:
+    dimensions = ASPECT_DIMENSIONS.get(aspect_ratio)
+    if dimensions is None:
+        return resize_auto(image)
+    return center_crop_resize(image, dimensions)
+
+
+def prepare_last_frame(image: Image.Image, reference: Image.Image) -> Image.Image:
+    return center_crop_resize(image, reference.size)
+
+
+def get_num_frames(duration_seconds: float) -> int:
+    target = int(round(float(duration_seconds) * BASE_FPS)) + 1
+    # Wan video frame counts are most reliable as 4n + 1.
+    target = 4 * round((target - 1) / 4) + 1
+    return int(np.clip(target, MIN_MODEL_FRAMES, MAX_MODEL_FRAMES))
+
+
+def build_prompts(
+    prompt: str,
+    motion_style: str,
+    camera_motion: str,
+    motion_strength: str,
+    enhance_prompt: bool,
+    preserve_identity: bool,
+    negative_prompt: str,
+) -> tuple[str, str]:
+    prompt = (prompt or "").strip()
+    if not prompt:
+        prompt = DEFAULT_PROMPT
+
+    additions: list[str] = []
+    if enhance_prompt:
+        additions.extend(
+            [
+                MOTION_STYLE_PROMPTS.get(motion_style, ""),
+                CAMERA_PROMPTS.get(camera_motion, ""),
+                MOTION_LEVEL_PROMPTS.get(motion_strength, ""),
+                "smooth temporal consistency, coherent details, natural motion blur, no flicker",
+            ]
+        )
+    if preserve_identity:
+        additions.append(IDENTITY_PROMPT)
+
+    final_prompt = ", ".join(part for part in [prompt, *additions] if part)
+    final_negative = (negative_prompt or DEFAULT_NEGATIVE_PROMPT).strip()
+    if preserve_identity:
+        final_negative = f"{final_negative}, {IDENTITY_NEGATIVE}"
+    return final_prompt, final_negative
+
+
+def configure_scheduler(name: str, flow_shift: float) -> None:
+    scheduler_class = SCHEDULER_MAP.get(name, UniPCMultistepScheduler)
+    current_name = pipe.scheduler.config.get("_class_name", pipe.scheduler.__class__.__name__)
+    current_shift = pipe.scheduler.config.get(
+        "flow_shift", pipe.scheduler.config.get("shift", None)
+    )
+
+    if current_name == scheduler_class.__name__ and current_shift == flow_shift:
+        return
+
+    config = copy.deepcopy(ORIGINAL_SCHEDULER.config)
+    if scheduler_class is FlowMatchEulerDiscreteScheduler:
+        config["shift"] = float(flow_shift)
+    else:
+        config["flow_shift"] = float(flow_shift)
+    pipe.scheduler = scheduler_class.from_config(config)
+
+
+def profile_settings(profile: str):
+    values = QUALITY_PROFILES.get(profile, QUALITY_PROFILES["Balanced"])
+    return (
+        gr.update(value=values["steps"]),
+        gr.update(value=values["quality"]),
+        gr.update(value=values["flow_shift"]),
+    )
 
-    final_w = round(target_w / MULTIPLE_OF) * MULTIPLE_OF
-    final_h = round(target_h / MULTIPLE_OF) * MULTIPLE_OF
-    final_w = max(MIN_DIM, min(MAX_DIM, final_w))
-    final_h = max(MIN_DIM, min(MAX_DIM, final_h))
-    return image_to_resize.resize((final_w, final_h), Image.LANCZOS)
 
+def swap_images(first: Image.Image | None, last: Image.Image | None):
+    return last, first
 
-def resize_and_crop_to_match(target_image, reference_image):
-    ref_width, ref_height = reference_image.size
-    target_width, target_height = target_image.size
-    scale = max(ref_width / target_width, ref_height / target_height)
-    new_width, new_height = int(target_width * scale), int(target_height * scale)
-    resized = target_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
-    left, top = (new_width - ref_width) // 2, (new_height - ref_height) // 2
-    return resized.crop((left, top, left + ref_width, top + ref_height))
 
+def format_external_links() -> str:
+    links: list[str] = []
+    if RUNPOD_URL:
+        links.append(f"[⚡ Run on Private GPU via RunPod]({RUNPOD_URL})")
+    if SUPPORT_URL:
+        links.append(f"[❤️ Support This Free Tool]({SUPPORT_URL})")
+    return " &nbsp; • &nbsp; ".join(links)
 
-def get_num_frames(duration_seconds: float):
-    return 1 + int(np.clip(
-        int(round(duration_seconds * FIXED_FPS)),
-        MIN_FRAMES_MODEL,
-        MAX_FRAMES_MODEL,
-    ))
+# -----------------------------------------------------------------------------
+# GPU generation
+# -----------------------------------------------------------------------------
 
 
 def get_inference_duration(
-    resized_image,
-    processed_last_image,
-    prompt,
-    steps,
-    negative_prompt,
-    num_frames,
-    guidance_scale,
-    guidance_scale_2,
-    current_seed,
-    scheduler_name,
-    flow_shift,
-    frame_multiplier,
-    quality,
-    duration_seconds,
-    safe_mode,
-    progress
-):
-    BASE_FRAMES_HEIGHT_WIDTH = 81 * 832 * 624
-    BASE_STEP_DURATION = 5.
-    width, height = resized_image.size
-    factor = num_frames * width * height / BASE_FRAMES_HEIGHT_WIDTH
-    step_duration = BASE_STEP_DURATION * factor ** 1.5
-    gen_time = int(steps) * step_duration
-
-    if guidance_scale > 1:
-        gen_time = gen_time * 2.4
-
-    frame_factor = frame_multiplier // FIXED_FPS
-    if frame_factor > 1:
-        total_out_frames = (num_frames * frame_factor) - num_frames
-        inter_time = (total_out_frames * 0.02)
-        gen_time += inter_time
-
-    total_time = 15 + gen_time
+    first_frame: Image.Image,
+    last_frame: Image.Image | None,
+    prompt: str,
+    negative_prompt: str,
+    num_frames: int,
+    steps: int,
+    guidance_scale: float,
+    guidance_scale_2: float,
+    seed: int,
+    scheduler_name: str,
+    flow_shift: float,
+    output_fps: int,
+    video_quality: int,
+    safe_mode: bool,
+    progress,
+) -> int:
+    del last_frame, prompt, negative_prompt, guidance_scale_2, seed
+    del scheduler_name, flow_shift, video_quality, progress
+
+    base_pixels = 81 * 832 * 624
+    width, height = first_frame.size
+    factor = max(0.2, num_frames * width * height / base_pixels)
+    seconds_per_step = 5.0 * factor**1.5
+    estimated = 15 + int(steps) * seconds_per_step
+
+    if float(guidance_scale) > 1:
+        estimated *= 2.4
+
+    interpolation_multiplier = max(1, int(output_fps) // BASE_FPS)
+    if interpolation_multiplier > 1:
+        extra_frames = num_frames * interpolation_multiplier - num_frames
+        estimated += extra_frames * 0.025
+
     if safe_mode:
-        total_time = total_time * 1.30
+        estimated *= 1.25
 
-    return total_time
+    return int(max(30, min(MAX_GPU_SECONDS, round(estimated))))
 
 
-@spaces.GPU(duration=get_inference_duration, size='xlarge')
+@spaces.GPU(duration=get_inference_duration, size="xlarge")
 def run_inference(
-    resized_image,
-    processed_last_image,
-    prompt,
-    steps,
-    negative_prompt,
-    num_frames,
-    guidance_scale,
-    guidance_scale_2,
-    current_seed,
-    scheduler_name,
-    flow_shift,
-    frame_multiplier,
-    quality,
-    duration_seconds,
-    safe_mode=False,
+    first_frame: Image.Image,
+    last_frame: Image.Image | None,
+    prompt: str,
+    negative_prompt: str,
+    num_frames: int,
+    steps: int,
+    guidance_scale: float,
+    guidance_scale_2: float,
+    seed: int,
+    scheduler_name: str,
+    flow_shift: float,
+    output_fps: int,
+    video_quality: int,
+    safe_mode: bool,
     progress=gr.Progress(track_tqdm=True),
-):
-    scheduler_class = SCHEDULER_MAP.get(scheduler_name)
-    if scheduler_class.__name__ != pipe.scheduler.config._class_name or flow_shift != pipe.scheduler.config.get("flow_shift", "shift"):
-        config = copy.deepcopy(original_scheduler.config)
-        if scheduler_class == FlowMatchEulerDiscreteScheduler:
-            config['shift'] = flow_shift
-        else:
-            config['flow_shift'] = flow_shift
-        pipe.scheduler = scheduler_class.from_config(config)
-
+) -> tuple[str, str, float]:
+    del safe_mode
     clear_vram()
+    configure_scheduler(scheduler_name, flow_shift)
 
-    task_name = str(uuid.uuid4())[:8]
-    print(f"Generating {num_frames} frames, task: {task_name}, {duration_seconds}, {resized_image.size}")
-    start = time.time()
-    result = pipe(
-        image=resized_image,
-        last_image=processed_last_image,
-        prompt=prompt,
-        negative_prompt=negative_prompt,
-        height=resized_image.height,
-        width=resized_image.width,
-        num_frames=num_frames,
-        guidance_scale=float(guidance_scale),
-        guidance_scale_2=float(guidance_scale_2),
-        num_inference_steps=int(steps),
-        generator=torch.Generator(device="cuda").manual_seed(current_seed),
-        output_type="np" 
+    task_id = str(uuid.uuid4())[:8]
+    started = time.time()
+    print(
+        f"Task {task_id}: {num_frames} frames, {first_frame.size}, "
+        f"{steps} steps, seed={seed}"
     )
-    print("gen time passed:", time.time() - start)
-    
-    raw_frames_np = result.frames[0]  # Returns (T, H, W, C) float32
-    pipe.scheduler = original_scheduler
-
-    frame_factor = frame_multiplier // FIXED_FPS
-    if frame_factor > 1:
-        start = time.time()
-        print(f"Processing frames (RIFE Multiplier: {frame_factor}x)...")
-        rife_model.device()
-        rife_model.flownet = rife_model.flownet.half()
-        final_frames = interpolate_bits(raw_frames_np, multiplier=int(frame_factor))
-        print("Interpolation time passed:", time.time() - start)
-    else:
-        final_frames = list(raw_frames_np)
 
-    final_fps = FIXED_FPS * int(frame_factor)
+    try:
+        result = pipe(
+            image=first_frame,
+            last_image=last_frame,
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=first_frame.height,
+            width=first_frame.width,
+            num_frames=int(num_frames),
+            guidance_scale=float(guidance_scale),
+            guidance_scale_2=float(guidance_scale_2),
+            num_inference_steps=int(steps),
+            generator=torch.Generator(device="cuda").manual_seed(int(seed)),
+            output_type="np",
+        )
 
-    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
-        video_path = tmpfile.name
+        raw_frames = result.frames[0]
+        multiplier = max(1, int(output_fps) // BASE_FPS)
+        if multiplier > 1:
+            print(f"Task {task_id}: applying RIFE {multiplier}x interpolation")
+            final_frames = interpolate_frames(raw_frames, multiplier=multiplier)
+        else:
+            final_frames = list(raw_frames)
 
-    start = time.time()
-    with tqdm(total=3, desc="Rendering Media", unit="clip") as pbar:
-        pbar.update(2)
-        export_to_video(final_frames, video_path, fps=final_fps, quality=quality)
-        pbar.update(1)
-    print(f"Export time passed, {final_fps} FPS:", time.time() - start)
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_file:
+            video_path = temp_file.name
 
-    return video_path, task_name
+        export_to_video(
+            final_frames,
+            video_path,
+            fps=int(output_fps),
+            quality=int(video_quality),
+        )
+        elapsed = time.time() - started
+        print(f"Task {task_id}: completed in {elapsed:.1f}s")
+        return video_path, task_id, elapsed
+    finally:
+        pipe.scheduler = ORIGINAL_SCHEDULER
+        clear_vram()
 
 
 def generate_video(
-    input_image,
-    last_image,
-    prompt,
-    steps=4,
-    negative_prompt=default_negative_prompt,
-    duration_seconds=MAX_DURATION,
-    guidance_scale=1,
-    guidance_scale_2=1,
-    seed=42,
-    randomize_seed=False,
-    quality=5,
-    scheduler="UniPCMultistep",
-    flow_shift=6.0,
-    frame_multiplier=16,
-    safe_mode=False,
-    video_component=True,
+    first_image: Image.Image | None,
+    last_image: Image.Image | None,
+    generation_mode: str,
+    prompt: str,
+    motion_style: str,
+    camera_motion: str,
+    motion_strength: str,
+    preserve_identity: bool,
+    enhance_prompt: bool,
+    aspect_ratio: str,
+    duration_seconds: float,
+    output_fps: int,
+    quality_profile: str,
+    steps: int,
+    negative_prompt: str,
+    video_quality: int,
+    seed: int,
+    randomize_seed: bool,
+    guidance_scale: float,
+    guidance_scale_2: float,
+    scheduler_name: str,
+    flow_shift: float,
+    safe_mode: bool,
+    show_preview: bool,
     progress=gr.Progress(track_tqdm=True),
 ):
-    """
-    Generate a video from an input image using the Wan 2.2 14B I2V model with Lightning LoRA.
-    This function takes an input image and generates a video animation based on the provided
-    prompt and parameters. It uses an FP8 qunatized Wan 2.2 14B Image-to-Video model in with Lightning LoRA
-    for fast generation in 4-8 steps.
-    Args:
-        input_image (PIL.Image): The input image to animate. Will be resized to target dimensions.
-        last_image (PIL.Image, optional): The optional last image for the video.
-        prompt (str): Text prompt describing the desired animation or motion.
-        steps (int, optional): Number of inference steps. More steps = higher quality but slower.
-            Defaults to 4. Range: 1-30.
-        negative_prompt (str, optional): Negative prompt to avoid unwanted elements.
-            Defaults to default_negative_prompt (contains unwanted visual artifacts).
-        duration_seconds (float, optional): Duration of the generated video in seconds.
-            Defaults to 2. Clamped between MIN_FRAMES_MODEL/FIXED_FPS and MAX_FRAMES_MODEL/FIXED_FPS.
-        guidance_scale (float, optional): Controls adherence to the prompt. Higher values = more adherence.
-            Defaults to 1.0. Range: 0.0-20.0.
-        guidance_scale_2 (float, optional): Controls adherence to the prompt. Higher values = more adherence.
-            Defaults to 1.0. Range: 0.0-20.0.
-        seed (int, optional): Random seed for reproducible results. Defaults to 42.
-            Range: 0 to MAX_SEED (2147483647).
-        randomize_seed (bool, optional): Whether to use a random seed instead of the provided seed.
-            Defaults to False.
-        quality (float, optional): Video output quality. Default is 5. Uses variable bit rate.
-            Highest quality is 10, lowest is 1.
-        scheduler (str, optional): The name of the scheduler to use for inference. Defaults to "UniPCMultistep".
-        flow_shift (float, optional): The flow shift value for compatible schedulers. Defaults to 6.0.
-        frame_multiplier (int, optional): The int value for fps enhancer
-        video_component(bool, optional): Show video player in output.
-            Defaults to True.
-        progress (gr.Progress, optional): Gradio progress tracker. Defaults to gr.Progress(track_tqdm=True).
-    Returns:
-        tuple: A tuple containing:
-            - video_path (str): Path for the video component.
-            - video_path (str): Path for the file download component. Attempt to avoid reconversion in video component.
-            - current_seed (int): The seed used for generation.
-    Raises:
-        gr.Error: If input_image is None (no image uploaded).
-    Note:
-        - Frame count is calculated as duration_seconds * FIXED_FPS (24)
-        - Output dimensions are adjusted to be multiples of MOD_VALUE (32)
-        - The function uses GPU acceleration via the @spaces.GPU decorator
-        - Generation time varies based on steps and duration (see get_duration function)
-    """
-    
-    if input_image is None:
-        raise gr.Error("Please upload an input image.")
+    if first_image is None:
+        raise gr.Error("Please upload a first image.")
+
+    use_last_frame = generation_mode == "First + Last Frame"
+    if use_last_frame and last_image is None:
+        raise gr.Error("Please upload a last image or switch to Single Image mode.")
+
+    first_frame = prepare_first_frame(first_image, aspect_ratio)
+    final_last_frame = (
+        prepare_last_frame(last_image, first_frame)
+        if use_last_frame and last_image is not None
+        else None
+    )
+
+    final_prompt, final_negative = build_prompts(
+        prompt=prompt,
+        motion_style=motion_style,
+        camera_motion=camera_motion,
+        motion_strength=motion_strength,
+        enhance_prompt=enhance_prompt,
+        preserve_identity=preserve_identity,
+        negative_prompt=negative_prompt,
+    )
 
     num_frames = get_num_frames(duration_seconds)
     current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
-    resized_image = resize_image(input_image)
 
-    processed_last_image = None
-    if last_image:
-        processed_last_image = resize_and_crop_to_match(last_image, resized_image)
+    try:
+        video_path, task_id, elapsed = run_inference(
+            first_frame,
+            final_last_frame,
+            final_prompt,
+            final_negative,
+            num_frames,
+            int(steps),
+            float(guidance_scale),
+            float(guidance_scale_2),
+            current_seed,
+            scheduler_name,
+            float(flow_shift),
+            int(output_fps),
+            int(video_quality),
+            bool(safe_mode),
+            progress,
+        )
+    except gr.Error:
+        raise
+    except Exception as exc:
+        clear_vram()
+        message = str(exc).strip() or exc.__class__.__name__
+        print(f"Generation failed: {message}")
+        raise gr.Error(f"Generation failed: {message}") from exc
+
+    mode_label = "First → Last" if use_last_frame else "Single Image"
+    status = (
+        f"### ✅ Generation complete\n"
+        f"**Task:** `{task_id}` &nbsp; • &nbsp; **Mode:** {mode_label} &nbsp; • &nbsp; "
+        f"**Resolution:** {first_frame.width}×{first_frame.height} &nbsp; • &nbsp; "
+        f"**Frames:** {num_frames} at {output_fps} FPS &nbsp; • &nbsp; "
+        f"**Seed:** `{current_seed}` &nbsp; • &nbsp; **Time:** {elapsed:.1f}s"
+    )
 
-    video_path, task_n = run_inference(
-        resized_image,
-        processed_last_image,
-        prompt,
-        steps,
-        negative_prompt,
-        num_frames,
-        guidance_scale,
-        guidance_scale_2,
+    return (
+        video_path if show_preview else None,
+        video_path,
         current_seed,
-        scheduler,
-        flow_shift,
-        frame_multiplier,
-        quality,
-        duration_seconds,
-        safe_mode,
-        progress,
+        status,
+        final_prompt,
     )
-    print(f"GPU complete: {task_n}")
 
-    return (video_path if video_component else None), video_path, current_seed
+# -----------------------------------------------------------------------------
+# Frame extraction from generated video
+# -----------------------------------------------------------------------------
+
+GET_TIMESTAMP_JS = """
+function() {
+    const video = document.querySelector('#generated-video video');
+    return video ? video.currentTime : 0;
+}
+"""
+
+
+def extract_frame(video_path: str | None, timestamp: float) -> np.ndarray | None:
+    if not video_path:
+        raise gr.Error("Generate or upload a video first.")
+
+    capture = cv2.VideoCapture(video_path)
+    if not capture.isOpened():
+        raise gr.Error("The video could not be opened.")
+
+    fps = capture.get(cv2.CAP_PROP_FPS) or BASE_FPS
+    total_frames = max(1, int(capture.get(cv2.CAP_PROP_FRAME_COUNT)))
+    frame_number = int(max(0, float(timestamp)) * fps)
+    frame_number = min(frame_number, total_frames - 1)
+    capture.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+    success, frame = capture.read()
+    capture.release()
+
+    if not success:
+        raise gr.Error("The selected frame could not be extracted.")
+    return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+# -----------------------------------------------------------------------------
+# Interface
+# -----------------------------------------------------------------------------
+
+
+def model_heading() -> str:
+    name = MODEL_ID.split("/")[-1].replace("_", " ")
+    return (
+        "<div class='hero'>"
+        "<div class='hero-badge'>WAN 2.2 • FP8 • AOTI • Lightning</div>"
+        "<h1>Dream Motion Pro</h1>"
+        "<p>Turn a single image—or a first and last frame—into a smooth cinematic video.</p>"
+        f"<p class='model-line'>Running <a href='https://huggingface.co/{MODEL_ID}' target='_blank'>{name}</a></p>"
+        "</div>"
+    )
 
 
 CSS = """
+.gradio-container { max-width: 1380px !important; }
+.hero {
+    padding: 26px 28px;
+    margin-bottom: 18px;
+    border: 1px solid var(--border-color-primary);
+    border-radius: 20px;
+    background: linear-gradient(135deg, rgba(79,70,229,.15), rgba(6,182,212,.09));
+}
+.hero h1 { margin: 8px 0 5px; font-size: 2.15rem; }
+.hero p { margin: 4px 0; opacity: .88; }
+.hero-badge {
+    display: inline-block;
+    padding: 6px 11px;
+    border-radius: 999px;
+    font-weight: 700;
+    font-size: .78rem;
+    letter-spacing: .04em;
+    border: 1px solid var(--border-color-primary);
+}
+.model-line { font-size: .9rem; }
+#generate-button { min-height: 52px; font-weight: 800; font-size: 1.02rem; }
+#generated-video video { border-radius: 16px; }
 #hidden-timestamp {
     opacity: 0;
-    height: 0px;
-    width: 0px;
-    margin: 0px;
-    padding: 0px;
+    height: 0;
+    width: 0;
+    margin: 0;
+    padding: 0;
     overflow: hidden;
     position: absolute;
     pointer-events: none;
 }
+.link-row { text-align: center; padding: 8px 0 2px; font-weight: 650; }
+.tip-box {
+    border: 1px solid var(--border-color-primary);
+    border-radius: 14px;
+    padding: 12px 14px;
+}
 """
 
+with gr.Blocks(
+    css=CSS,
+    theme=gr.themes.Soft(),
+    delete_cache=(3600, 10800),
+    title="Dream Motion Pro",
+) as demo:
+    gr.HTML(model_heading())
+
+    with gr.Row(equal_height=False):
+        with gr.Column(scale=6):
+            generation_mode = gr.Radio(
+                ["Single Image", "First + Last Frame"],
+                value="Single Image",
+                label="Generation Mode",
+                info="The second mode guides both the beginning and ending of the video.",
+            )
+
+            with gr.Row():
+                first_image = gr.Image(
+                    type="pil",
+                    label="First Image",
+                    sources=["upload", "clipboard"],
+                    height=320,
+                )
+                last_image = gr.Image(
+                    type="pil",
+                    label="Last Image (used only in First + Last Frame mode)",
+                    sources=["upload", "clipboard"],
+                    height=320,
+                )
+
+            with gr.Row():
+                swap_button = gr.Button("⇄ Swap First / Last", variant="secondary")
 
-with gr.Blocks(delete_cache=(3600, 10800)) as demo:
-    gr.Markdown(model_title())
-    gr.Markdown("Run Wan 2.2 in just 4-8 steps, fp8 quantization & AoT compilation - compatible with 🧨 diffusers and ZeroGPU")
-
-    with gr.Row():
-        with gr.Column():
-            input_image_component = gr.Image(type="pil", label="Input Image", sources=["upload", "clipboard"])
-            prompt_input = gr.Textbox(label="Prompt", value=default_prompt_i2v)
-            duration_seconds_input = gr.Slider(minimum=MIN_DURATION, maximum=MAX_DURATION, step=0.1, value=3.5, label="Duration (seconds)", info=f"Clamped to model's {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} frames at {FIXED_FPS}fps.")
-            frame_multi = gr.Dropdown(
-                choices=[FIXED_FPS, FIXED_FPS*2, FIXED_FPS*4, FIXED_FPS*8],
-                value=FIXED_FPS,
-                label="Video Fluidity (Frames per Second)",
-                info="Extra frames will be generated using flow estimation, which estimates motion between frames to make the video smoother."
+            prompt_input = gr.Textbox(
+                label="Describe the motion",
+                value=DEFAULT_PROMPT,
+                lines=3,
+                placeholder="Example: The subject looks toward the camera while the camera slowly pushes in.",
             )
-            safe_mode_checkbox = gr.Checkbox(
-                label="🛠️ Safe Mode",
-                value=True,
-                info="Requests 30% extra processing time to try to prevent unfinished tasks when the server is busy."
+
+            motion_style = gr.Radio(
+                choices=list(MOTION_STYLE_PROMPTS.keys()),
+                value="Cinematic",
+                label="Motion Style",
             )
-            with gr.Accordion("Advanced Settings", open=False):
-                last_image_component = gr.Image(type="pil", label="Last Image (Optional)", sources=["upload", "clipboard"])
-                negative_prompt_input = gr.Textbox(label="Negative Prompt", value=default_negative_prompt, info="Used if any Guidance Scale > 1.", lines=3)
-                quality_slider = gr.Slider(minimum=1, maximum=10, step=1, value=6, label="Video Quality", info="If set to 10, the generated video may be too large and won't play in the Gradio preview.")
-                seed_input = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=42, interactive=True)
-                randomize_seed_checkbox = gr.Checkbox(label="Randomize seed", value=True, interactive=True)
-                steps_slider = gr.Slider(minimum=1, maximum=30, step=1, value=6, label="Inference Steps")
-                guidance_scale_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="Guidance Scale - high noise stage", info="Values above 1 increase GPU usage and may take longer to process.")
-                guidance_scale_2_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="Guidance Scale 2 - low noise stage")
-                scheduler_dropdown = gr.Dropdown(
-                    label="Scheduler",
-                    choices=list(SCHEDULER_MAP.keys()),
-                    value="UniPCMultistep",
-                    info="Select a custom scheduler."
+
+            with gr.Row():
+                quality_profile = gr.Dropdown(
+                    choices=list(QUALITY_PROFILES.keys()),
+                    value="Balanced",
+                    label="Quality Mode",
                 )
-                flow_shift_slider = gr.Slider(minimum=0.5, maximum=15.0, step=0.1, value=3.0, label="Flow Shift")
-                play_result_video = gr.Checkbox(label="Display result", value=True, interactive=True)
-                gr.Markdown(f"[ZeroGPU help, tips and troubleshooting](https://huggingface.co/datasets/{ORG_NAME}/help/blob/main/gpu_help.md)")
-                gr.Markdown(  # TestOrganizationPleaseIgnore/wamu-tools
-                    "To use a different model, **duplicate this Space** first, then change the `REPO_ID` environment variable. "
-                    "[See compatible models here](https://huggingface.co/models?other=diffusers:WanImageToVideoPipeline&sort=trending&search=WAN2.2_I2V_LIGHTNING)."
+                aspect_ratio = gr.Dropdown(
+                    choices=list(ASPECT_DIMENSIONS.keys()),
+                    value="Auto (keep source ratio)",
+                    label="Aspect Ratio",
                 )
 
-            generate_button = gr.Button("Generate Video", variant="primary")
+            with gr.Row():
+                duration_seconds = gr.Slider(
+                    minimum=MIN_DURATION,
+                    maximum=MAX_DURATION,
+                    step=0.5,
+                    value=3.5,
+                    label="Duration (seconds)",
+                )
+                output_fps = gr.Dropdown(
+                    choices=[16, 32, 64],
+                    value=16,
+                    label="Output FPS",
+                    info="32/64 FPS uses RIFE interpolation after generation.",
+                )
+
+            with gr.Row():
+                preserve_identity = gr.Checkbox(
+                    value=True,
+                    label="Preserve Face & Identity",
+                )
+                enhance_prompt = gr.Checkbox(
+                    value=True,
+                    label="Professional Prompt Enhancement",
+                )
+
+            with gr.Accordion("Advanced Controls", open=False):
+                with gr.Row():
+                    camera_motion = gr.Dropdown(
+                        choices=list(CAMERA_PROMPTS.keys()),
+                        value="Slow Push In",
+                        label="Camera Movement",
+                    )
+                    motion_strength = gr.Radio(
+                        choices=list(MOTION_LEVEL_PROMPTS.keys()),
+                        value="Medium",
+                        label="Motion Strength",
+                    )
+
+                negative_prompt = gr.Textbox(
+                    label="Negative Prompt",
+                    value=DEFAULT_NEGATIVE_PROMPT,
+                    lines=4,
+                )
+
+                with gr.Row():
+                    steps = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        step=1,
+                        value=6,
+                        label="Inference Steps",
+                        info="Lightning models normally perform best around 4–8 steps.",
+                    )
+                    video_quality = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        step=1,
+                        value=7,
+                        label="MP4 Quality",
+                    )
+
+                with gr.Row():
+                    seed = gr.Slider(
+                        minimum=0,
+                        maximum=MAX_SEED,
+                        step=1,
+                        value=42,
+                        label="Seed",
+                    )
+                    randomize_seed = gr.Checkbox(
+                        value=True,
+                        label="Randomize Seed",
+                    )
+
+                with gr.Row():
+                    guidance_scale = gr.Slider(
+                        minimum=0.0,
+                        maximum=6.0,
+                        step=0.5,
+                        value=1.0,
+                        label="High-noise Guidance",
+                    )
+                    guidance_scale_2 = gr.Slider(
+                        minimum=0.0,
+                        maximum=6.0,
+                        step=0.5,
+                        value=1.0,
+                        label="Low-noise Guidance",
+                    )
+
+                with gr.Row():
+                    scheduler_name = gr.Dropdown(
+                        choices=list(SCHEDULER_MAP.keys()),
+                        value="UniPCMultistep",
+                        label="Scheduler",
+                    )
+                    flow_shift = gr.Slider(
+                        minimum=0.5,
+                        maximum=12.0,
+                        step=0.1,
+                        value=3.0,
+                        label="Flow Shift",
+                    )
+
+                with gr.Row():
+                    safe_mode = gr.Checkbox(
+                        value=True,
+                        label="Extra ZeroGPU Time Buffer",
+                    )
+                    show_preview = gr.Checkbox(
+                        value=True,
+                        label="Show Video Preview",
+                    )
+
+            generate_button = gr.Button(
+                "✨ Generate Video",
+                variant="primary",
+                elem_id="generate-button",
+            )
+
+            gr.Markdown(
+                "**Best results:** use a clear image, describe one main action, keep camera movement controlled, "
+                "and generate 2–3 variations with different seeds."
+            )
+
+        with gr.Column(scale=6):
+            video_output = gr.Video(
+                label="Generated Video",
+                autoplay=True,
+                buttons=["download", "share"],
+                interactive=False,
+                elem_id="generated-video",
+            )
+            status_output = gr.Markdown("Your generation details will appear here.")
 
-        with gr.Column():
-            # ASSIGNED elem_id="generated-video" so JS can find it
-            video_output = gr.Video(label="Generated Video", autoplay=True, sources=["upload"], buttons=["download", "share"], interactive=True, elem_id="generated-video")
-            
-            # --- Frame Grabbing UI ---
             with gr.Row():
-                grab_frame_btn = gr.Button("📸 Use Current Frame as Input", variant="secondary")
-                timestamp_box = gr.Number(value=0, label="Timestamp", visible=True, elem_id="hidden-timestamp")
-            # -------------------------
-            
-            file_output = gr.File(label="Download Video")
-
-    ui_inputs = [
-        input_image_component, last_image_component, prompt_input, steps_slider,
-        negative_prompt_input, duration_seconds_input,
-        guidance_scale_input, guidance_scale_2_input, seed_input, randomize_seed_checkbox,
-        quality_slider, scheduler_dropdown, flow_shift_slider, frame_multi,
-        safe_mode_checkbox,
-        play_result_video
+                grab_frame_button = gr.Button(
+                    "📸 Use Current Video Frame as First Image",
+                    variant="secondary",
+                )
+                timestamp_box = gr.Number(
+                    value=0,
+                    visible=True,
+                    elem_id="hidden-timestamp",
+                )
+
+            file_output = gr.File(label="Download Original MP4")
+
+            with gr.Accordion("Prompt used for this result", open=False):
+                final_prompt_output = gr.Textbox(
+                    label="Enhanced Prompt",
+                    interactive=False,
+                    lines=5,
+                )
+
+            external_links = format_external_links()
+            if external_links:
+                gr.Markdown(
+                    f"<div class='link-row'>{external_links}</div>",
+                    sanitize_html=False,
+                )
+
+            gr.Markdown(
+                "### Why this Space is fast\n"
+                "The Wan 2.2 high-noise and low-noise transformers run with FP8 quantization and AOTI-compiled blocks. "
+                "The selected WAMU checkpoint already includes Lightning and MotionBoost behavior."
+            )
+
+    quality_profile.change(
+        fn=profile_settings,
+        inputs=[quality_profile],
+        outputs=[steps, video_quality, flow_shift],
+    )
+
+    swap_button.click(
+        fn=swap_images,
+        inputs=[first_image, last_image],
+        outputs=[first_image, last_image],
+    )
+
+    inputs = [
+        first_image,
+        last_image,
+        generation_mode,
+        prompt_input,
+        motion_style,
+        camera_motion,
+        motion_strength,
+        preserve_identity,
+        enhance_prompt,
+        aspect_ratio,
+        duration_seconds,
+        output_fps,
+        quality_profile,
+        steps,
+        negative_prompt,
+        video_quality,
+        seed,
+        randomize_seed,
+        guidance_scale,
+        guidance_scale_2,
+        scheduler_name,
+        flow_shift,
+        safe_mode,
+        show_preview,
     ]
-    
+
     generate_button.click(
-        fn=generate_video, 
-        inputs=ui_inputs, 
-        outputs=[video_output, file_output, seed_input]
+        fn=generate_video,
+        inputs=inputs,
+        outputs=[
+            video_output,
+            file_output,
+            seed,
+            status_output,
+            final_prompt_output,
+        ],
     )
-    
-    # --- Frame Grabbing Events ---
-    # 1. Click button -> JS runs -> puts time in hidden number box
-    grab_frame_btn.click(
+
+    grab_frame_button.click(
         fn=None,
         inputs=None,
         outputs=[timestamp_box],
-        js=get_timestamp_js
+        js=GET_TIMESTAMP_JS,
     )
-    
-    # 2. Hidden number box changes -> Python runs -> puts frame in Input Image
     timestamp_box.change(
         fn=extract_frame,
         inputs=[video_output, timestamp_box],
-        outputs=[input_image_component]
+        outputs=[first_image],
     )
 
 if __name__ == "__main__":
-    demo.queue().launch(
+    demo.queue(default_concurrency_limit=1, max_size=20).launch(
         mcp_server=True,
-        css=CSS,
         show_error=True,
-    )
+    )

packages.txt

@@ -1 +1 @@
-ffmpeg
+ffmpeg

requirements.txt

@@ -1,19 +1,22 @@
+gradio==6.0.1
+spaces
+huggingface_hub
+
 diffusers==0.38.0
 transformers==4.57.6
-accelerate===1.13.0
+accelerate==1.13.0
 safetensors
 sentencepiece
 peft==0.19.1
 ftfy
-imageio
-imageio-ffmpeg
-opencv-python
-torchao==0.17.0
 
-numpy>=1.16, <=1.23.5
-# tqdm>=4.35.0
-# sk-video>=1.1.10
-# opencv-python>=4.1.2
-# moviepy>=1.0.3
 torch==2.11.0
 torchvision==0.26.0
+torchao==0.17.0
+
+numpy>=1.23.5,<3
+Pillow
+opencv-python-headless
+imageio
+imageio-ffmpeg
+tqdm