File size: 3,508 Bytes
db12400
b127fd6
5e44253
 
 
 
bbf9a90
 
db12400
5e44253
 
b8efd0d
 
 
 
c512cd9
b8efd0d
 
 
 
5e44253
 
 
 
 
 
 
 
 
 
 
 
c512cd9
5e44253
 
 
c512cd9
5e44253
 
 
 
 
 
54d06ee
c512cd9
55c9cad
5e44253
 
 
3e4418e
936c431
 
5e44253
c512cd9
936c431
6a04784
5e44253
 
55c9cad
5e44253
 
c512cd9
5e44253
db12400
b8efd0d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9e2421a
 
 
b8efd0d
6a04784
e38439c
b8efd0d
dafd4d1
54d06ee
4b109d4
55c9cad
7fa6f4c
 
dafd4d1
6a04784
b8efd0d
54d06ee
5cd1978
9e2421a
f90f58c
db12400
9e2421a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
import gradio as gr
import os
import cv2
import numpy as np
from moviepy.editor import *

token = os.environ.get('HF_TOKEN')
pix2pix = gr.Blocks.load(name="spaces/fffiloni/instruct-pix2pix-clone", api_key=token)

def get_frames(video_in):
    frames = []
    #resize the video
    clip = mp.VideoFileClip(video_in)
    clip_resized = clip.resize(height=512)
    clip_resized.write_videofile("video_resized.mp4")
    print("video resized to 512 height")
    
    # Opens the Video file with CV2
    cap= cv2.VideoCapture("video_resized.mp4")
    
    fps = cap.get(cv2.CAP_PROP_FPS)
    i=0
    while(cap.isOpened()):
        ret, frame = cap.read()
        if ret == False:
            break
        cv2.imwrite('kang'+str(i)+'.jpg',frame)
        frames.append('kang'+str(i)+'.jpg')
        i+=1
    
    cap.release()
    cv2.destroyAllWindows()
    print("broke the video into frames")
    return frames, fps

def create_video(frames, fps):
    print("building video result")
    clip = ImageSequenceClip(frames, fps=fps)
    clip.write_videofile("movie.mp4", fps=fps)
    
    return 'movie.mp4'


def infer(prompt,video_in, seed_in, trim_value):
    print(prompt)
    break_vid = get_frames(video_in)
    
    frames_list= break_vid[0]
    fps = break_vid[1]
    n_frame = int(trim_value*fps)
    if n_frame >= len(frames_list):
        n_frame = len(frames_list)
    result_frames = []
    print("set stop frames to: " + n_frame)
    for i in frames_list[0:int(n_frame)]:
        pix2pix_img = pix2pix(prompt,5.5,1.5,i,15,"",512,512,seed_in,fn_index=0)
        images = [os.path.join(pix2pix_img[0], img) for img in os.listdir(pix2pix_img[0])]
        result_frames.append(images[0])
        print("frame " + i + ": done;")

    final_vid = create_video(result_frames, fps)
    print("finished !")
    return final_vid

title = """
    <div style="text-align: center; max-width: 700px; margin: 0 auto;">
        <div
        style="
            display: inline-flex;
            align-items: center;
            gap: 0.8rem;
            font-size: 1.75rem;
        "
        >
        <h1 style="font-weight: 900; margin-bottom: 7px; margin-top: 5px;">
            Pix2Pix Video
        </h1>
        </div>
        <p style="margin-bottom: 10px; font-size: 94%">
        Apply Instruct Pix2Pix Diffusion to a video 
        </p>
    </div>
"""

article = """
    
    <div class="footer">
        <p>
         
        Follow <a href="https://twitter.com/fffiloni" target="_blank">Sylvain Filoni</a> for future updates 🤗
        </p>
    </div>
    
"""

with gr.Blocks(css='style.css') as demo:
    with gr.Column(elem_id="col-container"):
        gr.HTML(title)
        with gr.Row():
            with gr.Column():
                prompt = gr.Textbox(label="Prompt", placeholder="enter prompt", show_label=False)
                video_inp = gr.Video(label="Video source", source="upload", type="filepath")
                with gr.Row():
                    seed_inp = gr.Slider(minimum=0, maximum=10000, step=1, value=123456)
                    trim_in = gr.Slider(label="Cut video at (s)", minimun=2, maximum=10, step=1, value=2)
            with gr.Column():
                
                video_out = gr.Video(label="Pix2pix video result")
                submit_btn = gr.Button("Generate Pix2Pix video")
        gr.HTML(article)
    inputs = [prompt,video_inp,seed_inp, trim_in]
    outputs = [video_out]
    
    submit_btn.click(infer, inputs, outputs)

demo.launch().queue(max_size=12)