Update app.py

app.py

@@ -8,6 +8,15 @@ import torch.nn.functional as F
 import torchaudio
 import os
 from typing import Any
+import time
+from contextlib import contextmanager
+
+@contextmanager
+def timer(name: str):
+    start = time.time()
+    print(f"{name}...")
+    yield
+    print(f"  -> {name} completed in {time.time() - start:.2f} sec")
 
 def _coerce_audio_path(audio_path: Any) -> str:
     # Common Gradio case: tuple where first item is the filepath
@@ -25,6 +34,41 @@ def _coerce_audio_path(audio_path: Any) -> str:
 
     return os.fspath(audio_path)
 
+def extract_audio_wav_ffmpeg(video_path: str, target_sr: int = 48000) -> str | None:
+    """
+    Extract audio from a video into a temp WAV (mono, target_sr).
+    Returns path, or None if the video has no audio stream.
+    """
+    out_path = tempfile.NamedTemporaryFile(suffix=".wav", delete=False).name
+
+    # Check if there's an audio stream
+    probe_cmd = [
+        "ffprobe", "-v", "error",
+        "-select_streams", "a:0",
+        "-show_entries", "stream=codec_type",
+        "-of", "default=nw=1:nk=1",
+        video_path,
+    ]
+    try:
+        out = subprocess.check_output(probe_cmd).decode("utf-8").strip()
+        if not out:
+            return None
+    except subprocess.CalledProcessError:
+        return None
+
+    # Extract + resample + mono
+    cmd = [
+        "ffmpeg", "-y", "-v", "error",
+        "-i", video_path,
+        "-vn",
+        "-ac", "1",
+        "-ar", str(int(target_sr)),
+        "-c:a", "pcm_s16le",
+        out_path
+    ]
+    subprocess.check_call(cmd)
+    return out_path
+
 
 
 def match_audio_to_duration(
@@ -75,8 +119,6 @@ def match_audio_to_duration(
 
 def sh(cmd): subprocess.check_call(cmd, shell=True)
 
-sh("pip install --no-deps easy_dwpose")
-
 # Add packages to Python path
 current_dir = Path(__file__).parent
 sys.path.insert(0, str(current_dir / "packages" / "ltx-pipelines" / "src"))
@@ -118,8 +160,8 @@ from ltx_pipelines.utils import ModelLedger
 from ltx_pipelines.utils.helpers import generate_enhanced_prompt
 import imageio
 import cv2
-from controlnet_aux import CannyDetector
-from easy_dwpose import DWposeDetector
+from controlnet_aux import CannyDetector, MidasDetector
+from dwpose import DwposeDetector
 
 
 # HuggingFace Hub defaults
@@ -166,6 +208,9 @@ model_ledger = ModelLedger(
 )
 
 canny_processor = CannyDetector()
+# Depth (MiDaS) processor
+# Downloads annotator weights automatically the first time.
+depth_processor = MidasDetector.from_pretrained("lllyasviel/Annotators").to("cuda")
 
 
 # Load text encoder once and keep it in memory
@@ -186,7 +231,7 @@ def on_lora_change(selected: str):
 
 def process_video_for_pose(frames, width: int, height: int):
 
-    pose_processor = DWposeDetector("cuda")
+    pose_processor = DwposeDetector.from_pretrained_default()
 
     if not frames:
         return []
@@ -197,7 +242,7 @@ def process_video_for_pose(frames, width: int, height: int):
         pil = Image.fromarray(frame.astype(np.uint8)).convert("RGB")
 
         # ✅ do NOT pass width/height here (easy_dwpose will handle drawing sizes internally)
-        pose_img = pose_processor(pil)
+        pose_img = pose_processor(pil, include_body=True, include_hand=True, include_face=True)
 
         # Ensure it's PIL then resize to your conditioning size
         if not isinstance(pose_img, Image.Image):
@@ -219,6 +264,46 @@ def preprocess_video_to_pose_mp4(video_path: str, width: int, height: int, fps:
     tmp.close()
     return write_video_mp4(pose_frames, fps=fps, out_path=tmp.name)
 
+def process_video_for_depth(frames, width: int, height: int):
+    """
+    Convert RGB frames -> depth map frames.
+    Returns list of np arrays (H,W,3) float in [0..1] (controlnet-style).
+    """
+    if not frames:
+        return []
+
+    detect_resolution = max(frames[0].shape[0], frames[0].shape[1])
+    image_resolution = max(width, height)
+
+    depth_frames = []
+    for frame in frames:
+        # controlnet_aux MidasDetector returns float [0..1] when output_type="np"
+        depth = depth_processor(
+            frame,
+            detect_resolution=detect_resolution,
+            image_resolution=image_resolution,
+            output_type="np",
+        )
+
+        # Safety: ensure HWC and 3 channels (some versions may output 1ch)
+        if depth.ndim == 2:
+            depth = np.stack([depth, depth, depth], axis=-1)
+        elif depth.shape[-1] == 1:
+            depth = np.repeat(depth, 3, axis=-1)
+
+        depth_frames.append(depth)
+
+    return depth_frames
+
+
+def preprocess_video_to_depth_mp4(video_path: str, width: int, height: int, fps: float):
+    """End-to-end: read video -> depth -> write temp mp4 -> return path."""
+    frames = load_video_frames(video_path)
+    depth_frames = process_video_for_depth(frames, width=width, height=height)
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    tmp.close()
+    return write_video_mp4(depth_frames, fps=fps, out_path=tmp.name)
+
 
 def load_video_frames(video_path: str):
     """Return list of frames as numpy arrays (H,W,3) uint8."""
@@ -230,7 +315,7 @@ def load_video_frames(video_path: str):
 
 
 def process_video_for_canny(frames, width: int, height: int,
-                            low_threshold=50, high_threshold=200):
+                            low_threshold=20, high_threshold=60):
     """
     Convert RGB frames -> canny edge frames.
     Returns list of np arrays (H,W,3) in float [0..1] (like controlnet_aux output).
@@ -244,6 +329,8 @@ def process_video_for_canny(frames, width: int, height: int,
     canny_frames = []
     for frame in frames:
         # controlnet_aux CannyDetector returns float image in [0..1] if output_type="np"
+        # frame_blur = cv2.GaussianBlur(frame, (3, 3), 0)
+
         canny = canny_processor(
             frame,
             low_threshold=low_threshold,
@@ -277,6 +364,158 @@ def preprocess_video_to_canny_mp4(video_path: str, width: int, height: int, fps:
     tmp.close()
     return write_video_mp4(canny_frames, fps=fps, out_path=tmp.name)
 
+import json
+
+def probe_video_duration_seconds(video_path: str) -> float:
+    """Return duration in seconds using ffprobe."""
+    cmd = [
+        "ffprobe", "-v", "error",
+        "-select_streams", "v:0",
+        "-show_entries", "format=duration",
+        "-of", "json",
+        video_path,
+    ]
+    out = subprocess.check_output(cmd).decode("utf-8")
+    data = json.loads(out)
+    dur = float(data["format"]["duration"])
+    return dur
+
+def trim_video_to_seconds_ffmpeg(video_path: str, target_seconds: float, fps: float = None) -> str:
+    """
+    Trim video to [0, target_seconds]. Re-encode for accuracy & compatibility.
+    If fps is provided, also normalize fps.
+    Returns new temp mp4 path.
+    """
+    target_seconds = max(0.01, float(target_seconds))
+
+    out_path = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+
+    vf = []
+    if fps is not None:
+        vf.append(f"fps={float(fps)}")
+    vf_str = ",".join(vf) if vf else None
+
+    cmd = ["ffmpeg", "-y", "-v", "error"]
+
+    # Accurate trim: use -t and re-encode.
+    cmd += ["-i", video_path, "-t", f"{target_seconds:.6f}"]
+
+    if vf_str:
+        cmd += ["-vf", vf_str]
+
+    # Safe default encode
+    cmd += [
+        "-c:v", "libx264", "-pix_fmt", "yuv420p", "-preset", "veryfast", "-crf", "18",
+        "-an",  # conditioning video doesn't need audio
+        out_path
+    ]
+
+    subprocess.check_call(cmd)
+    return out_path
+
+def extract_first_frame_png(video_path: str) -> str:
+    """Extract first frame as png; returns png path."""
+    out_path = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
+    cmd = [
+        "ffmpeg", "-y", "-v", "error",
+        "-i", video_path,
+        "-frames:v", "1",
+        out_path
+    ]
+    subprocess.check_call(cmd)
+    return out_path
+
+def _coerce_video_path(video_path: Any) -> str:
+    if isinstance(video_path, tuple) and len(video_path) > 0:
+        video_path = video_path[0]
+    if isinstance(video_path, dict):
+        video_path = video_path.get("name") or video_path.get("path")
+    if not isinstance(video_path, (str, bytes, os.PathLike)):
+        raise TypeError(f"video_path must be a path-like, got {type(video_path)}: {video_path}")
+    return os.fspath(video_path)
+
+
+def prepare_conditioning_video_mp4(
+    video_path: Any,
+    target_num_frames: int,
+    target_fps: float,
+) -> tuple[str, str]:
+    """
+    Returns (conditioning_mp4_path, first_frame_png_path).
+
+    Makes an mp4 with exactly target_num_frames frames:
+    - if source has more -> truncate
+    - if source has fewer -> pad by repeating last frame
+    """
+    video_path = _coerce_video_path(video_path)
+
+    # Decode frames (robust / deterministic)
+    frames = load_video_frames(video_path)  # list of HWC uint8 frames
+    if not frames:
+        raise ValueError("No frames decoded from input video")
+
+    # Truncate or pad to exact length
+    if len(frames) >= target_num_frames:
+        frames = frames[:target_num_frames]
+    else:
+        last = frames[-1]
+        frames = frames + [last] * (target_num_frames - len(frames))
+
+    # Save first frame as PNG (for input_image)
+    first_png = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
+    Image.fromarray(frames[0]).save(first_png)
+
+    # Write conditioning mp4
+    # write_video_mp4 expects float [0..1]
+    frames_float = [f.astype(np.float32) / 255.0 for f in frames]
+    cond_mp4 = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+    write_video_mp4(frames_float, fps=target_fps, out_path=cond_mp4)
+
+    return cond_mp4, first_png
+
+def valid_1_plus_8k(n: int) -> int:
+    """Largest integer <= n that is of the form 1 + 8*k (k>=0)."""
+    if n <= 0:
+        return 0
+    return 1 + 8 * ((n - 1) // 8)
+
+def prepare_conditioning_video_mp4_no_pad(
+    video_path: Any,
+    duration_frames: int,
+    target_fps: float,
+) -> tuple[str, str, int]:
+    """
+    Returns (conditioning_mp4_path, first_frame_png_path, used_num_frames)
+
+    - Decodes source frames
+    - Trims to the largest valid length (1 + 8*k) <= source length
+    - NEVER pads / loops / repeats last frame
+    """
+    video_path = _coerce_video_path(video_path)
+
+    frames = load_video_frames(video_path)  # list of HWC uint8
+    if not frames:
+        raise ValueError("No frames decoded from input video")
+
+    n_src = len(frames)
+    n_src = min(n_src, duration_frames)
+    n_used = valid_1_plus_8k(n_src)
+
+    # If the video is extremely short (e.g. 1 frame), n_used can be 1 which is valid.
+    if n_used == 0:
+        raise ValueError(f"Video too short: {n_src} frames")
+
+    frames = frames[:n_used]
+
+    first_png = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
+    Image.fromarray(frames[0]).save(first_png)
+
+    frames_float = [f.astype(np.float32) / 255.0 for f in frames]
+    cond_mp4 = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False).name
+    write_video_mp4(frames_float, fps=target_fps, out_path=cond_mp4)
+
+    return cond_mp4, first_png, n_used
+
 
 def encode_text_simple(text_encoder, prompt: str):
     """Simple text encoding without using pipeline_utils."""
@@ -420,6 +659,13 @@ detailer_lora_path = get_hub_or_local_checkpoint(
     "ltx-2-19b-ic-lora-detailer.safetensors",
 )
 
+pose_lora_path = get_hub_or_local_checkpoint(
+    "Lightricks/LTX-2-19b-IC-LoRA-Pose-Control",
+    "ltx-2-19b-ic-lora-pose-control.safetensors",
+)
+
+
+
 # Load distilled LoRA as a regular LoRA
 loras = [
     # --- fused / base behavior ---
@@ -436,9 +682,22 @@ loras = [
     LoraPathStrengthAndSDOps(dolly_right_lora_path, DEFAULT_LORA_STRENGTH, LTXV_LORA_COMFY_RENAMING_MAP),
     LoraPathStrengthAndSDOps(jib_down_lora_path,    DEFAULT_LORA_STRENGTH, LTXV_LORA_COMFY_RENAMING_MAP),
     LoraPathStrengthAndSDOps(jib_up_lora_path,      DEFAULT_LORA_STRENGTH, LTXV_LORA_COMFY_RENAMING_MAP),
+    LoraPathStrengthAndSDOps(pose_lora_path,        DEFAULT_LORA_STRENGTH, LTXV_LORA_COMFY_RENAMING_MAP),
 ]
 
 # Runtime-toggle LoRAs (exclude fused distilled at index 0)
+VISIBLE_RUNTIME_LORA_CHOICES = [
+    ("No LoRA", -1),
+    ("Static", 0),
+    ("Detailer", 1),
+    ("Zoom In", 2),
+    ("Zoom Out", 3),
+    ("Slide Left", 4),
+    ("Slide Right", 5),
+    ("Slide Down", 6),
+    ("Slide Up", 7),
+]
+
 RUNTIME_LORA_CHOICES = [
     ("No LoRA", -1),
     ("Static", 0),
@@ -449,7 +708,7 @@ RUNTIME_LORA_CHOICES = [
     ("Slide Right", 5),
     ("Slide Down", 6),
     ("Slide Up", 7),
-    
+    ("Pose", 8),
 ]
 
 # Initialize pipeline WITHOUT text encoder (gemma_root=None)
@@ -556,6 +815,18 @@ class RadioAnimated(gr.HTML):
 
             // Recalc on resize (important in Gradio layouts)
             window.addEventListener('resize', () => setHighlightByIndex(currentIdx));
+
+            // sync from Python (Examples / backend updates)
+            let last = props.value;
+            const syncFromProps = () => {
+              if (props.value !== last) {
+                last = props.value;
+                setCheckedByValue(last, false);
+              }
+              requestAnimationFrame(syncFromProps);
+            };
+            requestAnimationFrame(syncFromProps);
+
         })();
 
         """
@@ -818,30 +1089,34 @@ class CameraDropdown(gr.HTML):
             **kwargs
         )
 
-def generate_video_example(input_image, prompt, camera_lora, resolution, audio_path = None, progress=gr.Progress(track_tqdm=True)):
+def generate_video_example(input_image, prompt, camera_lora, resolution, radioanimated_mode, input_video, input_audio, progress=gr.Progress(track_tqdm=True)):
 
     w, h = apply_resolution(resolution)
 
-    output_video = generate_video(
-        input_image,
-        prompt,
-        10,                      # duration seconds
-        True,                    # enhance_prompt
-        42,                      # seed
-        True,                    # randomize_seed
-        h,  # height
-        w,   # width
-        camera_lora,     
-        audio_path,
-        progress
-    )
-
+    with timer(f'generating with video path:{input_video} with duration:{duration} and LoRA:{camera_lora} in {w}x{h}'):
+        output_video = generate_video(
+            input_image,
+            prompt,
+            10,
+            input_video,
+            radioanimated_mode,
+            True,                    
+            42,                      
+            True,                    
+            h,  
+            w,   
+            camera_lora,     
+            input_audio,
+            progress
+        )
     return output_video
 
 def get_duration(
     input_image,
     prompt,
     duration,
+    input_video,
+    radioanimated_mode,
     enhance_prompt,
     seed,
     randomize_seed,
@@ -856,6 +1131,9 @@ def get_duration(
     if audio_path is not None:
         extra_time += 10
 
+    if input_video is not None:
+        extra_time += 60
+
     if duration <= 3:
         return 60 + extra_time
     elif duration <= 5:
@@ -865,11 +1143,14 @@ def get_duration(
     else:
         return 180 + extra_time
     
+    
 @spaces.GPU(duration=get_duration)
 def generate_video(
     input_image,
     prompt: str,
     duration: float,
+    input_video = None,
+    generation_mode = "Image-to-Video",
     enhance_prompt: bool = True,
     seed: int = 42,
     randomize_seed: bool = True,
@@ -885,6 +1166,7 @@ def generate_video(
         input_image: Optional input image for image-to-video. If provided, it is injected at frame 0 to guide motion.
         prompt: Text description of the scene, motion, and cinematic style to generate.
         duration: Desired video length in seconds. Converted to frames using a fixed 24 FPS rate.
+        input_video: Optional conditioning video path (mp4). If provided, motion is guided by this video.
         enhance_prompt: Whether to enhance the prompt using the prompt enhancer before encoding.
         seed: Base random seed for reproducibility (ignored if randomize_seed is True).
         randomize_seed: If True, a random seed is generated for each run.
@@ -920,12 +1202,42 @@ def generate_video(
     # Calculate num_frames from duration (using fixed 24 fps)
     frame_rate = 24.0
     num_frames = int(duration * frame_rate) + 1  # +1 to ensure we meet the duration
+    video_seconds = int(duration)
 
     with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
         output_path = tmpfile.name
 
 
     images = []
+    videos = []
+
+    if generation_mode == "Motion Control":
+        if input_video is not None:
+            cond_mp4, first_png, used_frames = prepare_conditioning_video_mp4_no_pad(
+                video_path=input_video,
+                duration_frames=num_frames,
+                target_fps=frame_rate,
+            )
+
+            if input_image is None:
+                images = [(first_png, 0, 1.0)]
+
+            if audio_path is None:
+                src_video_path = _coerce_video_path(input_video)
+                extracted_audio_tmp = extract_audio_wav_ffmpeg(src_video_path, target_sr=48000)
+                
+                if extracted_audio_tmp is not None:
+                    audio_path = extracted_audio_tmp
+
+            with timer("Pose selected: preprocessing conditioning video to pose..."):
+                cond_path = preprocess_video_to_pose_mp4(
+                    video_path=cond_mp4,
+                    width=width,
+                    height=height,
+                    fps=frame_rate,
+                )
+            videos = [(cond_path, 1.0)]
+            camera_lora = "Pose"
 
     if input_image is not None:
         images = [(input_image, 0, 1.0)]
@@ -955,7 +1267,9 @@ def generate_video(
             _, n_audio_context = encode_text_simple(text_encoder, "")  # returns tensors on GPU already
             del audio_context
             audio_context = n_audio_context
-        camera_lora = "Static"
+
+        if len(videos) == 0:
+            camera_lora = "Static"
 
     torch.cuda.empty_cache()
 
@@ -982,23 +1296,24 @@ def generate_video(
         input_waveform = None
         input_waveform_sample_rate = None
 
-    # Run inference - progress automatically tracks tqdm from pipeline
-    with torch.inference_mode():
-        pipeline(
-            prompt=prompt,
-            output_path=str(output_path),
-            seed=current_seed,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            frame_rate=frame_rate,
-            images=images,
-            tiling_config=TilingConfig.default(),
-            video_context=video_context,
-            audio_context=audio_context,
-            input_waveform=input_waveform,
-            input_waveform_sample_rate=input_waveform_sample_rate, 
-        )
+    with timer(f'generating with video path:{input_video} and LoRA:{camera_lora} in {width}x{height}'):
+        with torch.inference_mode():
+            pipeline(
+                prompt=prompt,
+                output_path=str(output_path),
+                seed=current_seed,
+                height=height,
+                width=width,
+                num_frames=num_frames,
+                frame_rate=frame_rate,
+                images=images,
+                video_conditioning=videos,
+                tiling_config=TilingConfig.default(),
+                video_context=video_context,
+                audio_context=audio_context,
+                input_waveform=input_waveform,
+                input_waveform_sample_rate=input_waveform_sample_rate, 
+            )
     del video_context, audio_context
     torch.cuda.empty_cache()
     print("successful generation")
@@ -1022,6 +1337,12 @@ def apply_duration(duration: str):
     duration_s = int(duration[:-1])
     return duration_s
 
+def on_mode_change(selected: str):
+    is_i2v = (selected == "Image-to-Video")
+
+    return gr.update(visible=not is_i2v)
+
+
 
 css = """
 
@@ -1130,6 +1451,45 @@ css = """
     #false:checked ~ .toggle-highlight {
     transform: translateX(100%);
     }
+
+    /* Center items inside that row */
+    #mode-row{
+      justify-content: center !important;
+      align-items: center !important;
+    }
+    
+    /* Center the mode row contents */
+    #mode-row {
+      display: flex !important;
+      justify-content: center !important;
+      align-items: center !important;
+      width: 100% !important;
+    }
+    
+    /* Stop Gradio from making children stretch */
+    #mode-row > * {
+      flex: 0 0 auto !important;
+      width: auto !important;
+      min-width: 0 !important;
+    }
+    
+    /* Specifically ensure the HTML component wrapper doesn't take full width */
+    #mode-row .gr-html,
+    #mode-row .gradio-html,
+    #mode-row .prose,
+    #mode-row .block {
+      width: auto !important;
+      flex: 0 0 auto !important;
+      display: inline-block !important;
+    }
+    
+    /* Center the pill itself */
+    #radioanimated_mode {
+      display: inline-flex !important;
+      justify-content: center !important;
+      width: auto !important;
+    }
+
     """
 
 css += """
@@ -1678,15 +2038,27 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
         """
     )
     with gr.Column(elem_id="col-container"):
+        with gr.Row(elem_id="mode-row"):
+            radioanimated_mode = RadioAnimated(
+                choices=["Image-to-Video", "Motion Control"],
+                value="Image-to-Video",
+                elem_id="radioanimated_mode"
+            )
         with gr.Row():
             with gr.Column(elem_id="step-column"):
-            
+ 
                 input_image = gr.Image(
                     label="First Frame (Optional)",
                     type="filepath",
                     height=256
                 )
 
+                input_video = gr.Video(
+                    label="Motion Reference Video",
+                    height=256,
+                    visible=False,
+                )
+
                 relocate = gr.HTML(
                     value="",
                     html_template="<div></div>",
@@ -1757,7 +2129,7 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                         
             with gr.Column(elem_id="step-column"):
                 output_video = gr.Video(label="Generated Video", autoplay=True, height=512)
-            
+
                 with gr.Row(elem_id="controls-row"):
                         
                         duration_ui = CameraDropdown(
@@ -1805,7 +2177,7 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                         height = gr.Number(label="Height", value=DEFAULT_1_STAGE_HEIGHT, precision=0, visible=False)   
 
                         camera_ui = CameraDropdown(
-                            choices=[name for name, _ in RUNTIME_LORA_CHOICES],
+                            choices=[name for name, _ in VISIBLE_RUNTIME_LORA_CHOICES],
                             value="No LoRA",
                             title="Camera LoRA",
                             elem_id="camera_ui",
@@ -1814,7 +2186,7 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                         # Hidden real dropdown (backend value)
                         camera_lora = gr.Dropdown(
                             label="Camera Control LoRA",
-                            choices=[name for name, _ in RUNTIME_LORA_CHOICES],
+                            choices=[name for name, _ in VISIBLE_RUNTIME_LORA_CHOICES],
                             value="No LoRA",
                             visible=False
                         )
@@ -1828,6 +2200,14 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
         api_visibility="private"
     )
 
+    radioanimated_mode.change(
+    fn=on_mode_change,
+        inputs=radioanimated_mode,
+        outputs=[input_video],
+        api_visibility="private",
+    )
+
+
     duration_ui.change(
         fn=apply_duration,
         inputs=duration_ui,
@@ -1854,6 +2234,8 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
             input_image,
             prompt,
             duration,
+            input_video,
+            radioanimated_mode,
             enhance_prompt,
             seed,
             randomize_seed,
@@ -1873,6 +2255,8 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                 "A fuzzy puppet superhero character resembling a female puppet with blonde hair and a blue superhero suit sleeping in bed and just waking up, she gradually gets up, rubbing her eyes and looking at her dog that just popped on the bed. the scene feels chaotic, comedic, and emotional with expressive puppet reactions, cinematic lighting, smooth camera motion, shallow depth of field, and high-quality puppet-style animation",
                 "Static",
                 "16:9",
+                "Image-to-Video",
+                None,
                 "supergirl.m4a"
             ],
             [
@@ -1880,13 +2264,35 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                 "A fuzzy puppet superhero character resembling a female puppet with blonde hair and a blue superhero suit stands inside an icy cave made of frozen walls and icicles, she looks panicked and frantic, rapidly turning her head left and right and scanning the cave while waving her arms and shouting angrily and desperately, mouthing the words “where the hell is my dog,” her movements exaggerated and puppet-like with high energy and urgency, suddenly a second puppet dog bursts into frame from the side, jumping up excitedly and tackling her affectionately while licking her face repeatedly, she freezes in surprise and then breaks into relief and laughter as the dog continues licking her, the scene feels chaotic, comedic, and emotional with expressive puppet reactions, cinematic lighting, smooth camera motion, shallow depth of field, and high-quality puppet-style animation",
                 "No LoRA",
                 "16:9",
+                "Image-to-Video",
+                None,
+                None,
+            ],
+            [
+                "clay.png",
+                "a character doing a tiktok dance by moving their heads side to side with dramatic lighting and cinematic effects and singing",
+                "Pose",
+                "9:16",
+                "Motion Control",
+                "tiktok.mp4",
                 None,
             ],
+            [
+                "paint.png",
+                "a character doing a tiktok dance by moving their heads side to side with dramatic lighting and cinematic effects and singing",
+                "Pose",
+                "9:16",
+                "Motion Control",
+                "tiktok.mp4",
+                None,
+            ], 
             [
                 "highland.png",
                 "Realistic POV selfie-style video in a snowy, foggy field. Two shaggy Highland cows with long curved horns stand ahead. The camera is handheld and slightly shaky. The woman filming talks nervously and excitedly in a vlog tone: \"Oh my god guys… look how big those horns are… I’m kinda scared.\" The cow on the left walks toward the camera in a cute, bouncy, hopping way, curious and gentle. Snow crunches under its hooves, breath visible in the cold air. The horns look massive from the POV. As the cow gets very close, its wet nose with slight dripping fills part of the frame. She laughs nervously but reaches out and pets the cow. The cow makes deep, soft, interesting mooing and snorting sounds, calm and friendly. Ultra-realistic, natural lighting, immersive audio, documentary-style realism.",
                 "No LoRA",
                 "16:9",
+                "Image-to-Video",
+                None,
                 None,
             ],
             [
@@ -1894,6 +2300,8 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                 "A cinematic dolly out of Wednesday Addams frozen mid-dance on a dark, blue-lit ballroom floor as students move indistinctly behind her, their footsteps and muffled music reduced to a distant, underwater thrum; the audio foregrounds her steady breathing and the faint rustle of fabric as she slowly raises one arm, never breaking eye contact with the camera, then after a deliberately long silence she speaks in a flat, dry, perfectly controlled voice, “I don’t dance… I vibe code,” each word crisp and unemotional, followed by an abrupt cutoff of her voice as the background sound swells slightly, reinforcing the deadpan humor, with precise lip sync, minimal facial movement, stark gothic lighting, and cinematic realism.",
                  "Zoom Out",
                 "16:9",
+                "Image-to-Video",
+                None,
                 None,
             ],
             [
@@ -1901,15 +2309,15 @@ with gr.Blocks(title="LTX-2 Video Distilled 🎥🔈") as demo:
                 "An astronaut hatches from a fragile egg on the surface of the Moon, the shell cracking and peeling apart in gentle low-gravity motion. Fine lunar dust lifts and drifts outward with each movement, floating in slow arcs before settling back onto the ground. The astronaut pushes free in a deliberate, weightless motion, small fragments of the egg tumbling and spinning through the air. In the background, the deep darkness of space subtly shifts as stars glide with the camera's movement, emphasizing vast depth and scale. The camera performs a smooth, cinematic slow push-in, with natural parallax between the foreground dust, the astronaut, and the distant starfield. Ultra-realistic detail, physically accurate low-gravity motion, cinematic lighting, and a breath-taking, movie-like shot.",
                 "Static",
                 "1:1",
+                "Image-to-Video",
+                None,
                 None,
             ],
-
-            
         ],
         fn=generate_video_example,
-        inputs=[input_image, prompt_ui, camera_ui, resolution_ui, audio_input],
+        inputs=[input_image, prompt_ui, camera_ui, resolution_ui, radioanimated_mode, input_video, audio_input],
         outputs = [output_video],
-        label="I2V Examples",
+        label="Examples",
         cache_examples=True,
     )