app.py

from diffusers_helper.hf_login import login

import os
import threading
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
import json

os.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))

import gradio as gr
import torch
import traceback
import einops
import safetensors.torch as sf
import numpy as np
import math

# Hugging Face Space環境内かどうか確認
IN_HF_SPACE = os.environ.get('SPACE_ID') is not None

# GPU利用可能性を追跡する変数を追加
GPU_AVAILABLE = False
GPU_INITIALIZED = False
last_update_time = time.time()

# Hugging Face Space内の場合、spacesモジュールをインポート
if IN_HF_SPACE:
    try:
        import spaces
        print("Hugging Face Space環境内で実行中、spacesモジュールをインポートしました")
        
        # GPU利用可能性をチェック
        try:
            GPU_AVAILABLE = torch.cuda.is_available()
            print(f"GPU利用可能: {GPU_AVAILABLE}")
            if GPU_AVAILABLE:
                print(f"GPUデバイス名: {torch.cuda.get_device_name(0)}")
                print(f"GPUメモリ: {torch.cuda.get_device_properties(0).total_memory / 1e9} GB")
                
                # 小規模なGPU操作を試行し、GPUが実際に使用可能か確認
                test_tensor = torch.zeros(1, device='cuda')
                test_tensor = test_tensor + 1
                del test_tensor
                print("GPUテスト操作に成功しました")
            else:
                print("警告: CUDAが利用可能と報告されていますが、GPUデバイスが検出されませんでした")
        except Exception as e:
            GPU_AVAILABLE = False
            print(f"GPU確認中にエラーが発生しました: {e}")
            print("CPUモードで実行します")
    except ImportError:
        print("spacesモジュールのインポートに失敗しました。Hugging Face Space環境外かもしれません")
        GPU_AVAILABLE = torch.cuda.is_available()

from PIL import Image
from diffusers import AutoencoderKLHunyuanVideo
from transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer
from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp
from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete, IN_HF_SPACE as MEMORY_IN_HF_SPACE
from diffusers_helper.thread_utils import AsyncStream, async_run
from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
from transformers import SiglipImageProcessor, SiglipVisionModel
from diffusers_helper.clip_vision import hf_clip_vision_encode
from diffusers_helper.bucket_tools import find_nearest_bucket

outputs_folder = './outputs/'
os.makedirs(outputs_folder, exist_ok=True)

# Spaces環境では、すべてのCUDA操作を遅延させる
if not IN_HF_SPACE:
    # 非Spaces環境でのみCUDAメモリを取得
    try:
        if torch.cuda.is_available():
            free_mem_gb = get_cuda_free_memory_gb(gpu)
            print(f'空きVRAM {free_mem_gb} GB')
        else:
            free_mem_gb = 6.0  # デフォルト値
            print("CUDAが利用できません。デフォルトのメモリ設定を使用します")
    except Exception as e:
        free_mem_gb = 6.0  # デフォルト値
        print(f"CUDAメモリ取得中にエラーが発生しました: {e}、デフォルトのメモリ設定を使用します")
        
    high_vram = free_mem_gb > 60
    print(f'高VRAM モード: {high_vram}')
else:
    # Spaces環境ではデフォルト値を使用
    print("Spaces環境でデフォルトのメモリ設定を使用します")
    try:
        if GPU_AVAILABLE:
            free_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 * 0.9  # GPUメモリの90%を使用
            high_vram = free_mem_gb > 10  # より保守的な条件
        else:
            free_mem_gb = 6.0  # デフォルト値
            high_vram = False
    except Exception as e:
        print(f"GPUメモリ取得中にエラーが発生しました: {e}")
        free_mem_gb = 6.0  # デフォルト値
        high_vram = False
    
    print(f'GPUメモリ: {free_mem_gb:.2f} GB, 高VRAMモード: {high_vram}')

# modelsグローバル変数でモデル参照を保存
models = {}
cpu_fallback_mode = not GPU_AVAILABLE  # GPUが利用できない場合、CPU代替モードを使用

# モデルロード関数を使用
def load_models():
    global models, cpu_fallback_mode, GPU_INITIALIZED
    
    if GPU_INITIALIZED:
        print("モデルはすでに読み込まれています。重複読み込みをスキップします")
        return models
    
    print("モデルの読み込みを開始しています...")
    
    try:
        # GPU利用可能性に基づいてデバイスを設定
        device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
        model_device = 'cpu'  # 初期はCPUに読み込み
        
        # メモリ節約のために精度を下げる
        dtype = torch.float16 if GPU_AVAILABLE else torch.float32
        transformer_dtype = torch.bfloat16 if GPU_AVAILABLE else torch.float32
        
        print(f"使用デバイス: {device}, モデル精度: {dtype}, Transformer精度: {transformer_dtype}")
        
        # モデルを読み込み
        try:
            text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to(model_device)
            text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to(model_device)
            tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
            tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
            vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to(model_device)

            feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
            image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to(model_device)

            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('tori29umai/FramePackI2V_HY_rotate_landscape', torch_dtype=transformer_dtype).to(model_device)
            
            print("すべてのモデルの読み込みに成功しました")
        except Exception as e:
            print(f"モデル読み込み中にエラーが発生しました: {e}")
            print("精度を下げて再試行します...")
            
            # 精度を下げて再試行
            dtype = torch.float32
            transformer_dtype = torch.float32
            cpu_fallback_mode = True
            
            text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to('cpu')
            text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to('cpu')
            tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
            tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
            vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to('cpu')

            feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
            image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to('cpu')

            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('tori29umai/FramePackI2V_HY_rotate_landscape', torch_dtype=transformer_dtype).to('cpu')
            
            print("CPUモードですべてのモデルの読み込みに成功しました")

        vae.eval()
        text_encoder.eval()
        text_encoder_2.eval()
        image_encoder.eval()
        transformer.eval()

        if not high_vram or cpu_fallback_mode:
            vae.enable_slicing()
            vae.enable_tiling()

        transformer.high_quality_fp32_output_for_inference = True
        print('transformer.high_quality_fp32_output_for_inference = True')

        # モデル精度を設定
        if not cpu_fallback_mode:
            transformer.to(dtype=transformer_dtype)
            vae.to(dtype=dtype)
            image_encoder.to(dtype=dtype)
            text_encoder.to(dtype=dtype)
            text_encoder_2.to(dtype=dtype)

        vae.requires_grad_(False)
        text_encoder.requires_grad_(False)
        text_encoder_2.requires_grad_(False)
        image_encoder.requires_grad_(False)
        transformer.requires_grad_(False)

        if torch.cuda.is_available() and not cpu_fallback_mode:
            try:
                if not high_vram:
                    # DynamicSwapInstallerはhuggingfaceのenable_sequential_offloadと同じですが3倍高速です
                    DynamicSwapInstaller.install_model(transformer, device=device)
                    DynamicSwapInstaller.install_model(text_encoder, device=device)
                else:
                    text_encoder.to(device)
                    text_encoder_2.to(device)
                    image_encoder.to(device)
                    vae.to(device)
                    transformer.to(device)
                print(f"モデルを{device}デバイスに移動することに成功しました")
            except Exception as e:
                print(f"モデルを{device}に移動中にエラーが発生しました: {e}")
                print("CPUモードにフォールバックします")
                cpu_fallback_mode = True
        
        # グローバル変数に保存
        models = {
            'text_encoder': text_encoder,
            'text_encoder_2': text_encoder_2,
            'tokenizer': tokenizer,
            'tokenizer_2': tokenizer_2,
            'vae': vae,
            'feature_extractor': feature_extractor,
            'image_encoder': image_encoder,
            'transformer': transformer
        }
        
        GPU_INITIALIZED = True
        print(f"モデルの読み込みが完了しました。実行モード: {'CPU' if cpu_fallback_mode else 'GPU'}")
        return models
    except Exception as e:
        print(f"モデル読み込みプロセスでエラーが発生しました: {e}")
        traceback.print_exc()
        
        # より詳細なエラー情報を記録
        error_info = {
            "error": str(e),
            "traceback": traceback.format_exc(),
            "cuda_available": torch.cuda.is_available(),
            "device": "cpu" if cpu_fallback_mode else "cuda",
        }
        
        # トラブルシューティングのためにエラー情報をファイルに保存
        try:
            with open(os.path.join(outputs_folder, "error_log.txt"), "w") as f:
                f.write(str(error_info))
        except:
            pass
            
        # アプリが引き続き実行を試みることができるよう空の辞書を返す
        cpu_fallback_mode = True
        return {}


# Hugging Face Spaces GPU装飾子を使用
if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE:
    try:
        @spaces.GPU
        def initialize_models():
            """@spaces.GPU装飾子内でモデルを初期化"""
            global GPU_INITIALIZED
            try:
                result = load_models()
                GPU_INITIALIZED = True
                return result
            except Exception as e:
                print(f"spaces.GPUを使用したモデル初期化中にエラーが発生しました: {e}")
                traceback.print_exc()
                global cpu_fallback_mode
                cpu_fallback_mode = True
                # 装飾子を使わずに再試行
                return load_models()
    except Exception as e:
        print(f"spaces.GPU装飾子の作成中にエラーが発生しました: {e}")
        # 装飾子がエラーの場合、非装飾子版を直接使用
        def initialize_models():
            return load_models()


# 以下の関数内部でモデルの取得を遅延させる
def get_models():
    """モデルを取得し、まだ読み込まれていない場合は読み込む"""
    global models, GPU_INITIALIZED
    
    # 並行読み込みを防ぐためのモデル読み込みロックを追加
    model_loading_key = "__model_loading__"
    
    if not models:
        # モデルが読み込み中かチェック
        if model_loading_key in globals():
            print("モデルは現在読み込み中です。お待ちください...")
            # モデル読み込み完了を待機
            import time
            start_wait = time.time()
            while not models and model_loading_key in globals():
                time.sleep(0.5)
                # 60秒以上待機したら読み込み失敗と判断
                if time.time() - start_wait > 60:
                    print("モデル読み込み待機がタイムアウトしました")
                    break
            
            if models:
                return models
            
        try:
            # 読み込みフラグを設定
            globals()[model_loading_key] = True
            
            if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE and not cpu_fallback_mode:
                try:
                    print("@spaces.GPU装飾子を使用してモデルを読み込みます")
                    models = initialize_models()
                except Exception as e:
                    print(f"GPU装飾子を使用したモデル読み込みに失敗しました: {e}")
                    print("直接モデルを読み込みます")
                    models = load_models()
            else:
                print("モデルを直接読み込みます")
                models = load_models()
        except Exception as e:
            print(f"モデル読み込み中に予期しないエラーが発生しました: {e}")
            traceback.print_exc()
            # 空の辞書を確保
            models = {}
        finally:
            # 成功か失敗にかかわらず、読み込みフラグを削除
            if model_loading_key in globals():
                del globals()[model_loading_key]
    
    return models


# 事前定義された解像度リスト（グローバル変数として追加）
PREDEFINED_RESOLUTIONS = [
    (416, 960), (448, 864), (480, 832), (512, 768), (544, 704), 
    (576, 672), (608, 640), (640, 608), (672, 576), (704, 544), 
    (768, 512), (832, 480), (864, 448), (960, 416)
]

# 最も近いアスペクト比を見つける関数
def find_closest_aspect_ratio(width, height, target_resolutions):
    """
    事前定義された解像度リストから、元の画像のアスペクト比に最も近い解像度を見つける
    
    引数:
        width: 元の画像の幅
        height: 元の画像の高さ
        target_resolutions: 目標解像度のリスト（幅, 高さ）のタプル
        
    戻り値:
        tuple: 最も近いアスペクト比の (target_width, target_height)
    """
    original_aspect = width / height
    
    # 各目標解像度に対してアスペクト比の差を計算
    min_diff = float('inf')
    closest_resolution = None
    
    for target_width, target_height in target_resolutions:
        target_aspect = target_width / target_height
        diff = abs(original_aspect - target_aspect)
        
        if diff < min_diff:
            min_diff = diff
            closest_resolution = (target_width, target_height)
    
    return closest_resolution


stream = AsyncStream()


@torch.no_grad()
def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
    global last_update_time
    last_update_time = time.time()
    
    # 動画の長さを5秒以下に制限
    total_second_length = min(total_second_length, 3.0)
    
    # モデルを取得
    try:
        models = get_models()
        if not models:
            error_msg = "モデルの読み込みに失敗しました。詳細情報はログを確認してください"
            print(error_msg)
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return
        
        text_encoder = models['text_encoder']
        text_encoder_2 = models['text_encoder_2']
        tokenizer = models['tokenizer']
        tokenizer_2 = models['tokenizer_2']
        vae = models['vae']
        feature_extractor = models['feature_extractor']
        image_encoder = models['image_encoder']
        transformer = models['transformer']
    except Exception as e:
        error_msg = f"モデル取得中にエラーが発生しました: {e}"
        print(error_msg)
        traceback.print_exc()
        stream.output_queue.push(('error', error_msg))
        stream.output_queue.push(('end', None))
        return
    
    # デバイスを決定
    device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
    print(f"推論に使用するデバイス: {device}")
    
    # CPUモードに合わせてパラメータを調整
    if cpu_fallback_mode:
        print("CPUモードではより軽量なパラメータを使用します")
        # CPU処理を高速化するために処理サイズを小さくする
        latent_window_size = min(latent_window_size, 5)
        steps = min(steps, 15)  # ステップ数を減らす
        total_second_length = min(total_second_length, 2.0)  # CPUモードでは動画の長さをさらに制限
    
    total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)
    total_latent_sections = int(max(round(total_latent_sections), 1))

    job_id = generate_timestamp()
    last_output_filename = None
    history_pixels = None
    history_latents = None
    total_generated_latent_frames = 0

    stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, '開始中 ...'))))

    try:
        # GPUをクリーン
        if not high_vram and not cpu_fallback_mode:
            try:
                unload_complete_models(
                    text_encoder, text_encoder_2, image_encoder, vae, transformer
                )
            except Exception as e:
                print(f"モデルのアンロード中にエラーが発生しました: {e}")
                # 処理を中断せずに続行

        # テキストエンコーディング
        last_update_time = time.time()
        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'テキストエンコーディング中 ...'))))

        try:
            if not high_vram and not cpu_fallback_mode:
                fake_diffusers_current_device(text_encoder, device)
                load_model_as_complete(text_encoder_2, target_device=device)

            llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)

            if cfg == 1:
                llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
            else:
                llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)

            llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
            llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
        except Exception as e:
            error_msg = f"テキストエンコーディング中にエラーが発生しました: {e}"
            print(error_msg)
            traceback.print_exc()
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return

        # 入力画像の処理
        try:
            H, W, C = input_image.shape
            
            # 事前定義された解像度から最も近いアスペクト比を見つける
            target_width, target_height = find_closest_aspect_ratio(W, H, PREDEFINED_RESOLUTIONS)
            
            # height, width変数も保持する（元のコードとの互換性のため）
            width = target_width
            height = target_height
            
            # CPUモードの場合、処理サイズを小さくする
            if cpu_fallback_mode:
                scale_factor = min(320 / target_height, 320 / target_width)
                target_height = int(target_height * scale_factor)
                target_width = int(target_width * scale_factor)
                # 縮小後の値も更新
                height = target_height
                width = target_width
                
            print(f'元の画像サイズ: {W}x{H}, リサイズ先: {target_width}x{target_height}')
            
            # 選択された解像度にリサイズ
            input_image_np = resize_and_center_crop(input_image, target_width=target_width, target_height=target_height)
            Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))

            input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
            input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
        except Exception as e:
            error_msg = f"画像処理中にエラーが発生しました: {e}"
            print(error_msg)
            traceback.print_exc()
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return

        # VAEエンコーディング
        last_update_time = time.time()
        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAEエンコーディング中 ...'))))

        try:
            if not high_vram and not cpu_fallback_mode:
                load_model_as_complete(vae, target_device=device)

            start_latent = vae_encode(input_image_pt, vae)
        except Exception as e:
            error_msg = f"VAEエンコーディング中にエラーが発生しました: {e}"
            print(error_msg)
            traceback.print_exc()
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return

        # CLIP Vision
        last_update_time = time.time()
        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Visionエンコーディング中 ...'))))

        try:
            if not high_vram and not cpu_fallback_mode:
                load_model_as_complete(image_encoder, target_device=device)

            image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
            image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
        except Exception as e:
            error_msg = f"CLIP Visionエンコーディング中にエラーが発生しました: {e}"
            print(error_msg)
            traceback.print_exc()
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return

        # データ型
        try:
            llama_vec = llama_vec.to(transformer.dtype)
            llama_vec_n = llama_vec_n.to(transformer.dtype)
            clip_l_pooler = clip_l_pooler.to(transformer.dtype)
            clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
            image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
        except Exception as e:
            error_msg = f"データ型変換中にエラーが発生しました: {e}"
            print(error_msg)
            traceback.print_exc()
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return

        # サンプリング
        last_update_time = time.time()
        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'サンプリング開始 ...'))))

        rnd = torch.Generator("cpu").manual_seed(seed)
        num_frames = latent_window_size * 4 - 3

        try:
            history_latents = torch.zeros(size=(1, 16, 1 + 2 + 16, height // 8, width // 8), dtype=torch.float32).cpu()
            history_pixels = None
            total_generated_latent_frames = 0
        except Exception as e:
            error_msg = f"履歴状態の初期化中にエラーが発生しました: {e}"
            print(error_msg)
            traceback.print_exc()
            stream.output_queue.push(('error', error_msg))
            stream.output_queue.push(('end', None))
            return

        latent_paddings = reversed(range(total_latent_sections))

        if total_latent_sections > 4:
            # 理論的にはlatent_paddingsは上記のシーケンスに従うべきですが、
            # total_latent_sections > 4の場合、展開するよりもいくつかの項目を複製する方が
            # 良い結果になるようです
            # 比較するために、latent_paddings = list(reversed(range(total_latent_sections)))を
            # 使用して下記のトリックを削除することもできます
            latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]

        for latent_padding in latent_paddings:
            last_update_time = time.time()
            is_last_section = latent_padding == 0
            latent_padding_size = latent_padding * latent_window_size

            if stream.input_queue.top() == 'end':
                # 終了時に現在の動画を保存することを確認
                if history_pixels is not None and total_generated_latent_frames > 0:
                    try:
                        output_filename = os.path.join(outputs_folder, f'{job_id}_final_{total_generated_latent_frames}.mp4')
                        save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=18)
                        stream.output_queue.push(('file', output_filename))
                    except Exception as e:
                        print(f"最終動画保存中にエラーが発生しました: {e}")
                
                stream.output_queue.push(('end', None))
                return

            print(f'latent_padding_size = {latent_padding_size}, is_last_section = {is_last_section}')

            try:
                indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
                clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
                clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)

                clean_latents_pre = start_latent.to(history_latents)
                clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16, :, :].split([1, 2, 16], dim=2)
                clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)
            except Exception as e:
                error_msg = f"サンプリングデータ準備中にエラーが発生しました: {e}"
                print(error_msg)
                traceback.print_exc()
                # 完全に終了せずに次のイテレーションを試みる
                if last_output_filename:
                    stream.output_queue.push(('file', last_output_filename))
                continue

            if not high_vram and not cpu_fallback_mode:
                try:
                    unload_complete_models()
                    move_model_to_device_with_memory_preservation(transformer, target_device=device, preserved_memory_gb=gpu_memory_preservation)
                except Exception as e:
                    print(f"transformerをGPUに移動中にエラーが発生しました: {e}")
                    # パフォーマンスに影響する可能性はありますが、終了する必要はないので続行

            if use_teacache and not cpu_fallback_mode:
                try:
                    transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
                except Exception as e:
                    print(f"teacache初期化中にエラーが発生しました: {e}")
                    # teacacheを無効にして続行
                    transformer.initialize_teacache(enable_teacache=False)
            else:
                transformer.initialize_teacache(enable_teacache=False)

            def callback(d):
                global last_update_time
                last_update_time = time.time()
                
                try:
                    # まず停止信号があるかチェック
                    print(f"【デバッグ】コールバック関数: ステップ {d['i']}, 停止信号のチェック")
                    try:
                        queue_top = stream.input_queue.top()
                        print(f"【デバッグ】コールバック関数: キュー先頭信号 = {queue_top}")
                        
                        if queue_top == 'end':
                            print("【デバッグ】コールバック関数: 停止信号を検出、中断準備中...")
                            try:
                                stream.output_queue.push(('end', None))
                                print("【デバッグ】コールバック関数: 出力キューにend信号を正常に送信")
                            except Exception as e:
                                print(f"【デバッグ】コールバック関数: 出力キューにend信号送信中にエラー: {e}")
                                
                            print("【デバッグ】コールバック関数: KeyboardInterrupt例外を投げる準備")
                            raise KeyboardInterrupt('ユーザーによるタスク停止')
                    except Exception as e:
                        print(f"【デバッグ】コールバック関数: キュー先頭信号チェック中にエラー: {e}")
                        
                    preview = d['denoised']
                    preview = vae_decode_fake(preview)

                    preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)
                    preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')

                    current_step = d['i'] + 1
                    percentage = int(100.0 * current_step / steps)
                    hint = f'サンプリング中 {current_step}/{steps}'
                    desc = f'総生成フレーム数: {int(max(0, total_generated_latent_frames * 4 - 3))}, 動画長: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} 秒 (FPS-30). 動画を現在拡張中...'
                    stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
                except KeyboardInterrupt as e:
                    # 中断例外をキャッチして再スローし、サンプリング関数に伝播されるようにする
                    print(f"【デバッグ】コールバック関数: KeyboardInterruptをキャッチ: {e}")
                    print("【デバッグ】コールバック関数: 中断例外を再スロー、サンプリング関数に伝播")
                    raise
                except Exception as e:
                    print(f"【デバッグ】コールバック関数でエラー: {e}")
                    # サンプリングプロセスを中断しない
                print(f"【デバッグ】コールバック関数: ステップ {d['i']} 完了")
                return

            try:
                sampling_start_time = time.time()
                print(f"サンプリング開始、デバイス: {device}, データ型: {transformer.dtype}, TeaCache使用: {use_teacache and not cpu_fallback_mode}")
                
                try:
                    print("【デバッグ】sample_hunyuanサンプリングプロセス開始")
                    generated_latents = sample_hunyuan(
                        transformer=transformer,
                        sampler='unipc',
                        width=width,
                        height=height,
                        frames=num_frames,
                        real_guidance_scale=cfg,
                        distilled_guidance_scale=gs,
                        guidance_rescale=rs,
                        # shift=3.0,
                        num_inference_steps=steps,
                        generator=rnd,
                        prompt_embeds=llama_vec,
                        prompt_embeds_mask=llama_attention_mask,
                        prompt_poolers=clip_l_pooler,
                        negative_prompt_embeds=llama_vec_n,
                        negative_prompt_embeds_mask=llama_attention_mask_n,
                        negative_prompt_poolers=clip_l_pooler_n,
                        device=device,
                        dtype=transformer.dtype,
                        image_embeddings=image_encoder_last_hidden_state,
                        latent_indices=latent_indices,
                        clean_latents=clean_latents,
                        clean_latent_indices=clean_latent_indices,
                        clean_latents_2x=clean_latents_2x,
                        clean_latent_2x_indices=clean_latent_2x_indices,
                        clean_latents_4x=clean_latents_4x,
                        clean_latent_4x_indices=clean_latent_4x_indices,
                        callback=callback,
                    )
                    
                    print(f"【デバッグ】サンプリング完了、所要時間: {time.time() - sampling_start_time:.2f}秒")
                except KeyboardInterrupt as e:
                    # ユーザーによる中断
                    print(f"【デバッグ】KeyboardInterruptをキャッチ: {e}")
                    print("【デバッグ】ユーザーによるサンプリングプロセス中断、中断ロジック処理中")
                    
                    # 既に生成された動画がある場合、最後に生成された動画を返す
                    if last_output_filename:
                        print(f"【デバッグ】部分的に生成された動画あり: {last_output_filename}、この動画を返します")
                        stream.output_queue.push(('file', last_output_filename))
                        error_msg = "ユーザーにより生成プロセスが中断されましたが、部分的な動画は生成されています"
                    else:
                        print("【デバッグ】部分的に生成された動画なし、中断メッセージを返します")
                        error_msg = "ユーザーにより生成プロセスが中断され、動画は生成されていません"
                    
                    print(f"【デバッグ】エラーメッセージを送信: {error_msg}")
                    stream.output_queue.push(('error', error_msg))
                    print("【デバッグ】end信号を送信")
                    stream.output_queue.push(('end', None))
                    print("【デバッグ】中断処理完了、リターン")
                    return
            except Exception as e:
                print(f"サンプリングプロセス中にエラーが発生しました: {e}")
                traceback.print_exc()
                
                # 既に生成された動画がある場合、最後に生成された動画を返す
                if last_output_filename:
                    stream.output_queue.push(('file', last_output_filename))
                    
                    # エラーメッセージを作成
                    error_msg = f"サンプリングプロセス中にエラーが発生しましたが、部分的に生成された動画を返します: {e}"
                    stream.output_queue.push(('error', error_msg))
                else:
                    # 生成された動画がない場合、エラーメッセージを返す
                    error_msg = f"サンプリングプロセス中にエラーが発生し、動画を生成できませんでした: {e}"
                    stream.output_queue.push(('error', error_msg))
                
                stream.output_queue.push(('end', None))
                return

            try:
                if is_last_section:
                    generated_latents = torch.cat([start_latent.to(generated_latents), generated_latents], dim=2)

                total_generated_latent_frames += int(generated_latents.shape[2])
                history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2)
            except Exception as e:
                error_msg = f"生成された潜在変数の処理中にエラーが発生しました: {e}"
                print(error_msg)
                traceback.print_exc()
                
                if last_output_filename:
                    stream.output_queue.push(('file', last_output_filename))
                stream.output_queue.push(('error', error_msg))
                stream.output_queue.push(('end', None))
                return

            if not high_vram and not cpu_fallback_mode:
                try:
                    offload_model_from_device_for_memory_preservation(transformer, target_device=device, preserved_memory_gb=8)
                    load_model_as_complete(vae, target_device=device)
                except Exception as e:
                    print(f"モデルメモリ管理中にエラーが発生しました: {e}")
                    # 続行

            try:
                real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]
            except Exception as e:
                error_msg = f"履歴潜在変数の処理中にエラーが発生しました: {e}"
                print(error_msg)
                
                if last_output_filename:
                    stream.output_queue.push(('file', last_output_filename))
                continue

            try:
                vae_start_time = time.time()
                print(f"VAEデコード開始、潜在変数形状: {real_history_latents.shape}")
                
                if history_pixels is None:
                    history_pixels = vae_decode(real_history_latents, vae).cpu()
                else:
                    section_latent_frames = (latent_window_size * 2 + 1) if is_last_section else (latent_window_size * 2)
                    overlapped_frames = latent_window_size * 4 - 3

                    current_pixels = vae_decode(real_history_latents[:, :, :section_latent_frames], vae).cpu()
                    history_pixels = soft_append_bcthw(current_pixels, history_pixels, overlapped_frames)

                print(f"VAEデコード完了、所要時間: {time.time() - vae_start_time:.2f}秒")
                
                if not high_vram and not cpu_fallback_mode:
                    try:
                        unload_complete_models()
                    except Exception as e:
                        print(f"モデルのアンロード中にエラーが発生しました: {e}")

                output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')

                save_start_time = time.time()
                save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=18)
                print(f"動画保存完了、所要時間: {time.time() - save_start_time:.2f}秒")

                print(f'デコード完了。現在の潜在変数形状 {real_history_latents.shape}; ピクセル形状 {history_pixels.shape}')

                last_output_filename = output_filename
                stream.output_queue.push(('file', output_filename))
            except Exception as e:
                print(f"動画のデコードまたは保存中にエラーが発生しました: {e}")
                traceback.print_exc()
                
                # 既に生成された動画がある場合、最後に生成された動画を返す
                if last_output_filename:
                    stream.output_queue.push(('file', last_output_filename))
                
                # エラー情報を記録
                error_msg = f"動画のデコードまたは保存中にエラーが発生しました: {e}"
                stream.output_queue.push(('error', error_msg))
                
                # 次のイテレーションを試みる
                continue

            if is_last_section:
                break
    except Exception as e:
        print(f"【デバッグ】処理中にエラーが発生しました: {e}, タイプ: {type(e)}")
        print(f"【デバッグ】エラー詳細:")
        traceback.print_exc()
        
        # 中断型例外かチェック
        if isinstance(e, KeyboardInterrupt):
            print("【デバッグ】外部KeyboardInterrupt例外を検出")

        if not high_vram and not cpu_fallback_mode:
            try:
                print("【デバッグ】リソース解放のためモデルをアンロード")
                unload_complete_models(
                    text_encoder, text_encoder_2, image_encoder, vae, transformer
                )
                print("【デバッグ】モデルのアンロードに成功")
            except Exception as unload_error:
                print(f"【デバッグ】モデルのアンロード中にエラー: {unload_error}")
                pass
        
        # 既に生成された動画がある場合、最後に生成された動画を返す
        if last_output_filename:
            print(f"【デバッグ】外部例外処理: 生成済み部分動画を返す {last_output_filename}")
            stream.output_queue.push(('file', last_output_filename))
        else:
            print("【デバッグ】外部例外処理: 生成済み動画が見つかりません")
        
        # エラーメッセージを返す
        error_msg = f"処理中にエラーが発生しました: {e}"
        print(f"【デバッグ】外部例外処理: エラーメッセージを送信: {error_msg}")
        stream.output_queue.push(('error', error_msg))

    # 常にend信号を返すことを確認
    print("【デバッグ】ワーカー関数終了、end信号を送信")
    stream.output_queue.push(('end', None))
    return


# Hugging Face Spaces GPU装飾子を使用してプロセス関数を処理
if IN_HF_SPACE and 'spaces' in globals():
    @spaces.GPU
    def process_with_gpu(input_image, prompt, n_prompt, seed, total_second_length, use_teacache):
        global stream
        assert input_image is not None, '入力画像がありません！'

        latent_window_size = 9
        steps = 25
        cfg = 1.0
        gs = 10.0
        rs = 0.0
        gpu_memory_preservation = 6


        # UI状態の初期化
        yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)

        try:
            stream = AsyncStream()

            # ワーカーを非同期で起動
            async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)

            output_filename = None
            prev_output_filename = None
            error_message = None

            # ワーカーの出力を継続的にチェック
            while True:
                try:
                    flag, data = stream.output_queue.next()

                    if flag == 'file':
                        output_filename = data
                        prev_output_filename = output_filename
                        # ファイル成功時にエラー表示をクリア
                        yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)

                    if flag == 'progress':
                        preview, desc, html = data
                        # 進捗更新時にエラーメッセージを変更せず、停止ボタンがインタラクティブであることを確認
                        yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
                    
                    if flag == 'error':
                        error_message = data
                        print(f"エラーメッセージを受信: {error_message}")
                        # 即時表示せず、end信号を待機

                    if flag == 'end':
                        # 最後の動画ファイルがある場合、確実に返す
                        if output_filename is None and prev_output_filename is not None:
                            output_filename = prev_output_filename
                        
                        # エラーメッセージがある場合、わかりやすいエラー表示を作成
                        if error_message:
                            yield output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                        else:
                            # 成功時にエラー表示をしない
                            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
                        break
                except Exception as e:
                    print(f"出力処理中にエラーが発生しました: {e}")
                    # 長時間更新がないか確認
                    current_time = time.time()
                    if current_time - last_update_time > 60:  # 60秒間更新がない場合、処理がフリーズした可能性
                        print(f"処理がフリーズした可能性があります。{current_time - last_update_time:.1f}秒間更新がありません")
                        
                        # 部分的に生成された動画がある場合、それを返す
                        if prev_output_filename:
                            yield prev_output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                        else:
                            yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                        break
                    
        except Exception as e:
            print(f"処理の開始中にエラーが発生しました: {e}")
            traceback.print_exc()
            error_msg = str(e)
            
            yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
    
    process = process_with_gpu
else:
    def process(input_image, prompt, n_prompt, seed, total_second_length, use_teacache):
        global stream
        assert input_image is not None, '入力画像がありません！'

        latent_window_size = 9
        steps = 25
        cfg = 1.0
        gs = 10.0
        rs = 0.0
        gpu_memory_preservation = 6

        # UI状態の初期化
        yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)

        try:
            stream = AsyncStream()

            # ワーカーを非同期で起動
            async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)

            output_filename = None
            prev_output_filename = None
            error_message = None

            # ワーカーの出力を継続的にチェック
            while True:
                try:
                    flag, data = stream.output_queue.next()

                    if flag == 'file':
                        output_filename = data
                        prev_output_filename = output_filename
                        # ファイル成功時にエラー表示をクリア
                        yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)

                    if flag == 'progress':
                        preview, desc, html = data
                        # 進捗更新時にエラーメッセージを変更せず、停止ボタンがインタラクティブであることを確認
                        yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
                    
                    if flag == 'error':
                        error_message = data
                        print(f"エラーメッセージを受信: {error_message}")
                        # 即時表示せず、end信号を待機

                    if flag == 'end':
                        # 最後の動画ファイルがある場合、確実に返す
                        if output_filename is None and prev_output_filename is not None:
                            output_filename = prev_output_filename
                        
                        # エラーメッセージがある場合、わかりやすいエラー表示を作成
                        if error_message:
                            yield output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                        else:
                            # 成功時にエラー表示をしない
                            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
                        break
                except Exception as e:
                    print(f"出力処理中にエラーが発生しました: {e}")
                    # 長時間更新がないか確認
                    current_time = time.time()
                    if current_time - last_update_time > 60:  # 60秒間更新がない場合、処理がフリーズした可能性
                        print(f"処理がフリーズした可能性があります。{current_time - last_update_time:.1f}秒間更新がありません")
                        
                        # 部分的に生成された動画がある場合、それを返す
                        if prev_output_filename:
                            yield prev_output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                        else:
                            yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                        break
                    
        except Exception as e:
            print(f"処理の開始中にエラーが発生しました: {e}")
            traceback.print_exc()
            error_msg = str(e)
            
            yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
    

def end_process():
    """生成プロセスを停止する関数 - キューに'end'信号を送信して生成を中断します"""
    print("【デバッグ】ユーザーが停止ボタンをクリックしました。停止信号を送信中...")
    # streamが初期化されていることを確認
    if 'stream' in globals() and stream is not None:
        # 送信前にキューの状態を確認
        try:
            current_top = stream.input_queue.top()
            print(f"【デバッグ】現在のキュー先頭信号: {current_top}")
        except Exception as e:
            print(f"【デバッグ】キュー状態確認中にエラー: {e}")
            
        # end信号を送信
        try:
            stream.input_queue.push('end')
            print("【デバッグ】キューにend信号を正常に送信しました")
            
            # 信号が正常に送信されたか確認
            try:
                current_top_after = stream.input_queue.top()
                print(f"【デバッグ】送信後のキュー先頭信号: {current_top_after}")
            except Exception as e:
                print(f"【デバッグ】送信後のキュー状態確認中にエラー: {e}")
                
        except Exception as e:
            print(f"【デバッグ】キューへのend信号送信に失敗: {e}")
    else:
        print("【デバッグ】警告: streamが初期化されていないため、停止信号を送信できません")
    return None


quick_prompts = [
    'The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view',
]
quick_prompts = [[x] for x in quick_prompts]


# カスタムCSSを作成し、レスポンシブレイアウトのサポートを追加
def make_custom_css():
    progress_bar_css = make_progress_bar_css()
    
    responsive_css = """
    /* 基本レスポンシブ設定 */
    #app-container {
        max-width: 100%;
        margin: 0 auto;
    }
    
    
    /* ページタイトルのスタイル */
    h1 {
        font-size: 2rem;
        text-align: center;
        margin-bottom: 1rem;
    }
    
    /* ボタンのスタイル */
    .start-btn, .stop-btn {
        min-height: 45px;
        font-size: 1rem;
    }
    
    /* モバイルデバイスのスタイル - 小画面 */
    @media (max-width: 768px) {
        h1 {
            font-size: 1.5rem;
            margin-bottom: 0.5rem;
        }
        
        /* 単一カラムレイアウト */
        .mobile-full-width {
            flex-direction: column !important;
        }
        
        .mobile-full-width > .gr-block {
            min-width: 100% !important;
            flex-grow: 1;
        }
        
        /* 動画サイズの調整 */
        .video-container {
            height: auto !important;
        }
        
        /* ボタンサイズの調整 */
        .button-container button {
            min-height: 50px;
            font-size: 1rem;
            touch-action: manipulation;
        }
        
        /* スライダーの調整 */
        .slider-container input[type="range"] {
            height: 30px;
        }
    }
    
    /* タブレットデバイスのスタイル */
    @media (min-width: 769px) and (max-width: 1024px) {
        .tablet-adjust {
            width: 48% !important;
        }
    }
    
    /* ダークモードサポート */
    @media (prefers-color-scheme: dark) {
        .dark-mode-text {
            color: #f0f0f0;
        }
        
        .dark-mode-bg {
            background-color: #2a2a2a;
        }
    }
    
    /* アクセシビリティの向上 */
    button, input, select, textarea {
        font-size: 16px; /* iOSでの拡大を防止 */
    }
    
    /* タッチ操作の最適化 */
    button, .interactive-element {
        min-height: 44px;
        min-width: 44px;
    }
    
    /* コントラストの向上 */
    .high-contrast {
        color: #fff;
        background-color: #000;
    }
    
    /* プログレスバーのスタイル強化 */
    .progress-container {
        margin-top: 10px;
        margin-bottom: 10px;
    }
    
    /* エラーメッセージのスタイル */
    #error-message {
        color: #ff4444;
        font-weight: bold;
        padding: 10px;
        border-radius: 4px;
        margin-top: 10px;
    }
    
    /* エラーコンテナの正しい表示 */
    .error-message {
        background-color: rgba(255, 0, 0, 0.1);
        padding: 10px;
        border-radius: 4px;
        margin-top: 10px;
        border: 1px solid #ffcccc;
    }
    
    /* 多言語エラーメッセージの処理 */
    .error-msg-en, .error-msg-ja {
        font-weight: bold;
    }
    
    /* エラーアイコン */
    .error-icon {
        color: #ff4444;
        font-size: 18px;
        margin-right: 8px;
    }
    
    /* 空のエラーメッセージが背景とボーダーを表示しないことを確認 */
    #error-message:empty {
        background-color: transparent;
        border: none;
        padding: 0;
        margin: 0;
    }
    
    /* Gradioのデフォルトエラー表示の修正 */
    .error {
        display: none !important;
    }
    """
    
    # CSSを結合
    combined_css = progress_bar_css + responsive_css
    return combined_css


css = make_custom_css()
block = gr.Blocks(css=css).queue()
with block:
    gr.HTML("<h1 ='title'>FramePack_rotate_landscape - 風景画像回転動画生成</h1>")
    
    # mobile-full-widthクラスを持つレスポンシブ行を使用
    with gr.Row(elem_classes="mobile-full-width"):
        with gr.Column(scale=1, elem_classes="mobile-full-width"):
            # 二言語ラベルを追加 - 画像アップロード
            input_image = gr.Image(
                sources='upload', 
                type="numpy", 
                label="画像をアップロード / Upload Image", 
                elem_id="input-image",
                height=320
            )
            
            prompt = gr.Textbox(
                label="プロンプト / Prompt", 
                value='The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view',
                elem_id="prompt-input"
            )
            
            example_quick_prompts = gr.Dataset(
                samples=quick_prompts, 
                label='クイックプロンプト一覧 / Quick Prompts', 
                samples_per_page=1000, 
                components=[prompt]
            )
            example_quick_prompts.click(lambda x: x[0], inputs=[example_quick_prompts], outputs=prompt, show_progress=False, queue=False)

            # スタイルと二言語ラベルを追加したボタン
            with gr.Row(elem_classes="button-container"):
                start_button = gr.Button(
                    value="生成開始 / Generate", 
                    elem_classes="start-btn", 
                    elem_id="start-button",
                    variant="primary"
                )
                
                end_button = gr.Button(
                    value="停止 / Stop", 
                    elem_classes="stop-btn", 
                    elem_id="stop-button",
                    interactive=False
                )

            # パラメータ設定エリア
            with gr.Group():
                use_teacache = gr.Checkbox(
                    label='TeaCacheを使用 / Use TeaCache', 
                    value=True, 
                    info='処理速度が速くなりますが、指や手の生成品質が若干低下する可能性があります。 / Faster speed, but may result in slightly worse finger and hand generation.'
                )

                n_prompt = gr.Textbox(label="ネガティブプロンプト / Negative Prompt", value="", visible=False)  # 使用しない
                
                seed = gr.Number(
                    label="シード値 / Seed", 
                    value=31337, 
                    precision=0
                )

                # タッチ操作を最適化するためにslider-containerクラスを追加
                with gr.Group(elem_classes="slider-container"):
                    total_second_length = gr.Slider(
                        label="動画の長さ（最大3秒） / Video Length (max 3 seconds)", 
                        minimum=0.5, 
                        maximum=3, 
                        value=1, 
                        step=0.1
                    )
                    
        # 右側のプレビューと結果カラム
        with gr.Column(scale=1, elem_classes="mobile-full-width"):
            # プレビュー画像
            preview_image = gr.Image(
                label="プレビュー / Preview", 
                height=200, 
                visible=False,
                elem_classes="preview-container"
            )
            
            # 動画結果コンテナ
            result_video = gr.Video(
                label="生成された動画 / Generated Video", 
                autoplay=True, 
                show_share_button=True,  # 共有ボタンを追加
                height=512, 
                loop=True,
                elem_classes="video-container",
                elem_id="result-video"
            )
            
            gr.HTML("<div ='sampling_note' class='note'>注意：逆順サンプリングのため、終了動作が開始動作より先に生成されます。開始動作が動画に表示されていない場合は、しばらくお待ちください。後で生成されます。</div>")
            gr.HTML("<div ='sampling_note' class='note'>Note that the ending actions will be generated before the starting actions due to the inverted sampling. If the starting action is not in the video, you just need to wait, and it will be generated later.</div>")

            # 進捗インジケーター
            with gr.Group(elem_classes="progress-container"):
                progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
                progress_bar = gr.HTML('', elem_classes='no-generating-animation')
            
            # エラーメッセージエリア - カスタムエラーメッセージ形式をサポートするHTMLコンポーネントを使用
            error_message = gr.HTML('', elem_id='error-message', visible=True)
    
    # 処理関数
    ips = [input_image, prompt, n_prompt, seed, total_second_length, use_teacache]
    
    # 開始と終了ボタンのイベント
    start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])
    end_button.click(fn=end_process)


block.launch()