Upload run_generator.py

run_generator.py

@@ -0,0 +1,424 @@
+import sys
+import os
+import time
+import glob
+import gc
+import torch
+import subprocess
+import random
+import argparse
+from typing import Sequence, Mapping, Any, Union
+import shutil
+
+# --- 0. 기본 설정 및 인수 파싱 ---
+def parse_args():
+    parser = argparse.ArgumentParser(description="ComfyUI Video Generation Script with All Controls from 1.py")
+    parser.add_argument("--positive_prompt", type=str, required=True); parser.add_argument("--negative_prompt", type=str, required=True)
+    parser.add_argument("--width", type=int, required=True); parser.add_argument("--height", type=int, required=True)
+    parser.add_argument("--length", type=int, required=True); parser.add_argument("--upscale_ratio", type=float, required=True)
+    parser.add_argument("--steps", type=int, default=4)
+    parser.add_argument("--cfg_high", type=float, default=1.0); parser.add_argument("--cfg_low", type=float, default=1.0)
+    parser.add_argument("--sampler_name_high", type=str, default="euler"); parser.add_argument("--scheduler_high", type=str, default="simple")
+    parser.add_argument("--sampler_name_low", type=str, default="euler"); parser.add_argument("--scheduler_low", type=str, default="simple")
+    parser.add_argument("--noise_seed", type=int, default=-1); parser.add_argument("--split_point_percent", type=float, default=50.0)
+    parser.add_argument("--shift", type=float, default=8.0); parser.add_argument("--sageattention", type=str, default="on")
+    parser.add_argument("--unet_high_name", type=str, required=True); parser.add_argument("--unet_low_name", type=str, required=True)
+    parser.add_argument("--vae_name", type=str, required=True); parser.add_argument("--clip_name", type=str, required=True)
+
+    # VAE (KJ) 로더를 위한 인자 추가
+    parser.add_argument("--vae_weight_dtype", type=str, default="bf16")
+    parser.add_argument("--vae_device", type=str, default="main_device")
+
+    parser.add_argument("--upscale_model_name", type=str, default="None")
+    parser.add_argument("--upscale_model_scale", type=float, default=2.0)
+    parser.add_argument("--upscale_chunk_size", type=int, default=30)
+    parser.add_argument("--frame_rate", type=int, default=16); parser.add_argument("--interpolation", type=str, default="on")
+    parser.add_argument("--rife_fast_mode", type=str, default="on"); parser.add_argument("--rife_ensemble", type=str, default="on")
+    parser.add_argument("--rife_chunk_size", type=int, default=30)
+    parser.add_argument("--connect_lora_clip", type=str, default="off")
+    parser.add_argument("--video_encoder", type=str, default="GPU: HEVC (NVENC)"); parser.add_argument("--nvenc_cq", type=int, default=25); parser.add_argument("--nvenc_preset", type=str, default="p5"); parser.add_argument("--cpu_crf", type=int, default=19) # FFmpeg
+    parser.add_argument("--lora_high_1_name", type=str, default="None"); parser.add_argument("--lora_high_1_strength_model", type=float, default=1.0); parser.add_argument("--lora_high_1_strength_clip", type=float, default=1.0)
+    parser.add_argument("--lora_high_2_name", type=str, default="None"); parser.add_argument("--lora_high_2_strength_model", type=float, default=1.0); parser.add_argument("--lora_high_2_strength_clip", type=float, default=1.0)
+    parser.add_argument("--lora_low_1_name", type=str, default="None"); parser.add_argument("--lora_low_1_strength_model", type=float, default=1.0); parser.add_argument("--lora_low_1_strength_clip", type=float, default=1.0)
+    parser.add_argument("--lora_low_2_name", type=str, default="None"); parser.add_argument("--lora_low_2_strength_model", type=float, default=1.0); parser.add_argument("--lora_low_2_strength_clip", type=float, default=1.0)
+    parser.add_argument("--input_resize_algo", type=str, default="bicubic")
+    parser.add_argument("--output_resize_algo", type=str, default="bicubic")
+    return parser.parse_args()
+
+def to_bool(s: str) -> bool: return s.lower() in ['true', '1', 't', 'y', 'yes', 'on']
+def clear_memory():
+    if torch.cuda.is_available(): torch.cuda.empty_cache(); torch.cuda.ipc_collect()
+    gc.collect()
+COMFYUI_BASE_PATH = '/content/ComfyUI'
+def get_value_at_index(obj: Union[Sequence, Mapping], index: int) -> Any:
+    try: return obj[index]
+    except (KeyError, TypeError):
+        if isinstance(obj, dict) and "result" in obj: return obj["result"][index]
+        raise
+def add_comfyui_directory_to_sys_path() -> None:
+    if os.path.isdir(COMFYUI_BASE_PATH) and COMFYUI_BASE_PATH not in sys.path: sys.path.append(COMFYUI_BASE_PATH)
+def import_custom_nodes() -> None:
+    try:
+        import nest_asyncio
+        nest_asyncio.apply()
+    except ImportError:
+        print("nest_asyncio not found, installing...")
+        try:
+            subprocess.run([sys.executable, "-m", "pip", "install", "-q", "nest_asyncio"], check=True)
+            import nest_asyncio
+            nest_asyncio.apply()
+            print("nest_asyncio installed and applied.")
+        except Exception as e:
+            print(f"Failed to install or apply nest_asyncio: {e}")
+    import asyncio, execution, server
+    from nodes import init_extra_nodes
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_closed():
+             loop = asyncio.new_event_loop()
+             asyncio.set_event_loop(loop)
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    server_instance = server.PromptServer(loop)
+    execution.PromptQueue(server_instance)
+    if not loop.is_running():
+        try:
+            loop.run_until_complete(init_extra_nodes())
+        except RuntimeError as e:
+            print(f"Note: Could not run init_extra_nodes synchronously, possibly due to existing loop state: {e}")
+            try:
+                 asyncio.ensure_future(init_extra_nodes())
+            except Exception as fut_e:
+                 print(f"Error trying async init_extra_nodes: {fut_e}")
+    else:
+        try:
+             asyncio.ensure_future(init_extra_nodes())
+        except Exception as fut_e:
+             print(f"Error trying async init_extra_nodes on running loop: {fut_e}")
+
+
+def main():
+    args = parse_args()
+    print("🚀 동영상 생성을 시작합니다 (Full Control Mode, VRAM Optimized)...\n")
+    
+    # ⭐⭐⭐ 수정된 부분: 시작 시 기존 output 폴더 정리 (최종 파일 유지) ⭐⭐⭐
+    temp_dirs = ["temp", "up", "interpolated"]
+    output_base = f"{COMFYUI_BASE_PATH}/output"
+    print("  - 이전 작업의 임시 폴더 정리 중...")
+    for d in temp_dirs:
+        full_path = os.path.join(output_base, d)
+        if os.path.exists(full_path):
+            shutil.rmtree(full_path)
+            print(f"    - 이전 임시 폴더 삭제 완료: {d}")
+
+    # 현재 작업에 필요한 임시 폴더 생성
+    os.makedirs(f"{COMFYUI_BASE_PATH}/output/temp", exist_ok=True); 
+    os.makedirs(f"{COMFYUI_BASE_PATH}/output/up", exist_ok=True)
+    os.makedirs(f"{COMFYUI_BASE_PATH}/output/interpolated", exist_ok=True)
+    # ⭐⭐⭐ 수정된 부분 끝 ⭐⭐⭐
+    
+    add_comfyui_directory_to_sys_path()
+    try: from utils.extra_config import load_extra_path_config
+    except ImportError: print("⚠️ ComfyUI의 extra_model_paths.yaml 로딩 실패 (무시하고 진행)"); load_extra_path_config = lambda x: None
+    extra_model_paths_file = os.path.join(COMFYUI_BASE_PATH, "extra_model_paths.yaml")
+    if os.path.exists(extra_model_paths_file): load_extra_path_config(extra_model_paths_file)
+    print("ComfyUI 커스텀 노드 초기화 중..."); import_custom_nodes(); from nodes import NODE_CLASS_MAPPINGS; print("커스텀 노드 초기화 완료.")
+
+    if args.noise_seed == -1: final_seed = random.randint(1, 2**64); print(f"  - 랜덤 시드 생성: {final_seed}")
+    else: final_seed = args.noise_seed; print(f"  - 고정 시드 사용: {final_seed}")
+    split_step = max(0, int(args.steps * (args.split_point_percent / 100.0))); print(f"  - 총 {args.steps} 스텝 중 {split_step} ( {args.split_point_percent}% )에서 분할")
+    loras_in_use = not (args.lora_high_1_name == "None" and args.lora_high_2_name == "None" and args.lora_low_1_name == "None" and args.lora_low_2_name == "None")
+    connect_clip_to_lora = to_bool(args.connect_lora_clip); should_keep_clip_loaded = loras_in_use and connect_clip_to_lora
+
+    with torch.inference_mode():
+        # VAE Loader, Upscale Model Loader, CLIP Loader 등 노드 매핑
+        loadimage=NODE_CLASS_MAPPINGS["LoadImage"](); upscalemodelloader=NODE_CLASS_MAPPINGS["UpscaleModelLoader"](); cliploader=NODE_CLASS_MAPPINGS["CLIPLoader"]()
+        vaeloaderkj=NODE_CLASS_MAPPINGS["VAELoaderKJ"]() 
+        cliptextencode=NODE_CLASS_MAPPINGS["CLIPTextEncode"](); unetloadergguf=NODE_CLASS_MAPPINGS["UnetLoaderGGUF"](); loraloader=NODE_CLASS_MAPPINGS["LoraLoader"](); imageresizekjv2=NODE_CLASS_MAPPINGS["ImageResizeKJv2"](); wanimagetovideo=NODE_CLASS_MAPPINGS["WanImageToVideo"](); modelsamplingsd3=NODE_CLASS_MAPPINGS["ModelSamplingSD3"](); ksampleradvanced=NODE_CLASS_MAPPINGS["KSamplerAdvanced"](); vaedecode=NODE_CLASS_MAPPINGS["VAEDecode"](); vhs_loadimagespath=NODE_CLASS_MAPPINGS["VHS_LoadImagesPath"](); imageupscalewithmodel=NODE_CLASS_MAPPINGS["ImageUpscaleWithModel"](); imagescaleby=NODE_CLASS_MAPPINGS["ImageScaleBy"](); rife_vfi=NODE_CLASS_MAPPINGS["RIFE VFI"](); vhs_videocombine=NODE_CLASS_MAPPINGS["VHS_VideoCombine"](); saveimage=NODE_CLASS_MAPPINGS["SaveImage"]()
+        clipvisionloader=NODE_CLASS_MAPPINGS["CLIPVisionLoader"]()
+        clipvisionencode=NODE_CLASS_MAPPINGS["CLIPVisionEncode"]()
+        pathchsageattentionkj=NODE_CLASS_MAPPINGS["PathchSageAttentionKJ"]()
+
+        # --- 1단계: CLIP Vision 로직 추가 및 초기 Latent 생성 ---
+        print("\n1단계: 데이터 로딩 및 초기 Latent 생성 중...");
+        print(f"  - CLIP 로딩: {args.clip_name}");
+        cliploader_460 = cliploader.load_clip(clip_name=args.clip_name, type="wan", device="default");
+        cliptextencode_462 = cliptextencode.encode(text=args.positive_prompt, clip=get_value_at_index(cliploader_460, 0));
+        cliptextencode_463 = cliptextencode.encode(text=args.negative_prompt, clip=get_value_at_index(cliploader_460, 0));
+        loadimage_88 = loadimage.load_image(image="example.png");
+
+        imageresizekjv2_401 = imageresizekjv2.resize(
+            width=args.width, height=args.height,
+            upscale_method=args.input_resize_algo,
+            image=get_value_at_index(loadimage_88, 0), keep_proportion="crop",
+            pad_color="0, 0, 0", crop_position="center", divisible_by=2,
+            unique_id=random.randint(1, 2**64)
+        );
+
+        print(f"  - CLIP Vision 로딩: clip_vision_h.safetensors");
+        clipvisionloader_cv = clipvisionloader.load_clip(clip_name="clip_vision_h.safetensors");
+        print(f"  - CLIP Vision 인코딩 중...");
+        clipvisionencode_cv = clipvisionencode.encode(
+            crop="none",
+            clip_vision=get_value_at_index(clipvisionloader_cv, 0),
+            image=get_value_at_index(imageresizekjv2_401, 0)
+        );
+        clip_vision_output = get_value_at_index(clipvisionencode_cv, 0)
+
+        print(f"  - VAE 임시 로딩 ({args.vae_weight_dtype}): {args.vae_name}");
+        vaeloader_temp = vaeloaderkj.load_vae(
+            vae_name=args.vae_name,
+            device=args.vae_device,
+            weight_dtype=args.vae_weight_dtype
+        );
+
+        wanimagetovideo_464 = wanimagetovideo.EXECUTE_NORMALIZED(
+            width=get_value_at_index(imageresizekjv2_401, 1),
+            height=get_value_at_index(imageresizekjv2_401, 2),
+            length=args.length,
+            batch_size=1,
+            positive=get_value_at_index(cliptextencode_462, 0),
+            negative=get_value_at_index(cliptextencode_463, 0),
+            vae=get_value_at_index(vaeloader_temp, 0),
+            clip_vision_output=clip_vision_output,
+            start_image=get_value_at_index(imageresizekjv2_401, 0)
+        );
+
+        if not should_keep_clip_loaded: print("  ✨ (최적화) 1단계 완료, CLIP 모델을 즉시 해제합니다."); del cliploader_460
+        else: print("  ⚠️ (설정) LoRA CLIP 연결 옵션이 활성화되어 3단계까지 CLIP 모델을 유지합니다.")
+        print("  ✨ (최적화) 1단계 완료, 임시 VAE 및 CLIP Vision 모델을 해제합니다.");
+        del vaeloader_temp, clipvisionloader_cv, clipvisionencode_cv, clip_vision_output;
+        clear_memory(); print("1단계 완료.");
+
+        # --- 2단계: High Noise (KSampler) ---
+        print(f"\n2단계: High Noise 샘플링 시작..."); print(f"  - UNet High 로딩: {args.unet_high_name}"); unetloadergguf_495 = unetloadergguf.load_unet(unet_name=args.unet_high_name); model = get_value_at_index(unetloadergguf_495, 0); clip = get_value_at_index(cliploader_460, 0) if should_keep_clip_loaded else None; model_for_patching = model;
+        if to_bool(args.sageattention): print("  ✨ SageAttention 패치 적용 중 (High)..."); pathchsageattentionkj_124 = pathchsageattentionkj.patch(sage_attention="auto", model=model_for_patching); model_for_patching = get_value_at_index(pathchsageattentionkj_124, 0)
+        if args.lora_high_1_name != "None": print(f"  - H LoRA 1: {args.lora_high_1_name}"); model_for_patching, clip = loraloader.load_lora(lora_name=args.lora_high_1_name, strength_model=args.lora_high_1_strength_model, strength_clip=args.lora_high_1_strength_clip, model=model_for_patching, clip=clip)
+        if args.lora_high_2_name != "None": print(f"  - H LoRA 2: {args.lora_high_2_name}"); model_for_patching, clip = loraloader.load_lora(lora_name=args.lora_high_2_name, strength_model=args.lora_high_2_strength_model, strength_clip=args.lora_high_2_strength_clip, model=model_for_patching, clip=clip)
+        shifted_model = get_value_at_index(modelsamplingsd3.patch(shift=args.shift, model=model_for_patching), 0); final_model = shifted_model;
+        ksampleradvanced_466 = ksampleradvanced.sample(add_noise="enable", noise_seed=final_seed, steps=args.steps, cfg=args.cfg_high, sampler_name=args.sampler_name_high, scheduler=args.scheduler_high, start_at_step=0, end_at_step=split_step, return_with_leftover_noise="enable", model=final_model, positive=get_value_at_index(wanimagetovideo_464, 0), negative=get_value_at_index(wanimagetovideo_464, 1), latent_image=get_value_at_index(wanimagetovideo_464, 2));
+        if to_bool(args.sageattention): del pathchsageattentionkj_124
+        del unetloadergguf_495, model, clip, model_for_patching, shifted_model, final_model; clear_memory(); print("2단계 완료.")
+
+        # --- 3단계: Low Noise (KSampler) ---
+        print(f"\n3단계: Low Noise 샘플링 시작..."); print(f"  - UNet Low 로딩: {args.unet_low_name}"); unetloadergguf_496 = unetloadergguf.load_unet(unet_name=args.unet_low_name); model = get_value_at_index(unetloadergguf_496, 0); clip = get_value_at_index(cliploader_460, 0) if should_keep_clip_loaded else None; model_for_patching = model;
+        if to_bool(args.sageattention): print("  ✨ SageAttention 패치 적용 중 (Low)..."); pathchsageattentionkj_129 = pathchsageattentionkj.patch(sage_attention="auto", model=model_for_patching); model_for_patching = get_value_at_index(pathchsageattentionkj_129, 0)
+        if args.lora_low_1_name != "None": print(f"  - L LoRA 1: {args.lora_low_1_name}"); model_for_patching, clip = loraloader.load_lora(lora_name=args.lora_low_1_name, strength_model=args.lora_low_1_strength_model, strength_clip=args.lora_low_1_strength_clip, model=model_for_patching, clip=clip)
+        if args.lora_low_2_name != "None": print(f"  - L LoRA 2: {args.lora_low_2_name}"); model_for_patching, clip = loraloader.load_lora(lora_name=args.lora_low_2_name, strength_model=args.lora_low_2_strength_model, strength_clip=args.lora_low_2_strength_clip, model=model_for_patching, clip=clip)
+        shifted_model = get_value_at_index(modelsamplingsd3.patch(shift=args.shift, model=model_for_patching), 0); final_model = shifted_model;
+        ksampleradvanced_465 = ksampleradvanced.sample(add_noise="disable", noise_seed=final_seed, steps=args.steps, cfg=args.cfg_low, sampler_name=args.sampler_name_low, scheduler=args.scheduler_low, start_at_step=split_step, end_at_step=10000, return_with_leftover_noise="disable", model=final_model, positive=get_value_at_index(wanimagetovideo_464, 0), negative=get_value_at_index(wanimagetovideo_464, 1), latent_image=get_value_at_index(ksampleradvanced_466, 0));
+        if to_bool(args.sageattention): del pathchsageattentionkj_129
+        if should_keep_clip_loaded: print("  ✨ (메모리) LoRA CLIP 연결 옵션 사용 완료, CLIP 모델을 해제합니다."); del cliploader_460
+        del unetloadergguf_496, model, clip, model_for_patching, shifted_model, final_model, ksampleradvanced_466, wanimagetovideo_464; clear_memory(); print("3단계 완료.")
+
+        # --- 4단계: VAE 디코딩 ---
+        print(f"\n4단계: VAE 디코딩 및 임시 저장 중...");
+
+        print(f"  - VAE 모델 로딩 (디코딩용, {args.vae_weight_dtype}): {args.vae_name}");
+        vaeloader_461 = vaeloaderkj.load_vae(
+            vae_name=args.vae_name,
+            device=args.vae_device,
+            weight_dtype=args.vae_weight_dtype
+        );
+
+        vaedecode_469 = vaedecode.decode(samples=get_value_at_index(ksampleradvanced_465, 0), vae=get_value_at_index(vaeloader_461, 0));
+        saveimage.save_images(filename_prefix="temp/example", images=get_value_at_index(vaedecode_469, 0));
+        del ksampleradvanced_465, vaeloader_461, vaedecode_469, loadimage_88, imageresizekjv2_401; clear_memory(); print("4단계 완료.")
+
+        # --- 5단계: 업스케일링 ---
+        combine_input_dir_for_ffmpeg = f"{COMFYUI_BASE_PATH}/output/temp"
+        if args.upscale_ratio > 1:
+            if args.upscale_model_name == "None": print("\n5단계: 업스케일링 건너뜀 (모델이 선택되지 않음).")
+            else:
+                print(f"\n5단계: 프레임 업스케일링 중..."); print(f"  - Upscale 모델 로딩: {args.upscale_model_name}"); upscalemodelloader_384 = upscalemodelloader.load_model(model_name=args.upscale_model_name); chunk_size = args.upscale_chunk_size; base_dir = f"{COMFYUI_BASE_PATH}/output/temp"; scale_by_ratio = args.upscale_ratio / args.upscale_model_scale;
+                total_frames = 0
+                try:
+                    temp_files = [f for f in os.listdir(base_dir) if f.endswith(('.png', '.jpg', '.jpeg', '.webp'))]
+                    total_frames = len(temp_files)
+                    if total_frames == 0:
+                        raise FileNotFoundError("업스케일할 프레임이 'temp' 폴더에 없습니다.")
+                except Exception as e:
+                    print(f"  ❌ 업스케일 5단계 중단: 'temp' 폴더에서 프레임을 읽을 수 없습니다. (오류: {e})")
+                    if 'upscalemodelloader_384' in locals(): del upscalemodelloader_384
+                    clear_memory()
+                    raise
+                print(f"  - 총 {total_frames}개의 프레임을 {chunk_size}개 단위로 분할하여 실행합니다...")
+                for i in range(0, total_frames, chunk_size):
+                    print(f"    - 배치 처리 중 (프레임 {i} ~ {min(i + chunk_size, total_frames) - 1})...")
+                    vhs_load_chunk = vhs_loadimagespath.load_images(directory=base_dir, skip_first_images=i, image_load_cap=chunk_size); loaded_images = get_value_at_index(vhs_load_chunk, 0);
+                    if loaded_images is None: print("    - (경고) 건너뛸 수 없는 이미지가 로드되었습니다, 이 배치를 건너뜁니다."); continue
+                    imageupscale_chunk = imageupscalewithmodel.upscale(upscale_model=get_value_at_index(upscalemodelloader_384, 0), image=loaded_images);
+                    imagescale_chunk = imagescaleby.upscale(
+                        upscale_method=args.output_resize_algo,
+                        scale_by=scale_by_ratio,
+                        image=get_value_at_index(imageupscale_chunk, 0)
+                    );
+                    saveimage.save_images(filename_prefix="up/example", images=get_value_at_index(imagescale_chunk, 0));
+                    del vhs_load_chunk, loaded_images, imageupscale_chunk, imagescale_chunk; clear_memory()
+                del upscalemodelloader_384; clear_memory(); combine_input_dir_for_ffmpeg = f"{COMFYUI_BASE_PATH}/output/up"; print("5단계 완료.")
+        else: print("\n5단계: 업스케일링 건너김 (비율 1.0).")
+
+        # --- 6단계: RIFE 및 비디오 결합 ---
+        print("\n6단계: 비디오 결합 준비 중..."); final_frame_rate = float(args.frame_rate); ffmpeg_input_dir = combine_input_dir_for_ffmpeg
+        if to_bool(args.interpolation):
+            print("  - 프레임 보간 (RIFE)을 활성화합니다."); interpolated_dir = f"{COMFYUI_BASE_PATH}/output/interpolated"; source_dir = combine_input_dir_for_ffmpeg
+            total_frames_rife = 0
+            try:
+                temp_files = [f for f in os.listdir(source_dir) if f.endswith(('.png', '.jpg', '.jpeg', '.webp'))]; total_frames_rife = len(temp_files);
+                if total_frames_rife == 0: raise FileNotFoundError(f"RIFE 보간할 프레임이 '{source_dir}' 폴더에 없습니다.")
+            except Exception as e: print(f"  ❌ RIFE 6단계 중단: '{source_dir}' 폴더에서 프레임을 읽을 수 없습니다. (오류: {e})"); raise
+            chunk_size = args.rife_chunk_size;
+            print(f"  - 총 {total_frames_rife}개의 프레임을 RIFE 청크 {chunk_size}개 단위로 분할하여 실행합니다 (Overlap 적용)...")
+            current_frame_idx = 0; is_first_chunk = True
+            while current_frame_idx < total_frames_rife:
+                load_from = current_frame_idx; load_cap = chunk_size
+                if not is_first_chunk:
+                    load_from -= 1; load_cap += 1
+                if load_from + load_cap > total_frames_rife:
+                    load_cap = total_frames_rife - load_from
+                if load_cap < 2:
+                    print(f"    - (경고) RIFE 처리에 필요한 프레임(2개)이 부족하여 마지막 배치를 건너뜁니다."); break
+                print(f"    - RIFE 배치 처리 중 (원본 프레임 {load_from} ~ {load_from + load_cap - 1})...")
+                vhs_load_chunk = vhs_loadimagespath.load_images(directory=source_dir, skip_first_images=load_from, image_load_cap=load_cap);
+                loaded_images = get_value_at_index(vhs_load_chunk, 0);
+                if loaded_images is None:
+                    print("    - (경고) 건너뛸 수 없는 이미지가 로드되었습니다, 이 배치를 건너뜁니다.");
+                    current_frame_idx += chunk_size; is_first_chunk = False; continue
+                rife_chunk_result_tensor = get_value_at_index(rife_vfi.vfi(
+                    ckpt_name="rife49.pth", multiplier=2,
+                    fast_mode=to_bool(args.rife_fast_mode),
+                    ensemble=to_bool(args.rife_ensemble),
+                    frames=loaded_images
+                ), 0)
+                images_to_save = rife_chunk_result_tensor
+                if not is_first_chunk:
+                    print(f"    - (Overlap) 중복 프레임 1개 제거 후 저장")
+                    images_to_save = rife_chunk_result_tensor[1:]
+                saveimage.save_images(filename_prefix="interpolated/example", images=images_to_save);
+                del vhs_load_chunk, loaded_images, rife_chunk_result_tensor, images_to_save; clear_memory()
+                current_frame_idx += chunk_size; is_first_chunk = False
+            ffmpeg_input_dir = interpolated_dir; final_frame_rate *= 2
+        else: print("  - 프레임 보간이 비활성화되었습니다.");
+
+        print(f"  - 최종 비디오를 FFmpeg ({args.video_encoder})로 결합합니다..."); print(f"  - 입력 폴더: '{ffmpeg_input_dir}'")
+        input_pattern = os.path.join(ffmpeg_input_dir, "example_%05d_.png");
+        timestamp = time.strftime("%Y%m%d-%H%M%S"); output_filename = f"AnimateDiff_{timestamp}.mp4"; output_path = os.path.join(COMFYUI_BASE_PATH, "output", output_filename)
+        ffmpeg_cmd = ["ffmpeg", "-framerate", str(final_frame_rate), "-i", input_pattern]
+        encoder_choice = args.video_encoder
+        if encoder_choice == "GPU: HEVC (NVENC)": ffmpeg_cmd.extend(["-c:v", "hevc_nvenc", "-cq", str(args.nvenc_cq), "-preset", args.nvenc_preset, "-tag:v", "hvc1"])
+        elif encoder_choice == "GPU: H.264 (NVENC)": ffmpeg_cmd.extend(["-c:v", "h264_nvenc", "-cq", str(args.nvenc_cq), "-preset", args.nvenc_preset])
+        else: ffmpeg_cmd.extend(["-c:v", "libx264", "-crf", str(args.cpu_crf), "-preset", "medium"])
+        ffmpeg_cmd.extend(["-pix_fmt", "yuv420p", "-y", output_path])
+        print(f"  - 실행 명령어: {' '.join(ffmpeg_cmd)}")
+        try:
+            result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True, check=True, encoding='utf-8')
+            print("  - FFmpeg 실행 완료.")
+        except FileNotFoundError: print("  ❌ 오류: 'ffmpeg' 명령어를 찾을 수 없습니다. 시스템에 설치되어 있는지 확인하세요."); raise
+        except subprocess.CalledProcessError as e:
+            print(f"  ❌ 오류: FFmpeg 실행 실패 (Return code: {e.returncode})")
+            if e.stdout: print(f"    FFmpeg stdout:\n{e.stdout}")
+            if e.stderr: print(f"    FFmpeg stderr:\n{e.stderr}")
+            raise
+        except Exception as e: print(f"  ❌ 오류: FFmpeg 실행 중 예상치 못한 오류 발생: {e}"); raise
+        print("✅ 모든 단계 완료.")
+
+        # --- 최종 파일 경로 출력 및 복사 ---
+        latest_video = None
+        if os.path.exists(output_path):
+            latest_video = output_path
+            print(f"LATEST_VIDEO_PATH:{latest_video}")
+        else:
+            output_dir = os.path.join(COMFYUI_BASE_PATH, "output");
+            # mp4와 mkv 파일 모두 확인
+            video_files = glob.glob(os.path.join(output_dir, '**', '*.mp4'), recursive=True) + \
+                          glob.glob(os.path.join(output_dir, '**', '*.mkv'), recursive=True)
+            if not video_files:
+                raise FileNotFoundError("생성된 동영상 파일을 찾을 수 없습니다!")
+            latest_video = max(video_files, key=os.path.getctime)
+            print(f"LATEST_VIDEO_PATH:{latest_video}")
+        if latest_video is None:
+             raise FileNotFoundError("최종 비디오 경로를 확정할 수 없습니다. 스크립트를 확인하세요.")
+        
+        base, ext = os.path.splitext(latest_video)
+        original_copy_path = f"{base}_original{ext}"
+        try:
+             shutil.copy2(latest_video, original_copy_path)
+             print(f"✅ 원본 복사본 생성 완료: {original_copy_path}")
+             print(f"ORIGINAL_COPY_PATH:{original_copy_path}")
+        except Exception as e:
+             print(f"❌ 원본 복사본 생성 실패: {e}")
+
+        # --- 7단계: 로그 파일 (.txt) 저장 ---
+        log_file_path = f"{base}.txt"
+        print(f"\n7단계: 설정 로그 파일 작성 중 ({os.path.basename(log_file_path)})...")
+        try:
+            log_content = f"""
+[--- 생성 정보 ---]
+Positive Prompt: {args.positive_prompt}
+Negative Prompt: {args.negative_prompt}
+
+[--- 기본 설정 ---]
+Seed: {final_seed}
+Steps: {args.steps}
+Split Step (%): {args.split_point_percent}% ({split_step} steps)
+Shift: {args.shift}
+SageAttention: {args.sageattention}
+Length (Frames): {args.length}
+Output Resolution: {args.width}x{args.height}
+
+[--- High Noise (2단계) ---]
+Model: {args.unet_high_name}
+CFG: {args.cfg_high}
+Sampler: {args.sampler_name_high}
+Scheduler: {args.scheduler_high}
+LoRA 1: {args.lora_high_1_name} (Model: {args.lora_high_1_strength_model}, Clip: {args.lora_high_1_strength_clip})
+LoRA 2: {args.lora_high_2_name} (Model: {args.lora_high_2_strength_model}, Clip: {args.lora_high_2_strength_clip})
+
+[--- Low Noise (3단계) ---]
+Model: {args.unet_low_name}
+CFG: {args.cfg_low}
+Sampler: {args.sampler_name_low}
+Scheduler: {args.scheduler_low}
+LoRA 1: {args.lora_low_1_name} (Model: {args.lora_low_1_strength_model}, Clip: {args.lora_low_1_strength_clip})
+LoRA 2: {args.lora_low_2_name} (Model: {args.lora_low_2_strength_model}, Clip: {args.lora_low_2_strength_clip})
+
+[--- VAE & CLIP ---]
+VAE Model: {args.vae_name}
+CLIP Model: {args.clip_name}
+Connect LoRA to CLIP: {args.connect_lora_clip}
+
+[--- 후처리 및 인코딩 ---]
+Upscale Model: {args.upscale_model_name} (Ratio: {args.upscale_ratio})
+Frame Interpolation (RIFE): {args.interpolation}
+Target Frame Rate: {args.frame_rate} fps ({final_frame_rate} fps, 보간 적용 후)
+Video Encoder: {args.video_encoder}
+"""
+            with open(log_file_path, 'w', encoding='utf-8') as f:
+                f.write(log_content.strip())
+            print(f"✅ 설정 로그 파일 작성 완료: {log_file_path}")
+        except Exception as e:
+            print(f"❌ 설정 로그 파일 작성 중 오류 발생: {e}")
+
+        # --- 8단계: 작업 후 정리 (요청대로 임시 폴더 3개만 삭제) ---
+        print("\n8단계: 작업 후 정리 시작 (temp, up, interpolated 폴더만 삭제)");
+        try:
+            temp_dirs = ["temp", "up", "interpolated"]
+            output_dir = os.path.join(COMFYUI_BASE_PATH, "output")
+            
+            # 1. 임시 폴더만 삭제
+            for d in temp_dirs:
+                full_path = os.path.join(output_dir, d)
+                if os.path.exists(full_path):
+                    shutil.rmtree(full_path)
+                    print(f"  - 임시 폴더 삭제 완료: {d}")
+            
+            # 2. output 디렉토리에 남아있는 '파일'은 일체 건드리지 않음 (영상, png, json, txt 모두 유지)
+            print("  - output 폴더 내의 파일(영상, 로그, 이미지 등)은 모두 유지됩니다.")
+            print("✅ 작업 후 정리 완료.")
+        except Exception as e:
+            print(f"❌ 작업 후 정리 중 오류 발생: {e}")
+        # --------------------------------------------------------
+
+if __name__ == "__main__":
+    main()