Upload run_generator_itstxt.py

run_generator_itstxt.py

@@ -0,0 +1,479 @@
+#@title 필요 파일 생성
+# 이 파일은 셀 4에서 서브프로세스로 실행됩니다.
+
+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)
+    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")
+    # 'parse_args()'가 실행된 후 모든 인자들을 반환합니다.
+    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() # 💡 args 변수에 모든 인자 저장
+
+    print("🚀 동영상 생성을 시작합니다 (Full Control Mode, VRAM Optimized)...\n")
+
+    # 🚨🚨🚨 수정된 부분: .mp4, .mkv, .webm 파일은 제외하고 output 폴더 정리 🚨🚨🚨
+    output_dir = os.path.join(COMFYUI_BASE_PATH, 'output')
+    print(f"  - 이전 출력물 정리 중... (Output: {output_dir})")
+    
+    deleted_count = 0
+    try:
+        for item_name in os.listdir(output_dir):
+            item_path = os.path.join(output_dir, item_name)
+            
+            # 💡 조건: 비디오 파일 확장자(.mp4, .mkv, .webm)는 삭제하지 않고 보존합니다.
+            if item_name.lower().endswith(('.mp4', '.mkv', '.webm')):
+                print(f"    - 🗄️ 비디오 파일 '{item_name}'은 보존합니다.")
+                continue
+            
+            # 파일 또는 링크인 경우 삭제
+            if os.path.isfile(item_path) or os.path.islink(item_path):
+                os.unlink(item_path)
+                deleted_count += 1
+            # 폴더인 경우 재귀적으로 삭제
+            elif os.path.isdir(item_path):
+                shutil.rmtree(item_path)
+                deleted_count += 1
+                
+        print(f"  ✅ 정리 완료. 보존된 비디오 외 {deleted_count}개의 항목이 삭제되었습니다.")
+    except Exception as e:
+        print(f"  ❌ 출력 폴더 정리 중 오류 발생: {e}")
+    # 🚨🚨🚨 수정된 부분 끝 🚨🚨🚨
+    
+    # 임시 폴더 재생성 (정리 과정에서 삭제되었을 수 있음)
+    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():
+        loadimage=NODE_CLASS_MAPPINGS["LoadImage"](); upscalemodelloader=NODE_CLASS_MAPPINGS["UpscaleModelLoader"](); cliploader=NODE_CLASS_MAPPINGS["CLIPLoader"](); vaeloader=NODE_CLASS_MAPPINGS["VAELoader"](); 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 로직 추가 및 메모리 해제 ---
+        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 임시 로딩 (초기 Latent 생성용): {args.vae_name}");
+        vaeloader_temp = vaeloader.load_vae(vae_name=args.vae_name);
+
+        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단계 완료.");
+        # --- 1단계 수정 완료 ---
+
+        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;
+
+        # ✨ Gradio 파싱을 위한 샘플링 시작 로그 추가
+        print(f"### SAMPLER_START: HIGH_NOISE, Steps 0 to {split_step} (CFG {args.cfg_high}) ###") 
+
+        # 수정: cfg=args.cfg_high 사용
+        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));
+        
+        # ✨ Gradio 파싱을 위한 샘플링 종료 로그 추가
+        print("### SAMPLER_END: HIGH_NOISE ###")
+
+        if to_bool(args.sageattention): del pathchsageattentionkj_124
+        del unetloadergguf_495, model, clip, model_for_patching, shifted_model, final_model; clear_memory(); print("2단계 완료.")
+
+        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;
+
+        # ✨ Gradio 파싱을 위한 샘플링 시작 로그 추가
+        print(f"### SAMPLER_START: LOW_NOISE, Steps {split_step} to {args.steps} (CFG {args.cfg_low}) ###")
+
+        # 수정: cfg=args.cfg_low 사용
+        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));
+
+        # ✨ Gradio 파싱을 위한 샘플링 종료 로그 추가
+        print("### SAMPLER_END: LOW_NOISE ###")
+        
+        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단계 완료.")
+
+        print(f"\n4단계: VAE 디코딩 및 임시 저장 중..."); print(f"  - VAE 모델 로딩 (디코딩용): {args.vae_name}"); vaeloader_461 = vaeloader.load_vae(vae_name=args.vae_name); 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단계 완료.")
+
+        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 청크 로직 수정 (Overlap 적용) ---
+        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  # 1프레임 겹치기
+                    load_cap += 1  # 겹친 만큼 1프레임 더 로드
+
+                # 마지막 청크 경계 처리
+                if load_from + load_cap > total_frames_rife:
+                    load_cap = total_frames_rife - load_from
+
+                # RIFE는 최소 2프레임이 필요함
+                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("  - 프레임 보간이 비활성화되었습니다.");
+        # --- 6단계 수정 완료 ---
+
+        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");
+            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}")
+        # --- 비디오 저장 완료 ---
+        
+        # 🚨🚨🚨 수정: 설정 TXT 파일 저장 로직 추가 🚨🚨🚨
+        txt_path = f"{base}.txt"
+        
+        try:
+            print(f"  - 설정 로그 TXT 파일 생성 중: {txt_path}")
+            
+            # 모든 인자(args)를 딕셔너리로 변환
+            settings = vars(args) 
+            
+            with open(txt_path, 'w', encoding='utf-8') as f:
+                f.write("========== 🎬 Video Generation Settings (Full Control) ==========\n\n")
+                
+                f.write("--- 📝 Prompts & Seed ---\n")
+                f.write(f"Seed: {final_seed}\n")
+                f.write(f"Positive Prompt: {settings['positive_prompt']}\n")
+                f.write(f"Negative Prompt: {settings['negative_prompt']}\n\n")
+                
+                f.write("--- 🖼️ Size & Length ---\n")
+                f.write(f"Width: {settings['width']}, Height: {settings['height']}\n")
+                f.write(f"Length (Frames): {settings['length']}\n")
+                f.write(f"Upscale Ratio (Final): {settings['upscale_ratio']}\n")
+                f.write(f"Input Resize Algo: {settings['input_resize_algo']}\n")
+                f.write(f"Output Resize Algo: {settings['output_resize_algo']}\n\n")
+                
+                f.write("--- ⚙️ Sampler & Steps ---\n")
+                f.write(f"Total Steps: {settings['steps']}\n")
+                f.write(f"Split Point (%): {settings['split_point_percent']} -> Step {split_step}\n")
+                f.write(f"Shift (Speed): {settings['shift']}\n")
+                f.write(f"SageAttention: {settings['sageattention']}\n")
+                f.write(f"Connect LoRA Clip: {settings['connect_lora_clip']}\n\n")
+                
+                f.write("--- ⚡ High Noise (Initial) ---\n")
+                f.write(f"Model (Unet): {settings['unet_high_name']}\n")
+                f.write(f"CFG: {settings['cfg_high']}\n")
+                f.write(f"Sampler: {settings['sampler_name_high']}\n")
+                f.write(f"Scheduler: {settings['scheduler_high']}\n")
+                if settings['lora_high_1_name'] != 'None':
+                    f.write(f"LoRA 1: {settings['lora_high_1_name']} (M:{settings['lora_high_1_strength_model']}, C:{settings['lora_high_1_strength_clip']})\n")
+                if settings['lora_high_2_name'] != 'None':
+                    f.write(f"LoRA 2: {settings['lora_high_2_name']} (M:{settings['lora_high_2_strength_model']}, C:{settings['lora_high_2_strength_clip']})\n\n")
+                
+                f.write("--- 🌿 Low Noise (Refiner) ---\n")
+                f.write(f"Model (Unet): {settings['unet_low_name']}\n")
+                f.write(f"CFG: {settings['cfg_low']}\n")
+                f.write(f"Sampler: {settings['sampler_name_low']}\n")
+                f.write(f"Scheduler: {settings['scheduler_low']}\n")
+                if settings['lora_low_1_name'] != 'None':
+                    f.write(f"LoRA 1: {settings['lora_low_1_name']} (M:{settings['lora_low_1_strength_model']}, C:{settings['lora_low_1_strength_clip']})\n")
+                if settings['lora_low_2_name'] != 'None':
+                    f.write(f"LoRA 2: {settings['lora_low_2_name']} (M:{settings['lora_low_2_strength_model']}, C:{settings['lora_low_2_strength_clip']})\n\n")
+
+                f.write("--- 💾 Other Models ---\n")
+                f.write(f"VAE: {settings['vae_name']}\n")
+                f.write(f"CLIP: {settings['clip_name']}\n")
+                f.write(f"Upscale Model: {settings['upscale_model_name']} (Scale: {settings['upscale_model_scale']}, Chunk: {settings['upscale_chunk_size']})\n\n")
+
+                f.write("--- 🎥 Video Output & Interpolation ---\n")
+                f.write(f"Frame Rate (Base): {settings['frame_rate']}\n")
+                f.write(f"Interpolation (RIFE): {settings['interpolation']}\n")
+                if to_bool(settings['interpolation']):
+                    f.write(f"  - RIFE Fast Mode: {settings['rife_fast_mode']}\n")
+                    f.write(f"  - RIFE Ensemble: {settings['rife_ensemble']}\n")
+                    f.write(f"  - RIFE Chunk Size: {settings['rife_chunk_size']}\n")
+                f.write(f"Video Encoder: {settings['video_encoder']}\n")
+                if 'NVENC' in settings['video_encoder']:
+                    f.write(f"  - NVENC CQ: {settings['nvenc_cq']}, Preset: {settings['nvenc_preset']}\n")
+                elif 'CPU' in settings['video_encoder']:
+                    f.write(f"  - CPU CRF: {settings['cpu_crf']}\n")
+                
+                f.write("\n========================================================\n")
+
+            print(f"✅ 설정 로그 TXT 파일 저장 완료: {os.path.basename(txt_path)}")
+            
+        except Exception as e:
+            print(f"❌ 설정 로그 TXT 파일 저장 실패: {e}")
+        # 🚨🚨🚨 TXT 파일 저장 로직 끝 🚨🚨🚨
+
+if __name__ == "__main__":
+    main()