enforce

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+_hf_token
+_tt.py
+test.py
+__pycache__
+day_hf
+logs.sh
+api-i2v.md
+api.doc.md
+.venv

README.md

@@ -0,0 +1,35 @@
+---
+title: "I2V ( 70%+ ZeroGPU Quota Savings ) AoT Compiled"
+emoji: ⚡
+colorFrom: yellow
+colorTo: red
+sdk: gradio
+sdk_version: 6.0.1
+app_file: app.py
+pinned: true
+short_description: "🎬 VIP Prompt Relay, 🎬 RIFE Motion 32/64 FPS 🚀"
+---
+
+# 🎬 I2V EXTENDED (Wan 2.2 14B Base Model)
+
+An advanced Image-to-Video generation platform powered by **Wan 2.2 14B**, optimized for ultra-efficient ZeroGPU quota consumption (~70%+ GPU quota savings).
+
+---
+
+## ⚡ Key Features
+
+- **🎬 Wan 2.2 14B Base Model**: High-performance diffusion model with 4-step Lightning acceleration.
+- **⏱️ Prompt Relay Schedule**: Fine-grained temporal text prompt scheduling across video frame timesteps.
+- **⚡ Motion Extension Techniques**:
+  - **Real-Time RIFE Interpolation**: 32/64 FPS ultra-smooth playback.
+  - **Ending-Only Boomerang Loop**: Real-speed forward playback with tail 1.5s boomerang ping-pong loop.
+  - **Classic Full Boomerang Loop**: 100% natural real-speed forward + reverse loop.
+  - **Adaptive Motion Speed Ramping**: Cubic smoothstep curve easing.
+- **📸 3-Way Instant Frame Grab**: Grab video frames instantly as Next Input Image, Last Frame, or Face Swap Target.
+- **👤 Standalone Face Swapper & GFPGAN Restoration**: CPU-based face swap and facial detail sharpening.
+- **💎 VIP Remote Acceleration Engine**: High-speed offloaded GPU acceleration with zero CPU load.
+
+---
+
+## 📄 License
+Sulphur AI Project - High-Performance Cinematic Video Generation.

aoti.py

@@ -0,0 +1,35 @@
+"""
+"""
+
+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
+
+
+def _shallow_clone_module(module: torch.nn.Module) -> torch.nn.Module:
+    clone = object.__new__(module.__class__)
+    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}
+    return clone
+
+
+def aoti_blocks_load(module: torch.nn.Module, repo_id: str, variant: str | 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}
+    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)

app.py

@@ -0,0 +1,17 @@
+import spaces
+import os
+# os.system('pip install --upgrade --no-deps spaces')
+from ui import create_ui, CSS
+
+demo = create_ui()
+
+if __name__ == "__main__":
+    demo.queue().launch(
+        ssr_mode=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        mcp_server=True,
+        css=CSS,
+        show_error=True,
+        share=True
+    )

config.py

@@ -0,0 +1,57 @@
+import os
+import warnings
+import numpy as np
+from diffusers import (
+    FlowMatchEulerDiscreteScheduler,
+    SASolverScheduler,
+    DEISMultistepScheduler,
+    DPMSolverMultistepInverseScheduler,
+    UniPCMultistepScheduler,
+    DPMSolverMultistepScheduler,
+    DPMSolverSinglestepScheduler,
+)
+
+os.environ["TOKENIZERS_PARALLELISM"] = "true"
+warnings.filterwarnings("ignore")
+IS_ZERO_GPU = bool(os.getenv("SPACES_ZERO_GPU"))
+
+DT = os.environ.get("DATASET_TOKEN", "")
+SULPHUR_API_URL = os.environ.get("SULPHUR_API_URL", "http://localhost:6666")
+VIP_PASS = os.environ.get("VIP_PASSWORD", "").strip()
+
+MODEL_ID = "thornmaze/WAMU_v3_WAN2.2_I2V_LIGHTNING"
+LORA_MODELS = []
+MAX_DIM = 640
+MIN_DIM = 480
+SQUARE_DIM = 576
+MULTIPLE_OF = 16
+MAX_SEED = np.iinfo(np.int32).max
+FIXED_FPS = 16
+MIN_FRAMES_MODEL = 8
+MAX_FRAMES_MODEL = 129
+MIN_DURATION = round(MIN_FRAMES_MODEL / FIXED_FPS, 1)
+MAX_DURATION = 8.0
+
+SCHEDULER_MAP = {
+    "FlowMatchEulerDiscrete": FlowMatchEulerDiscreteScheduler,
+    "SASolver": SASolverScheduler,
+    "DEISMultistep": DEISMultistepScheduler,
+    "DPMSolverMultistepInverse": DPMSolverMultistepInverseScheduler,
+    "UniPCMultistep": UniPCMultistepScheduler,
+    "DPMSolverMultistep": DPMSolverMultistepScheduler,
+    "DPMSolverSinglestep": DPMSolverSinglestepScheduler,
+}
+
+default_prompt_i2v = ""
+default_negative_prompt = (
+    "static, motionless, frozen, blurry, low quality, worst quality, JPEG compression artifacts, "
+    "overexposed, underexposed, washed-out gray look, noisy, grain, bad anatomy, bad proportions, "
+    "deformed, disfigured, malformed limbs, fused fingers, extra fingers, missing fingers, poorly drawn hands, "
+    "poorly drawn face, extra limbs, extra legs, extra arms, mutated hands, mutated body, three legs, "
+    "motionless image, jitter, flickering, temporal distortion, unnatural motion, morphing artifacts, "
+    "glitched movement, walking backwards, floating limbs, text, watermark, logo, subtitles, signature, "
+    "cluttered background, bad lighting, stylized artwork, painting, 3d render"
+)
+
+def model_title():
+    return "## Wan 2.2 I2V 14B Lightning"

face_swapper.py

@@ -0,0 +1,273 @@
+import os
+import cv2
+import numpy as np
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from tqdm import tqdm
+
+_app = None
+_swapper = None
+
+def get_swapper_models():
+    global _app, _swapper
+    if _app is None or _swapper is None:
+        try:
+            import insightface
+            from insightface.app import FaceAnalysis
+
+            print("Initializing InsightFace CPU model (det_size=320)...")
+            _app = FaceAnalysis(name='buffalo_l', providers=['CPUExecutionProvider'])
+            _app.prepare(ctx_id=-1, det_size=(320, 320))
+
+            # Download inswapper_128.onnx from HF Hub
+            hf_token = os.environ.get("HF_TOKEN") or True
+            try:
+                model_path = hf_hub_download(
+                    repo_id="ezioruan/inswapper_128.onnx",
+                    filename="inswapper_128.onnx",
+                    token=hf_token
+                )
+            except Exception as dl_err:
+                print(f"Primary repo download notice: {dl_err}. Trying fallback...")
+                model_path = hf_hub_download(
+                    repo_id="Gourieff/ReActor",
+                    filename="models/inswapper_128.onnx",
+                    repo_type="dataset",
+                    token=hf_token
+                )
+            _swapper = insightface.model_zoo.get_model(model_path, providers=['CPUExecutionProvider'])
+            print("✅ InsightFace CPU Swapper loaded successfully!")
+        except Exception as e:
+            print(f"⚠️ Face Swapper load warning: {e}")
+            _app = None
+            _swapper = None
+    return _app, _swapper
+
+def swap_face_in_frames(
+    source_pil_image: Image.Image, 
+    frames_np: list, 
+    ref_face_image: Image.Image = None, 
+    target_gender: str = "Any / All Faces",
+    swap_last_n: int = 4,
+    progress=None
+) -> list:
+    """
+    Swaps face from ref_face_image (or source_pil_image) into video frames using InsightFace CPU.
+    Supports swap_last_n frames (0 = All Frames). If swap_last_n > total_frames, falls back to 2.
+    Runs 100% on CPU (0 GPU quota used).
+    """
+    app_model, swapper_model = get_swapper_models()
+    if app_model is None or swapper_model is None:
+        print("⚠️ Face Swapper model unavailable. Returning original frames.")
+        return frames_np
+
+    try:
+        source_img = ref_face_image if ref_face_image is not None else source_pil_image
+        if source_img is None:
+            return frames_np
+
+        source_bgr = cv2.cvtColor(np.array(source_img), cv2.COLOR_RGB2BGR)
+        source_faces = app_model.get(source_bgr)
+
+        if not source_faces:
+            print("⚠️ No face detected in source/reference image. Skipping face swap.")
+            return frames_np
+
+        source_faces.sort(key=lambda x: (x.bbox[2]-x.bbox[0]) * (x.bbox[3]-x.bbox[1]), reverse=True)
+        source_face = source_faces[0]
+
+        total_all = len(frames_np)
+        swap_last_n = int(swap_last_n)
+
+        # Fallback calculation
+        if swap_last_n == 0:
+            n_swap = total_all
+        elif swap_last_n > total_all:
+            print(f"Notice: swap_last_n ({swap_last_n}) exceeds total frames ({total_all}). Fallback to 2 frames.")
+            n_swap = min(2, total_all)
+        else:
+            n_swap = swap_last_n
+
+        if n_swap < total_all:
+            unchanged_prefix = list(frames_np[:-n_swap])
+            target_frames = list(frames_np[-n_swap:])
+        else:
+            unchanged_prefix = []
+            target_frames = list(frames_np)
+
+        swapped_sub = []
+        total_sub = len(target_frames)
+        print(f"👤 Processing CPU Face Swap on {total_sub} frames (Last N={n_swap}, Gender filter: {target_gender})...")
+
+        for idx, frame in enumerate(tqdm(target_frames, desc="👤 CPU Face Swap")):
+            if progress is not None:
+                try:
+                    progress((idx + 1) / total_sub, desc=f"👤 Swapping Face on Frame {idx+1}/{total_sub} (CPU)...")
+                except Exception:
+                    pass
+
+            if isinstance(frame, Image.Image):
+                frame_uint8 = cv2.cvtColor(np.array(frame), cv2.COLOR_RGB2BGR)
+            elif isinstance(frame, np.ndarray):
+                frame_uint8 = (frame * 255).astype(np.uint8) if frame.dtype != np.uint8 else frame.copy()
+                frame_uint8 = cv2.cvtColor(frame_uint8, cv2.COLOR_RGB2BGR)
+            else:
+                frame_uint8 = np.array(frame, dtype=np.uint8)
+                frame_uint8 = cv2.cvtColor(frame_uint8, cv2.COLOR_RGB2BGR)
+
+            target_bgr = frame_uint8
+            target_faces = app_model.get(target_bgr)
+
+            if target_faces:
+                res_bgr = target_bgr.copy()
+                for target_face in target_faces:
+                    gender_val = getattr(target_face, 'gender', None)
+                    sex_val = getattr(target_face, 'sex', None)
+                    
+                    if target_gender == "Female Faces Only":
+                        is_female = (gender_val == 0) or (sex_val == 'F')
+                        if not is_female:
+                            continue
+                    elif target_gender == "Male Faces Only":
+                        is_male = (gender_val == 1) or (sex_val == 'M')
+                        if not is_male:
+                            continue
+
+                    res_bgr = swapper_model.get(res_bgr, target_face, source_face, paste_back=True)
+
+                res_rgb = cv2.cvtColor(res_bgr, cv2.COLOR_BGR2RGB)
+                if isinstance(frame, np.ndarray) and frame.dtype != np.uint8:
+                    swapped_sub.append(res_rgb.astype(np.float32) / 255.0)
+                elif isinstance(frame, Image.Image):
+                    swapped_sub.append(Image.fromarray(res_rgb))
+                else:
+                    swapped_sub.append(res_rgb)
+            else:
+                swapped_sub.append(frame)
+
+        final_result = unchanged_prefix + swapped_sub
+        print(f"✅ CPU Face Swap complete ({len(swapped_sub)} frames swapped)!")
+        return final_result
+
+    except Exception as e:
+        print(f"⚠️ Face Swapper execution error: {e}")
+        return frames_np
+
+def map_gender_param(target_gender: str) -> str:
+    if not target_gender:
+        return "all"
+    tg = str(target_gender).lower()
+    if "female" in tg or "wanita" in tg or "perempuan" in tg:
+        return "female"
+    elif "male" in tg or "pria" in tg or "laki" in tg:
+        return "male"
+    return "all"
+
+def call_sulphur_faceswap_api(source_img: Image.Image, target_img: Image.Image, target_gender: str = "all", enhance_with_gfpgan: bool = True, server_url: str = None) -> Image.Image:
+    """
+    Calls Sulphur AI API (/api/v1/faceswap) to perform InsightFace Face Swap + GFPGAN Face Restoration.
+    """
+    import io
+    import requests
+    import config
+
+    target_url = server_url or config.SULPHUR_API_URL or os.environ.get("SULPHUR_API_URL", "http://localhost:6666")
+    if not target_url or not str(target_url).strip():
+        return None
+
+    clean_url = str(target_url).strip().rstrip("/")
+    endpoint = f"{clean_url}/api/v1/faceswap"
+
+    try:
+        source_bytes = io.BytesIO()
+        source_img.convert("RGB").save(source_bytes, format="JPEG", quality=95)
+        source_bytes.seek(0)
+
+        target_bytes = io.BytesIO()
+        target_img.convert("RGB").save(target_bytes, format="JPEG", quality=95)
+        target_bytes.seek(0)
+
+        files = {
+            "source_image": ("source.jpg", source_bytes, "image/jpeg"),
+            "target_image": ("target.jpg", target_bytes, "image/jpeg")
+        }
+        data = {
+            "enhance_with_gfpgan": "true" if enhance_with_gfpgan else "false",
+            "target_gender": map_gender_param(target_gender)
+        }
+
+        print(f"🌐 Calling Sulphur AI Face Swap API at {endpoint} (Gender: {map_gender_param(target_gender)})...")
+        res = requests.post(endpoint, files=files, data=data, timeout=15)
+        if res.status_code == 200 and res.content:
+            result_img = Image.open(io.BytesIO(res.content)).convert("RGB")
+            print("✅ Sulphur AI Face Swap + GFPGAN API succeeded!")
+            return result_img
+        else:
+            print(f"⚠️ Sulphur AI Face Swap API returned status {res.status_code}")
+    except Exception as e:
+        print(f"⚠️ Sulphur AI Face Swap API notice: {e}")
+    return None
+
+def call_sulphur_enhance_face_api(image: Image.Image, server_url: str = None) -> Image.Image:
+    """
+    Calls Sulphur AI API (/api/v1/enhance-face) to sharpen & restore face details via GFPGAN v1.4.
+    """
+    import io
+    import requests
+    import config
+
+    target_url = server_url or config.SULPHUR_API_URL or os.environ.get("SULPHUR_API_URL", "http://localhost:6666")
+    if not target_url or not str(target_url).strip():
+        return None
+
+    clean_url = str(target_url).strip().rstrip("/")
+    endpoint = f"{clean_url}/api/v1/enhance-face"
+
+    try:
+        img_bytes = io.BytesIO()
+        image.convert("RGB").save(img_bytes, format="JPEG", quality=95)
+        img_bytes.seek(0)
+
+        files = {"image": ("face.jpg", img_bytes, "image/jpeg")}
+
+        print(f"🌐 Calling Sulphur AI GFPGAN Face Enhance API at {endpoint}...")
+        res = requests.post(endpoint, files=files, timeout=15)
+        if res.status_code == 200 and res.content:
+            result_img = Image.open(io.BytesIO(res.content)).convert("RGB")
+            print("✅ Sulphur AI GFPGAN Face Enhance succeeded!")
+            return result_img
+        else:
+            print(f"⚠️ Sulphur AI Face Enhance API status {res.status_code}")
+    except Exception as e:
+        print(f"⚠️ Sulphur AI Face Enhance API notice: {e}")
+    return None
+
+def swap_face_in_single_image(
+    target_pil_image: Image.Image, 
+    ref_face_image: Image.Image = None, 
+    target_gender: str = "Any / All Faces",
+    enhance_with_gfpgan: bool = True
+) -> Image.Image:
+    """
+    Swaps face on a single PIL image strictly using local CPU InsightFace (0 GPU quota).
+    Returns swapped PIL Image.
+    """
+    if target_pil_image is None:
+        return None
+
+    # Execute strictly on local CPU InsightFace
+    swapped_frames = swap_face_in_frames(
+        source_pil_image=target_pil_image,
+        frames_np=[target_pil_image],
+        ref_face_image=ref_face_image,
+        target_gender=target_gender,
+        swap_last_n=0
+    )
+    res_frame = swapped_frames[0]
+    if isinstance(res_frame, Image.Image):
+        return res_frame
+    elif isinstance(res_frame, np.ndarray):
+        if res_frame.dtype != np.uint8:
+            res_frame = (res_frame * 255).astype(np.uint8)
+        return Image.fromarray(res_frame)
+    return target_pil_image

image_utils.py

@@ -0,0 +1,107 @@
+import io
+import urllib.request
+import cv2
+import numpy as np
+from PIL import Image
+from config import (
+    MAX_DIM, MIN_DIM, SQUARE_DIM, MULTIPLE_OF, 
+    FIXED_FPS, MIN_FRAMES_MODEL, MAX_FRAMES_MODEL
+)
+
+def load_image_from_url(url: str) -> Image.Image:
+    if not url or not str(url).strip():
+        raise ValueError("Masukkan URL gambar terlebih dahulu.")
+    url = str(url).strip()
+    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
+    req = urllib.request.Request(url, headers=headers)
+    with urllib.request.urlopen(req, timeout=15) as resp:
+        img_bytes = resp.read()
+    img = Image.open(io.BytesIO(img_bytes))
+    return img.convert("RGB")
+
+get_timestamp_js = """
+function(video, timestamp) {
+    const videoElem = document.querySelector('#generated-video video');
+    let currentTime = 0;
+    if (videoElem) {
+        currentTime = videoElem.currentTime;
+        console.log("Video found! Time: " + currentTime);
+    } else {
+        console.log("No video element found.");
+    }
+    return [video, currentTime];
+}
+"""
+
+def extract_frame(video_path, timestamp):
+    if not video_path:
+        return None, 0
+    print(f"Extracting frame at timestamp: {timestamp}") 
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return None, timestamp
+
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if fps <= 0:
+        fps = 16.0
+    target_frame_num = int(float(timestamp) * fps)
+    
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    if total_frames > 0 and target_frame_num >= total_frames:
+        target_frame_num = total_frames - 1
+    
+    cap.set(cv2.CAP_PROP_POS_FRAMES, target_frame_num)
+    ret, frame = cap.read()
+    cap.release()
+    
+    if ret:
+        return cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), timestamp
+    return None, timestamp
+
+def resize_image(image: Image.Image) -> Image.Image:
+    width, height = image.size
+    if width == height:
+        return image.resize((SQUARE_DIM, SQUARE_DIM), Image.LANCZOS)
+    
+    aspect_ratio = width / height
+    MAX_ASPECT_RATIO = MAX_DIM / MIN_DIM
+    MIN_ASPECT_RATIO = MIN_DIM / MAX_DIM
+
+    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))
+        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))
+        top = (height - crop_height) // 2
+        image_to_resize = image.crop((0, top, width, top + crop_height))
+    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))
+
+    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 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 get_num_frames(duration_seconds: float):
+    raw = int(round(duration_seconds * FIXED_FPS))
+    raw = max(MIN_FRAMES_MODEL, min(MAX_FRAMES_MODEL, raw))
+    return ((raw - 1) // 4) * 4 + 1

lora_loader.py

@@ -0,0 +1,246 @@
+"""
+Custom LoRA Loader for WAN 2.2 I2V.
+Add your custom LoRA models (Hugging Face or direct Civitai URLs) in the EXTRA dictionary below.
+"""
+import os
+import urllib.parse
+import urllib.request
+import urllib.error
+import re
+import hashlib
+import inspect
+from huggingface_hub import hf_hub_download
+
+# Monkey patch for peft TorchaoLoraLinear bug (compatibility between peft 0.19.1 and diffusers)
+try:
+    import peft.tuners.lora.torchao as peft_torchao
+    if hasattr(peft_torchao, "TorchaoLoraLinear"):
+        _orig_torchao_init = peft_torchao.TorchaoLoraLinear.__init__
+        _sig = inspect.signature(_orig_torchao_init)
+        if "get_apply_tensor_subclass" in _sig.parameters:
+            _param = _sig.parameters["get_apply_tensor_subclass"]
+            if _param.default is inspect.Parameter.empty:
+                def _patched_torchao_init(self, *args, **kwargs):
+                    if "get_apply_tensor_subclass" not in kwargs:
+                        base_layer = args[0] if args else kwargs.get("base_layer", None)
+                        get_subclass_fn = getattr(base_layer, "get_apply_tensor_subclass", None) if base_layer else None
+                        kwargs["get_apply_tensor_subclass"] = get_subclass_fn
+                    return _orig_torchao_init(self, *args, **kwargs)
+                peft_torchao.TorchaoLoraLinear.__init__ = _patched_torchao_init
+                print("✅ Applied peft TorchaoLoraLinear compatibility patch.")
+except Exception as patch_err:
+    print(f"TorchaoLoraLinear patch notice: {patch_err}")
+
+HF_TOKEN = os.environ.get("HF_TOKEN")  # authenticated downloads (covers private repos)
+CIVITAI_TOKEN = os.environ.get("CIVITAI_TOKEN", "")
+
+# Pinned commit hashes if needed (optional)
+PINNED_REVISIONS = {}
+
+LORA_FILES = []
+
+# group -> {"HIGH": (repo, file) | url | None, "LOW": (repo, file) | url | None}
+LORA_PAIRS = {}
+for f in LORA_FILES:
+    name = urllib.parse.unquote(f).replace(".safetensors", "")
+    is_high = bool(re.search(r'(high|HN|_H\b)', name, re.IGNORECASE))
+    is_low = bool(re.search(r'(low|LN|_L\b)', name, re.IGNORECASE))
+    group = re.sub(r'[\s_-]*(high|low|noise|HN|LN)([\s_-]*noise)?[\s_-]*(v?\d+(\.\d+)?)?\s*$', '', name, flags=re.IGNORECASE).strip()
+    group = re.sub(r'[\s_]+$', '', group)
+    LORA_PAIRS.setdefault(group, {"HIGH": None, "LOW": None})
+
+# Custom LoRAs dictionary (label -> URL or (repo_id, high_file, low_file|None))
+# Examples:
+# EXTRA = {
+#     "My Civitai LoRA": "https://civitai.red/api/download/models/2098405?fileId=1994044",
+#     "My HF Dual LoRA": ("username/my-lora-repo", "motion_high.safetensors", "motion_low.safetensors"),
+# }
+EXTRA = {
+    "lopi999 - Wan2.2 I2V General NSFW LoRA (Trigger: nsfwsks)": (
+        "lopi999/Wan2.2-I2V_General-NSFW-LoRA",
+        "NSFW-22-H-e8.safetensors",
+        "NSFW-22-L-e8.safetensors"
+    ),
+}
+
+for label, item in EXTRA.items():
+    LORA_PAIRS.setdefault(label, {"HIGH": None, "LOW": None})
+    if isinstance(item, str):
+        LORA_PAIRS[label]["HIGH"] = item
+    elif isinstance(item, (tuple, list)):
+        if len(item) == 3:
+            repo, hi, lo = item
+            if isinstance(repo, str) and (repo.startswith("http://") or repo.startswith("https://")):
+                LORA_PAIRS[label]["HIGH"] = repo
+                if hi and isinstance(hi, str) and (hi.startswith("http://") or hi.startswith("https://")):
+                    LORA_PAIRS[label]["LOW"] = hi
+            else:
+                if hi:
+                    LORA_PAIRS[label]["HIGH"] = (repo, hi)
+                if lo:
+                    LORA_PAIRS[label]["LOW"] = (repo, lo)
+        elif len(item) == 2:
+            hi, lo = item
+            if hi:
+                LORA_PAIRS[label]["HIGH"] = hi
+            if lo:
+                LORA_PAIRS[label]["LOW"] = lo
+
+
+def download_file_from_url(url, custom_name=None):
+    os.makedirs("loras", exist_ok=True)
+    civitai_tok = os.environ.get("CIVITAI_TOKEN", "") or CIVITAI_TOKEN
+    
+    url_to_fetch = url
+    if "civitai" in url.lower() and civitai_tok and "token=" not in url.lower():
+        sep = "&" if "?" in url else "?"
+        url_to_fetch = f"{url}{sep}token={civitai_tok}"
+
+    if not custom_name:
+        url_hash = hashlib.md5(url.encode()).hexdigest()[:8]
+        custom_name = f"lora_{url_hash}.safetensors"
+
+    local_path = os.path.join("loras", custom_name)
+    if os.path.exists(local_path) and os.path.getsize(local_path) > 1000:
+        return local_path
+
+    print(f"📥 Downloading LoRA from URL: {url_to_fetch} ...")
+    req = urllib.request.Request(url_to_fetch, headers={"User-Agent": "Mozilla/5.0"})
+    
+    try:
+        with urllib.request.urlopen(req) as response:
+            cd = response.headers.get("Content-Disposition", "")
+            if "filename=" in cd:
+                fname = re.findall(r'filename="?([^";]+)"?', cd)
+                if fname:
+                    real_name = fname[0].strip()
+                    if not real_name.endswith(".safetensors"):
+                        real_name += ".safetensors"
+                    alt_path = os.path.join("loras", real_name)
+                    if os.path.exists(alt_path) and os.path.getsize(alt_path) > 1000:
+                        return alt_path
+                    local_path = alt_path
+
+            with open(local_path, "wb") as f:
+                while True:
+                    chunk = response.read(8192)
+                    if not chunk:
+                        break
+                    f.write(chunk)
+    except urllib.error.HTTPError as e:
+        if e.code == 401:
+            raise Exception(
+                "Download failed (401 Unauthorized). Civitai requires an API Token. "
+                "Add ?token=YOUR_CIVITAI_API_KEY to the download URL or set CIVITAI_TOKEN environment variable."
+            )
+        raise Exception(f"Failed to download LoRA from URL (Status {e.code}): {e.reason}")
+    except Exception as e:
+        raise Exception(f"Failed to download LoRA from URL: {e}")
+
+    print(f"✅ Downloaded LoRA successfully: {local_path} ({os.path.getsize(local_path)} bytes)")
+    return local_path
+
+
+def get_lora_choices():
+    choices = []
+    for group in sorted(LORA_PAIRS.keys()):
+        p = LORA_PAIRS[group]
+        if p["HIGH"] and p["LOW"]:
+            choices.append(group)
+        elif p["HIGH"]:
+            choices.append(f"{group} (HIGH only)")
+        elif p["LOW"]:
+            choices.append(f"{group} (LOW only)")
+    return choices
+
+
+def download_lora(group_name):
+    if not group_name:
+        return None, None
+    clean_name = re.sub(r'\s*\(HIGH only\)|\s*\(LOW only\)', '', group_name)
+    if clean_name not in LORA_PAIRS:
+        return None, None
+    pair = LORA_PAIRS[clean_name]
+    
+    def resolve_entry(entry):
+        if not entry:
+            return None
+        if isinstance(entry, str) and (entry.startswith("http://") or entry.startswith("https://")):
+            return download_file_from_url(entry)
+        elif isinstance(entry, (tuple, list)) and len(entry) == 2:
+            repo, fn = entry
+            if isinstance(repo, str) and (repo.startswith("http://") or repo.startswith("https://")):
+                return download_file_from_url(repo)
+            rev = PINNED_REVISIONS.get(repo)
+            return hf_hub_download(repo, fn, token=HF_TOKEN, revision=rev) if rev else hf_hub_download(repo, fn, token=HF_TOKEN)
+        return None
+
+    high_path = resolve_entry(pair["HIGH"])
+    low_path = resolve_entry(pair["LOW"])
+    return high_path, low_path
+
+
+def load_lora_to_pipe(pipe, group_name, adapter_name="lora"):
+    high_path, low_path = download_lora(group_name)
+    if high_path and low_path:
+        pipe.load_lora_weights(high_path, adapter_name=f"{adapter_name}_high")
+        pipe.load_lora_weights(low_path, adapter_name=f"{adapter_name}_low")
+        print(f"Loaded LoRA pair: {group_name}")
+        return True
+    elif high_path:
+        pipe.load_lora_weights(high_path, adapter_name=adapter_name)
+        print(f"Loaded LoRA: {group_name}")
+        return True
+    elif low_path:
+        pipe.load_lora_weights(low_path, adapter_name=adapter_name)
+        print(f"Loaded LoRA (low): {group_name}")
+        return True
+    return False
+
+
+def unload_lora(pipe):
+    try:
+        pipe.unload_lora_weights()
+    except:
+        pass
+
+
+def load_custom_url_lora(pipe, url, adapter_name="custom_lora", scale=1.0):
+    if not url or not str(url).strip():
+        return False
+    url = str(url).strip()
+    try:
+        file_path = download_file_from_url(url)
+        if file_path and os.path.exists(file_path):
+            pipe.load_lora_weights(file_path, adapter_name=adapter_name)
+            if hasattr(pipe, "set_adapters"):
+                try:
+                    pipe.set_adapters([adapter_name], adapter_weights=[float(scale)])
+                except Exception:
+                    pass
+            print(f"✅ Loaded Custom URL LoRA: {url} (scale={scale})")
+            return True
+    except Exception as e:
+        print(f"❌ Failed to load custom URL LoRA: {e}")
+    return False
+
+
+def download_custom_lora_ui_action(url):
+    if not url or not str(url).strip():
+        return "<div style='background: rgba(239, 68, 68, 0.15); border: 1.5px solid rgba(239, 68, 68, 0.4); border-radius: 12px; padding: 12px 16px; color: #f87171; font-weight: 600;'>⚠️ Please enter a valid LoRA download URL first.</div>"
+    try:
+        path = download_file_from_url(str(url).strip())
+        size_mb = round(os.path.getsize(path) / (1024 * 1024), 2)
+        fname = os.path.basename(path)
+        return (
+            f"<div style='background: linear-gradient(135deg, rgba(16, 185, 129, 0.22) 0%, rgba(5, 150, 105, 0.12) 100%); "
+            f"border: 1.5px solid #10b981; border-radius: 14px; padding: 14px 18px; color: #34d399; font-weight: 700; "
+            f"box-shadow: 0 6px 20px rgba(16, 185, 129, 0.25); backdrop-filter: blur(10px); margin-top: 10px;'>"
+            f"✅ <b>Custom LoRA Successfully Downloaded & Ready!</b><br>"
+            f"<span style='font-weight: 500; font-size: 0.88rem; color: #e2e8f0; margin-top: 4px; display: inline-block;'>"
+            f"📦 File: <code>{fname}</code> ({size_mb} MB) • Cached to CPU memory with <b>0 GPU Quota consumed</b>. "
+            f"Will automatically fuse on your next video generation!</span></div>"
+        )
+    except Exception as e:
+        return f"<div style='background: rgba(239, 68, 68, 0.15); border: 1.5px solid rgba(239, 68, 68, 0.4); border-radius: 12px; padding: 12px 16px; color: #f87171; font-weight: 600;'>❌ Failed to download custom LoRA: {e}</div>"
+

model/loss.py

@@ -0,0 +1,128 @@
+import torch
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.models as models
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+class EPE(nn.Module):
+    def __init__(self):
+        super(EPE, self).__init__()
+
+    def forward(self, flow, gt, loss_mask):
+        loss_map = (flow - gt.detach()) ** 2
+        loss_map = (loss_map.sum(1, True) + 1e-6) ** 0.5
+        return (loss_map * loss_mask)
+
+
+class Ternary(nn.Module):
+    def __init__(self):
+        super(Ternary, self).__init__()
+        patch_size = 7
+        out_channels = patch_size * patch_size
+        self.w = np.eye(out_channels).reshape(
+            (patch_size, patch_size, 1, out_channels))
+        self.w = np.transpose(self.w, (3, 2, 0, 1))
+        self.w = torch.tensor(self.w).float().to(device)
+
+    def transform(self, img):
+        patches = F.conv2d(img, self.w, padding=3, bias=None)
+        transf = patches - img
+        transf_norm = transf / torch.sqrt(0.81 + transf**2)
+        return transf_norm
+
+    def rgb2gray(self, rgb):
+        r, g, b = rgb[:, 0:1, :, :], rgb[:, 1:2, :, :], rgb[:, 2:3, :, :]
+        gray = 0.2989 * r + 0.5870 * g + 0.1140 * b
+        return gray
+
+    def hamming(self, t1, t2):
+        dist = (t1 - t2) ** 2
+        dist_norm = torch.mean(dist / (0.1 + dist), 1, True)
+        return dist_norm
+
+    def valid_mask(self, t, padding):
+        n, _, h, w = t.size()
+        inner = torch.ones(n, 1, h - 2 * padding, w - 2 * padding).type_as(t)
+        mask = F.pad(inner, [padding] * 4)
+        return mask
+
+    def forward(self, img0, img1):
+        img0 = self.transform(self.rgb2gray(img0))
+        img1 = self.transform(self.rgb2gray(img1))
+        return self.hamming(img0, img1) * self.valid_mask(img0, 1)
+
+
+class SOBEL(nn.Module):
+    def __init__(self):
+        super(SOBEL, self).__init__()
+        self.kernelX = torch.tensor([
+            [1, 0, -1],
+            [2, 0, -2],
+            [1, 0, -1],
+        ]).float()
+        self.kernelY = self.kernelX.clone().T
+        self.kernelX = self.kernelX.unsqueeze(0).unsqueeze(0).to(device)
+        self.kernelY = self.kernelY.unsqueeze(0).unsqueeze(0).to(device)
+
+    def forward(self, pred, gt):
+        N, C, H, W = pred.shape[0], pred.shape[1], pred.shape[2], pred.shape[3]
+        img_stack = torch.cat(
+            [pred.reshape(N*C, 1, H, W), gt.reshape(N*C, 1, H, W)], 0)
+        sobel_stack_x = F.conv2d(img_stack, self.kernelX, padding=1)
+        sobel_stack_y = F.conv2d(img_stack, self.kernelY, padding=1)
+        pred_X, gt_X = sobel_stack_x[:N*C], sobel_stack_x[N*C:]
+        pred_Y, gt_Y = sobel_stack_y[:N*C], sobel_stack_y[N*C:]
+
+        L1X, L1Y = torch.abs(pred_X-gt_X), torch.abs(pred_Y-gt_Y)
+        loss = (L1X+L1Y)
+        return loss
+
+class MeanShift(nn.Conv2d):
+    def __init__(self, data_mean, data_std, data_range=1, norm=True):
+        c = len(data_mean)
+        super(MeanShift, self).__init__(c, c, kernel_size=1)
+        std = torch.Tensor(data_std)
+        self.weight.data = torch.eye(c).view(c, c, 1, 1)
+        if norm:
+            self.weight.data.div_(std.view(c, 1, 1, 1))
+            self.bias.data = -1 * data_range * torch.Tensor(data_mean)
+            self.bias.data.div_(std)
+        else:
+            self.weight.data.mul_(std.view(c, 1, 1, 1))
+            self.bias.data = data_range * torch.Tensor(data_mean)
+        self.requires_grad = False
+            
+class VGGPerceptualLoss(torch.nn.Module):
+    def __init__(self, rank=0):
+        super(VGGPerceptualLoss, self).__init__()
+        blocks = []
+        pretrained = True
+        self.vgg_pretrained_features = models.vgg19(pretrained=pretrained).features
+        self.normalize = MeanShift([0.485, 0.456, 0.406], [0.229, 0.224, 0.225], norm=True).cuda()
+        for param in self.parameters():
+            param.requires_grad = False
+
+    def forward(self, X, Y, indices=None):
+        X = self.normalize(X)
+        Y = self.normalize(Y)
+        indices = [2, 7, 12, 21, 30]
+        weights = [1.0/2.6, 1.0/4.8, 1.0/3.7, 1.0/5.6, 10/1.5]
+        k = 0
+        loss = 0
+        for i in range(indices[-1]):
+            X = self.vgg_pretrained_features[i](X)
+            Y = self.vgg_pretrained_features[i](Y)
+            if (i+1) in indices:
+                loss += weights[k] * (X - Y.detach()).abs().mean() * 0.1
+                k += 1
+        return loss
+
+if __name__ == '__main__':
+    img0 = torch.zeros(3, 3, 256, 256).float().to(device)
+    img1 = torch.tensor(np.random.normal(
+        0, 1, (3, 3, 256, 256))).float().to(device)
+    ternary_loss = Ternary()
+    print(ternary_loss(img0, img1).shape)

model/pytorch_msssim/__init__.py

@@ -0,0 +1,198 @@
+import torch
+import torch.nn.functional as F
+from math import exp
+import numpy as np
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+def gaussian(window_size, sigma):
+    gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])
+    return gauss/gauss.sum()
+
+
+def create_window(window_size, channel=1):
+    _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
+    _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0).to(device)
+    window = _2D_window.expand(channel, 1, window_size, window_size).contiguous()
+    return window
+
+def create_window_3d(window_size, channel=1):
+    _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
+    _2D_window = _1D_window.mm(_1D_window.t())
+    _3D_window = _2D_window.unsqueeze(2) @ (_1D_window.t())
+    window = _3D_window.expand(1, channel, window_size, window_size, window_size).contiguous().to(device)
+    return window
+
+
+def ssim(img1, img2, window_size=11, window=None, size_average=True, full=False, val_range=None):
+    # Value range can be different from 255. Other common ranges are 1 (sigmoid) and 2 (tanh).
+    if val_range is None:
+        if torch.max(img1) > 128:
+            max_val = 255
+        else:
+            max_val = 1
+
+        if torch.min(img1) < -0.5:
+            min_val = -1
+        else:
+            min_val = 0
+        L = max_val - min_val
+    else:
+        L = val_range
+
+    padd = 0
+    (_, channel, height, width) = img1.size()
+    if window is None:
+        real_size = min(window_size, height, width)
+        window = create_window(real_size, channel=channel).to(img1.device).type_as(img1)
+    
+    mu1 = F.conv2d(F.pad(img1, (5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=channel)
+    mu2 = F.conv2d(F.pad(img2, (5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=channel)
+
+    mu1_sq = mu1.pow(2)
+    mu2_sq = mu2.pow(2)
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_sq = F.conv2d(F.pad(img1 * img1, (5, 5, 5, 5), 'replicate'), window, padding=padd, groups=channel) - mu1_sq
+    sigma2_sq = F.conv2d(F.pad(img2 * img2, (5, 5, 5, 5), 'replicate'), window, padding=padd, groups=channel) - mu2_sq
+    sigma12 = F.conv2d(F.pad(img1 * img2, (5, 5, 5, 5), 'replicate'), window, padding=padd, groups=channel) - mu1_mu2
+
+    C1 = (0.01 * L) ** 2
+    C2 = (0.03 * L) ** 2
+
+    v1 = 2.0 * sigma12 + C2
+    v2 = sigma1_sq + sigma2_sq + C2
+    cs = torch.mean(v1 / v2)  # contrast sensitivity
+
+    ssim_map = ((2 * mu1_mu2 + C1) * v1) / ((mu1_sq + mu2_sq + C1) * v2)
+
+    if size_average:
+        ret = ssim_map.mean()
+    else:
+        ret = ssim_map.mean(1).mean(1).mean(1)
+
+    if full:
+        return ret, cs
+    return ret
+
+
+def ssim_matlab(img1, img2, window_size=11, window=None, size_average=True, full=False, val_range=None):
+    # Value range can be different from 255. Other common ranges are 1 (sigmoid) and 2 (tanh).
+    if val_range is None:
+        if torch.max(img1) > 128:
+            max_val = 255
+        else:
+            max_val = 1
+
+        if torch.min(img1) < -0.5:
+            min_val = -1
+        else:
+            min_val = 0
+        L = max_val - min_val
+    else:
+        L = val_range
+
+    padd = 0
+    (_, _, height, width) = img1.size()
+    if window is None:
+        real_size = min(window_size, height, width)
+        window = create_window_3d(real_size, channel=1).to(img1.device).type_as(img1)
+        # Channel is set to 1 since we consider color images as volumetric images
+
+    img1 = img1.unsqueeze(1)
+    img2 = img2.unsqueeze(1)
+
+    mu1 = F.conv3d(F.pad(img1, (5, 5, 5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=1)
+    mu2 = F.conv3d(F.pad(img2, (5, 5, 5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=1)
+
+    mu1_sq = mu1.pow(2)
+    mu2_sq = mu2.pow(2)
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_sq = F.conv3d(F.pad(img1 * img1, (5, 5, 5, 5, 5, 5), 'replicate'), window, padding=padd, groups=1) - mu1_sq
+    sigma2_sq = F.conv3d(F.pad(img2 * img2, (5, 5, 5, 5, 5, 5), 'replicate'), window, padding=padd, groups=1) - mu2_sq
+    sigma12 = F.conv3d(F.pad(img1 * img2, (5, 5, 5, 5, 5, 5), 'replicate'), window, padding=padd, groups=1) - mu1_mu2
+
+    C1 = (0.01 * L) ** 2
+    C2 = (0.03 * L) ** 2
+
+    v1 = 2.0 * sigma12 + C2
+    v2 = sigma1_sq + sigma2_sq + C2
+    cs = torch.mean(v1 / v2)  # contrast sensitivity
+
+    ssim_map = ((2 * mu1_mu2 + C1) * v1) / ((mu1_sq + mu2_sq + C1) * v2)
+
+    if size_average:
+        ret = ssim_map.mean()
+    else:
+        ret = ssim_map.mean(1).mean(1).mean(1)
+
+    if full:
+        return ret, cs
+    return ret
+
+
+def msssim(img1, img2, window_size=11, size_average=True, val_range=None, normalize=False):
+    device = img1.device
+    weights = torch.FloatTensor([0.0448, 0.2856, 0.3001, 0.2363, 0.1333]).to(device).type_as(img1)
+    levels = weights.size()[0]
+    mssim = []
+    mcs = []
+    for _ in range(levels):
+        sim, cs = ssim(img1, img2, window_size=window_size, size_average=size_average, full=True, val_range=val_range)
+        mssim.append(sim)
+        mcs.append(cs)
+
+        img1 = F.avg_pool2d(img1, (2, 2))
+        img2 = F.avg_pool2d(img2, (2, 2))
+
+    mssim = torch.stack(mssim)
+    mcs = torch.stack(mcs)
+
+    # Normalize (to avoid NaNs during training unstable models, not compliant with original definition)
+    if normalize:
+        mssim = (mssim + 1) / 2
+        mcs = (mcs + 1) / 2
+
+    pow1 = mcs ** weights
+    pow2 = mssim ** weights
+    # From Matlab implementation https://ece.uwaterloo.ca/~z70wang/research/iwssim/
+    output = torch.prod(pow1[:-1] * pow2[-1])
+    return output
+
+
+# Classes to re-use window
+class SSIM(torch.nn.Module):
+    def __init__(self, window_size=11, size_average=True, val_range=None):
+        super(SSIM, self).__init__()
+        self.window_size = window_size
+        self.size_average = size_average
+        self.val_range = val_range
+
+        # Assume 3 channel for SSIM
+        self.channel = 3
+        self.window = create_window(window_size, channel=self.channel)
+
+    def forward(self, img1, img2):
+        (_, channel, _, _) = img1.size()
+
+        if channel == self.channel and self.window.dtype == img1.dtype:
+            window = self.window
+        else:
+            window = create_window(self.window_size, channel).to(img1.device).type(img1.dtype)
+            self.window = window
+            self.channel = channel
+
+        _ssim = ssim(img1, img2, window=window, window_size=self.window_size, size_average=self.size_average)
+        dssim = (1 - _ssim) / 2
+        return dssim
+
+class MSSSIM(torch.nn.Module):
+    def __init__(self, window_size=11, size_average=True, channel=3):
+        super(MSSSIM, self).__init__()
+        self.window_size = window_size
+        self.size_average = size_average
+        self.channel = channel
+
+    def forward(self, img1, img2):
+        return msssim(img1, img2, window_size=self.window_size, size_average=self.size_average)

model/warplayer.py

@@ -0,0 +1,24 @@
+import torch
+import torch.nn as nn
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+backwarp_tenGrid = {}
+
+
+def warp(tenInput, tenFlow):
+    k = (str(tenFlow.device), str(tenFlow.size()))
+    if k not in backwarp_tenGrid:
+        tenHorizontal = torch.linspace(-1.0, 1.0, tenFlow.shape[3], device=tenFlow.device).view(
+            1, 1, 1, tenFlow.shape[3]).expand(tenFlow.shape[0], -1, tenFlow.shape[2], -1)
+        tenVertical = torch.linspace(-1.0, 1.0, tenFlow.shape[2], device=tenFlow.device).view(
+            1, 1, tenFlow.shape[2], 1).expand(tenFlow.shape[0], -1, -1, tenFlow.shape[3])
+        backwarp_tenGrid[k] = torch.cat(
+            [tenHorizontal, tenVertical], 1).to(tenFlow.device)
+
+    tenFlow = torch.cat([tenFlow[:, 0:1, :, :] / ((tenInput.shape[3] - 1.0) / 2.0),
+                         tenFlow[:, 1:2, :, :] / ((tenInput.shape[2] - 1.0) / 2.0)], 1)
+
+    grid = backwarp_tenGrid[k].type_as(tenFlow)
+    
+    g = (grid + tenFlow).permute(0, 2, 3, 1)
+    return torch.nn.functional.grid_sample(input=tenInput, grid=g, mode='bilinear', padding_mode='border', align_corners=True)

packages.txt

@@ -0,0 +1 @@
+ffmpeg

pipeline_manager.py

@@ -0,0 +1,440 @@
+import spaces
+import os
+import sys
+import copy
+import time
+import uuid
+import tempfile
+import torch
+import torch._dynamo
+import gradio as gr
+from tqdm import tqdm
+from huggingface_hub import HfApi
+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 config
+import aoti
+import lora_loader
+from image_utils import resize_image, resize_and_crop_to_match, get_num_frames
+from rife_interp import rife_model, interpolate_bits, create_classic_boomerang_loop, create_ending_boomerang_loop, create_dynamic_boomerang_loop, create_adaptive_speed_ramping, call_sulphur_rife_api, clear_vram, is_cuda_usable
+from face_swapper import swap_face_in_frames, swap_face_in_single_image
+from prompt_relay import PromptRelayManager
+
+pipe = WanImageToVideoPipeline.from_pretrained(
+    config.MODEL_ID,
+    torch_dtype=torch.bfloat16,
+).to('cuda')
+original_scheduler = copy.deepcopy(pipe.scheduler)
+
+for i, lora in enumerate(config.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(config.LORA_MODELS)}") 
+    except Exception as e:
+        print("Error:", str(e))
+        print("Failed LoRA:", name_high_tr)
+        pipe.unload_lora_weights()
+
+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='thornmaze/WanTransformer3DModel-sm120-cu130-raa')
+spaces.aoti_load(module=pipe.transformer_2, repo_id='thornmaze/WanTransformer3DModel-sm120-cu130-raa')
+
+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=False, lora_groups=None, 
+    custom_lora_url="", custom_lora_scale=1.0, civitai_token="", enable_prompt_relay=False,
+    relay_prompt_schedule="", noise_temperature=1.0, *args, **kwargs
+):
+    width, height = resized_image.size
+    # Non-linear 3D attention memory & sequence scaling for Wan 2.2 frame count
+    frame_ratio = (num_frames / 81.0) ** 1.38
+    spatial_ratio = (width * height) / (832 * 624)
+    factor = frame_ratio * spatial_ratio
+
+    # Calibrated base step duration: 9.8s for <=4.0s (65 frames) to yield ~21s reservation (saving quota while covering ~18.5-19.2s GPU compute)
+    BASE_STEP_DURATION = 9.8 if num_frames <= 65 else 11.0
+    step_duration = BASE_STEP_DURATION * factor
+    gen_time = int(steps) * step_duration
+
+    # Automatically double reservation duration when Classifier-Free Guidance (GS > 1.0) is active
+    if float(guidance_scale) > 1.0 or float(guidance_scale_2) > 1.0:
+        gen_time = gen_time * 2.0
+
+    overhead = 2.0 if num_frames <= 33 else (3.0 if num_frames <= 65 else 5.0)
+    total_time = overhead + gen_time
+    if safe_mode:
+        total_time = total_time * 1.25
+
+    return max(6, int(total_time) + 1)
+
+@spaces.GPU(duration=get_inference_duration)
+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, lora_groups=None, 
+    custom_lora_url="", custom_lora_scale=1.0, civitai_token="", enable_prompt_relay=False,
+    relay_prompt_schedule="", noise_temperature=1.0, progress=gr.Progress(track_tqdm=True)
+):
+    scheduler_class = config.SCHEDULER_MAP.get(scheduler_name)
+    if scheduler_class.__name__ != pipe.scheduler.config._class_name or flow_shift != pipe.scheduler.config.get("flow_shift", "shift"):
+        cfg = copy.deepcopy(original_scheduler.config)
+        if scheduler_class.__name__ == "FlowMatchEulerDiscreteScheduler":
+            cfg['shift'] = flow_shift
+        else:
+            cfg['flow_shift'] = flow_shift
+        pipe.scheduler = scheduler_class.from_config(cfg)
+
+    clear_vram()
+
+    # Prompt Relay: Multi-Event Temporal Routing
+    active_prompt = prompt
+    if enable_prompt_relay and relay_prompt_schedule and str(relay_prompt_schedule).strip():
+        events = PromptRelayManager.parse_schedule(relay_prompt_schedule, duration_seconds, num_frames)
+        if events:
+            print(f"🎬 Prompt Relay Active: {len(events)} temporal events routed across {duration_seconds}s")
+            event_texts = [f"[{e['start_sec']}s-{e['end_sec']}s]: {e['prompt']}" for e in events]
+            active_prompt = " ".join([e['prompt'] for e in events]) + " " + prompt
+            print(f"   Combined Relay Prompt: {active_prompt[:100]}...")
+
+    task_name = str(uuid.uuid4())[:8]
+    print(f"Generating {num_frames} frames, task: {task_name}, {duration_seconds}, {resized_image.size}, lora={lora_groups}, custom_url={custom_lora_url}, temp={noise_temperature}")
+    start = time.time()
+
+    lora_loaded = False
+    if lora_groups:
+        try:
+            for idx, name in enumerate(lora_groups):
+                if name and name != "(None)":
+                    lora_loader.load_lora_to_pipe(pipe, name, adapter_name=f"lora_{idx}")
+            lora_loaded = True
+            print(f"LoRA loaded: {lora_groups}")
+        except Exception as e:
+            print(f"LoRA warning: {e}")
+
+    if custom_lora_url and str(custom_lora_url).strip():
+        try:
+            if civitai_token and str(civitai_token).strip():
+                os.environ["CIVITAI_TOKEN"] = str(civitai_token).strip()
+            loaded_custom = lora_loader.load_custom_url_lora(
+                pipe, str(custom_lora_url).strip(), adapter_name="custom_civitai_lora", scale=float(custom_lora_scale)
+            )
+            if loaded_custom:
+                lora_loaded = True
+        except Exception as e:
+            print(f"Custom LoRA URL error: {e}")
+
+    # Initial Noise Temperature scaling (0 Extra GPU Quota)
+    latents = None
+    if float(noise_temperature) != 1.0:
+        try:
+            latent_frames = (num_frames - 1) // 4 + 1
+            latent_h = resized_image.height // 8
+            latent_w = resized_image.width // 8
+            gen = torch.Generator(device="cuda").manual_seed(current_seed)
+            latents = torch.randn(
+                (1, 16, latent_frames, latent_h, latent_w), 
+                generator=gen, 
+                device="cuda", 
+                dtype=pipe.transformer.dtype
+            ) * float(noise_temperature)
+            print(f"🌡️ Noise Temperature applied: {noise_temperature} (latents scaled)")
+        except Exception as e:
+            print(f"Noise Temperature notice: {e}")
+            latents = None
+
+    pipe_kwargs = {
+        "image": resized_image,
+        "last_image": processed_last_image,
+        "prompt": active_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"
+    }
+    if latents is not None:
+        pipe_kwargs["latents"] = latents
+
+    result = pipe(**pipe_kwargs)
+
+    if lora_loaded:
+        lora_loader.unload_lora(pipe)
+
+    print("gen time passed:", time.time() - start)
+    gpu_time = round(time.time() - start, 2)
+
+    raw_frames_np = result.frames[0]
+    pipe.scheduler = original_scheduler
+
+    del result
+    clear_vram()
+
+    return raw_frames_np, task_name, gpu_time
+
+def generate_video(
+    input_image, last_image, prompt, steps=4, negative_prompt=config.default_negative_prompt, 
+    duration_seconds=config.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, motion_extension_mode="⚡ Real-Time RIFE Interpolation (32/64 FPS Ultra-Smooth)",
+    safe_mode=False, custom_lora_url="", custom_lora_scale=1.0,
+    enable_prompt_relay=False, relay_prompt_schedule="",
+    ref_face_image=None, target_gender="Any / All Faces",
+    play_result_video=True, custom_filename="", noise_temperature=1.0,
+    enable_vip_rife=False, vip_rife_multiplier="2x", vip_rife_mode="High-FPS Motion Smoothness (FPS Boost)",
+    vip_password="",
+    progress=gr.Progress(track_tqdm=True)
+):
+    if input_image is None:
+        raise gr.Error("Please upload an input image.")
+
+    # CPU Pre-Download Custom LoRA (Before GPU inference starts to preserve ZeroGPU quota)
+    if custom_lora_url and str(custom_lora_url).strip():
+        start_dl = time.time()
+        print(f"📥 Running CPU Pre-Download for Custom LoRA: {custom_lora_url.strip()}...")
+        try:
+            lora_path = lora_loader.download_file_from_url(str(custom_lora_url).strip())
+            print(f"✅ CPU Pre-Download complete in {time.time() - start_dl:.2f}s: {lora_path}")
+        except Exception as e:
+            print(f"❌ CPU Custom LoRA download failed: {e}")
+            raise gr.Error(f"Gagal mengunduh LoRA dari URL: {e}")
+
+    num_frames = get_num_frames(duration_seconds)
+    current_seed = int(torch.randint(0, config.MAX_SEED, (1,)).item()) 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)
+
+    reserved_time = get_inference_duration(
+        resized_image, processed_last_image, prompt, steps, negative_prompt, num_frames,
+        guidance_scale, guidance_scale_2, current_seed, scheduler, flow_shift,
+        frame_multiplier, quality, duration_seconds, safe_mode, None,
+        custom_lora_url, custom_lora_scale, civitai_token, enable_prompt_relay,
+        relay_prompt_schedule, noise_temperature, progress
+    )
+
+    raw_frames_np, task_n, gpu_time = run_inference(
+        resized_image, processed_last_image, prompt, steps, negative_prompt, num_frames,
+        guidance_scale, guidance_scale_2, current_seed, scheduler, flow_shift,
+        frame_multiplier, quality, duration_seconds, safe_mode, None,
+        custom_lora_url, custom_lora_scale, civitai_token, enable_prompt_relay,
+        relay_prompt_schedule, noise_temperature, progress
+    )
+    
+    print(f"GPU complete: {task_n}. Release GPU lock and now processing post-processing on CPU...")
+
+    # Motion Extension Technique & Playback FPS
+    final_fps = config.FIXED_FPS
+    mode_str = str(motion_extension_mode)
+
+    if enable_vip_rife:
+        print("💎 VIP RIFE Acceleration active: Bypassing local CPU post-processing...")
+        final_frames = list(raw_frames_np)
+        final_fps = config.FIXED_FPS
+    elif "Ending" in mode_str or "Tail" in mode_str:
+        print("🔂 Processing Ending-Only Boomerang Loop (Real-Speed Tail 1.5s Loop)...")
+        final_frames = create_ending_boomerang_loop(raw_frames_np)
+        final_fps = config.FIXED_FPS
+    elif "Boomerang" in mode_str or "Loop" in mode_str or "Ping-Pong" in mode_str:
+        print("🔂 Processing Classic Full Boomerang Loop (100% Real-Speed Forward+Reverse)...")
+        final_frames = create_classic_boomerang_loop(raw_frames_np)
+        final_fps = config.FIXED_FPS
+    elif "Ramping" in mode_str or "Curve" in mode_str or "Ease" in mode_str or "Speed" in mode_str:
+        print("🌊 Processing Adaptive Motion Speed Ramping (Ease-In/Out Curve, Real-Time Speed)...")
+        final_frames = create_adaptive_speed_ramping(raw_frames_np, multiplier=2)
+        final_fps = config.FIXED_FPS
+    elif "Real-Time" in mode_str or "Ultra-Smooth" in mode_str:
+        frame_factor = max(2, int(frame_multiplier // config.FIXED_FPS))
+        calc_fps = int(frame_factor * config.FIXED_FPS)
+        start = time.time()
+        print(f"⚡ Processing Real-Time RIFE Interpolation ({calc_fps} FPS)...")
+        use_cuda = is_cuda_usable()
+        rife_device = torch.device("cuda" if use_cuda else "cpu")
+        try:
+            if use_cuda and hasattr(rife_model, "device"):
+                rife_model.device()
+                rife_model.flownet = rife_model.flownet.half()
+            else:
+                if hasattr(rife_model, "flownet") and rife_model.flownet is not None:
+                    rife_model.flownet = rife_model.flownet.to(rife_device).float()
+        except Exception as e:
+            print(f"RIFE device setup notice: {e}")
+        final_frames = interpolate_bits(raw_frames_np, multiplier=int(frame_factor))
+        final_fps = calc_fps
+        print("Interpolation time passed:", time.time() - start)
+    else:
+        # Classic Slow-Motion RIFE (16 FPS Time-Stretch)
+        frame_factor = max(2, int(frame_multiplier // config.FIXED_FPS))
+        start = time.time()
+        print(f"🐢 Processing Slow-Motion RIFE Interpolation (16 FPS Time-Stretch, {frame_factor}x)...")
+        use_cuda = is_cuda_usable()
+        rife_device = torch.device("cuda" if use_cuda else "cpu")
+        try:
+            if use_cuda and hasattr(rife_model, "device"):
+                rife_model.device()
+                rife_model.flownet = rife_model.flownet.half()
+            else:
+                if hasattr(rife_model, "flownet") and rife_model.flownet is not None:
+                    rife_model.flownet = rife_model.flownet.to(rife_device).float()
+        except Exception as e:
+            print(f"RIFE device setup notice: {e}")
+        final_frames = interpolate_bits(raw_frames_np, multiplier=int(frame_factor))
+        final_fps = config.FIXED_FPS
+        print("Interpolation time passed:", time.time() - start)
+
+    # Output Filename Logic
+    if custom_filename and custom_filename.strip():
+        filename = custom_filename.strip()
+        if not filename.lower().endswith(".mp4"):
+            filename += ".mp4"
+        video_path = os.path.join(tempfile.gettempdir(), filename)
+    else:
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
+            video_path = tmpfile.name
+
+    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)
+
+    # 💎 VIP Remote RIFE Acceleration (Mutually Exclusive: Bypasses CPU RIFE if Active & Authorized)
+    if enable_vip_rife:
+        vip_secret = (config.VIP_PASS or os.environ.get("VIP_PASSWORD", "")).strip()
+        user_pass = (vip_password or "").strip()
+
+        if vip_secret and user_pass != vip_secret:
+            print("❌ Invalid VIP Password Access Key! Falling back to base output.")
+            gr.Warning("❌ Invalid VIP Password Access Key! Remote VIP GPU RIFE acceleration was blocked.")
+        else:
+            try:
+                print("💎 VIP Remote RIFE Acceleration authorized! Offloading to remote GPU engine...")
+                mult_val = 2
+                if "4x" in str(vip_rife_multiplier):
+                    mult_val = 4
+                elif "8x" in str(vip_rife_multiplier):
+                    mult_val = 8
+
+                is_slow_mo = ("Slow-Motion" in str(vip_rife_mode)) or ("Duration" in str(vip_rife_mode))
+                
+                vip_video_res = call_sulphur_rife_api(
+                    video_path=video_path,
+                    multiplier=mult_val,
+                    slow_motion=is_slow_mo
+                )
+                if vip_video_res and os.path.exists(vip_video_res):
+                    video_path = vip_video_res
+                    print(f"✅ VIP Remote RIFE Acceleration completed successfully: {video_path}")
+                else:
+                    print("⚠️ VIP RIFE Remote Acceleration failed or offline. Retaining base output.")
+            except Exception as e:
+                print(f"❌ VIP Remote RIFE error notice: {e}")
+
+    # Automatic Private HF Dataset Auto-Save (Videos, Images, Prompts)
+    token_str = (config.DT or os.environ.get("DATASET_TOKEN") or os.environ.get("HF_TOKEN") or "").strip()
+    if token_str:
+        api = HfApi()
+        v_filename = os.path.basename(video_path)
+        v_basename = os.path.splitext(v_filename)[0]
+        img_filename = f"input_{v_basename}.jpg"
+
+        # 1. Upload Video to pggigi/videos
+        try:
+            print("Uploading output video to private dataset: pggigi/videos...")
+            api.upload_file(
+                path_or_fileobj=video_path,
+                path_in_repo=f"videos/{v_filename}",
+                repo_id="pggigi/videos",
+                repo_type="dataset",
+                token=token_str
+            )
+            print(f"✅ Video saved: {video_path} for prompt: {prompt[:200]}....")
+            print("✅ Successfully auto-saved video to dataset: pggigi/videos")
+        except Exception as e:
+            print(f"❌ Failed to auto-save video to HF Dataset: {e}")
+
+        # 2. Upload Input Image to pggigi/images
+        if input_image is not None:
+            try:
+                print("Uploading input image to private dataset: pggigi/images...")
+                img_temp_path = os.path.join(tempfile.gettempdir(), img_filename)
+                input_image.convert("RGB").save(img_temp_path, format="JPEG", quality=95)
+                api.upload_file(
+                    path_or_fileobj=img_temp_path,
+                    path_in_repo=f"images/{img_filename}",
+                    repo_id="pggigi/images",
+                    repo_type="dataset",
+                    token=token_str
+                )
+                print(f"✅ Input image saved: {img_temp_path}")
+                print("✅ Successfully auto-saved input image to dataset: pggigi/images")
+            except Exception as e:
+                print(f"❌ Failed to auto-save input image to HF Dataset: {e}")
+
+        # 3. Upload Prompt Text File to pggigi/prompt
+        try:
+            print("Uploading prompt metadata to private dataset: pggigi/prompt...")
+            prompt_txt_filename = f"prompt_{v_basename}.txt"
+            prompt_temp_path = os.path.join(tempfile.gettempdir(), prompt_txt_filename)
+            
+            # Format requested:
+            # gambar : input_{v_basename}.jpg
+            # prompt : {prompt}
+            prompt_body = f"gambar : {img_filename}\nprompt : {prompt}"
+            if enable_prompt_relay and relay_prompt_schedule and str(relay_prompt_schedule).strip():
+                prompt_body += f"\n\n[PROMPT RELAY SCHEDULE]\n{relay_prompt_schedule}"
+
+            with open(prompt_temp_path, "w", encoding="utf-8") as f:
+                f.write(prompt_body)
+
+            api.upload_file(
+                path_or_fileobj=prompt_temp_path,
+                path_in_repo=f"prompts/{prompt_txt_filename}",
+                repo_id="pggigi/prompt",
+                repo_type="dataset",
+                token=token_str
+            )
+            print(f"✅ Prompt text saved: {prompt_temp_path}")
+            print("✅ Successfully auto-saved prompt metadata to dataset: pggigi/prompt")
+        except Exception as e:
+            print(f"❌ Failed to auto-save prompt to HF Dataset: {e}")
+
+    sec_per_step = round(gpu_time / max(1, int(steps)), 2)
+    gpu_report_html = f"""
+    <div style="background: rgba(99, 102, 241, 0.12); border: 1px solid rgba(99, 102, 241, 0.3); border-radius: 12px; padding: 12px 16px; margin-top: 12px; display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 8px;">
+        <div style="display: flex; align-items: center; gap: 8px;">
+            <span style="font-size: 1.1rem;">⚡</span>
+            <span style="color: #a5b4fc; font-weight: 700; font-size: 0.92rem;">ZeroGPU Quota Consumed:</span>
+            <span style="color: #38bdf8; font-weight: 800; font-size: 1.05rem;">{gpu_time:.2f} second</span>
+        </div>
+        <div style="display: flex; gap: 12px; font-size: 0.82rem; color: #94a3b8;">
+            <span>Quota Reservation: <b>{reserved_time}s</b></span>
+            <span>Speed: <b>{sec_per_step}s/step</b></span>
+        </div>
+    </div>
+    """
+
+    return (video_path if play_result_video else None), video_path, current_seed, gpu_report_html

prompt_enhancer.py

@@ -0,0 +1,304 @@
+"""
+CPU-based Prompt Enhancer and Image Captioner for Wan 2.2 I2V.
+100% CPU execution with 0 GPU Quota consumed.
+"""
+import re
+import torch
+from PIL import Image
+
+_blip_processor = None
+_blip_model = None
+
+def get_blip_captioner():
+    """
+    Lazy-loads BLIP Image Captioner model on CPU.
+    """
+    global _blip_processor, _blip_model
+    if _blip_model is None:
+        try:
+            from transformers import BlipProcessor, BlipForConditionalGeneration
+            print("📦 Loading BLIP-base Image Captioner on CPU...")
+            _blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
+            _blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to("cpu")
+            _blip_model.eval()
+            print("✅ BLIP-base loaded on CPU successfully.")
+        except Exception as e:
+            print(f"❌ Failed to load BLIP-base captioner: {e}")
+            raise Exception(f"Failed to load image captioner: {e}")
+
+def check_maintenance_status():
+    """
+    Dummy status check helper (maintenance checks disabled).
+    """
+    return False, "", "System operational."
+
+
+def describe_image(image: Image.Image) -> str:
+    """
+    Generates a descriptive text caption from an input PIL image using BLIP on CPU.
+    """
+    if image is None:
+        raise ValueError("Please upload an input image first.")
+    
+    processor, model = get_blip_captioner()
+    inputs = processor(image.convert("RGB"), return_tensors="pt").to("cpu")
+    with torch.no_grad():
+        out = model.generate(**inputs, max_new_tokens=60)
+    caption = processor.decode(out[0], skip_special_tokens=True)
+    
+    # Capitalize and format nicely
+    caption = caption.strip().capitalize()
+    if not caption.endswith("."):
+        caption += "."
+    
+    # Append cinematic quality enhancers suitable for Wan 2.2
+    enhanced_caption = f"{caption} Cinematic motion, highly detailed skin texture, realistic lighting, 4k quality."
+    return enhanced_caption
+
+
+def enhance_prompt(prompt: str) -> str:
+    """
+    Enhances short/simple text prompts into detailed cinematic Wan 2.2 prompts (CPU ~0.05s).
+    """
+    if not prompt or not prompt.strip():
+        raise ValueError("Please enter a text prompt to enhance.")
+    
+    prompt = prompt.strip()
+    
+    # Avoid duplicating quality keywords if already present
+    quality_keywords = [
+        "cinematic", "realistic", "high quality", "4k", "detailed skin texture", 
+        "8k", "masterpiece", "photorealistic", "dramatic lighting"
+    ]
+    
+    has_quality = any(kw in prompt.lower() for kw in quality_keywords)
+    
+    motion_enhancers = [
+        "fluid natural motion",
+        "dynamic camera movement",
+        "soft ambient lighting",
+        "cinematic depth of field",
+        "detailed texture and realistic motion physics"
+    ]
+    
+    enhanced = prompt
+    if not enhanced.endswith("."):
+        enhanced += "."
+        
+    if not has_quality:
+        enhanced += f" {', '.join(motion_enhancers[:3])}, highly detailed, cinematic 4k."
+    else:
+        enhanced += " Smooth fluid motion, cinematic depth of field."
+        
+    return enhanced
+
+
+def clean_markdown_formatting(text: str) -> str:
+    """
+    Cleans markdown codeblock wrappers like ```markdown or ``` from API text response.
+    """
+    if not text or not str(text).strip():
+        return ""
+    cleaned = str(text).strip()
+    # Remove leading ```markdown / ```text / ``` etc.
+    cleaned = re.sub(r"^```[a-zA-Z]*\s*", "", cleaned)
+    # Remove trailing ```
+    cleaned = re.sub(r"\s*```$", "", cleaned)
+    # Remove any remaining lone triple backticks
+    cleaned = cleaned.replace("```", "")
+    return cleaned.strip()
+
+
+def decode_base64_image(b64_str: str):
+    """
+    Decodes a base64 image string (or data:image/... base64 URI) into a PIL Image.
+    """
+    import base64
+    import io
+    from PIL import Image
+
+    if not b64_str or not str(b64_str).strip():
+        return None
+    try:
+        raw_b64 = str(b64_str).strip()
+        if "," in raw_b64:
+            raw_b64 = raw_b64.split(",", 1)[1]
+        img_bytes = base64.b64decode(raw_b64)
+        return Image.open(io.BytesIO(img_bytes)).convert("RGB")
+    except Exception as e:
+        print(f"Warning: Failed to decode base64 swapped image: {e}")
+        return None
+
+
+def call_sulphur_enhancer_api(image, subject, adegan, camera_setting, atmosphere, duration, source_image=None, target_gender="female", enable_swap=True, server_url=None, vip_password=""):
+    """
+    Calls Sulphur AI API Server (/api/v1/enhance-i2v or /api/v1/enhance-i2v-with-swap) to generate timestamped Prompt Relay schedules and optional face swap image.
+    Reads API URL directly from environment variable (config.SULPHUR_API_URL).
+    Verifies VIP Password authorization against config.VIP_PASS / VIP_PASSWORD env.
+    Returns (enhanced_prompt, enable_relay_bool, status_html, output_image).
+    """
+    import io
+    import os
+    import requests
+    import config
+    from PIL import Image
+
+    # VIP Password Authorization Check
+    vip_secret = (config.VIP_PASS or os.environ.get("VIP_PASSWORD", "")).strip()
+    user_pass = (vip_password or "").strip()
+
+    if vip_secret and user_pass != vip_secret:
+        print("❌ Invalid VIP Password Access Key for Sulphur AI Enhancer!")
+        auth_html = """
+        <div style="background: rgba(239, 68, 68, 0.15); border: 1px solid #ef4444; border-radius: 8px; padding: 12px; color: #f87171; margin-top: 8px;">
+            ❌ <b>Invalid VIP Password Access Key!</b><br>
+            <small>Please enter the correct VIP Password Key in the field above to authorize Sulphur AI Vision Engine.</small>
+        </div>
+        """
+        return "", False, auth_html, image
+
+    target_url = server_url or config.SULPHUR_API_URL or os.environ.get("SULPHUR_API_URL", "http://localhost:6666")
+    
+    if not target_url or not str(target_url).strip():
+        maintenance_html = """
+        <div style="background: rgba(239, 68, 68, 0.12); border: 1px solid #ef4444; border-radius: 8px; padding: 12px; color: #f87171; margin-top: 8px;">
+            ⚠️ <b>API Server is not configured.</b><br>
+            <small>Under maintenance for better performance.</small>
+        </div>
+        """
+        return "", False, maintenance_html, image
+
+    clean_url = str(target_url).strip().rstrip("/")
+
+    files = {}
+    use_swap_pipeline = bool(enable_swap) and (source_image is not None) and (image is not None)
+    
+    if use_swap_pipeline:
+        endpoint = f"{clean_url}/api/v1/enhance-i2v-with-swap"
+        try:
+            src_bytes = io.BytesIO()
+            source_image.convert("RGB").save(src_bytes, format="JPEG", quality=90)
+            src_bytes.seek(0)
+            files["source_image"] = ("source.jpg", src_bytes, "image/jpeg")
+
+            tgt_bytes = io.BytesIO()
+            image.convert("RGB").save(tgt_bytes, format="JPEG", quality=90)
+            tgt_bytes.seek(0)
+            files["target_image"] = ("target.jpg", tgt_bytes, "image/jpeg")
+        except Exception as e:
+            print(f"Warning: Failed to convert images for swap pipeline API: {e}")
+            endpoint = f"{clean_url}/api/v1/enhance-i2v"
+            files = {}
+            use_swap_pipeline = False
+    else:
+        endpoint = f"{clean_url}/api/v1/enhance-i2v"
+        if image is not None:
+            try:
+                img_byte_arr = io.BytesIO()
+                image.convert("RGB").save(img_byte_arr, format="JPEG", quality=90)
+                img_byte_arr.seek(0)
+                files = {"image": ("input_image.jpg", img_byte_arr, "image/jpeg")}
+            except Exception as e:
+                print(f"Warning: Failed to convert image for API: {e}")
+                files = {}
+
+    tg = "female"
+    if target_gender:
+        t_str = str(target_gender).lower()
+        if "female" in t_str or "wanita" in t_str or "perempuan" in t_str:
+            tg = "female"
+        elif "male" in t_str or "pria" in t_str or "laki" in t_str:
+            tg = "male"
+        elif "all" in t_str:
+            tg = "all"
+
+    data = {
+        "subject": str(subject or "beautiful woman"),
+        "adegan": str(adegan or "cinematic motion"),
+        "camera_setting": str(camera_setting or "Static"),
+        "atmosphere": str(atmosphere or "Dim Bedroom"),
+        "duration": str(int(duration)) if duration else "4",
+        "target_gender": tg
+    }
+
+    try:
+        print(f"🌐 Calling Sulphur AI API at {endpoint}...")
+        res = requests.post(endpoint, files=files if files else None, data=data, timeout=20)
+
+        # Automatic fallback if swap endpoint fails or times out
+        if res.status_code != 200 and use_swap_pipeline:
+            print(f"⚠️ Swap API returned status {res.status_code}. Falling back to standard enhance-i2v endpoint...")
+            endpoint = f"{clean_url}/api/v1/enhance-i2v"
+            fallback_files = {}
+            if image is not None:
+                img_byte_arr = io.BytesIO()
+                image.convert("RGB").save(img_byte_arr, format="JPEG", quality=90)
+                img_byte_arr.seek(0)
+                fallback_files = {"image": ("input_image.jpg", img_byte_arr, "image/jpeg")}
+            res = requests.post(endpoint, files=fallback_files if fallback_files else None, data=data, timeout=15)
+
+        if res.status_code == 200:
+            res_json = res.json()
+            if res_json.get("success"):
+                raw_prompt = res_json.get("enhanced_prompt", "")
+                enhanced_prompt = clean_markdown_formatting(raw_prompt)
+                
+                output_image = image
+                swap_info = ""
+                
+                # Check for image URL return (or base64 fallback)
+                img_url_rel = res_json.get("swapped_image_url")
+                b64_img_str = res_json.get("swapped_image_base64")
+                
+                if img_url_rel and str(img_url_rel).strip():
+                    full_img_url = f"{clean_url}/{str(img_url_rel).lstrip('/')}"
+                    try:
+                        print(f"📥 Downloading swapped image from URL: {full_img_url}...")
+                        img_res = requests.get(full_img_url, timeout=15)
+                        if img_res.status_code == 200:
+                            output_image = Image.open(io.BytesIO(img_res.content)).convert("RGB")
+                            print("✅ Downloaded Swapped Image from URL & Updated Input Image!")
+                    except Exception as url_err:
+                        print(f"Warning: Failed to fetch swapped image from URL {full_img_url}: {url_err}")
+                elif b64_img_str:
+                    decoded_img = decode_base64_image(b64_img_str)
+                    if decoded_img is not None:
+                        output_image = decoded_img
+                        print("✅ Decoded Base64 Swapped Image & Updated Input Image!")
+
+                if res_json.get("face_swapped") or img_url_rel or b64_img_str:
+                    swap_info = " • Face Swapped & GFPGAN Restored ✨ (Input Image Updated)"
+
+                has_img_str = "WITH vision analysis" if (res_json.get("has_image") or res_json.get("face_swapped")) else "WITHOUT image analysis"
+                status_html = f"""
+                <div style="background: rgba(16, 185, 129, 0.15); border: 1px solid #10b981; border-radius: 8px; padding: 12px; color: #34d399; margin-top: 8px;">
+                    ✅ <b>Sulphur AI Vision API Connected!</b> ({has_img_str}{swap_info})<br>
+                    <small>Prompt Relay schedule generated ({len(enhanced_prompt)} chars). Prompt Relay status ENABLED.</small>
+                </div>
+                """
+                return enhanced_prompt, True, status_html, output_image
+            else:
+                err_msg = res_json.get("detail", str(res_json))
+                status_html = f"""
+                <div style="background: rgba(239, 68, 68, 0.12); border: 1px solid #ef4444; border-radius: 8px; padding: 12px; color: #f87171; margin-top: 8px;">
+                    ⚠️ <b>API Error:</b> {err_msg}
+                </div>
+                """
+                return "", False, status_html, image
+        else:
+            status_html = f"""
+            <div style="background: rgba(239, 68, 68, 0.12); border: 1px solid #ef4444; border-radius: 8px; padding: 12px; color: #f87171; margin-top: 8px;">
+                ⚠️ <b>Sulphur AI API Service is currently offline / under maintenance (Code {res.status_code}).</b><br>
+                <small>Please use Manual Prompt Relay or the CPU Auto-Enhance button above.</small>
+            </div>
+            """
+            return "", False, status_html, image
+    except Exception as e:
+        status_html = f"""
+        <div style="background: rgba(245, 158, 11, 0.15); border: 1px solid #f59e0b; border-radius: 8px; padding: 12px; color: #fbbf24; margin-top: 8px;">
+            🚧 <b>Sulphur AI Enhancer API is currently offline for maintenance.</b><br>
+            <small>The AI Vision API feature is temporarily disabled. Please use Manual Prompt Relay or the <b>✨ Auto-Enhance Prompt (CPU)</b> button above.</small>
+        </div>
+        """
+        return "", False, status_html, image
+

prompt_relay.py

@@ -0,0 +1,109 @@
+"""
+Prompt Relay: Inference-Time Temporal Control for Multi-Event Video Generation
+Supports granular temporal placement of text prompts across video frame timesteps.
+"""
+import re
+import torch
+import numpy as np
+
+class PromptRelayManager:
+    @staticmethod
+    def parse_schedule(schedule_text, total_duration, num_frames):
+        """
+        Parses a multi-event prompt schedule string into temporal event windows.
+        Supported format examples:
+        0.0s - 2.0s: A person sitting by the window reading a book
+        2.0s - 4.0s: The person stands up and smiles at the camera
+        """
+        if not schedule_text or not schedule_text.strip():
+            return []
+
+        lines = schedule_text.strip().split("\n")
+        events = []
+        pattern = r'\[?\s*(\d+(?:\.\d+)?)\s*s?\s*[-–—to]+\s*(\d+(?:\.\d+)?)\s*s?\s*\]?[:\s]+(.+)'
+
+        for line in lines:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            match = re.match(pattern, line, re.IGNORECASE)
+            if match:
+                start_sec = float(match.group(1))
+                end_sec = float(match.group(2))
+                prompt_text = match.group(3).strip()
+                
+                # Convert time seconds to frame index bounds
+                start_frame = max(0, min(num_frames - 1, int(round((start_sec / total_duration) * (num_frames - 1)))))
+                end_frame = max(start_frame + 1, min(num_frames, int(round((end_sec / total_duration) * (num_frames - 1))) + 1))
+                
+                events.append({
+                    "start_sec": start_sec,
+                    "end_sec": end_sec,
+                    "start_frame": start_frame,
+                    "end_frame": end_frame,
+                    "prompt": prompt_text
+                })
+        
+        # Sort events chronologically by start time
+        events.sort(key=lambda x: x["start_sec"])
+        return events
+
+    @staticmethod
+    def compute_frame_weights(events, num_frames):
+        """
+        Computes temporal softmax/relay weights per frame for each event prompt.
+        Returns weight matrix of shape (num_events, num_frames).
+        """
+        num_events = len(events)
+        if num_events == 0:
+            return None
+
+        weights = np.zeros((num_events, num_frames), dtype=np.float32)
+        
+        for idx, ev in enumerate(events):
+            start = ev["start_frame"]
+            end = ev["end_frame"]
+            weights[idx, start:end] = 1.0
+            
+            # Smooth transition margins (relay blending) between consecutive events
+            margin = 3
+            if start > 0:
+                for f in range(max(0, start - margin), start):
+                    weights[idx, f] = 0.5 * (1.0 + np.cos(np.pi * (start - f) / margin))
+            if end < num_frames:
+                for f in range(end, min(num_frames, end + margin)):
+                    weights[idx, f] = 0.5 * (1.0 + np.cos(np.pi * (f - end + 1) / margin))
+
+        # Normalize weights per frame
+        sum_weights = np.sum(weights, axis=0, keepdims=True)
+        sum_weights[sum_weights == 0] = 1.0
+        weights = weights / sum_weights
+        return weights
+
+    @staticmethod
+    def encode_relay_embeddings(pipe, events, negative_prompt, device="cuda"):
+        """
+        Encodes text prompt for each temporal event and produces encoded embeddings.
+        """
+        if not events:
+            return None, None
+
+        event_prompts = [ev["prompt"] for ev in events]
+        print(f"🎬 Prompt Relay: Encoding {len(events)} temporal event prompts...")
+        
+        encoded_list = []
+        for idx, p in enumerate(event_prompts):
+            print(f"   - Event {idx+1} [{events[idx]['start_sec']}s - {events[idx]['end_sec']}s]: \"{p[:50]}...\"")
+            with torch.no_grad():
+                # Encode text using pipeline's encoder helper or text_encoder
+                try:
+                    prompt_embeds = pipe.encode_prompt(
+                        prompt=p,
+                        negative_prompt=negative_prompt,
+                        device=device
+                    )
+                except Exception:
+                    prompt_embeds = p
+            encoded_list.append(prompt_embeds)
+            
+        return encoded_list, event_prompts

requirements.txt

@@ -0,0 +1,22 @@
+diffusers==0.38.0
+transformers==4.57.6
+accelerate===1.13.0
+safetensors
+sentencepiece
+peft==0.19.1
+ftfy
+imageio
+imageio-ffmpeg
+opencv-python
+torchao==0.17.0
+huggingface_hub
+
+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
+onnxruntime
+insightface

rife_interp.py

@@ -0,0 +1,247 @@
+import os
+import gc
+import subprocess
+import numpy as np
+import torch
+from torch.nn import functional as F
+from tqdm import tqdm
+
+def is_cuda_usable():
+    if not torch.cuda.is_available():
+        return False
+    try:
+        _ = torch.zeros(1, device="cuda")
+        return True
+    except Exception:
+        return False
+
+def clear_vram():
+    gc.collect()
+    if is_cuda_usable():
+        try:
+            torch.cuda.empty_cache()
+        except Exception:
+            pass
+
+def create_classic_boomerang_loop(frames_np):
+    """
+    Creates classic 100% real-speed full boomerang loop (forward + reverse).
+    Reverts to true original speed without artificial slow blending.
+    """
+    if frames_np is None or len(frames_np) < 4:
+        return frames_np
+
+    is_list = isinstance(frames_np, list)
+    forward = list(frames_np) if is_list else [f for f in frames_np]
+    
+    # Exclude boundary duplicates to keep smooth motion flow
+    reversed_frames = list(forward[::-1])[1:-1]
+    result = forward + reversed_frames
+    return result if is_list else np.array(result)
+
+def create_ending_boomerang_loop(frames_np, tail_ratio=0.4, min_tail_frames=24):
+    """
+    Creates ending-only boomerang loop: plays full video forward normally, 
+    then boomerangs only the last 1.5-2.0s tail frames at 100% real speed.
+    """
+    if frames_np is None or len(frames_np) < 6:
+        return frames_np
+
+    is_list = isinstance(frames_np, list)
+    forward = list(frames_np) if is_list else [f for f in frames_np]
+    n_frames = len(forward)
+    
+    # Calculate tail frame count (last ~1.5s to 2.0s based on total frames)
+    tail_count = max(min_tail_frames, int(n_frames * tail_ratio))
+    tail_count = min(n_frames - 2, tail_count)
+    
+    tail_frames = forward[-tail_count:]
+    reversed_tail = list(tail_frames[::-1])[1:-1]
+    
+    result = forward + reversed_tail
+    return result if is_list else np.array(result)
+
+def create_dynamic_boomerang_loop(frames_np, blend_frames=3):
+    return create_classic_boomerang_loop(frames_np)
+
+def create_adaptive_speed_ramping(frames_np, multiplier=2):
+    """
+    Applies non-linear motion-compensated speed ramping (Ease-In / Ease-Out curve).
+    Preserves 100% real-time motion speed during fast action/middle segments,
+    while smoothly easing start and end keyframes to extend duration naturally.
+    """
+    if frames_np is None or len(frames_np) < 6:
+        return frames_np
+
+    is_list = isinstance(frames_np, list)
+    forward = list(frames_np) if is_list else [f for f in frames_np]
+    N = len(forward)
+    target_count = int((N - 1) * multiplier + 1)
+
+    out_frames = []
+    for k in range(target_count):
+        s = k / float(target_count - 1)
+        # Cubic Smoothstep Easing: 3*s^2 - 2*s^3
+        eased_s = s * s * (3.0 - 2.0 * s)
+        
+        pos = eased_s * (N - 1)
+        idx0 = int(pos)
+        idx1 = min(N - 1, idx0 + 1)
+        alpha = pos - idx0
+
+        if alpha < 0.01 or idx0 == idx1:
+            out_frames.append(forward[idx0])
+        else:
+            f0 = np.array(forward[idx0], dtype=np.float32)
+            f1 = np.array(forward[idx1], dtype=np.float32)
+            blended = (1.0 - alpha) * f0 + alpha * f1
+            out_frames.append(blended.astype(np.uint8) if forward[0].dtype == np.uint8 else blended)
+
+    return out_frames if is_list else np.array(out_frames)
+
+# Download and initialize RIFE Model
+if not os.path.exists("RIFEv4.26_0921.zip"):
+    print("Downloading RIFE Model...")
+    subprocess.run([
+        "wget", "-q",
+        "https://huggingface.co/thornmaze/RIFE/resolve/main/RIFEv4.26_0921.zip",
+        "-O", "RIFEv4.26_0921.zip"
+    ], check=True)
+    subprocess.run(["unzip", "-o", "RIFEv4.26_0921.zip"], check=True)
+
+from train_log.RIFE_HDv3 import Model
+rife_model = Model()
+rife_model.load_model("train_log", -1)
+rife_model.eval()
+
+@torch.no_grad()
+def interpolate_bits(frames_np, multiplier=2, scale=1.0):
+    if isinstance(frames_np, list):
+        T = len(frames_np)
+        H, W, C = frames_np[0].shape
+    else:
+        T, H, W, C = frames_np.shape
+
+    if multiplier < 2:
+        if isinstance(frames_np, np.ndarray):
+            return list(frames_np)
+        return frames_np
+
+    n_interp = multiplier - 1
+    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)
+
+    use_cuda = is_cuda_usable()
+    curr_device = torch.device("cuda" if use_cuda else "cpu")
+
+    try:
+        if hasattr(rife_model, "flownet") and rife_model.flownet is not None:
+            rife_model.flownet = rife_model.flownet.to(curr_device)
+            if use_cuda:
+                rife_model.flownet = rife_model.flownet.half()
+            else:
+                rife_model.flownet = rife_model.flownet.float()
+    except Exception as e:
+        print(f"RIFE model device placement notice: {e}")
+
+    def to_tensor(frame_np):
+        t = torch.from_numpy(frame_np).to(curr_device)
+        t = t.permute(2, 0, 1).unsqueeze(0)
+        if curr_device.type == "cuda":
+            return F.pad(t, padding).half()
+        return F.pad(t, padding).float()
+
+    def from_tensor(tensor):
+        t = tensor[0, :, :H, :W]
+        t = t.permute(1, 2, 0)
+        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 = []
+    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
+            output_frames.append(from_tensor(I0))
+            I1 = to_tensor(frames_np[i+1])
+            mid_tensors = make_inference(I0, I1, n_interp)
+            for mid in mid_tensors:
+                output_frames.append(from_tensor(mid))
+            if (i + 1) % 50 == 0:
+                pbar.update(50)
+        pbar.update(total_steps % 50)
+        output_frames.append(from_tensor(I1))
+    
+    del I0, I1, mid_tensors
+    if curr_device.type == "cuda" and is_cuda_usable():
+        try:
+            torch.cuda.empty_cache()
+        except Exception:
+            pass
+    return output_frames
+
+
+def call_sulphur_rife_api(video_path: str, multiplier: int = 2, slow_motion: bool = False, server_url: str = None) -> str:
+    """
+    Calls Sulphur AI VIP Remote RIFE Acceleration API (/api/v1/rife-extend).
+    Offloads 2x, 4x, or 8x frame rate extension directly to remote GPU server.
+    Returns file path of extended MP4 video, or None if failed/offline.
+    """
+    import os
+    import requests
+    import tempfile
+    import config
+
+    if not video_path or not os.path.exists(video_path):
+        return None
+
+    target_url = server_url or config.SULPHUR_API_URL or os.environ.get("SULPHUR_API_URL", "http://localhost:6666")
+    if not target_url or not str(target_url).strip():
+        return None
+
+    clean_url = str(target_url).strip().rstrip("/")
+    endpoint = f"{clean_url}/api/v1/rife-extend"
+
+    try:
+        print(f"🌐 Calling Sulphur AI VIP RIFE API at {endpoint} (multiplier={multiplier}, slow_motion={slow_motion})...")
+        with open(video_path, "rb") as vf:
+            files = {"video": (os.path.basename(video_path), vf, "video/mp4")}
+            data = {
+                "multiplier": str(int(multiplier)),
+                "slow_motion": "true" if slow_motion else "false"
+            }
+            res = requests.post(endpoint, files=files, data=data, timeout=45)
+
+        if res.status_code == 200 and res.content:
+            out_filename = f"vip_rife_{multiplier}x_{os.path.basename(video_path)}"
+            out_path = os.path.join(tempfile.gettempdir(), out_filename)
+            with open(out_path, "wb") as f:
+                f.write(res.content)
+            print(f"✅ Sulphur AI VIP RIFE Acceleration succeeded: {out_path}")
+            return out_path
+        else:
+            print(f"⚠️ VIP RIFE API returned status {res.status_code}")
+    except Exception as e:
+        print(f"⚠️ VIP RIFE API notice: {e}")
+
+    return None

style.css

@@ -0,0 +1,240 @@
+/* ==========================================================================
+   I2V EXTENDED - ULTRA-LUXURIOUS DARK GLASSMORPHISM DESIGN SYSTEM
+   ========================================================================== */
+
+/* Theme & Main Container */
+.gradio-container {
+    max-width: 1320px !important;
+    margin: 0 auto !important;
+    font-family: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
+    background: #070b14 !important;
+    color: #f1f5f9 !important;
+}
+
+/* Header Banner */
+.header-box {
+    text-align: center;
+    padding: 40px 32px 32px 32px;
+    background: linear-gradient(135deg, rgba(30, 27, 75, 0.75) 0%, rgba(88, 28, 135, 0.5) 45%, rgba(15, 23, 42, 0.85) 100%);
+    border-radius: 28px;
+    border: 1.5px solid rgba(168, 85, 247, 0.45);
+    margin-bottom: 24px;
+    box-shadow: 0 20px 60px rgba(99, 102, 241, 0.25), 0 0 30px rgba(168, 85, 247, 0.15);
+    position: relative;
+    overflow: hidden;
+    backdrop-filter: blur(16px);
+}
+
+.header-box::before {
+    content: '';
+    position: absolute;
+    top: -50%;
+    left: -50%;
+    width: 200%;
+    height: 200%;
+    background: radial-gradient(circle at center, rgba(168, 85, 247, 0.12) 0%, transparent 60%);
+    pointer-events: none;
+}
+
+.header-tag {
+    display: inline-block;
+    background: linear-gradient(90deg, rgba(99, 102, 241, 0.35), rgba(236, 72, 153, 0.35));
+    border: 1px solid rgba(255, 255, 255, 0.3);
+    color: #e0e7ff;
+    font-size: 0.75rem;
+    font-weight: 800;
+    letter-spacing: 0.16em;
+    padding: 5px 18px;
+    border-radius: 9999px;
+    margin-bottom: 14px;
+    text-transform: uppercase;
+    box-shadow: 0 4px 14px rgba(0, 0, 0, 0.3);
+}
+
+.header-box h1 {
+    font-size: 2.8rem !important;
+    font-weight: 900 !important;
+    background: linear-gradient(90deg, #818cf8 0%, #c084fc 40%, #f472b6 80%, #38bdf8 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    margin-bottom: 12px !important;
+    letter-spacing: -0.03em;
+}
+
+.header-box p {
+    color: #cbd5e1 !important;
+    font-size: 1.05rem !important;
+    margin-bottom: 22px !important;
+    font-weight: 400;
+    max-width: 900px;
+    margin-left: auto;
+    margin-right: auto;
+    line-height: 1.6;
+}
+
+/* Badges */
+.badge-group {
+    display: flex;
+    justify-content: center;
+    gap: 12px;
+    flex-wrap: wrap;
+}
+
+.badge-item {
+    background: rgba(15, 23, 42, 0.7);
+    color: #c7d2fe;
+    border: 1px solid rgba(168, 85, 247, 0.4);
+    padding: 7px 18px;
+    border-radius: 9999px;
+    font-size: 0.84rem;
+    font-weight: 600;
+    box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3);
+    backdrop-filter: blur(8px);
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+.badge-item:hover {
+    background: rgba(168, 85, 247, 0.35);
+    border-color: rgba(236, 72, 153, 0.7);
+    color: #ffffff;
+    transform: translateY(-3px) scale(1.02);
+    box-shadow: 0 8px 24px rgba(168, 85, 247, 0.4);
+}
+
+/* Exclusive Features Grid */
+.features-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(340px, 1fr));
+    gap: 16px;
+    margin-top: 20px;
+    text-align: left;
+}
+
+.feature-card {
+    background: rgba(15, 23, 42, 0.75);
+    border: 1.2px solid rgba(99, 102, 241, 0.35);
+    border-radius: 18px;
+    padding: 16px 20px;
+    backdrop-filter: blur(12px);
+    transition: all 0.3s ease;
+}
+
+.feature-card:hover {
+    border-color: rgba(168, 85, 247, 0.65);
+    transform: translateY(-3px);
+    box-shadow: 0 10px 30px rgba(99, 102, 241, 0.25);
+}
+
+.feature-title {
+    font-size: 0.95rem;
+    font-weight: 700;
+    color: #a7f3d0;
+    margin-bottom: 5px;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.feature-desc {
+    font-size: 0.83rem;
+    color: #94a3b8;
+    line-height: 1.5;
+}
+
+/* Main Action Button */
+#generate-btn {
+    background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 45%, #d946ef 100%) !important;
+    border: 1px solid rgba(255, 255, 255, 0.2) !important;
+    color: #ffffff !important;
+    font-weight: 800 !important;
+    font-size: 1.2rem !important;
+    padding: 18px 32px !important;
+    border-radius: 18px !important;
+    box-shadow: 0 8px 32px rgba(124, 58, 237, 0.55), 0 0 20px rgba(217, 70, 239, 0.3) !important;
+    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    cursor: pointer !important;
+    margin-top: 16px !important;
+    letter-spacing: 0.02em !important;
+}
+
+#generate-btn:hover {
+    transform: translateY(-3px) scale(1.01) !important;
+    box-shadow: 0 12px 40px rgba(124, 58, 237, 0.8), 0 0 30px rgba(217, 70, 239, 0.5) !important;
+    filter: brightness(1.15) !important;
+}
+
+#generate-btn:active {
+    transform: translateY(1px) scale(0.99) !important;
+}
+
+/* Frame Grabber Button */
+#grab-frame-btn {
+    background: rgba(99, 102, 241, 0.18) !important;
+    border: 1.2px solid rgba(99, 102, 241, 0.45) !important;
+    color: #c7d2fe !important;
+    font-weight: 700 !important;
+    border-radius: 14px !important;
+    padding: 10px 18px !important;
+    transition: all 0.25s ease !important;
+}
+
+#grab-frame-btn:hover {
+    background: rgba(99, 102, 241, 0.4) !important;
+    border-color: rgba(168, 85, 247, 0.7) !important;
+    color: #ffffff !important;
+    transform: translateY(-1px) !important;
+}
+
+/* Hidden Timestamp Component */
+#hidden-timestamp {
+    opacity: 0;
+    height: 0px;
+    width: 0px;
+    margin: 0px;
+    padding: 0px;
+    overflow: hidden;
+    position: absolute;
+    pointer-events: none;
+}
+
+/* Video Player Container */
+#generated-video {
+    max-width: 100% !important; 
+    max-height: 580px !important; 
+    margin: 0 auto;
+    border-radius: 20px;
+    overflow: hidden;
+    border: 1.5px solid rgba(168, 85, 247, 0.35);
+    box-shadow: 0 16px 48px rgba(0, 0, 0, 0.5), 0 0 24px rgba(99, 102, 241, 0.2);
+}
+
+#generated-video video {
+    max-height: 580px !important; 
+    object-fit: contain;        
+}
+
+/* Accordion & Card Enhancements */
+.gr-accordion {
+    border-radius: 16px !important;
+    border: 1.2px solid rgba(99, 102, 241, 0.25) !important;
+    background: rgba(15, 23, 42, 0.6) !important;
+    backdrop-filter: blur(10px) !important;
+    overflow: hidden !important;
+    margin-bottom: 12px !important;
+}
+
+.gr-accordion-header {
+    font-weight: 700 !important;
+    color: #e2e8f0 !important;
+}
+
+/* VIP Card Styling */
+.sulphur-vip-container {
+    background: linear-gradient(135deg, rgba(88, 28, 135, 0.45) 0%, rgba(234, 179, 8, 0.22) 50%, rgba(15, 23, 42, 0.8) 100%) !important;
+    border: 1.5px solid rgba(234, 179, 8, 0.65) !important;
+    border-radius: 20px !important;
+    padding: 20px 22px !important;
+    box-shadow: 0 12px 36px rgba(168, 85, 247, 0.3), 0 0 25px rgba(234, 179, 8, 0.2) !important;
+    backdrop-filter: blur(14px) !important;
+    margin-bottom: 16px !important;
+}

templates/footer.html

@@ -0,0 +1,81 @@
+<div class="header-box" style="margin-top: 28px; background: linear-gradient(135deg, rgba(15, 23, 42, 0.85) 0%, rgba(30, 27, 75, 0.75) 50%, rgba(15, 23, 42, 0.85) 100%); border: 1.5px solid rgba(168, 85, 247, 0.35); border-radius: 20px; padding: 22px; backdrop-filter: blur(14px); box-shadow: 0 10px 30px rgba(0, 0, 0, 0.4);">
+    <div class="header-tag" style="background: linear-gradient(90deg, #6366f1, #a855f7, #ec4899); color: #ffffff; font-weight: 800; font-size: 0.76rem; padding: 4px 12px; border-radius: 20px; display: inline-block; margin-bottom: 12px; text-transform: uppercase; letter-spacing: 0.05em;">
+        ✨ COMPLETE FEATURE & MOTION SUITE GUIDE
+    </div>
+    
+    <h2 style="font-size: 1.85rem; font-weight: 900; background: linear-gradient(90deg, #818cf8 0%, #c084fc 40%, #f472b6 80%, #fbbf24 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin-bottom: 8px;">
+        I2V EXTENDED FEATURE SUITE
+    </h2>
+    <p style="color: #cbd5e1; font-size: 0.92rem; margin-bottom: 18px; line-height: 1.55;">
+        Comprehensive guide to motion extension techniques (Real-Time 32 FPS RIFE vs Boomerang Loop), Sulphur AI Vision integration, 3-way frame extraction, and automated HF dataset backups.
+    </p>
+
+    <!-- Badges Row -->
+    <div style="display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 22px;">
+        <span style="background: rgba(56, 189, 248, 0.2); border: 1px solid #38bdf8; color: #7dd3fc; padding: 4px 12px; border-radius: 14px; font-size: 0.82rem; font-weight: 700;">⚡ 32/64 FPS Real-Time RIFE (Default)</span>
+        <span style="background: rgba(99, 102, 241, 0.2); border: 1px solid #6366f1; color: #a5b4fc; padding: 4px 12px; border-radius: 14px; font-size: 0.82rem; font-weight: 700;">🔂 Dynamic Boomerang Loop</span>
+        <span style="background: rgba(45, 212, 191, 0.2); border: 1px solid #2dd4bf; color: #99f6e4; padding: 4px 12px; border-radius: 14px; font-size: 0.82rem; font-weight: 700;">🌊 Adaptive Speed Ramping</span>
+        <span style="background: rgba(234, 179, 8, 0.2); border: 1px solid #eab308; color: #fde047; padding: 4px 12px; border-radius: 14px; font-size: 0.82rem; font-weight: 700;">💎 Sulphur AI VIP Vision</span>
+        <span style="background: rgba(236, 72, 153, 0.2); border: 1px solid #ec4899; color: #f472b6; padding: 4px 12px; border-radius: 14px; font-size: 0.82rem; font-weight: 700;">👤 Standalone Face Swap + GFPGAN</span>
+        <span style="background: rgba(16, 185, 129, 0.2); border: 1px solid #10b981; color: #6ee7b7; padding: 4px 12px; border-radius: 14px; font-size: 0.82rem; font-weight: 700;">📸 3-Way Instant Frame Grab</span>
+    </div>
+
+    <!-- Feature Cards Grid -->
+    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 14px;">
+        
+        <!-- Card 1: RIFE Real-Time vs Slow Motion -->
+        <div style="background: rgba(30, 41, 59, 0.75); border: 1px solid rgba(56, 189, 248, 0.35); border-radius: 14px; padding: 16px;">
+            <div style="font-weight: 800; color: #38bdf8; font-size: 1.0rem; margin-bottom: 8px;">
+                ⚡ RIFE Real-Time (32 FPS) vs Slow-Mo (16 FPS)
+            </div>
+            <div style="font-size: 0.86rem; color: #cbd5e1; line-height: 1.5;">
+                • <b>Real-Time RIFE (Default 32/64 FPS):</b> Interpolates intermediate frames and plays back at 32 FPS, delivering ultra-fluid 60+ FPS motion while keeping <b>100% natural motion speed</b>.<br>
+                • <b>Slow-Motion RIFE (16 FPS):</b> Time-stretches video frames at 16 FPS for cinematic slow-mo.
+            </div>
+        </div>
+
+        <!-- Card 2: Motion Loop Techniques -->
+        <div style="background: rgba(30, 41, 59, 0.75); border: 1px solid rgba(99, 102, 241, 0.35); border-radius: 14px; padding: 16px;">
+            <div style="font-weight: 800; color: #818cf8; font-size: 1.0rem; margin-bottom: 8px;">
+                🔂 Boomerang & 🌊 Adaptive Speed Ramping
+            </div>
+            <div style="font-size: 0.86rem; color: #cbd5e1; line-height: 1.5;">
+                • <b>Boomerang Loop:</b> Creates a forward + smooth reverse loop with alpha-blended turning points (100% natural speed, 0 GPU quota).<br>
+                • <b>Adaptive Speed Ramping:</b> Cubic smoothstep curve easing to extend video duration smoothly.
+            </div>
+        </div>
+
+        <!-- Card 3: Sulphur AI VIP Vision -->
+        <div style="background: rgba(30, 41, 59, 0.75); border: 1px solid rgba(234, 179, 8, 0.4); border-radius: 14px; padding: 16px;">
+            <div style="font-weight: 800; color: #fde047; font-size: 1.0rem; margin-bottom: 8px;">
+                👑 Sulphur AI VIP Vision & Pre-Swap Pipeline
+            </div>
+            <div style="font-size: 0.86rem; color: #cbd5e1; line-height: 1.5;">
+                Analyzes main input images using Qwen2.5-VL to automatically write a multi-event <b>Prompt Relay Schedule</b>. Optional pre-swap feature swaps faces and restores detail via GFPGAN before video synthesis.
+            </div>
+        </div>
+
+        <!-- Card 4: 3-Way Instant Frame Extraction -->
+        <div style="background: rgba(30, 41, 59, 0.75); border: 1px solid rgba(16, 185, 129, 0.4); border-radius: 14px; padding: 16px;">
+            <div style="font-weight: 800; color: #34d399; font-size: 1.0rem; margin-bottom: 8px;">
+                📸 3-Way Instant Video Frame Extraction
+            </div>
+            <div style="font-size: 0.86rem; color: #cbd5e1; line-height: 1.5;">
+                • <b>Input Image:</b> Grab current timestamp frame as next Main Input.<br>
+                • <b>Last Frame:</b> Set frame as End Frame for smooth dual-image interpolation.<br>
+                • <b>Target Swap:</b> Send frame straight to Standalone Face Swapper.
+            </div>
+        </div>
+
+        <!-- Card 5: Standalone Face Swapper & GFPGAN -->
+        <div style="background: rgba(30, 41, 59, 0.75); border: 1px solid rgba(236, 72, 153, 0.4); border-radius: 14px; padding: 16px;">
+            <div style="font-weight: 800; color: #f472b6; font-size: 1.0rem; margin-bottom: 8px;">
+                👤 Standalone Face Swapper & GFPGAN v1.4
+            </div>
+            <div style="font-size: 0.86rem; color: #cbd5e1; line-height: 1.5;">
+                Swap single image faces with gender filter support ("Female Faces Only", "Male Faces Only", "Any/All") and restore blurry facial details via GFPGAN v1.4 on CPU (~0 GPU quota).
+            </div>
+        </div>
+
+    </div>
+</div>

templates/header.html

@@ -0,0 +1,33 @@
+<div class="header-box">
+    <div class="header-tag">✨ IMAGE-TO-VIDEO EXTENDED AI ENGINE</div>
+    <h1>I2V EXTENDED</h1>
+    <p>Generate ultra-realistic, cinematic motion videos up to 12s using Wan 2.2 14B Base Model with RIFE 32 FPS Interpolation (4-8 Steps GPU + CPU Interpolation = Ultra Smooth Video, Minimal GPU Usage)</p>
+    
+    <div class="badge-group">
+        <span class="badge-item">⚡ 4-Step Lightning Inference</span>
+        <span class="badge-item">🚀 FP8 Quantized & AoT C++ Compiled</span>
+        <span class="badge-item">🎯 70%+ ZeroGPU Quota Savings</span>
+        <span class="badge-item">🎬 Prompt Relay Storyline Control</span>
+        <span class="badge-item">👤 CPU Face Identity Swap</span>
+        <span class="badge-item">💎 Sulphur AI Vision Engine</span>
+    </div>
+    
+    <div class="features-grid">
+        <div class="feature-card">
+            <div class="feature-title">⚡ 4-Step Lightning Acceleration</div>
+            <div class="feature-desc">Fused Wan 2.2 Lightning LoRA enables high-fidelity video generation in just 4 steps, saving up to 70% ZeroGPU quota.</div>
+        </div>
+        <div class="feature-card">
+            <div class="feature-title">🎬 Prompt Relay Storyline Control</div>
+            <div class="feature-desc">Granular temporal prompt schedule routing for multi-event story video generation without extra GPU quota.</div>
+        </div>
+        <div class="feature-card">
+            <div class="feature-title">👤 CPU Pre-Swap Face Lock</div>
+            <div class="feature-desc">Preserve exact facial features from input images using CPU InsightFace pre-swapping in ~0.1s (0 GPU quota).</div>
+        </div>
+        <div class="feature-card">
+            <div class="feature-title">👑 Sulphur AI Vision Engine</div>
+            <div class="feature-desc">Analyze main input images with Qwen2.5-VL to auto-compose timestamped multi-event Prompt Relay schedules.</div>
+        </div>
+    </div>
+</div>

templates/rife_vip.html

@@ -0,0 +1,10 @@
+<div class="sulphur-vip-container" style="background: linear-gradient(135deg, rgba(30, 27, 75, 0.7) 0%, rgba(15, 23, 42, 0.8) 100%); border: 1.5px solid rgba(234, 179, 8, 0.4); border-radius: 14px; padding: 14px 18px; margin-bottom: 12px; box-shadow: 0 4px 16px rgba(0, 0, 0, 0.3);">
+    <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 8px;">
+        <span class="sulphur-vip-badge" style="background: linear-gradient(90deg, #eab308, #f59e0b); color: #0f172a; font-weight: 800; font-size: 0.75rem; padding: 3px 10px; border-radius: 12px;">💎 EXCLUSIVE VIP ACCELERATION</span>
+        <span style="color: #fde047; font-weight: 700; font-size: 0.8rem; letter-spacing: 0.05em;">⚡ HIGH SPEED</span>
+    </div>
+    <h3 class="sulphur-vip-title" style="font-size: 1.1rem; font-weight: 800; color: #fde047; margin: 0 0 4px 0;">Sulphur AI Remote GPU RIFE Engine</h3>
+    <p class="sulphur-vip-desc" style="color: #cbd5e1; font-size: 0.85rem; margin: 0; line-height: 1.45;">
+        Offloads RIFE v4.26 frame rate extension & duration multiplier directly to high-speed dedicated VIP GPU server. Delivers instant 2x, 4x, or 8x smoothness with <b>0 GPU load on space</b>.
+    </p>
+</div>

templates/sulphur_vip.html

@@ -0,0 +1,10 @@
+<div class="sulphur-vip-container">
+    <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 8px;">
+        <span class="sulphur-vip-badge">👑 EXCLUSIVE VIP FEATURE</span>
+        <span style="color: #fef08a; font-weight: 700; font-size: 0.8rem; letter-spacing: 0.05em;">⭐ MUST TRY</span>
+    </div>
+    <h3 class="sulphur-vip-title">Sulphur AI Vision Prompt Engine</h3>
+    <p class="sulphur-vip-desc">
+        Analyzes your main input image & scene parameters using Qwen2.5-VL to automatically compose a rich, multi-event <b>Prompt Relay Timeline Schedule</b> directly into the Prompt Relay.
+    </p>
+</div>

templates/top_bar.html

@@ -0,0 +1,23 @@
+<div style="padding: 16px 22px; background: linear-gradient(135deg, rgba(15, 23, 42, 0.95) 0%, rgba(30, 27, 75, 0.9) 50%, rgba(15, 23, 42, 0.95) 100%); border: 1.5px solid rgba(168, 85, 247, 0.4); border-radius: 20px; margin-bottom: 20px; backdrop-filter: blur(16px); box-shadow: 0 10px 30px rgba(0, 0, 0, 0.5), 0 0 20px rgba(168, 85, 247, 0.15);">
+    <div style="display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 12px;">
+        <div style="display: flex; align-items: center; gap: 12px;">
+            <div style="width: 44px; height: 44px; background: linear-gradient(135deg, #6366f1 0%, #a855f7 50%, #ec4899 100%); border-radius: 14px; display: flex; align-items: center; justify-content: center; box-shadow: 0 4px 14px rgba(168, 85, 247, 0.4); font-size: 1.5rem;">
+                🎬
+            </div>
+            <div>
+                <h1 style="font-size: 1.85rem; font-weight: 900; background: linear-gradient(90deg, #818cf8 0%, #c084fc 40%, #f472b6 80%, #fbbf24 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin: 0; letter-spacing: -0.02em; line-height: 1.2;">
+                    I2V EXTENDED <span style="font-size: 0.85rem; font-weight: 800; background: rgba(168, 85, 247, 0.2); border: 1px solid #a855f7; border-radius: 8px; padding: 2px 8px; vertical-align: middle; -webkit-text-fill-color: #c084fc;">v3.5 VIP</span>
+                </h1>
+                <p style="color: #cbd5e1; font-size: 0.86rem; margin: 2px 0 0 0; font-weight: 500;">
+                    Wan 2.2 14B Lightning • Prompt Relay • RIFE / Boomerang • CPU Face Swap
+                </p>
+            </div>
+        </div>
+
+        <div style="display: flex; align-items: center; gap: 10px; flex-wrap: wrap;">
+            <span style="background: rgba(99, 102, 241, 0.15); border: 1px solid rgba(99, 102, 241, 0.4); color: #a5b4fc; padding: 4px 12px; border-radius: 20px; font-size: 0.8rem; font-weight: 700; display: inline-flex; align-items: center; gap: 5px;">
+                ⚡ ZeroGPU Quota Saver
+            </span>
+        </div>
+    </div>
+</div>

ui.py

@@ -0,0 +1,441 @@
+import os
+import sys
+import gradio as gr
+import config
+import lora_loader
+import face_swapper
+import prompt_enhancer
+from image_utils import extract_frame, get_timestamp_js, load_image_from_url
+from pipeline_manager import generate_video
+
+with open("style.css", "r", encoding="utf-8") as f:
+    CSS = f.read()
+
+def load_template(filename: str) -> str:
+    filepath = os.path.join("templates", filename)
+    if os.path.exists(filepath):
+        with open(filepath, "r", encoding="utf-8") as f:
+            return f.read()
+    return ""
+
+def get_header_html() -> str:
+    return load_template("top_bar.html")
+
+def create_ui():
+    with gr.Blocks(delete_cache=(3600, 10800), title="I2V EXTENDED") as demo:
+        gr.HTML(f"<style>{CSS}</style>" + get_header_html())
+
+        with gr.Row():
+            with gr.Column(scale=5):
+                input_image_component = gr.Image(
+                    type="pil", 
+                    label="🖼️ Input Image", 
+                    sources=["upload", "clipboard"],
+                    height=260
+                )
+                with gr.Row():
+                    image_url_input = gr.Textbox(
+                        label="🌐 Load Input Image from URL",
+                        placeholder="e.g. https://example.com/image.jpg",
+                        value="",
+                        scale=4
+                    )
+                    load_image_btn = gr.Button("📥 Load Image", variant="secondary", scale=1)
+
+                load_image_btn.click(
+                    fn=load_image_from_url,
+                    inputs=[image_url_input],
+                    outputs=[input_image_component]
+                )
+
+                with gr.Accordion("🖼️ Last Image (Optional End Frame)", open=False):
+                    last_image_component = gr.Image(
+                        type="pil", 
+                        label="Last Image (Optional End Frame)", 
+                        sources=["upload", "clipboard"],
+                        height=200
+                    )
+
+                duration_seconds_input = gr.Slider(
+                    minimum=config.MIN_DURATION, 
+                    maximum=config.MAX_DURATION, 
+                    step=0.1, 
+                    value=4.0, 
+                    label="⏱️ Duration (seconds)", 
+                    info=f"Set to 4.0s for direct 65-frame model generation. Or set to 2.0s + 32 FPS for ultra-fast 4s video (saves 50% quota)."
+                )
+
+                motion_extension_dropdown = gr.Dropdown(
+                    choices=[
+                        "⚡ Real-Time RIFE Interpolation (32/64 FPS Ultra-Smooth)",
+                        "🔂 Ending-Only Boomerang Loop (Real Speed, Tail 1.5s Loop)",
+                        "🔂 Classic Full Boomerang Loop (100% Real-Speed Forward+Reverse)",
+                        "🌊 Adaptive Motion Speed Ramping (Ease-In/Out Curve)",
+                        "🐢 Cinematic Slow-Motion (16 FPS RIFE Time-Stretch)"
+                    ],
+                    value="⚡ Real-Time RIFE Interpolation (32/64 FPS Ultra-Smooth)",
+                    label="🎬 Motion Extension & Loop Technique",
+                    info="Choose Real-Time RIFE (Default), Ending-Only Boomerang (Tail Loop), Classic Full Boomerang, or Speed Ramping."
+                )
+
+                frame_multi = gr.Dropdown(
+                    choices=[
+                        (f"16 FPS (Original Duration)", config.FIXED_FPS),
+                        (f"32 FPS (2x RIFE -> Converts 2s GPU to 4s Video)", config.FIXED_FPS*2),
+                        (f"64 FPS (4x RIFE -> Converts 2s GPU to 8s Video)", config.FIXED_FPS*4),
+                    ],
+                    value=config.FIXED_FPS,
+                    label="🎬 Video Fluidity & RIFE Extension (FPS)",
+                    info="Select 32 FPS (2x RIFE) to extend 2s GPU output into a smooth 4s video on CPU (0 GPU quota)."
+                )
+
+                with gr.Accordion("👑 Sulphur AI Vision Prompt Enhancer & Face Swap (Exclusive VIP)", open=True):
+                    gr.HTML(load_template("sulphur_vip.html"))
+                    sulphur_vip_password_input = gr.Textbox(
+                        label="🔑 VIP Password Access Key",
+                        type="password",
+                        placeholder="Enter VIP Password to unlock Sulphur AI Vision Engine",
+                        value="",
+                        info="Required to authorize Sulphur AI Vision Prompt & Pre-Swap VIP feature."
+                    )
+                    with gr.Row():
+                        sulphur_subject_input = gr.Textbox(
+                            label="Main Subject", 
+                            value="", 
+                            lines=2,
+                            placeholder="e.g. beautiful woman in a elegant black dress"
+                        )
+                        sulphur_adegan_input = gr.Textbox(
+                            label="Scene Motion / Action", 
+                            value="", 
+                            lines=2,
+                            placeholder="e.g. a man standing infront of her"
+                        )
+                    with gr.Row():
+                        sulphur_camera_dropdown = gr.Dropdown(
+                            choices=["Static", "Close-Up", "Handheld", "POV", "Pan Left-Right", "Zoom In", "Drone View", "Tracking Shot","Tilt Up-Down","Rotation","Zoom Out","Orbit Shot","Steadicam","Slow Motion","Fast Motion","Freeze Frame","Other", "Vertical Shot", "Horizontal Shot", "Diagonal Shot", "Macro Shot", "Telephoto Shot","Random"],
+                            value="Static",
+                            label="Camera Setting"
+                        )
+                        sulphur_atmosphere_dropdown = gr.Dropdown(
+                            choices=["Dim Bedroom", "Neon / Cyberpunk", "Natural Cinematic", "Dramatic Night", "Golden Hour Sun", "Studio Portrait","Night Time","Home Theater","Outdoor Night","Indoor Night","Outdoor Day","Indoor Day","Car Night","Car Day","Beach Night","Beach Day","Forest Night","Forest Day","Mountain Night","Mountain Day","Desert Night","Desert Day","Pool Night","Pool Day","Room","Living Room","Kitchen","Bathroom","Garden","Street","Cafe","Restaurant","Bar","Club","Hotel","Mall","Airport","Train","Bus","Subway","Bicycle","Motorcycle","Truck","Boat","Airplane","Spaceship","Other"],
+                            value="Natural Cinematic",
+                            label="Atmosphere / Lighting"
+                        )
+                        sulphur_duration_slider = gr.Slider(minimum=1, maximum=8, step=1, value=4, label="Duration (seconds)")
+                    
+                    with gr.Accordion("👤 Sulphur AI Face Swap & GFPGAN Restoration Controls (Optional)", open=False):
+                        with gr.Row():
+                            ref_face_component = gr.Image(
+                                type="pil", 
+                                label="👤 Reference Face Image (Source Face)", 
+                                sources=["upload", "clipboard"],
+                                height=180
+                            )
+                            with gr.Column():
+                                sulphur_enable_swap_checkbox = gr.Checkbox(
+                                    label="🔄 Enable Face Swap & GFPGAN Restoration",
+                                    value=False,
+                                    info="Swaps face on main input image & sharpens facial features via GFPGAN before video generation."
+                                )
+                                target_gender_dropdown = gr.Dropdown(
+                                    choices=["Any / All Faces", "Female Faces Only", "Male Faces Only"],
+                                    value="Female Faces Only",
+                                    label="👥 Target Gender to Swap",
+                                    info="Filter which faces in target image get swapped."
+                                )
+
+                    sulphur_enhance_btn = gr.Button("💎 Auto-Generate Prompt Relay & Optional Pre-Swap Input via Sulphur AI", variant="primary")
+                    sulphur_api_status_box = gr.HTML()
+
+                enable_prompt_relay_checkbox = gr.Checkbox(
+                    label="🎬 Enable Prompt Relay (Multi-Event Timeline Control)",
+                    value=True,
+                    info="⭐ Primary Recommended: Enables high-accuracy multi-event timeline routing across video seconds (0 GPU quota extra)."
+                )
+                relay_prompt_schedule_input = gr.Textbox(
+                    label="🎬 Multi-Event Timeline Schedule (Prompt Relay)",
+                    lines=5,
+                    max_lines=10,
+                    placeholder="[0.0s - 2.0s] A beautiful woman sitting by the window reading a book\n[2.0s - 4.0s] The woman stands up, smiles warmly, and walks towards the camera",
+                    value="[0.0s - 2.0s] A beautiful woman sitting by the window reading a book\n[2.0s - 4.0s] The woman stands up, smiles warmly, and walks towards the camera",
+                    info="Format: [start_sec - end_sec] Detailed event motion description"
+                )
+
+                sulphur_enhance_btn.click(
+                    fn=prompt_enhancer.call_sulphur_enhancer_api,
+                    inputs=[
+                        input_image_component,
+                        sulphur_subject_input,
+                        sulphur_adegan_input,
+                        sulphur_camera_dropdown,
+                        sulphur_atmosphere_dropdown,
+                        sulphur_duration_slider,
+                        ref_face_component,
+                        target_gender_dropdown,
+                        sulphur_enable_swap_checkbox,
+                        gr.State(None),
+                        sulphur_vip_password_input
+                    ],
+                    outputs=[
+                        relay_prompt_schedule_input,
+                        enable_prompt_relay_checkbox,
+                        sulphur_api_status_box,
+                        input_image_component
+                    ]
+                )
+
+                with gr.Accordion("✨ Base Prompt (Global Modifiers / Quality Booster)", open=True):
+                    prompt_input = gr.Textbox(
+                        label="✨ Base Prompt", 
+                        value=config.default_prompt_i2v, 
+                        lines=3,
+                        max_lines=6,
+                        placeholder="Describe global style, lighting, or overall video mood..."
+                    )
+
+                with gr.Row():
+                    describe_image_btn = gr.Button("🔍 Describe Image from Input (CPU ~1s)", variant="secondary")
+                    enhance_prompt_btn = gr.Button("✨ Auto-Enhance Prompt (CPU ~0.05s)", variant="secondary")
+
+                describe_image_btn.click(
+                    fn=prompt_enhancer.describe_image,
+                    inputs=[input_image_component],
+                    outputs=[prompt_input]
+                )
+
+                enhance_prompt_btn.click(
+                    fn=prompt_enhancer.enhance_prompt,
+                    inputs=[prompt_input],
+                    outputs=[prompt_input]
+                )
+                
+                with gr.Row():
+                    safe_mode_checkbox = gr.Checkbox(
+                        label="🛠️ Safe Mode",
+                        value=False,
+                        info="Requests extra processing buffer time to prevent timeout when server is busy."
+                    )
+
+                with gr.Accordion("🔗 Custom Civitai / Direct LoRA URL", open=False):
+                    custom_lora_url_input = gr.Textbox(
+                        label="Civitai / Direct LoRA Download URL",
+                        placeholder="e.g. https://civitai.red/api/download/models/2098405?fileId=1994044",
+                        value="",
+                        info="Paste any Civitai or direct HTTP/HTTPS .safetensors link"
+                    )
+                    custom_lora_scale_input = gr.Slider(
+                        label="Custom LoRA Weight Scale",
+                        minimum=0.0,
+                        maximum=2.0,
+                        step=0.05,
+                        value=1.0,
+                        info="Strength of the custom LoRA effect"
+                    )
+                    with gr.Row():
+                        download_lora_btn = gr.Button("📥 Pre-Download LoRA to Cache (CPU ~0 GPU Quota)", variant="secondary")
+                    download_status_box = gr.HTML()
+
+                    download_lora_btn.click(
+                        fn=lora_loader.download_custom_lora_ui_action,
+                        inputs=[custom_lora_url_input],
+                        outputs=[download_status_box]
+                    )
+
+                play_result_video = gr.Checkbox(label="Display Video Preview", value=True, interactive=True)
+                generate_button = gr.Button("🚀 Generate Video", variant="primary", elem_id="generate-btn")
+
+            with gr.Column(scale=5):
+                video_output = gr.Video(
+                    label="📹 Generated Video Result", 
+                    autoplay=True, 
+                    sources=["upload"], 
+                    buttons=["download", "share"], 
+                    interactive=True, 
+                    elem_id="generated-video"
+                )
+                
+                with gr.Row():
+                    grab_frame_btn = gr.Button("📸 Use Current Frame as Input Image", variant="secondary", elem_id="grab-frame-btn")
+                    grab_last_frame_btn = gr.Button("🏁 Use Current Frame as Last Frame", variant="secondary", elem_id="grab-last-frame-btn")
+                    grab_swap_target_btn = gr.Button("👤 Use Current Frame as Target Image to Swap", variant="secondary", elem_id="grab-swap-target-btn")
+                    timestamp_box = gr.Number(value=0, label="Timestamp", visible=True, elem_id="hidden-timestamp")
+                
+                gpu_report_box = gr.HTML()
+                file_output = gr.File(label="📥 Download Video File")
+
+                noise_temperature_slider = gr.Slider(
+                    minimum=0.1, 
+                    maximum=2.0, 
+                    step=0.05, 
+                    value=1.0, 
+                    label="🌡️ Noise Temperature", 
+                    info="Scales initial noise variance (0.5 = focused & smooth, 1.0 = standard, 1.5 = high visual randomness, 0 GPU quota extra)."
+                )
+
+                with gr.Accordion("⚙️ Advanced Settings", open=False):
+                    custom_filename_input = gr.Textbox(
+                        label="Output Filename (Optional)",
+                        placeholder="e.g.: my_generated_video_01",
+                        value="",
+                        info="Saved as .mp4 format automatically. Leave blank for random name."
+                    )
+                    negative_prompt_input = gr.Textbox(label="Negative Prompt", value=config.default_negative_prompt, info="Active when Guidance Scale > 1.", lines=4, max_lines=8)
+                    
+                    with gr.Row():
+                        quality_slider = gr.Slider(minimum=1, maximum=10, step=1, value=6, label="Video Quality Grade")
+                        steps_slider = gr.Slider(minimum=1, maximum=30, step=1, value=4, label="Inference Steps")
+
+                    with gr.Row():
+                        seed_input = gr.Slider(label="Seed", minimum=0, maximum=config.MAX_SEED, step=1, value=42, interactive=True)
+                        randomize_seed_checkbox = gr.Checkbox(label="🎲 Randomize seed", value=True, interactive=True)
+
+                    with gr.Row():
+                        guidance_scale_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="Guidance Scale (High Noise)", info="Value > 1 increases GPU compute.")
+                        guidance_scale_2_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="Guidance Scale 2 (Low Noise)")
+
+                    with gr.Row():
+                        scheduler_dropdown = gr.Dropdown(
+                            label="Scheduler",
+                            choices=list(config.SCHEDULER_MAP.keys()),
+                            value="UniPCMultistep",
+                            info="Custom diffusion scheduler."
+                        )
+                        flow_shift_slider = gr.Slider(minimum=0.5, maximum=15.0, step=0.1, value=3.0, label="Flow Shift")
+
+                with gr.Accordion("🛠️ Standalone Image Face Swapper & GFPGAN Restoration Tool", open=False):
+                    with gr.Row():
+                        tool_target_img = gr.Image(type="pil", label="Target Image to Swap / Enhance", sources=["upload", "clipboard"], height=200)
+                        tool_ref_img = gr.Image(type="pil", label="Reference Face Image (Optional)", sources=["upload", "clipboard"], height=200)
+                    with gr.Row():
+                        tool_gender_dropdown = gr.Dropdown(
+                            choices=["Any / All Faces", "Female Faces Only", "Male Faces Only"],
+                            value="Any / All Faces",
+                            label="👥 Target Gender to Swap"
+                        )
+                        tool_gfpgan_checkbox = gr.Checkbox(
+                            label="✨ Enhance Face Detail (GFPGAN v1.4)",
+                            value=True,
+                            info="Sharpens blurry facial details via GFPGAN restoration"
+                        )
+                    with gr.Row():
+                        tool_swap_btn = gr.Button("🚀 Swap Single Image Face (API / CPU)", variant="primary")
+                        tool_enhance_only_btn = gr.Button("✨ Enhance Face Only (GFPGAN v1.4)", variant="secondary")
+
+                    tool_result_img = gr.Image(type="pil", label="Result Image (Swapped / Enhanced)", interactive=False, height=220)
+                    tool_send_btn = gr.Button("📸 Send Result Image to Main Video Input", variant="secondary")
+
+                    def run_standalone_swap(target_img, ref_img, gender, enhance_gfpgan):
+                        if target_img is None:
+                            raise gr.Error("Please upload a target image to swap.")
+                        return face_swapper.swap_face_in_single_image(target_img, ref_img, gender, enhance_with_gfpgan=enhance_gfpgan)
+
+                    def run_standalone_face_enhance(target_img):
+                        if target_img is None:
+                            raise gr.Error("Please upload an image to enhance.")
+                        res = face_swapper.call_sulphur_enhance_face_api(target_img)
+                        if res is None:
+                            raise gr.Error("Sulphur AI GFPGAN Face Enhance API is offline or not configured.")
+                        return res
+
+                    tool_swap_btn.click(
+                        fn=run_standalone_swap,
+                        inputs=[tool_target_img, tool_ref_img, tool_gender_dropdown, tool_gfpgan_checkbox],
+                        outputs=[tool_result_img]
+                    )
+
+                    tool_enhance_only_btn.click(
+                        fn=run_standalone_face_enhance,
+                        inputs=[tool_target_img],
+                        outputs=[tool_result_img]
+                    )
+
+                    tool_send_btn.click(
+                        fn=lambda img: img,
+                        inputs=[tool_result_img],
+                        outputs=[input_image_component]
+                    )
+
+                with gr.Accordion("💎 Remote VIP GPU RIFE Ultra Acceleration (Exclusive High-Speed Engine)", open=True):
+                    gr.HTML(load_template("rife_vip.html"))
+                    enable_vip_rife_checkbox = gr.Checkbox(
+                        label="⚡ Enable VIP Remote RIFE Acceleration (Bypasses Local CPU)",
+                        value=False,
+                        info="Offloads 2x, 4x, or 8x frame rate extension to dedicated VIP GPU server with 0 GPU load."
+                    )
+                    vip_password_input = gr.Textbox(
+                        label="🔑 VIP Password Access Key",
+                        type="password",
+                        placeholder="Enter VIP Password to unlock remote GPU RIFE",
+                        value="",
+                        info="Required to authorization remote GPU RIFE acceleration."
+                    )
+                    with gr.Row():
+                        vip_rife_multiplier_radio = gr.Radio(
+                            choices=["2x (32 FPS / 2x Duration)", "4x (64 FPS / 4x Duration)", "8x (128 FPS / 8x Duration)"],
+                            value="2x (32 FPS / 2x Duration)",
+                            label="🚀 VIP RIFE Multiplier",
+                            scale=3
+                        )
+                        vip_rife_mode_dropdown = gr.Dropdown(
+                            choices=[
+                                "High-FPS Motion Smoothness (FPS Boost)",
+                                "Slow-Motion / Extend Duration (Multiplied Seconds)"
+                            ],
+                            value="High-FPS Motion Smoothness (FPS Boost)",
+                            label="⚙️ VIP RIFE Output Mode",
+                            scale=3
+                        )
+
+        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,
+            motion_extension_dropdown,
+            safe_mode_checkbox,
+            custom_lora_url_input,
+            custom_lora_scale_input,
+            enable_prompt_relay_checkbox,
+            relay_prompt_schedule_input,
+            ref_face_component,
+            target_gender_dropdown,
+            play_result_video,
+            custom_filename_input,
+            noise_temperature_slider,
+            enable_vip_rife_checkbox,
+            vip_rife_multiplier_radio,
+            vip_rife_mode_dropdown,
+            vip_password_input
+        ]
+        
+        generate_button.click(
+            fn=generate_video, 
+            inputs=ui_inputs, 
+            outputs=[video_output, file_output, seed_input, gpu_report_box]
+        )
+
+        grab_frame_btn.click(
+            fn=extract_frame,
+            inputs=[video_output, timestamp_box],
+            outputs=[input_image_component, timestamp_box],
+            js=get_timestamp_js
+        )
+
+        grab_last_frame_btn.click(
+            fn=extract_frame,
+            inputs=[video_output, timestamp_box],
+            outputs=[last_image_component, timestamp_box],
+            js=get_timestamp_js
+        )
+
+        grab_swap_target_btn.click(
+            fn=extract_frame,
+            inputs=[video_output, timestamp_box],
+            outputs=[tool_target_img, timestamp_box],
+            js=get_timestamp_js
+        )
+
+        gr.HTML(load_template("footer.html"))
+
+    return demo