Update app.py

app.py

@@ -1,403 +1,273 @@
-import gradio as gr
-import torch
-import spaces
-import numpy as np
-import random
-import os
-import yaml
-from pathlib import Path
-import imageio
-import tempfile
-from PIL import Image
-from huggingface_hub import hf_hub_download
-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
-
-# Đường dẫn tới file cấu hình YAML
-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)
-
-# Repo HuggingFace của bạn chứa hai file mô hình
-LTX_REPO = "LTTEAM/VideoAI"
-MAX_IMAGE_SIZE = PIPELINE_CONFIG_YAML.get("max_resolution", 1280)
-MAX_NUM_FRAMES = 257
-
-FPS = 30.0  # Khung hình trên giây
-
-# --- Biến toàn cục cho pipeline và upsampler đã tải ---
-pipeline_instance = None
-latent_upsampler_instance = None
-models_dir = "downloaded_models_gradio_cpu_init"
-Path(models_dir).mkdir(parents=True, exist_ok=True)
-
-print("Đang tải mô hình (nếu chưa có)…")
-# Tải mô hình distilled
-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"Đường dẫn mô hình distilled: {distilled_model_actual_path}")
-
-# Tải mô hình upscaler không gian
-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"Đường dẫn mô hình upscaler: {spatial_upscaler_actual_path}")
-
-print("Khởi tạo pipeline LTX Video trên 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("Pipeline LTX Video đã sẵn sàng trên CPU.")
-
-if PIPELINE_CONFIG_YAML.get("spatial_upscaler_model_path"):
-    print("Khởi tạo latent upsampler trên CPU…")
-    latent_upsampler_instance = create_latent_upsampler(
-        PIPELINE_CONFIG_YAML["spatial_upscaler_model_path"],
-        device="cpu"
-    )
-    print("Latent upsampler đã sẵn sàng trên CPU.")
-
-# Chuyển sang GPU để inference
-target_inference_device = "cuda"
-print(f"Sử dụng thiết bị inference: {target_inference_device}")
-pipeline_instance.to(target_inference_device)
-if latent_upsampler_instance:
-    latent_upsampler_instance.to(target_inference_device)
-
-
-# --- Hàm trợ giúp tính kích thước mới sao cho vừa khung 32 pixel ---
-MIN_DIM_SLIDER = 256    # Giá trị tối thiểu của slider
-TARGET_FIXED_SIDE = 768 # Kích thước cố định một cạnh
-
-def calculate_new_dimensions(orig_w, orig_h):
-    """
-    Tính kích thước mới cho height/width slider dựa trên kích thước gốc.
-    - Một cạnh cố định là TARGET_FIXED_SIDE, cạnh kia co tỉ lệ.
-    - Cả hai phải chia hết cho 32 và trong khoảng [MIN_DIM_SLIDER, MAX_IMAGE_SIZE].
-    """
-    if orig_w == 0 or orig_h == 0:
-        return TARGET_FIXED_SIDE, TARGET_FIXED_SIDE
-
-    if orig_w >= orig_h:
-        new_h = TARGET_FIXED_SIDE
-        aspect_ratio = orig_w / orig_h
-        new_w_ideal = new_h * aspect_ratio
-        new_w = round(new_w_ideal / 32) * 32
-        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
-        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE))
-    else:
-        new_w = TARGET_FIXED_SIDE
-        aspect_ratio = orig_h / orig_w
-        new_h_ideal = new_w * aspect_ratio
-        new_h = round(new_h_ideal / 32) * 32
-        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE))
-        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, ui_frames_to_use,
-                 seed_ui, randomize_seed, ui_guidance_scale, improve_texture_flag,
-                 progress):
-    # Spaces.GPU yêu cầu hàm duration trả về số giây max
-    return 75 if duration_ui > 7 else 60
-
-@spaces.GPU(duration=get_duration)
-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)):
-    # Xử lý seed
-    if randomize_seed:
-        seed_ui = random.randint(0, 2**32 - 1)
-    seed_everething(int(seed_ui))
-
-    # Tính số frame
-    target_frames = round(duration_ui * FPS)
-    target_frames = max(1, target_frames)
-    n_val = round((target_frames - 1) / 8)
-    num_frames = int(n_val * 8 + 1)
-    num_frames = max(9, min(num_frames, MAX_NUM_FRAMES))
-
-    h, w = int(height_ui), int(width_ui)
-    h_padded = ((h - 1) // 32 + 1) * 32
-    w_padded = ((w - 1) // 32 + 1) * 32
-    frames_padded = ((num_frames - 2) // 8 + 1) * 8 + 1
-    if frames_padded != num_frames:
-        print(f"Cảnh báo: num_frames ({num_frames}) ≠ frames_padded ({frames_padded}), dùng frames_padded.")
-
-    padding_values = calculate_padding(h, w, h_padded, w_padded)
-
-    # Chuẩn bị tham số gọi pipeline
-    call_kwargs = {
-        "prompt": prompt,
-        "negative_prompt": negative_prompt,
-        "height": h_padded,
-        "width": w_padded,
-        "num_frames": 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,
-    }
-
-    # Cấu hình skip layer strategy
-    stg = PIPELINE_CONFIG_YAML.get("stg_mode", "attention_values").lower()
-    if stg in ["stg_av", "attention_values"]:
-        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.AttentionValues
-    elif stg in ["stg_as", "attention_skip"]:
-        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.AttentionSkip
-    elif stg in ["stg_r", "residual"]:
-        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.Residual
-    elif stg in ["stg_t", "transformer_block"]:
-        call_kwargs["skip_layer_strategy"] = SkipLayerStrategy.TransformerBlock
-    else:
-        raise ValueError(f"stg_mode không hợp lệ: {stg}")
-
-    # Xử lý conditioning cho image-to-video hoặc video-to-video
-    if mode == "image-to-video" and input_image_filepath:
-        try:
-            media_tensor = load_image_to_tensor_with_resize_and_crop(input_image_filepath, h, w)
-            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:
-            raise gr.Error(f"Không tải được ảnh: {e}")
-    elif mode == "video-to-video" and input_video_filepath:
-        try:
-            call_kwargs["media_items"] = load_media_file(
-                media_path=input_video_filepath,
-                height=h,
-                width=w,
-                max_frames=int(ui_frames_to_use),
-                padding=padding_values
-            ).to(target_inference_device)
-        except Exception as e:
-            raise gr.Error(f"Không tải được video: {e}")
-
-    print(f"Chuyển mô hình sang {target_inference_device} nếu cần…")
-    active_upsampler = latent_upsampler_instance if improve_texture_flag else None
-
-    # Chạy pipeline (1 pass hoặc multi-scale)
-    if improve_texture_flag and active_upsampler:
-        pipeline_ms = LTXMultiScalePipeline(pipeline_instance, active_upsampler)
-        # Cấu hình 2 pass
-        first_pass = PIPELINE_CONFIG_YAML.get("first_pass", {}).copy()
-        first_pass["guidance_scale"] = float(ui_guidance_scale)
-        first_pass.pop("num_inference_steps", None)
-        second_pass = PIPELINE_CONFIG_YAML.get("second_pass", {}).copy()
-        second_pass["guidance_scale"] = float(ui_guidance_scale)
-        second_pass.pop("num_inference_steps", None)
-        kwargs_ms = {**call_kwargs,
-                     "downscale_factor": PIPELINE_CONFIG_YAML["downscale_factor"],
-                     "first_pass": first_pass,
-                     "second_pass": second_pass}
-        print(f"Chạy multi-scale pipeline: {h}x{w}, frames {num_frames}→{frames_padded}")
-        result = pipeline_ms(**kwargs_ms).images
-    else:
-        single_cfg = PIPELINE_CONFIG_YAML.get("first_pass", {})
-        kwargs_sp = {**call_kwargs,
-                     "timesteps": single_cfg.get("timesteps"),
-                     "guidance_scale": float(ui_guidance_scale),
-                     "stg_scale": single_cfg.get("stg_scale"),
-                     "rescaling_scale": single_cfg.get("rescaling_scale"),
-                     "skip_block_list": single_cfg.get("skip_block_list")}
-        # Loại bỏ key không dùng
-        for k in ["num_inference_steps", "first_pass", "second_pass", "downscale_factor"]:
-            kwargs_sp.pop(k, None)
-        print(f"Chạy single-pass pipeline: {h_padded}x{w_padded}, frames {num_frames}→{frames_padded}")
-        result = pipeline_instance(**kwargs_sp).images
-
-    if result is None:
-        raise gr.Error("Quá trình tạo thất bại.")
-
-    # Bỏ padding
-    pad_l, pad_r, pad_t, pad_b = padding_values
-    slice_h = None if pad_b == 0 else -pad_b
-    slice_w = None if pad_r == 0 else -pad_r
-    result = result[:, :, :num_frames, pad_t:slice_h, pad_l:slice_w]
-
-    # Chuyển sang numpy và lưu video
-    video_np = result[0].permute(1, 2, 3, 0).cpu().numpy()
-    video_np = (np.clip(video_np,0,1)*255).astype(np.uint8)
-
-    temp_dir = tempfile.mkdtemp()
-    out_path = os.path.join(temp_dir, f"output_{random.randint(10000,99999)}.mp4")
-    try:
-        with imageio.get_writer(out_path, fps=int(FPS), macro_block_size=1) as writer:
-            for i in range(video_np.shape[0]):
-                progress(i/video_np.shape[0], desc="Lưu video")
-                writer.append_data(video_np[i])
-    except Exception:
-        # Fallback dùng ffmpeg
-        with imageio.get_writer(out_path, fps=int(FPS), format='FFMPEG', codec='libx264', quality=8) as writer:
-            for i in range(video_np.shape[0]):
-                progress(i/video_np.shape[0], desc="Lưu video fallback")
-                writer.append_data(video_np[i])
-
-    return out_path, seed_ui
-
-# Hàm cập nhật tab
-def update_task_image(): return "image-to-video"
-def update_task_text():  return "text-to-video"
-def update_task_video(): return "video-to-video"
-
-# --- Định nghĩa giao diện Gradio ---
-css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 900px;
-}
-"""
-
-with gr.Blocks(css=css) as demo:
-    gr.Markdown("# Ứng dụng LTX Video 0.9.7 Distilled")
-    gr.Markdown(
-        "Tạo video chất lượng cao nhanh chóng. "
-        "[Mô hình](https://huggingface.co/LTTEAM/VideoAI/blob/main/ltxv-13b-0.9.7-distilled.safetensors) · "
-        "[GitHub](https://github.com/Lightricks/LTX-Video)"
-    )
-
-    with gr.Row():
-        with gr.Column():
-            # Tab image-to-video
-            with gr.Tab("Ảnh→Video") as tab_img:
-                video_i_hidden = gr.Textbox(visible=False)
-                image_input = gr.Image(label="Chọn ảnh", type="filepath", sources=["upload","webcam","clipboard"])
-                prompt_img = gr.Textbox(label="Nhập mô tả", value="Con sinh vật trong ảnh bắt đầu chuyển động", lines=3)
-                btn_img = gr.Button("Tạo video từ ảnh", variant="primary")
-
-            # Tab text-to-video
-            with gr.Tab("Văn bản→Video") as tab_txt:
-                image_n_hidden = gr.Textbox(visible=False)
-                video_n_hidden = gr.Textbox(visible=False)
-                prompt_txt = gr.Textbox(label="Nhập mô tả", value="Rồng hùng vĩ bay trên lâu đài thời trung cổ", lines=3)
-                btn_txt = gr.Button("Tạo video từ văn bản", variant="primary")
-
-            # Tab video-to-video (ẩn theo mặc định)
-            with gr.Tab("Video→Video", visible=False) as tab_vid:
-                image_v_hidden = gr.Textbox(visible=False)
-                video_input = gr.Video(label="Chọn video", sources=["upload","webcam"])
-                frames_slider = gr.Slider(label="Số frame dùng", minimum=9, maximum=MAX_NUM_FRAMES, value=9, step=8,
-                                          info="Phải là N*8+1")
-                prompt_vid = gr.Textbox(label="Nhập mô tả", value="Chuyển phong cách sang anime điện ảnh", lines=3)
-                btn_vid = gr.Button("Tạo video từ video", variant="primary")
-
-            duration_input = gr.Slider(label="Thời lượng video (s)", minimum=0.3, maximum=8.5, value=2, step=0.1)
-            improve_texture = gr.Checkbox(label="Cải thiện chi tiết (multi-scale)", value=True)
-
-        with gr.Column():
-            output_video = gr.Video(label="Video kết quả", interactive=False)
-
-    # Cài đặt nâng cao
-    with gr.Accordion("Cài đặt nâng cao", open=False):
-        mode = gr.Dropdown(["text-to-video","image-to-video","video-to-video"], visible=False)
-        negative_prompt = 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)
-            rand_seed = gr.Checkbox(label="Randomize Seed", value=True)
-        with gr.Row():
-            cfg_scale = 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)
-        with gr.Row():
-            height_slider = gr.Slider(label="Chiều cao", value=512, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE)
-            width_slider  = gr.Slider(label="Chiều rộng", value=704, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE)
-
-    # Cập nhật kích thước khi tải ảnh/video
-    def on_image_upload(fp, h, w):
-        if not fp: return gr.update(value=h), gr.update(value=w)
-        try:
-            img = Image.open(fp)
-            new_h, new_w = calculate_new_dimensions(*img.size)
-            return gr.update(value=new_h), gr.update(value=new_w)
-        except:
-            return gr.update(value=h), gr.update(value=w)
-
-    def on_video_upload(fp, h, w):
-        if not fp: return gr.update(value=h), gr.update(value=w)
-        try:
-            fp = str(fp)
-            if not os.path.exists(fp): return gr.update(value=h), gr.update(value=w)
-            reader = imageio.get_reader(fp)
-            meta = reader.get_meta_data()
-            if "size" in meta:
-                orig_w, orig_h = meta["size"]
-            else:
-                f0 = reader.get_data(0)
-                orig_h, orig_w = f0.shape[0], f0.shape[1]
-            new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
-            return gr.update(value=new_h), gr.update(value=new_w)
-        except:
-            return gr.update(value=h), gr.update(value=w)
-
-    image_input.upload(on_image_upload, [image_input, height_slider, width_slider], [height_slider, width_slider])
-    video_input.upload(on_video_upload, [video_input, height_slider, width_slider], [height_slider, width_slider])
-
-    # Kết nối tab với mode
-    tab_img.select(lambda: "image-to-video", outputs=[mode])
-    tab_txt.select(lambda: "text-to-video",  outputs=[mode])
-    tab_vid.select(lambda: "video-to-video", outputs=[mode])
-
-    # Đầu vào cho mỗi nút
-    inputs_txt = [prompt_txt, negative_prompt, image_n_hidden, video_n_hidden,
-                  height_slider, width_slider, mode,
-                  duration_input, frames_slider,
-                  seed_input, rand_seed, cfg_scale, improve_texture]
-    inputs_img = [prompt_img, negative_prompt, image_input, video_i_hidden,
-                  height_slider, width_slider, mode,
-                  duration_input, frames_slider,
-                  seed_input, rand_seed, cfg_scale, improve_texture]
-    inputs_vid = [prompt_vid, negative_prompt, image_v_hidden, video_input,
-                  height_slider, width_slider, mode,
-                  duration_input, frames_slider,
-                  seed_input, rand_seed, cfg_scale, improve_texture]
-
-    btn_txt.click(fn=generate, inputs=inputs_txt, outputs=[output_video, seed_input], api_name="text_to_video")
-    btn_img.click(fn=generate, inputs=inputs_img, outputs=[output_video, seed_input], api_name="image_to_video")
-    btn_vid.click(fn=generate, inputs=inputs_vid, outputs=[output_video, seed_input], api_name="video_to_video")
-
-if __name__ == "__main__":
-    if os.path.isdir(models_dir):
-        print(f"Thư mục mô hình: {Path(models_dir).resolve()}")
-    demo.queue().launch(debug=True, share=False, mcp_server=True)
+import gradio as gr
+import torch
+import spaces
+import numpy as np
+import random
+import os
+import yaml
+from pathlib import Path
+import imageio
+import tempfile
+from PIL import Image
+from huggingface_hub import hf_hub_download
+
+from inference import (
+    create_ltx_video_pipeline,
+    create_latent_upsampler,
+    load_image_to_tensor_with_resize_and_crop,
+    seed_everething,
+    calculate_padding,
+    load_media_file
+)
+from ltx_video.pipelines.pipeline_ltx_video import ConditioningItem, LTXMultiScalePipeline
+from ltx_video.utils.skip_layer_strategy import SkipLayerStrategy
+
+# --- Cấu hình và tải mô hình từ repo của bạn ---
+CONFIG_PATH = "configs/ltxv-13b-0.9.7-distilled.yaml"
+with open(CONFIG_PATH, "r") as f:
+    CFG = yaml.safe_load(f)
+
+HF_REPO = "LTTEAM/VideoAI"
+MODELS_DIR = "downloaded_models"
+Path(MODELS_DIR).mkdir(parents=True, exist_ok=True)
+
+print("Đang tải mô hình (nếu chưa có)…")
+ckpt_path = hf_hub_download(
+    repo_id=HF_REPO,
+    filename=CFG["checkpoint_path"],
+    local_dir=MODELS_DIR
+)
+CFG["checkpoint_path"] = ckpt_path
+upscaler_path = hf_hub_download(
+    repo_id=HF_REPO,
+    filename=CFG["spatial_upscaler_model_path"],
+    local_dir=MODELS_DIR
+)
+CFG["spatial_upscaler_model_path"] = upscaler_path
+
+# --- Khởi tạo pipeline trên CPU ban đầu ---
+print("Khởi tạo LTX Video pipeline trên CPU…")
+pipeline = create_ltx_video_pipeline(
+    ckpt_path=CFG["checkpoint_path"],
+    precision=CFG["precision"],
+    text_encoder_model_name_or_path=CFG["text_encoder_model_name_or_path"],
+    sampler=CFG["sampler"],
+    device="cpu",
+    enhance_prompt=False,
+    prompt_enhancer_image_caption_model_name_or_path=CFG["prompt_enhancer_image_caption_model_name_or_path"],
+    prompt_enhancer_llm_model_name_or_path=CFG["prompt_enhancer_llm_model_name_or_path"],
+)
+print("Pipeline sẵn sàng.")
+print("Khởi tạo latent upsampler trên CPU…")
+upsampler = create_latent_upsampler(CFG["spatial_upscaler_model_path"], device="cpu")
+print("Latent upsampler sẵn sàng.")
+
+# --- Các thông số cố định ---
+FPS = 30.0
+MAX_NUM_FRAMES = 257
+MIN_DIM = 256
+TARGET_SIDE = 768
+MAX_RES = CFG.get("max_resolution", 1280)
+
+def calculate_new_dimensions(w, h):
+    if w==0 or h==0:
+        return TARGET_SIDE, TARGET_SIDE
+    if w>=h:
+        nh = TARGET_SIDE
+        nw = round((nh * w/h)/32)*32
+    else:
+        nw = TARGET_SIDE
+        nh = round((nw * h/w)/32)*32
+    return ( 
+        int(max(MIN_DIM, min(nh, MAX_RES))),
+        int(max(MIN_DIM, min(nw, MAX_RES)))
+    )
+
+def get_duration(*args, **kwargs):
+    # spaces.GPU yêu cầu
+    return 75 if kwargs.get("duration_ui",0) > 7 else 60
+
+@spaces.GPU(duration=get_duration)
+def generate(prompt, neg_prompt,
+             img_path, vid_path,
+             height, width,
+             mode_task, duration_ui, frames_to_use,
+             seed, rand_seed, cfg_scale,
+             improve_tex, device_choice,
+             progress=gr.Progress(track_tqdm=True)):
+    # 1) Chuyển pipeline & upsampler theo lựa chọn
+    dev = "cuda" if device_choice=="GPU" and torch.cuda.is_available() else "cpu"
+    print(f"Chạy trên thiết bị: {dev}")
+    pipeline.to(dev)
+    upsampler.to(dev)
+
+    # 2) Xử seed
+    if rand_seed:
+        seed = random.randint(0, 2**32-1)
+    seed_everething(int(seed))
+
+    # 3) Tính số frame
+    tf = max(1, round(duration_ui*FPS))
+    n8 = round((tf-1)/8)
+    n_frames = max(9, min(n8*8+1, MAX_NUM_FRAMES))
+
+    # 4) Padding kích thước
+    h, w = int(height), int(width)
+    h32 = ((h-1)//32+1)*32
+    w32 = ((w-1)//32+1)*32
+    pad = calculate_padding(h, w, h32, w32)
+
+    # 5) Chuẩn bị kwargs
+    kwargs = {
+        "prompt": prompt,
+        "negative_prompt": neg_prompt,
+        "height": h32,
+        "width": w32,
+        "num_frames": n_frames,
+        "frame_rate": int(FPS),
+        "generator": torch.Generator(device=dev).manual_seed(int(seed)),
+        "output_type": "pt",
+        "decode_timestep": CFG["decode_timestep"],
+        "decode_noise_scale": CFG["decode_noise_scale"],
+        "stochastic_sampling": CFG["stochastic_sampling"],
+        "is_video": True,
+        "vae_per_channel_normalize": True,
+        "mixed_precision": CFG["precision"]=="mixed_precision",
+        "offload_to_cpu": False,
+        "enhance_prompt": False,
+    }
+    # skip strategy
+    stg = CFG.get("stg_mode","attention_values").lower()
+    mapping = {
+        "stg_av":SkipLayerStrategy.AttentionValues,
+        "attention_values":SkipLayerStrategy.AttentionValues,
+        "stg_as":SkipLayerStrategy.AttentionSkip,
+        "attention_skip":SkipLayerStrategy.AttentionSkip,
+        "stg_r":SkipLayerStrategy.Residual,
+        "residual":SkipLayerStrategy.Residual,
+        "stg_t":SkipLayerStrategy.TransformerBlock,
+        "transformer_block":SkipLayerStrategy.TransformerBlock,
+    }
+    kwargs["skip_layer_strategy"] = mapping.get(stg, SkipLayerStrategy.AttentionValues)
+
+    # 6) Conditioning
+    if mode_task=="image-to-video" and img_path:
+        tensor = load_image_to_tensor_with_resize_and_crop(img_path, h, w)
+        tensor = torch.nn.functional.pad(tensor, pad)
+        kwargs["conditioning_items"] = [ConditioningItem(tensor.to(dev),0,1.0)]
+    elif mode_task=="video-to-video" and vid_path:
+        mi = load_media_file(vid_path, h, w, int(frames_to_use), pad).to(dev)
+        kwargs["media_items"] = mi
+
+    # 7) Chọn multi-scale hay single
+    if improve_tex:
+        pipe_ms = LTXMultiScalePipeline(pipeline, upsampler)
+        fp = CFG.get("first_pass",{}).copy()
+        fp["guidance_scale"] = float(cfg_scale)
+        fp.pop("num_inference_steps",None)
+        sp = CFG.get("second_pass",{}).copy()
+        sp["guidance_scale"] = float(cfg_scale)
+        sp.pop("num_inference_steps",None)
+        kwargs.update({
+            "downscale_factor":CFG["downscale_factor"],
+            "first_pass":fp,
+            "second_pass":sp
+        })
+        out = pipe_ms(**kwargs).images
+    else:
+        fp0 = CFG.get("first_pass",{})
+        kwargs.update({
+            "timesteps":fp0.get("timesteps"),
+            "guidance_scale":float(cfg_scale),
+            "stg_scale":fp0.get("stg_scale"),
+            "rescaling_scale":fp0.get("rescaling_scale"),
+            "skip_block_list":fp0.get("skip_block_list")
+        })
+        for k in ["first_pass","second_pass","downscale_factor","num_inference_steps"]:
+            kwargs.pop(k, None)
+        out = pipeline(**kwargs).images
+
+    # 8) Xử kết quả, bỏ padding, lưu video
+    pad_l,pad_r,pad_t,pad_b = pad
+    sh = None if pad_b==0 else -pad_b
+    sw = None if pad_r==0 else -pad_r
+    vid_tensor = out[0][:,:,:n_frames,pad_t:sh,pad_l:sw]
+    arr = vid_tensor.permute(1,2,3,0).cpu().numpy()
+    arr = (np.clip(arr,0,1)*255).astype(np.uint8)
+
+    tmp = tempfile.mkdtemp()
+    dst = os.path.join(tmp, f"out_{random.randint(0,99999)}.mp4")
+    with imageio.get_writer(dst, fps=int(FPS), macro_block_size=1) as w:
+        for i in range(arr.shape[0]):
+            progress(i/arr.shape[0], desc="Lưu video")
+            w.append_data(arr[i])
+    return dst, seed
+
+# --- Giao diện Gradio ---
+css = """
+#col-container {margin:0 auto; max-width:900px;}
+"""
+with gr.Blocks(css=css) as demo:
+    gr.Markdown("## Ứng dụng LTX Video 0.9.7 Distilled")
+    gr.Markdown(
+        "[Mô hình trên HF](https://huggingface.co/LTTEAM/VideoAI) · "
+        "[GitHub](https://github.com/Lightricks/LTX-Video)"
+    )
+
+    with gr.Row():
+        with gr.Column():
+            # Chọn thiết bị
+            device = gr.Radio(["CPU","GPU"], label="Chạy trên thiết bị", value="CPU")
+            # Tabs
+            with gr.Tab("Ảnh→Video"):
+                img_in = gr.Image(label="Ảnh đầu vào", type="filepath", source="upload")
+                prompt1 = gr.Textbox(label="Mô tả", lines=2, value="Con sinh vật di chuyển")
+                btn1 = gr.Button("Tạo từ ảnh")
+            with gr.Tab("Văn bản→Video"):
+                prompt2 = gr.Textbox(label="Mô tả", lines=2, value="Rồng bay trên lâu đài")
+                btn2 = gr.Button("Tạo từ văn bản")
+            with gr.Tab("Video→Video"):
+                vid_in = gr.Video(label="Video đầu vào", source="upload")
+                frames = gr.Slider(label="Số frame dùng", minimum=9, maximum=MAX_NUM_FRAMES, step=8, value=9)
+                prompt3 = gr.Textbox(label="Mô tả", lines=2, value="Chuyển phong cách anime")
+                btn3 = gr.Button("Tạo từ video")
+
+            duration = gr.Slider(label="Thời lượng (giây)", minimum=0.3, maximum=8.5, step=0.1, value=2)
+            improve = gr.Checkbox(label="Cải thiện chi tiết", value=True)
+
+        with gr.Column():
+            out_video = gr.Video(label="Kết quả", interactive=False)
+
+    # Ẩn mode, reuse chung
+    mode = gr.State("image-to-video")
+    # Nút
+    btn1.click(fn=generate,
+               inputs=[prompt1, gr.State(""), img_in, gr.State(""), 
+                       height := gr.State(512), width := gr.State(704),
+                       mode := gr.State("image-to-video"),
+                       duration, frames,
+                       seed := gr.State(42), gr.State(True),
+                       cfg_scale := gr.State(CFG["first_pass"]["guidance_scale"]),
+                       improve, device],
+               outputs=[out_video, seed])
+    btn2.click(fn=generate,
+               inputs=[prompt2, gr.State(""), gr.State(""), gr.State(""), 
+                       height, width,
+                       mode := gr.State("text-to-video"),
+                       duration, frames,
+                       seed, gr.State(True),
+                       cfg_scale,
+                       improve, device],
+               outputs=[out_video, seed])
+    btn3.click(fn=generate,
+               inputs=[prompt3, gr.State(""), gr.State(""), vid_in, 
+                       height, width,
+                       mode := gr.State("video-to-video"),
+                       duration, frames,
+                       seed, gr.State(True),
+                       cfg_scale,
+                       improve, device],
+               outputs=[out_video, seed])
+
+if __name__ == "__main__":
+    demo.queue().launch(debug=True, share=False)