import os import numpy as np import argparse import imageio import torch import json from einops import rearrange from diffusers import DDIMScheduler, AutoencoderKL from transformers import CLIPTextModel, CLIPTokenizer import torchvision from controlnet_aux.processor import Processor from models.pipeline_controlvideo import ControlVideoPipeline from models.util import save_videos_grid, read_video from models.unet import UNet3DConditionModel from models.controlnet import ControlNetModel3D from models.RIFE.IFNet_HDv3 import IFNet # Device and model checkpoint paths device = "cuda" sd_path = "checkpoints/stable-diffusion-v1-5" inter_path = "checkpoints/flownet.pkl" controlnet_dict_version = { "v10": { "openpose": "checkpoints/sd-controlnet-openpose", "depth_midas": "checkpoints/sd-controlnet-depth", "canny": "checkpoints/sd-controlnet-canny", }, "v11": { "softedge_pidinet": "checkpoints/control_v11p_sd15_softedge", "softedge_pidsafe": "checkpoints/control_v11p_sd15_softedge", "softedge_hed": "checkpoints/control_v11p_sd15_softedge", "softedge_hedsafe": "checkpoints/control_v11p_sd15_softedge", "scribble_hed": "checkpoints/control_v11p_sd15_scribble", "scribble_pidinet": "checkpoints/control_v11p_sd15_scribble", "lineart_anime": "checkpoints/control_v11p_sd15_lineart_anime", "lineart_coarse": "checkpoints/control_v11p_sd15_lineart", "lineart_realistic": "checkpoints/control_v11p_sd15_lineart", "depth_midas": "checkpoints/control_v11f1p_sd15_depth", "depth_leres": "checkpoints/control_v11f1p_sd15_depth", "depth_leres++": "checkpoints/control_v11f1p_sd15_depth", "depth_zoe": "checkpoints/control_v11f1p_sd15_depth", "canny": "checkpoints/control_v11p_sd15_canny", "openpose": "checkpoints/control_v11p_sd15_openpose", "openpose_face": "checkpoints/control_v11p_sd15_openpose", "openpose_faceonly": "checkpoints/control_v11p_sd15_openpose", "openpose_full": "checkpoints/control_v11p_sd15_openpose", "openpose_hand": "checkpoints/control_v11p_sd15_openpose", "normal_bae": "checkpoints/control_v11p_sd15_normalbae" } } # Positive and negative prompts for generation POS_PROMPT = " ,best quality, extremely detailed, HD, ultra-realistic, 8K, HQ, masterpiece, trending on artstation, art, smooth" NEG_PROMPT = "longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, deformed body, bloated, ugly, unrealistic" def get_args(): """Parse command-line arguments.""" parser = argparse.ArgumentParser() parser.add_argument("--jsonl_path", type=str, default=None, help="Path to JSONL file for batch processing") parser.add_argument("--prompt", type=str, default=None, help="Text description of target video (used for single video mode)") parser.add_argument("--video_path", type=str, default=None, help="Path to a source video (used for single video mode)") parser.add_argument("--output_path", type=str, default="./outputs", help="Directory for output videos") parser.add_argument("--condition", type=str, default="depth", help="Condition of structure sequence") parser.add_argument("--video_length", type=int, default=15, help="Length of synthesized video") parser.add_argument("--height", type=int, default=512, help="Height of synthesized video, must be a multiple of 32") parser.add_argument("--width", type=int, default=512, help="Width of synthesized video, must be a multiple of 32") parser.add_argument("--smoother_steps", nargs='+', default=[19, 20], type=int, help="Timesteps for interleaved-frame smoother") parser.add_argument("--is_long_video", action='store_true', help="Use hierarchical sampler for long videos") parser.add_argument("--seed", type=int, default=42, help="Random seed for generator") parser.add_argument("--version", type=str, default='v10', choices=["v10", "v11"], help="ControlNet version") parser.add_argument("--frame_rate", type=int, default=None, help="Frame rate of input video (default computed from video length)") parser.add_argument("--temp_video_name", type=str, default=None, help="Default video name for single video mode") args = parser.parse_args() return args def process_video(prompt, video_path, output_path, condition, video_length, height, width, smoother_steps, is_long_video, seed, version, frame_rate, temp_video_name, pipe, generator): """Process a single video with the given parameters.""" # Ensure output directory exists os.makedirs(output_path, exist_ok=True) # Adjust height and width to be multiples of 32 height = (height // 32) * 32 width = (width // 32) * 32 # Step 1: Read the video video = read_video(video_path=video_path, video_length=video_length, width=width, height=height, frame_rate=frame_rate) original_pixels = rearrange(video, "(b f) c h w -> b c f h w", b=1) save_videos_grid(original_pixels, os.path.join(output_path, f"source_{temp_video_name}"), rescale=True) # Step 2: Parse video to conditional frames processor = Processor(condition) t2i_transform = torchvision.transforms.ToPILImage() pil_annotation = [processor(t2i_transform(frame), to_pil=True) for frame in video] video_cond = [np.array(p).astype(np.uint8) for p in pil_annotation] imageio.mimsave(os.path.join(output_path, f"{condition}_condition_{temp_video_name}"), video_cond, fps=8) # Free up memory del processor torch.cuda.empty_cache() # Step 3: Inference if is_long_video: window_size = int(np.sqrt(video_length)) sample = pipe.generate_long_video( prompt + POS_PROMPT, video_length=video_length, frames=pil_annotation, num_inference_steps=50, smooth_steps=smoother_steps, window_size=window_size, generator=generator, guidance_scale=12.5, negative_prompt=NEG_PROMPT, width=width, height=height ).videos else: sample = pipe( prompt + POS_PROMPT, video_length=video_length, frames=pil_annotation, num_inference_steps=50, smooth_steps=smoother_steps, generator=generator, guidance_scale=12.5, negative_prompt=NEG_PROMPT, width=width, height=height ).videos # Save the generated video save_videos_grid(sample, os.path.join(output_path, temp_video_name)) def main(): """Main function to handle both single and batch video processing.""" args = get_args() # Load models (shared across all videos) controlnet_dict = controlnet_dict_version[args.version] tokenizer = CLIPTokenizer.from_pretrained(sd_path, subfolder="tokenizer") text_encoder = CLIPTextModel.from_pretrained(sd_path, subfolder="text_encoder").to(dtype=torch.float16) vae = AutoencoderKL.from_pretrained(sd_path, subfolder="vae").to(dtype=torch.float16) unet = UNet3DConditionModel.from_pretrained_2d(sd_path, subfolder="unet").to(dtype=torch.float16) controlnet = ControlNetModel3D.from_pretrained_2d(controlnet_dict[args.condition]).to(dtype=torch.float16) interpolater = IFNet(ckpt_path=inter_path).to(dtype=torch.float16) scheduler = DDIMScheduler.from_pretrained(sd_path, subfolder="scheduler") pipe = ControlVideoPipeline( vae=vae, text_encoder=text_encoder, tokenizer=tokenizer, unet=unet, controlnet=controlnet, interpolater=interpolater, scheduler=scheduler, ) pipe.enable_vae_slicing() pipe.enable_xformers_memory_efficient_attention() pipe.to(device) generator = torch.Generator(device="cuda") generator.manual_seed(args.seed) if args.jsonl_path: # Batch processing mode with open(args.jsonl_path, 'r') as f: for line in f: try: data = json.loads(line.strip()) prompt = data['edit_prompt'] video_filename = data['video'] video_path = os.path.join('/home/wangjuntong/video_editing_dataset/all_sourse/', video_filename) # Process the video with the extracted parameters process_video( prompt=prompt, video_path=video_path, output_path=args.output_path, condition=args.condition, video_length=args.video_length, height=args.height, width=args.width, smoother_steps=args.smoother_steps, is_long_video=args.is_long_video, seed=args.seed, version=args.version, frame_rate=args.frame_rate, temp_video_name=video_filename, # Output name matches input video name pipe=pipe, generator=generator ) print(f"Processed video: {video_filename}") except Exception as e: print(f"Error processing line '{line.strip()}': {e}") else: # Single video processing mode if not args.prompt or not args.video_path: raise ValueError("For single video mode, --prompt and --video_path are required.") temp_video_name = args.temp_video_name if args.temp_video_name else "output.mp4" process_video( prompt=args.prompt, video_path=args.video_path, output_path=args.output_path, condition=args.condition, video_length=args.video_length, height=args.height, width=args.width, smoother_steps=args.smoother_steps, is_long_video=args.is_long_video, seed=args.seed, version=args.version, frame_rate=args.frame_rate, temp_video_name=temp_video_name, pipe=pipe, generator=generator ) print(f"Processed single video: {temp_video_name}") if __name__ == "__main__": main()