import gradio as gr from gradio import update as gr_update import subprocess import threading import time import re import os import random import tiktoken import sys import ffmpeg from typing import List, Tuple, Optional, Generator, Dict, Any import json from gradio import themes from gradio.themes.utils import colors import subprocess from PIL import Image import math import cv2 import glob import shutil from pathlib import Path import logging from datetime import datetime from tqdm import tqdm from diffusers_helper.bucket_tools import find_nearest_bucket import time import spaces # Add global stop event stop_event = threading.Event() skip_event = threading.Event() logger = logging.getLogger(__name__) def refresh_lora_dropdowns_simple(lora_folder: str) -> List[gr.update]: """Refreshes LoRA choices, always defaulting the selection to 'None'.""" new_choices = get_lora_options(lora_folder) results = [] print(f"Refreshing LoRA dropdowns. Found choices: {new_choices}") # Debug print for i in range(4): # Update all 4 slots results.extend([ gr.update(choices=new_choices, value="None"), # Always reset value to None gr.update(value=1.0) # Reset multiplier ]) return results def process_framepack_extension_video( input_video: str, prompt: str, negative_prompt: str, seed: int, batch_count: int, fpe_use_normal_framepack: bool, fpe_end_frame: Optional[str], fpe_end_frame_weight: float, resolution_max_dim: int, total_second_length: float, latent_window_size: int, steps: int, cfg_scale: float, # Maps to --cfg distilled_guidance_scale: float, # Maps to --gs # rs_scale: float, # --rs, usually 0.0, can be fixed or advanced option gpu_memory_preservation: float, use_teacache: bool, no_resize: bool, mp4_crf: int, num_clean_frames: int, vae_batch_size: int, save_path: str, # Maps to --output_dir # Model Paths fpe_transformer_path: str, # DiT fpe_vae_path: str, fpe_text_encoder_path: str, # TE1 fpe_text_encoder_2_path: str, # TE2 fpe_image_encoder_path: str, # Advanced performance fpe_attn_mode: str, fpe_fp8_llm: bool, fpe_vae_chunk_size: Optional[int], fpe_vae_spatial_tile_sample_min_size: Optional[int], # LoRAs fpe_lora_folder: str, fpe_lora_weight_1: str, fpe_lora_mult_1: float, fpe_lora_weight_2: str, fpe_lora_mult_2: float, fpe_lora_weight_3: str, fpe_lora_mult_3: float, fpe_lora_weight_4: str, fpe_lora_mult_4: float, # Preview fpe_enable_preview: bool, fpe_preview_interval: int, # This arg is not used by f1_video_cli_local.py fpe_extension_only: bool, fpe_start_guidance_image: Optional[str], fpe_start_guidance_image_clip_weight: float, fpe_use_guidance_image_as_first_latent: bool, *args: Any # For future expansion or unmapped params, not strictly needed here ) -> Generator[Tuple[List[Tuple[str, str]], Optional[str], str, str], None, None]: global stop_event, skip_event stop_event.clear() skip_event.clear() # Assuming skip_event might be used for batch items if not input_video or not os.path.exists(input_video): yield [], None, "Error: Input video for extension not found.", "" return if not save_path or not save_path.strip(): save_path = "outputs/framepack_extensions" # Default save path for extensions os.makedirs(save_path, exist_ok=True) # Prepare LoRA arguments lora_weights_paths = [] lora_multipliers_values = [] lora_params_ui = [ (fpe_lora_weight_1, fpe_lora_mult_1), (fpe_lora_weight_2, fpe_lora_mult_2), (fpe_lora_weight_3, fpe_lora_mult_3), (fpe_lora_weight_4, fpe_lora_mult_4) ] if fpe_lora_folder and os.path.exists(fpe_lora_folder): for weight_name, mult_val in lora_params_ui: if weight_name and weight_name != "None": lora_path = os.path.join(fpe_lora_folder, weight_name) if os.path.exists(lora_path): lora_weights_paths.append(lora_path) lora_multipliers_values.append(str(mult_val)) else: print(f"Warning: LoRA file not found: {lora_path}") all_generated_videos = [] script_to_use = "f_video_end_cli_local.py" if fpe_use_normal_framepack else "f1_video_cli_local.py" model_type_str = "Normal FramePack" if fpe_use_normal_framepack else "FramePack F1" print(f"Using {model_type_str} model for extension via script: {script_to_use}") for i in range(batch_count): if stop_event.is_set(): yield all_generated_videos, None, "Generation stopped by user.", "" return skip_event.clear() current_seed_val = seed if seed == -1: current_seed_val = random.randint(0, 2**32 - 1) elif batch_count > 1: current_seed_val = seed + i # This run_id is not directly used for preview file naming by f1_video_cli_local.py # as it constructs its own job_id based filenames for section previews. # run_id = f"{int(time.time())}_{random.randint(1000, 9999)}_ext_s{current_seed_val}" current_preview_yield_path = None last_preview_section_processed = -1 status_text = f"Processing Extension {i + 1}/{batch_count} (Seed: {current_seed_val})" progress_text = "Preparing extension subprocess..." yield all_generated_videos, current_preview_yield_path, status_text, progress_text command = [ sys.executable, script_to_use, "--input_video", str(input_video), "--prompt", str(prompt), "--n_prompt", str(negative_prompt), "--seed", str(current_seed_val), "--resolution_max_dim", str(resolution_max_dim), "--total_second_length", str(total_second_length), # Script uses this for *additional* length "--latent_window_size", str(latent_window_size), "--steps", str(steps), "--cfg", str(cfg_scale), "--gs", str(distilled_guidance_scale), "--rs", "0.0", "--gpu_memory_preservation", str(gpu_memory_preservation), "--mp4_crf", str(mp4_crf), "--num_clean_frames", str(num_clean_frames), "--vae_batch_size", str(vae_batch_size), "--output_dir", str(save_path), "--dit", str(fpe_transformer_path), "--vae", str(fpe_vae_path), "--text_encoder1", str(fpe_text_encoder_path), "--text_encoder2", str(fpe_text_encoder_2_path), "--image_encoder", str(fpe_image_encoder_path), "--attn_mode", str(fpe_attn_mode), ] if use_teacache: command.append("--use_teacache") if no_resize: command.append("--no_resize") if fpe_fp8_llm: command.append("--fp8_llm") # Though F1 script might not use this if fpe_vae_chunk_size is not None and fpe_vae_chunk_size > 0: command.extend(["--vae_chunk_size", str(fpe_vae_chunk_size)]) if fpe_vae_spatial_tile_sample_min_size is not None and fpe_vae_spatial_tile_sample_min_size > 0: command.extend(["--vae_spatial_tile_sample_min_size", str(fpe_vae_spatial_tile_sample_min_size)]) if lora_weights_paths: command.extend(["--lora_weight"] + lora_weights_paths) command.extend(["--lora_multiplier"] + lora_multipliers_values) if fpe_extension_only: command.append("--extension_only") # Script-specific arguments if fpe_use_normal_framepack: if fpe_fp8_llm: # Normal FP script uses this command.append("--fp8_llm") if fpe_end_frame and os.path.exists(fpe_end_frame): command.extend(["--end_frame", str(fpe_end_frame)]) command.extend(["--end_frame_weight", str(fpe_end_frame_weight)]) else: if fpe_start_guidance_image and os.path.exists(fpe_start_guidance_image): command.extend(["--start_guidance_image", str(fpe_start_guidance_image)]) command.extend(["--start_guidance_image_clip_weight", str(fpe_start_guidance_image_clip_weight)]) if fpe_use_guidance_image_as_first_latent: command.append("--use_guidance_image_as_first_latent") env = os.environ.copy() env["PYTHONUNBUFFERED"] = "1" print(f"Running FramePack-Extension Command: {' '.join(command)}") process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, env=env, bufsize=1, universal_newlines=True) # Regex patterns based on script if fpe_use_normal_framepack: # This means f_video_end_cli_local.py was used final_video_path_regex = re.compile(r"Final (?:extended video saved:|extension-only video saved:) (.*\.mp4)") # Regex for "--- Generating Extension: ... Section X / Y (backward) ---" fpe_section_progress_regex = re.compile(r"--- Generating Extension: .*?: Section\s+(\d+)\s*/\s*(\d+)\s+\(backward\)") tqdm_cli_progress_regex = re.compile(r"Sampling Extension Section .*?:\s*(\d+)%\|.*?\|\s*(\d+/\d+)\s*\[([^<]+)<([^,]+),") else: # F1 script (f1_video_cli_local.py) was used final_video_path_regex = re.compile(r"Final (?:extension-only )?video for seed \d+.*? saved as: (.*\.mp4)") fpe_section_progress_regex = re.compile(r"--- F1 Extension: .*?: Section (\d+)\s*/\s*(\d+) ---") tqdm_cli_progress_regex = re.compile(r"Sampling Extension Section .*?:\s*(\d+)%\|.*?\|\s*(\d+/\d+)\s*\[([^<]+)<([^,]+),") fpe_preview_saved_regex = re.compile(r"MP4 Preview for section (\d+) saved: (.*\.mp4)") current_video_file_for_item = None current_section_being_processed = 0 total_sections_from_log = 0 for line in iter(process.stdout.readline, ''): if stop_event.is_set(): try: process.terminate() process.wait(timeout=5) except subprocess.TimeoutExpired: process.kill(); process.wait() except Exception as e: print(f"Error terminating FPE subprocess: {e}") yield all_generated_videos, None, "Generation stopped by user.", "" return if skip_event.is_set() and batch_count > 1: print(f"Skip signal received for FPE batch item {i+1}. Terminating subprocess...") try: process.terminate() process.wait(timeout=5) except subprocess.TimeoutExpired: process.kill(); process.wait() except Exception as e: print(f"Error terminating FPE subprocess during skip: {e}") skip_event.clear() yield all_generated_videos, current_preview_yield_path, f"Skipping FPE item {i+1}/{batch_count}...", "" break line_strip = line.strip() if not line_strip: continue print(f"FPE_SUBPROCESS: {line_strip}") progress_text_update = line_strip section_match = fpe_section_progress_regex.search(line_strip) tqdm_match_cli = tqdm_cli_progress_regex.search(line_strip) final_video_match = final_video_path_regex.search(line_strip) preview_saved_match = fpe_preview_saved_regex.search(line_strip) if preview_saved_match and fpe_enable_preview: saved_section_num = int(preview_saved_match.group(1)) preview_mp4_path_from_log = preview_saved_match.group(2).strip() if os.path.exists(preview_mp4_path_from_log) and saved_section_num > last_preview_section_processed: current_preview_yield_path = preview_mp4_path_from_log # Yield clean path last_preview_section_processed = saved_section_num print(f"DEBUG FPE: MP4 Preview updated from log - {current_preview_yield_path}") # This log usually comes *after* the section info, so status might already be updated if section_match: current_section_being_processed = int(section_match.group(1)) total_sections_from_log = int(section_match.group(2)) status_text = f"Extending Video {i + 1}/{batch_count} (Seed: {current_seed_val}) - Section {current_section_being_processed}/{total_sections_from_log}" progress_text_update = f"Starting Section {current_section_being_processed}..." # Fallback logic for preview (if enabled and explicit log was missed) # This is less likely to be needed if fpe_preview_saved_regex is robust if fpe_enable_preview and current_section_being_processed > 1: section_to_check_for_preview = current_section_being_processed - 1 if section_to_check_for_preview > last_preview_section_processed: # Construct the expected preview filename based on f1_video_cli_local.py's naming # It uses a job_id that includes seed, resolution, etc. We don't know the exact job_id here. # Relying on "MP4 Preview for section X saved:" log is more reliable. # For a fallback, we could glob for *partX*.mp4, but that's risky. # For now, this fallback is removed as the primary log line should be sufficient. pass elif tqdm_match_cli: percentage = tqdm_match_cli.group(1) steps_iter_total = tqdm_match_cli.group(2) time_elapsed = tqdm_match_cli.group(3).strip() time_remaining = tqdm_match_cli.group(4).strip() # Ensure total_sections_from_log is not zero before using in f-string total_sections_display = total_sections_from_log if total_sections_from_log > 0 else "?" progress_text_update = f"Section {current_section_being_processed}/{total_sections_display} - Step {steps_iter_total} ({percentage}%) | ETA: {time_remaining}" status_text = f"Extending Video {i + 1}/{batch_count} (Seed: {current_seed_val}) - Sampling Section {current_section_being_processed}" elif final_video_match: found_video_path = final_video_match.group(1).strip() if os.path.exists(found_video_path): current_video_file_for_item = found_video_path progress_text_update = f"Finalizing: {os.path.basename(current_video_file_for_item)}" status_text = f"Extension {i + 1}/{batch_count} (Seed: {current_seed_val}) - Saved" else: print(f"Warning FPE: Final video path from log not found: {found_video_path}") yield all_generated_videos, current_preview_yield_path, status_text, progress_text_update process.stdout.close() return_code = process.wait() if return_code == 0 and current_video_file_for_item and os.path.exists(current_video_file_for_item): all_generated_videos.append((current_video_file_for_item, f"Extended - Seed: {current_seed_val}")) status_text = f"Extension {i + 1}/{batch_count} (Seed: {current_seed_val}) - Completed and Added" progress_text = f"Saved: {os.path.basename(current_video_file_for_item)}" yield all_generated_videos.copy(), None, status_text, progress_text # Clear preview after item completion elif return_code != 0: status_text = f"Extension {i + 1}/{batch_count} (Seed: {current_seed_val}) - Failed (Code: {return_code})" progress_text = f"Subprocess failed. Check console for errors from f1_video_cli_local.py" yield all_generated_videos.copy(), None, status_text, progress_text else: # rc == 0 but no video path status_text = f"Extension {i + 1}/{batch_count} (Seed: {current_seed_val}) - Finished, but no video file confirmed." progress_text = "Check console logs from f1_video_cli_local.py for the saved path." yield all_generated_videos.copy(), None, status_text, progress_text # The F1 script already cleans up its intermediate _partX files. # No need for unique_preview_suffix based cleanup here for FPE. yield all_generated_videos, None, "FramePack-Extension Batch complete.", "" def set_random_seed(): """Returns -1 to set the seed input to random.""" return -1 def get_step_from_preview_path(path): # Helper function # Extracts step number from preview filenames like latent_preview_step_005.mp4 # or for framepack: latent_preview_section_002.mp4 (assuming sections for framepack) # Let's adjust for potential FramePack naming convention (using 'section' instead of 'step') base = os.path.basename(path) match_step = re.search(r"step_(\d+)", base) if match_step: return int(match_step.group(1)) match_section = re.search(r"section_(\d+)", base) # Check for FramePack section naming if match_section: # Maybe treat sections differently? Or just return the number? Let's return number. return int(match_section.group(1)) return -1 # Default if no number found @spaces.GPU(duration=1000) def process_framepack_video( prompt: str, negative_prompt: str, input_image: str, # Start image path input_end_frame: Optional[str], # End image path end_frame_influence: str, end_frame_weight: float, transformer_path: str, vae_path: str, text_encoder_path: str, text_encoder_2_path: str, image_encoder_path: str, target_resolution: Optional[int], framepack_width: Optional[int], framepack_height: Optional[int], original_dims_str: str, # This comes from framepack_original_dims state total_second_length: float, framepack_video_sections: Optional[int], fps: int, seed: int, steps: int, distilled_guidance_scale: float, cfg: float, rs: float, sample_solver: str, latent_window_size: int, fp8: bool, fp8_scaled: bool, fp8_llm: bool, blocks_to_swap: int, bulk_decode: bool, attn_mode: str, vae_chunk_size: Optional[int], vae_spatial_tile_sample_min_size: Optional[int], device: Optional[str], use_teacache: bool, teacache_steps: int, teacache_thresh: float, batch_size: int, save_path: str, lora_folder: str, enable_preview: bool, preview_every_n_sections: int, use_full_video_preview: bool, is_f1: bool, use_random_folder: bool, input_folder_path: str, *args: Any ) -> Generator[Tuple[List[Tuple[str, str]], Optional[str], str, str], None, None]: """Generate video using fpack_generate_video.py""" global stop_event stop_event.clear() if not save_path or not save_path.strip(): print("Warning: save_path was empty, defaulting to 'outputs'") save_path = "outputs" num_section_controls = 4 num_loras = 4 secs_end = num_section_controls prompts_end = secs_end + num_section_controls images_end = prompts_end + num_section_controls lora_weights_end = images_end + num_loras lora_mults_end = lora_weights_end + num_loras framepack_secs = args[0:secs_end] framepack_sec_prompts = args[secs_end:prompts_end] framepack_sec_images = args[prompts_end:images_end] lora_weights_list = list(args[images_end:lora_weights_end]) lora_multipliers_list = list(args[lora_weights_end:lora_mults_end]) if not use_random_folder and not input_image and not any(img for img in framepack_sec_images if img): yield [], None, "Error: Input start image or at least one section image override is required when not using folder mode.", "" return if use_random_folder and (not input_folder_path or not os.path.isdir(input_folder_path)): yield [], None, f"Error: Random image folder path '{input_folder_path}' is invalid or not a directory.", "" return section_prompts_parts = [] section_images_parts = [] index_pattern = re.compile(r"^\d+(-\d+)?$") for idx_str, sec_prompt, sec_image in zip(framepack_secs, framepack_sec_prompts, framepack_sec_images): if not idx_str or not isinstance(idx_str, str) or not index_pattern.match(idx_str.strip()): if idx_str and idx_str.strip(): print(f"Warning: Invalid section index/range format '{idx_str}'. Skipping.") continue current_idx_str = idx_str.strip() if sec_prompt and sec_prompt.strip(): section_prompts_parts.append(f"{current_idx_str}:{sec_prompt.strip()}") if sec_image and os.path.exists(sec_image): section_images_parts.append(f"{current_idx_str}:{sec_image}") final_prompt_arg = prompt if section_prompts_parts: final_prompt_arg = ";;;".join(section_prompts_parts) print(f"Using section prompt overrides: {final_prompt_arg}") final_image_path_arg = None if section_images_parts: final_image_path_arg = ";;;".join(section_images_parts) print(f"Using section image overrides for --image_path: {final_image_path_arg}") elif input_image: final_image_path_arg = input_image print(f"Using base input image for --image_path: {final_image_path_arg}") # These are batch-wide defaults if not overridden by folder mode + target res per item. batch_wide_final_height, batch_wide_final_width = None, None if framepack_width is not None and framepack_width > 0 and framepack_height is not None and framepack_height > 0: if framepack_width % 8 != 0 or framepack_height % 8 != 0: yield [], None, "Error: Explicit Width and Height must be divisible by 8.", "" return batch_wide_final_height = int(framepack_height) batch_wide_final_width = int(framepack_width) print(f"Using explicit dimensions for all items: H={batch_wide_final_height}, W={batch_wide_final_width}") elif target_resolution is not None and target_resolution > 0 and not use_random_folder: # This case applies if: # 1. Target resolution is set. # 2. We are NOT in random folder mode (so aspect ratio from UI image is reliable). if not original_dims_str: # original_dims_str comes from the UI input image yield [], None, "Error: Target Resolution selected (not in folder mode), but no UI input image provided for aspect ratio.", "" return try: orig_w, orig_h = map(int, original_dims_str.split('x')) if orig_w <= 0 or orig_h <= 0: yield [], None, "Error: Invalid original dimensions stored from UI image.", "" return bucket_dims = find_nearest_bucket(orig_h, orig_w, resolution=target_resolution) if bucket_dims: batch_wide_final_height, batch_wide_final_width = bucket_dims print(f"Using Target Resolution {target_resolution} with UI image aspect. Batch-wide bucket: H={batch_wide_final_height}, W={batch_wide_final_width}") else: yield [], None, f"Error: Could not find bucket for Target Res {target_resolution} and UI image aspect.", "" return except Exception as e: yield [], None, f"Error calculating bucket dimensions from UI image: {e}", "" return elif use_random_folder and target_resolution is not None and target_resolution > 0: # Folder mode with target resolution: resolution will be determined per item. # batch_wide_final_height and batch_wide_final_width remain None. print(f"Folder mode with Target Resolution {target_resolution}. Resolution will be determined per item.") elif not (framepack_width is not None and framepack_width > 0 and framepack_height is not None and framepack_height > 0) and \ not (target_resolution is not None and target_resolution > 0): # This is the fallback if no resolution strategy is active for the batch. yield [], None, "Error: Resolution required. Please provide Target Resolution OR valid Width and Height (divisible by 8).", "" return all_videos = [] if framepack_video_sections is not None and framepack_video_sections > 0: total_sections_estimate = framepack_video_sections print(f"Using user-defined total sections for UI: {total_sections_estimate}") else: total_sections_estimate_float = (total_second_length * fps) / (latent_window_size * 4) total_sections_estimate = int(max(round(total_sections_estimate_float), 1)) print(f"Calculated total sections for UI from duration: {total_sections_estimate}") progress_text = f"Starting FramePack generation batch ({total_sections_estimate} estimated sections per video)..." status_text = "Preparing batch..." yield all_videos, None, status_text, progress_text valid_loras_paths = [] valid_loras_mults = [] if lora_folder and os.path.exists(lora_folder): for weight_name, mult in zip(lora_weights_list, lora_multipliers_list): if weight_name and weight_name != "None": if os.path.isabs(weight_name): lora_path = weight_name else: lora_path = os.path.join(lora_folder, weight_name) if os.path.exists(lora_path): valid_loras_paths.append(lora_path) valid_loras_mults.append(str(mult)) else: print(f"Warning: LoRA file not found: {lora_path}") for i in range(batch_size): # <<< START OF THE BATCH LOOP >>> if stop_event.is_set(): yield all_videos, None, "Generation stopped by user.", "" return skip_event.clear() last_preview_mtime = 0 run_id = f"{int(time.time())}_{random.randint(1000, 9999)}" unique_preview_suffix = f"fpack_{run_id}" preview_base_path = os.path.join(save_path, f"latent_preview_{unique_preview_suffix}") preview_mp4_path = preview_base_path + ".mp4" preview_png_path = preview_base_path + ".png" current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i status_text = f"Generating video {i + 1} of {batch_size} (Seed: {current_seed})" progress_text_update = f"Item {i+1}/{batch_size}: Preparing..." # Renamed progress_text to progress_text_update for clarity current_video_path = None current_preview_yield_path = None current_input_image_for_item = input_image current_original_dims_str_for_item = original_dims_str # Use batch-wide original_dims_str initially if use_random_folder: progress_text_update = f"Item {i+1}/{batch_size}: Selecting random image..." yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update random_image_path, random_status = get_random_image_from_folder(input_folder_path) if random_image_path is None: error_msg = f"Error for item {i+1}/{batch_size}: {random_status}. Skipping." print(error_msg) yield all_videos.copy(), None, status_text, error_msg continue current_input_image_for_item = random_image_path progress_text_update = f"Item {i+1}/{batch_size}: Using random image: {os.path.basename(random_image_path)}" print(progress_text_update) yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update # Derive original_dims_str_for_item from the random image if using target resolution # and explicit UI W/H were not provided. if target_resolution is not None and target_resolution > 0 and \ not (framepack_width is not None and framepack_width > 0 and framepack_height is not None and framepack_height > 0): try: img_for_dims = Image.open(random_image_path) rand_w, rand_h = img_for_dims.size current_original_dims_str_for_item = f"{rand_w}x{rand_h}" print(f"Folder mode item {i+1}: Using random image dims {current_original_dims_str_for_item} for target resolution bucketing.") except Exception as e: error_msg = f"Error getting dims for random image {random_image_path}: {e}. Skipping item {i+1}." print(error_msg) yield all_videos.copy(), None, status_text, error_msg continue final_image_path_arg_for_item = None if section_images_parts: final_image_path_arg_for_item = ";;;".join(section_images_parts) if current_input_image_for_item: has_section_0_override = any(part.strip().startswith("0:") for part in section_images_parts) if not has_section_0_override: final_image_path_arg_for_item = f"0:{current_input_image_for_item};;;{final_image_path_arg_for_item}" print(f"Using section image overrides (potentially with prepended base) for --image_path (item {i+1}): {final_image_path_arg_for_item}") elif current_input_image_for_item: final_image_path_arg_for_item = current_input_image_for_item print(f"Using {'random' if use_random_folder else 'base'} input image as the primary for --image_path (item {i+1}): {final_image_path_arg_for_item}") if final_image_path_arg_for_item is None: yield [], None, f"Error for item {i+1}: No valid start image could be determined. Ensure an image is provided.", "" continue final_height_for_item, final_width_for_item = None, None # 1. Use batch-wide dimensions if they were set (from explicit UI W/H or target_res + UI image) if batch_wide_final_height is not None and batch_wide_final_width is not None: final_height_for_item = batch_wide_final_height final_width_for_item = batch_wide_final_width print(f"Item {i+1}: Using batch-wide dimensions: H={final_height_for_item}, W={final_width_for_item}") # 2. Else, if using target resolution (this implies folder mode, as other cases were handled above) elif target_resolution is not None and target_resolution > 0: if not current_original_dims_str_for_item: # This should now be populated for folder mode yield [], None, f"Error for item {i+1}: Target Resolution selected, but no original dimensions available for aspect ratio.", "" continue try: orig_w_item, orig_h_item = map(int, current_original_dims_str_for_item.split('x')) if orig_w_item <= 0 or orig_h_item <= 0: yield [], None, f"Error for item {i+1}: Invalid original dimensions '{current_original_dims_str_for_item}'.", "" continue bucket_dims_item = find_nearest_bucket(orig_h_item, orig_w_item, resolution=target_resolution) if bucket_dims_item: final_height_for_item, final_width_for_item = bucket_dims_item print(f"Item {i+1}: Using Target Resolution {target_resolution} with item-specific aspect from '{current_original_dims_str_for_item}'. Bucket: H={final_height_for_item}, W={final_width_for_item}") else: yield [], None, f"Error for item {i+1}: Could not find bucket for Target Res {target_resolution} and aspect {current_original_dims_str_for_item}.", "" continue except Exception as e_res: yield [], None, f"Error calculating bucket dimensions for item {i+1} ({current_original_dims_str_for_item}): {e_res}", "" continue else: # This case should ideally not be hit if the initial batch-wide resolution checks were thorough. # It implies no explicit W/H, no target_res, or some other unhandled state. yield [], None, f"Error for item {i+1}: Failed to determine resolution strategy for the item.", "" continue # Skip this item if final_height_for_item is None or final_width_for_item is None: # Final check for the item yield [], None, f"Error for item {i+1}: Final resolution could not be determined for this item.", "" continue # Update status text with the preparing subprocess message yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update # Use progress_text_update env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" clear_cuda_cache() command = [ sys.executable, "fpack_generate_video.py", "--text_encoder1", text_encoder_path, "--text_encoder2", text_encoder_2_path, "--image_encoder", image_encoder_path, *(["--image_path", final_image_path_arg_for_item] if final_image_path_arg_for_item else []), "--save_path", save_path, "--prompt", final_prompt_arg, "--video_size", str(final_height_for_item), str(final_width_for_item), *(["--video_sections", str(framepack_video_sections)] if framepack_video_sections is not None and framepack_video_sections > 0 else ["--video_seconds", str(total_second_length)]), "--infer_steps", str(steps), "--seed", str(current_seed), "--embedded_cfg_scale", str(distilled_guidance_scale), "--guidance_scale", str(cfg), "--guidance_rescale", str(rs), "--latent_window_size", str(latent_window_size), "--sample_solver", sample_solver, "--output_type", "video", "--attn_mode", attn_mode ] if is_f1: command.append("--is_f1") if transformer_path and os.path.exists(transformer_path): command.extend(["--dit", transformer_path.strip()]) if vae_path and os.path.exists(vae_path): command.extend(["--vae", vae_path.strip()]) if negative_prompt and negative_prompt.strip(): command.extend(["--negative_prompt", negative_prompt.strip()]) if input_end_frame and os.path.exists(input_end_frame): command.extend(["--end_image_path", input_end_frame]) if fp8: command.append("--fp8") if fp8 and fp8_scaled: command.append("--fp8_scaled") if fp8_llm: command.append("--fp8_llm") if bulk_decode: command.append("--bulk_decode") if blocks_to_swap > 0: command.extend(["--blocks_to_swap", str(blocks_to_swap)]) if vae_chunk_size is not None and vae_chunk_size > 0: command.extend(["--vae_chunk_size", str(vae_chunk_size)]) if vae_spatial_tile_sample_min_size is not None and vae_spatial_tile_sample_min_size > 0: command.extend(["--vae_spatial_tile_sample_min_size", str(vae_spatial_tile_sample_min_size)]) if device and device.strip(): command.extend(["--device", device.strip()]) if valid_loras_paths: command.extend(["--lora_weight"] + valid_loras_paths) command.extend(["--lora_multiplier"] + valid_loras_mults) if enable_preview and preview_every_n_sections > 0: command.extend(["--preview_latent_every", str(preview_every_n_sections)]) command.extend(["--preview_suffix", unique_preview_suffix]) if use_full_video_preview: # Check if full preview is requested command.append("--full_preview") print(f"DEBUG: Enabling FULL VIDEO preview every {preview_every_n_sections} sections with suffix {unique_preview_suffix}.") else: print(f"DEBUG: Enabling latent preview every {preview_every_n_sections} sections with suffix {unique_preview_suffix}.") if use_teacache: command.append("--use_teacache") command.extend(["--teacache_steps", str(teacache_steps)]) command.extend(["--teacache_thresh", str(teacache_thresh)]) command_str = [str(c) for c in command] print(f"Running FramePack Command: {' '.join(command_str)}") p = subprocess.Popen( command_str, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) current_phase = "Preparing" actual_total_sections = None display_section_num = 1 while True: if stop_event.is_set(): try: p.terminate() p.wait(timeout=5) except subprocess.TimeoutExpired: p.kill(); p.wait() except Exception as e: print(f"Error terminating subprocess: {e}") yield all_videos.copy(), None, "Generation stopped by user.", "" return if skip_event.is_set(): print(f"Skip signal received for batch item {i+1}. Terminating subprocess...") try: p.terminate() p.wait(timeout=5) except subprocess.TimeoutExpired: p.kill(); p.wait() except Exception as e: print(f"Error terminating subprocess during skip: {e}") skip_event.clear() yield all_videos.copy(), current_preview_yield_path, f"Skipping item {i+1}/{batch_size}...", "" break line = p.stdout.readline() if not line: if p.poll() is not None: break time.sleep(0.01); continue line = line.strip() if not line: continue print(f"SUBPROCESS: {line}") section_match = re.search(r"---.*?Section\s+(\d+)\s*/\s*(\d+)(?:\s+|$|\()", line) tqdm_match = re.search(r'(\d+)\%\|.+\| (\d+)/(\d+) \[(\d{2}:\d{2})<(\d{2}:\d{2})', line) phase_changed = False # Initialize phase_changed inside the loop # Default progress_text_update to the current line for general logging progress_text_update = line # This was defined outside the loop before, moved inside if section_match: current_section_num_display = int(section_match.group(1)) total_sections_from_log = int(section_match.group(2)) display_section_num = current_section_num_display if actual_total_sections != total_sections_from_log: actual_total_sections = total_sections_from_log print(f"Detected/Updated actual total sections: {actual_total_sections}") new_phase = f"Generating Section {display_section_num}" if current_phase != new_phase: current_phase = new_phase phase_changed = True progress_text_update = f"Item {i+1}/{batch_size} | Section {display_section_num}/{actual_total_sections} | Preparing..." status_text = f"Generating video {i + 1} of {batch_size} (Seed: {current_seed}) - {current_phase}" elif tqdm_match: percentage = int(tqdm_match.group(1)) current_step = int(tqdm_match.group(2)) total_steps = int(tqdm_match.group(3)) time_elapsed = tqdm_match.group(4) time_remaining = tqdm_match.group(5) current_total_for_display = actual_total_sections if actual_total_sections is not None else total_sections_estimate section_str = f"Section {display_section_num}/{current_total_for_display}" progress_text_update = f"Item {i+1}/{batch_size} | {section_str} | Step {current_step}/{total_steps} ({percentage}%) | Elapsed: {time_elapsed}, Remaining: {time_remaining}" denoising_phase = f"Denoising Section {display_section_num}" if current_phase != denoising_phase: current_phase = denoising_phase phase_changed = True status_text = f"Generating video {i + 1} of {batch_size} (Seed: {current_seed}) - {current_phase}" elif "Decoding video..." in line: if current_phase != "Decoding Video": current_phase = "Decoding Video" phase_changed = True progress_text_update = f"Item {i+1}/{batch_size} | {current_phase}..." status_text = f"Generating video {i + 1} of {batch_size} (Seed: {current_seed}) - {current_phase}" elif "INFO:__main__:Video saved to:" in line: match = re.search(r"Video saved to:\s*(.*\.mp4)", line) if match: found_video_path = match.group(1).strip() if os.path.exists(found_video_path): current_video_path = found_video_path # Don't add to all_videos here, add after subprocess completion else: print(f"Warning: Parsed video path does not exist: {found_video_path}") status_text = f"Video {i+1}/{batch_size} Saved (Seed: {current_seed})" progress_text_update = f"Saved: {os.path.basename(found_video_path) if found_video_path else 'Unknown Path'}" current_phase = "Saved" phase_changed = True else: print(f"Warning: Could not parse video path from INFO line: {line}") elif "ERROR" in line.upper() or "TRACEBACK" in line.upper(): status_text = f"Item {i+1}/{batch_size}: Error Detected (Check Console)" progress_text_update = line if current_phase != "Error": current_phase = "Error" phase_changed = True elif phase_changed and current_phase not in ["Saved", "Error"]: status_text = f"Generating video {i + 1} of {batch_size} (Seed: {current_seed}) - {current_phase}" preview_updated = False current_mtime_check = 0 # Renamed from current_mtime to avoid conflict found_preview_path_check = None # Renamed if enable_preview: if os.path.exists(preview_mp4_path): current_mtime_check = os.path.getmtime(preview_mp4_path) found_preview_path_check = preview_mp4_path elif os.path.exists(preview_png_path): current_mtime_check = os.path.getmtime(preview_png_path) found_preview_path_check = preview_png_path if found_preview_path_check and current_mtime_check > last_preview_mtime: print(f"DEBUG: Preview file updated: {found_preview_path_check} (mtime: {current_mtime_check})") current_preview_yield_path = found_preview_path_check last_preview_mtime = current_mtime_check preview_updated = True yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update p.stdout.close(); rc = p.wait() clear_cuda_cache(); time.sleep(0.1) if rc == 0 and current_video_path and os.path.exists(current_video_path): all_videos.append((current_video_path, f"Seed: {current_seed}")) # Add video here parameters = { "prompt": prompt, "negative_prompt": negative_prompt, "input_image": os.path.basename(current_input_image_for_item) if current_input_image_for_item else None, "section_controls": [ {"index": s, "prompt_override": p_override, "image_override": os.path.basename(img_override) if img_override else None} for s, p_override, img_override in zip(framepack_secs, framepack_sec_prompts, framepack_sec_images) if (p_override and p_override.strip()) or img_override ], "final_prompt_arg": final_prompt_arg, "final_image_path_arg": final_image_path_arg_for_item, # Use item-specific image path "input_end_frame": os.path.basename(input_end_frame) if input_end_frame else None, "transformer_path": transformer_path, "vae_path": vae_path, "text_encoder_path": text_encoder_path, "text_encoder_2_path": text_encoder_2_path, "image_encoder_path": image_encoder_path, "video_width": final_width_for_item, "video_height": final_height_for_item, "video_seconds": total_second_length, "fps": fps, "seed": current_seed, "infer_steps": steps, "embedded_cfg_scale": distilled_guidance_scale, "guidance_scale": cfg, "guidance_rescale": rs, "sample_solver": sample_solver, "latent_window_size": latent_window_size, "fp8": fp8, "fp8_scaled": fp8_scaled, "fp8_llm": fp8_llm, "blocks_to_swap": blocks_to_swap, "bulk_decode": bulk_decode, "attn_mode": attn_mode, "vae_chunk_size": vae_chunk_size, "vae_spatial_tile_sample_min_size": vae_spatial_tile_sample_min_size, "device": device, "lora_weights": [os.path.basename(p) for p in valid_loras_paths], "lora_multipliers": [float(m) for m in valid_loras_mults], "original_dims_str": current_original_dims_str_for_item, "target_resolution": target_resolution, "is_f1": is_f1 } try: add_metadata_to_video(current_video_path, parameters) print(f"Added metadata to {current_video_path}") except Exception as meta_err: print(f"Warning: Failed to add metadata to {current_video_path}: {meta_err}") status_text = f"Item {i+1}/{batch_size} Completed (Seed: {current_seed})" progress_text_update = f"Video saved: {os.path.basename(current_video_path)}" current_preview_yield_path = None # Clear preview for next item yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update elif rc != 0: status_text = f"Item {i+1}/{batch_size} Failed (Seed: {current_seed}, Code: {rc})" progress_text_update = f"Subprocess failed. Check console logs." current_preview_yield_path = None # Clear preview yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update else: status_text = f"Item {i+1}/{batch_size} Finished (Seed: {current_seed}), but no video file confirmed." progress_text_update = "Check console logs for the saved path." current_preview_yield_path = None # Clear preview yield all_videos.copy(), current_preview_yield_path, status_text, progress_text_update # Cleanup preview files for the completed item to avoid them being picked up by next item if enable_preview: for prev_file in [preview_mp4_path, preview_png_path]: if os.path.exists(prev_file): try: os.remove(prev_file) print(f"Cleaned up preview file: {prev_file}") except Exception as e_clean: print(f"Warning: Could not remove preview file {prev_file}: {e_clean}") time.sleep(0.2) yield all_videos, None, "FramePack Batch complete", "" def calculate_framepack_width(height, original_dims): """Calculate FramePack width based on height maintaining aspect ratio (divisible by 32)""" if not original_dims or height is None: return gr.update() try: # Ensure height is an integer and divisible by 32 height = int(height) if height <= 0 : return gr.update() height = (height // 32) * 32 # <-- Use 32 height = max(64, height) # Min height (64 is divisible by 32) orig_w, orig_h = map(int, original_dims.split('x')) if orig_h == 0: return gr.update() aspect_ratio = orig_w / orig_h # Calculate new width, rounding to the nearest multiple of 32 new_width = round((height * aspect_ratio) / 32) * 32 # <-- Round and use 32 return gr.update(value=max(64, new_width)) # Ensure minimum size (also divisible by 32) except Exception as e: print(f"Error calculating width: {e}") return gr.update() def calculate_framepack_height(width, original_dims): """Calculate FramePack height based on width maintaining aspect ratio (divisible by 32)""" if not original_dims or width is None: return gr.update() try: # Ensure width is an integer and divisible by 32 width = int(width) if width <= 0: return gr.update() width = (width // 32) * 32 # <-- Use 32 width = max(64, width) # Min width (64 is divisible by 32) orig_w, orig_h = map(int, original_dims.split('x')) if orig_w == 0: return gr.update() aspect_ratio = orig_w / orig_h # Calculate new height, rounding to the nearest multiple of 32 new_height = round((width / aspect_ratio) / 32) * 32 # <-- Round and use 32 return gr.update(value=max(64, new_height)) # Ensure minimum size (also divisible by 32) except Exception as e: print(f"Error calculating height: {e}") return gr.update() def update_framepack_from_scale(scale, original_dims): """Update FramePack dimensions based on scale percentage (divisible by 32)""" if not original_dims: return gr.update(), gr.update(), gr.update() try: scale = float(scale) if scale is not None else 100.0 if scale <= 0: scale = 100.0 orig_w, orig_h = map(int, original_dims.split('x')) scale_factor = scale / 100.0 # Calculate and round to the nearest multiple of 32 new_w = round((orig_w * scale_factor) / 32) * 32 # <-- Round and use 32 new_h = round((orig_h * scale_factor) / 32) * 32 # <-- Round and use 32 # Ensure minimum size (must be multiple of 32) new_w = max(64, new_w) # 64 is divisible by 32 new_h = max(64, new_h) # Clear target resolution if using scale slider for explicit dims return gr.update(value=new_w), gr.update(value=new_h), gr.update(value=None) except Exception as e: print(f"Error updating from scale: {e}") return gr.update(), gr.update(), gr.update() def process_i2v_single_video( prompt: str, image_path: str, width: int, height: int, batch_size: int, video_length: int, fps: int, infer_steps: int, seed: int, dit_folder: str, model: str, vae: str, te1: str, te2: str, clip_vision_path: str, save_path: str, flow_shift: float, cfg_scale: float, # embedded_cfg_scale guidance_scale: float, # main CFG output_type: str, attn_mode: str, block_swap: int, exclude_single_blocks: bool, use_split_attn: bool, lora_folder: str, vae_chunk_size: int, vae_spatial_tile_min: int, # --- Explicit LoRA args instead of *lora_params --- lora1: str = "None", lora2: str = "None", lora3: str = "None", lora4: str = "None", lora1_multiplier: float = 1.0, lora2_multiplier: float = 1.0, lora3_multiplier: float = 1.0, lora4_multiplier: float = 1.0, # --- End LoRA args --- negative_prompt: Optional[str] = None, use_fp8: bool = False, fp8_llm: bool = False ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Generate a single video using hv_i2v_generate_video.py""" global stop_event # ... (Keep existing argument validation and env setup) ... if stop_event.is_set(): yield [], "", "" return # Argument validation if not image_path or not os.path.exists(image_path): yield [], "Error: Input image not found", f"Cannot find image: {image_path}" return # Check clip vision path only if needed (Hunyuan-I2V, not SkyReels-I2V based on script name) is_hunyuan_i2v = "mp_rank_00_model_states_i2v" in model # Heuristic check if is_hunyuan_i2v and (not clip_vision_path or not os.path.exists(clip_vision_path)): yield [], "Error: CLIP Vision model not found", f"Cannot find file: {clip_vision_path}" return if os.path.isabs(model): model_path = model else: model_path = os.path.normpath(os.path.join(dit_folder, model)) env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" if seed == -1: current_seed = random.randint(0, 2**32 - 1) else: current_seed = seed clear_cuda_cache() command = [ sys.executable, "hv_i2v_generate_video.py", # <<< Use the new script "--dit", model_path, "--vae", vae, "--text_encoder1", te1, "--text_encoder2", te2, # Add clip vision path only if it's likely the Hunyuan I2V model *(["--clip_vision_path", clip_vision_path] if is_hunyuan_i2v else []), "--prompt", prompt, "--video_size", str(height), str(width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", save_path, "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--embedded_cfg_scale", str(cfg_scale), "--guidance_scale", str(guidance_scale), "--output_type", output_type, "--attn_mode", attn_mode, "--blocks_to_swap", str(block_swap), "--image_path", image_path ] if negative_prompt: command.extend(["--negative_prompt", negative_prompt]) if use_fp8: command.append("--fp8") if fp8_llm: command.append("--fp8_llm") if exclude_single_blocks: command.append("--exclude_single_blocks") if use_split_attn: command.append("--split_attn") if vae_chunk_size > 0: command.extend(["--vae_chunk_size", str(vae_chunk_size)]) if vae_spatial_tile_min > 0: command.extend(["--vae_spatial_tile_sample_min_size", str(vae_spatial_tile_min)]) # --- Updated LoRA handling using named arguments --- lora_weights_list = [lora1, lora2, lora3, lora4] lora_multipliers_list = [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier] valid_loras = [] for weight, mult in zip(lora_weights_list, lora_multipliers_list): if weight and weight != "None": lora_file_path = os.path.join(lora_folder, weight) if os.path.exists(lora_file_path): valid_loras.append((lora_file_path, mult)) else: print(f"Warning: LoRA file not found: {lora_file_path}") if valid_loras: weights = [weight for weight, _ in valid_loras] multipliers = [str(mult) for _, mult in valid_loras] command.extend(["--lora_weight"] + weights) command.extend(["--lora_multiplier"] + multipliers) # --- End Updated LoRA handling --- # ... (Keep subprocess execution, output collection, and metadata saving logic) ... command_str = [str(c) for c in command] # Ensure all args are strings print(f"Running Command (I2V): {' '.join(command_str)}") p = subprocess.Popen( command_str, # Use stringified command stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) videos = [] while True: if stop_event.is_set(): p.terminate() p.wait() yield videos, current_previews, "Generation stopped by user.", "" return line = p.stdout.readline() if not line: if p.poll() is not None: break continue print(line, end='') # Print progress to console if '|' in line and '%' in line and '[' in line and ']' in line: yield videos.copy(), f"Processing (seed: {current_seed})", line.strip() p.stdout.close() p.wait() clear_cuda_cache() time.sleep(0.5) # Collect generated video save_path_abs = os.path.abspath(save_path) generated_video_path = None if os.path.exists(save_path_abs): all_videos_files = sorted( [f for f in os.listdir(save_path_abs) if f.endswith('.mp4')], key=lambda x: os.path.getmtime(os.path.join(save_path_abs, x)), reverse=True ) # Try to find the video matching the seed matching_videos = [v for v in all_videos_files if f"_{current_seed}" in v] if matching_videos: generated_video_path = os.path.join(save_path_abs, matching_videos[0]) if generated_video_path: # Collect parameters for metadata (adjust as needed for i2v specifics) parameters = { "prompt": prompt, "width": width, "height": height, "video_length": video_length, "fps": fps, "infer_steps": infer_steps, "seed": current_seed, "model": model, "vae": vae, "te1": te1, "te2": te2, "clip_vision_path": clip_vision_path, "save_path": save_path, "flow_shift": flow_shift, "embedded_cfg_scale": cfg_scale, "guidance_scale": guidance_scale, "output_type": output_type, "attn_mode": attn_mode, "block_swap": block_swap, "lora_weights": list(lora_weights_list), # Save the list "lora_multipliers": list(lora_multipliers_list), # Save the list "input_image": image_path, "negative_prompt": negative_prompt if negative_prompt else None, "vae_chunk_size": vae_chunk_size, "vae_spatial_tile_min": vae_spatial_tile_min, "use_fp8_dit": use_fp8, "use_fp8_llm": fp8_llm } add_metadata_to_video(generated_video_path, parameters) videos.append((str(generated_video_path), f"Seed: {current_seed}")) yield videos, f"Completed (seed: {current_seed})", "" else: yield [], f"Failed (seed: {current_seed})", "Could not find generated video file." def process_i2v_batch( prompt: str, image_path: str, width: int, height: int, batch_size: int, video_length: int, fps: int, infer_steps: int, seed: int, dit_folder: str, model: str, vae: str, te1: str, te2: str, clip_vision_path: str, # Added save_path: str, flow_shift: float, cfg_scale: float, # embedded_cfg_scale guidance_scale: float, # main CFG output_type: str, attn_mode: str, block_swap: int, exclude_single_blocks: bool, use_split_attn: bool, lora_folder: str, vae_chunk_size: int, # Added vae_spatial_tile_min: int, # Added negative_prompt: Optional[str] = None, # Added use_fp8: bool = False, # Added fp8_llm: bool = False, # Added *lora_params # Captures LoRA weights and multipliers ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Process a batch of videos using the new I2V script""" global stop_event stop_event.clear() all_videos = [] progress_text = "Starting I2V generation..." yield [], "Preparing...", progress_text # Extract LoRA weights and multipliers once num_lora_weights = 4 lora_weights_list = lora_params[:num_lora_weights] lora_multipliers_list = lora_params[num_lora_weights:num_lora_weights*2] for i in range(batch_size): if stop_event.is_set(): yield all_videos, "Generation stopped by user.", "" return current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i batch_text = f"Generating video {i + 1} of {batch_size} (I2V)" yield all_videos.copy(), batch_text, progress_text # Call the single video processing function single_gen = process_i2v_single_video( prompt=prompt, image_path=image_path, width=width, height=height, batch_size=batch_size, video_length=video_length, fps=fps, infer_steps=infer_steps, seed=current_seed, dit_folder=dit_folder, model=model, vae=vae, te1=te1, te2=te2, clip_vision_path=clip_vision_path, save_path=save_path, flow_shift=flow_shift, cfg_scale=cfg_scale, guidance_scale=guidance_scale, output_type=output_type, attn_mode=attn_mode, block_swap=block_swap, exclude_single_blocks=exclude_single_blocks, use_split_attn=use_split_attn, lora_folder=lora_folder, vae_chunk_size=vae_chunk_size, vae_spatial_tile_min=vae_spatial_tile_min, # --- Pass LoRA params by keyword --- lora1=lora_weights_list[0], lora2=lora_weights_list[1], lora3=lora_weights_list[2], lora4=lora_weights_list[3], lora1_multiplier=lora_multipliers_list[0], lora2_multiplier=lora_multipliers_list[1], lora3_multiplier=lora_multipliers_list[2], lora4_multiplier=lora_multipliers_list[3], # --- End LoRA keyword args --- negative_prompt=negative_prompt, use_fp8=use_fp8, fp8_llm=fp8_llm ) # Yield progress updates from the single generator try: for videos, status, progress in single_gen: if videos: # Only add the latest video from this specific generation new_video = videos[-1] if new_video not in all_videos: all_videos.append(new_video) yield all_videos.copy(), f"Batch {i+1}/{batch_size}: {status}", progress except Exception as e: yield all_videos.copy(), f"Error in batch {i+1}: {e}", "" print(f"Error during single I2V generation: {e}") # Log error # Optional small delay between batch items time.sleep(0.1) yield all_videos, "I2V Batch complete", "" def wanx_extend_video_wrapper( prompt, negative_prompt, input_image, base_video_path, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, task, dit_folder, dit_path, vae_path, t5_path, clip_path, # <--- Parameters received here save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers="", slg_start=0.0, slg_end=1.0, lora1="None", lora2="None", lora3="None", lora4="None", lora1_multiplier=1.0, lora2_multiplier=1.0, lora3_multiplier=1.0, lora4_multiplier=1.0, enable_cfg_skip=False, cfg_skip_mode="none", cfg_apply_ratio=0.7 ): """Direct wrapper that bypasses the problematic wanx_generate_video function""" global stop_event # All videos generated all_videos = [] # Debug prints to understand what we're getting print(f"DEBUG - Received parameters in wanx_extend_video_wrapper:") print(f" task: {task}") print(f" dit_folder: {dit_folder}") # <<< Should be the folder path ('wan') print(f" dit_path: {dit_path}") # <<< Should be the model filename print(f" vae_path: {vae_path}") # <<< Should be the VAE path print(f" t5_path: {t5_path}") # <<< Should be the T5 path print(f" clip_path: {clip_path}") # <<< Should be the CLIP path print(f" output_type: {output_type}") print(f" sample_solver: {sample_solver}") print(f" attn_mode: {attn_mode}") print(f" block_swap: {block_swap}") # Get current seed current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) # --- START CRITICAL FIX --- # Detect if parameters are swapped based on the pattern observed in the error log # Check if dit_path looks like a VAE path (contains "VAE" or ends with .pth) # AND dit_folder looks like a model filename (ends with .safetensors or .pt) params_swapped = False if dit_path and dit_folder and \ (("VAE" in dit_path or dit_path.endswith(".pth")) and \ (dit_folder.endswith(".safetensors") or dit_folder.endswith(".pt"))): params_swapped = True print("WARNING: Parameters appear to be swapped in extend workflow. Applying correction...") # Correct the parameters based on the observed swap actual_model_filename = dit_folder # Original dit_folder was the filename actual_vae_path = dit_path # Original dit_path was the VAE path actual_t5_path = vae_path # Original vae_path was the T5 path actual_clip_path = t5_path # Original t5_path was the CLIP path # Assign corrected values back to expected variable names for the rest of the function dit_path = actual_model_filename vae_path = actual_vae_path t5_path = actual_t5_path clip_path = actual_clip_path dit_folder = "wan" # Assume default 'wan' folder if swapped print(f" Corrected dit_folder: {dit_folder}") print(f" Corrected dit_path (model filename): {dit_path}") print(f" Corrected vae_path: {vae_path}") print(f" Corrected t5_path: {t5_path}") print(f" Corrected clip_path: {clip_path}") # Construct the full model path using the potentially corrected dit_folder and dit_path actual_model_path = os.path.join(dit_folder, dit_path) if not os.path.isabs(dit_path) else dit_path print(f" Using actual_model_path for --dit: {actual_model_path}") # --- END CRITICAL FIX --- # Prepare environment env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" # Clear CUDA cache clear_cuda_cache() # Validate and fix parameters # Fix output_type - must be one of: video, images, latent, both valid_output_types = ["video", "images", "latent", "both"] actual_output_type = "video" if output_type not in valid_output_types else output_type # Fix sample_solver - must be one of: unipc, dpm++, vanilla valid_sample_solvers = ["unipc", "dpm++", "vanilla"] actual_sample_solver = "unipc" if sample_solver not in valid_sample_solvers else sample_solver # Fix attn_mode - must be one of: sdpa, flash, sageattn, xformers, torch valid_attn_modes = ["sdpa", "flash", "sageattn", "xformers", "torch"] actual_attn_mode = "sdpa" if attn_mode not in valid_attn_modes else attn_mode # Fix block_swap - must be an integer try: actual_block_swap = int(block_swap) except (ValueError, TypeError): actual_block_swap = 0 # Build command array with explicit string conversions for EVERY parameter command = [ sys.executable, "wan_generate_video.py", "--task", str(task), "--prompt", str(prompt), "--video_size", str(height), str(width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", str(save_path), "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--guidance_scale", str(guidance_scale), "--output_type", actual_output_type, "--sample_solver", actual_sample_solver, "--attn_mode", actual_attn_mode, "--blocks_to_swap", str(actual_block_swap), # Use the corrected model path and other paths "--dit", str(actual_model_path), # <<< Use corrected full model path "--vae", str(vae_path), # <<< Use potentially corrected vae_path "--t5", str(t5_path) # <<< Use potentially corrected t5_path ] # Add image path and clip model path if needed if input_image: command.extend(["--image_path", str(input_image)]) # Use the potentially corrected clip_path if clip_path and clip_path != "outputs" and "output" not in clip_path: command.extend(["--clip", str(clip_path)]) # <<< Use potentially corrected clip_path # Add negative prompt if negative_prompt: command.extend(["--negative_prompt", str(negative_prompt)]) # Handle boolean flags - keep original values if fp8: command.append("--fp8") if fp8_scaled: command.append("--fp8_scaled") if fp8_t5: command.append("--fp8_t5") # Add SLG parameters try: # Ensure slg_layers is treated as a string before splitting slg_layers_str = str(slg_layers) if slg_layers is not None else "" if slg_layers_str and slg_layers_str.strip() and slg_layers_str.lower() != "none": slg_list = [] for layer in slg_layers_str.split(","): layer = layer.strip() if layer.isdigit(): # Only add if it's a valid integer slg_list.append(int(layer)) if slg_list: # Only add if we have valid layers command.extend(["--slg_layers", ",".join(map(str, slg_list))]) # Only add slg_start and slg_end if we have valid slg_layers if slg_start is not None: try: slg_start_float = float(slg_start) if slg_start_float >= 0: command.extend(["--slg_start", str(slg_start_float)]) except (ValueError, TypeError): pass # Ignore if conversion fails if slg_end is not None: try: slg_end_float = float(slg_end) if slg_end_float <= 1.0: command.extend(["--slg_end", str(slg_end_float)]) except (ValueError, TypeError): pass # Ignore if conversion fails except Exception as e: # Catch potential errors during processing print(f"Warning: Error processing SLG parameters: {e}") pass # Handle LoRA weights and multipliers valid_loras = [] if lora_folder and isinstance(lora_folder, str): for weight, mult in zip([lora1, lora2, lora3, lora4], [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier]): # Skip None or empty values if not weight or str(weight).lower() == "none": continue # Construct path and check existence full_path = os.path.join(str(lora_folder), str(weight)) if not os.path.exists(full_path): print(f"LoRA file not found: {full_path}") continue # Add valid LoRA valid_loras.append((full_path, str(mult))) if valid_loras: weights = [w for w, _ in valid_loras] multipliers = [m for _, m in valid_loras] command.extend(["--lora_weight"] + weights) command.extend(["--lora_multiplier"] + multipliers) # Final conversion to ensure all elements are strings command_str = [str(item) for item in command] print(f"Running Command (wanx_extend_video_wrapper): {' '.join(command_str)}") # Process execution p = subprocess.Popen( command_str, # Use stringified command stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) videos = [] # Store the generated (non-extended) video first # Process stdout in real time while True: if stop_event.is_set(): p.terminate() p.wait() yield [], "", "Generation stopped by user." return line = p.stdout.readline() if not line: if p.poll() is not None: break continue print(line, end='') if '|' in line and '%' in line and '[' in line and ']' in line: # Yield empty list during processing, actual video is collected later yield [], f"Processing (seed: {current_seed})", line.strip() p.stdout.close() return_code = p.wait() # Get return code # Clean CUDA cache and wait clear_cuda_cache() time.sleep(0.5) # Check return code if return_code != 0: print(f"❌ Error: wan_generate_video.py exited with code {return_code}") yield [], f"Failed (seed: {current_seed})", f"Subprocess failed with code {return_code}" return # Find the *newly generated* video first generated_video_path = None save_path_abs = os.path.abspath(save_path) if os.path.exists(save_path_abs): # Find the most recent mp4 containing the seed all_mp4_files = glob.glob(os.path.join(save_path_abs, f"*_{current_seed}*.mp4")) if all_mp4_files: generated_video_path = max(all_mp4_files, key=os.path.getmtime) print(f"Found newly generated video: {generated_video_path}") # Add metadata to the generated video before potential concatenation parameters = { "prompt": prompt, "negative_prompt": negative_prompt, "input_image": input_image, "width": width, "height": height, "video_length": video_length, "fps": fps, "infer_steps": infer_steps, "flow_shift": flow_shift, "guidance_scale": guidance_scale, "seed": current_seed, "task": task, "dit_path": actual_model_path, # Store the actual path used "vae_path": vae_path, "t5_path": t5_path, "clip_path": clip_path, "save_path": save_path, "output_type": actual_output_type, "sample_solver": actual_sample_solver, "exclude_single_blocks": exclude_single_blocks, "attn_mode": actual_attn_mode, "block_swap": actual_block_swap, "fp8": fp8, "fp8_scaled": fp8_scaled, "fp8_t5": fp8_t5, "lora_weights": [lora1, lora2, lora3, lora4], "lora_multipliers": [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier], "slg_layers": slg_layers, "slg_start": slg_start, "slg_end": slg_end, "is_extension_source": True # Flag this as the source for an extension } add_metadata_to_video(generated_video_path, parameters) # videos.append((str(generated_video_path), f"Generated segment (Seed: {current_seed})")) # Optionally yield segment else: print(f"Could not find generated video segment for seed {current_seed} in {save_path_abs}") # Stop here if no new video segment was generated if not generated_video_path: yield [], f"Failed (seed: {current_seed})", "Could not find generated video segment." return # Now concatenate with base video if we have the new segment and a base_video_path if generated_video_path and base_video_path and os.path.exists(base_video_path): try: print(f"Extending base video: {base_video_path}") # Create unique output filename for the *extended* video timestamp = datetime.fromtimestamp(time.time()).strftime("%Y%m%d-%H%M%S") output_filename = f"extended_{timestamp}_seed{current_seed}_{Path(base_video_path).stem}.mp4" output_path = os.path.join(save_path_abs, output_filename) # Create a temporary file list for ffmpeg concatenation list_file = os.path.join(save_path_abs, f"temp_concat_list_{current_seed}.txt") with open(list_file, "w") as f: f.write(f"file '{os.path.abspath(base_video_path)}'\n") f.write(f"file '{os.path.abspath(generated_video_path)}'\n") # Use the newly generated segment print(f"Concatenating: {base_video_path} + {generated_video_path} -> {output_path}") # Run ffmpeg concatenation command concat_command = [ "ffmpeg", "-f", "concat", "-safe", "0", # Allow relative paths if needed, but we use absolute "-i", list_file, "-c", "copy", # Fast concatenation without re-encoding "-y", # Overwrite output if exists output_path ] # Convert all command parts to strings concat_command_str = [str(item) for item in concat_command] print(f"Running FFmpeg command: {' '.join(concat_command_str)}") concat_result = subprocess.run(concat_command_str, check=False, capture_output=True, text=True) # Don't check=True initially # Clean up temporary list file if os.path.exists(list_file): try: os.remove(list_file) except OSError as e: print(f"Warning: Could not remove temp list file {list_file}: {e}") # Check if concatenation was successful if concat_result.returncode == 0 and os.path.exists(output_path): # Optionally, add metadata to the *extended* video as well extended_parameters = parameters.copy() extended_parameters["is_extension_source"] = False extended_parameters["base_video"] = os.path.basename(base_video_path) add_metadata_to_video(output_path, extended_parameters) extended_video_gallery_item = [(output_path, f"Extended (Seed: {current_seed})")] print(f"✅ Successfully created extended video: {output_path}") yield extended_video_gallery_item, "Extended video created successfully", "" return # Success! else: print(f"❌ Failed to create extended video at {output_path}") print(f"FFmpeg stderr: {concat_result.stderr}") # Yield the generated segment if concatenation failed yield [(generated_video_path, f"Generated segment (Seed: {current_seed})")], "Generated segment (extension failed)", f"FFmpeg failed: {concat_result.stderr[:200]}..." return except Exception as e: print(f"❌ Error during concatenation: {str(e)}") # Yield the generated segment if concatenation failed yield [(generated_video_path, f"Generated segment (Seed: {current_seed})")], "Generated segment (extension error)", f"Error: {str(e)}" return # If we got here, base_video_path was likely None or didn't exist, but generation succeeded yield [(generated_video_path, f"Generated segment (Seed: {current_seed})")], "Generated segment (no base video provided)", "" def wanx_v2v_generate_video( prompt, negative_prompt, input_video, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, strength, seed, task, dit_folder, dit_path, vae_path, t5_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora1="None", lora2="None", lora3="None", lora4="None", lora1_multiplier=1.0, lora2_multiplier=1.0, lora3_multiplier=1.0, lora4_multiplier=1.0, enable_cfg_skip=False, cfg_skip_mode="none", cfg_apply_ratio=0.7, ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Generate video with WanX model in video-to-video mode""" global stop_event # Convert values safely to float or None try: slg_start_float = float(slg_start) if slg_start is not None and str(slg_start).lower() != "none" else None except (ValueError, TypeError): slg_start_float = None print(f"Warning: Could not convert slg_start '{slg_start}' to float") try: slg_end_float = float(slg_end) if slg_end is not None and str(slg_end).lower() != "none" else None except (ValueError, TypeError): slg_end_float = None print(f"Warning: Could not convert slg_end '{slg_end}' to float") print(f"slg_start_float: {slg_start_float}, slg_end_float: {slg_end_float}") if stop_event.is_set(): yield [], "", "" return # Check if we need input video (required for v2v) if not input_video: yield [], "Error: No input video provided", "Please provide an input video for video-to-video generation" return if seed == -1: current_seed = random.randint(0, 2**32 - 1) else: current_seed = seed # Prepare environment env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" clear_cuda_cache() # Construct full dit_path including folder - this is the fix full_dit_path = os.path.join(dit_folder, dit_path) if not os.path.isabs(dit_path) else dit_path command = [ sys.executable, "wan_generate_video.py", "--task", task, "--prompt", prompt, "--video_size", str(height), str(width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", save_path, "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--guidance_scale", str(guidance_scale), "--output_type", output_type, "--attn_mode", attn_mode, "--blocks_to_swap", str(block_swap), "--dit", full_dit_path, # Use full_dit_path instead of dit_path "--vae", vae_path, "--t5", t5_path, "--sample_solver", sample_solver, "--video_path", input_video, # This is the key for v2v mode "--strength", str(strength) # Strength parameter for v2v ] if enable_cfg_skip and cfg_skip_mode != "none": command.extend([ "--cfg_skip_mode", cfg_skip_mode, "--cfg_apply_ratio", str(cfg_apply_ratio) ]) # Handle SLG parameters if slg_layers and str(slg_layers).strip() and slg_layers.lower() != "none": try: # Parse SLG layers layer_list = [int(x) for x in str(slg_layers).split(",")] if layer_list: # Only proceed if we have valid layer values command.extend(["--slg_layers", ",".join(map(str, layer_list))]) # Only add slg_start and slg_end if we have valid slg_layers try: if slg_start_float is not None and slg_start_float >= 0: command.extend(["--slg_start", str(slg_start_float)]) if slg_end_float is not None and slg_end_float <= 1.0: command.extend(["--slg_end", str(slg_end_float)]) except ValueError as e: print(f"Invalid SLG timing values: {str(e)}") except ValueError as e: print(f"Invalid SLG layers format: {slg_layers} - {str(e)}") if negative_prompt: command.extend(["--negative_prompt", negative_prompt]) if fp8: command.append("--fp8") if fp8_scaled: command.append("--fp8_scaled") if fp8_t5: command.append("--fp8_t5") if exclude_single_blocks: command.append("--exclude_single_blocks") # Handle LoRA weights and multipliers lora_weights = [lora1, lora2, lora3, lora4] lora_multipliers = [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier] valid_loras = [] for weight, mult in zip(lora_weights, lora_multipliers): if weight and weight != "None": full_path = os.path.join(lora_folder, weight) if not os.path.exists(full_path): print(f"LoRA file not found: {full_path}") continue valid_loras.append((full_path, mult)) if valid_loras: weights = [w for w, _ in valid_loras] multipliers = [str(m) for _, m in valid_loras] command.extend(["--lora_weight"] + weights) command.extend(["--lora_multiplier"] + multipliers) print(f"Running: {' '.join(command)}") p = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) videos = [] while True: if stop_event.is_set(): p.terminate() p.wait() yield [], "", "Generation stopped by user." return line = p.stdout.readline() if not line: if p.poll() is not None: break continue print(line, end='') if '|' in line and '%' in line and '[' in line and ']' in line: yield videos.copy(), f"Processing (seed: {current_seed})", line.strip() p.stdout.close() p.wait() clear_cuda_cache() time.sleep(0.5) # Collect generated video save_path_abs = os.path.abspath(save_path) if os.path.exists(save_path_abs): all_videos = sorted( [f for f in os.listdir(save_path_abs) if f.endswith('.mp4')], key=lambda x: os.path.getmtime(os.path.join(save_path_abs, x)), reverse=True ) matching_videos = [v for v in all_videos if f"_{current_seed}" in v] if matching_videos: video_path = os.path.join(save_path_abs, matching_videos[0]) # Collect parameters for metadata parameters = { "prompt": prompt, "width": width, "height": height, "video_length": video_length, "fps": fps, "infer_steps": infer_steps, "seed": current_seed, "task": task, "flow_shift": flow_shift, "guidance_scale": guidance_scale, "output_type": output_type, "attn_mode": attn_mode, "block_swap": block_swap, "input_video": input_video, "strength": strength, "lora_weights": [lora1, lora2, lora3, lora4], "lora_multipliers": [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier], "dit_path": full_dit_path, # Store the full path in metadata "vae_path": vae_path, "t5_path": t5_path, "negative_prompt": negative_prompt if negative_prompt else None, "sample_solver": sample_solver } add_metadata_to_video(video_path, parameters) videos.append((str(video_path), f"Seed: {current_seed}")) yield videos, f"Completed (seed: {current_seed})", "" def wanx_v2v_batch_handler( prompt, negative_prompt, input_video, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, strength, seed, batch_size, task, dit_folder, # folder path dit_path, # model filename vae_path, t5_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers: str, slg_start: Optional[str], slg_end: Optional[str], enable_cfg_skip: bool, cfg_skip_mode: str, cfg_apply_ratio: float, *lora_params ): """Handle batch generation for WanX v2v""" global stop_event stop_event.clear() # Extract LoRA parameters num_lora_weights = 4 lora_weights = lora_params[:num_lora_weights] lora_multipliers = lora_params[num_lora_weights:num_lora_weights*2] all_videos = [] progress_text = "Starting generation..." yield [], "Preparing...", progress_text # Process each item in the batch for i in range(batch_size): if stop_event.is_set(): yield all_videos, "Generation stopped by user", "" return # Calculate seed for this batch item current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i batch_text = f"Generating video {i + 1} of {batch_size}" yield all_videos.copy(), batch_text, progress_text # Generate a single video for videos, status, progress in wanx_v2v_generate_video( prompt, negative_prompt, input_video, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, strength, current_seed, task, dit_folder, # Pass folder path dit_path, # Pass model filename vae_path, t5_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, *lora_weights, *lora_multipliers, enable_cfg_skip, cfg_skip_mode, cfg_apply_ratio, ): if videos: all_videos.extend(videos) yield all_videos.copy(), f"Batch {i+1}/{batch_size}: {status}", progress # Clear CUDA cache between generations clear_cuda_cache() time.sleep(0.5) yield all_videos, "Batch complete", "" def update_wanx_v2v_dimensions(video): """Update dimensions from uploaded video""" if video is None: return "", gr.update(value=832), gr.update(value=480) cap = cv2.VideoCapture(video) if not cap.isOpened(): return "Error opening video", gr.update(), gr.update() w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) cap.release() # Make dimensions divisible by 32 w = (w // 32) * 32 h = (h // 32) * 32 return f"{w}x{h}", w, h def send_wanx_v2v_to_hunyuan_v2v( gallery: list, prompt: str, selected_index: int, width: int, height: int, video_length: int, fps: int, infer_steps: int, seed: int, flow_shift: float, guidance_scale: float, negative_prompt: str ) -> Tuple: """Send the selected WanX v2v video to Hunyuan v2v tab""" if gallery is None or not gallery: return (None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) # If no selection made but we have videos, use the first one if selected_index is None and len(gallery) > 0: selected_index = 0 if selected_index is None or selected_index >= len(gallery): return (None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) selected_item = gallery[selected_index] # Handle different gallery item formats if isinstance(selected_item, tuple): video_path = selected_item[0] elif isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) else: video_path = selected_item # Clean up path for Video component if isinstance(video_path, tuple): video_path = video_path[0] # Make sure it's a string video_path = str(video_path) return (video_path, prompt, width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) def handle_wanx_v2v_gallery_select(evt: gr.SelectData) -> int: """Track selected index when gallery item is clicked""" return evt.index def variance_of_laplacian(image): """ Compute the variance of the Laplacian of the image. Higher variance indicates a sharper image. """ return cv2.Laplacian(image, cv2.CV_64F).var() def extract_sharpest_frame(video_path, frames_to_check=30): """ Extract the sharpest frame from the last N frames of the video. Args: video_path (str): Path to the video file frames_to_check (int): Number of frames from the end to check Returns: tuple: (temp_image_path, frame_number, sharpness_score) """ print(f"\n=== Extracting sharpest frame from the last {frames_to_check} frames ===") print(f"Input video path: {video_path}") if not video_path or not os.path.exists(video_path): print("❌ Error: Video file does not exist") return None, None, None try: cap = cv2.VideoCapture(video_path) if not cap.isOpened(): print("❌ Error: Failed to open video file") return None, None, None total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) fps = cap.get(cv2.CAP_PROP_FPS) print(f"Total frames detected: {total_frames}, FPS: {fps:.2f}") if total_frames < 1: print("❌ Error: Video contains 0 frames") return None, None, None # Determine how many frames to check (the last N frames) if frames_to_check > total_frames: frames_to_check = total_frames start_frame = 0 else: start_frame = total_frames - frames_to_check print(f"Checking frames {start_frame} to {total_frames-1}") # Find the sharpest frame sharpest_frame = None max_sharpness = -1 sharpest_frame_number = -1 # Set starting position cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame) # Process frames with a progress bar with tqdm(total=frames_to_check, desc="Finding sharpest frame") as pbar: frame_idx = start_frame while frame_idx < total_frames: ret, frame = cap.read() if not ret: break # Convert to grayscale and calculate sharpness gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) sharpness = variance_of_laplacian(gray) # Update if this is the sharpest frame so far if sharpness > max_sharpness: max_sharpness = sharpness sharpest_frame = frame.copy() sharpest_frame_number = frame_idx frame_idx += 1 pbar.update(1) cap.release() if sharpest_frame is None: print("❌ Error: Failed to find a sharp frame") return None, None, None # Prepare output path temp_dir = os.path.abspath("temp_frames") os.makedirs(temp_dir, exist_ok=True) temp_path = os.path.join(temp_dir, f"sharpest_frame_{os.path.basename(video_path)}.png") print(f"Saving frame to: {temp_path}") # Write and verify if not cv2.imwrite(temp_path, sharpest_frame): print("❌ Error: Failed to write frame to file") return None, None, None if not os.path.exists(temp_path): print("❌ Error: Output file not created") return None, None, None # Calculate frame time in seconds frame_time = sharpest_frame_number / fps print(f"✅ Extracted sharpest frame: {sharpest_frame_number} (at {frame_time:.2f}s) with sharpness {max_sharpness:.2f}") return temp_path, sharpest_frame_number, max_sharpness except Exception as e: print(f"❌ Unexpected error: {str(e)}") return None, None, None finally: if 'cap' in locals(): cap.release() def trim_video_to_frame(video_path, frame_number, output_dir="outputs"): """ Trim video up to the specified frame and save as a new video. Args: video_path (str): Path to the video file frame_number (int): Frame number to trim to output_dir (str): Directory to save the trimmed video Returns: str: Path to the trimmed video file """ print(f"\n=== Trimming video to frame {frame_number} ===") if not video_path or not os.path.exists(video_path): print("❌ Error: Video file does not exist") return None try: # Get video information cap = cv2.VideoCapture(video_path) if not cap.isOpened(): print("❌ Error: Failed to open video file") return None fps = cap.get(cv2.CAP_PROP_FPS) cap.release() # Calculate time in seconds time_seconds = frame_number / fps # Create output directory if it doesn't exist os.makedirs(output_dir, exist_ok=True) # Generate output filename timestamp = f"{int(time_seconds)}s" base_name = Path(video_path).stem output_file = os.path.join(output_dir, f"{base_name}_trimmed_to_{timestamp}.mp4") # Use ffmpeg to trim the video ( ffmpeg .input(video_path) .output(output_file, to=time_seconds, c="copy") .global_args('-y') # Overwrite output files .run(quiet=True) ) if not os.path.exists(output_file): print("❌ Error: Failed to create trimmed video") return None print(f"✅ Successfully trimmed video to {time_seconds:.2f}s: {output_file}") return output_file except Exception as e: print(f"❌ Error trimming video: {str(e)}") return None def send_sharpest_frame_handler(gallery, selected_idx, frames_to_check=30): """ Extract the sharpest frame from the last N frames of the selected video Args: gallery: Gradio gallery component with videos selected_idx: Index of the selected video frames_to_check: Number of frames from the end to check Returns: tuple: (image_path, video_path, frame_number, sharpness) """ if gallery is None or not gallery: return None, None, None, "No videos in gallery" if selected_idx is None and len(gallery) == 1: selected_idx = 0 if selected_idx is None or selected_idx >= len(gallery): return None, None, None, "No video selected" # Get the video path item = gallery[selected_idx] if isinstance(item, tuple): video_path = item[0] elif isinstance(item, dict): video_path = item.get('name') or item.get('data') else: video_path = str(item) # Extract the sharpest frame image_path, frame_number, sharpness = extract_sharpest_frame(video_path, frames_to_check) if image_path is None: return None, None, None, "Failed to extract sharpest frame" return image_path, video_path, frame_number, f"Extracted frame {frame_number} with sharpness {sharpness:.2f}" def trim_and_prepare_for_extension(video_path, frame_number, save_path="outputs"): """ Trim the video to the specified frame and prepare for extension. Args: video_path: Path to the video file frame_number: Frame number to trim to save_path: Directory to save the trimmed video Returns: tuple: (trimmed_video_path, status_message) """ if not video_path or not os.path.exists(video_path): return None, "No video selected or video file does not exist" if frame_number is None: return None, "No frame number provided, please extract sharpest frame first" # Trim the video trimmed_video = trim_video_to_frame(video_path, frame_number, save_path) if trimmed_video is None: return None, "Failed to trim video" return trimmed_video, f"Video trimmed to frame {frame_number} and ready for extension" def send_last_frame_handler(gallery, selected_idx): """Handle sending last frame to input with better error handling""" if gallery is None or not gallery: return None, None if selected_idx is None and len(gallery) == 1: selected_idx = 0 if selected_idx is None or selected_idx >= len(gallery): return None, None # Get the frame and video path frame = handle_last_frame_transfer(gallery, selected_idx) video_path = None if selected_idx < len(gallery): item = gallery[selected_idx] video_path = parse_video_path(item) return frame, video_path def extract_last_frame(video_path: str) -> Optional[str]: """Extract last frame from video and return temporary image path with error handling""" print(f"\n=== Starting frame extraction ===") print(f"Input video path: {video_path}") if not video_path or not os.path.exists(video_path): print("❌ Error: Video file does not exist") return None try: cap = cv2.VideoCapture(video_path) if not cap.isOpened(): print("❌ Error: Failed to open video file") return None total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) print(f"Total frames detected: {total_frames}") if total_frames < 1: print("❌ Error: Video contains 0 frames") return None # Extract last frame cap.set(cv2.CAP_PROP_POS_FRAMES, total_frames - 1) success, frame = cap.read() if not success or frame is None: print("❌ Error: Failed to read last frame") return None # Prepare output path temp_dir = os.path.abspath("temp_frames") os.makedirs(temp_dir, exist_ok=True) temp_path = os.path.join(temp_dir, f"last_frame_{os.path.basename(video_path)}.png") print(f"Saving frame to: {temp_path}") # Write and verify if not cv2.imwrite(temp_path, frame): print("❌ Error: Failed to write frame to file") return None if not os.path.exists(temp_path): print("❌ Error: Output file not created") return None print("✅ Frame extraction successful") return temp_path except Exception as e: print(f"❌ Unexpected error: {str(e)}") return None finally: if 'cap' in locals(): cap.release() def handle_last_frame_transfer(gallery: list, selected_idx: int) -> Optional[str]: """Improved frame transfer with video input validation""" try: if gallery is None or not gallery: raise ValueError("No videos generated yet") if selected_idx is None: # Auto-select last generated video if batch_size=1 if len(gallery) == 1: selected_idx = 0 else: raise ValueError("Please select a video first") if selected_idx >= len(gallery): raise ValueError("Invalid selection index") item = gallery[selected_idx] # Video file existence check video_path = parse_video_path(item) if not os.path.exists(video_path): raise FileNotFoundError(f"Video file missing: {video_path}") return extract_last_frame(video_path) except Exception as e: print(f"Frame transfer failed: {str(e)}") return None def parse_video_path(item) -> str: """Parse different gallery item formats""" if isinstance(item, tuple): return item[0] elif isinstance(item, dict): return item.get('name') or item.get('data') return str(item) def get_random_image_from_folder(folder_path): """Get a random image from the specified folder""" if not os.path.isdir(folder_path): return None, f"Error: {folder_path} is not a valid directory" # Get all image files in the folder image_files = [] for ext in ('*.jpg', '*.jpeg', '*.png', '*.bmp', '*.webp'): image_files.extend(glob.glob(os.path.join(folder_path, ext))) for ext in ('*.JPG', '*.JPEG', '*.PNG', '*.BMP', '*.WEBP'): image_files.extend(glob.glob(os.path.join(folder_path, ext))) if not image_files: return None, f"Error: No image files found in {folder_path}" # Select a random image random_image = random.choice(image_files) return random_image, f"Selected: {os.path.basename(random_image)}" def resize_image_keeping_aspect_ratio(image_path, max_width, max_height): """Resize image keeping aspect ratio and ensuring dimensions are divisible by 16""" try: img = Image.open(image_path) width, height = img.size # Calculate aspect ratio aspect_ratio = width / height # Calculate new dimensions while maintaining aspect ratio if width > height: new_width = min(max_width, width) new_height = int(new_width / aspect_ratio) else: new_height = min(max_height, height) new_width = int(new_height * aspect_ratio) # Make dimensions divisible by 16 new_width = math.floor(new_width / 16) * 16 new_height = math.floor(new_height / 16) * 16 # Ensure minimum size new_width = max(16, new_width) new_height = max(16, new_height) # Resize image resized_img = img.resize((new_width, new_height), Image.LANCZOS) # Save to temporary file temp_path = f"temp_resized_{os.path.basename(image_path)}" resized_img.save(temp_path) return temp_path, (new_width, new_height) except Exception as e: return None, f"Error: {str(e)}" # Function to process a batch of images from a folder def batch_handler( use_random, prompt, negative_prompt, width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, embedded_cfg_scale, batch_size, input_folder_path, dit_folder, model, vae, te1, te2, save_path, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, use_fp8, split_uncond, lora_folder, *lora_params ): """Handle both folder-based batch processing and regular batch processing""" global stop_event # Check if this is a SkyReels model that needs special handling is_skyreels = "skyreels" in model.lower() is_skyreels_i2v = is_skyreels and "i2v" in model.lower() if use_random: # Random image from folder mode stop_event.clear() all_videos = [] progress_text = "Starting generation..." yield [], "Preparing...", progress_text for i in range(batch_size): if stop_event.is_set(): break batch_text = f"Generating video {i + 1} of {batch_size}" yield all_videos.copy(), batch_text, progress_text # Get random image from folder random_image, status = get_random_image_from_folder(input_folder_path) if random_image is None: yield all_videos, f"Error in batch {i+1}: {status}", "" continue # Resize image resized_image, size_info = resize_image_keeping_aspect_ratio(random_image, width, height) if resized_image is None: yield all_videos, f"Error resizing image in batch {i+1}: {size_info}", "" continue # If we have dimensions, update them local_width, local_height = width, height if isinstance(size_info, tuple): local_width, local_height = size_info progress_text = f"Using image: {os.path.basename(random_image)} - Resized to {local_width}x{local_height}" else: progress_text = f"Using image: {os.path.basename(random_image)}" yield all_videos.copy(), batch_text, progress_text # Calculate seed for this batch item current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i # Process the image # For SkyReels models, we need to create a command with dit_in_channels=32 if is_skyreels_i2v: env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" model_path = os.path.join(dit_folder, model) if not os.path.isabs(model) else model # Extract parameters from lora_params num_lora_weights = 4 lora_weights = lora_params[:num_lora_weights] lora_multipliers = lora_params[num_lora_weights:num_lora_weights*2] cmd = [ sys.executable, "hv_generate_video.py", "--dit", model_path, "--vae", vae, "--text_encoder1", te1, "--text_encoder2", te2, "--prompt", prompt, "--video_size", str(local_height), str(local_width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", save_path, "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--embedded_cfg_scale", str(embedded_cfg_scale), "--output_type", output_type, "--attn_mode", attn_mode, "--blocks_to_swap", str(block_swap), "--fp8_llm", "--vae_chunk_size", "32", "--vae_spatial_tile_sample_min_size", "128", "--dit_in_channels", "32", # This is crucial for SkyReels i2v "--image_path", resized_image # Pass the image directly ] if use_fp8: cmd.append("--fp8") if split_uncond: cmd.append("--split_uncond") if use_split_attn: cmd.append("--split_attn") if exclude_single_blocks: cmd.append("--exclude_single_blocks") if negative_prompt: cmd.extend(["--negative_prompt", negative_prompt]) if guidance_scale is not None: cmd.extend(["--guidance_scale", str(guidance_scale)]) # Add LoRA weights and multipliers if provided valid_loras = [] for weight, mult in zip(lora_weights, lora_multipliers): if weight and weight != "None": valid_loras.append((os.path.join(lora_folder, weight), mult)) if valid_loras: weights = [weight for weight, _ in valid_loras] multipliers = [str(mult) for _, mult in valid_loras] cmd.extend(["--lora_weight"] + weights) cmd.extend(["--lora_multiplier"] + multipliers) print(f"Running command: {' '.join(cmd)}") # Run the process p = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) while True: if stop_event.is_set(): p.terminate() p.wait() yield all_videos, "Generation stopped by user.", "" return line = p.stdout.readline() if not line: if p.poll() is not None: break continue print(line, end='') if '|' in line and '%' in line and '[' in line and ']' in line: yield all_videos.copy(), f"Processing video {i+1} (seed: {current_seed})", line.strip() p.stdout.close() p.wait() # Collect generated video save_path_abs = os.path.abspath(save_path) if os.path.exists(save_path_abs): all_videos_files = sorted( [f for f in os.listdir(save_path_abs) if f.endswith('.mp4')], key=lambda x: os.path.getmtime(os.path.join(save_path_abs, x)), reverse=True ) matching_videos = [v for v in all_videos_files if f"_{current_seed}" in v] if matching_videos: video_path = os.path.join(save_path_abs, matching_videos[0]) all_videos.append((str(video_path), f"Seed: {current_seed}")) else: # For non-SkyReels models, use the regular process_single_video function num_lora_weights = 4 lora_weights = lora_params[:num_lora_weights] lora_multipliers = lora_params[num_lora_weights:num_lora_weights*2] single_video_args = [ prompt, local_width, local_height, 1, video_length, fps, infer_steps, current_seed, dit_folder, model, vae, te1, te2, save_path, flow_shift, embedded_cfg_scale, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, lora_folder ] single_video_args.extend(lora_weights) single_video_args.extend(lora_multipliers) single_video_args.extend([None, resized_image, None, negative_prompt, embedded_cfg_scale, split_uncond, guidance_scale, use_fp8]) for videos, status, progress in process_single_video(*single_video_args): if videos: all_videos.extend(videos) yield all_videos.copy(), f"Batch {i+1}/{batch_size}: {status}", progress # Clean up temporary file try: if os.path.exists(resized_image): os.remove(resized_image) except: pass # Clear CUDA cache between generations clear_cuda_cache() time.sleep(0.5) yield all_videos, "Batch complete", "" else: # Regular image input - this is the part we need to fix # When a SkyReels I2V model is used, we need to use the direct command approach # with dit_in_channels=32 explicitly specified, just like in the folder processing branch if is_skyreels_i2v: stop_event.clear() all_videos = [] progress_text = "Starting generation..." yield [], "Preparing...", progress_text # Extract lora parameters num_lora_weights = 4 lora_weights = lora_params[:num_lora_weights] lora_multipliers = lora_params[num_lora_weights:num_lora_weights*2] extra_args = list(lora_params[num_lora_weights*2:]) if len(lora_params) > num_lora_weights*2 else [] # Print extra_args for debugging print(f"Extra args: {extra_args}") # Get input image path from extra args - this is where we need to fix # In skyreels_generate_btn.click, we're passing skyreels_input which # should be the image path image_path = None if len(extra_args) > 0 and extra_args[0] is not None: image_path = extra_args[0] print(f"Image path found in extra_args[0]: {image_path}") # If we still don't have an image path, this is a problem if not image_path: # Let's try to debug what's happening - in the future, you can remove these # debug prints once everything works correctly print("No image path found in extra_args[0]") print(f"Full lora_params: {lora_params}") yield [], "Error: No input image provided", "An input image is required for SkyReels I2V models" return for i in range(batch_size): if stop_event.is_set(): yield all_videos, "Generation stopped by user", "" return # Calculate seed for this batch item current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i batch_text = f"Generating video {i + 1} of {batch_size}" yield all_videos.copy(), batch_text, progress_text # Set up environment env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" model_path = os.path.join(dit_folder, model) if not os.path.isabs(model) else model # Build the command with dit_in_channels=32 cmd = [ sys.executable, "hv_generate_video.py", "--dit", model_path, "--vae", vae, "--text_encoder1", te1, "--text_encoder2", te2, "--prompt", prompt, "--video_size", str(height), str(width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", save_path, "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--embedded_cfg_scale", str(embedded_cfg_scale), "--output_type", output_type, "--attn_mode", attn_mode, "--blocks_to_swap", str(block_swap), "--fp8_llm", "--vae_chunk_size", "32", "--vae_spatial_tile_sample_min_size", "128", "--dit_in_channels", "32", # This is crucial for SkyReels i2v "--image_path", image_path ] if use_fp8: cmd.append("--fp8") if split_uncond: cmd.append("--split_uncond") if use_split_attn: cmd.append("--split_attn") if exclude_single_blocks: cmd.append("--exclude_single_blocks") if negative_prompt: cmd.extend(["--negative_prompt", negative_prompt]) if guidance_scale is not None: cmd.extend(["--guidance_scale", str(guidance_scale)]) # Add LoRA weights and multipliers if provided valid_loras = [] for weight, mult in zip(lora_weights, lora_multipliers): if weight and weight != "None": valid_loras.append((os.path.join(lora_folder, weight), mult)) if valid_loras: weights = [weight for weight, _ in valid_loras] multipliers = [str(mult) for _, mult in valid_loras] cmd.extend(["--lora_weight"] + weights) cmd.extend(["--lora_multiplier"] + multipliers) print(f"Running command: {' '.join(cmd)}") # Run the process p = subprocess.Popen( cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) while True: if stop_event.is_set(): p.terminate() p.wait() yield all_videos, "Generation stopped by user.", "" return line = p.stdout.readline() if not line: if p.poll() is not None: break continue print(line, end='') if '|' in line and '%' in line and '[' in line and ']' in line: yield all_videos.copy(), f"Processing (seed: {current_seed})", line.strip() p.stdout.close() p.wait() # Collect generated video save_path_abs = os.path.abspath(save_path) if os.path.exists(save_path_abs): all_videos_files = sorted( [f for f in os.listdir(save_path_abs) if f.endswith('.mp4')], key=lambda x: os.path.getmtime(os.path.join(save_path_abs, x)), reverse=True ) matching_videos = [v for v in all_videos_files if f"_{current_seed}" in v] if matching_videos: video_path = os.path.join(save_path_abs, matching_videos[0]) all_videos.append((str(video_path), f"Seed: {current_seed}")) # Clear CUDA cache between generations clear_cuda_cache() time.sleep(0.5) yield all_videos, "Batch complete", "" else: # For regular non-SkyReels models, use the original process_batch function regular_args = [ prompt, width, height, batch_size, video_length, fps, infer_steps, seed, dit_folder, model, vae, te1, te2, save_path, flow_shift, guidance_scale, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, lora_folder ] yield from process_batch(*(regular_args + list(lora_params))) def get_dit_models(dit_folder: str) -> List[str]: """Get list of available DiT models in the specified folder""" if not os.path.exists(dit_folder): return ["mp_rank_00_model_states.pt"] models = [f for f in os.listdir(dit_folder) if f.endswith('.pt') or f.endswith('.safetensors')] models.sort(key=str.lower) return models if models else ["mp_rank_00_model_states.pt"] def update_dit_and_lora_dropdowns(dit_folder: str, lora_folder: str, *current_values) -> List[gr.update]: """Update both DiT and LoRA dropdowns""" # Get model lists dit_models = get_dit_models(dit_folder) lora_choices = get_lora_options(lora_folder) # Current values processing dit_value = current_values[0] if dit_value not in dit_models: dit_value = dit_models[0] if dit_models else None weights = current_values[1:5] multipliers = current_values[5:9] results = [gr.update(choices=dit_models, value=dit_value)] # Add LoRA updates for i in range(4): weight = weights[i] if i < len(weights) else "None" multiplier = multipliers[i] if i < len(multipliers) else 1.0 if weight not in lora_choices: weight = "None" results.extend([ gr.update(choices=lora_choices, value=weight), gr.update(value=multiplier) ]) return results def extract_video_metadata(video_path: str) -> Dict: """Extract metadata from video file using ffprobe.""" cmd = [ 'ffprobe', '-v', 'quiet', '-print_format', 'json', '-show_format', video_path ] try: result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True) metadata = json.loads(result.stdout.decode('utf-8')) if 'format' in metadata and 'tags' in metadata['format']: comment = metadata['format']['tags'].get('comment', '{}') return json.loads(comment) return {} except Exception as e: print(f"Metadata extraction failed: {str(e)}") return {} def create_parameter_transfer_map(metadata: Dict, target_tab: str) -> Dict: """Map metadata parameters to Gradio components for different tabs""" mapping = { 'common': { 'prompt': ('prompt', 'v2v_prompt', 'wanx_v2v_prompt'), # Add WanX-v2v mapping 'width': ('width', 'v2v_width', 'wanx_v2v_width'), 'height': ('height', 'v2v_height', 'wanx_v2v_height'), 'batch_size': ('batch_size', 'v2v_batch_size', 'wanx_v2v_batch_size'), 'video_length': ('video_length', 'v2v_video_length', 'wanx_v2v_video_length'), 'fps': ('fps', 'v2v_fps', 'wanx_v2v_fps'), 'infer_steps': ('infer_steps', 'v2v_infer_steps', 'wanx_v2v_infer_steps'), 'seed': ('seed', 'v2v_seed', 'wanx_v2v_seed'), 'flow_shift': ('flow_shift', 'v2v_flow_shift', 'wanx_v2v_flow_shift'), 'guidance_scale': ('cfg_scale', 'v2v_cfg_scale', 'wanx_v2v_guidance_scale'), 'negative_prompt': ('negative_prompt', 'v2v_negative_prompt', 'wanx_v2v_negative_prompt'), 'strength': ('strength', 'v2v_strength', 'wanx_v2v_strength') }, 'lora': { 'lora_weights': [(f'lora{i+1}', f'v2v_lora_weights[{i}]', f'wanx_v2v_lora_weights[{i}]') for i in range(4)], 'lora_multipliers': [(f'lora{i+1}_multiplier', f'v2v_lora_multipliers[{i}]', f'wanx_v2v_lora_multipliers[{i}]') for i in range(4)] } } results = {} for param, value in metadata.items(): # Handle common parameters if param in mapping['common']: target_idx = 0 if target_tab == 't2v' else 1 if target_tab == 'v2v' else 2 if target_idx < len(mapping['common'][param]): target = mapping['common'][param][target_idx] results[target] = value # Handle LoRA parameters if param == 'lora_weights': for i, weight in enumerate(value[:4]): target_idx = 0 if target_tab == 't2v' else 1 if target_tab == 'v2v' else 2 if target_idx < len(mapping['lora']['lora_weights'][i]): target = mapping['lora']['lora_weights'][i][target_idx] results[target] = weight if param == 'lora_multipliers': for i, mult in enumerate(value[:4]): target_idx = 0 if target_tab == 't2v' else 1 if target_tab == 'v2v' else 2 if target_idx < len(mapping['lora']['lora_multipliers'][i]): target = mapping['lora']['lora_multipliers'][i][target_idx] results[target] = float(mult) return results def add_metadata_to_video(video_path: str, parameters: dict) -> None: """Add generation parameters to video metadata using ffmpeg.""" import json import subprocess # Convert parameters to JSON string params_json = json.dumps(parameters, indent=2) # Temporary output path temp_path = video_path.replace(".mp4", "_temp.mp4") # Add Fun-Control information to metadata if applicable task = parameters.get("task", "") if task.endswith("-FC"): parameters["fun_control"] = True # Store the control path in metadata if available if "control_path" in parameters: parameters["control_video"] = os.path.basename(parameters["control_path"]) # FFmpeg command to add metadata without re-encoding cmd = [ 'ffmpeg', '-i', video_path, '-metadata', f'comment={params_json}', '-codec', 'copy', temp_path ] try: # Execute FFmpeg command subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Replace original file with the metadata-enhanced version os.replace(temp_path, video_path) except subprocess.CalledProcessError as e: print(f"Failed to add metadata: {e.stderr.decode()}") if os.path.exists(temp_path): os.remove(temp_path) except Exception as e: print(f"Error: {str(e)}") def count_prompt_tokens(prompt: str) -> int: enc = tiktoken.get_encoding("cl100k_base") tokens = enc.encode(prompt) return len(tokens) def get_lora_options(lora_folder: str = "lora") -> List[str]: if not os.path.exists(lora_folder): return ["None"] lora_files = [f for f in os.listdir(lora_folder) if f.endswith('.safetensors') or f.endswith('.pt')] lora_files.sort(key=str.lower) return ["None"] + lora_files def update_lora_dropdowns(lora_folder: str, *current_values) -> List[gr.update]: new_choices = get_lora_options(lora_folder) weights = current_values[:4] multipliers = current_values[4:8] results = [] for i in range(4): weight = weights[i] if i < len(weights) else "None" multiplier = multipliers[i] if i < len(multipliers) else 1.0 if weight not in new_choices: weight = "None" results.extend([ gr.update(choices=new_choices, value=weight), gr.update(value=multiplier) ]) return results def send_to_v2v(evt: gr.SelectData, gallery: list, prompt: str, selected_index: gr.State) -> Tuple[Optional[str], str, int]: """Transfer selected video and prompt to Video2Video tab""" if not gallery or evt.index >= len(gallery): return None, "", selected_index.value selected_item = gallery[evt.index] # Handle different gallery item formats if isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, (tuple, list)): video_path = selected_item[0] else: video_path = selected_item # Final cleanup for Gradio Video component if isinstance(video_path, tuple): video_path = video_path[0] # Update the selected index selected_index.value = evt.index return str(video_path), prompt, evt.index def send_selected_to_v2v(gallery: list, prompt: str, selected_index: gr.State) -> Tuple[Optional[str], str]: """Send the currently selected video to V2V tab""" if not gallery or selected_index.value is None or selected_index.value >= len(gallery): return None, "" selected_item = gallery[selected_index.value] # Handle different gallery item formats if isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, (tuple, list)): video_path = selected_item[0] else: video_path = selected_item # Final cleanup for Gradio Video component if isinstance(video_path, tuple): video_path = video_path[0] return str(video_path), prompt def clear_cuda_cache(): """Clear CUDA cache if available""" import torch if torch.cuda.is_available(): torch.cuda.empty_cache() # Optional: synchronize to ensure cache is cleared torch.cuda.synchronize() def wanx_batch_handler( use_random, prompt, negative_prompt, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, batch_size, input_folder_path, wanx_input_end, task, dit_folder, dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers: str, slg_start: Optional[str], slg_end: Optional[str], enable_cfg_skip: bool, cfg_skip_mode: str, cfg_apply_ratio: float, enable_preview: bool, preview_steps: int, *lora_params, # <-- DO NOT ADD NAMED ARGS AFTER THIS! ): """Handle both folder-based batch processing and regular processing for all WanX tabs""" global stop_event # Convert None strings to actual None slg_layers = None if slg_layers == "None" else slg_layers slg_start = None if slg_start == "None" else slg_start slg_end = None if slg_end == "None" else slg_end # Construct full dit_path including folder full_dit_path = os.path.join(dit_folder, dit_path) if not os.path.isabs(dit_path) else dit_path # Clean up LoRA params to proper format clean_lora_params = [] for param in lora_params: # Convert None strings to "None" for consistency if param is None or str(param).lower() == "none": clean_lora_params.append("None") else: clean_lora_params.append(str(param)) # Extract LoRA weights and multipliers num_lora_weights = 4 lora_weights = clean_lora_params[:num_lora_weights] lora_multipliers = [] for mult in clean_lora_params[num_lora_weights:num_lora_weights*2]: try: lora_multipliers.append(float(mult)) except (ValueError, TypeError): lora_multipliers.append(1.0) while len(lora_weights) < 4: lora_weights.append("None") while len(lora_multipliers) < 4: lora_multipliers.append(1.0) # Now extract trailing params: input_file, control_video, control_strength, control_start, control_end remaining_params = clean_lora_params[num_lora_weights*2:] input_file = remaining_params[0] if len(remaining_params) > 0 else None control_video = remaining_params[1] if len(remaining_params) > 1 else None try: control_strength = float(remaining_params[2]) if len(remaining_params) > 2 else 1.0 except Exception: control_strength = 1.0 try: control_start = float(remaining_params[3]) if len(remaining_params) > 3 else 0.0 except Exception: control_start = 0.0 try: control_end = float(remaining_params[4]) if len(remaining_params) > 4 else 1.0 except Exception: control_end = 1.0 yield [], [], "Preparing batch...", "" # Clear main and preview galleries if use_random: stop_event.clear() all_videos = [] all_previews = [] # Keep track of previews from the last successful item? Or clear each time? Let's clear. progress_text = "Starting generation..." yield [], [], "Preparing...", progress_text # Clear galleries again just in case batch_size = int(batch_size) for i in range(batch_size): if stop_event.is_set(): yield all_videos, [], "Generation stopped by user", "" # Yield empty previews on stop return # --- Clear previews for this item --- current_previews_for_item = [] yield all_videos.copy(), current_previews_for_item, f"Generating video {i + 1} of {batch_size}", progress_text # Yield cleared previews # ... (Keep existing random image logic: get random, resize) ... random_image, status = get_random_image_from_folder(input_folder_path) if random_image is None: yield all_videos, current_previews_for_item, f"Error in batch {i+1}: {status}", "" continue # Skip to next batch item on error resized_image, size_info = resize_image_keeping_aspect_ratio(random_image, width, height) if resized_image is None: yield all_videos, current_previews_for_item, f"Error resizing image in batch {i+1}: {size_info}", "" # Clean up the random image if resize failed but image exists try: if os.path.exists(random_image) and "temp_resized" not in random_image: # Avoid double delete if resize output existed pass # Might not want to delete original random image here except: pass continue # Skip to next batch item on error local_width, local_height = width, height if isinstance(size_info, tuple): local_width, local_height = size_info progress_text = f"Using image: {os.path.basename(random_image)} - Resized to {local_width}x{local_height}" yield all_videos.copy(), current_previews_for_item, f"Generating video {i + 1} of {batch_size}", progress_text current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i # --- Corrected call to wanx_generate_video with accumulation --- newly_generated_video = None # Track the video generated *in this iteration* last_status_for_item = f"Generating video {i+1}/{batch_size}" # Keep track of last status last_progress_for_item = progress_text # Keep track of last progress line # Inner loop iterates through the generator for ONE batch item for videos_update, previews_update, status, progress in wanx_generate_video( prompt, negative_prompt, resized_image, local_width, local_height, video_length, fps, infer_steps, flow_shift, guidance_scale, current_seed, wanx_input_end, # Pass the argument task, dit_folder, full_dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora_weights[0], lora_weights[1], lora_weights[2], lora_weights[3], lora_multipliers[0], lora_multipliers[1], lora_multipliers[2], lora_multipliers[3], enable_cfg_skip, cfg_skip_mode, cfg_apply_ratio, None, 1.0, 0.0, 1.0, # Placeholders for control video args in random mode enable_preview=enable_preview, preview_steps=preview_steps ): # Store the latest video info from this *specific* generator run if videos_update: # wanx_generate_video yields the *full* list it knows about, # so we take the last item assuming it's the new one. newly_generated_video = videos_update[-1] current_previews_for_item = previews_update # Update previews for *this* item last_status_for_item = f"Batch {i+1}/{batch_size}: {status}" # Store last status last_progress_for_item = progress # Store last progress line # Yield the *current cumulative* list during progress updates yield all_videos.copy(), current_previews_for_item, last_status_for_item, last_progress_for_item # --- After the inner loop finishes for item 'i' --- # Now, add the video generated in this iteration to the main list if newly_generated_video and newly_generated_video not in all_videos: all_videos.append(newly_generated_video) print(f"DEBUG: Appended video {newly_generated_video[1] if isinstance(newly_generated_video, tuple) else 'unknown'} to all_videos (Total: {len(all_videos)})") # Yield the updated cumulative list *immediately* after appending yield all_videos.copy(), current_previews_for_item, last_status_for_item, last_progress_for_item elif not newly_generated_video: print(f"DEBUG: No new video generated or yielded by wanx_generate_video for batch item {i+1}.") # --- Cleanup for item 'i' (Correctly indented) --- try: # Only remove the temporary resized image if os.path.exists(resized_image) and "temp_resized" in resized_image: os.remove(resized_image) print(f"DEBUG: Removed temporary resized image: {resized_image}") except Exception as e: print(f"Warning: Could not remove temp image {resized_image}: {e}") clear_cuda_cache() time.sleep(0.5) # --- End Cleanup for item 'i' --- # --- After the outer loop (all batch items processed) --- yield all_videos, [], "Batch complete", "" # Yield empty previews at the end else: # ... (Keep existing checks for non-random mode: input file, control video) ... batch_size = int(batch_size) if not input_file and "i2v" in task: yield [], [], "Error: No input image provided", "An input image is required for I2V models" return if "-FC" in task and not control_video: yield [], [], "Error: No control video provided", "A control video is required for Fun-Control models" return if batch_size > 1: stop_event.clear() all_videos = [] all_previews = [] # Clear previews at start of batch progress_text = "Starting generation..." yield [], [], "Preparing...", progress_text # Clear galleries for i in range(batch_size): if stop_event.is_set(): yield all_videos, [], "Generation stopped by user", "" # Yield empty previews return # --- Clear previews for this item --- current_previews_for_item = [] yield all_videos.copy(), current_previews_for_item, f"Generating video {i+1}/{batch_size}", progress_text current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i batch_text = f"Generating video {i+1}/{batch_size} (seed: {current_seed})" yield all_videos.copy(), current_previews_for_item, batch_text, progress_text # Update status # --- Corrected call to wanx_generate_video with accumulation --- newly_generated_video = None # Track the video generated *in this iteration* last_status_for_item = f"Generating video {i+1}/{batch_size}" # Keep track of last status last_progress_for_item = progress_text # Keep track of last progress line # Inner loop iterates through the generator for ONE batch item for videos_update, previews_update, status, progress in wanx_generate_video( prompt, negative_prompt, input_file, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, current_seed, wanx_input_end, # Pass the argument task, dit_folder, full_dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora_weights[0], lora_weights[1], lora_weights[2], lora_weights[3], lora_multipliers[0], lora_multipliers[1], lora_multipliers[2], lora_multipliers[3], enable_cfg_skip, cfg_skip_mode, cfg_apply_ratio, control_video, control_strength, control_start, control_end, # --- Pass preview args --- enable_preview=enable_preview, preview_steps=preview_steps ): # Store the latest video info from this *specific* generator run if videos_update: # wanx_generate_video yields the *full* list it knows about, # so we take the last item assuming it's the new one. newly_generated_video = videos_update[-1] current_previews_for_item = previews_update # Update previews for *this* item last_status_for_item = f"Batch {i+1}/{batch_size}: {status}" # Store last status last_progress_for_item = progress # Store last progress line # Yield the *current cumulative* list during progress updates yield all_videos.copy(), current_previews_for_item, last_status_for_item, last_progress_for_item # --- After the inner loop finishes for item 'i' --- # Now, add the video generated in this iteration to the main list if newly_generated_video and newly_generated_video not in all_videos: all_videos.append(newly_generated_video) print(f"DEBUG: Appended video {newly_generated_video[1] if isinstance(newly_generated_video, tuple) else 'unknown'} to all_videos (Total: {len(all_videos)})") # Yield the updated cumulative list *immediately* after appending yield all_videos.copy(), current_previews_for_item, last_status_for_item, last_progress_for_item elif not newly_generated_video: print(f"DEBUG: No new video generated or yielded by wanx_generate_video for batch item {i+1}.") # --- End modified call --- clear_cuda_cache() time.sleep(0.5) yield all_videos, [], "Batch complete", "" # Yield empty previews at the end else: # Single generation (batch_size = 1) stop_event.clear() # --- Modified call to wanx_generate_video (yield from) --- # Add preview args directly yield from wanx_generate_video( prompt, negative_prompt, input_file, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, wanx_input_end, # Pass the argument task, dit_folder, full_dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora_weights[0], lora_weights[1], lora_weights[2], lora_weights[3], lora_multipliers[0], lora_multipliers[1], lora_multipliers[2], lora_multipliers[3], enable_cfg_skip, cfg_skip_mode, cfg_apply_ratio, control_video, control_strength, control_start, control_end, # --- Pass preview args --- enable_preview=enable_preview, preview_steps=preview_steps ) def process_single_video( prompt: str, width: int, height: int, batch_size: int, video_length: int, fps: int, infer_steps: int, seed: int, dit_folder: str, model: str, vae: str, te1: str, te2: str, save_path: str, flow_shift: float, cfg_scale: float, output_type: str, attn_mode: str, block_swap: int, exclude_single_blocks: bool, use_split_attn: bool, lora_folder: str, lora1: str = "", lora2: str = "", lora3: str = "", lora4: str = "", lora1_multiplier: float = 1.0, lora2_multiplier: float = 1.0, lora3_multiplier: float = 1.0, lora4_multiplier: float = 1.0, video_path: Optional[str] = None, image_path: Optional[str] = None, strength: Optional[float] = None, negative_prompt: Optional[str] = None, embedded_cfg_scale: Optional[float] = None, split_uncond: Optional[bool] = None, guidance_scale: Optional[float] = None, use_fp8: bool = True ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Generate a single video with the given parameters""" global stop_event if stop_event.is_set(): yield [], "", "" return # Determine if this is a SkyReels model and what type is_skyreels = "skyreels" in model.lower() is_skyreels_i2v = is_skyreels and "i2v" in model.lower() is_skyreels_t2v = is_skyreels and "t2v" in model.lower() if is_skyreels: # Force certain parameters for SkyReels if negative_prompt is None: negative_prompt = "" if embedded_cfg_scale is None: embedded_cfg_scale = 1.0 # Force to 1.0 for SkyReels if split_uncond is None: split_uncond = True if guidance_scale is None: guidance_scale = cfg_scale # Use cfg_scale as guidance_scale if not provided # Determine the input channels based on model type if is_skyreels_i2v: dit_in_channels = 32 # SkyReels I2V uses 32 channels else: dit_in_channels = 16 # SkyReels T2V uses 16 channels (same as regular models) else: dit_in_channels = 16 # Regular Hunyuan models use 16 channels embedded_cfg_scale = cfg_scale if os.path.isabs(model): model_path = model else: model_path = os.path.normpath(os.path.join(dit_folder, model)) env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" env["BATCH_RUN_ID"] = f"{time.time()}" if seed == -1: current_seed = random.randint(0, 2**32 - 1) else: batch_id = int(env.get("BATCH_RUN_ID", "0").split('.')[-1]) if batch_size > 1: # Only modify seed for batch generation current_seed = (seed + batch_id * 100003) % (2**32) else: current_seed = seed clear_cuda_cache() command = [ sys.executable, "hv_generate_video.py", "--dit", model_path, "--vae", vae, "--text_encoder1", te1, "--text_encoder2", te2, "--prompt", prompt, "--video_size", str(height), str(width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", save_path, "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--embedded_cfg_scale", str(cfg_scale), "--output_type", output_type, "--attn_mode", attn_mode, "--blocks_to_swap", str(block_swap), "--fp8_llm", "--vae_chunk_size", "32", "--vae_spatial_tile_sample_min_size", "128" ] if use_fp8: command.append("--fp8") # Add negative prompt and embedded cfg scale for SkyReels if is_skyreels: command.extend(["--dit_in_channels", str(dit_in_channels)]) command.extend(["--guidance_scale", str(guidance_scale)]) if negative_prompt: command.extend(["--negative_prompt", negative_prompt]) if split_uncond: command.append("--split_uncond") # Add LoRA weights and multipliers if provided valid_loras = [] for weight, mult in zip([lora1, lora2, lora3, lora4], [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier]): if weight and weight != "None": valid_loras.append((os.path.join(lora_folder, weight), mult)) if valid_loras: weights = [weight for weight, _ in valid_loras] multipliers = [str(mult) for _, mult in valid_loras] command.extend(["--lora_weight"] + weights) command.extend(["--lora_multiplier"] + multipliers) if exclude_single_blocks: command.append("--exclude_single_blocks") if use_split_attn: command.append("--split_attn") # Handle input paths if video_path: command.extend(["--video_path", video_path]) if strength is not None: command.extend(["--strength", str(strength)]) elif image_path: command.extend(["--image_path", image_path]) # Only add strength parameter for non-SkyReels I2V models # SkyReels I2V doesn't use strength parameter for image-to-video generation if strength is not None and not is_skyreels_i2v: command.extend(["--strength", str(strength)]) print(f"{command}") p = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) videos = [] while True: if stop_event.is_set(): p.terminate() p.wait() yield [], "", "Generation stopped by user." return line = p.stdout.readline() if not line: if p.poll() is not None: break continue print(line, end='') if '|' in line and '%' in line and '[' in line and ']' in line: yield videos.copy(), f"Processing (seed: {current_seed})", line.strip() p.stdout.close() p.wait() clear_cuda_cache() time.sleep(0.5) # Collect generated video save_path_abs = os.path.abspath(save_path) if os.path.exists(save_path_abs): all_videos = sorted( [f for f in os.listdir(save_path_abs) if f.endswith('.mp4')], key=lambda x: os.path.getmtime(os.path.join(save_path_abs, x)), reverse=True ) matching_videos = [v for v in all_videos if f"_{current_seed}" in v] if matching_videos: video_path = os.path.join(save_path_abs, matching_videos[0]) # Collect parameters for metadata parameters = { "prompt": prompt, "width": width, "height": height, "video_length": video_length, "fps": fps, "infer_steps": infer_steps, "seed": current_seed, "model": model, "vae": vae, "te1": te1, "te2": te2, "save_path": save_path, "flow_shift": flow_shift, "cfg_scale": cfg_scale, "output_type": output_type, "attn_mode": attn_mode, "block_swap": block_swap, "lora_weights": [lora1, lora2, lora3, lora4], "lora_multipliers": [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier], "input_video": video_path if video_path else None, "input_image": image_path if image_path else None, "strength": strength, "negative_prompt": negative_prompt if is_skyreels else None, "embedded_cfg_scale": embedded_cfg_scale if is_skyreels else None } add_metadata_to_video(video_path, parameters) videos.append((str(video_path), f"Seed: {current_seed}")) yield videos, f"Completed (seed: {current_seed})", "" # The issue is in the process_batch function, in the section that handles different input types # Here's the corrected version of that section: def process_batch( prompt: str, width: int, height: int, batch_size: int, video_length: int, fps: int, infer_steps: int, seed: int, dit_folder: str, model: str, vae: str, te1: str, te2: str, save_path: str, flow_shift: float, cfg_scale: float, output_type: str, attn_mode: str, block_swap: int, exclude_single_blocks: bool, use_split_attn: bool, lora_folder: str, *args ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Process a batch of videos using Gradio's queue""" global stop_event stop_event.clear() all_videos = [] progress_text = "Starting generation..." yield [], "Preparing...", progress_text # Extract additional arguments num_lora_weights = 4 lora_weights = args[:num_lora_weights] lora_multipliers = args[num_lora_weights:num_lora_weights*2] extra_args = args[num_lora_weights*2:] # Determine if this is a SkyReels model and what type is_skyreels = "skyreels" in model.lower() is_skyreels_i2v = is_skyreels and "i2v" in model.lower() is_skyreels_t2v = is_skyreels and "t2v" in model.lower() # Handle input paths and additional parameters input_path = extra_args[0] if extra_args else None strength = float(extra_args[1]) if len(extra_args) > 1 else None # Get use_fp8 flag (it should be the last parameter) use_fp8 = bool(extra_args[-1]) if extra_args and len(extra_args) >= 3 else True # Get SkyReels specific parameters if applicable if is_skyreels: # Always set embedded_cfg_scale to 1.0 for SkyReels models embedded_cfg_scale = 1.0 negative_prompt = str(extra_args[2]) if len(extra_args) > 2 and extra_args[2] is not None else "" # Use cfg_scale for guidance_scale parameter guidance_scale = float(extra_args[3]) if len(extra_args) > 3 and extra_args[3] is not None else cfg_scale split_uncond = True if len(extra_args) > 4 and extra_args[4] else False else: negative_prompt = str(extra_args[2]) if len(extra_args) > 2 and extra_args[2] is not None else None guidance_scale = cfg_scale embedded_cfg_scale = cfg_scale split_uncond = bool(extra_args[4]) if len(extra_args) > 4 else None for i in range(batch_size): if stop_event.is_set(): break batch_text = f"Generating video {i + 1} of {batch_size}" yield all_videos.copy(), batch_text, progress_text # Handle different input types video_path = None image_path = None if input_path: # Check if it's an image file (common image extensions) is_image = False lower_path = input_path.lower() image_extensions = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp') is_image = any(lower_path.endswith(ext) for ext in image_extensions) # Only use image_path for SkyReels I2V models and actual image files if is_skyreels_i2v and is_image: image_path = input_path else: video_path = input_path # Prepare arguments for process_single_video single_video_args = [ prompt, width, height, batch_size, video_length, fps, infer_steps, seed, dit_folder, model, vae, te1, te2, save_path, flow_shift, cfg_scale, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, lora_folder ] single_video_args.extend(lora_weights) single_video_args.extend(lora_multipliers) single_video_args.extend([video_path, image_path, strength, negative_prompt, embedded_cfg_scale, split_uncond, guidance_scale, use_fp8]) for videos, status, progress in process_single_video(*single_video_args): if videos: all_videos.extend(videos) yield all_videos.copy(), f"Batch {i+1}/{batch_size}: {status}", progress yield all_videos, "Batch complete", "" def update_wanx_image_dimensions(image): """Update dimensions from uploaded image""" if image is None: return "", gr.update(value=832), gr.update(value=480) img = Image.open(image) w, h = img.size w = (w // 32) * 32 h = (h // 32) * 32 return f"{w}x{h}", w, h def calculate_wanx_width(height, original_dims): """Calculate width based on height maintaining aspect ratio""" if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_width = math.floor((height * aspect_ratio) / 32) * 32 return gr.update(value=new_width) def calculate_wanx_height(width, original_dims): """Calculate height based on width maintaining aspect ratio""" if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_height = math.floor((width / aspect_ratio) / 32) * 32 return gr.update(value=new_height) def update_wanx_from_scale(scale, original_dims): """Update dimensions based on scale percentage""" if not original_dims: return gr.update(), gr.update() orig_w, orig_h = map(int, original_dims.split('x')) new_w = math.floor((orig_w * scale / 100) / 32) * 32 new_h = math.floor((orig_h * scale / 100) / 32) * 32 return gr.update(value=new_w), gr.update(value=new_h) def recommend_wanx_flow_shift(width, height): """Get recommended flow shift value based on dimensions""" recommended_shift = 3.0 if (width == 832 and height == 480) or (width == 480 and height == 832) else 5.0 return gr.update(value=recommended_shift) def handle_wanx_gallery_select(evt: gr.SelectData, gallery) -> tuple: """Track selected index and video path when gallery item is clicked""" if gallery is None: return None, None if evt.index >= len(gallery): return None, None selected_item = gallery[evt.index] video_path = None # Extract the video path based on the item type if isinstance(selected_item, tuple): video_path = selected_item[0] elif isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) else: video_path = selected_item return evt.index, video_path def get_step_from_preview_path(path): match = re.search(r"step_(\d+)_", os.path.basename(path)) return int(match.group(1)) if match else -1 def wanx_generate_video( prompt, negative_prompt, input_image, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, wanx_input_end, task, dit_folder, dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora1="None", lora2="None", lora3="None", lora4="None", lora1_multiplier=1.0, lora2_multiplier=1.0, lora3_multiplier=1.0, lora4_multiplier=1.0, enable_cfg_skip=False, cfg_skip_mode="none", cfg_apply_ratio=0.7, control_video=None, control_strength=1.0, control_start=0.0, control_end=1.0, enable_preview: bool = False, preview_steps: int = 5 ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Generate video with WanX model (supports both i2v, t2v and Fun-Control)""" global stop_event current_previews = [] yield [], current_previews, "Preparing...", "" # Yield empty previews # Fix 1: Ensure lora_folder is a string lora_folder = str(lora_folder) if lora_folder else "lora" # Debug prints print(f"DEBUG - LoRA params: {lora1}, {lora2}, {lora3}, {lora4}") print(f"DEBUG - LoRA multipliers: {lora1_multiplier}, {lora2_multiplier}, {lora3_multiplier}, {lora4_multiplier}") print(f"DEBUG - LoRA folder: {lora_folder}") # Convert values safely to float or None try: slg_start_float = float(slg_start) if slg_start is not None and str(slg_start).lower() != "none" else None except (ValueError, TypeError): slg_start_float = None print(f"Warning: Could not convert slg_start '{slg_start}' to float") try: slg_end_float = float(slg_end) if slg_end is not None and str(slg_end).lower() != "none" else None except (ValueError, TypeError): slg_end_float = None print(f"Warning: Could not convert slg_end '{slg_end}' to float") print(f"slg_start_float: {slg_start_float}, slg_end_float: {slg_end_float}") if stop_event.is_set(): yield [], [], "", "" # Yield empty previews return run_id = f"{int(time.time())}_{random.randint(1000, 9999)}" unique_preview_suffix = f"wanx_{run_id}" # Add prefix for clarity # --- Construct unique preview paths --- preview_base_path = os.path.join(save_path, f"latent_preview_{unique_preview_suffix}") preview_mp4_path = preview_base_path + ".mp4" preview_png_path = preview_base_path + ".png" # Check if this is a Fun-Control task is_fun_control = "-FC" in task and control_video is not None if is_fun_control: print(f"DEBUG - Using Fun-Control mode with control video: {control_video}") # Verify control video is provided if not control_video: yield [], "Error: No control video provided", "Fun-Control requires a control video" return # Verify needed files exist for path_name, path in [ ("DIT", dit_path), ("VAE", vae_path), ("T5", t5_path), ("CLIP", clip_path) ]: if not os.path.exists(path): yield [], f"Error: {path_name} model not found", f"Model file doesn't exist: {path}" return # Get current seed or use provided seed current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) # Check if we need input image (required for i2v, not for t2v) if "i2v" in task and not input_image: yield [], "Error: No input image provided", "Please provide an input image for image-to-video generation" return # Check for Fun-Control requirements if is_fun_control and not control_video: yield [], "Error: No control video provided", "Please provide a control video for Fun-Control generation" return # Prepare environment env = os.environ.copy() env["PATH"] = os.path.dirname(sys.executable) + os.pathsep + env.get("PATH", "") env["PYTHONIOENCODING"] = "utf-8" clear_cuda_cache() # Fix 2: Create command array with all string values command = [ sys.executable, "wan_generate_video.py", "--task", str(task), "--prompt", str(prompt), "--video_size", str(height), str(width), "--video_length", str(video_length), "--fps", str(fps), "--infer_steps", str(infer_steps), "--save_path", str(save_path), "--seed", str(current_seed), "--flow_shift", str(flow_shift), "--guidance_scale", str(guidance_scale), "--output_type", str(output_type), "--attn_mode", str(attn_mode), "--blocks_to_swap", str(block_swap), "--dit", str(dit_path), "--vae", str(vae_path), "--t5", str(t5_path), "--sample_solver", str(sample_solver) ] # Fix 3: Only add boolean flags if they're True if enable_preview and preview_steps > 0: command.extend(["--preview", str(preview_steps)]) # --- ADDED: Pass the unique suffix --- command.extend(["--preview_suffix", unique_preview_suffix]) # --- End Pass Suffix --- print(f"DEBUG - Enabling preview every {preview_steps} steps with suffix {unique_preview_suffix}.") if enable_cfg_skip and cfg_skip_mode != "none": command.extend([ "--cfg_skip_mode", str(cfg_skip_mode), "--cfg_apply_ratio", str(cfg_apply_ratio) ]) if wanx_input_end and wanx_input_end != "none" and os.path.exists(str(wanx_input_end)): command.extend(["--end_image_path", str(wanx_input_end)]) command.extend(["--trim_tail_frames", "3"]) # Handle Fun-Control (control video path) if is_fun_control and control_video: command.extend(["--control_path", str(control_video)]) command.extend(["--control_weight", str(control_strength)]) command.extend(["--control_start", str(control_start)]) command.extend(["--control_end", str(control_end)]) # Handle SLG parameters if slg_layers and str(slg_layers).strip() and str(slg_layers).lower() != "none": try: # Make sure slg_layers is parsed as a list of integers slg_list = [] for layer in str(slg_layers).split(","): layer = layer.strip() if layer.isdigit(): # Only add if it's a valid integer slg_list.append(int(layer)) if slg_list: # Only add if we have valid layers command.extend(["--slg_layers", ",".join(map(str, slg_list))]) # Only add slg_start and slg_end if we have valid slg_layers try: if slg_start_float is not None and slg_start_float >= 0: command.extend(["--slg_start", str(slg_start_float)]) if slg_end_float is not None and slg_end_float <= 1.0: command.extend(["--slg_end", str(slg_end_float)]) except ValueError as e: print(f"Invalid SLG timing values: {str(e)}") except ValueError as e: print(f"Invalid SLG layers format: {slg_layers} - {str(e)}") # Add image path only for i2v task and if input image is provided if "i2v" in task and input_image: command.extend(["--image_path", str(input_image)]) command.extend(["--clip", str(clip_path)]) # CLIP is needed for i2v and Fun-Control # Add video path for v2v task if "v2v" in task and input_image: command.extend(["--video_path", str(input_image)]) # Add strength parameter for video-to-video if isinstance(guidance_scale, (int, float)) and guidance_scale > 0: command.extend(["--strength", str(guidance_scale)]) if negative_prompt: command.extend(["--negative_prompt", str(negative_prompt)]) # Add boolean flags correctly if fp8: command.append("--fp8") if fp8_scaled: command.append("--fp8_scaled") if fp8_t5: command.append("--fp8_t5") if exclude_single_blocks: command.append("--exclude_single_blocks") # Handle LoRA weights and multipliers lora_weights = [lora1, lora2, lora3, lora4] lora_multipliers = [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier] valid_loras = [] for weight, mult in zip(lora_weights, lora_multipliers): # Skip None, empty, or "None" values if weight is None or not str(weight) or str(weight).lower() == "none": continue # Ensure weight is a string weight_str = str(weight) # Construct full path and verify file exists full_path = os.path.join(lora_folder, weight_str) if not os.path.exists(full_path): print(f"LoRA file not found: {full_path}") continue # Add valid LoRA to the list valid_loras.append((full_path, mult)) # Only add LoRA parameters if we have valid LoRAs if valid_loras: weights = [w for w, _ in valid_loras] multipliers = [str(m) for _, m in valid_loras] command.extend(["--lora_weight"] + weights) command.extend(["--lora_multiplier"] + multipliers) # Make sure every item in command is a string command = [str(item) for item in command] print(f"Running: {' '.join(command)}") p = subprocess.Popen( command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env, text=True, encoding='utf-8', errors='replace', bufsize=1 ) videos = [] processed_preview_files = set() # Keep track of previews already yielded - REMAINS THE SAME IN UI FUNCTION # --- Reset preview state for this run --- current_preview_yield_path = None last_preview_mtime = 0 current_phase = "Preparing" # Add phase tracking like FramePack while True: if stop_event.is_set(): try: p.terminate() p.wait(timeout=5) except subprocess.TimeoutExpired: p.kill() p.wait() except Exception as e: print(f"Error terminating subprocess: {e}") yield [], [], "Generation stopped by user.", "" # Yield empty previews return line = p.stdout.readline() if not line: if p.poll() is not None: break time.sleep(0.01); continue line = line.strip() if not line: continue print(f"WANX SUBPROCESS: {line}") # Log subprocess output # --- Adopt FramePack's Parsing Logic --- status_text = f"Processing (seed: {current_seed})" # Default status progress_text_update = line # Default progress # Check for TQDM progress using regex tqdm_match = re.search(r'(\d+)\%\|.+\| (\d+)/(\d+) \[(\d{2}:\d{2})<(\d{2}:\d{2})', line) if tqdm_match: percentage = int(tqdm_match.group(1)) current_step = int(tqdm_match.group(2)) total_steps = int(tqdm_match.group(3)) time_elapsed = tqdm_match.group(4) time_remaining = tqdm_match.group(5) current_phase = f"Denoising Step {current_step}/{total_steps}" # Update phase # Format progress text like FramePack for JS compatibility progress_text_update = f"Step {current_step}/{total_steps} ({percentage}%) | Elapsed: {time_elapsed}, Remaining: {time_remaining}" status_text = f"Generating (seed: {current_seed}) - {current_phase}" elif "ERROR" in line.upper() or "TRACEBACK" in line.upper(): status_text = f"Error (seed: {current_seed})" progress_text_update = line # Show error line current_phase = "Error" # Add more phases if needed (e.g., "Decoding", "Saving") by checking logs elif "Decoding video..." in line: # Placeholder check current_phase = "Decoding Video" status_text = f"Generating (seed: {current_seed}) - {current_phase}" progress_text_update = "Decoding video..." elif "Video saved to:" in line: # Placeholder check current_phase = "Saved" status_text = f"Completed (seed: {current_seed})" progress_text_update = line # Show the save line # Add any other status parsing if needed preview_updated = False current_mtime = 0 found_preview_path = None if enable_preview: # --- MODIFIED: Check unique paths --- if os.path.exists(preview_mp4_path): current_mtime = os.path.getmtime(preview_mp4_path) found_preview_path = preview_mp4_path elif os.path.exists(preview_png_path): current_mtime = os.path.getmtime(preview_png_path) found_preview_path = preview_png_path # --- End Modified Check --- if found_preview_path and current_mtime > last_preview_mtime: print(f"DEBUG: Preview file updated: {found_preview_path} (mtime: {current_mtime})") # Yield the clean path (already unique) current_preview_yield_path = found_preview_path # No cache buster needed last_preview_mtime = current_mtime preview_updated = True # --- End Preview Check --- # --- YIELD --- # Yield progress and potentially updated unique preview path preview_list_for_yield = [current_preview_yield_path] if current_preview_yield_path else [] # Yield progress and potentially updated unique preview path list yield videos.copy(), preview_list_for_yield, status_text, progress_text_update p.stdout.close() rc = p.wait() clear_cuda_cache() time.sleep(0.5) # --- Collect final generated video --- generated_video_path = None if rc == 0: # Only look for video if process succeeded save_path_abs = os.path.abspath(save_path) if os.path.exists(save_path_abs): # Find the most recent mp4 containing the seed all_mp4_files = glob.glob(os.path.join(save_path_abs, f"*_{current_seed}*.mp4")) # Exclude files in the 'previews' subdirectory all_mp4_files = [f for f in all_mp4_files if "previews" not in os.path.dirname(f)] if all_mp4_files: # Find the *absolute* most recent one, as multiple might match seed in edge cases generated_video_path = max(all_mp4_files, key=os.path.getmtime) print(f"Found newly generated video: {generated_video_path}") # Add metadata (assuming add_metadata_to_video exists and works) parameters = { "prompt": prompt, "negative_prompt": negative_prompt, "input_image": input_image if "i2v" in task else None, "width": width, "height": height, "video_length": video_length, "fps": fps, "infer_steps": infer_steps, "flow_shift": flow_shift, "guidance_scale": guidance_scale, "seed": current_seed, "task": task, "dit_path": dit_path, "vae_path": vae_path, "t5_path": t5_path, "clip_path": clip_path if "i2v" in task or is_fun_control else None, "save_path": save_path, "output_type": output_type, "sample_solver": sample_solver, "exclude_single_blocks": exclude_single_blocks, "attn_mode": attn_mode, "block_swap": block_swap, "fp8": fp8, "fp8_scaled": fp8_scaled, "fp8_t5": fp8_t5, "lora_weights": [lora1, lora2, lora3, lora4], "lora_multipliers": [lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier], "slg_layers": slg_layers, "slg_start": slg_start, "slg_end": slg_end, "enable_cfg_skip": enable_cfg_skip, "cfg_skip_mode": cfg_skip_mode, "cfg_apply_ratio": cfg_apply_ratio, "control_video": control_video if is_fun_control else None, "control_strength": control_strength if is_fun_control else None, "control_start": control_start if is_fun_control else None, "control_end": control_end if is_fun_control else None, } try: add_metadata_to_video(generated_video_path, parameters) except NameError: print("Warning: add_metadata_to_video function not found. Skipping metadata.") except Exception as meta_err: print(f"Warning: Failed to add metadata: {meta_err}") # Append to the final video list videos.append((str(generated_video_path), f"Seed: {current_seed}")) else: print(f"Subprocess finished successfully (rc=0), but could not find generated video for seed {current_seed} in {save_path_abs}") # --- Final Yield --- final_status = f"Completed (seed: {current_seed})" if rc == 0 and generated_video_path else f"Failed (seed: {current_seed}, rc={rc})" final_progress = f"Video saved: {os.path.basename(generated_video_path)}" if rc == 0 and generated_video_path else f"Subprocess failed with exit code {rc}" # Check for the preview file one last time for the final update (using unique path) # --- MODIFIED Final Preview Check and List Creation --- final_preview_path = None # --- Use the UNIQUE paths defined earlier in the function --- if os.path.exists(preview_mp4_path): final_preview_path = os.path.abspath(preview_mp4_path) elif os.path.exists(preview_png_path): final_preview_path = os.path.abspath(preview_png_path) # --- End path checking --- final_preview_list_for_yield = [final_preview_path] if final_preview_path else [] # --- End Modified --- yield videos, final_preview_list_for_yield, final_status, final_progress def send_wanx_to_v2v( gallery: list, prompt: str, selected_index: int, width: int, height: int, video_length: int, fps: int, infer_steps: int, seed: int, flow_shift: float, guidance_scale: float, negative_prompt: str ) -> Tuple: """Send the selected WanX video to Video2Video tab""" if gallery is None or not gallery: return (None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) # If no selection made but we have videos, use the first one if selected_index is None and len(gallery) > 0: selected_index = 0 if selected_index is None or selected_index >= len(gallery): return (None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) selected_item = gallery[selected_index] # Handle different gallery item formats if isinstance(selected_item, tuple): video_path = selected_item[0] elif isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) else: video_path = selected_item # Clean up path for Video component if isinstance(video_path, tuple): video_path = video_path[0] # Make sure it's a string video_path = str(video_path) return (video_path, prompt, width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) def wanx_generate_video_batch( prompt, negative_prompt, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, task, dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers: int, slg_start: Optional[str], slg_end: Optional[str], lora1="None", lora2="None", lora3="None", lora4="None", lora1_multiplier=1.0, lora2_multiplier=1.0, lora3_multiplier=1.0, lora4_multiplier=1.0, batch_size=1, input_image=None # Make input_image optional and place it at the end ) -> Generator[Tuple[List[Tuple[str, str]], str, str], None, None]: """Generate videos with WanX with support for batches""" slg_start = None if slg_start == 'None' or slg_start is None else slg_start slg_end = None if slg_end == 'None' or slg_end is None else slg_end # Now safely convert to float if not None slg_start_float = float(slg_start) if slg_start is not None and isinstance(slg_start, (str, int, float)) else None slg_end_float = float(slg_end) if slg_end is not None and isinstance(slg_end, (str, int, float)) else None print(f"slg_start_float: {slg_start_float}, slg_end_float: {slg_end_float}") global stop_event stop_event.clear() all_videos = [] progress_text = "Starting generation..." yield [], "Preparing...", progress_text # Process each item in the batch for i in range(batch_size): if stop_event.is_set(): yield all_videos, "Generation stopped by user", "" return # Calculate seed for this batch item current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i batch_text = f"Generating video {i + 1} of {batch_size}" yield all_videos.copy(), batch_text, progress_text # Generate a single video using the existing function for videos, status, progress in wanx_generate_video( prompt, negative_prompt, input_image, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, current_seed, task, dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier ): if videos: all_videos.extend(videos) yield all_videos.copy(), f"Batch {i+1}/{batch_size}: {status}", progress yield all_videos, "Batch complete", "" def update_wanx_t2v_dimensions(size): """Update width and height based on selected size""" width, height = map(int, size.split('*')) return gr.update(value=width), gr.update(value=height) def handle_wanx_t2v_gallery_select(evt: gr.SelectData) -> int: """Track selected index when gallery item is clicked""" return evt.index def send_wanx_t2v_to_v2v( gallery, prompt, selected_index, width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt ) -> Tuple: """Send the selected WanX T2V video to Video2Video tab""" if not gallery or selected_index is None or selected_index >= len(gallery): return (None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) selected_item = gallery[selected_index] if isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, (tuple, list)): video_path = selected_item[0] else: video_path = selected_item if isinstance(video_path, tuple): video_path = video_path[0] return (str(video_path), prompt, width, height, video_length, fps, infer_steps, seed, flow_shift, guidance_scale, negative_prompt) def prepare_for_batch_extension(input_img, base_video, batch_size): """Prepare inputs for batch video extension""" if input_img is None: return None, None, batch_size, "No input image found", "" if base_video is None: return input_img, None, batch_size, "No base video selected for extension", "" return input_img, base_video, batch_size, "Preparing batch extension...", f"Will create {batch_size} variations of extended video" def concat_batch_videos(base_video_path, generated_videos, save_path, original_video_path=None): """Concatenate multiple generated videos with the base video""" if not base_video_path: return [], "No base video provided" if not generated_videos or len(generated_videos) == 0: return [], "No new videos generated" # Create output directory if it doesn't exist os.makedirs(save_path, exist_ok=True) # Track all extended videos extended_videos = [] # For each generated video, create an extended version for i, video_item in enumerate(generated_videos): try: # Extract video path from gallery item if isinstance(video_item, tuple): new_video_path = video_item[0] seed_info = video_item[1] if len(video_item) > 1 else "" elif isinstance(video_item, dict): new_video_path = video_item.get("name", video_item.get("data", None)) seed_info = "" else: new_video_path = video_item seed_info = "" if not new_video_path or not os.path.exists(new_video_path): print(f"Skipping missing video: {new_video_path}") continue # Create unique output filename timestamp = datetime.fromtimestamp(time.time()).strftime("%Y%m%d-%H%M%S") # Extract seed from seed_info if available seed_match = re.search(r"Seed: (\d+)", seed_info) seed_part = f"_seed{seed_match.group(1)}" if seed_match else f"_{i}" output_filename = f"extended_{timestamp}{seed_part}_{Path(base_video_path).stem}.mp4" output_path = os.path.join(save_path, output_filename) # Create a temporary file list for ffmpeg list_file = os.path.join(save_path, f"temp_list_{i}.txt") with open(list_file, "w") as f: f.write(f"file '{os.path.abspath(base_video_path)}'\n") f.write(f"file '{os.path.abspath(new_video_path)}'\n") # Run ffmpeg concatenation command = [ "ffmpeg", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", output_path ] subprocess.run(command, check=True, capture_output=True) # Clean up temporary file if os.path.exists(list_file): os.remove(list_file) # Add to extended videos list if successful if os.path.exists(output_path): seed_display = f"Extended {seed_info}" if seed_info else f"Extended video #{i+1}" extended_videos.append((output_path, seed_display)) except Exception as e: print(f"Error processing video {i}: {str(e)}") if not extended_videos: return [], "Failed to create any extended videos" return extended_videos, f"Successfully created {len(extended_videos)} extended videos" def wanx_extend_single_video( prompt, negative_prompt, input_image, base_video_path, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, task, dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers="", slg_start=0.0, slg_end=1.0, lora1="None", lora2="None", lora3="None", lora4="None", lora1_multiplier=1.0, lora2_multiplier=1.0, lora3_multiplier=1.0, lora4_multiplier=1.0 ): """Generate a single video and concatenate with base video""" # First, generate the video with proper parameter handling all_videos = [] # Sanitize lora parameters lora_weights = [str(lora1) if lora1 is not None else "None", str(lora2) if lora2 is not None else "None", str(lora3) if lora3 is not None else "None", str(lora4) if lora4 is not None else "None"] # Convert multipliers to float try: lora_multipliers = [float(lora1_multiplier), float(lora2_multiplier), float(lora3_multiplier), float(lora4_multiplier)] except (ValueError, TypeError): # Fallback to defaults if conversion fails lora_multipliers = [1.0, 1.0, 1.0, 1.0] # Debug print print(f"Sanitized LoRA weights: {lora_weights}") print(f"Sanitized LoRA multipliers: {lora_multipliers}") # Generate video for videos, status, progress in wanx_generate_video( prompt, negative_prompt, input_image, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, task, dit_path, vae_path, t5_path, clip_path, save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora_weights[0], lora_weights[1], lora_weights[2], lora_weights[3], lora_multipliers[0], lora_multipliers[1], lora_multipliers[2], lora_multipliers[3], enable_cfg_skip=False, cfg_skip_mode="none", cfg_apply_ratio=0.7 ): # Keep track of generated videos if videos: all_videos = videos # Forward progress updates yield all_videos, status, progress # Now concatenate with base video if we have something if all_videos and base_video_path and os.path.exists(base_video_path): try: print(f"Extending base video: {base_video_path}") # Create unique output filename timestamp = datetime.fromtimestamp(time.time()).strftime("%Y%m%d-%H%M%S") output_filename = f"extended_{timestamp}_seed{seed}_{Path(base_video_path).stem}.mp4" output_path = os.path.join(save_path, output_filename) # Extract the path from the gallery item new_video_path = all_videos[0][0] if isinstance(all_videos[0], tuple) else all_videos[0] # Create a temporary file list for ffmpeg list_file = os.path.join(save_path, f"temp_list_{seed}.txt") with open(list_file, "w") as f: f.write(f"file '{os.path.abspath(base_video_path)}'\n") f.write(f"file '{os.path.abspath(new_video_path)}'\n") print(f"Concatenating: {base_video_path} + {new_video_path}") # Run ffmpeg concatenation command = [ "ffmpeg", "-f", "concat", "-safe", "0", "-i", list_file, "-c", "copy", "-y", output_path ] subprocess.run(command, check=True, capture_output=True) # Clean up temporary file if os.path.exists(list_file): os.remove(list_file) # Return the extended video if successful if os.path.exists(output_path): extended_video = [(output_path, f"Extended (Seed: {seed})")] print(f"Successfully created extended video: {output_path}") yield extended_video, "Extended video created successfully", "" return else: print(f"Failed to create extended video at {output_path}") except Exception as e: print(f"Error creating extended video: {str(e)}") # If we got here, something went wrong with the concatenation yield all_videos, "Generated video (extension failed)", "" def process_batch_extension( prompt, negative_prompt, input_image, base_video, width, height, video_length, fps, infer_steps, flow_shift, guidance_scale, seed, batch_size, task, dit_folder, dit_path, vae_path, t5_path, clip_path, # <<< Added dit_folder save_path, output_type, sample_solver, exclude_single_blocks, attn_mode, block_swap, fp8, fp8_scaled, fp8_t5, lora_folder, slg_layers, slg_start, slg_end, lora1="None", lora2="None", lora3="None", lora4="None", lora1_multiplier=1.0, lora2_multiplier=1.0, lora3_multiplier=1.0, lora4_multiplier=1.0 ): """Process a batch of video extensions one at a time""" global stop_event stop_event.clear() all_extended_videos = [] # Store successfully extended videos progress_text = "Starting video extension batch..." yield [], progress_text, "" # Initial yield try: # Ensure batch_size is treated as an integer batch_size = int(batch_size) except (ValueError, TypeError): batch_size = 1 print("Warning: Invalid batch_size, defaulting to 1.") # Ensure base_video exists if not base_video or not os.path.exists(base_video): yield [], "Error: Base video not found", f"Cannot find video at {base_video}" return # Process each batch item independently for i in range(batch_size): if stop_event.is_set(): yield all_extended_videos, "Extension stopped by user", "" return # Calculate seed for this batch item current_seed = seed if seed == -1: current_seed = random.randint(0, 2**32 - 1) elif batch_size > 1: current_seed = seed + i batch_text = f"Processing extension {i+1}/{batch_size} (seed: {current_seed})" yield all_extended_videos, batch_text, progress_text # Update progress # Use the direct wrapper with correct parameter order, including dit_folder generation_iterator = wanx_extend_video_wrapper( prompt=prompt, negative_prompt=negative_prompt, input_image=input_image, base_video_path=base_video, width=width, height=height, video_length=video_length, fps=fps, infer_steps=infer_steps, flow_shift=flow_shift, guidance_scale=guidance_scale, seed=current_seed, task=task, dit_folder=dit_folder, # <<< Pass the folder path dit_path=dit_path, # <<< Pass the model filename vae_path=vae_path, t5_path=t5_path, clip_path=clip_path, save_path=save_path, output_type=output_type, sample_solver=sample_solver, exclude_single_blocks=exclude_single_blocks, attn_mode=attn_mode, block_swap=block_swap, fp8=fp8, fp8_scaled=fp8_scaled, fp8_t5=fp8_t5, lora_folder=lora_folder, slg_layers=slg_layers, slg_start=slg_start, slg_end=slg_end, lora1=lora1, lora2=lora2, lora3=lora3, lora4=lora4, lora1_multiplier=lora1_multiplier, lora2_multiplier=lora2_multiplier, lora3_multiplier=lora3_multiplier, lora4_multiplier=lora4_multiplier ) # Iterate through the generator for this single extension final_videos_for_item = [] final_status_for_item = "Unknown status" final_progress_for_item = "" try: for videos, status, progress in generation_iterator: # Forward progress information immediately yield all_extended_videos, f"Batch {i+1}/{batch_size}: {status}", progress # Store the latest state for this item final_videos_for_item = videos final_status_for_item = status final_progress_for_item = progress # After the loop for one item finishes, check the result if final_videos_for_item: # Check if the video is actually an extended one is_extended = any("Extended" in (v[1] if isinstance(v, tuple) else "") for v in final_videos_for_item) if is_extended: all_extended_videos.extend(final_videos_for_item) print(f"Added extended video to collection (total: {len(all_extended_videos)})") else: # It was just the generated segment, maybe log this? print(f"Video segment generated for batch {i+1} but extension failed or wasn't performed.") else: print(f"No video returned for batch item {i+1}.") except Exception as e: print(f"Error during single extension processing (batch {i+1}): {e}") yield all_extended_videos, f"Error in batch {i+1}: {e}", "" # Clean CUDA cache between generations clear_cuda_cache() time.sleep(0.5) # Final yield after the loop yield all_extended_videos, "Batch extension complete", "" def handle_extend_generation(base_video_path: str, new_videos: list, save_path: str, current_gallery: list) -> tuple: """Combine generated video with base video and update gallery""" if not base_video_path: return current_gallery, "Extend failed: No base video provided" if not new_videos: return current_gallery, "Extend failed: No new video generated" # Ensure save path exists os.makedirs(save_path, exist_ok=True) # Get the first video from new_videos (gallery item) new_video_path = new_videos[0][0] if isinstance(new_videos[0], tuple) else new_videos[0] # Create a unique output filename timestamp = datetime.fromtimestamp(time.time()).strftime("%Y%m%d-%H%M%S") output_filename = f"extended_{timestamp}_{Path(base_video_path).stem}.mp4" output_path = str(Path(save_path) / output_filename) try: # Concatenate the videos using ffmpeg ( ffmpeg .input(base_video_path) .concat( ffmpeg.input(new_video_path) ) .output(output_path) .run(overwrite_output=True, quiet=True) ) # Create a new gallery entry with the combined video updated_gallery = [(output_path, f"Extended video: {Path(output_path).stem}")] return updated_gallery, f"Successfully extended video to {Path(output_path).name}" except Exception as e: print(f"Error extending video: {str(e)}") return current_gallery, f"Failed to extend video: {str(e)}" # UI setup with gr.Blocks( theme=themes.Default( primary_hue=colors.Color( name="custom", c50="#E6F0FF", c100="#CCE0FF", c200="#99C1FF", c300="#66A3FF", c400="#3384FF", c500="#0060df", # This is your main color c600="#0052C2", c700="#003D91", c800="#002961", c900="#001430", c950="#000A18" ) ), css=""" .gallery-item:first-child { border: 2px solid #4CAF50 !important; } .gallery-item:first-child:hover { border-color: #45a049 !important; } .green-btn { background: linear-gradient(to bottom right, #2ecc71, #27ae60) !important; color: white !important; border: none !important; } .green-btn:hover { background: linear-gradient(to bottom right, #27ae60, #219651) !important; } .refresh-btn { max-width: 40px !important; min-width: 40px !important; height: 40px !important; border-radius: 50% !important; padding: 0 !important; display: flex !important; align-items: center !important; justify-content: center !important; } .light-blue-btn { background: linear-gradient(to bottom right, #AEC6CF, #9AB8C4) !important; /* Light blue gradient */ color: #333 !important; /* Darker text for readability */ border: 1px solid #9AB8C4 !important; /* Subtle border */ } .light-blue-btn:hover { background: linear-gradient(to bottom right, #9AB8C4, #8AA9B5) !important; /* Slightly darker on hover */ border-color: #8AA9B5 !important; } """, ) as demo: # Add state for tracking selected video indices in both tabs selected_index = gr.State(value=None) # For Text to Video v2v_selected_index = gr.State(value=None) # For Video to Video params_state = gr.State() #New addition i2v_selected_index = gr.State(value=None) skyreels_selected_index = gr.State(value=None) wanx_i2v_selected_index = gr.State(value=None) extended_videos = gr.State(value=[]) wanx_base_video = gr.State(value=None) wanx_sharpest_frame_number = gr.State(value=None) wanx_sharpest_frame_path = gr.State(value=None) wanx_trimmed_video_path = gr.State(value=None) wanx_v2v_selected_index = gr.State(value=None) wanx_t2v_selected_index = gr.State(value=None) framepack_selected_index = gr.State(value=None) framepack_original_dims = gr.State(value="") fpe_selected_index = gr.State(value=None) demo.load(None, None, None, js=""" () => { document.title = 'H1111'; function updateTitle(text) { if (text && text.trim()) { // Regex for the FramePack format: "Item ... (...)% | ... Remaining: HH:MM" const framepackMatch = text.match(/.*?\((\d+)%\).*?Remaining:\s*(\d{2}:\d{2})/); // Regex for standard tqdm format (like WanX uses) const tqdmMatch = text.match(/(\d+)%\|.*\[.*<(\d{2}:\d{2})/); // Adjusted slightly for robustness if (framepackMatch) { // Handle FramePack format const percentage = framepackMatch[1]; const timeRemaining = framepackMatch[2]; document.title = `[${percentage}% ETA: ${timeRemaining}] - H1111`; } else if (tqdmMatch) { // <<< ADDED ELSE IF for standard tqdm // Handle standard tqdm format const percentage = tqdmMatch[1]; const timeRemaining = tqdmMatch[2]; document.title = `[${percentage}% ETA: ${timeRemaining}] - H1111`; } else { // Optional: Reset title if neither format matches? // document.title = 'H1111'; } } } setTimeout(() => { // This selector should still find all relevant progress textareas const progressElements = document.querySelectorAll('textarea.scroll-hide'); progressElements.forEach(element => { if (element) { new MutationObserver(() => { updateTitle(element.value); }).observe(element, { attributes: true, childList: true, characterData: true }); } }); }, 1000); } """) with gr.Tabs() as tabs: #FRAME PACK TAB with gr.Tab(id=10, label="FramePack") as framepack_tab: with gr.Row(): with gr.Column(scale=4): framepack_prompt = gr.Textbox( scale=3, label="Prompt (Supports sections: index:prompt;;;index:prompt)", value="cinematic video of a cat wizard casting a spell", lines=3, info="Use '0:prompt;;;-1:prompt' or '0-2:prompt;;;3:prompt'. Index total sections -1 is last section." ) framepack_negative_prompt = gr.Textbox(scale=3, label="Negative Prompt", value="", lines=3) with gr.Column(scale=1): framepack_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) framepack_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) framepack_is_f1 = gr.Checkbox(label="🏎️ Use F1 Model", value=False, info="Switches to the F1 model (different DiT path and logic).") with gr.Column(scale=2): framepack_batch_progress = gr.Textbox(label="Status", interactive=False, value="") framepack_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): framepack_generate_btn = gr.Button("Generate FramePack Video", elem_classes="green-btn") framepack_stop_btn = gr.Button("Stop Generation", variant="stop") # Main Content with gr.Row(): # --- Left Column --- with gr.Column(): framepack_input_image = gr.Image(label="Input Image (Video Start)", type="filepath") with gr.Row(): framepack_use_random_folder = gr.Checkbox(label="Use Random Images from Folder", value=False, info="If checked, 'Input Image (Video Start)' is hidden. Each batch item uses a random image from the folder.") framepack_input_folder_path = gr.Textbox( label="Image Folder Path", placeholder="Path to folder containing images for batch processing", visible=False # Initially hidden ) with gr.Row(visible=False) as framepack_folder_options_row: # Parent Row for folder options framepack_validate_folder_btn = gr.Button("Validate Folder") framepack_folder_status_text = gr.Textbox( label="Folder Status", placeholder="Validation status will appear here", interactive=False ) with gr.Accordion("Optional End Frame Control (normal model only)", open=False): framepack_input_end_frame = gr.Image(label="End Frame Image (Video End)", type="filepath", scale=1) framepack_end_frame_influence = gr.Dropdown( label="End Frame Influence Mode", choices=["last", "half", "progressive", "bookend"], value="last", info="How the end frame affects generation (if provided)", visible=False ) framepack_end_frame_weight = gr.Slider( minimum=0.0, maximum=1.0, step=0.05, value=0.5, # Default changed from 0.3 label="End Frame Weight", info="Influence strength of the end frame (if provided)", visible=False ) gr.Markdown("### Resolution Options (Choose One)") framepack_target_resolution = gr.Number( label="Option 1: Target Resolution (Uses Buckets)", value=640, minimum=0, maximum=1280, step=32, info="Target bucket size (e.g., 640 for 640x640). Uses input image aspect ratio. Final size divisible by 32.", interactive=True ) with gr.Accordion("Option 2: Explicit Resolution (Overrides Option 1)", open=False): framepack_scale_slider = gr.Slider( minimum=1, maximum=200, value=100, step=1, label="Scale % (UI Only)" ) with gr.Row(): framepack_width = gr.Number( label="Width", value=None, minimum=0, step=32, info="Must be divisible by 32.", interactive=True ) framepack_calc_height_btn = gr.Button("→") framepack_calc_width_btn = gr.Button("←") framepack_height = gr.Number( label="Height", value=None, minimum=0, step=32, info="Must be divisible by 32.", interactive=True ) framepack_total_second_length = gr.Slider(minimum=1.0, maximum=120.0, step=0.5, label="Total Video Length (seconds)", value=5.0) framepack_video_sections = gr.Number( label="Total Video Sections (Overrides seconds if > 0)", value=None, step=1, info="Specify exact number of sections. If set, 'Total Video Length (seconds)' is ignored by the backend." ) framepack_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Output FPS", value=30) with gr.Row(): framepack_seed = gr.Number(label="Seed (-1 for random)", value=-1) framepack_random_seed =gr.Button("🎲️") framepack_steps = gr.Slider(minimum=1, maximum=100, step=1, label="Steps", value=25, interactive=True) # Moved here # --- Right Column --- with gr.Column(): framepack_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[1], object_fit="contain", height="auto", show_label=True, elem_id="gallery_framepack", allow_preview=True, preview=True ) with gr.Accordion("Latent Preview (During Generation)", open=True): with gr.Row(): framepack_enable_preview = gr.Checkbox(label="Enable Latent Preview", value=True) framepack_use_full_video_preview = gr.Checkbox(label="Use Full Video Previews (slower)", value=False) with gr.Row(): framepack_preview_every_n_sections = gr.Slider( minimum=1, maximum=50, step=1, value=1, label="Preview Every N Sections", info="Generates previews during the sampling loop." ) framepack_preview_output = gr.Video( # Changed from Gallery to Video label="Latest Preview", height=300, interactive=False, # Not interactive for display elem_id="framepack_preview_video" ) framepack_skip_btn = gr.Button("Skip Batch Item", elem_classes="light-blue-btn") with gr.Group(): with gr.Row(): framepack_refresh_lora_btn = gr.Button("🔄 LoRA", elem_classes="refresh-btn") # Specific LoRA refresh framepack_lora_folder = gr.Textbox(label="LoRa Folder", value="lora", scale=4) framepack_lora_weights = [] framepack_lora_multipliers = [] for i in range(4): # Assuming max 4 LoRAs like other tabs with gr.Row(): framepack_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options("lora"), value="None", allow_custom_value=False, interactive=True, scale=2 )) framepack_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0, scale=1, interactive=True )) # Fixed Generation Parameters Section with gr.Accordion("Generation Parameters", open=True): with gr.Row(): framepack_distilled_guidance_scale = gr.Slider(minimum=1.0, maximum=20.0, step=0.1, label="Distilled Guidance Scale (embedded_cfg_scale)", value=10.0, interactive=True) framepack_guidance_scale = gr.Slider(minimum=1.0, maximum=10.0, step=0.1, label="Guidance Scale (CFG)", value=1.0, interactive=True, info="Default 1.0 (no CFG), backend recommends not changing.") with gr.Row(): framepack_guidance_rescale = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="CFG Rescale (rs)", value=0.0, interactive=True, info="Default 0.0, backend recommends not changing.") framepack_latent_window_size = gr.Number(label="Latent Window Size", value=9, interactive=True, info="Default 9") framepack_sample_solver = gr.Dropdown(label="Sample Solver", choices=["unipc", "dpm++", "vanilla"], value="unipc", interactive=True) with gr.Accordion("Advanced Section Control (Optional)", open=False): gr.Markdown( "Define specific prompts and starting images for different sections of the video. " "For the index you can input a range or a single index. A 5 second default video has 4 sections. The first section is 0 and the last is 3" ) # --- Define section controls explicitly --- with gr.Row(): with gr.Column(scale=1): with gr.Group(): gr.Markdown("**--- Control Slot 1 ---**") with gr.Row(): framepack_sec_1 = gr.Textbox(label="Index/Range", value="0", placeholder="e.g., 0 or 0-1", interactive=True) framepack_sec_prompt_1 = gr.Textbox(label="Prompt Override", lines=2, placeholder="Overrides base prompt for these sections") framepack_sec_image_1 = gr.Image(label="Start Image Override", type="filepath", scale=1) with gr.Column(scale=1): with gr.Group(): gr.Markdown("**--- Control Slot 2 ---**") with gr.Row(): framepack_sec_2 = gr.Textbox(label="Index/Range", value="1", placeholder="e.g., 2 or 2-3", interactive=True) framepack_sec_prompt_2 = gr.Textbox(label="Prompt Override", lines=2) framepack_sec_image_2 = gr.Image(label="Start Image Override", type="filepath", scale=1) with gr.Row(): with gr.Column(scale=1): with gr.Group(): gr.Markdown("**--- Control Slot 3 ---**") with gr.Row(): framepack_sec_3 = gr.Textbox(label="Index/Range", value="2", placeholder="e.g., 4 or 4-5", interactive=True) framepack_sec_prompt_3 = gr.Textbox(label="Prompt Override", lines=2) framepack_sec_image_3 = gr.Image(label="Start Image Override", type="filepath", scale=1) with gr.Column(scale=1): with gr.Group(): gr.Markdown("**--- Control Slot 4 ---**") with gr.Row(): framepack_sec_4 = gr.Textbox(label="Index/Range", value="3", placeholder="e.g., 6 or 6-7", interactive=True) framepack_sec_prompt_4 = gr.Textbox(label="Prompt Override", lines=2) framepack_sec_image_4 = gr.Image(label="Start Image Override", type="filepath", scale=1) # Group section control components for easier passing to functions (remains the same) framepack_secs = [framepack_sec_1, framepack_sec_2, framepack_sec_3, framepack_sec_4] framepack_sec_prompts = [framepack_sec_prompt_1, framepack_sec_prompt_2, framepack_sec_prompt_3, framepack_sec_prompt_4] framepack_sec_images = [framepack_sec_image_1, framepack_sec_image_2, framepack_sec_image_3, framepack_sec_image_4] # Performance/Memory Accordion - Updated with gr.Accordion("Performance / Memory", open=True): with gr.Row(): framepack_fp8 = gr.Checkbox(label="Use FP8 DiT", value=False, info="Enable FP8 precision for the main Transformer model.") framepack_fp8_llm = gr.Checkbox(label="Use FP8 LLM (Text Encoder 1)", value=False, info="Enable FP8 for the Llama text encoder.", visible=False) framepack_fp8_scaled = gr.Checkbox(label="Use Scaled FP8 DiT", value=False, info="Requires FP8 DiT. Use scaled math (potential quality improvement).") framepack_blocks_to_swap = gr.Slider(minimum=0, maximum=39, step=1, label="Blocks to Swap (to Save VRAM, 0=disable)", value=26, info="Higher values = less VRAM usage but slower generation") framepack_bulk_decode = gr.Checkbox(label="Bulk Decode Frames (Faster Decode, Higher VRAM)", value=False, info="Decode all frames at once instead of section by section.") with gr.Row(): framepack_attn_mode = gr.Dropdown( label="Attention Mode", choices=["torch", "sdpa", "flash", "xformers", "sageattn"], # Added choices from script value="sdpa", # Defaulting to sdpa interactive=True ) framepack_vae_chunk_size = gr.Number(label="VAE Chunk Size (CausalConv3d)", value=32, step=1, minimum=0, info="0 or None=disable (Default: None)") framepack_vae_spatial_tile_sample_min_size = gr.Number(label="VAE Spatial Tile Min Size", value=128, step=16, minimum=0, info="0 or None=disable (Default: None)") framepack_device = gr.Textbox(label="Device Override (optional)", placeholder="e.g., cuda:0, cpu") with gr.Row(): framepack_use_teacache = gr.Checkbox(label="Use TeaCache", value=False, info="Enable TeaCache for faster generation (shits hands).") framepack_teacache_steps = gr.Number(label="TeaCache Init Steps", value=25, step=1, minimum=1, info="Steps for TeaCache init (match Inference Steps)") framepack_teacache_thresh = gr.Slider(label="TeaCache Threshold", minimum=0.0, maximum=1.0, step=0.01, value=0.15, info="Relative L1 distance threshold for skipping.") with gr.Accordion("Model Paths / Advanced", open=False): with gr.Row(): framepack_transformer_path = gr.Textbox(label="Transformer Path (DiT)", value="hunyuan/FramePackI2V_HY_bf16.safetensors", interactive=True) framepack_vae_path = gr.Textbox(label="VAE Path", value="hunyuan/pytorch_model.pt") with gr.Row(): framepack_text_encoder_path = gr.Textbox(label="Text Encoder 1 (Llama) Path *Required*", value="hunyuan/llava_llama3_fp16.safetensors") framepack_text_encoder_2_path = gr.Textbox(label="Text Encoder 2 (CLIP) Path *Required*", value="hunyuan/clip_l.safetensors") with gr.Row(): framepack_image_encoder_path = gr.Textbox(label="Image Encoder (SigLIP) Path *Required*", value="hunyuan/model.safetensors") framepack_save_path = gr.Textbox(label="Save Path *Required*", value="outputs") ### FRAMEPACK EXTENSION with gr.Tab(id=11, label="FramePack-Extension") as framepack_extension_tab: with gr.Row(): with gr.Column(scale=4): fpe_prompt = gr.Textbox( scale=3, label="Prompt", value="cinematic video of a cat wizard casting a spell, epic action scene", lines=3 ) fpe_negative_prompt = gr.Textbox(scale=3, label="Negative Prompt", value="", lines=3) with gr.Column(scale=1): fpe_use_normal_framepack = gr.Checkbox(label="Use Normal FramePack Model", value=False, info="Uses og model supports end frame. Default is F1 model.") fpe_batch_count = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): fpe_batch_progress = gr.Textbox(label="Status", interactive=False, value="") fpe_progress_text = gr.Textbox(label="Progress", interactive=False, lines=1, elem_id="fpe_progress_text") # Unique elem_id with gr.Row(): fpe_generate_btn = gr.Button("Generate Extended Video", elem_classes="green-btn") fpe_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): # Left column for inputs fpe_input_video = gr.Video(label="Input Video for Extension", sources=['upload'], height=300) with gr.Accordion("Optional End Frame (for Normal FramePack Model)", open=False, visible=False) as fpe_end_frame_accordion: fpe_end_frame = gr.Image(label="End Frame for Extension", type="filepath") fpe_end_frame_weight = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, value=1.0, label="End Frame Weight") with gr.Accordion("Optional Start Guidance Image (for F1 Model Extension)", open=False, visible=True) as fpe_start_guidance_accordion: # Initially hidden fpe_start_guidance_image = gr.Image(label="Start Guidance Image for Extension", type="filepath") fpe_start_guidance_image_clip_weight = gr.Slider( minimum=0.0, maximum=2.0, step=0.05, value=0.75, label="Start Guidance Image CLIP Weight", info="Blend weight for the guidance image's CLIP embedding with input video's first frame CLIP." ) fpe_use_guidance_image_as_first_latent = gr.Checkbox( label="Use Guidance Image as First Latent", value=False, info="If checked, the VAE latent of the guidance image will be used as the initial conditioning for the first generated segment. Turn down context frames when using this" ) gr.Markdown("### Core Generation Parameters") with gr.Row(): fpe_seed = gr.Number(label="Seed (-1 for random)", value=-1) # fpe_random_seed_btn = gr.Button("🎲️") # Optional: Add random seed button fpe_resolution_max_dim = gr.Number(label="Resolution (Max Dimension)", value=640, step=32, info="Target max width/height for bucket.") fpe_total_second_length = gr.Slider(minimum=1.0, maximum=120.0, step=0.5, label="Additional Video Length (seconds)", value=5.0) fpe_latent_window_size = gr.Slider(minimum=9, maximum=33, step=1, label="Latent Window Size", value=9, info="Default 9 for F1 model.") fpe_steps = gr.Slider(minimum=1, maximum=100, step=1, label="Inference Steps", value=25) with gr.Row(): fpe_cfg_scale = gr.Slider(minimum=1.0, maximum=32.0, step=0.1, label="CFG Scale", value=1.0, info="Usually 1.0 for F1 (no external CFG).") fpe_distilled_guidance_scale = gr.Slider(minimum=1.0, maximum=32.0, step=0.1, label="Distilled Guidance (GS)", value=3.0) # fpe_rs_scale = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="CFG Rescale (RS)", value=0.0, visible=False) with gr.Row(): with gr.Accordion("Advanced & Performance", open=True): fpe_gpu_memory_preservation = gr.Slider(label="GPU Memory Preserve (GB)", minimum=1.0, maximum=16.0, value=6.0, step=0.1) fpe_use_teacache = gr.Checkbox(label="Use TeaCache", value=False) fpe_no_resize = gr.Checkbox(label="Force Original Video Resolution (No Resize)", value=False) fpe_extension_only = gr.Checkbox(label="Save Extension Only", value=False, info="If checked, only the newly generated extension part of the video will be saved.") fpe_mp4_crf = gr.Slider(label="MP4 CRF (Quality)", minimum=0, maximum=51, value=1, step=1, info="Lower is better quality, larger file.") fpe_num_clean_frames = gr.Slider(label="Context Frames (1x from Input)", minimum=1, maximum=10, value=5, step=1) fpe_vae_batch_size = gr.Slider(label="VAE Batch Size (Input Video Encoding)", minimum=4, maximum=128, value=72, step=4) fpe_attn_mode = gr.Dropdown(label="Attention Mode (DiT)", choices=["torch", "sdpa", "flash", "xformers", "sageattn"], value="torch") fpe_fp8_llm = gr.Checkbox(label="Use FP8 LLM (Text Encoder 1)", value=False, visible=False) fpe_vae_chunk_size = gr.Number(label="VAE Chunk Size (CausalConv3d)", value=32, step=1, minimum=0, info="0 or None=disable") fpe_vae_spatial_tile_sample_min_size = gr.Number(label="VAE Spatial Tile Min Size", value=128, step=16, minimum=0, info="0 or None=disable") with gr.Column(): # Right column for outputs and advanced settings fpe_output_gallery = gr.Gallery( label="Generated Extended Videos", columns=[1], rows=[1], # Show one main video at a time object_fit="contain", height=480, show_label=True, elem_id="gallery_framepack_extension", allow_preview=True, preview=True ) with gr.Accordion("Live Preview (During Generation)", open=True): with gr.Row(): fpe_enable_preview = gr.Checkbox(label="Enable Live Preview", value=True, visible=False) fpe_preview_interval = gr.Slider( minimum=1, maximum=50, step=1, value=5, label="Preview Every N Steps", info="Saves a PNG preview during sampling.", visible=False ) fpe_preview_output_component = gr.Video( # Changed to Video for MP4 previews label="Latest Section Preview", height=300, interactive=False, elem_id="fpe_preview_video" ) # fpe_skip_btn = gr.Button("Skip Batch Item", elem_classes="light-blue-btn") # Optional gr.Markdown("### LoRA Configuration") with gr.Row(): fpe_refresh_lora_btn = gr.Button("🔄 LoRA", elem_classes="refresh-btn") fpe_lora_folder = gr.Textbox(label="LoRA Folder", value="lora", scale=4) fpe_lora_weights_ui = [] fpe_lora_multipliers_ui = [] for i in range(4): with gr.Row(): fpe_lora_weights_ui.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options("lora"), value="None", allow_custom_value=False, interactive=True, scale=2 )) fpe_lora_multipliers_ui.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0, scale=1, interactive=True )) with gr.Row(): with gr.Accordion("Model Paths (FramePack-Extension)", open=False): fpe_transformer_path = gr.Textbox(label="DiT Path (F1 Model)", value="hunyuan/FramePack_F1_I2V_HY_20250503.safetensors") # Default to F1 fpe_vae_path = gr.Textbox(label="VAE Path", value="hunyuan/pytorch_model.pt") fpe_text_encoder_path = gr.Textbox(label="Text Encoder 1 (Llama)", value="hunyuan/llava_llama3_fp16.safetensors") fpe_text_encoder_2_path = gr.Textbox(label="Text Encoder 2 (CLIP)", value="hunyuan/clip_l.safetensors") fpe_image_encoder_path = gr.Textbox(label="Image Encoder (SigLIP)", value="hunyuan/model.safetensors") fpe_save_path = gr.Textbox(label="Save Path (Output Directory)", value="outputs/framepack_extensions") # Text to Video Tab with gr.Tab(id=1, label="Hunyuan-t2v"): with gr.Row(): with gr.Column(scale=4): prompt = gr.Textbox(scale=3, label="Enter your prompt", value="POV video of a cat chasing a frob.", lines=5) with gr.Column(scale=1): token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress") progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): generate_btn = gr.Button("Generate Video", elem_classes="green-btn") stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): t2v_width = gr.Slider(minimum=64, maximum=1536, step=16, value=544, label="Video Width") t2v_height = gr.Slider(minimum=64, maximum=1536, step=16, value=544, label="Video Height") video_length = gr.Slider(minimum=1, maximum=201, step=1, label="Video Length in Frames", value=25, elem_id="my_special_slider") fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=24, elem_id="my_special_slider") infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=30, elem_id="my_special_slider") flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=11.0, elem_id="my_special_slider") cfg_scale = gr.Slider(minimum=0.0, maximum=14.0, step=0.1, label="cfg Scale", value=7.0, elem_id="my_special_slider") with gr.Column(): with gr.Row(): video_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[2], object_fit="contain", height="auto", show_label=True, elem_id="gallery", allow_preview=True, preview=True ) with gr.Row():send_t2v_to_v2v_btn = gr.Button("Send Selected to Video2Video") with gr.Row(): refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") lora_weights = [] lora_multipliers = [] for i in range(4): with gr.Column(): lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) seed = gr.Number(label="Seed (use -1 for random)", value=-1) dit_folder = gr.Textbox(label="DiT Model Folder", value="hunyuan") model = gr.Dropdown( label="DiT Model", choices=get_dit_models("hunyuan"), value="mp_rank_00_model_states.pt", allow_custom_value=True, interactive=True ) vae = gr.Textbox(label="vae", value="hunyuan/pytorch_model.pt") te1 = gr.Textbox(label="te1", value="hunyuan/llava_llama3_fp16.safetensors") te2 = gr.Textbox(label="te2", value="hunyuan/clip_l.safetensors") save_path = gr.Textbox(label="Save Path", value="outputs") with gr.Row(): lora_folder = gr.Textbox(label="LoRA Folder", value="lora") output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") use_split_attn = gr.Checkbox(label="Use Split Attention", value=False) use_fp8 = gr.Checkbox(label="Use FP8 (faster but lower precision)", value=True) attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") block_swap = gr.Slider(minimum=0, maximum=36, step=1, label="Block Swap to Save Vram", value=0) #Image to Video Tab with gr.Tab(label="Hunyuan-i2v") as i2v_tab: # Keep tab name consistent if needed elsewhere # ... (Keep existing Rows for prompt, batch size, progress) ... with gr.Row(): with gr.Column(scale=4): i2v_prompt = gr.Textbox(scale=3, label="Enter your prompt", value="POV video of a cat chasing a frob.", lines=5) with gr.Column(scale=1): i2v_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) i2v_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): i2v_batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress_i2v") # Unique elem_id i2v_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text_i2v") # Unique elem_id with gr.Row(): i2v_generate_btn = gr.Button("Generate Video", elem_classes="green-btn") i2v_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): i2v_input = gr.Image(label="Input Image", type="filepath") # REMOVED i2v_strength slider, as hv_i2v_generate_video.py doesn't seem to use it based on the sample command # i2v_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.75, label="Denoise Strength") scale_slider = gr.Slider(minimum=1, maximum=200, value=100, step=1, label="Scale % (UI Only - affects W/H)") # Clarified UI only original_dims = gr.Textbox(label="Original Dimensions", interactive=False, visible=True) # Width and height inputs with gr.Row(): # Renamed width/height to avoid potential conflicts if they weren't already prefixed i2v_width = gr.Number(label="New Width", value=720, step=16) # Default from sample calc_height_btn = gr.Button("→") calc_width_btn = gr.Button("←") i2v_height = gr.Number(label="New Height", value=720, step=16) # Default from sample i2v_video_length = gr.Slider(minimum=1, maximum=201, step=1, label="Video Length in Frames", value=49) # Default from sample i2v_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=24) # Default from sample i2v_infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=30) # Default from sample i2v_flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=17.0) # Default from sample i2v_cfg_scale = gr.Slider(minimum=0.0, maximum=14.0, step=0.1, label="Embedded CFG Scale", value=7.0) # Default from sample i2v_guidance_scale = gr.Slider(minimum=1.0, maximum=20.0, step=0.1, label="Guidance Scale (CFG)", value=1.0) # Default from sample (usually 1.0 for no CFG) with gr.Column(): i2v_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[2], object_fit="contain", height="auto", show_label=True, elem_id="gallery_i2v", # Unique elem_id allow_preview=True, preview=True ) i2v_send_to_v2v_btn = gr.Button("Send Selected to Hunyuan-v2v") # Keep sending to original V2V # Add LoRA section for Image2Video i2v_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") i2v_lora_weights = [] i2v_lora_multipliers = [] for i in range(4): with gr.Column(): i2v_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) i2v_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): i2v_exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) i2v_seed = gr.Number(label="Seed (use -1 for random)", value=-1) i2v_dit_folder = gr.Textbox(label="DiT Model Folder", value="hunyuan") i2v_model = gr.Dropdown( label="DiT Model", choices=get_dit_models("hunyuan"), value="mp_rank_00_model_states_i2v.pt", # Default from sample allow_custom_value=True, interactive=True ) i2v_vae = gr.Textbox(label="VAE Path", value="hunyuan/pytorch_model.pt") # Default from sample i2v_te1 = gr.Textbox(label="Text Encoder 1 Path", value="hunyuan/llava_llama3_fp16.safetensors") # Default from sample i2v_te2 = gr.Textbox(label="Text Encoder 2 Path", value="hunyuan/clip_l.safetensors") # Default from sample i2v_clip_vision_path = gr.Textbox(label="CLIP Vision Path", value="hunyuan/llava_llama3_vision.safetensors") # Default from sample i2v_save_path = gr.Textbox(label="Save Path", value="outputs") # Default from sample with gr.Row(): i2v_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") i2v_output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") # Default from sample i2v_use_split_attn = gr.Checkbox(label="Use Split Attention", value=False) # Not in sample, keep default False i2v_use_fp8 = gr.Checkbox(label="Use FP8 DiT", value=False) # Not in sample, keep default False i2v_fp8_llm = gr.Checkbox(label="Use FP8 LLM", value=False) # Not in sample, keep default False i2v_attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") # Default from sample i2v_block_swap = gr.Slider(minimum=0, maximum=36, step=1, label="Block Swap to Save Vram", value=30) # Default from sample # Add VAE tiling options like sample command i2v_vae_chunk_size = gr.Number(label="VAE Chunk Size", value=32, step=1, info="For CausalConv3d, set 0 to disable") i2v_vae_spatial_tile_min = gr.Number(label="VAE Spatial Tile Min Size", value=128, step=16, info="Set 0 to disable spatial tiling") # Video to Video Tab with gr.Tab(id=2, label="Hunyuan v2v") as v2v_tab: with gr.Row(): with gr.Column(scale=4): v2v_prompt = gr.Textbox(scale=3, label="Enter your prompt", value="POV video of a cat chasing a frob.", lines=5) v2v_negative_prompt = gr.Textbox( scale=3, label="Negative Prompt (for SkyReels models)", value="Aerial view, aerial view, overexposed, low quality, deformation, a poor composition, bad hands, bad teeth, bad eyes, bad limbs, distortion", lines=3 ) with gr.Column(scale=1): v2v_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) v2v_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): v2v_batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress") v2v_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): v2v_generate_btn = gr.Button("Generate Video", elem_classes="green-btn") v2v_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): v2v_input = gr.Video(label="Input Video", format="mp4") v2v_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.75, label="Denoise Strength") v2v_scale_slider = gr.Slider(minimum=1, maximum=200, value=100, step=1, label="Scale %") v2v_original_dims = gr.Textbox(label="Original Dimensions", interactive=False, visible=True) # Width and Height Inputs with gr.Row(): v2v_width = gr.Number(label="New Width", value=544, step=16) v2v_calc_height_btn = gr.Button("→") v2v_calc_width_btn = gr.Button("←") v2v_height = gr.Number(label="New Height", value=544, step=16) v2v_video_length = gr.Slider(minimum=1, maximum=201, step=1, label="Video Length in Frames", value=25) v2v_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=24) v2v_infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=30) v2v_flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=11.0) v2v_cfg_scale = gr.Slider(minimum=0.0, maximum=14.0, step=0.1, label="cfg scale", value=7.0) with gr.Column(): v2v_output = gr.Gallery( label="Generated Videos", columns=[1], rows=[1], object_fit="contain", height="auto" ) v2v_send_to_input_btn = gr.Button("Send Selected to Input") # New button v2v_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") v2v_lora_weights = [] v2v_lora_multipliers = [] for i in range(4): with gr.Column(): v2v_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) v2v_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): v2v_exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) v2v_seed = gr.Number(label="Seed (use -1 for random)", value=-1) v2v_dit_folder = gr.Textbox(label="DiT Model Folder", value="hunyuan") v2v_model = gr.Dropdown( label="DiT Model", choices=get_dit_models("hunyuan"), value="mp_rank_00_model_states.pt", allow_custom_value=True, interactive=True ) v2v_vae = gr.Textbox(label="vae", value="hunyuan/pytorch_model.pt") v2v_te1 = gr.Textbox(label="te1", value="hunyuan/llava_llama3_fp16.safetensors") v2v_te2 = gr.Textbox(label="te2", value="hunyuan/clip_l.safetensors") v2v_save_path = gr.Textbox(label="Save Path", value="outputs") with gr.Row(): v2v_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") v2v_output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") v2v_use_split_attn = gr.Checkbox(label="Use Split Attention", value=False) v2v_use_fp8 = gr.Checkbox(label="Use FP8 (faster but lower precision)", value=True) v2v_attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") v2v_block_swap = gr.Slider(minimum=0, maximum=36, step=1, label="Block Swap to Save Vram", value=0) v2v_split_uncond = gr.Checkbox(label="Split Unconditional (for SkyReels)", value=True) ### SKYREELS with gr.Tab(label="SkyReels-i2v") as skyreels_tab: with gr.Row(): with gr.Column(scale=4): skyreels_prompt = gr.Textbox( scale=3, label="Enter your prompt", value="A person walking on a beach at sunset", lines=5 ) skyreels_negative_prompt = gr.Textbox( scale=3, label="Negative Prompt", value="Aerial view, aerial view, overexposed, low quality, deformation, a poor composition, bad hands, bad teeth, bad eyes, bad limbs, distortion", lines=3 ) with gr.Column(scale=1): skyreels_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) skyreels_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): skyreels_batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress") skyreels_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): skyreels_generate_btn = gr.Button("Generate Video", elem_classes="green-btn") skyreels_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): skyreels_input = gr.Image(label="Input Image (optional)", type="filepath") with gr.Row(): skyreels_use_random_folder = gr.Checkbox(label="Use Random Images from Folder", value=False) skyreels_input_folder = gr.Textbox( label="Image Folder Path", placeholder="Path to folder containing images", visible=False ) skyreels_folder_status = gr.Textbox( label="Folder Status", placeholder="Status will appear here", interactive=False, visible=False ) skyreels_validate_folder_btn = gr.Button("Validate Folder", visible=False) skyreels_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.75, label="Denoise Strength") # Scale slider as percentage skyreels_scale_slider = gr.Slider(minimum=1, maximum=200, value=100, step=1, label="Scale %") skyreels_original_dims = gr.Textbox(label="Original Dimensions", interactive=False, visible=True) # Width and height inputs with gr.Row(): skyreels_width = gr.Number(label="New Width", value=544, step=16) skyreels_calc_height_btn = gr.Button("→") skyreels_calc_width_btn = gr.Button("←") skyreels_height = gr.Number(label="New Height", value=544, step=16) skyreels_video_length = gr.Slider(minimum=1, maximum=201, step=1, label="Video Length in Frames", value=25) skyreels_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=24) skyreels_infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=30) skyreels_flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=11.0) skyreels_guidance_scale = gr.Slider(minimum=1.0, maximum=20.0, step=0.1, label="Guidance Scale", value=6.0) skyreels_embedded_cfg_scale = gr.Slider(minimum=0.0, maximum=10.0, step=0.1, label="Embedded CFG Scale", value=1.0) with gr.Column(): skyreels_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[2], object_fit="contain", height="auto", show_label=True, elem_id="gallery", allow_preview=True, preview=True ) skyreels_send_to_v2v_btn = gr.Button("Send Selected to Video2Video") # Add LoRA section for SKYREELS skyreels_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") skyreels_lora_weights = [] skyreels_lora_multipliers = [] for i in range(4): with gr.Column(): skyreels_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) skyreels_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): skyreels_exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) skyreels_seed = gr.Number(label="Seed (use -1 for random)", value=-1) skyreels_dit_folder = gr.Textbox(label="DiT Model Folder", value="hunyuan") skyreels_model = gr.Dropdown( label="DiT Model", choices=get_dit_models("skyreels"), value="skyreels_hunyuan_i2v_bf16.safetensors", allow_custom_value=True, interactive=True ) skyreels_vae = gr.Textbox(label="vae", value="hunyuan/pytorch_model.pt") skyreels_te1 = gr.Textbox(label="te1", value="hunyuan/llava_llama3_fp16.safetensors") skyreels_te2 = gr.Textbox(label="te2", value="hunyuan/clip_l.safetensors") skyreels_save_path = gr.Textbox(label="Save Path", value="outputs") with gr.Row(): skyreels_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") skyreels_output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") skyreels_use_split_attn = gr.Checkbox(label="Use Split Attention", value=False) skyreels_use_fp8 = gr.Checkbox(label="Use FP8 (faster but lower precision)", value=True) skyreels_attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") skyreels_block_swap = gr.Slider(minimum=0, maximum=36, step=1, label="Block Swap to Save Vram", value=0) skyreels_split_uncond = gr.Checkbox(label="Split Unconditional", value=True) # WanX Image to Video Tab with gr.Tab(id=4, label="WanX-i2v") as wanx_i2v_tab: with gr.Row(): with gr.Column(scale=4): wanx_prompt = gr.Textbox( scale=3, label="Enter your prompt", value="A person walking on a beach at sunset", lines=5 ) wanx_negative_prompt = gr.Textbox( scale=3, label="Negative Prompt", value="色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走", lines=3, ) with gr.Column(scale=1): wanx_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) wanx_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): wanx_batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress") wanx_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): wanx_generate_btn = gr.Button("Generate Video", elem_classes="green-btn") wanx_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): wanx_input = gr.Image(label="Input Image", type="filepath") with gr.Row(): wanx_use_random_folder = gr.Checkbox(label="Use Random Images from Folder", value=False) wanx_input_folder = gr.Textbox( label="Image Folder Path", placeholder="Path to folder containing images", visible=False ) wanx_folder_status = gr.Textbox( label="Folder Status", placeholder="Status will appear here", interactive=False, visible=False ) wanx_validate_folder_btn = gr.Button("Validate Folder", visible=False) with gr.Row(): wanx_use_end_image = gr.Checkbox(label="use ending image", value=False) wanx_input_end = gr.Image(label="End Image", type="filepath", visible=False) wanx_trim_frames = gr.Checkbox(label="trim last 3 frames", value=True, visible=False, interactive=True) with gr.Row(): wanx_use_fun_control = gr.Checkbox(label="Use Fun-Control Model", value=False) wanx_control_video = gr.Video(label="Control Video for Fun-Control", visible=False, format="mp4") wanx_control_strength = gr.Slider(minimum=0.1, maximum=2.0, step=0.05, value=1.0, label="Control Strength", visible=False, info="Adjust influence of control video (1.0 = normal)") wanx_control_start = gr.Slider( minimum=0.0, maximum=1.0, step=0.01, value=0.0, label="Control Start (Fun-Control fade-in)", visible=False, info="When (0-1) in the timeline control influence is full after fade-in" ) wanx_control_end = gr.Slider( minimum=0.0, maximum=1.0, step=0.01, value=1.0, label="Control End (Fun-Control fade-out start)", visible=False, info="When (0-1) in the timeline control starts to fade out" ) wanx_scale_slider = gr.Slider(minimum=1, maximum=200, value=100, step=1, label="Scale %") wanx_original_dims = gr.Textbox(label="Original Dimensions", interactive=False, visible=True) # Width and height display with gr.Row(): wanx_width = gr.Number(label="Width", value=832, interactive=True) wanx_calc_height_btn = gr.Button("→") wanx_calc_width_btn = gr.Button("←") wanx_height = gr.Number(label="Height", value=480, interactive=True) wanx_recommend_flow_btn = gr.Button("Recommend Flow Shift", size="sm") wanx_video_length = gr.Slider(minimum=1, maximum=401, step=4, label="Video Length in Frames", value=81) wanx_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=16) wanx_infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=20) wanx_flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=3.0, info="Recommended: 3.0 for 480p, 5.0 for others") wanx_guidance_scale = gr.Slider(minimum=1.0, maximum=20.0, step=0.5, label="Guidance Scale", value=5.0) with gr.Column(): wanx_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[2], object_fit="contain", height="auto", show_label=True, elem_id="gallery", allow_preview=True, preview=True ) with gr.Accordion("Latent Preview (During Generation)", open=True): wanx_enable_preview = gr.Checkbox(label="Enable Latent Preview", value=True) wanx_preview_steps = gr.Slider(minimum=1, maximum=50, step=1, value=5, label="Preview Every N Steps", info="Generates previews during the sampling loop.") wanx_preview_output = gr.Gallery( label="Latent Previews", columns=4, rows=2, object_fit="contain", height=300, allow_preview=True, preview=True, show_label=True, elem_id="wanx_preview_gallery" ) wanx_send_to_v2v_btn = gr.Button("Send Selected to Hunyuan-v2v") wanx_i2v_send_to_wanx_v2v_btn = gr.Button("Send Selected to WanX-v2v") wanx_send_last_frame_btn = gr.Button("Send Last Frame to Input") wanx_extend_btn = gr.Button("Extend Video") wanx_frames_to_check = gr.Slider(minimum=1, maximum=100, step=1, value=30, label="Frames to Check from End", info="Number of frames from the end to check for sharpness") wanx_send_sharpest_frame_btn = gr.Button("Extract Sharpest Frame") wanx_trim_and_extend_btn = gr.Button("Trim Video & Prepare for Extension") wanx_sharpest_frame_status = gr.Textbox(label="Status", interactive=False) # Add a new button for directly extending with the trimmed video wanx_extend_with_trimmed_btn = gr.Button("Extend with Trimmed Video") # Add LoRA section for WanX-i2v similar to other tabs wanx_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") wanx_lora_weights = [] wanx_lora_multipliers = [] for i in range(4): with gr.Column(): wanx_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) wanx_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): wanx_seed = gr.Number(label="Seed (use -1 for random)", value=-1) # Update the wanx_task dropdown choices to include Fun-Control options wanx_task = gr.Dropdown( label="Task", choices=["i2v-14B", "i2v-14B-FC", "i2v-14B-FC-1.1", "t2v-14B", "t2v-1.3B", "t2v-14B-FC", "t2v-1.3B-FC", "i2v-1.3B-new"], value="i2v-14B", info="Select model type. *-FC options enable Fun-Control features" ) wanx_dit_folder = gr.Textbox(label="DiT Model Folder", value="wan") wanx_dit_path = gr.Dropdown( label="DiT Model", choices=get_dit_models("wan"), # Use the existing function to get available models value="wan2.1_i2v_720p_14B_fp16.safetensors", allow_custom_value=True, interactive=True ) wanx_vae_path = gr.Textbox(label="VAE Path", value="wan/Wan2.1_VAE.pth") wanx_t5_path = gr.Textbox(label="T5 Path", value="wan/models_t5_umt5-xxl-enc-bf16.pth") wanx_clip_path = gr.Textbox(label="CLIP Path", value="wan/models_clip_open-clip-xlm-roberta-large-vit-huge-14.pth") wanx_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") wanx_save_path = gr.Textbox(label="Save Path", value="outputs") with gr.Row(): wanx_output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") wanx_sample_solver = gr.Radio(choices=["unipc", "dpm++", "vanilla"], label="Sample Solver", value="unipc") wanx_exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) wanx_attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") wanx_block_swap = gr.Slider(minimum=0, maximum=39, step=1, label="Block Swap to Save VRAM", value=0) with gr.Column(): wanx_fp8 = gr.Checkbox(label="Use FP8", value=True) wanx_fp8_scaled = gr.Checkbox(label="Use Scaled FP8", value=False, info="For mixing fp16/bf16 and fp8 weights") wanx_fp8_t5 = gr.Checkbox(label="Use FP8 for T5", value=False) # Add new row for Skip Layer Guidance options with gr.Row(): wanx_slg_layers = gr.Textbox(label="SLG Layers", value="", placeholder="Comma-separated layer indices, e.g. 1,5,10", info="Layers to skip for guidance") wanx_slg_start = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="SLG Start", value=0.0, info="When to start skipping layers (% of total steps)") wanx_slg_end = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="SLG End", value=1.0, info="When to stop skipping layers (% of total steps)") with gr.Row(): wanx_enable_cfg_skip = gr.Checkbox(label="Enable CFG Skip (similar to teacache)", value=False) with gr.Column(visible=False) as wanx_cfg_skip_options: wanx_cfg_skip_mode = gr.Radio( choices=["early", "late", "middle", "early_late", "alternate", "none"], label="CFG Skip Mode", value="none", info="Controls which steps to apply CFG on" ) wanx_cfg_apply_ratio = gr.Slider( minimum=0.0, maximum=1.0, step=0.05, value=0.7, label="CFG Apply Ratio", info="Ratio of steps to apply CFG (0.0-1.0). Lower values = faster, but less accurate" ) #WanX-t2v Tab # WanX Text to Video Tab with gr.Tab(id=5, label="WanX-t2v") as wanx_t2v_tab: with gr.Row(): with gr.Column(scale=4): wanx_t2v_prompt = gr.Textbox( scale=3, label="Enter your prompt", value="A person walking on a beach at sunset", lines=5 ) wanx_t2v_negative_prompt = gr.Textbox( scale=3, label="Negative Prompt", value="", lines=3, info="Leave empty to use default negative prompt" ) with gr.Column(scale=1): wanx_t2v_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) wanx_t2v_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): wanx_t2v_batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress") wanx_t2v_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): wanx_t2v_generate_btn = gr.Button("Generate Video", elem_classes="green-btn") wanx_t2v_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): with gr.Row(): wanx_t2v_width = gr.Number(label="Width", value=832, interactive=True, info="Should be divisible by 32") wanx_t2v_height = gr.Number(label="Height", value=480, interactive=True, info="Should be divisible by 32") wanx_t2v_recommend_flow_btn = gr.Button("Recommend Flow Shift", size="sm") wanx_t2v_video_length = gr.Slider(minimum=1, maximum=201, step=4, label="Video Length in Frames", value=81) wanx_t2v_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=16) wanx_t2v_infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=20) wanx_t2v_flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=5.0, info="Recommended: 3.0 for I2V with 480p, 5.0 for others") wanx_t2v_guidance_scale = gr.Slider(minimum=1.0, maximum=20.0, step=0.1, label="Guidance Scale", value=5.0) with gr.Column(): wanx_t2v_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[2], object_fit="contain", height="auto", show_label=True, elem_id="gallery", allow_preview=True, preview=True ) with gr.Accordion("Latent Preview (During Generation)", open=False): wanx_t2v_enable_preview = gr.Checkbox(label="Enable Latent Preview", value=False) wanx_t2v_preview_steps = gr.Slider(minimum=1, maximum=50, step=1, value=5, label="Preview Every N Steps", info="Generates previews during the sampling loop.") wanx_t2v_preview_output = gr.Gallery( label="Latent Previews", columns=4, rows=2, object_fit="contain", height=300, allow_preview=True, preview=True, show_label=True, elem_id="wanx_t2v_preview_gallery" ) wanx_t2v_send_to_v2v_btn = gr.Button("Send Selected to Hunyuan v2v") wanx_t2v_send_to_wanx_v2v_btn = gr.Button("Send Selected to WanX-v2v") # Add LoRA section for WanX-t2v wanx_t2v_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") wanx_t2v_lora_weights = [] wanx_t2v_lora_multipliers = [] for i in range(4): with gr.Column(): wanx_t2v_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) wanx_t2v_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): wanx_t2v_seed = gr.Number(label="Seed (use -1 for random)", value=-1) wanx_t2v_task = gr.Dropdown( label="Task", choices=["t2v-1.3B", "t2v-14B", "t2i-14B"], value="t2v-14B", info="Select model size: t2v-1.3B is faster, t2v-14B has higher quality" ) wanx_t2v_dit_path = gr.Dropdown( label="DiT Model", choices=get_dit_models("wan"), value="wan2.1_t2v_14B_fp16.safetensors", allow_custom_value=True, interactive=True ) wanx_t2v_vae_path = gr.Textbox(label="VAE Path", value="wan/Wan2.1_VAE.pth") wanx_t2v_t5_path = gr.Textbox(label="T5 Path", value="wan/models_t5_umt5-xxl-enc-bf16.pth") wanx_t2v_clip_path = gr.Textbox(label="CLIP Path", visible=False, value="") wanx_t2v_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") wanx_t2v_save_path = gr.Textbox(label="Save Path", value="outputs") with gr.Row(): wanx_t2v_output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") wanx_t2v_sample_solver = gr.Radio(choices=["unipc", "dpm++", "vanilla"], label="Sample Solver", value="unipc") wanx_t2v_exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) wanx_t2v_attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") wanx_t2v_block_swap = gr.Slider(minimum=0, maximum=39, step=1, label="Block Swap to Save VRAM", value=0, info="Max 39 for 14B model, 29 for 1.3B model") with gr.Column(): wanx_t2v_fp8 = gr.Checkbox(label="Use FP8", value=True) wanx_t2v_fp8_scaled = gr.Checkbox(label="Use Scaled FP8", value=False, info="For mixing fp16/bf16 and fp8 weights") wanx_t2v_fp8_t5 = gr.Checkbox(label="Use FP8 for T5", value=False) # Add new row for Skip Layer Guidance options with gr.Row(): wanx_t2v_slg_layers = gr.Textbox(label="SLG Layers", value="", placeholder="Comma-separated layer indices, e.g. 1,5,10", info="Layers to skip for guidance") wanx_t2v_slg_start = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="SLG Start", value=0.0, info="When to start skipping layers (% of total steps)") wanx_t2v_slg_end = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="SLG End", value=1.0, info="When to stop skipping layers (% of total steps)") wanx_t2v_use_random_folder = gr.Checkbox(visible=False, value=False, label="Use Random Images") wanx_t2v_input_folder = gr.Textbox(visible=False, value="", label="Image Folder") wanx_t2v_input_end = gr.Textbox(visible=False, value="none", label="End Frame") with gr.Row(): wanx_t2v_enable_cfg_skip = gr.Checkbox(label="Enable CFG Skip (similar to teacache)", value=False) with gr.Column(visible=False) as wanx_t2v_cfg_skip_options: wanx_t2v_cfg_skip_mode = gr.Radio( choices=["early", "late", "middle", "early_late", "alternate", "none"], label="CFG Skip Mode", value="none", info="Controls which steps to apply CFG on" ) wanx_t2v_cfg_apply_ratio = gr.Slider( minimum=0.0, maximum=1.0, step=0.05, value=0.7, label="CFG Apply Ratio", info="Ratio of steps to apply CFG (0.0-1.0). Lower values = faster, but less accurate" ) #WanX-v2v Tab with gr.Tab(id=6, label="WanX-v2v") as wanx_v2v_tab: with gr.Row(): with gr.Column(scale=4): wanx_v2v_prompt = gr.Textbox( scale=3, label="Enter your prompt", value="A person walking on a beach at sunset", lines=5 ) wanx_v2v_negative_prompt = gr.Textbox( scale=3, label="Negative Prompt", value="", lines=3, info="Leave empty to use default negative prompt" ) with gr.Column(scale=1): wanx_v2v_token_counter = gr.Number(label="Prompt Token Count", value=0, interactive=False) wanx_v2v_batch_size = gr.Number(label="Batch Count", value=1, minimum=1, step=1) with gr.Column(scale=2): wanx_v2v_batch_progress = gr.Textbox(label="", visible=True, elem_id="batch_progress") wanx_v2v_progress_text = gr.Textbox(label="", visible=True, elem_id="progress_text") with gr.Row(): wanx_v2v_generate_btn = gr.Button("Generate Video", elem_classes="green-btn") wanx_v2v_stop_btn = gr.Button("Stop Generation", variant="stop") with gr.Row(): with gr.Column(): wanx_v2v_input = gr.Video(label="Input Video", format="mp4") wanx_v2v_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, value=0.75, label="Denoise Strength", info="0 = keep original, 1 = full generation") wanx_v2v_scale_slider = gr.Slider(minimum=1, maximum=200, value=100, step=1, label="Scale %") wanx_v2v_original_dims = gr.Textbox(label="Original Dimensions", interactive=False, visible=True) # Width and Height Inputs with gr.Row(): wanx_v2v_width = gr.Number(label="New Width", value=832, step=32) wanx_v2v_calc_height_btn = gr.Button("→") wanx_v2v_calc_width_btn = gr.Button("←") wanx_v2v_height = gr.Number(label="New Height", value=480, step=32) wanx_v2v_recommend_flow_btn = gr.Button("Recommend Flow Shift", size="sm") wanx_v2v_video_length = gr.Slider(minimum=1, maximum=201, step=4, label="Video Length in Frames", value=81) wanx_v2v_fps = gr.Slider(minimum=1, maximum=60, step=1, label="Frames Per Second", value=16) wanx_v2v_infer_steps = gr.Slider(minimum=10, maximum=100, step=1, label="Inference Steps", value=40) wanx_v2v_flow_shift = gr.Slider(minimum=0.0, maximum=28.0, step=0.5, label="Flow Shift", value=5.0, info="Recommended: 3.0 for 480p, 5.0 for others") wanx_v2v_guidance_scale = gr.Slider(minimum=1.0, maximum=20.0, step=0.1, label="Guidance Scale", value=5.0) with gr.Column(): wanx_v2v_output = gr.Gallery( label="Generated Videos (Click to select)", columns=[2], rows=[2], object_fit="contain", height="auto", show_label=True, elem_id="gallery", allow_preview=True, preview=True ) wanx_v2v_send_to_v2v_btn = gr.Button("Send Selected to Hunyuan-v2v") # Add LoRA section for WanX-v2v wanx_v2v_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") wanx_v2v_lora_weights = [] wanx_v2v_lora_multipliers = [] for i in range(4): with gr.Column(): wanx_v2v_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) wanx_v2v_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): wanx_v2v_seed = gr.Number(label="Seed (use -1 for random)", value=-1) wanx_v2v_task = gr.Dropdown( label="Task", choices=["t2v-14B", "t2v-1.3B"], value="t2v-14B", info="Model size: t2v-1.3B is faster, t2v-14B has higher quality" ) wanx_v2v_dit_folder = gr.Textbox(label="DiT Model Folder", value="wan") wanx_v2v_dit_path = gr.Dropdown( label="DiT Model", choices=get_dit_models("wan"), value="wan2.1_t2v_14B_fp16.safetensors", allow_custom_value=True, interactive=True ) wanx_v2v_vae_path = gr.Textbox(label="VAE Path", value="wan/Wan2.1_VAE.pth") wanx_v2v_t5_path = gr.Textbox(label="T5 Path", value="wan/models_t5_umt5-xxl-enc-bf16.pth") wanx_v2v_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") wanx_v2v_save_path = gr.Textbox(label="Save Path", value="outputs") with gr.Row(): wanx_v2v_output_type = gr.Radio(choices=["video", "images", "latent", "both"], label="Output Type", value="video") wanx_v2v_sample_solver = gr.Radio(choices=["unipc", "dpm++", "vanilla"], label="Sample Solver", value="unipc") wanx_v2v_exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) wanx_v2v_attn_mode = gr.Radio(choices=["sdpa", "flash", "sageattn", "xformers", "torch"], label="Attention Mode", value="sdpa") wanx_v2v_block_swap = gr.Slider(minimum=0, maximum=39, step=1, label="Block Swap to Save VRAM", value=0, info="Max 39 for 14B model, 29 for 1.3B model") with gr.Column(): wanx_v2v_fp8 = gr.Checkbox(label="Use FP8", value=True) wanx_v2v_fp8_scaled = gr.Checkbox(label="Use Scaled FP8", value=False, info="For mixing fp16/bf16 and fp8 weights") wanx_v2v_fp8_t5 = gr.Checkbox(label="Use FP8 for T5", value=False) # Add Skip Layer Guidance options with gr.Row(): wanx_v2v_slg_layers = gr.Textbox(label="SLG Layers", value="", placeholder="Comma-separated layer indices, e.g. 1,5,10", info="Layers to skip for guidance") wanx_v2v_slg_start = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="SLG Start", value=0.0, info="When to start skipping layers (% of total steps)") wanx_v2v_slg_end = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="SLG End", value=1.0, info="When to stop skipping layers (% of total steps)") with gr.Row(): wanx_v2v_enable_cfg_skip = gr.Checkbox(label="Enable CFG Skip (similar to teacache)", value=False) with gr.Column(visible=False) as wanx_v2v_cfg_skip_options: wanx_v2v_cfg_skip_mode = gr.Radio( choices=["early", "late", "middle", "early_late", "alternate", "none"], label="CFG Skip Mode", value="none", info="Controls which steps to apply CFG on" ) wanx_v2v_cfg_apply_ratio = gr.Slider( minimum=0.0, maximum=1.0, step=0.05, value=0.7, label="CFG Apply Ratio", info="Ratio of steps to apply CFG (0.0-1.0). Lower values = faster, but less accurate" ) #Video Info Tab with gr.Tab("Video Info") as video_info_tab: with gr.Row(): video_input = gr.Video(label="Upload Video", interactive=True) metadata_output = gr.JSON(label="Generation Parameters") with gr.Row(): send_to_fpe_btn = gr.Button("Send to FramePack-Extension", variant="primary") send_to_t2v_btn = gr.Button("Send to Text2Video", variant="primary") send_to_v2v_btn = gr.Button("Send to Video2Video", variant="primary") with gr.Row(): send_to_framepack_btn = gr.Button("Send to FramePack", variant="primary") send_to_wanx_i2v_btn = gr.Button("Send to WanX-i2v", variant="primary") send_to_wanx_t2v_btn = gr.Button("Send to WanX-t2v", variant="primary") send_to_wanx_v2v_btn = gr.Button("Send to WanX-v2v", variant="primary") with gr.Row(): status = gr.Textbox(label="Status", interactive=False) #Convert lora tab with gr.Tab("Convert LoRA") as convert_lora_tab: def suggest_output_name(file_obj) -> str: """Generate suggested output name from input file""" if not file_obj: return "" # Get input filename without extension and add MUSUBI base_name = os.path.splitext(os.path.basename(file_obj.name))[0] return f"{base_name}_MUSUBI" def convert_lora(input_file, output_name: str, target_format: str) -> str: """Convert LoRA file to specified format""" try: if input_file is None: return "Error: No input file selected" # Ensure output directory exists os.makedirs("lora", exist_ok=True) # Construct output path output_path = os.path.join("lora", f"{output_name}.safetensors") # Determine which script to use based on target_format if target_format == "Hunyuan to FramePack": script_name = "convert_hunyuan_to_framepack.py" cmd = [ sys.executable, script_name, "--input", input_file.name, "--output", output_path ] print(f"Using '{script_name}' to convert {input_file.name} to {output_path} for FramePack.") else: # Existing logic for "default" and "other" script_name = "convert_lora.py" cmd = [ sys.executable, script_name, "--input", input_file.name, "--output", output_path, "--target", target_format.lower() ] print(f"Running conversion command: {' '.join(cmd)}") # Check if the selected script file exists if not os.path.exists(script_name): return f"Error: Conversion script '{script_name}' not found. Please ensure it's in the same directory as h1111.py." # Execute conversion result = subprocess.run( cmd, capture_output=True, text=True, check=True ) console_output = result.stdout if result.stdout else "" if result.stderr: console_output += f"\n--- Script STDERR ---\n{result.stderr}" if not console_output.strip(): console_output = "Conversion script completed with no output." if os.path.exists(output_path): console_output += f"\n[UI Info] Output file confirmed by h1111.py at: {output_path}" else: console_output += f"\n[UI Warning] Output file NOT found by h1111.py at expected location: {output_path}" return console_output.strip() except subprocess.CalledProcessError as e: error_message = f"Conversion Script Error (Exit Code: {e.returncode}):\n" if e.stdout and e.stdout.strip(): error_message += f"--- Script STDOUT ---\n{e.stdout.strip()}\n" if e.stderr and e.stderr.strip(): error_message += f"--- Script STDERR ---\n{e.stderr.strip()}\n" if not (e.stdout and e.stdout.strip()) and not (e.stderr and e.stderr.strip()): error_message += "Script produced no output on STDOUT or STDERR." print(f"Subprocess error details logged to console. UI will show combined script output.") # Log for server console return error_message.strip() with gr.Row(): input_file = gr.File(label="Input LoRA File", file_types=[".safetensors"]) output_name = gr.Textbox(label="Output Name", placeholder="Output filename (without extension)") format_radio = gr.Radio( choices=["default", "other", "Hunyuan to FramePack"], # <-- Added new choice here value="default", label="Target Format", info="Choose 'default' for H1111/MUSUBI format, 'other' for diffusion pipe format, or 'Hunyuan to FramePack' for FramePack compatibility." ) with gr.Row(): convert_btn = gr.Button("Convert LoRA", variant="primary") status_output = gr.Textbox(label="Status", interactive=False) # Automatically update output name when file is selected input_file.change( fn=suggest_output_name, inputs=[input_file], outputs=[output_name] ) # Handle conversion convert_btn.click( fn=convert_lora, inputs=[input_file, output_name, format_radio], outputs=status_output ) with gr.Tab("Model Merging") as model_merge_tab: with gr.Row(): with gr.Column(): # Model selection dit_model = gr.Dropdown( label="Base DiT Model", choices=["mp_rank_00_model_states.pt"], value="mp_rank_00_model_states.pt", allow_custom_value=True, interactive=True ) merge_refresh_btn = gr.Button("🔄", elem_classes="refresh-btn") with gr.Row(): with gr.Column(): # Output model name output_model = gr.Textbox(label="Output Model Name", value="merged_model.safetensors") exclude_single_blocks = gr.Checkbox(label="Exclude Single Blocks", value=False) merge_btn = gr.Button("Merge Models", variant="primary") merge_status = gr.Textbox(label="Status", interactive=False) with gr.Row(): # LoRA selection section (similar to Text2Video) merge_lora_weights = [] merge_lora_multipliers = [] for i in range(4): with gr.Column(): merge_lora_weights.append(gr.Dropdown( label=f"LoRA {i+1}", choices=get_lora_options(), value="None", allow_custom_value=True, interactive=True )) merge_lora_multipliers.append(gr.Slider( label=f"Multiplier", minimum=0.0, maximum=2.0, step=0.05, value=1.0 )) with gr.Row(): merge_lora_folder = gr.Textbox(label="LoRA Folder", value="lora") dit_folder = gr.Textbox(label="DiT Model Folder", value="hunyuan") #Event handlers etc # Toggle visibility of End Frame controls and DiT path based on fpe_use_normal_framepack def toggle_fpe_normal_framepack_options(use_normal_fp): f1_dit_path = "hunyuan/FramePack_F1_I2V_HY_20250503.safetensors" normal_fp_dit_path = "hunyuan/FramePackI2V_HY_bf16.safetensors" updated_dit_path = normal_fp_dit_path if use_normal_fp else f1_dit_path # Check if the target path exists and fallback if necessary if not os.path.exists(updated_dit_path): fallback_path = f1_dit_path if use_normal_fp and os.path.exists(f1_dit_path) else normal_fp_dit_path if not use_normal_fp and os.path.exists(normal_fp_dit_path) else None if fallback_path and os.path.exists(fallback_path): print(f"Warning: DiT path '{updated_dit_path}' not found. Falling back to '{fallback_path}'.") updated_dit_path = fallback_path else: # If preferred and fallback are missing, stick to the intended one and let later checks handle it. print(f"Warning: DiT path '{updated_dit_path}' not found. No fallback available or fallback also missing.") return ( gr.update(visible=use_normal_fp), # fpe_end_frame_accordion gr.update(visible=not use_normal_fp), # fpe_start_guidance_accordion (NEW) gr.update(value=updated_dit_path), # fpe_transformer_path gr.update(visible=use_normal_fp) # fpe_fp8_llm ) fpe_use_normal_framepack.change( fn=toggle_fpe_normal_framepack_options, inputs=[fpe_use_normal_framepack], outputs=[ fpe_end_frame_accordion, fpe_start_guidance_accordion, # NEW output fpe_transformer_path, fpe_fp8_llm ] ) fpe_generate_btn.click( fn=process_framepack_extension_video, inputs=[ fpe_input_video, fpe_prompt, fpe_negative_prompt, fpe_seed, fpe_batch_count, fpe_use_normal_framepack, fpe_end_frame, fpe_end_frame_weight, fpe_resolution_max_dim, fpe_total_second_length, fpe_latent_window_size, fpe_steps, fpe_cfg_scale, fpe_distilled_guidance_scale, fpe_gpu_memory_preservation, fpe_use_teacache, fpe_no_resize, fpe_mp4_crf, fpe_num_clean_frames, fpe_vae_batch_size, fpe_save_path, # Model Paths fpe_transformer_path, fpe_vae_path, fpe_text_encoder_path, fpe_text_encoder_2_path, fpe_image_encoder_path, # Advanced fpe_attn_mode, fpe_fp8_llm, fpe_vae_chunk_size, fpe_vae_spatial_tile_sample_min_size, # LoRAs fpe_lora_folder, fpe_lora_weights_ui[0], fpe_lora_multipliers_ui[0], fpe_lora_weights_ui[1], fpe_lora_multipliers_ui[1], fpe_lora_weights_ui[2], fpe_lora_multipliers_ui[2], fpe_lora_weights_ui[3], fpe_lora_multipliers_ui[3], # Preview (UI state, not directly passed to scripts) fpe_enable_preview, fpe_preview_interval, fpe_extension_only, fpe_start_guidance_image, fpe_start_guidance_image_clip_weight, fpe_use_guidance_image_as_first_latent, ], outputs=[ fpe_output_gallery, fpe_preview_output_component, fpe_batch_progress, fpe_progress_text ], queue=True ) fpe_stop_btn.click(fn=lambda: stop_event.set(), queue=False) def handle_fpe_gallery_select(evt: gr.SelectData) -> int: return evt.index fpe_output_gallery.select(fn=handle_fpe_gallery_select, outputs=fpe_selected_index) fpe_lora_refresh_outputs_list = [] for i in range(len(fpe_lora_weights_ui)): fpe_lora_refresh_outputs_list.extend([fpe_lora_weights_ui[i], fpe_lora_multipliers_ui[i]]) fpe_refresh_lora_btn.click( fn=refresh_lora_dropdowns_simple, inputs=[fpe_lora_folder], outputs=fpe_lora_refresh_outputs_list ) def change_to_framepack_tab(): return gr.Tabs(selected=10) # FramePack tab has id=10 def handle_send_to_framepack_tab(metadata: dict) -> Tuple[str, dict, str]: # Added str return type for state value """Prepare parameters specifically for the FramePack tab.""" if not metadata: # Return default/empty values for status, params, and original_dims state return "No parameters to send", {}, "" # Extract the value intended for the state here original_dims_value = metadata.get("original_dims_str", "") # Return status message, the full metadata for params_state, and the specific value for framepack_original_dims state return "Parameters ready for FramePack", metadata, original_dims_value send_to_framepack_btn.click( fn=handle_send_to_framepack_tab, inputs=[metadata_output], outputs=[status, params_state, framepack_original_dims] # Add framepack_original_dims here ).then( # This lambda now prepares updates for UI components (32 items) lambda params: ( # Prepare the full list of 32 update values first ( # Fetch LoRA lists from params, default to empty lists if not found (weights_from_meta := params.get("lora_weights", [])), (mults_from_meta := params.get("lora_multipliers", [])), # Create explicitly padded lists ensuring 4 elements (padded_weights := (weights_from_meta + ["None"] * 4)[:4]), (padded_mults := ([float(m) for m in mults_from_meta] + [1.0] * 4)[:4]), # Ensure multipliers are floats # Build the list of update values [ params.get("prompt", "cinematic video of a cat wizard casting a spell"), params.get("negative_prompt", ""), # Handle resolution: Prioritize explicit W/H if valid (divisible by 8), else use target_res, else default gr_update(value=int(params["video_width"])) if params.get("video_width") and int(params.get("video_width", 0)) > 0 and int(params.get("video_width", 0)) % 8 == 0 else gr_update(value=None), gr_update(value=int(params["video_height"])) if params.get("video_height") and int(params.get("video_height", 0)) > 0 and int(params.get("video_height", 0)) % 8 == 0 else gr_update(value=None), # Use target resolution only if explicit width/height are *not* validly provided from metadata gr_update(value=int(params.get("target_resolution"))) if not (params.get("video_width") and int(params.get("video_width", 0)) > 0 and int(params.get("video_width", 0)) % 8 == 0) and params.get("target_resolution") else gr_update(value=640), params.get("video_seconds", 5.0), params.get("fps", 30), params.get("seed", -1), params.get("infer_steps", 25), params.get("embedded_cfg_scale", 10.0), # Distilled Guidance params.get("guidance_scale", 1.0), # CFG params.get("guidance_rescale", 0.0), # RS params.get("sample_solver", "unipc"), # Unpack the *padded* lists *padded_weights, # 4 items *padded_mults, # 4 items # Performance/Memory params.get("fp8", False), params.get("fp8_scaled", False), params.get("fp8_llm", False), params.get("blocks_to_swap", 26), params.get("bulk_decode", False), params.get("attn_mode", "sdpa"), params.get("vae_chunk_size", 32), params.get("vae_spatial_tile_sample_min_size", 128), params.get("device", ""), # End Frame Blending Params - Use UI defaults params.get("end_frame_influence", "last"), params.get("end_frame_weight", 0.5), params.get("is_f1", False) ] )[-1] # Return the list of values we just built ) if params else [gr.update()] * 32, inputs=params_state, # Read parameters from state outputs=[ # Map to FramePack components (UI only - 32 components) framepack_prompt, framepack_negative_prompt, framepack_width, # Will be updated or set to None framepack_height, # Will be updated or set to None framepack_target_resolution, # Will be updated or set to None/default framepack_total_second_length, framepack_fps, framepack_seed, framepack_steps, framepack_distilled_guidance_scale, framepack_guidance_scale, framepack_guidance_rescale, framepack_sample_solver, # LoRAs (unpacking the lists - 8 components total) *framepack_lora_weights, # 4 components *framepack_lora_multipliers, # 4 components # Performance/Memory framepack_fp8, framepack_fp8_scaled, framepack_fp8_llm, framepack_blocks_to_swap, framepack_bulk_decode, framepack_attn_mode, framepack_vae_chunk_size, framepack_vae_spatial_tile_sample_min_size, framepack_device, # Map to new UI components framepack_end_frame_influence, framepack_end_frame_weight, framepack_is_f1 ] ).then( fn=change_to_framepack_tab, # Switch to the FramePack tab inputs=None, outputs=[tabs] ) # Connect FramePack Generate button def update_framepack_image_dimensions(image): """Update FramePack dimensions from uploaded image, store raw dims, set default target res""" if image is None: return "", gr.update(value=None), gr.update(value=None), gr.update(value=640) # Reset W/H, default target res try: img = Image.open(image) w, h = img.size original_dims_str = f"{w}x{h}" # Store raw WxH target_res_default = 640 # Return original dims string, clear explicit W/H, set default target res return original_dims_str, gr.update(value=None), gr.update(value=None), gr.update(value=target_res_default) except Exception as e: print(f"Error reading image dimensions: {e}") return "", gr.update(value=None), gr.update(value=None), gr.update(value=640) # Fallback framepack_input_image.change( fn=update_framepack_image_dimensions, inputs=[framepack_input_image], outputs=[framepack_original_dims, framepack_width, framepack_height, framepack_target_resolution] ) framepack_prompt.change(fn=count_prompt_tokens, inputs=framepack_prompt, outputs=framepack_token_counter) # If explicit width/height is set (and valid), clear target resolution def clear_target_res_on_explicit_change(val): return gr.update(value=None) if val is not None and val > 0 else gr.update() framepack_scale_slider.change( fn=update_framepack_from_scale, inputs=[framepack_scale_slider, framepack_original_dims], outputs=[framepack_width, framepack_height, framepack_target_resolution] # Also clears target res ) framepack_calc_width_btn.click( fn=calculate_framepack_width, inputs=[framepack_height, framepack_original_dims], outputs=[framepack_width] ).then( fn=clear_target_res_on_explicit_change, # Clear target res if width is manually set inputs=[framepack_width], outputs=[framepack_target_resolution] ) framepack_calc_height_btn.click( fn=calculate_framepack_height, inputs=[framepack_width, framepack_original_dims], outputs=[framepack_height] ).then( fn=clear_target_res_on_explicit_change, # Clear target res if height is manually set inputs=[framepack_height], outputs=[framepack_target_resolution] ) framepack_width.change( fn=clear_target_res_on_explicit_change, inputs=[framepack_width], outputs=[framepack_target_resolution] ) framepack_height.change( fn=clear_target_res_on_explicit_change, inputs=[framepack_height], outputs=[framepack_target_resolution] ) # If target resolution is set (and valid), clear explicit width/height def clear_explicit_res_on_target_change(target_res): return (gr.update(value=None), gr.update(value=None)) if target_res is not None and target_res > 0 else (gr.update(), gr.update()) framepack_target_resolution.change( fn=clear_explicit_res_on_target_change, inputs=[framepack_target_resolution], outputs=[framepack_width, framepack_height] ) framepack_use_random_folder.change( fn=lambda use_folder_mode: ( gr.update(visible=use_folder_mode), # framepack_input_folder_path gr.update(visible=use_folder_mode), # framepack_folder_options_row (which contains validate button and status) gr.update(visible=not use_folder_mode) # framepack_input_image ), inputs=[framepack_use_random_folder], outputs=[framepack_input_folder_path, framepack_folder_options_row, framepack_input_image] ) # Validate folder button handler framepack_validate_folder_btn.click( fn=lambda folder: get_random_image_from_folder(folder)[1], # Reuse existing helper inputs=[framepack_input_folder_path], outputs=[framepack_folder_status_text] ) def toggle_f1_model_path(is_f1): f1_path = "hunyuan/FramePack_F1_I2V_HY_20250503.safetensors" standard_path = "hunyuan/FramePackI2V_HY_bf16.safetensors" target_path = f1_path if is_f1 else standard_path # Check if the target path exists if not os.path.exists(target_path): print(f"Warning: F1 model path '{target_path}' not found. Falling back to standard path.") # Optionally fall back or just update with the non-existent path # Let's fall back to standard if F1 is missing, but keep standard if standard is missing (error handled later) if is_f1 and os.path.exists(standard_path): print(f"Falling back to standard path: {standard_path}") return gr.update(value=standard_path) elif is_f1: print(f"F1 path missing and standard path also missing. Cannot automatically switch.") # Return the intended (missing) path, error will be caught later return gr.update(value=target_path) else: # Standard path is missing print(f"Warning: Standard path '{standard_path}' not found.") return gr.update(value=target_path) # Return the missing standard path print(f"Switching DiT path to: {target_path}") return gr.update(value=target_path) framepack_is_f1.change( fn=toggle_f1_model_path, inputs=[framepack_is_f1], outputs=[framepack_transformer_path] ) framepack_generate_btn.click( fn=process_framepack_video, inputs=[ framepack_prompt, framepack_negative_prompt, framepack_input_image, framepack_input_end_frame, framepack_end_frame_influence, framepack_end_frame_weight, framepack_transformer_path, framepack_vae_path, framepack_text_encoder_path, framepack_text_encoder_2_path, framepack_image_encoder_path, framepack_target_resolution, framepack_width, framepack_height, framepack_original_dims, framepack_total_second_length, framepack_video_sections, framepack_fps, framepack_seed, framepack_steps, framepack_distilled_guidance_scale, framepack_guidance_scale, framepack_guidance_rescale, framepack_sample_solver, framepack_latent_window_size, framepack_fp8, framepack_fp8_scaled, framepack_fp8_llm, framepack_blocks_to_swap, framepack_bulk_decode, framepack_attn_mode, framepack_vae_chunk_size, framepack_vae_spatial_tile_sample_min_size, framepack_device, framepack_use_teacache, framepack_teacache_steps, framepack_teacache_thresh, framepack_batch_size, framepack_save_path, framepack_lora_folder, framepack_enable_preview, framepack_preview_every_n_sections, framepack_use_full_video_preview, framepack_is_f1, framepack_use_random_folder, framepack_input_folder_path, *framepack_secs, *framepack_sec_prompts, *framepack_sec_images, *framepack_lora_weights, *framepack_lora_multipliers ], outputs=[ framepack_output, # Main gallery framepack_preview_output, # Preview video player framepack_batch_progress, # Status text framepack_progress_text # Progress text ], queue=True ) framepack_random_seed.click( fn=set_random_seed, inputs=None, outputs=[framepack_seed] ) # Connect FramePack Stop button framepack_stop_btn.click(fn=lambda: stop_event.set(), queue=False) # Connect FramePack Gallery selection def handle_framepack_gallery_select(evt: gr.SelectData) -> int: return evt.index framepack_output.select( fn=handle_framepack_gallery_select, outputs=framepack_selected_index ) # FramePack LoRA Refresh Button Handler framepack_lora_refresh_outputs = [] for i in range(len(framepack_lora_weights)): framepack_lora_refresh_outputs.extend([framepack_lora_weights[i], framepack_lora_multipliers[i]]) framepack_refresh_lora_btn.click( fn=refresh_lora_dropdowns_simple, # Use the new simplified function inputs=[framepack_lora_folder], # Only needs the folder path as input outputs=framepack_lora_refresh_outputs # Still outputs updates to all 8 components ) def trigger_skip(): """Sets the skip event and returns a status message.""" print("FramePack Skip button clicked, setting skip_event.") skip_event.set() return "Skip signal sent..." framepack_skip_btn.click( fn=trigger_skip, inputs=None, outputs=[framepack_batch_progress], # Update status text queue=False # Send signal immediately ) def toggle_fun_control(use_fun_control): """Toggle control video visibility and update task suffix""" # Only update visibility, don't try to set paths return gr.update(visible=use_fun_control) def update_task_for_funcontrol(use_fun_control, current_task): """Add or remove -FC suffix from task based on checkbox""" if use_fun_control: if not current_task.endswith("-FC"): if "i2v" in current_task: return "i2v-14B-FC" elif "t2v" in current_task: return "t2v-14B-FC" return current_task else: if current_task.endswith("-FC"): return current_task.replace("-FC", "") return current_task wanx_use_fun_control.change( fn=lambda x: (gr.update(visible=x), gr.update(visible=x), gr.update(visible=x), gr.update(visible=x)), inputs=[wanx_use_fun_control], outputs=[wanx_control_video, wanx_control_strength, wanx_control_start, wanx_control_end] ) # Make task change update checkbox state def update_from_task(task): """Update Fun-Control checkbox and control video visibility based on task""" is_fun_control = "-FC" in task return gr.update(value=is_fun_control), gr.update(visible=is_fun_control) wanx_task.change( fn=update_from_task, inputs=[wanx_task], outputs=[wanx_use_fun_control, wanx_control_video] ) wanx_enable_cfg_skip.change( fn=lambda x: gr.update(visible=x), inputs=[wanx_enable_cfg_skip], outputs=[wanx_cfg_skip_options] ) wanx_t2v_enable_cfg_skip.change( fn=lambda x: gr.update(visible=x), inputs=[wanx_t2v_enable_cfg_skip], outputs=[wanx_t2v_cfg_skip_options] ) wanx_v2v_enable_cfg_skip.change( fn=lambda x: gr.update(visible=x), inputs=[wanx_v2v_enable_cfg_skip], outputs=[wanx_v2v_cfg_skip_options] ) #WanX-v2v tab functions wanx_v2v_prompt.change(fn=count_prompt_tokens, inputs=wanx_v2v_prompt, outputs=wanx_v2v_token_counter) # Stop button handler wanx_v2v_stop_btn.click(fn=lambda: stop_event.set(), queue=False) # Video input handling wanx_v2v_input.change( fn=update_wanx_v2v_dimensions, inputs=[wanx_v2v_input], outputs=[wanx_v2v_original_dims, wanx_v2v_width, wanx_v2v_height] ) # Flow shift recommendation button wanx_v2v_recommend_flow_btn.click( fn=recommend_wanx_flow_shift, inputs=[wanx_v2v_width, wanx_v2v_height], outputs=[wanx_v2v_flow_shift] ) # Width/height calculation buttons wanx_v2v_calc_width_btn.click( fn=calculate_wanx_width, # Reuse function from WanX tabs inputs=[wanx_v2v_height, wanx_v2v_original_dims], outputs=[wanx_v2v_width] ) wanx_v2v_calc_height_btn.click( fn=calculate_wanx_height, # Reuse function from WanX tabs inputs=[wanx_v2v_width, wanx_v2v_original_dims], outputs=[wanx_v2v_height] ) # Scale slider handling for adjusting dimensions wanx_v2v_scale_slider.change( fn=update_wanx_from_scale, # Reuse function from WanX tabs inputs=[wanx_v2v_scale_slider, wanx_v2v_original_dims], outputs=[wanx_v2v_width, wanx_v2v_height] ) def change_to_wanx_v2v_tab(): return gr.Tabs(selected=6) def send_wanx_t2v_to_v2v_input(gallery, selected_index): """Send the selected WanX-t2v video to WanX-v2v input""" if gallery is None or not gallery: return None, None if selected_index is None and len(gallery) == 1: selected_index = 0 if selected_index is None or selected_index >= len(gallery): return None, None # Get the video path item = gallery[selected_index] video_path = parse_video_path(item) return video_path, "Video sent from WanX-t2v tab" wanx_t2v_send_to_wanx_v2v_btn.click( fn=send_wanx_t2v_to_v2v_input, inputs=[wanx_t2v_output, wanx_t2v_selected_index], outputs=[wanx_v2v_input, wanx_v2v_batch_progress] ).then( fn=lambda prompt: prompt, inputs=[wanx_t2v_prompt], outputs=[wanx_v2v_prompt] ).then( fn=change_to_wanx_v2v_tab, inputs=None, outputs=[tabs] ) # Send video from WanX-i2v to WanX-v2v wanx_i2v_send_to_wanx_v2v_btn.click( fn=send_wanx_t2v_to_v2v_input, # Reuse the same function inputs=[wanx_output, wanx_i2v_selected_index], outputs=[wanx_v2v_input, wanx_v2v_batch_progress] ).then( fn=lambda prompt: prompt, inputs=[wanx_prompt], outputs=[wanx_v2v_prompt] ).then( fn=change_to_wanx_v2v_tab, inputs=None, outputs=[tabs] ) # Update model paths when task changes def update_model_paths_for_task(task): if "1.3B" in task: return gr.update(value="wan/wan2.1_t2v_1.3B_fp16.safetensors") else: return gr.update(value="wan/wan2.1_t2v_14B_fp16.safetensors") wanx_v2v_task.change( fn=update_model_paths_for_task, inputs=[wanx_v2v_task], outputs=[wanx_v2v_dit_path] ) # Generate button handler wanx_v2v_generate_btn.click( fn=wanx_v2v_batch_handler, inputs=[ wanx_v2v_prompt, wanx_v2v_negative_prompt, wanx_v2v_input, wanx_v2v_width, wanx_v2v_height, wanx_v2v_video_length, wanx_v2v_fps, wanx_v2v_infer_steps, wanx_v2v_flow_shift, wanx_v2v_guidance_scale, wanx_v2v_strength, wanx_v2v_seed, wanx_v2v_batch_size, wanx_v2v_task, wanx_v2v_dit_folder, wanx_v2v_dit_path, wanx_v2v_vae_path, wanx_v2v_t5_path, wanx_v2v_save_path, wanx_v2v_output_type, wanx_v2v_sample_solver, wanx_v2v_exclude_single_blocks, wanx_v2v_attn_mode, wanx_v2v_block_swap, wanx_v2v_fp8, wanx_v2v_fp8_scaled, wanx_v2v_fp8_t5, wanx_v2v_lora_folder, wanx_v2v_slg_layers, wanx_v2v_slg_start, wanx_v2v_slg_end, wanx_v2v_enable_cfg_skip, wanx_v2v_cfg_skip_mode, wanx_v2v_cfg_apply_ratio, *wanx_v2v_lora_weights, *wanx_v2v_lora_multipliers ], outputs=[wanx_v2v_output, wanx_v2v_batch_progress, wanx_v2v_progress_text], queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[wanx_v2v_batch_size], outputs=wanx_v2v_selected_index ) # Gallery selection handling wanx_v2v_output.select( fn=handle_wanx_v2v_gallery_select, outputs=wanx_v2v_selected_index ) def change_to_tab_two(): return gr.Tabs(selected=2) # Send to Hunyuan v2v tab wanx_v2v_send_to_v2v_btn.click( fn=send_wanx_v2v_to_hunyuan_v2v, inputs=[ wanx_v2v_output, wanx_v2v_prompt, wanx_v2v_selected_index, wanx_v2v_width, wanx_v2v_height, wanx_v2v_video_length, wanx_v2v_fps, wanx_v2v_infer_steps, wanx_v2v_seed, wanx_v2v_flow_shift, wanx_v2v_guidance_scale, wanx_v2v_negative_prompt ], outputs=[ v2v_input, v2v_prompt, v2v_width, v2v_height, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_flow_shift, v2v_cfg_scale, v2v_negative_prompt ] ).then( fn=change_to_tab_two, inputs=None, outputs=[tabs] ) # Add refresh button handler for WanX-v2v tab wanx_v2v_refresh_outputs = [wanx_v2v_dit_path] # This is one output for i in range(4): wanx_v2v_refresh_outputs.extend([wanx_v2v_lora_weights[i], wanx_v2v_lora_multipliers[i]]) # This adds 8 more outputs wanx_v2v_refresh_btn.click( fn=update_dit_and_lora_dropdowns, # We need to use this function instead inputs=[wanx_v2v_dit_folder, wanx_v2v_lora_folder, wanx_v2v_dit_path] + wanx_v2v_lora_weights + wanx_v2v_lora_multipliers, outputs=wanx_v2v_refresh_outputs ) # Add function to send videos from Video Info tab to WanX-v2v def send_to_wanx_v2v(metadata: dict, video_path: str) -> Tuple[str, Dict, str]: """Handle both parameters and video transfer from Video Info to WanX-v2v tab with debugging""" if not video_path: return "No video selected", {}, None # Print debug information print(f"VIDEO INFO TO WANX-V2V TRANSFER:") print(f"Original metadata: {metadata}") print(f"Video path: {video_path}") # Special handling for WanX-v2v prompt fields # Create a copy of metadata with explicit prompt fields enhanced_metadata = metadata.copy() if "prompt" in metadata: enhanced_metadata["wanx_v2v_prompt"] = metadata["prompt"] if "negative_prompt" in metadata: enhanced_metadata["wanx_v2v_negative_prompt"] = metadata["negative_prompt"] print(f"Enhanced metadata: {enhanced_metadata}") status_msg, params = send_parameters_to_tab(enhanced_metadata, "wanx_v2v") print(f"Mapped parameters: {params}") return f"Parameters ready for WanX-v2v (DEBUG INFO IN CONSOLE)", enhanced_metadata, video_path # Then, implement a proper handler to change to the WanX-v2v tab def change_to_wanx_v2v_tab(): return gr.Tabs(selected=6) # WanX-v2v is tab index 6 # Next, connect the button to the functions with proper parameter mapping send_to_wanx_v2v_btn.click( fn=lambda m, v: handle_send_to_wanx_tab(m, 'wanx_v2v', v), inputs=[metadata_output, video_input], outputs=[status, params_state, wanx_v2v_input] ).then( lambda params: [ params.get("prompt", ""), params.get("width", 832), params.get("height", 480), params.get("video_length", 81), params.get("fps", 16), params.get("infer_steps", 40), params.get("seed", -1), params.get("flow_shift", 5.0), params.get("guidance_scale", 5.0), params.get("attn_mode", "sdpa"), params.get("block_swap", 0), params.get("negative_prompt", ""), params.get("strength", 0.75), *[params.get("lora_weights", ["None"]*4)[i] if isinstance(params.get("lora_weights", []), list) and i < len(params.get("lora_weights", [])) else "None" for i in range(4)], *[params.get("lora_multipliers", [1.0]*4)[i] if isinstance(params.get("lora_multipliers", []), list) and i < len(params.get("lora_multipliers", [])) else 1.0 for i in range(4)] ] if params else [gr.update()]*21, inputs=params_state, outputs=[ wanx_v2v_prompt, wanx_v2v_width, wanx_v2v_height, wanx_v2v_video_length, wanx_v2v_fps, wanx_v2v_infer_steps, wanx_v2v_seed, wanx_v2v_flow_shift, wanx_v2v_guidance_scale, wanx_v2v_attn_mode, wanx_v2v_block_swap, wanx_v2v_negative_prompt, wanx_v2v_strength, *wanx_v2v_lora_weights, *wanx_v2v_lora_multipliers ] ).then( fn=change_to_wanx_v2v_tab, inputs=None, outputs=[tabs] ) #Video Extension wanx_send_last_frame_btn.click( fn=send_last_frame_handler, inputs=[wanx_output, wanx_i2v_selected_index], outputs=[wanx_input, wanx_base_video] ) wanx_extend_btn.click( fn=prepare_for_batch_extension, inputs=[wanx_input, wanx_base_video, wanx_batch_size], outputs=[wanx_input, wanx_base_video, wanx_batch_size, wanx_batch_progress, wanx_progress_text] ).then( fn=lambda batch_size, base_video: "Starting batch extension..." if base_video and batch_size > 0 else "Error: Missing base video or invalid batch size", inputs=[wanx_batch_size, wanx_base_video], outputs=[wanx_batch_progress] ).then( # Process batch extension one at a time fn=process_batch_extension, inputs=[ wanx_prompt, wanx_negative_prompt, wanx_input, # Input image (last frame) wanx_base_video, # Base video to extend wanx_width, wanx_height, wanx_video_length, wanx_fps, wanx_infer_steps, wanx_flow_shift, wanx_guidance_scale, wanx_seed, wanx_batch_size, wanx_task, wanx_dit_folder, # <<< Pass the folder path wanx_dit_path, # <<< Pass the model filename wanx_vae_path, wanx_t5_path, wanx_clip_path, wanx_save_path, wanx_output_type, wanx_sample_solver, wanx_exclude_single_blocks, wanx_attn_mode, wanx_block_swap, wanx_fp8, wanx_fp8_scaled, wanx_fp8_t5, wanx_lora_folder, wanx_slg_layers, wanx_slg_start, wanx_slg_end, # Pass LoRA weights and multipliers individually wanx_lora_weights[0], wanx_lora_weights[1], wanx_lora_weights[2], wanx_lora_weights[3], wanx_lora_multipliers[0], wanx_lora_multipliers[1], wanx_lora_multipliers[2], wanx_lora_multipliers[3] ], outputs=[wanx_output, wanx_batch_progress, wanx_progress_text] ) # Extract and send sharpest frame to input wanx_send_sharpest_frame_btn.click( fn=send_sharpest_frame_handler, inputs=[wanx_output, wanx_i2v_selected_index, wanx_frames_to_check], outputs=[wanx_input, wanx_base_video, wanx_sharpest_frame_number, wanx_sharpest_frame_status] ) # Trim video to sharpest frame and prepare for extension wanx_trim_and_extend_btn.click( fn=trim_and_prepare_for_extension, inputs=[wanx_base_video, wanx_sharpest_frame_number, wanx_save_path], outputs=[wanx_trimmed_video_path, wanx_sharpest_frame_status] ).then( fn=lambda path, status: (path, status if "Failed" in status else "Video trimmed successfully and ready for extension"), inputs=[wanx_trimmed_video_path, wanx_sharpest_frame_status], outputs=[wanx_base_video, wanx_sharpest_frame_status] ) wanx_extend_with_trimmed_btn.click( # Prepare step: Sets the base video to the trimmed video path fn=prepare_for_batch_extension, inputs=[wanx_input, wanx_trimmed_video_path, wanx_batch_size], # Use trimmed video path here outputs=[wanx_input, wanx_base_video, wanx_batch_size, wanx_batch_progress, wanx_progress_text] # Update base_video state ).then( # Actual extension processing step fn=process_batch_extension, inputs=[ wanx_prompt, wanx_negative_prompt, wanx_input, # Input image (sharpest frame) wanx_trimmed_video_path, # Base video to extend (the trimmed one) wanx_width, wanx_height, wanx_video_length, wanx_fps, wanx_infer_steps, wanx_flow_shift, wanx_guidance_scale, wanx_seed, wanx_batch_size, wanx_task, wanx_dit_folder, # <<< Pass the folder path wanx_dit_path, # <<< Pass the model filename wanx_vae_path, wanx_t5_path, wanx_clip_path, wanx_save_path, wanx_output_type, wanx_sample_solver, wanx_exclude_single_blocks, wanx_attn_mode, wanx_block_swap, wanx_fp8, wanx_fp8_scaled, wanx_fp8_t5, wanx_lora_folder, wanx_slg_layers, wanx_slg_start, wanx_slg_end, # Pass LoRA weights and multipliers individually wanx_lora_weights[0], wanx_lora_weights[1], wanx_lora_weights[2], wanx_lora_weights[3], wanx_lora_multipliers[0], wanx_lora_multipliers[1], wanx_lora_multipliers[2], wanx_lora_multipliers[3] ], outputs=[wanx_output, wanx_batch_progress, wanx_progress_text] ) #Video Info def handle_send_to_wanx_tab(metadata, target_tab, video_path=None): """Common handler for sending video parameters to WanX tabs""" if not metadata: return "No parameters to send", {}, None # Return three values # Tab names for clearer messages tab_names = { 'wanx_i2v': 'WanX-i2v', 'wanx_t2v': 'WanX-t2v', 'wanx_v2v': 'WanX-v2v' } # Just pass through all parameters - we'll use them in the .then() function return f"Parameters ready for {tab_names.get(target_tab, target_tab)}", metadata, video_path def change_to_wanx_i2v_tab(): return gr.Tabs(selected=4) # WanX-i2v tab index def change_to_wanx_t2v_tab(): return gr.Tabs(selected=5) # WanX-t2v tab index send_to_wanx_i2v_btn.click( fn=lambda m: ("Parameters ready for WanX-i2v", m), inputs=[metadata_output], outputs=[status, params_state] ).then( # Reusing the same pattern as other tab transfers with LoRA handling lambda params: [ params.get("prompt", ""), params.get("width", 832), params.get("height", 480), params.get("video_length", 81), params.get("fps", 16), params.get("infer_steps", 40), params.get("seed", -1), params.get("flow_shift", 3.0), params.get("guidance_scale", 5.0), params.get("attn_mode", "sdpa"), params.get("block_swap", 0), params.get("task", "i2v-14B"), params.get("negative_prompt", ""), *[params.get("lora_weights", ["None"]*4)[i] if isinstance(params.get("lora_weights", []), list) and i < len(params.get("lora_weights", [])) else "None" for i in range(4)], *[params.get("lora_multipliers", [1.0]*4)[i] if isinstance(params.get("lora_multipliers", []), list) and i < len(params.get("lora_multipliers", [])) else 1.0 for i in range(4)] ] if params else [gr.update()]*20, inputs=params_state, outputs=[ wanx_prompt, wanx_width, wanx_height, wanx_video_length, wanx_fps, wanx_infer_steps, wanx_seed, wanx_flow_shift, wanx_guidance_scale, wanx_attn_mode, wanx_block_swap, wanx_task, wanx_negative_prompt, *wanx_lora_weights, *wanx_lora_multipliers ] ).then( fn=change_to_wanx_i2v_tab, inputs=None, outputs=[tabs] ) # 3. Update the WanX-t2v button handler send_to_wanx_t2v_btn.click( fn=lambda m: handle_send_to_wanx_tab(m, 'wanx_t2v'), inputs=[metadata_output], outputs=[status, params_state] ).then( lambda params: [ params.get("prompt", ""), params.get("width", 832), params.get("height", 480), params.get("video_length", 81), params.get("fps", 16), params.get("infer_steps", 50), params.get("seed", -1), params.get("flow_shift", 5.0), params.get("guidance_scale", 5.0), params.get("attn_mode", "sdpa"), params.get("block_swap", 0), params.get("negative_prompt", ""), *[params.get("lora_weights", ["None"]*4)[i] if isinstance(params.get("lora_weights", []), list) and i < len(params.get("lora_weights", [])) else "None" for i in range(4)], *[params.get("lora_multipliers", [1.0]*4)[i] if isinstance(params.get("lora_multipliers", []), list) and i < len(params.get("lora_multipliers", [])) else 1.0 for i in range(4)] ] if params else [gr.update()]*20, inputs=params_state, outputs=[ wanx_t2v_prompt, wanx_t2v_width, wanx_t2v_height, wanx_t2v_video_length, wanx_t2v_fps, wanx_t2v_infer_steps, wanx_t2v_seed, wanx_t2v_flow_shift, wanx_t2v_guidance_scale, wanx_t2v_attn_mode, wanx_t2v_block_swap, wanx_t2v_negative_prompt, *wanx_t2v_lora_weights, *wanx_t2v_lora_multipliers ] ).then( fn=change_to_wanx_t2v_tab, inputs=None, outputs=[tabs] ) # FramePack-Extension send-to logic def handle_send_to_fpe_tab(metadata: dict, video_path: str) -> Tuple[str, Dict, str]: """Prepare parameters and video path for the FramePack-Extension tab.""" if not video_path: return "No video selected to send to FramePack-Extension", {}, None # If metadata is empty, provide a message but still allow video transfer status_msg = "Parameters ready for FramePack-Extension." if not metadata: status_msg = "Video sent to FramePack-Extension (no parameters found in metadata)." metadata = {} # Ensure metadata is a dict return status_msg, metadata, video_path def change_to_fpe_tab(): return gr.Tabs(selected=11) # FramePack-Extension tab has id=11 send_to_fpe_btn.click( fn=handle_send_to_fpe_tab, inputs=[metadata_output, video_input], outputs=[status, params_state, fpe_input_video] # status, state for params, and video input for FPE ).then( lambda params: ( ( (is_f1_from_meta := params.get("is_f1", True)), # Default to F1 if not specified (use_normal_fp_val := not is_f1_from_meta), # fpe_use_normal_framepack is opposite of is_f1 # Determine resolution_max_dim (target_res_meta := params.get("target_resolution")), (video_w_meta := params.get("video_width")), (video_h_meta := params.get("video_height")), ( res_max_dim_val := int(target_res_meta) if target_res_meta and int(target_res_meta) > 0 else max(int(video_w_meta), int(video_h_meta)) if video_w_meta and video_h_meta and int(video_w_meta) > 0 and int(video_h_meta) > 0 else 640 # Default ), # LoRA handling (weights_from_meta := params.get("lora_weights", [])), (mults_from_meta := params.get("lora_multipliers", [])), (padded_weights := (weights_from_meta + ["None"] * 4)[:4]), (padded_mults := ([float(m) if isinstance(m, (int, float, str)) and str(m).replace('.', '', 1).isdigit() else 1.0 for m in mults_from_meta] + [1.0] * 4)[:4]), [ params.get("prompt", "cinematic video of a cat wizard casting a spell"), params.get("negative_prompt", ""), params.get("seed", -1), use_normal_fp_val, # fpe_end_frame and fpe_end_frame_weight are typically not in generic metadata, use defaults gr_update(value=None), # fpe_end_frame (Image) gr_update(value=1.0), # fpe_end_frame_weight res_max_dim_val, params.get("video_seconds", params.get("total_second_length", 5.0)), # Map from FramePack's video_seconds params.get("latent_window_size", 9), params.get("infer_steps", params.get("steps", 25)), # Map from FramePack's infer_steps params.get("guidance_scale", params.get("cfg_scale", 1.0)), # Map from FramePack's guidance_scale to fpe_cfg_scale params.get("embedded_cfg_scale", params.get("distilled_guidance_scale", 3.0)), # Map from FramePack's embedded_cfg_scale # Model Paths - use FPE defaults or specific paths from metadata if available # The DiT path is now primarily handled by the fpe_use_normal_framepack.change event params.get("transformer_path", "hunyuan/FramePack_F1_I2V_HY_20250503.safetensors"), # Placeholder, will be overridden params.get("vae_path", "hunyuan/pytorch_model.pt"), params.get("text_encoder_path", "hunyuan/llava_llama3_fp16.safetensors"), params.get("text_encoder_2_path", "hunyuan/clip_l.safetensors"), params.get("image_encoder_path", "hunyuan/model.safetensors"), # Advanced performance params.get("attn_mode", "torch"), params.get("fp8_llm", False), # This will be correctly set by fpe_use_normal_framepack.change params.get("vae_chunk_size", 32), params.get("vae_spatial_tile_sample_min_size", 128), # LoRAs *padded_weights, *padded_mults, ] )[-1] # Return the list of values ) if params else [gr.update()] * (18 + 8), # 18 direct params + 4 lora weights + 4 lora mults inputs=params_state, outputs=[ fpe_prompt, fpe_negative_prompt, fpe_seed, fpe_use_normal_framepack, # This will trigger its own .change event fpe_end_frame, fpe_end_frame_weight, # These are UI only if fpe_use_normal_framepack is True fpe_resolution_max_dim, fpe_total_second_length, fpe_latent_window_size, fpe_steps, fpe_cfg_scale, fpe_distilled_guidance_scale, # Model Paths fpe_transformer_path, # Will be set by fpe_use_normal_framepack.change fpe_vae_path, fpe_text_encoder_path, fpe_text_encoder_2_path, fpe_image_encoder_path, # Advanced fpe_attn_mode, fpe_fp8_llm, # fpe_fp8_llm also set by fpe_use_normal_framepack.change fpe_vae_chunk_size, fpe_vae_spatial_tile_sample_min_size, # LoRAs *fpe_lora_weights_ui, *fpe_lora_multipliers_ui, ] ).then( fn=change_to_fpe_tab, inputs=None, outputs=[tabs] ) #text to video def change_to_tab_one(): return gr.Tabs(selected=1) #This will navigate #video to video def change_to_skyreels_tab(): return gr.Tabs(selected=3) #SKYREELS TAB!!! # Add state management for dimensions def sync_skyreels_dimensions(width, height): return gr.update(value=width), gr.update(value=height) # Add this function to update the LoRA dropdowns in the SKYREELS tab def update_skyreels_lora_dropdowns(lora_folder: str, *current_values) -> List[gr.update]: new_choices = get_lora_options(lora_folder) weights = current_values[:4] multipliers = current_values[4:8] results = [] for i in range(4): weight = weights[i] if i < len(weights) else "None" multiplier = multipliers[i] if i < len(multipliers) else 1.0 if weight not in new_choices: weight = "None" results.extend([ gr.update(choices=new_choices, value=weight), gr.update(value=multiplier) ]) return results # Add this function to update the models dropdown in the SKYREELS tab def update_skyreels_model_dropdown(dit_folder: str) -> Dict: models = get_dit_models(dit_folder) return gr.update(choices=models, value=models[0] if models else None) # Add event handler for model dropdown refresh skyreels_dit_folder.change( fn=update_skyreels_model_dropdown, inputs=[skyreels_dit_folder], outputs=[skyreels_model] ) # Add handlers for the refresh button skyreels_refresh_btn.click( fn=update_skyreels_lora_dropdowns, inputs=[skyreels_lora_folder] + skyreels_lora_weights + skyreels_lora_multipliers, outputs=[drop for _ in range(4) for drop in [skyreels_lora_weights[_], skyreels_lora_multipliers[_]]] ) # Skyreels dimension handling def calculate_skyreels_width(height, original_dims): if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_width = math.floor((height * aspect_ratio) / 16) * 16 return gr.update(value=new_width) def calculate_skyreels_height(width, original_dims): if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_height = math.floor((width / aspect_ratio) / 16) * 16 return gr.update(value=new_height) def update_skyreels_from_scale(scale, original_dims): if not original_dims: return gr.update(), gr.update() orig_w, orig_h = map(int, original_dims.split('x')) new_w = math.floor((orig_w * scale / 100) / 16) * 16 new_h = math.floor((orig_h * scale / 100) / 16) * 16 return gr.update(value=new_w), gr.update(value=new_h) def update_skyreels_dimensions(image): if image is None: return "", gr.update(value=544), gr.update(value=544) img = Image.open(image) w, h = img.size w = (w // 16) * 16 h = (h // 16) * 16 return f"{w}x{h}", w, h def handle_skyreels_gallery_select(evt: gr.SelectData) -> int: return evt.index def send_skyreels_to_v2v( gallery: list, prompt: str, selected_index: int, width: int, height: int, video_length: int, fps: int, infer_steps: int, seed: int, flow_shift: float, cfg_scale: float, lora1: str, lora2: str, lora3: str, lora4: str, lora1_multiplier: float, lora2_multiplier: float, lora3_multiplier: float, lora4_multiplier: float, negative_prompt: str = "" # Add this parameter ) -> Tuple: if not gallery or selected_index is None or selected_index >= len(gallery): return (None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, cfg_scale, lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier, negative_prompt) # Add negative_prompt to return selected_item = gallery[selected_index] if isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, (tuple, list)): video_path = selected_item[0] else: video_path = selected_item if isinstance(video_path, tuple): video_path = video_path[0] return (str(video_path), prompt, width, height, video_length, fps, infer_steps, seed, flow_shift, cfg_scale, lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier, negative_prompt) # Add negative_prompt to return # Add event handlers for the SKYREELS tab skyreels_prompt.change(fn=count_prompt_tokens, inputs=skyreels_prompt, outputs=skyreels_token_counter) skyreels_stop_btn.click(fn=lambda: stop_event.set(), queue=False) # Image input handling skyreels_input.change( fn=update_skyreels_dimensions, inputs=[skyreels_input], outputs=[skyreels_original_dims, skyreels_width, skyreels_height] ) skyreels_scale_slider.change( fn=update_skyreels_from_scale, inputs=[skyreels_scale_slider, skyreels_original_dims], outputs=[skyreels_width, skyreels_height] ) skyreels_calc_width_btn.click( fn=calculate_skyreels_width, inputs=[skyreels_height, skyreels_original_dims], outputs=[skyreels_width] ) skyreels_calc_height_btn.click( fn=calculate_skyreels_height, inputs=[skyreels_width, skyreels_original_dims], outputs=[skyreels_height] ) # Handle checkbox visibility toggling skyreels_use_random_folder.change( fn=lambda x: (gr.update(visible=x), gr.update(visible=x), gr.update(visible=not x)), inputs=[skyreels_use_random_folder], outputs=[skyreels_input_folder, skyreels_folder_status, skyreels_input] ) # Validate folder button click handler skyreels_validate_folder_btn.click( fn=lambda folder: get_random_image_from_folder(folder)[1], inputs=[skyreels_input_folder], outputs=[skyreels_folder_status] ) skyreels_use_random_folder.change( fn=lambda x: gr.update(visible=x), inputs=[skyreels_use_random_folder], outputs=[skyreels_validate_folder_btn] ) # Modify the skyreels_generate_btn.click event handler to use process_random_image_batch when folder mode is on skyreels_generate_btn.click( fn=batch_handler, inputs=[ skyreels_use_random_folder, # Rest of the arguments skyreels_prompt, skyreels_negative_prompt, skyreels_width, skyreels_height, skyreels_video_length, skyreels_fps, skyreels_infer_steps, skyreels_seed, skyreels_flow_shift, skyreels_guidance_scale, skyreels_embedded_cfg_scale, skyreels_batch_size, skyreels_input_folder, skyreels_dit_folder, skyreels_model, skyreels_vae, skyreels_te1, skyreels_te2, skyreels_save_path, skyreels_output_type, skyreels_attn_mode, skyreels_block_swap, skyreels_exclude_single_blocks, skyreels_use_split_attn, skyreels_use_fp8, skyreels_split_uncond, skyreels_lora_folder, *skyreels_lora_weights, *skyreels_lora_multipliers, skyreels_input # Add the input image path ], outputs=[skyreels_output, skyreels_batch_progress, skyreels_progress_text], queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[skyreels_batch_size], outputs=skyreels_selected_index ) # Gallery selection handling skyreels_output.select( fn=handle_skyreels_gallery_select, outputs=skyreels_selected_index ) # Send to Video2Video handler skyreels_send_to_v2v_btn.click( fn=send_skyreels_to_v2v, inputs=[ skyreels_output, skyreels_prompt, skyreels_selected_index, skyreels_width, skyreels_height, skyreels_video_length, skyreels_fps, skyreels_infer_steps, skyreels_seed, skyreels_flow_shift, skyreels_guidance_scale ] + skyreels_lora_weights + skyreels_lora_multipliers + [skyreels_negative_prompt], # This is ok because skyreels_negative_prompt is a Gradio component outputs=[ v2v_input, v2v_prompt, v2v_width, v2v_height, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_flow_shift, v2v_cfg_scale ] + v2v_lora_weights + v2v_lora_multipliers + [v2v_negative_prompt] ).then( fn=change_to_tab_two, inputs=None, outputs=[tabs] ) # Refresh button handler skyreels_refresh_outputs = [skyreels_model] for i in range(4): skyreels_refresh_outputs.extend([skyreels_lora_weights[i], skyreels_lora_multipliers[i]]) skyreels_refresh_btn.click( fn=update_dit_and_lora_dropdowns, inputs=[skyreels_dit_folder, skyreels_lora_folder, skyreels_model] + skyreels_lora_weights + skyreels_lora_multipliers, outputs=skyreels_refresh_outputs ) def calculate_v2v_width(height, original_dims): if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_width = math.floor((height * aspect_ratio) / 16) * 16 # Ensure divisible by 16 return gr.update(value=new_width) def calculate_v2v_height(width, original_dims): if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_height = math.floor((width / aspect_ratio) / 16) * 16 # Ensure divisible by 16 return gr.update(value=new_height) def update_v2v_from_scale(scale, original_dims): if not original_dims: return gr.update(), gr.update() orig_w, orig_h = map(int, original_dims.split('x')) new_w = math.floor((orig_w * scale / 100) / 16) * 16 # Ensure divisible by 16 new_h = math.floor((orig_h * scale / 100) / 16) * 16 # Ensure divisible by 16 return gr.update(value=new_w), gr.update(value=new_h) def update_v2v_dimensions(video): if video is None: return "", gr.update(value=544), gr.update(value=544) cap = cv2.VideoCapture(video) w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) cap.release() # Make dimensions divisible by 16 w = (w // 16) * 16 h = (h // 16) * 16 return f"{w}x{h}", w, h # Event Handlers for Video to Video Tab v2v_input.change( fn=update_v2v_dimensions, inputs=[v2v_input], outputs=[v2v_original_dims, v2v_width, v2v_height] ) v2v_scale_slider.change( fn=update_v2v_from_scale, inputs=[v2v_scale_slider, v2v_original_dims], outputs=[v2v_width, v2v_height] ) v2v_calc_width_btn.click( fn=calculate_v2v_width, inputs=[v2v_height, v2v_original_dims], outputs=[v2v_width] ) v2v_calc_height_btn.click( fn=calculate_v2v_height, inputs=[v2v_width, v2v_original_dims], outputs=[v2v_height] ) ##Image 2 video dimension logic def calculate_width(height, original_dims): if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_width = math.floor((height * aspect_ratio) / 16) * 16 # Changed from 8 to 16 return gr.update(value=new_width) def calculate_height(width, original_dims): if not original_dims: return gr.update() orig_w, orig_h = map(int, original_dims.split('x')) aspect_ratio = orig_w / orig_h new_height = math.floor((width / aspect_ratio) / 16) * 16 # Changed from 8 to 16 return gr.update(value=new_height) def update_from_scale(scale, original_dims): if not original_dims: return gr.update(), gr.update() orig_w, orig_h = map(int, original_dims.split('x')) new_w = math.floor((orig_w * scale / 100) / 16) * 16 # Changed from 8 to 16 new_h = math.floor((orig_h * scale / 100) / 16) * 16 # Changed from 8 to 16 return gr.update(value=new_w), gr.update(value=new_h) def update_dimensions(image): if image is None: return "", gr.update(value=544), gr.update(value=544) img = Image.open(image) w, h = img.size # Make dimensions divisible by 16 w = (w // 16) * 16 # Changed from 8 to 16 h = (h // 16) * 16 # Changed from 8 to 16 return f"{w}x{h}", w, h i2v_input.change( fn=update_dimensions, inputs=[i2v_input], outputs=[original_dims, i2v_width, i2v_height] # Update correct components ) scale_slider.change( fn=update_from_scale, inputs=[scale_slider, original_dims], outputs=[i2v_width, i2v_height] # Update correct components ) calc_width_btn.click( fn=calculate_width, inputs=[i2v_height, original_dims], # Update correct components outputs=[i2v_width] ) calc_height_btn.click( fn=calculate_height, inputs=[i2v_width, original_dims], # Update correct components outputs=[i2v_height] ) # Function to get available DiT models def get_dit_models(dit_folder: str) -> List[str]: if not os.path.exists(dit_folder): return ["mp_rank_00_model_states.pt"] models = [f for f in os.listdir(dit_folder) if f.endswith('.pt') or f.endswith('.safetensors')] models.sort(key=str.lower) return models if models else ["mp_rank_00_model_states.pt"] # Function to perform model merging def merge_models( dit_folder: str, dit_model: str, output_model: str, exclude_single_blocks: bool, merge_lora_folder: str, *lora_params # Will contain both weights and multipliers ) -> str: try: # Separate weights and multipliers num_loras = len(lora_params) // 2 weights = list(lora_params[:num_loras]) multipliers = list(lora_params[num_loras:]) # Filter out "None" selections valid_loras = [] for weight, mult in zip(weights, multipliers): if weight and weight != "None": valid_loras.append((os.path.join(merge_lora_folder, weight), mult)) if not valid_loras: return "No LoRA models selected for merging" # Create output path in the dit folder os.makedirs(dit_folder, exist_ok=True) output_path = os.path.join(dit_folder, output_model) # Prepare command cmd = [ sys.executable, "merge_lora.py", "--dit", os.path.join(dit_folder, dit_model), "--save_merged_model", output_path ] # Add LoRA weights and multipliers weights = [weight for weight, _ in valid_loras] multipliers = [str(mult) for _, mult in valid_loras] cmd.extend(["--lora_weight"] + weights) cmd.extend(["--lora_multiplier"] + multipliers) if exclude_single_blocks: cmd.append("--exclude_single_blocks") # Execute merge operation result = subprocess.run( cmd, capture_output=True, text=True, check=True ) if os.path.exists(output_path): return f"Successfully merged model and saved to {output_path}" else: return "Error: Output file not created" except subprocess.CalledProcessError as e: return f"Error during merging: {e.stderr}" except Exception as e: return f"Error: {str(e)}" # Update DiT model dropdown def update_dit_dropdown(dit_folder: str) -> Dict: models = get_dit_models(dit_folder) return gr.update(choices=models, value=models[0] if models else None) # Connect events merge_btn.click( fn=merge_models, inputs=[ dit_folder, dit_model, output_model, exclude_single_blocks, merge_lora_folder, *merge_lora_weights, *merge_lora_multipliers ], outputs=merge_status ) # Refresh buttons for both DiT and LoRA dropdowns merge_refresh_btn.click( fn=lambda f: update_dit_dropdown(f), inputs=[dit_folder], outputs=[dit_model] ) # LoRA refresh handling merge_refresh_outputs = [] for i in range(4): merge_refresh_outputs.extend([merge_lora_weights[i], merge_lora_multipliers[i]]) merge_refresh_btn.click( fn=update_lora_dropdowns, inputs=[merge_lora_folder] + merge_lora_weights + merge_lora_multipliers, outputs=merge_refresh_outputs ) # Event handlers prompt.change(fn=count_prompt_tokens, inputs=prompt, outputs=token_counter) v2v_prompt.change(fn=count_prompt_tokens, inputs=v2v_prompt, outputs=v2v_token_counter) stop_btn.click(fn=lambda: stop_event.set(), queue=False) v2v_stop_btn.click(fn=lambda: stop_event.set(), queue=False) #Image_to_Video def image_to_video(image_path, output_path, width, height, frames=240): # Add width, height parameters img = Image.open(image_path) # Resize to the specified dimensions img_resized = img.resize((width, height), Image.LANCZOS) temp_image_path = os.path.join(os.path.dirname(output_path), "temp_resized_image.png") img_resized.save(temp_image_path) # Rest of function remains the same frame_rate = 24 duration = frames / frame_rate command = [ "ffmpeg", "-loop", "1", "-i", temp_image_path, "-c:v", "libx264", "-t", str(duration), "-pix_fmt", "yuv420p", "-vf", f"fps={frame_rate}", output_path ] try: subprocess.run(command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) print(f"Video saved to {output_path}") return True except subprocess.CalledProcessError as e: print(f"An error occurred while creating the video: {e}") return False finally: # Clean up the temporary image file if os.path.exists(temp_image_path): os.remove(temp_image_path) img.close() # Make sure to close the image file explicitly def generate_from_image( image_path, prompt, width, height, video_length, fps, infer_steps, seed, model, vae, te1, te2, save_path, flow_shift, cfg_scale, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, lora_folder, strength, batch_size, *lora_params ): """Generate video from input image with progressive updates""" global stop_event stop_event.clear() # Create temporary video path temp_video_path = os.path.join(save_path, f"temp_{os.path.basename(image_path)}.mp4") try: # Convert image to video if not image_to_video(image_path, temp_video_path, width, height, frames=video_length): yield [], "Failed to create temporary video", "Error in video creation" return # Ensure video is fully written before proceeding time.sleep(1) if not os.path.exists(temp_video_path) or os.path.getsize(temp_video_path) == 0: yield [], "Failed to create temporary video", "Temporary video file is empty or missing" return # Get video dimensions try: probe = ffmpeg.probe(temp_video_path) video_stream = next((stream for stream in probe['streams'] if stream['codec_type'] == 'video'), None) if video_stream is None: raise ValueError("No video stream found") width = int(video_stream['width']) height = int(video_stream['height']) except Exception as e: yield [], f"Error reading video dimensions: {str(e)}", "Video processing error" return # Generate the video using the temporary file try: generator = process_single_video( prompt, width, height, batch_size, video_length, fps, infer_steps, seed, model, vae, te1, te2, save_path, flow_shift, cfg_scale, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, lora_folder, *lora_params, video_path=temp_video_path, strength=strength ) # Forward all generator updates for videos, batch_text, progress_text in generator: yield videos, batch_text, progress_text except Exception as e: yield [], f"Error in video generation: {str(e)}", "Generation error" return except Exception as e: yield [], f"Unexpected error: {str(e)}", "Error occurred" return finally: # Clean up temporary file try: if os.path.exists(temp_video_path): os.remove(temp_video_path) except Exception: pass # Ignore cleanup errors # Add event handlers i2v_prompt.change(fn=count_prompt_tokens, inputs=i2v_prompt, outputs=i2v_token_counter) i2v_stop_btn.click(fn=lambda: stop_event.set(), queue=False) def handle_i2v_gallery_select(evt: gr.SelectData) -> int: """Track selected index when I2V gallery item is clicked""" return evt.index def send_i2v_to_v2v( gallery: list, prompt: str, selected_index: int, width: int, height: int, video_length: int, fps: int, infer_steps: int, seed: int, flow_shift: float, cfg_scale: float, lora1: str, lora2: str, lora3: str, lora4: str, lora1_multiplier: float, lora2_multiplier: float, lora3_multiplier: float, lora4_multiplier: float ) -> Tuple[Optional[str], str, int, int, int, int, int, int, float, float, str, str, str, str, float, float, float, float]: """Send the selected video and parameters from Image2Video tab to Video2Video tab""" if not gallery or selected_index is None or selected_index >= len(gallery): return None, "", width, height, video_length, fps, infer_steps, seed, flow_shift, cfg_scale, \ lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier selected_item = gallery[selected_index] # Handle different gallery item formats if isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, (tuple, list)): video_path = selected_item[0] else: video_path = selected_item # Final cleanup for Gradio Video component if isinstance(video_path, tuple): video_path = video_path[0] # Use the original width and height without doubling return (str(video_path), prompt, width, height, video_length, fps, infer_steps, seed, flow_shift, cfg_scale, lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier) # Generate button handler for h-basic-i2v i2v_generate_btn.click( fn=process_i2v_batch, # <<< Use the new batch function inputs=[ i2v_prompt, i2v_input, # Image path i2v_width, i2v_height, i2v_batch_size, i2v_video_length, i2v_fps, i2v_infer_steps, i2v_seed, i2v_dit_folder, i2v_model, i2v_vae, i2v_te1, i2v_te2, i2v_clip_vision_path, i2v_save_path, i2v_flow_shift, i2v_cfg_scale, # embedded_cfg_scale i2v_guidance_scale, # main CFG scale i2v_output_type, i2v_attn_mode, i2v_block_swap, i2v_exclude_single_blocks, i2v_use_split_attn, i2v_lora_folder, i2v_vae_chunk_size, i2v_vae_spatial_tile_min, # --- Add negative prompt component if you have one --- # i2v_negative_prompt, # Uncomment if you added this textbox # --- If no negative prompt textbox, pass None or "": --- gr.Textbox(value="", visible=False), # Placeholder if no UI element # --- End negative prompt handling --- i2v_use_fp8, i2v_fp8_llm, *i2v_lora_weights, # Pass LoRA weights components *i2v_lora_multipliers # Pass LoRA multipliers components ], outputs=[i2v_output, i2v_batch_progress, i2v_progress_text], queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[i2v_batch_size], outputs=i2v_selected_index ) # Send to Video2Video i2v_output.select( fn=handle_i2v_gallery_select, outputs=i2v_selected_index ) i2v_send_to_v2v_btn.click( fn=send_i2v_to_v2v, # Function definition needs careful review/update if args changed inputs=[ i2v_output, i2v_prompt, i2v_selected_index, i2v_width, i2v_height, # <<< Use i2v width/height i2v_video_length, i2v_fps, i2v_infer_steps, i2v_seed, i2v_flow_shift, i2v_cfg_scale # <<< Use i2v cfg_scale (embedded) ] + i2v_lora_weights + i2v_lora_multipliers, # <<< Use i2v LoRAs outputs=[ v2v_input, v2v_prompt, v2v_width, v2v_height, # Target V2V components v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_flow_shift, v2v_cfg_scale # Target V2V components ] + v2v_lora_weights + v2v_lora_multipliers # Target V2V LoRAs ).then( fn=change_to_tab_two, inputs=None, outputs=[tabs] ) #Video Info def clean_video_path(video_path) -> str: """Extract clean video path from Gradio's various return formats""" print(f"Input video_path: {video_path}, type: {type(video_path)}") if isinstance(video_path, dict): path = video_path.get("name", "") elif isinstance(video_path, (tuple, list)): path = video_path[0] elif isinstance(video_path, str): path = video_path else: path = "" print(f"Cleaned path: {path}") return path def handle_video_upload(video_path: str) -> Dict: """Handle video upload and metadata extraction""" if not video_path: return {}, "No video uploaded" metadata = extract_video_metadata(video_path) if not metadata: return {}, "No metadata found in video" return metadata, "Metadata extracted successfully" def get_video_info(video_path: str) -> dict: try: probe = ffmpeg.probe(video_path) video_info = next(stream for stream in probe['streams'] if stream['codec_type'] == 'video') width = int(video_info['width']) height = int(video_info['height']) fps = eval(video_info['r_frame_rate']) # This converts '30/1' to 30.0 # Calculate total frames duration = float(probe['format']['duration']) total_frames = int(duration * fps) # Ensure video length does not exceed 201 frames if total_frames > 201: total_frames = 201 duration = total_frames / fps # Adjust duration accordingly return { 'width': width, 'height': height, 'fps': fps, 'total_frames': total_frames, 'duration': duration # Might be useful in some contexts } except Exception as e: print(f"Error extracting video info: {e}") return {} def extract_video_details(video_path: str) -> Tuple[dict, str]: metadata = extract_video_metadata(video_path) video_details = get_video_info(video_path) # Combine metadata with video details for key, value in video_details.items(): if key not in metadata: metadata[key] = value # Ensure video length does not exceed 201 frames if 'video_length' in metadata: metadata['video_length'] = min(metadata['video_length'], 201) else: metadata['video_length'] = min(video_details.get('total_frames', 0), 201) # Return both the updated metadata and a status message return metadata, "Video details extracted successfully" def send_parameters_to_tab(metadata: Dict, target_tab: str) -> Tuple[str, Dict]: """Create parameter mapping for target tab""" if not metadata: return "No parameters to send", {} tab_name = "Text2Video" if target_tab == "t2v" else "Video2Video" try: mapping = create_parameter_transfer_map(metadata, target_tab) return f"Parameters ready for {tab_name}", mapping except Exception as e: return f"Error: {str(e)}", {} video_input.upload( fn=extract_video_details, inputs=video_input, outputs=[metadata_output, status] ) send_to_t2v_btn.click( fn=lambda m: send_parameters_to_tab(m, "t2v"), inputs=metadata_output, outputs=[status, params_state] ).then( fn=change_to_tab_one, inputs=None, outputs=[tabs] ).then( lambda params: [ params.get("prompt", ""), params.get("width", 544), # Parameter mapping is fine here params.get("height", 544), # Parameter mapping is fine here params.get("batch_size", 1), params.get("video_length", 25), params.get("fps", 24), params.get("infer_steps", 30), params.get("seed", -1), params.get("model", "hunyuan/mp_rank_00_model_states.pt"), params.get("vae", "hunyuan/pytorch_model.pt"), params.get("te1", "hunyuan/llava_llama3_fp16.safetensors"), params.get("te2", "hunyuan/clip_l.safetensors"), params.get("save_path", "outputs"), params.get("flow_shift", 11.0), params.get("cfg_scale", 7.0), params.get("output_type", "video"), params.get("attn_mode", "sdpa"), params.get("block_swap", "0"), *[params.get(f"lora{i+1}", "") for i in range(4)], *[params.get(f"lora{i+1}_multiplier", 1.0) for i in range(4)] ] if params else [gr.update()]*26, # This lambda returns values based on param keys inputs=params_state, outputs=[prompt, t2v_width, t2v_height, batch_size, video_length, fps, infer_steps, seed, # <<< CORRECTED HERE: use t2v_width, t2v_height model, vae, te1, te2, save_path, flow_shift, cfg_scale, output_type, attn_mode, block_swap] + lora_weights + lora_multipliers ) # Text to Video generation generate_btn.click( fn=process_batch, inputs=[ prompt, t2v_width, t2v_height, batch_size, video_length, fps, infer_steps, seed, dit_folder, model, vae, te1, te2, save_path, flow_shift, cfg_scale, output_type, attn_mode, block_swap, exclude_single_blocks, use_split_attn, lora_folder, *lora_weights, *lora_multipliers, gr.Textbox(visible=False), gr.Number(visible=False), use_fp8 ], outputs=[video_output, batch_progress, progress_text], queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[batch_size], outputs=selected_index ) # Update gallery selection handling def handle_gallery_select(evt: gr.SelectData) -> int: return evt.index # Track selected index when gallery item is clicked video_output.select( fn=handle_gallery_select, outputs=selected_index ) # Track selected index when Video2Video gallery item is clicked def handle_v2v_gallery_select(evt: gr.SelectData) -> int: """Handle gallery selection without automatically updating the input""" return evt.index # Update the gallery selection event v2v_output.select( fn=handle_v2v_gallery_select, outputs=v2v_selected_index ) # Send button handler with gallery selection def handle_send_button( gallery: list, prompt: str, idx: int, width: int, height: int, batch_size: int, video_length: int, fps: int, infer_steps: int, seed: int, flow_shift: float, cfg_scale: float, lora1: str, lora2: str, lora3: str, lora4: str, lora1_multiplier: float, lora2_multiplier: float, lora3_multiplier: float, lora4_multiplier: float ) -> tuple: if not gallery or idx is None or idx >= len(gallery): return (None, "", width, height, batch_size, video_length, fps, infer_steps, seed, flow_shift, cfg_scale, lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier, "") # Add empty string for negative_prompt in the return values # Auto-select first item if only one exists and no selection made if idx is None and len(gallery) == 1: idx = 0 selected_item = gallery[idx] # Handle different gallery item formats if isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, (tuple, list)): video_path = selected_item[0] else: video_path = selected_item # Final cleanup for Gradio Video component if isinstance(video_path, tuple): video_path = video_path[0] return ( str(video_path), prompt, width, height, batch_size, video_length, fps, infer_steps, seed, flow_shift, cfg_scale, lora1, lora2, lora3, lora4, lora1_multiplier, lora2_multiplier, lora3_multiplier, lora4_multiplier, "" # Add empty string for negative_prompt ) send_t2v_to_v2v_btn.click( fn=handle_send_button, inputs=[ video_output, prompt, selected_index, t2v_width, t2v_height, batch_size, video_length, fps, infer_steps, seed, flow_shift, cfg_scale ] + lora_weights + lora_multipliers, # Remove the string here outputs=[ v2v_input, v2v_prompt, v2v_width, v2v_height, v2v_batch_size, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_flow_shift, v2v_cfg_scale ] + v2v_lora_weights + v2v_lora_multipliers + [v2v_negative_prompt] ).then( fn=change_to_tab_two, inputs=None, outputs=[tabs] ) def handle_send_to_v2v(metadata: dict, video_path: str) -> Tuple[str, dict, str]: """Handle both parameters and video transfer""" status_msg, params = send_parameters_to_tab(metadata, "v2v") return status_msg, params, video_path def handle_info_to_v2v(metadata: dict, video_path: str) -> Tuple[str, Dict, str]: """Handle both parameters and video transfer from Video Info to V2V tab""" if not video_path: return "No video selected", {}, None status_msg, params = send_parameters_to_tab(metadata, "v2v") # Just return the path directly return status_msg, params, video_path # Send button click handler send_to_v2v_btn.click( fn=handle_info_to_v2v, inputs=[metadata_output, video_input], outputs=[status, params_state, v2v_input] ).then( lambda params: [ params.get("v2v_prompt", ""), params.get("v2v_width", 544), params.get("v2v_height", 544), params.get("v2v_batch_size", 1), params.get("v2v_video_length", 25), params.get("v2v_fps", 24), params.get("v2v_infer_steps", 30), params.get("v2v_seed", -1), params.get("v2v_model", "hunyuan/mp_rank_00_model_states.pt"), params.get("v2v_vae", "hunyuan/pytorch_model.pt"), params.get("v2v_te1", "hunyuan/llava_llama3_fp16.safetensors"), params.get("v2v_te2", "hunyuan/clip_l.safetensors"), params.get("v2v_save_path", "outputs"), params.get("v2v_flow_shift", 11.0), params.get("v2v_cfg_scale", 7.0), params.get("v2v_output_type", "video"), params.get("v2v_attn_mode", "sdpa"), params.get("v2v_block_swap", "0"), *[params.get(f"v2v_lora_weights[{i}]", "") for i in range(4)], *[params.get(f"v2v_lora_multipliers[{i}]", 1.0) for i in range(4)] ] if params else [gr.update()] * 26, inputs=params_state, outputs=[ v2v_prompt, v2v_width, v2v_height, v2v_batch_size, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_model, v2v_vae, v2v_te1, v2v_te2, v2v_save_path, v2v_flow_shift, v2v_cfg_scale, v2v_output_type, v2v_attn_mode, v2v_block_swap ] + v2v_lora_weights + v2v_lora_multipliers ).then( lambda: print(f"Tabs object: {tabs}"), # Debug print outputs=None ).then( fn=change_to_tab_two, inputs=None, outputs=[tabs] ) # Handler for sending selected video from Video2Video gallery to input def handle_v2v_send_button(gallery: list, prompt: str, idx: int) -> Tuple[Optional[str], str]: """Send the currently selected video in V2V gallery to V2V input""" if not gallery or idx is None or idx >= len(gallery): return None, "" selected_item = gallery[idx] video_path = None # Handle different gallery item formats if isinstance(selected_item, tuple): video_path = selected_item[0] # Gallery returns (path, caption) elif isinstance(selected_item, dict): video_path = selected_item.get("name", selected_item.get("data", None)) elif isinstance(selected_item, str): video_path = selected_item if not video_path: return None, "" # Check if the file exists and is accessible if not os.path.exists(video_path): print(f"Warning: Video file not found at {video_path}") return None, "" return video_path, prompt v2v_send_to_input_btn.click( fn=handle_v2v_send_button, inputs=[v2v_output, v2v_prompt, v2v_selected_index], outputs=[v2v_input, v2v_prompt] ).then( lambda: gr.update(visible=True), # Ensure the video input is visible outputs=v2v_input ) # Video to Video generation v2v_generate_btn.click( fn=process_batch, inputs=[ v2v_prompt, v2v_width, v2v_height, v2v_batch_size, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_dit_folder, v2v_model, v2v_vae, v2v_te1, v2v_te2, v2v_save_path, v2v_flow_shift, v2v_cfg_scale, v2v_output_type, v2v_attn_mode, v2v_block_swap, v2v_exclude_single_blocks, v2v_use_split_attn, v2v_lora_folder, *v2v_lora_weights, *v2v_lora_multipliers, v2v_input, v2v_strength, v2v_negative_prompt, v2v_cfg_scale, v2v_split_uncond, v2v_use_fp8 ], outputs=[v2v_output, v2v_batch_progress, v2v_progress_text], queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[v2v_batch_size], outputs=v2v_selected_index ) refresh_outputs = [model] # Add model dropdown to outputs for i in range(4): refresh_outputs.extend([lora_weights[i], lora_multipliers[i]]) refresh_btn.click( fn=update_dit_and_lora_dropdowns, inputs=[dit_folder, lora_folder, model] + lora_weights + lora_multipliers, outputs=refresh_outputs ) # Image2Video refresh i2v_refresh_outputs = [i2v_model] # Add model dropdown to outputs for i in range(4): i2v_refresh_outputs.extend([i2v_lora_weights[i], i2v_lora_multipliers[i]]) i2v_refresh_btn.click( fn=update_dit_and_lora_dropdowns, inputs=[i2v_dit_folder, i2v_lora_folder, i2v_model] + i2v_lora_weights + i2v_lora_multipliers, outputs=i2v_refresh_outputs ) # Video2Video refresh v2v_refresh_outputs = [v2v_model] # Add model dropdown to outputs for i in range(4): v2v_refresh_outputs.extend([v2v_lora_weights[i], v2v_lora_multipliers[i]]) v2v_refresh_btn.click( fn=update_dit_and_lora_dropdowns, inputs=[v2v_dit_folder, v2v_lora_folder, v2v_model] + v2v_lora_weights + v2v_lora_multipliers, outputs=v2v_refresh_outputs ) # WanX-i2v tab connections wanx_prompt.change(fn=count_prompt_tokens, inputs=wanx_prompt, outputs=wanx_token_counter) wanx_stop_btn.click(fn=lambda: stop_event.set(), queue=False) # Image input handling for WanX-i2v wanx_input.change( fn=update_wanx_image_dimensions, inputs=[wanx_input], outputs=[wanx_original_dims, wanx_width, wanx_height] ) # Scale slider handling for WanX-i2v wanx_scale_slider.change( fn=update_wanx_from_scale, inputs=[wanx_scale_slider, wanx_original_dims], outputs=[wanx_width, wanx_height] ) # Width/height calculation buttons for WanX-i2v wanx_calc_width_btn.click( fn=calculate_wanx_width, inputs=[wanx_height, wanx_original_dims], outputs=[wanx_width] ) wanx_calc_height_btn.click( fn=calculate_wanx_height, inputs=[wanx_width, wanx_original_dims], outputs=[wanx_height] ) # Add visibility toggle for the folder input components wanx_use_random_folder.change( fn=lambda x: (gr.update(visible=x), gr.update(visible=x), gr.update(visible=x), gr.update(visible=not x)), inputs=[wanx_use_random_folder], outputs=[wanx_input_folder, wanx_folder_status, wanx_validate_folder_btn, wanx_input] ) def toggle_end_image(use_end_image): return ( gr.update(visible=use_end_image, interactive=use_end_image), # wanx_input_end gr.update(visible=False) # wanx_trim_frames ) wanx_use_end_image.change( fn=toggle_end_image, inputs=[wanx_use_end_image], outputs=[wanx_input_end, wanx_trim_frames] ) # Validate folder button handler wanx_validate_folder_btn.click( fn=lambda folder: get_random_image_from_folder(folder)[1], inputs=[wanx_input_folder], outputs=[wanx_folder_status] ) # Flow shift recommendation buttons wanx_recommend_flow_btn.click( fn=recommend_wanx_flow_shift, inputs=[wanx_width, wanx_height], outputs=[wanx_flow_shift] ) wanx_t2v_recommend_flow_btn.click( fn=recommend_wanx_flow_shift, inputs=[wanx_t2v_width, wanx_t2v_height], outputs=[wanx_t2v_flow_shift] ) # Generate button handler wanx_generate_btn.click( fn=wanx_batch_handler, inputs=[ wanx_use_random_folder, wanx_prompt, wanx_negative_prompt, wanx_width, wanx_height, wanx_video_length, wanx_fps, wanx_infer_steps, wanx_flow_shift, wanx_guidance_scale, wanx_seed, wanx_batch_size, wanx_input_folder, wanx_input_end, # Make sure this is passed wanx_task, wanx_dit_folder, wanx_dit_path, wanx_vae_path, wanx_t5_path, wanx_clip_path, wanx_save_path, wanx_output_type, wanx_sample_solver, wanx_exclude_single_blocks, wanx_attn_mode, wanx_block_swap, wanx_fp8, wanx_fp8_scaled, wanx_fp8_t5, wanx_lora_folder, wanx_slg_layers, wanx_slg_start, wanx_slg_end, wanx_enable_cfg_skip, wanx_cfg_skip_mode, wanx_cfg_apply_ratio, # --- ADDED PREVIEW INPUTS --- wanx_enable_preview, wanx_preview_steps, # --- END ADDED --- *wanx_lora_weights, *wanx_lora_multipliers, wanx_input, # Input image (used as input_file in handler) wanx_control_video, # Control video wanx_control_strength, wanx_control_start, wanx_control_end, ], outputs=[ wanx_output, # Main video gallery wanx_preview_output, # ADDED: Preview gallery wanx_batch_progress, # Status text wanx_progress_text # Progress text ], # Now 4 outputs queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[wanx_batch_size], outputs=wanx_i2v_selected_index ) # Add refresh button handler for WanX-i2v tab wanx_refresh_outputs = [wanx_dit_path] # Add model dropdown to outputs for i in range(4): wanx_refresh_outputs.extend([wanx_lora_weights[i], wanx_lora_multipliers[i]]) wanx_refresh_btn.click( fn=update_dit_and_lora_dropdowns, # This function already exists and handles both updates inputs=[wanx_dit_folder, wanx_lora_folder, wanx_dit_path] + wanx_lora_weights + wanx_lora_multipliers, outputs=wanx_refresh_outputs ) wanx_dit_folder.change( fn=update_dit_dropdown, inputs=[wanx_dit_folder], outputs=[wanx_dit_path] ) wanx_dit_folder.change( fn=update_dit_dropdown, inputs=[wanx_dit_folder], outputs=[wanx_t2v_dit_path] ) wanx_dit_folder.change( fn=update_dit_dropdown, inputs=[wanx_dit_folder], outputs=[wanx_v2v_dit_path] ) # Gallery selection handling wanx_output.select( fn=handle_wanx_gallery_select, inputs=[wanx_output], outputs=[wanx_i2v_selected_index, wanx_base_video] ) # Send to Video2Video handler wanx_send_to_v2v_btn.click( fn=send_wanx_to_v2v, inputs=[ wanx_output, # Gallery with videos wanx_prompt, # Prompt text wanx_i2v_selected_index, # Use the correct selected index state wanx_width, wanx_height, wanx_video_length, wanx_fps, wanx_infer_steps, wanx_seed, wanx_flow_shift, wanx_guidance_scale, wanx_negative_prompt ], outputs=[ v2v_input, # Video input in V2V tab v2v_prompt, # Prompt in V2V tab v2v_width, v2v_height, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_flow_shift, v2v_cfg_scale, v2v_negative_prompt ] ).then( fn=change_to_tab_two, # Function to switch to Video2Video tab inputs=None, outputs=[tabs] ) # Connect prompt token counter wanx_t2v_prompt.change(fn=count_prompt_tokens, inputs=wanx_t2v_prompt, outputs=wanx_t2v_token_counter) # Stop button handler wanx_t2v_stop_btn.click(fn=lambda: stop_event.set(), queue=False) # Flow shift recommendation button wanx_t2v_recommend_flow_btn.click( fn=recommend_wanx_flow_shift, inputs=[wanx_t2v_width, wanx_t2v_height], outputs=[wanx_t2v_flow_shift] ) # Task change handler to update CLIP visibility and path def update_clip_visibility(task): is_i2v = "i2v" in task return gr.update(visible=is_i2v) wanx_t2v_task.change( fn=update_clip_visibility, inputs=[wanx_t2v_task], outputs=[wanx_t2v_clip_path] ) # Generate button handler for T2V wanx_t2v_generate_btn.click( fn=wanx_batch_handler, inputs=[ wanx_t2v_use_random_folder, # use_random wanx_t2v_prompt, # prompt wanx_t2v_negative_prompt, # negative_prompt wanx_t2v_width, # width wanx_t2v_height, # height wanx_t2v_video_length, # video_length wanx_t2v_fps, # fps wanx_t2v_infer_steps, # infer_steps wanx_t2v_flow_shift, # flow_shift wanx_t2v_guidance_scale, # guidance_scale wanx_t2v_seed, # seed wanx_t2v_batch_size, # batch_size wanx_t2v_input_folder, # input_folder_path wanx_t2v_input_end, # wanx_input_end wanx_t2v_task, # task wanx_dit_folder, # dit_folder (shared) wanx_t2v_dit_path, # dit_path wanx_t2v_vae_path, # vae_path wanx_t2v_t5_path, # t5_path wanx_t2v_clip_path, # clip_path (often None for t2v) wanx_t2v_save_path, # save_path wanx_t2v_output_type, # output_type wanx_t2v_sample_solver, # sample_solver wanx_t2v_exclude_single_blocks, # exclude_single_blocks wanx_t2v_attn_mode, # attn_mode wanx_t2v_block_swap, # block_swap wanx_t2v_fp8, # fp8 wanx_t2v_fp8_scaled, # fp8_scaled wanx_t2v_fp8_t5, # fp8_t5 wanx_t2v_lora_folder, # lora_folder wanx_t2v_slg_layers, # slg_layers wanx_t2v_slg_start, # slg_start wanx_t2v_slg_end, # slg_end wanx_t2v_enable_cfg_skip, # enable_cfg_skip wanx_t2v_cfg_skip_mode, # cfg_skip_mode wanx_t2v_cfg_apply_ratio, # cfg_apply_ratio # --- ADDED PREVIEW INPUTS --- wanx_t2v_enable_preview, wanx_t2v_preview_steps, # --- END ADDED --- *wanx_t2v_lora_weights, # *lora_params (weights) *wanx_t2v_lora_multipliers, # *lora_params (multipliers) # --- ADDED Placeholders for trailing args expected by wanx_batch_handler --- gr.File(value=None, visible=False), # Placeholder for input_file (None for T2V) gr.Video(value=None, visible=False), # Placeholder for control_video (None for T2V) gr.Number(value=1.0, visible=False), # Placeholder for control_strength gr.Number(value=0.0, visible=False), # Placeholder for control_start gr.Number(value=1.0, visible=False), # Placeholder for control_end # --- END Placeholders --- ], outputs=[ wanx_t2v_output, # Main video gallery wanx_t2v_preview_output, # ADDED: Preview gallery wanx_t2v_batch_progress, # Status text wanx_t2v_progress_text # Progress text ], # Now 4 outputs queue=True ).then( fn=lambda batch_size: 0 if batch_size == 1 else None, inputs=[wanx_t2v_batch_size], outputs=wanx_t2v_selected_index ) # Add refresh button handler for WanX-t2v tab wanx_t2v_refresh_outputs = [wanx_t2v_dit_path] # This is one output for i in range(4): wanx_t2v_refresh_outputs.extend([wanx_t2v_lora_weights[i], wanx_t2v_lora_multipliers[i]]) # This adds 8 more outputs wanx_t2v_refresh_btn.click( fn=update_dit_and_lora_dropdowns, # Change to this function instead inputs=[wanx_dit_folder, wanx_t2v_lora_folder, wanx_t2v_dit_path] + wanx_t2v_lora_weights + wanx_t2v_lora_multipliers, outputs=wanx_t2v_refresh_outputs ) # Gallery selection handling wanx_t2v_output.select( fn=handle_wanx_t2v_gallery_select, outputs=wanx_t2v_selected_index ) # Send to Video2Video handler wanx_t2v_send_to_v2v_btn.click( fn=send_wanx_t2v_to_v2v, inputs=[ wanx_t2v_output, wanx_t2v_prompt, wanx_t2v_selected_index, wanx_t2v_width, wanx_t2v_height, wanx_t2v_video_length, wanx_t2v_fps, wanx_t2v_infer_steps, wanx_t2v_seed, wanx_t2v_flow_shift, wanx_t2v_guidance_scale, wanx_t2v_negative_prompt ], outputs=[ v2v_input, v2v_prompt, v2v_width, v2v_height, v2v_video_length, v2v_fps, v2v_infer_steps, v2v_seed, v2v_flow_shift, v2v_cfg_scale, v2v_negative_prompt ] ).then( fn=change_to_tab_two, inputs=None, outputs=[tabs] ) if __name__ == "__main__": # Make sure 'outputs' directory exists os.makedirs("outputs", exist_ok=True) # Optional: Clean temp_frames directory on startup #if os.path.exists("temp_frames"): # try: shutil.rmtree("temp_frames") # except OSError as e: print(f"Error removing temp_frames: {e}") os.makedirs("temp_frames", exist_ok=True) demo.queue().launch(share=True, mcp_server=True)