ControlVideo-master/inference.py

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()