Upload 3 files

README.md

@@ -1,21 +1,13 @@
 ---
-title: SUPIR Image Upscaler
+title: LTX Video Fast
+emoji: 🎥
+colorFrom: yellow
+colorTo: pink
 sdk: gradio
-emoji: 📷
-sdk_version: 4.38.1
+sdk_version: 5.29.1
 app_file: app.py
-license: mit
-colorFrom: blue
-colorTo: pink
-tags:
-  - Upscaling
-  - Restoring
-  - Image-to-Image
-  - Image-2-Image
-  - Img-to-Img
-  - Img-2-Img
-  - language models
-  - LLMs
-short_description: Restore blurred or small images with prompt
-suggested_hardware: zero-a10g
----
+pinned: false
+short_description: ultra-fast video model, LTX 0.9.7 13B distilled
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,864 +1,623 @@
-import os
 import gradio as gr
-import argparse
-import numpy as np
 import torch
-import einops
-import copy
-import math
-import time
-import random
 import spaces
-import re
-import uuid
-
-from gradio_imageslider import ImageSlider
+import numpy as np
+import random
+import os
+import yaml
+from pathlib import Path
+import imageio
+import tempfile
 from PIL import Image
-from SUPIR.util import HWC3, upscale_image, fix_resize, convert_dtype, create_SUPIR_model, load_QF_ckpt
 from huggingface_hub import hf_hub_download
-from pillow_heif import register_heif_opener
-
-register_heif_opener()
-
-max_64_bit_int = np.iinfo(np.int32).max
-
-hf_hub_download(repo_id="laion/CLIP-ViT-bigG-14-laion2B-39B-b160k", filename="open_clip_pytorch_model.bin", local_dir="laion_CLIP-ViT-bigG-14-laion2B-39B-b160k")
-hf_hub_download(repo_id="camenduru/SUPIR", filename="sd_xl_base_1.0_0.9vae.safetensors", local_dir="yushan777_SUPIR")
-hf_hub_download(repo_id="camenduru/SUPIR", filename="SUPIR-v0F.ckpt", local_dir="yushan777_SUPIR")
-hf_hub_download(repo_id="camenduru/SUPIR", filename="SUPIR-v0Q.ckpt", local_dir="yushan777_SUPIR")
-hf_hub_download(repo_id="RunDiffusion/Juggernaut-XL-Lightning", filename="Juggernaut_RunDiffusionPhoto2_Lightning_4Steps.safetensors", local_dir="RunDiffusion_Juggernaut-XL-Lightning")
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--opt", type=str, default='options/SUPIR_v0.yaml')
-parser.add_argument("--ip", type=str, default='127.0.0.1')
-parser.add_argument("--port", type=int, default='6688')
-parser.add_argument("--no_llava", action='store_true', default=True)#False
-parser.add_argument("--use_image_slider", action='store_true', default=False)#False
-parser.add_argument("--log_history", action='store_true', default=False)
-parser.add_argument("--loading_half_params", action='store_true', default=False)#False
-parser.add_argument("--use_tile_vae", action='store_true', default=True)#False
-parser.add_argument("--encoder_tile_size", type=int, default=512)
-parser.add_argument("--decoder_tile_size", type=int, default=64)
-parser.add_argument("--load_8bit_llava", action='store_true', default=False)
-args = parser.parse_args()
-
-if torch.cuda.device_count() > 0:
-    SUPIR_device = 'cuda:0'
-
-    # Load SUPIR
-    model, default_setting = create_SUPIR_model(args.opt, SUPIR_sign='Q', load_default_setting=True)
-    if args.loading_half_params:
-        model = model.half()
-    if args.use_tile_vae:
-        model.init_tile_vae(encoder_tile_size=args.encoder_tile_size, decoder_tile_size=args.decoder_tile_size)
-    model = model.to(SUPIR_device)
-    model.first_stage_model.denoise_encoder_s1 = copy.deepcopy(model.first_stage_model.denoise_encoder)
-    model.current_model = 'v0-Q'
-    ckpt_Q, ckpt_F = load_QF_ckpt(args.opt)
-
-def check_upload(input_image):
-    if input_image is None:
-        raise gr.Error("Please provide an image to restore.")
-    return gr.update(visible = True)
-
-def update_seed(is_randomize_seed, seed):
-    if is_randomize_seed:
-        return random.randint(0, max_64_bit_int)
-    return seed
-
-def reset():
-    return [
-        None,
-        0,
-        None,
-        None,
-        "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-        "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-        1,
-        1024,
-        1,
-        2,
-        50,
-        -1.0,
-        1.,
-        default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0,
-        True,
-        random.randint(0, max_64_bit_int),
-        5,
-        1.003,
-        "Wavelet",
-        "fp32",
-        "fp32",
-        1.0,
-        True,
-        False,
-        default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0,
-        0.,
-        "v0-Q",
-        "input",
-        179
-    ]
-
-def check_and_update(input_image):
-    if input_image is None:
-        raise gr.Error("Please provide an image to restore.")
-    return gr.update(visible = True)
-
-@spaces.GPU(duration=420)
-def stage1_process(
-    input_image,
-    gamma_correction,
-    diff_dtype,
-    ae_dtype
-):
-    print('stage1_process ==>>')
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return None, None
-    torch.cuda.set_device(SUPIR_device)
-    LQ = HWC3(np.array(Image.open(input_image)))
-    LQ = fix_resize(LQ, 512)
-    # stage1
-    LQ = np.array(LQ) / 255 * 2 - 1
-    LQ = torch.tensor(LQ, dtype=torch.float32).permute(2, 0, 1).unsqueeze(0).to(SUPIR_device)[:, :3, :, :]
-
-    model.ae_dtype = convert_dtype(ae_dtype)
-    model.model.dtype = convert_dtype(diff_dtype)
-
-    LQ = model.batchify_denoise(LQ, is_stage1=True)
-    LQ = (LQ[0].permute(1, 2, 0) * 127.5 + 127.5).cpu().numpy().round().clip(0, 255).astype(np.uint8)
-    # gamma correction
-    LQ = LQ / 255.0
-    LQ = np.power(LQ, gamma_correction)
-    LQ *= 255.0
-    LQ = LQ.round().clip(0, 255).astype(np.uint8)
-    print('<<== stage1_process')
-    return LQ, gr.update(visible = True)
-
-def stage2_process(*args, **kwargs):
-    try:
-        return restore_in_Xmin(*args, **kwargs)
-    except Exception as e:
-        # NO_GPU_MESSAGE_INQUEUE
-        print("gradio.exceptions.Error 'No GPU is currently available for you after 60s'")
-        print('str(type(e)): ' + str(type(e))) # <class 'gradio.exceptions.Error'>
-        print('str(e): ' + str(e)) # You have exceeded your GPU quota...
-        try:
-            print('e.message: ' + e.message) # No GPU is currently available for you after 60s
-        except Exception as e2:
-            print('Failure')
-        if str(e).startswith("No GPU is currently available for you after 60s"):
-            print('Exception identified!!!')
-        #if str(type(e)) == "<class 'gradio.exceptions.Error'>":
-            #print('Exception of name ' + type(e).__name__)
-        raise e
-
-def restore_in_Xmin(
-    noisy_image,
-    rotation,
-    denoise_image,
-    prompt,
-    a_prompt,
-    n_prompt,
-    num_samples,
-    min_size,
-    downscale,
-    upscale,
-    edm_steps,
-    s_stage1,
-    s_stage2,
-    s_cfg,
-    randomize_seed,
-    seed,
-    s_churn,
-    s_noise,
-    color_fix_type,
-    diff_dtype,
-    ae_dtype,
-    gamma_correction,
-    linear_CFG,
-    linear_s_stage2,
-    spt_linear_CFG,
-    spt_linear_s_stage2,
-    model_select,
-    output_format,
-    allocation
-):
-    print("noisy_image:\n" + str(noisy_image))
-    print("denoise_image:\n" + str(denoise_image))
-    print("rotation: " + str(rotation))
-    print("prompt: " + str(prompt))
-    print("a_prompt: " + str(a_prompt))
-    print("n_prompt: " + str(n_prompt))
-    print("num_samples: " + str(num_samples))
-    print("min_size: " + str(min_size))
-    print("downscale: " + str(downscale))
-    print("upscale: " + str(upscale))
-    print("edm_steps: " + str(edm_steps))
-    print("s_stage1: " + str(s_stage1))
-    print("s_stage2: " + str(s_stage2))
-    print("s_cfg: " + str(s_cfg))
-    print("randomize_seed: " + str(randomize_seed))
-    print("seed: " + str(seed))
-    print("s_churn: " + str(s_churn))
-    print("s_noise: " + str(s_noise))
-    print("color_fix_type: " + str(color_fix_type))
-    print("diff_dtype: " + str(diff_dtype))
-    print("ae_dtype: " + str(ae_dtype))
-    print("gamma_correction: " + str(gamma_correction))
-    print("linear_CFG: " + str(linear_CFG))
-    print("linear_s_stage2: " + str(linear_s_stage2))
-    print("spt_linear_CFG: " + str(spt_linear_CFG))
-    print("spt_linear_s_stage2: " + str(spt_linear_s_stage2))
-    print("model_select: " + str(model_select))
-    print("GPU time allocation: " + str(allocation) + " min")
-    print("output_format: " + str(output_format))
-
-    input_format = re.sub(r"^.*\.([^\.]+)$", r"\1", noisy_image)
-
-    if input_format not in ['png', 'webp', 'jpg', 'jpeg', 'gif', 'bmp', 'heic']:
-        gr.Warning('Invalid image format. Please first convert into *.png, *.webp, *.jpg, *.jpeg, *.gif, *.bmp or *.heic.')
-        return None, None, None, None
-
-    if output_format == "input":
-        if noisy_image is None:
-            output_format = "png"
-        else:
-            output_format = input_format
-    print("final output_format: " + str(output_format))
-
-    if prompt is None:
-        prompt = ""
-
-    if a_prompt is None:
-        a_prompt = ""
-
-    if n_prompt is None:
-        n_prompt = ""
-
-    if prompt != "" and a_prompt != "":
-        a_prompt = prompt + ", " + a_prompt
-    else:
-        a_prompt = prompt + a_prompt
-    print("Final prompt: " + str(a_prompt))
-
-    denoise_image = np.array(Image.open(noisy_image if denoise_image is None else denoise_image))
-
-    if rotation == 90:
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-    elif rotation == 180:
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-        denoise_image = np.array(list(zip(*denoise_image[::-1])))
-    elif rotation == -90:
-        denoise_image = np.array(list(zip(*denoise_image))[::-1])
-
-    if 1 < downscale:
-        input_height, input_width, input_channel = denoise_image.shape
-        denoise_image = np.array(Image.fromarray(denoise_image).resize((input_width // downscale, input_height // downscale), Image.LANCZOS))
-
-    denoise_image = HWC3(denoise_image)
-
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return [noisy_image, denoise_image], gr.update(label="Downloadable results in *." + output_format + " format", format = output_format, value = [denoise_image]), None, gr.update(visible=True)
-
-    if model_select != model.current_model:
-        print('load ' + model_select)
-        if model_select == 'v0-Q':
-            model.load_state_dict(ckpt_Q, strict=False)
-        elif model_select == 'v0-F':
-            model.load_state_dict(ckpt_F, strict=False)
-        model.current_model = model_select
-
-    model.ae_dtype = convert_dtype(ae_dtype)
-    model.model.dtype = convert_dtype(diff_dtype)
-
-    return restore_on_gpu(
-        noisy_image, denoise_image, prompt, a_prompt, n_prompt, num_samples, min_size, downscale, upscale, edm_steps, s_stage1, s_stage2, s_cfg, randomize_seed, seed, s_churn, s_noise, color_fix_type, diff_dtype, ae_dtype, gamma_correction, linear_CFG, linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select, output_format, allocation
+import shutil
+
+from inference import (
+    create_ltx_video_pipeline,
+    create_latent_upsampler,
+    load_image_to_tensor_with_resize_and_crop,
+    seed_everething,
+    get_device,
+    calculate_padding,
+    load_media_file
+)
+from ltx_video.pipelines.pipeline_ltx_video import ConditioningItem, LTXMultiScalePipeline, LTXVideoPipeline
+from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
+
+image_i2v_debug_value = None
+i2v_prompt_debug_value = None
+height_input_debug_value = None
+width_input_debug_value = None
+duration_input_debug_value = None
+config_file_path = "configs/ltxv-13b-0.9.7-distilled.yaml"
+with open(config_file_path, "r") as file:
+    PIPELINE_CONFIG_YAML = yaml.safe_load(file)
+
+LTX_REPO = "Lightricks/LTX-Video"
+MAX_IMAGE_SIZE = PIPELINE_CONFIG_YAML.get("max_resolution", 1280)
+MAX_NUM_FRAMES = 257
+
+FPS = 30.0 
+
+# --- Global variables for loaded models ---
+pipeline_instance = None
+latent_upsampler_instance = None
+models_dir = "downloaded_models_gradio_cpu_init"
+Path(models_dir).mkdir(parents=True, exist_ok=True)
+
+print("Downloading models (if not present)...")
+distilled_model_actual_path = hf_hub_download(
+    repo_id=LTX_REPO,
+    filename=PIPELINE_CONFIG_YAML["checkpoint_path"],
+    local_dir=models_dir,
+    local_dir_use_symlinks=False
+)
+PIPELINE_CONFIG_YAML["checkpoint_path"] = distilled_model_actual_path
+print(f"Distilled model path: {distilled_model_actual_path}")
+
+SPATIAL_UPSCALER_FILENAME = PIPELINE_CONFIG_YAML["spatial_upscaler_model_path"]
+spatial_upscaler_actual_path = hf_hub_download(
+    repo_id=LTX_REPO,
+    filename=SPATIAL_UPSCALER_FILENAME,
+    local_dir=models_dir,
+    local_dir_use_symlinks=False
+)
+PIPELINE_CONFIG_YAML["spatial_upscaler_model_path"] = spatial_upscaler_actual_path
+print(f"Spatial upscaler model path: {spatial_upscaler_actual_path}")
+
+print("Creating LTX Video pipeline on CPU...")
+pipeline_instance = create_ltx_video_pipeline(
+    ckpt_path=PIPELINE_CONFIG_YAML["checkpoint_path"],
+    precision=PIPELINE_CONFIG_YAML["precision"],
+    text_encoder_model_name_or_path=PIPELINE_CONFIG_YAML["text_encoder_model_name_or_path"],
+    sampler=PIPELINE_CONFIG_YAML["sampler"],
+    device="cpu",
+    enhance_prompt=False,
+    prompt_enhancer_image_caption_model_name_or_path=PIPELINE_CONFIG_YAML["prompt_enhancer_image_caption_model_name_or_path"],
+    prompt_enhancer_llm_model_name_or_path=PIPELINE_CONFIG_YAML["prompt_enhancer_llm_model_name_or_path"],
+)
+print("LTX Video pipeline created on CPU.")
+
+if PIPELINE_CONFIG_YAML.get("spatial_upscaler_model_path"):
+    print("Creating latent upsampler on CPU...")
+    latent_upsampler_instance = create_latent_upsampler(
+        PIPELINE_CONFIG_YAML["spatial_upscaler_model_path"],
+        device="cpu"
     )
+    print("Latent upsampler created on CPU.")
+
+target_inference_device = "cuda"
+print(f"Target inference device: {target_inference_device}")
+pipeline_instance.to(target_inference_device)
+if latent_upsampler_instance: 
+    latent_upsampler_instance.to(target_inference_device)
 
-def get_duration(
-    noisy_image,
-    input_image,
-    prompt,
-    a_prompt,
-    n_prompt,
-    num_samples,
-    min_size,
-    downscale,
-    upscale,
-    edm_steps,
-    s_stage1,
-    s_stage2,
-    s_cfg,
-    randomize_seed,
-    seed,
-    s_churn,
-    s_noise,
-    color_fix_type,
-    diff_dtype,
-    ae_dtype,
-    gamma_correction,
-    linear_CFG,
-    linear_s_stage2,
-    spt_linear_CFG,
-    spt_linear_s_stage2,
-    model_select,
-    output_format,
-    allocation
-):
-    return allocation
+
+# --- Helper function for dimension calculation ---
+MIN_DIM_SLIDER = 256  # As defined in the sliders minimum attribute
+TARGET_FIXED_SIDE = 768 # Desired fixed side length as per requirement
+
+def calculate_new_dimensions(orig_w, orig_h):
+    """
+    Calculates new dimensions for height and width sliders based on original media dimensions.
+    Ensures one side is TARGET_FIXED_SIDE, the other is scaled proportionally,
+    both are multiples of 32, and within [MIN_DIM_SLIDER, MAX_IMAGE_SIZE].
+    """
+    if orig_w == 0 or orig_h == 0:
+        # Default to TARGET_FIXED_SIDE square if original dimensions are invalid
+        return int(TARGET_FIXED_SIDE), int(TARGET_FIXED_SIDE)
+
+    if orig_w >= orig_h:  # Landscape or square
+        new_h = TARGET_FIXED_SIDE
+        aspect_ratio = orig_w / orig_h
+        new_w_ideal = new_h * aspect_ratio
+        
+        # Round to nearest multiple of 32
+        new_w = round(new_w_ideal / 32) * 32
+        
+        # Clamp to [MIN_DIM_SLIDER, MAX_IMAGE_SIZE]
+        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
+        # Ensure new_h is also clamped (TARGET_FIXED_SIDE should be within these bounds if configured correctly)
+        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE)) 
+    else:  # Portrait
+        new_w = TARGET_FIXED_SIDE
+        aspect_ratio = orig_h / orig_w # Use H/W ratio for portrait scaling
+        new_h_ideal = new_w * aspect_ratio
+        
+        # Round to nearest multiple of 32
+        new_h = round(new_h_ideal / 32) * 32
+        
+        # Clamp to [MIN_DIM_SLIDER, MAX_IMAGE_SIZE]
+        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE))
+        # Ensure new_w is also clamped
+        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
+
+    return int(new_h), int(new_w)
+
+def get_duration(prompt, negative_prompt, input_image_filepath, input_video_filepath,
+             height_ui, width_ui, mode,
+             duration_ui, # Removed ui_steps
+             ui_frames_to_use,
+             seed_ui, randomize_seed, ui_guidance_scale, improve_texture_flag,
+             progress):
+    if duration_ui > 7:
+        return 75
+    else:
+        return 60
 
 @spaces.GPU(duration=get_duration)
-def restore_on_gpu(
-    noisy_image,
-    input_image,
-    prompt,
-    a_prompt,
-    n_prompt,
-    num_samples,
-    min_size,
-    downscale,
-    upscale,
-    edm_steps,
-    s_stage1,
-    s_stage2,
-    s_cfg,
-    randomize_seed,
-    seed,
-    s_churn,
-    s_noise,
-    color_fix_type,
-    diff_dtype,
-    ae_dtype,
-    gamma_correction,
-    linear_CFG,
-    linear_s_stage2,
-    spt_linear_CFG,
-    spt_linear_s_stage2,
-    model_select,
-    output_format,
-    allocation
-):
-    start = time.time()
-    print('restore ==>>')
-
-    torch.cuda.set_device(SUPIR_device)
-
-    with torch.no_grad():
-        input_image = upscale_image(input_image, upscale, unit_resolution=32, min_size=min_size)
-        LQ = np.array(input_image) / 255.0
-        LQ = np.power(LQ, gamma_correction)
-        LQ *= 255.0
-        LQ = LQ.round().clip(0, 255).astype(np.uint8)
-        LQ = LQ / 255 * 2 - 1
-        LQ = torch.tensor(LQ, dtype=torch.float32).permute(2, 0, 1).unsqueeze(0).to(SUPIR_device)[:, :3, :, :]
-        captions = ['']
-
-        samples = model.batchify_sample(LQ, captions, num_steps=edm_steps, restoration_scale=s_stage1, s_churn=s_churn,
-                                    s_noise=s_noise, cfg_scale=s_cfg, control_scale=s_stage2, seed=seed,
-                                    num_samples=num_samples, p_p=a_prompt, n_p=n_prompt, color_fix_type=color_fix_type,
-                                    use_linear_CFG=linear_CFG, use_linear_control_scale=linear_s_stage2,
-                                    cfg_scale_start=spt_linear_CFG, control_scale_start=spt_linear_s_stage2)
-
-        x_samples = (einops.rearrange(samples, 'b c h w -> b h w c') * 127.5 + 127.5).cpu().numpy().round().clip(
-            0, 255).astype(np.uint8)
-        results = [x_samples[i] for i in range(num_samples)]
-    torch.cuda.empty_cache()
-
-    # All the results have the same size
-    input_height, input_width, input_channel = np.array(input_image).shape
-    result_height, result_width, result_channel = np.array(results[0]).shape
-
-    print('<<== restore')
-    end = time.time()
-    secondes = int(end - start)
-    minutes = math.floor(secondes / 60)
-    secondes = secondes - (minutes * 60)
-    hours = math.floor(minutes / 60)
-    minutes = minutes - (hours * 60)
-    information = ("Start the process again if you want a different result. " if randomize_seed else "") + \
-    "If you don't get the image you wanted, add more details in the « Image description ». " + \
-    "Wait " + str(allocation) + " min before a new run to avoid quota penalty or use another computer. " + \
-    "The image" + (" has" if len(results) == 1 else "s have") + " been generated in " + \
-    ((str(hours) + " h, ") if hours != 0 else "") + \
-    ((str(minutes) + " min, ") if hours != 0 or minutes != 0 else "") + \
-    str(secondes) + " sec. " + \
-    "The new image resolution is " + str(result_width) + \
-    " pixels large and " + str(result_height) + \
-    " pixels high, so a resolution of " + f'{result_width * result_height:,}' + " pixels."
-    print(information)
-    try:
-        print("Initial resolution: " + f'{input_width * input_height:,}')
-        print("Final resolution: " + f'{result_width * result_height:,}')
-        print("edm_steps: " + str(edm_steps))
-        print("num_samples: " + str(num_samples))
-        print("downscale: " + str(downscale))
-        print("Estimated minutes: " + f'{(((result_width * result_height**(1/1.75)) * input_width * input_height * (edm_steps**(1/2)) * (num_samples**(1/2.5)))**(1/2.5)) / 25000:,}')
-    except Exception as e:
-        print('Exception of Estimation')
-
-    # Only one image can be shown in the slider
-    return [noisy_image] + [results[0]], gr.update(label="Downloadable results in *." + output_format + " format", format = output_format, value = results), gr.update(value = information, visible = True), gr.update(visible=True)
-
-def load_and_reset(param_setting):
-    print('load_and_reset ==>>')
-    if torch.cuda.device_count() == 0:
-        gr.Warning('Set this space to GPU config to make it work.')
-        return None, None, None, None, None, None, None, None, None, None, None, None, None, None
-    edm_steps = default_setting.edm_steps
-    s_stage2 = 1.0
-    s_stage1 = -1.0
-    s_churn = 5
-    s_noise = 1.003
-    a_prompt = 'Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - ' \
-               'realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore ' \
-               'detailing, hyper sharpness, perfect without deformations.'
-    n_prompt = 'painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, ' \
-               '3D render, unreal engine, blurring, dirty, messy, worst quality, low quality, frames, watermark, ' \
-               'signature, jpeg artifacts, deformed, lowres, over-smooth'
-    color_fix_type = 'Wavelet'
-    spt_linear_s_stage2 = 0.0
-    linear_s_stage2 = False
-    linear_CFG = True
-    if param_setting == "Quality":
-        s_cfg = default_setting.s_cfg_Quality
-        spt_linear_CFG = default_setting.spt_linear_CFG_Quality
-        model_select = "v0-Q"
-    elif param_setting == "Fidelity":
-        s_cfg = default_setting.s_cfg_Fidelity
-        spt_linear_CFG = default_setting.spt_linear_CFG_Fidelity
-        model_select = "v0-F"
+def generate(prompt, negative_prompt, input_image_filepath, input_video_filepath,
+             height_ui, width_ui, mode,
+             duration_ui, 
+             ui_frames_to_use,
+             seed_ui, randomize_seed, ui_guidance_scale, improve_texture_flag,
+             progress=gr.Progress(track_tqdm=True)):
+
+    if i2v_prompt_debug_value is not None:
+        prompt = i2v_prompt_debug_value
+        global i2v_prompt_debug_value
+        i2v_prompt_debug_value = None
+
+    if image_i2v_debug_value is not None:
+        input_image_filepath = image_i2v_debug_value
+        global image_i2v_debug_value
+        image_i2v_debug_value = None
+
+    if height_input_debug_value is not None:
+        height_ui = height_input_debug_value
+        global height_input_debug_value
+        height_input_debug_value = None
+
+    if width_input_debug_value is not None:
+        width_ui = width_input_debug_value
+        global width_input_debug_value
+        width_input_debug_value = None
+
+    if duration_input_debug_value is not None:
+        duration_ui = duration_input_debug_value
+        global duration_input_debug_value
+        duration_input_debug_value = None
+
+    if randomize_seed:
+        seed_ui = random.randint(0, 2**32 - 1)
+    seed_everething(int(seed_ui))
+    
+    target_frames_ideal = duration_ui * FPS
+    target_frames_rounded = round(target_frames_ideal)
+    if target_frames_rounded < 1: 
+        target_frames_rounded = 1
+    
+    n_val = round((float(target_frames_rounded) - 1.0) / 8.0)
+    actual_num_frames = int(n_val * 8 + 1)
+
+    actual_num_frames = max(9, actual_num_frames)
+    actual_num_frames = min(MAX_NUM_FRAMES, actual_num_frames)
+    
+    actual_height = int(height_ui)
+    actual_width = int(width_ui)
+
+    height_padded = ((actual_height - 1) // 32 + 1) * 32
+    width_padded = ((actual_width - 1) // 32 + 1) * 32
+    num_frames_padded = ((actual_num_frames - 2) // 8 + 1) * 8 + 1 
+    if num_frames_padded != actual_num_frames:
+        print(f"Warning: actual_num_frames ({actual_num_frames}) and num_frames_padded ({num_frames_padded}) differ. Using num_frames_padded for pipeline.")
+    
+    padding_values = calculate_padding(actual_height, actual_width, height_padded, width_padded)
+
+    call_kwargs = {
+        "prompt": prompt,
+        "negative_prompt": negative_prompt,
+        "height": height_padded,
+        "width": width_padded,
+        "num_frames": num_frames_padded, 
+        "frame_rate": int(FPS), 
+        "generator": torch.Generator(device=target_inference_device).manual_seed(int(seed_ui)),
+        "output_type": "pt", 
+        "conditioning_items": None,
+        "media_items": None,
+        "decode_timestep": PIPELINE_CONFIG_YAML["decode_timestep"],
+        "decode_noise_scale": PIPELINE_CONFIG_YAML["decode_noise_scale"],
+        "stochastic_sampling": PIPELINE_CONFIG_YAML["stochastic_sampling"],
+        "image_cond_noise_scale": 0.15,
+        "is_video": True,
+        "vae_per_channel_normalize": True,
+        "mixed_precision": (PIPELINE_CONFIG_YAML["precision"] == "mixed_precision"),
+        "offload_to_cpu": False,
+        "enhance_prompt": False,
+    }
+
+    stg_mode_str = PIPELINE_CONFIG_YAML.get("stg_mode", "attention_values")
+    if stg_mode_str.lower() in ["stg_av", "attention_values"]:
+        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.AttentionValues
+    elif stg_mode_str.lower() in ["stg_as", "attention_skip"]:
+        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.AttentionSkip
+    elif stg_mode_str.lower() in ["stg_r", "residual"]:
+        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.Residual
+    elif stg_mode_str.lower() in ["stg_t", "transformer_block"]:
+        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.TransformerBlock
     else:
-        raise NotImplementedError
-    gr.Info('The parameters are reset.')
-    print('<<== load_and_reset')
-    return edm_steps, s_cfg, s_stage2, s_stage1, s_churn, s_noise, a_prompt, n_prompt, color_fix_type, linear_CFG, \
-        linear_s_stage2, spt_linear_CFG, spt_linear_s_stage2, model_select
-
-def log_information(result_gallery):
-    print('log_information')
-    if result_gallery is not None:
-        for i, result in enumerate(result_gallery):
-            print(result[0])
-
-def on_select_result(result_slider, result_gallery, evt: gr.SelectData):
-    print('on_select_result')
-    if result_gallery is not None:
-        for i, result in enumerate(result_gallery):
-            print(result[0])
-    return [result_slider[0], result_gallery[evt.index][0]]
-
-title_html = """
-    <h1><center>SUPIR</center></h1>
-    <big><center>Upscale your images up to x10 freely, without account, without watermark and download it</center></big>
-    <center><big><big>🤸<big><big><big><big><big><big>🤸</big></big></big></big></big></big></big></big></center>
+        raise ValueError(f"Invalid stg_mode: {stg_mode_str}")
+
+    if mode == "image-to-video" and input_image_filepath:
+        try:
+            media_tensor = load_image_to_tensor_with_resize_and_crop(
+                input_image_filepath, actual_height, actual_width
+            )
+            media_tensor = torch.nn.functional.pad(media_tensor, padding_values)
+            call_kwargs["conditioning_items"] = [ConditioningItem(media_tensor.to(target_inference_device), 0, 1.0)]
+        except Exception as e:
+            print(f"Error loading image {input_image_filepath}: {e}")
+            raise gr.Error(f"Could not load image: {e}")
+    elif mode == "video-to-video" and input_video_filepath:
+        try:
+            call_kwargs["media_items"] = load_media_file(
+                media_path=input_video_filepath,
+                height=actual_height, 
+                width=actual_width,
+                max_frames=int(ui_frames_to_use), 
+                padding=padding_values
+            ).to(target_inference_device)
+        except Exception as e:
+            print(f"Error loading video {input_video_filepath}: {e}")
+            raise gr.Error(f"Could not load video: {e}")
+
+    print(f"Moving models to {target_inference_device} for inference (if not already there)...")
     
-    <p>This is an online demo of SUPIR, a practicing model scaling for photo-realistic image restoration.
-    The content added by SUPIR is <b><u>imagination, not real-world information</u></b>.
-    SUPIR is for beauty and illustration only.
-    Most of the processes last few minutes.
-    If you want to upscale AI-generated images, be noticed that <i>PixArt Sigma</i> space can directly generate 5984x5984 images.
-    Due to Gradio issues, the generated image is slightly less satured than the original.
-    Please leave a <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">message in discussion</a> if you encounter issues.
-    You can also use <a href="https://huggingface.co/spaces/gokaygokay/AuraSR">AuraSR</a> to upscale x4.
+    active_latent_upsampler = None
+    if improve_texture_flag and latent_upsampler_instance:
+        active_latent_upsampler = latent_upsampler_instance
+
+    result_images_tensor = None
+    if improve_texture_flag:
+        if not active_latent_upsampler:
+            raise gr.Error("Spatial upscaler model not loaded or improve_texture not selected, cannot use multi-scale.")
+        
+        multi_scale_pipeline_obj = LTXMultiScalePipeline(pipeline_instance, active_latent_upsampler)
+        
+        first_pass_args = PIPELINE_CONFIG_YAML.get("first_pass", {}).copy()
+        first_pass_args["guidance_scale"] = float(ui_guidance_scale) # UI overrides YAML
+        # num_inference_steps will be derived from len(timesteps) in the pipeline
+        first_pass_args.pop("num_inference_steps", None)
+
+
+        second_pass_args = PIPELINE_CONFIG_YAML.get("second_pass", {}).copy()
+        second_pass_args["guidance_scale"] = float(ui_guidance_scale) # UI overrides YAML
+        # num_inference_steps will be derived from len(timesteps) in the pipeline
+        second_pass_args.pop("num_inference_steps", None)
+        
+        multi_scale_call_kwargs = call_kwargs.copy()
+        multi_scale_call_kwargs.update({
+            "downscale_factor": PIPELINE_CONFIG_YAML["downscale_factor"],
+            "first_pass": first_pass_args,
+            "second_pass": second_pass_args,
+        })
+        
+        print(f"Calling multi-scale pipeline (eff. HxW: {actual_height}x{actual_width}, Frames: {actual_num_frames} -> Padded: {num_frames_padded}) on {target_inference_device}")
+        result_images_tensor = multi_scale_pipeline_obj(**multi_scale_call_kwargs).images
+    else:
+        single_pass_call_kwargs = call_kwargs.copy()
+        first_pass_config_from_yaml = PIPELINE_CONFIG_YAML.get("first_pass", {})
+
+        single_pass_call_kwargs["timesteps"] = first_pass_config_from_yaml.get("timesteps")
+        single_pass_call_kwargs["guidance_scale"] = float(ui_guidance_scale) # UI overrides YAML
+        single_pass_call_kwargs["stg_scale"] = first_pass_config_from_yaml.get("stg_scale")
+        single_pass_call_kwargs["rescaling_scale"] = first_pass_config_from_yaml.get("rescaling_scale")
+        single_pass_call_kwargs["skip_block_list"] = first_pass_config_from_yaml.get("skip_block_list")
+        
+        # Remove keys that might conflict or are not used in single pass / handled by above
+        single_pass_call_kwargs.pop("num_inference_steps", None) 
+        single_pass_call_kwargs.pop("first_pass", None) 
+        single_pass_call_kwargs.pop("second_pass", None)
+        single_pass_call_kwargs.pop("downscale_factor", None)
+        
+        print(f"Calling base pipeline (padded HxW: {height_padded}x{width_padded}, Frames: {actual_num_frames} -> Padded: {num_frames_padded}) on {target_inference_device}")
+        result_images_tensor = pipeline_instance(**single_pass_call_kwargs).images
+
+    if result_images_tensor is None:
+        raise gr.Error("Generation failed.")
+
+    pad_left, pad_right, pad_top, pad_bottom = padding_values
+    slice_h_end = -pad_bottom if pad_bottom > 0 else None
+    slice_w_end = -pad_right if pad_right > 0 else None
     
-    <p><center><a href="https://arxiv.org/abs/2401.13627">Paper</a> &emsp; <a href="http://supir.xpixel.group/">Project Page</a> &emsp; <a href="https://huggingface.co/blog/MonsterMMORPG/supir-sota-image-upscale-better-than-magnific-ai">Local Install Guide</a></center></p>
-    <p><center><a style="display:inline-block" href='https://github.com/Fanghua-Yu/SUPIR'><img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/Fanghua-Yu/SUPIR?style=social"></a></center></p>
-    """
+    result_images_tensor = result_images_tensor[
+        :, :, :actual_num_frames, pad_top:slice_h_end, pad_left:slice_w_end
+    ]
 
+    video_np = result_images_tensor[0].permute(1, 2, 3, 0).cpu().float().numpy()
+    
+    video_np = np.clip(video_np, 0, 1) 
+    video_np = (video_np * 255).astype(np.uint8)
 
-claim_md = """
-## **Piracy**
-The images are not stored but the logs are saved during a month.
-## **How to get SUPIR**
-You can get SUPIR on HuggingFace by [duplicating this space](https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true) and set GPU.
-You can also install SUPIR on your computer following [this tutorial](https://huggingface.co/blog/MonsterMMORPG/supir-sota-image-upscale-better-than-magnific-ai).
-You can install _Pinokio_ on your computer and then install _SUPIR_ into it. It should be quite easy if you have an Nvidia GPU.
-## **Terms of use**
-By using this service, users are required to agree to the following terms: The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research. Please submit a feedback to us if you get any inappropriate answer! We will collect those to keep improving our models. For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality.
-## **License**
-The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/Fanghua-Yu/SUPIR) of SUPIR.
+    temp_dir = tempfile.mkdtemp()
+    timestamp = random.randint(10000,99999)
+    output_video_path = os.path.join(temp_dir, f"output_{timestamp}.mp4")
+    
+    try:
+        with imageio.get_writer(output_video_path, fps=call_kwargs["frame_rate"], macro_block_size=1) as video_writer:
+            for frame_idx in range(video_np.shape[0]):
+                progress(frame_idx / video_np.shape[0], desc="Saving video")
+                video_writer.append_data(video_np[frame_idx])
+    except Exception as e:
+        print(f"Error saving video with macro_block_size=1: {e}")
+        try:
+            with imageio.get_writer(output_video_path, fps=call_kwargs["frame_rate"], format='FFMPEG', codec='libx264', quality=8) as video_writer:
+                 for frame_idx in range(video_np.shape[0]):
+                    progress(frame_idx / video_np.shape[0], desc="Saving video (fallback ffmpeg)")
+                    video_writer.append_data(video_np[frame_idx])
+        except Exception as e2:
+            print(f"Fallback video saving error: {e2}")
+            raise gr.Error(f"Failed to save video: {e2}")
+            
+    return output_video_path, seed_ui
+
+def update_task_image():
+    return "image-to-video"
+
+def update_task_text():
+    return "text-to-video"
+
+def update_task_video():
+    return "video-to-video"
+
+# --- Gradio UI Definition ---
+css="""
+#col-container {
+    margin: 0 auto;
+    max-width: 900px;
+}
 """
 
-# Gradio interface
-with gr.Blocks() as interface:
-    if torch.cuda.device_count() == 0:
-        with gr.Row():
-            gr.HTML("""
-    <p style="background-color: red;"><big><big><big><b>⚠️To use SUPIR, <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR?duplicate=true">duplicate this space</a> and set a GPU with 30 GB VRAM.</b>
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("# LTX Video 0.9.7 Distilled")
+    gr.Markdown("Fast high quality video generation. [Model](https://huggingface.co/Lightricks/LTX-Video/blob/main/ltxv-13b-0.9.7-distilled.safetensors) [GitHub](https://github.com/Lightricks/LTX-Video) [Diffusers](#)")
     
-    You can't use SUPIR directly here because this space runs on a CPU, which is not enough for SUPIR. Please provide <a href="https://huggingface.co/spaces/Fabrice-TIERCELIN/SUPIR/discussions/new">feedback</a> if you have issues.
-    </big></big></big></p>
-    """)
-    gr.HTML(title_html)
-
-    input_image = gr.Image(label="Input (*.png, *.webp, *.jpeg, *.jpg, *.gif, *.bmp, *.heic)", show_label=True, type="filepath", height=600, elem_id="image-input")
-    rotation = gr.Radio([["No rotation", 0], ["⤵ Rotate +90°", 90], ["↩ Return 180°", 180], ["⤴ Rotate -90°", -90]], label="Orientation correction", info="Will apply the following rotation before restoring the image; the AI needs a good orientation to understand the content", value=0, interactive=True, visible=False)
-    with gr.Group():
-        prompt = gr.Textbox(label="Image description", info="Help the AI understand what the image represents; describe as much as possible, especially the details we can't see on the original image; you can write in any language", value="", placeholder="A 33 years old man, walking, in the street, Santiago, morning, Summer, photorealistic", lines=3)
-        prompt_hint = gr.HTML("You can use a <a href='"'https://huggingface.co/spaces/badayvedat/LLaVA'"'>LlaVa space</a> to auto-generate the description of your image.")
-        upscale = gr.Radio([["x1", 1], ["x2", 2], ["x3", 3], ["x4", 4], ["x5", 5], ["x6", 6], ["x7", 7], ["x8", 8], ["x9", 9], ["x10", 10]], label="Upscale factor", info="Resolution x1 to x10", value=2, interactive=True)
-        output_format = gr.Radio([["As input", "input"], ["*.png", "png"], ["*.webp", "webp"], ["*.jpeg", "jpeg"], ["*.gif", "gif"], ["*.bmp", "bmp"]], label="Image format for result", info="File extention", value="input", interactive=True)
-        allocation = gr.Slider(label="GPU allocation time (in seconds)", info="lower=May abort run, higher=Quota penalty for next runs", value=179, minimum=59, maximum=320, step=1)
-
-    with gr.Accordion("Pre-denoising (optional)", open=False):
-        gamma_correction = gr.Slider(label="Gamma Correction", info = "lower=lighter, higher=darker", minimum=0.1, maximum=2.0, value=1.0, step=0.1)
-        denoise_button = gr.Button(value="Pre-denoise")
-        denoise_image = gr.Image(label="Denoised image", show_label=True, type="filepath", sources=[], interactive = False, height=600, elem_id="image-s1")
-        denoise_information = gr.HTML(value="If present, the denoised image will be used for the restoration instead of the input image.", visible=False)
-
-    with gr.Accordion("Advanced options", open=False):
-        a_prompt = gr.Textbox(label="Additional image description",
-                              info="Completes the main image description",
-                              value='Cinematic, High Contrast, highly detailed, taken using a Canon EOS R '
-                                    'camera, hyper detailed photo - realistic maximum detail, 32k, Color '
-                                    'Grading, ultra HD, extreme meticulous detailing, skin pore detailing, clothing fabric detailing, '
-                                    'hyper sharpness, perfect without deformations.',
-                              lines=3)
-        n_prompt = gr.Textbox(label="Negative image description",
-                              info="Disambiguate by listing what the image does NOT represent",
-                              value='painting, oil painting, illustration, drawing, art, sketch, anime, '
-                                    'cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, '
-                                    'worst quality, low quality, frames, watermark, signature, jpeg artifacts, '
-                                    'deformed, lowres, over-smooth',
-                              lines=3)
-        edm_steps = gr.Slider(label="Steps", info="lower=faster, higher=more details; too many steps create a checker effect", minimum=1, maximum=200, value=default_setting.edm_steps if torch.cuda.device_count() > 0 else 1, step=1)
-        num_samples = gr.Slider(label="Num Samples", info="Number of generated results", minimum=1, maximum=4 if not args.use_image_slider else 1
-                                , value=1, step=1)
-        min_size = gr.Slider(label="Minimum size", info="Minimum height, minimum width of the result", minimum=32, maximum=4096, value=1024, step=32)
-        downscale = gr.Radio([["/1", 1], ["/2", 2], ["/3", 3], ["/4", 4], ["/5", 5], ["/6", 6], ["/7", 7], ["/8", 8], ["/9", 9], ["/10", 10]], label="Pre-downscale factor", info="Reducing blurred image reduce the process time", value=1, interactive=True)
+    with gr.Row():
+        with gr.Column():
+            with gr.Tab("image-to-video") as image_tab:
+                video_i_hidden = gr.Textbox(label="video_i", visible=False, value=None)
+                image_i2v = gr.Image(label="Input Image", type="filepath", sources=["upload", "webcam", "clipboard"])
+                i2v_prompt = gr.Textbox(label="Prompt", value="The creature from the image starts to move", lines=3)
+                i2v_button = gr.Button("Generate Image-to-Video", variant="primary")
+            with gr.Tab("text-to-video") as text_tab:
+                image_n_hidden = gr.Textbox(label="image_n", visible=False, value=None)
+                video_n_hidden = gr.Textbox(label="video_n", visible=False, value=None)
+                t2v_prompt = gr.Textbox(label="Prompt", value="A majestic dragon flying over a medieval castle", lines=3)
+                t2v_button = gr.Button("Generate Text-to-Video", variant="primary")
+            with gr.Tab("video-to-video", visible=False) as video_tab:
+                image_v_hidden = gr.Textbox(label="image_v", visible=False, value=None)
+                video_v2v = gr.Video(label="Input Video", sources=["upload", "webcam"]) # type defaults to filepath
+                frames_to_use = gr.Slider(label="Frames to use from input video", minimum=9, maximum=MAX_NUM_FRAMES, value=9, step=8, info="Number of initial frames to use for conditioning/transformation. Must be N*8+1.")
+                v2v_prompt = gr.Textbox(label="Prompt", value="Change the style to cinematic anime", lines=3)
+                v2v_button = gr.Button("Generate Video-to-Video", variant="primary")
+
+            duration_input = gr.Slider(
+                label="Video Duration (seconds)", 
+                minimum=0.3, 
+                maximum=8.5, 
+                value=2,  
+                step=0.1, 
+                info=f"Target video duration (0.3s to 8.5s)"
+            )
+            improve_texture = gr.Checkbox(label="Improve Texture (multi-scale)", value=True, info="Uses a two-pass generation for better quality, but is slower. Recommended for final output.")
+
+        with gr.Column():
+            output_video = gr.Video(label="Generated Video", interactive=False)
+            # gr.DeepLinkButton()
+
+    with gr.Accordion("Advanced settings", open=False):
+        mode = gr.Dropdown(["text-to-video", "image-to-video", "video-to-video"], label="task", value="image-to-video", visible=False)
+        negative_prompt_input = gr.Textbox(label="Negative Prompt", value="worst quality, inconsistent motion, blurry, jittery, distorted", lines=2)
+        with gr.Row():
+            seed_input = gr.Number(label="Seed", value=42, precision=0, minimum=0, maximum=2**32-1)
+            randomize_seed_input = gr.Checkbox(label="Randomize Seed", value=True)
         with gr.Row():
-            with gr.Column():
-                model_select = gr.Radio([["💃 Quality (v0-Q)", "v0-Q"], ["🎯 Fidelity (v0-F)", "v0-F"]], label="Model Selection", info="Pretrained model", value="v0-Q",
-                                        interactive=True)
-            with gr.Column():
-                color_fix_type = gr.Radio([["None", "None"], ["AdaIn (improve as a photo)", "AdaIn"], ["Wavelet (for JPEG artifacts)", "Wavelet"]], label="Color-Fix Type", info="AdaIn=Improve following a style, Wavelet=For JPEG artifacts", value="AdaIn",
-                                          interactive=True)
-        s_cfg = gr.Slider(label="Text Guidance Scale", info="lower=follow the image, higher=follow the prompt", minimum=1.0, maximum=15.0,
-                          value=default_setting.s_cfg_Quality if torch.cuda.device_count() > 0 else 1.0, step=0.1)
-        s_stage2 = gr.Slider(label="Restoring Guidance Strength", minimum=0., maximum=1., value=1., step=0.05)
-        s_stage1 = gr.Slider(label="Pre-denoising Guidance Strength", minimum=-1.0, maximum=6.0, value=-1.0, step=1.0)
-        s_churn = gr.Slider(label="S-Churn", minimum=0, maximum=40, value=5, step=1)
-        s_noise = gr.Slider(label="S-Noise", minimum=1.0, maximum=1.1, value=1.003, step=0.001)
+            guidance_scale_input = gr.Slider(label="Guidance Scale (CFG)", minimum=1.0, maximum=10.0, value=PIPELINE_CONFIG_YAML.get("first_pass", {}).get("guidance_scale", 1.0), step=0.1, info="Controls how much the prompt influences the output. Higher values = stronger influence.")
         with gr.Row():
-            with gr.Column():
-                linear_CFG = gr.Checkbox(label="Linear CFG", value=True)
-                spt_linear_CFG = gr.Slider(label="CFG Start", minimum=1.0,
-                                                maximum=9.0, value=default_setting.spt_linear_CFG_Quality if torch.cuda.device_count() > 0 else 1.0, step=0.5)
-            with gr.Column():
-                linear_s_stage2 = gr.Checkbox(label="Linear Restoring Guidance", value=False)
-                spt_linear_s_stage2 = gr.Slider(label="Guidance Start", minimum=0.,
-                                                maximum=1., value=0., step=0.05)
-            with gr.Column():
-                diff_dtype = gr.Radio([["fp32 (precision)", "fp32"], ["fp16 (medium)", "fp16"], ["bf16 (speed)", "bf16"]], label="Diffusion Data Type", value="fp32",
-                                      interactive=True)
-            with gr.Column():
-                ae_dtype = gr.Radio([["fp32 (precision)", "fp32"], ["bf16 (speed)", "bf16"]], label="Auto-Encoder Data Type", value="fp32",
-                                    interactive=True)
-        randomize_seed = gr.Checkbox(label = "\U0001F3B2 Randomize seed", value = True, info = "If checked, result is always different")
-        seed = gr.Slider(label="Seed", minimum=0, maximum=max_64_bit_int, step=1, randomize=True)
-        with gr.Group():
-            param_setting = gr.Radio(["Quality", "Fidelity"], interactive=True, label="Presetting", value = "Quality")
-            restart_button = gr.Button(value="Apply presetting")
-
-    with gr.Column():
-        diffusion_button = gr.Button(value="🚀 Upscale/Restore", variant = "primary", elem_id = "process_button")
-        reset_btn = gr.Button(value="🧹 Reinit page", variant="stop", elem_id="reset_button", visible = False)
-
-        warning = gr.HTML(value = "<center><big>Your computer must <u>not</u> enter into standby mode.</big><br/>On Chrome, you can force to keep a tab alive in <code>chrome://discards/</code></center>", visible = False)
-        restore_information = gr.HTML(value = "Restart the process to get another result.", visible = False)
-        result_slider = ImageSlider(label = 'Comparator', show_label = False, interactive = False, elem_id = "slider1", show_download_button = False)
-        result_gallery = gr.Gallery(label = 'Downloadable results', show_label = True, interactive = False, elem_id = "gallery1")
-
-    gr.Examples(
+            height_input = gr.Slider(label="Height", value=512, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE, info="Must be divisible by 32.")
+            width_input = gr.Slider(label="Width", value=704, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE, info="Must be divisible by 32.")
+
+    with gr.Accordion("Debug", open=False):
+        image_i2v_debug = gr.Image(label="Input Image Debug", type="filepath", sources=["upload", "webcam", "clipboard"])
+        i2v_prompt_debug = gr.Textbox(label="Prompt Debug", value="", lines=3)
+        height_input_debug = gr.Slider(label="Height Debug", value=512, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE, info="Must be divisible by 32.")
+        width_input_debug = gr.Slider(label="Width Debug", value=704, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE, info="Must be divisible by 32.")
+        duration_input_debug = gr.Slider(
+                label="Video Duration Debug (seconds)", 
+                minimum=0.3, 
+                maximum=8.5, 
+                value=6,  
+                step=0.1, 
+                info=f"Target video duration (0.3s to 8.5s)"
+            )
+
+    with gr.Row(visible=False):
+        gr.Examples(
         examples = [
                 [
-                    "./Examples/Example1.png",
-                    0,
-                    None,
-                    "Group of people, walking, happy, in the street, photorealistic, 8k, extremely detailled",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    2,
-                    1024,
-                    1,
-                    8,
-                    100,
-                    -1,
-                    1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "AdaIn",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    179
-                ],
-                [
-                    "./Examples/Example2.jpeg",
-                    0,
-                    None,
-                    "La cabeza de un gato atigrado, en una casa, fotorrealista, 8k, extremadamente detallada",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,
-                    1024,
-                    1,
-                    1,
-                    200,
-                    -1,
-                    1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "Wavelet",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    179
-                ],
-                [
-                    "./Examples/Example3.webp",
-                    0,
+                    "View of the sea as far as the eye can see, from the seaside, a piece of land is barely visible on the horizon at the middle, the sky is radiant, reflections of the sun in the water, photorealistic, realistic, intricate details, 8k, insanely detailed",
+                    "",
+                    "./Example_LTX/Example1.png",
                     None,
-                    "A red apple",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,
-                    1024,
-                    1,
-                    1,
-                    200,
-                    -1,
-                    1,
-                    7.5,
-                    False,
+                    512,
+                    800,
+                    "image-to-video",
+                    6,
+                    9,
                     42,
-                    5,
-                    1.003,
-                    "Wavelet",
-                    "fp16",
-                    "bf16",
-                    1.0,
                     True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    179
-                ],
-                [
-                    "./Examples/Example3.webp",
-                    0,
-                    None,
-                    "A red marble",
-                    "Cinematic, High Contrast, highly detailed, taken using a Canon EOS R camera, hyper detailed photo - realistic maximum detail, 32k, Color Grading, ultra HD, extreme meticulous detailing, skin pore detailing, hyper sharpness, perfect without deformations.",
-                    "painting, oil painting, illustration, drawing, art, sketch, anime, cartoon, CG Style, 3D render, unreal engine, blurring, aliasing, pixel, unsharp, weird textures, ugly, dirty, messy, worst quality, low quality, frames, watermark, signature, jpeg artifacts, deformed, lowres, over-smooth",
-                    1,
-                    1024,
-                    1,
-                    1,
-                    200,
-                    -1,
                     1,
-                    7.5,
-                    False,
-                    42,
-                    5,
-                    1.003,
-                    "Wavelet",
-                    "fp16",
-                    "bf16",
-                    1.0,
-                    True,
-                    4,
-                    False,
-                    0.,
-                    "v0-Q",
-                    "input",
-                    179
+                    True
                 ],
             ],
         run_on_click = True,
-        fn = stage2_process,
-	    inputs = [
-            input_image,
-            rotation,
-            denoise_image,
-            prompt,
-            a_prompt,
-            n_prompt,
-            num_samples,
-            min_size,
-            downscale,
-            upscale,
-            edm_steps,
-            s_stage1,
-            s_stage2,
-            s_cfg,
-            randomize_seed,
-            seed,
-            s_churn,
-            s_noise,
-            color_fix_type,
-            diff_dtype,
-            ae_dtype,
-            gamma_correction,
-            linear_CFG,
-            linear_s_stage2,
-            spt_linear_CFG,
-            spt_linear_s_stage2,
-            model_select,
-            output_format,
-            allocation
-        ],
-	    outputs = [
-            result_slider,
-            result_gallery,
-            restore_information,
-            reset_btn
-        ],
-        cache_examples = False,
+        fn = generate,
+	    inputs = [i2v_prompt, negative_prompt_input, image_i2v, video_i_hidden,
+                  height_input, width_input, mode,
+                  duration_input, frames_to_use, 
+                  seed_input, randomize_seed_input, guidance_scale_input, improve_texture],
+	    outputs = [output_video, seed_input],
+        cache_examples = True,
     )
 
-    with gr.Row():
-        gr.Markdown(claim_md)
+    def height_input_debug_change(value):
+        global height_input_debug_value
+        height_input_debug_value = value
+        return []
+
+    def width_input_debug_change(value):
+        global width_input_debug_value
+        width_input_debug_value = value
+        return []
+
+    def duration_input_debug_change(value):
+        global duration_input_debug_value
+        duration_input_debug_value = value
+        return []
+
+    def i2v_prompt_debug_change(prompt):
+        global i2v_prompt_debug_value
+        i2v_prompt_debug_value = prompt
+        return []
+
+    # --- Event handlers for updating dimensions on upload ---
+    def handle_image_upload_for_dims(image_filepath, current_h, current_w):
+        if not image_filepath:  # Image cleared or no image initially
+            # Keep current slider values if image is cleared or no input
+            return gr.update(value=current_h), gr.update(value=current_w)
+        try:
+            img = Image.open(image_filepath)
+            orig_w, orig_h = img.size
+            new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
+            return gr.update(value=new_h), gr.update(value=new_w)
+        except Exception as e:
+            print(f"Error processing image for dimension update: {e}")
+            # Keep current slider values on error
+            return gr.update(value=current_h), gr.update(value=current_w)
+
+    def handle_image_debug_upload_for_dims(image_filepath, current_h, current_w):
+        global image_i2v_debug_value
+        image_i2v_debug_value = image_filepath
+        if not image_filepath:  # Image cleared or no image initially
+            # Keep current slider values if image is cleared or no input
+            return gr.update(value=current_h), gr.update(value=current_w)
+        try:
+            img = Image.open(image_filepath)
+            orig_w, orig_h = img.size
+            new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
+            global height_input_debug_value
+            height_input_debug_value = new_h
+            global width_input_debug_value
+            width_input_debug_value = new_w
+            return gr.update(value=new_h), gr.update(value=new_w)
+        except Exception as e:
+            # Keep current slider values on error
+            return gr.update(value=current_h), gr.update(value=current_w)
+
+    def handle_video_upload_for_dims(video_filepath, current_h, current_w):
+        if not video_filepath:  # Video cleared or no video initially
+            return gr.update(value=current_h), gr.update(value=current_w)
+        try:
+            # Ensure video_filepath is a string for os.path.exists and imageio
+            video_filepath_str = str(video_filepath) 
+            if not os.path.exists(video_filepath_str):
+                print(f"Video file path does not exist for dimension update: {video_filepath_str}")
+                return gr.update(value=current_h), gr.update(value=current_w)
+
+            orig_w, orig_h = -1, -1
+            with imageio.get_reader(video_filepath_str) as reader:
+                meta = reader.get_meta_data()
+                if 'size' in meta:
+                    orig_w, orig_h = meta['size']
+                else:
+                    # Fallback: read first frame if 'size' not in metadata
+                    try:
+                        first_frame = reader.get_data(0)
+                        # Shape is (h, w, c) for frames
+                        orig_h, orig_w = first_frame.shape[0], first_frame.shape[1]
+                    except Exception as e_frame:
+                        print(f"Could not get video size from metadata or first frame: {e_frame}")
+                        return gr.update(value=current_h), gr.update(value=current_w)
+            
+            if orig_w == -1 or orig_h == -1: # If dimensions couldn't be determined
+                 print(f"Could not determine dimensions for video: {video_filepath_str}")
+                 return gr.update(value=current_h), gr.update(value=current_w)
+
+            new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
+            return gr.update(value=new_h), gr.update(value=new_w)
+        except Exception as e:
+            # Log type of video_filepath for debugging if it's not a path-like string
+            print(f"Error processing video for dimension update: {e} (Path: {video_filepath}, Type: {type(video_filepath)})")
+            return gr.update(value=current_h), gr.update(value=current_w)
+
     
-    input_image.upload(fn = check_upload, inputs = [
-        input_image
-    ], outputs = [
-        rotation
-    ], queue = False, show_progress = False)
-
-    denoise_button.click(fn = check_and_update, inputs = [
-        input_image
-    ], outputs = [warning], queue = False, show_progress = False).success(fn = stage1_process, inputs = [
-        input_image,
-        gamma_correction,
-        diff_dtype,
-        ae_dtype
-    ], outputs=[
-        denoise_image,
-        denoise_information
-    ])
-
-    diffusion_button.click(fn = update_seed, inputs = [
-        randomize_seed,
-        seed
-    ], outputs = [
-        seed
-    ], queue = False, show_progress = False).then(fn = check_and_update, inputs = [
-        input_image
-    ], outputs = [warning], queue = False, show_progress = False).success(fn=stage2_process, inputs = [
-        input_image,
-        rotation,
-        denoise_image,
-        prompt,
-        a_prompt,
-        n_prompt,
-        num_samples,
-        min_size,
-        downscale,
-        upscale,
-        edm_steps,
-        s_stage1,
-        s_stage2,
-        s_cfg,
-        randomize_seed,
-        seed,
-        s_churn,
-        s_noise,
-        color_fix_type,
-        diff_dtype,
-        ae_dtype,
-        gamma_correction,
-        linear_CFG,
-        linear_s_stage2,
-        spt_linear_CFG,
-        spt_linear_s_stage2,
-        model_select,
-        output_format,
-        allocation
-    ], outputs = [
-        result_slider,
-        result_gallery,
-        restore_information,
-        reset_btn
-    ]).success(fn = log_information, inputs = [
-        result_gallery
-    ], outputs = [], queue = False, show_progress = False)
-
-    result_gallery.change(on_select_result, [result_slider, result_gallery], result_slider)
-    result_gallery.select(on_select_result, [result_slider, result_gallery], result_slider)
-
-    restart_button.click(fn = load_and_reset, inputs = [
-        param_setting
-    ], outputs = [
-        edm_steps,
-        s_cfg,
-        s_stage2,
-        s_stage1,
-        s_churn,
-        s_noise,
-        a_prompt,
-        n_prompt,
-        color_fix_type,
-        linear_CFG,
-        linear_s_stage2,
-        spt_linear_CFG,
-        spt_linear_s_stage2,
-        model_select
-    ])
-
-    reset_btn.click(fn = reset, inputs = [], outputs = [
-            input_image,
-            rotation,
-            denoise_image,
-            prompt,
-            a_prompt,
-            n_prompt,
-            num_samples,
-            min_size,
-            downscale,
-            upscale,
-            edm_steps,
-            s_stage1,
-            s_stage2,
-            s_cfg,
-            randomize_seed,
-            seed,
-            s_churn,
-            s_noise,
-            color_fix_type,
-            diff_dtype,
-            ae_dtype,
-            gamma_correction,
-            linear_CFG,
-            linear_s_stage2,
-            spt_linear_CFG,
-            spt_linear_s_stage2,
-            model_select,
-            output_format,
-            allocation
-        ], queue = False, show_progress = False)
-        
-    interface.queue(10).launch()
+    image_i2v_debug.upload(
+        fn=handle_image_debug_upload_for_dims,
+        inputs=[image_i2v_debug, height_input_debug, width_input_debug],
+        outputs=[height_input_debug, width_input_debug]
+    )
+    
+    image_i2v.upload(
+        fn=handle_image_upload_for_dims,
+        inputs=[image_i2v, height_input, width_input],
+        outputs=[height_input, width_input]
+    )
+    video_v2v.upload(
+        fn=handle_video_upload_for_dims,
+        inputs=[video_v2v, height_input, width_input],
+        outputs=[height_input, width_input]
+    )
+    i2v_prompt_debug.change(
+        fn=i2v_prompt_debug_change,
+        inputs=[image_i2v_debug],
+        outputs=[]
+    )
+    height_input_debug.change(
+        fn=height_input_debug_change,
+        inputs=[height_input_debug],
+        outputs=[]
+    )
+    width_input_debug.change(
+        fn=width_input_debug_change,
+        inputs=[width_input_debug],
+        outputs=[]
+    )
+    duration_input_debug.change(
+        fn=duration_input_debug_change,
+        inputs=[duration_input_debug],
+        outputs=[]
+    )
+
+    image_tab.select(
+        fn=update_task_image,
+        outputs=[mode]
+    )
+    text_tab.select(
+        fn=update_task_text,
+        outputs=[mode]
+    )
+    
+    t2v_inputs = [t2v_prompt, negative_prompt_input, image_n_hidden, video_n_hidden,
+                  height_input, width_input, mode,
+                  duration_input, frames_to_use, 
+                  seed_input, randomize_seed_input, guidance_scale_input, improve_texture]
+    
+    i2v_inputs = [i2v_prompt, negative_prompt_input, image_i2v, video_i_hidden,
+                  height_input, width_input, mode,
+                  duration_input, frames_to_use, 
+                  seed_input, randomize_seed_input, guidance_scale_input, improve_texture]
+
+    v2v_inputs = [v2v_prompt, negative_prompt_input, image_v_hidden, video_v2v,
+                  height_input, width_input, mode,
+                  duration_input, frames_to_use, 
+                  seed_input, randomize_seed_input, guidance_scale_input, improve_texture]
+
+    t2v_button.click(fn=generate, inputs=t2v_inputs, outputs=[output_video, seed_input], api_name="text_to_video")
+    i2v_button.click(fn=generate, inputs=i2v_inputs, outputs=[output_video, seed_input], api_name="image_to_video")
+    v2v_button.click(fn=generate, inputs=v2v_inputs, outputs=[output_video, seed_input], api_name="video_to_video")
+
+if __name__ == "__main__":
+    if os.path.exists(models_dir) and os.path.isdir(models_dir):
+        print(f"Model directory: {Path(models_dir).resolve()}")
+    
+    demo.queue().launch(debug=True, share=False, mcp_server=True)

requirements.txt

@@ -1,48 +1,15 @@
-pydantic==2.10.6
-fastapi==0.115.8
-gradio_imageslider==0.0.20
-gradio_client==1.7.0
-numpy==1.26.4
-requests==2.32.3
-sentencepiece==0.2.0
-tokenizers==0.19.1
-torchvision==0.18.1
-uvicorn==0.30.1
-wandb==0.17.4
-httpx==0.27.0
-transformers==4.42.4
-accelerate==0.32.1
-scikit-learn==1.5.1
-einops==0.8.0
-einops-exts==0.0.4
-timm==1.0.7
-openai-clip==1.0.1
-fsspec==2024.6.1
-kornia==0.7.3
-matplotlib==3.9.1
-ninja==1.11.1.1
-omegaconf==2.3.0
-opencv-python==4.10.0.84
-pandas==2.2.2
-pillow==10.4.0
-pytorch-lightning==2.3.3
-PyYAML==6.0.1
-scipy==1.14.0
-tqdm==4.66.4
-triton==2.3.1
-urllib3==2.2.2
-webdataset==0.2.86
-xformers==0.0.27
-facexlib==0.3.0
-k-diffusion==0.1.1.post1
-diffusers==0.30.0
-pillow-heif==0.18.0
-
-open-clip-torch==2.24.0
-
-torchaudio
-easydict==1.13
-fairscale==0.4.13
-torchsde==0.2.6
-huggingface_hub==0.23.3
-gradio
+accelerate
+transformers
+sentencepiece
+pillow
+numpy
+torchvision
+huggingface_hub
+spaces
+opencv-python
+imageio
+imageio-ffmpeg
+einops
+timm
+av
+git+https://github.com/huggingface/diffusers.git@main