Spaces:
Running
Running
| import gradio as gr | |
| import yt_dlp | |
| import os | |
| #import json | |
| import numpy as np | |
| import cv2 | |
| import uuid | |
| import moviepy | |
| from moviepy.video.io.ffmpeg_tools import ffmpeg_extract_subclip | |
| import moviepy.video.io.ImageSequenceClip | |
| from moviepy.editor import * | |
| from PIL import Image | |
| #os.system("pip install --upgrade yt-dlp") | |
| os.system("yt-dlp -U") | |
| uid=uuid.uuid4() | |
| if not os.path.exists(f'{uid}'): os.makedirs(f'{uid}') | |
| if not os.path.exists(f'{uid}-frames'): os.makedirs(f'{uid}-frames') | |
| if not os.path.exists(f'{uid}-rembg'): os.makedirs(f'{uid}-rembg') | |
| esr = gr.Interface.load("spaces/Omnibus/real_esrgan_mod") | |
| main_url= "https://omnibus-Deblur-Media.hf.space" | |
| load_js = """ | |
| function(text_input, url_params) { | |
| console.log(text_input, url_params); | |
| const params = new URLSearchParams(window.location.search); | |
| url_params = Object.fromEntries(params); | |
| return [text_input, url_params] | |
| } | |
| """ | |
| def load_video(vid): | |
| #os.system("yt-dlp -U") | |
| new_video_in = str(vid) | |
| capture = cv2.VideoCapture(new_video_in) | |
| fps = capture.get(cv2.CAP_PROP_FPS) | |
| msc = capture.get(cv2.CAP_PROP_POS_MSEC) | |
| frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| msc = float(frame_count/fps) | |
| capture.release() | |
| vid_t = float(msc) | |
| hours = int(vid_t/360) | |
| minutes = int(vid_t/60)-(hours*360) | |
| seconds = vid_t-(minutes*60)-(hours*360) | |
| vid_len = f'{hours}:{minutes}:{seconds}' | |
| return frame_count, fps, vid_len, vid | |
| def im_2_vid(images,fps): | |
| this_im=cv2.imread(images[0]) | |
| height=this_im.shape[0] | |
| width= this_im.shape[1] | |
| size = (width, height) | |
| movie_clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(images, fps) | |
| movie_clip.write_videofile(f'{uid}-rembg/bg_removed-{uid}.mp4') | |
| return (f'{uid}-rembg/bg_removed-{uid}.mp4', f'{uid}-rembg/bg_removed-{uid}.mp4') | |
| def predict(text, url_params): | |
| mod_url="" | |
| mod=gr.HTML("") | |
| out = None | |
| valid=gr.update(visible=False) | |
| mod_url = url_params.get('url') | |
| return ["" + text + "", mod_url] | |
| def dl(inp,img): | |
| fps="Error" | |
| out = None | |
| out_file=[] | |
| if img == None and inp !="": | |
| try: | |
| inp_out=inp.replace("https://","") | |
| inp_out=inp_out.replace("/","_").replace(".","_").replace("=","_").replace("?","_") | |
| if "twitter" in inp: | |
| os.system(f'yt-dlp "{inp}" --extractor-arg "twitter:api=syndication" --trim-filenames 160 -o "{uid}/{inp_out}.mp4" -S res,mp4 --recode mp4') | |
| else: | |
| os.system(f'yt-dlp "{inp}" --trim-filenames 160 -o "{uid}/{inp_out}.mp4" -S res,mp4 --recode mp4') | |
| out = f"{uid}/{inp_out}.mp4" | |
| capture = cv2.VideoCapture(out) | |
| fps = capture.get(cv2.CAP_PROP_FPS) | |
| capture.release() | |
| except Exception as e: | |
| print(e) | |
| out = None | |
| elif img !=None and inp == "": | |
| capture = cv2.VideoCapture(img) | |
| fps = capture.get(cv2.CAP_PROP_FPS) | |
| capture.release() | |
| out = f"{img}" | |
| return out,out,out,out,fps | |
| def trim_vid(vid,start_time,end_time): | |
| print (vid) | |
| start_hr=float(start_time.split(":",2)[0])*360 | |
| start_min=int(start_time.split(":",2)[1])*60 | |
| start_sec=int(start_time.split(":",2)[2]) | |
| end_hr=int(end_time.split(":",2)[0])*360 | |
| end_min=int(end_time.split(":",2)[1])*60 | |
| end_sec=float(end_time.split(":",2)[2]) | |
| start=start_hr+start_min+start_sec | |
| end=end_hr+end_min+end_sec | |
| clip = VideoFileClip(vid) | |
| mod_fps=clip.fps | |
| clip = clip.subclip(start, end) | |
| clip.write_videofile(f"{uid}-clip.mp4", fps=mod_fps) | |
| #ffmpeg_extract_subclip(vid, start, end, targetname=f"{uid}-clip.mp4") | |
| out= f"{uid}-clip.mp4" | |
| capture = cv2.VideoCapture(out) | |
| frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| capture.release() | |
| return out,frame_count | |
| def video_clip(program,fps,qual,model_name,denoise_strength,face_enhance,outscale): | |
| _=None | |
| fps=float(fps) | |
| new_video_in = str(f"{uid}-clip.mp4") | |
| capture = cv2.VideoCapture(new_video_in) | |
| frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| fbox=[] | |
| out_box=[] | |
| cnt=0 | |
| frame_count1= int(frame_count) | |
| for i in range(int(frame_count1)-1): | |
| capture.set(cv2.CAP_PROP_POS_FRAMES, i) | |
| ret, frame_f = capture.read(i) | |
| #frame_ff = cv2.cvtColor(frame_f, cv2.COLOR_BGR2RGB) | |
| cv2.imwrite(f'{uid}-frames/{i+1}.png',frame_f) | |
| fbox.append(f'{uid}-frames/{i+1}.png') | |
| mes=f'Working on {i+1} of {frame_count1}' | |
| yield _,_,mes | |
| yield _,_,"Frames Complete" | |
| if qual: | |
| mes = "Improving Quality" | |
| yield _,_,mes | |
| if qual: | |
| for i,img in enumerate(fbox): | |
| #print (img) | |
| out = os.path.abspath(img) | |
| out_url = f'{main_url}/file={out}' | |
| mes=f'Improving frame {i+1} of {frame_count}' | |
| yield _,_,mes | |
| out = esr(out_url, model_name, float(denoise_strength), face_enhance, int(outscale)) | |
| #yield _,_,mes | |
| #cv2.imwrite(f'{img}',out) | |
| out_box.append(f'{out}') | |
| print (f'{main_url}/file={out}') | |
| #print (f'out::{out}') | |
| print (f'out_box::{out_box}') | |
| clip = ImageSequenceClip(out_box, fps = fps) | |
| else: | |
| mes="Writing Video" | |
| clip = ImageSequenceClip(fbox, fps = fps) | |
| yield _,_,"Writing Video" | |
| videoclip = VideoFileClip(new_video_in) | |
| audioclip=videoclip.audio | |
| clip.audio=audioclip | |
| clip.write_videofile(f"{uid}/enhanced_vid.mp4") | |
| yield _,_,"Saving Video" | |
| out = f"{uid}/enhanced_vid.mp4" | |
| yield out,out,"Video Complete" | |
| def gif_clip(program,fps,qual,model_name,denoise_strength,face_enhance,outscale): | |
| _=None | |
| fps=float(fps) | |
| if program == 'imageio': | |
| print (f"NOT adjusting fps from: {fps} to: {fps*2}") | |
| fps=fps*2 | |
| new_video_in = str(f"{uid}-clip.mp4") | |
| capture = cv2.VideoCapture(new_video_in) | |
| frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT)) | |
| fbox=[] | |
| out_box=[] | |
| cnt=0 | |
| frame_count1= int(frame_count) | |
| for i in range(int(frame_count1)-1): | |
| capture.set(cv2.CAP_PROP_POS_FRAMES, i) | |
| ret, frame_f = capture.read(i) | |
| cv2.imwrite(f'{uid}-frames/{i+1}.png',frame_f) | |
| fbox.append(f'{uid}-frames/{i+1}.png') | |
| mes=f'Working on {i+1} of {frame_count1}' | |
| yield _,_,mes | |
| yield _,_,"Frames Complete" | |
| if qual: | |
| mes = "Improving Quality" | |
| yield _,_,mes | |
| if qual: | |
| for i,img in enumerate(fbox): | |
| out = os.path.abspath(img) | |
| out_url = f'{main_url}/file={out}' | |
| mes=f'Improving frame {i+1} of {frame_count}' | |
| yield _,_,mes | |
| out = esr(out_url, model_name, float(denoise_strength), face_enhance, int(outscale)) | |
| out_box.append(f'{out}') | |
| print (f'{main_url}/file={out}') | |
| clip = ImageSequenceClip(out_box, fps = fps) | |
| else: | |
| clip = ImageSequenceClip(fbox, fps = fps) | |
| yield _,_,"Writing GIF" | |
| clip.to_gif(f"{uid}/clip_gif.gif",fps=fps, program=program) | |
| #clip.speedx(2).to_gif(f"{uid}/clip_gif.gif",program=program) | |
| out = f"{uid}/clip_gif.gif" | |
| yield out,out,"GIF Complete" | |
| def improve_img(inp,model_name,denoise_strength,face_enhance,outscale): | |
| _=None | |
| yield _,"Reading image" | |
| #img=cv2.imread(inp) | |
| cv2.imwrite(f'{uid}-frames/tmp_im.png',cv2.cvtColor(inp, cv2.COLOR_BGR2RGB)) | |
| out = os.path.abspath(f'{uid}-frames/tmp_im.png') | |
| out_url = f'{main_url}/file={out}' | |
| yield _,"Improving image" | |
| out = esr(out_url, model_name, float(denoise_strength), face_enhance, int(outscale)) | |
| yield out,"Complete" | |
| def update_speed(inp,clip_speed,fps): | |
| if "-split.mp4" in inp: | |
| out_inp = f'{inp.split("-split.mp4",1)[0]}-split.mp4' | |
| else: | |
| out_inp = f'{inp.split(".mp4",1)[0]}-split.mp4' | |
| mod_fps=float(fps)*float(clip_speed) | |
| clip = VideoFileClip(inp) | |
| final = moviepy.video.fx.all.speedx(clip, factor=clip_speed) | |
| final.write_videofile(f'{out_inp}', fps=mod_fps) | |
| out = f'{out_inp}' | |
| return out,out,out | |
| def echo_fn(inp): | |
| return inp | |
| def check_load(inp_url,outp_vid,hid_box,start_f,end_f): | |
| if outp_vid == None and inp_url !="": | |
| out_trim,in_vid,trim_count=trim_vid(hid_box,start_f,end_f) | |
| elif outp_vid !=None and inp_url == "": | |
| out_trim = None | |
| in_vid=outp_vid | |
| trim_count = "" | |
| return out_trim,in_vid,trim_count | |
| def run_samp(program,fps,qual,model_name,denoise_strength,face_enhance,outscale,frame_targ): | |
| _=None | |
| #fps=float(fps) | |
| new_video_in = str(f"{uid}-clip.mp4") | |
| capture = cv2.VideoCapture(new_video_in) | |
| #frame_count1= int(frame_count) | |
| i=int(frame_targ) | |
| capture.set(cv2.CAP_PROP_POS_FRAMES, i) | |
| ret, frame_f = capture.read(i) | |
| #frame_ff = cv2.cvtColor(frame_f, cv2.COLOR_BGR2RGB) | |
| cv2.imwrite(f'{uid}-frames/{i}.png',frame_f) | |
| out = os.path.abspath(f'{uid}-frames/{i}.png') | |
| out_url = f'{main_url}/file={out}' | |
| yield _,"Creating Sample Frame","Creating Sample Frame" | |
| out = esr(out_url, model_name, float(denoise_strength), face_enhance, int(outscale)) | |
| yield out,"Sample Frame Complete","Sample Frame Complete" | |
| def new_media(inp): | |
| if inp == "Image": | |
| im_box = gr.update(visible=True) | |
| vid_box = gr.update(visible=False) | |
| gif_row = gr.update(visible=False) | |
| vid_row = gr.update(visible=False) | |
| #qual = gr.update(value=True,interactive=False) | |
| return (im_box,vid_box,gif_row,vid_row) | |
| if inp == "Video": | |
| im_box = gr.update(visible=False) | |
| vid_box = gr.update(visible=True) | |
| gif_row = gr.update(visible=False) | |
| vid_row = gr.update(visible=True) | |
| #qual = gr.update(value=False,interactive=True) | |
| return (im_box,vid_box,gif_row,vid_row) | |
| if inp == "GIF": | |
| im_box = gr.update(visible=False) | |
| vid_box = gr.update(visible=True) | |
| gif_row = gr.update(visible=True) | |
| vid_row = gr.update(visible=False) | |
| #qual = gr.update(value=False,interactive=True) | |
| return (im_box,vid_box,gif_row,vid_row) | |
| css=''' | |
| #component-0{ | |
| background:repeating-radial-gradient(white, cornflowerblue); | |
| } | |
| .padded.svelte-90oupt{ | |
| background:cornflowerblue; | |
| } | |
| .dark .gr-box{ | |
| background:#344d74;!important; | |
| opacity:1;!important; | |
| } | |
| .p-2 { | |
| background:#344d74;!important; | |
| opacity:1;!important; | |
| } | |
| .gap-4 { | |
| background:#6681ab;!important; | |
| opacity:1;!important; | |
| } | |
| .dark .gr-padded{ | |
| background:#21314a;!important; | |
| opacity:1;!important; | |
| } | |
| ''' | |
| with gr.Blocks(css=css) as app: | |
| with gr.Row(): | |
| gr.Column() | |
| with gr.Column(): | |
| with gr.Group(): | |
| choose_media = gr.Radio(label="Media Type",choices=["Image","Video","GIF"],value="Image") | |
| with gr.Accordion("Quality Options", open=False): | |
| with gr.Row(): | |
| model_name = gr.Dropdown(label="Real-ESRGAN Model", | |
| choices=["RealESRGAN_x4plus", "RealESRNet_x4plus", "RealESRGAN_x4plus_anime_6B", | |
| "RealESRGAN_x2plus", "realesr-general-x4v3"], | |
| value="realesr-general-x4v3", show_label=True) | |
| face_enhance = gr.Checkbox(label="Face Enhancement using GFPGAN", | |
| value=False, show_label=True) | |
| denoise_strength = gr.Slider(label="Denoise Strength", | |
| minimum=0, maximum=1, step=0.1, value=0.5) | |
| outscale = gr.Slider(label="Image Upscaling Factor", | |
| minimum=1, maximum=10, step=1, value=1, show_label=True) | |
| with gr.Box(visible=True) as im_box: | |
| with gr.Group(): | |
| inp_img_url=gr.Textbox(label="Image URL") | |
| load_im_btn=gr.Button("Load URL") | |
| inp_img=gr.Image(label = "Input Image") | |
| with gr.Row(): | |
| proc_im_btn=gr.Button("Improve") | |
| im_stat=gr.Textbox(label="Status") | |
| outp_img=gr.Image(label="Enhanced Image") | |
| with gr.Box(visible=False) as vid_box: | |
| with gr.Group(): | |
| inp_url = gr.Textbox(label="Video URL") | |
| go_btn = gr.Button("Run") | |
| outp_vid=gr.Video(format="mp4") | |
| with gr.Row(): | |
| frame_count=gr.Textbox(label="Frame Count",interactive = False) | |
| fps=gr.Textbox(label="FPS",interactive = False) | |
| outp_file=gr.Files() | |
| clip_speed = gr.Slider(label="Speed", minimum=0.01, maximum=2, value=1, step=0.01) | |
| speed_btn = gr.Button("Update Speed") | |
| with gr.Row(): | |
| start_f = gr.Textbox(label = "Start", value = "0:00:00", placeholder = "0:00:23",interactive = True) | |
| end_f = gr.Textbox(label = "End", value = "0:00:05", placeholder = "0:00:54",interactive = True) | |
| trim_count = gr.Textbox(label="Trimmed Frames") | |
| trim_btn=gr.Button("Trim") | |
| out_trim=gr.Video(format="mp4") | |
| hid_box = gr.Textbox(visible=False) | |
| hid_fps = gr.Textbox(visible=False) | |
| with gr.Row(): | |
| qual=gr.Checkbox(label="Improve Quality",value=False) | |
| with gr.Accordion("Sample Frame",open=False): | |
| with gr.Row(): | |
| frame_targ=gr.Number(label="Frame",value=1) | |
| samp_btn=gr.Button("Get Sample") | |
| samp_im = gr.Image(label="Sample Frame") | |
| with gr.Column(visible=False) as gif_row: | |
| with gr.Row(): | |
| choose_prog=gr.Radio(label="GIF Engine",choices=['imageio','ImageMagick','ffmpeg'], value = "imageio") | |
| with gr.Row(): | |
| gif_btn = gr.Button("Make GIF") | |
| gif_stat=gr.Textbox(label="Status") | |
| with gr.Row(visible=False) as vid_row: | |
| vid_btn = gr.Button("Make Video") | |
| vid_stat=gr.Textbox(label="Status") | |
| with gr.Row(): | |
| with gr.Column(): | |
| gif_show = gr.Video() | |
| with gr.Column(): | |
| gif_file = gr.Files() | |
| gr.Column() | |
| with gr.Row(visible=False): | |
| text_input=gr.Textbox() | |
| text_output=gr.Textbox() | |
| url_params=gr.JSON() | |
| def load_im_fn(inp): | |
| return inp | |
| load_im_btn.click(load_im_fn,inp_img_url,inp_img) | |
| proc_im_btn.click(improve_img,[inp_img,model_name,denoise_strength,face_enhance,outscale],[outp_img,im_stat]) | |
| choose_media.change(new_media,choose_media,[im_box,vid_box,gif_row,vid_row]) | |
| samp_btn.click(run_samp,[choose_prog,fps,qual,model_name,denoise_strength,face_enhance,outscale,frame_targ],[samp_im,gif_stat,vid_stat]) | |
| speed_btn.click(update_speed,[hid_box,clip_speed,hid_fps],[outp_vid,hid_box,outp_file]) | |
| gif_btn.click(gif_clip,[choose_prog,fps,qual,model_name,denoise_strength,face_enhance,outscale],[gif_show,gif_file,gif_stat]) | |
| vid_btn.click(video_clip,[choose_prog,fps,qual,model_name,denoise_strength,face_enhance,outscale],[gif_show,gif_file,vid_stat]) | |
| trim_btn.click(trim_vid,[hid_box,start_f,end_f],[out_trim,trim_count]) | |
| outp_vid.change(load_video,outp_vid,[frame_count,fps,end_f,hid_box]).then(trim_vid,[hid_box,start_f,end_f],[out_trim,trim_count]) | |
| go_btn.click(dl,[inp_url,outp_vid],[outp_vid,outp_file,out_trim,hid_box,hid_fps]) | |
| app.load(fn=predict, inputs=[text_input,url_params], outputs=[text_output,text_input],_js=load_js) | |
| app.queue().launch(show_api=False) |