Upload 7 files

ui/globals.py

@@ -0,0 +1,17 @@
+ui_restart_server = False
+
+SELECTION_FACES_DATA = None
+ui_SELECTED_INPUT_FACE_INDEX = 0
+
+ui_selected_enhancer = None
+ui_upscale = None
+ui_blend_ratio = None
+ui_input_thumbs = []
+ui_target_thumbs = []
+ui_camera_frame = None
+ui_selected_swap_model = None
+
+
+
+
+

ui/main.py

@@ -0,0 +1,96 @@
+import os
+import time
+import gradio as gr
+import roop.globals
+import roop.metadata
+import roop.utilities as util
+import ui.globals as uii
+
+from ui.tabs.faceswap_tab import faceswap_tab
+from ui.tabs.livecam_tab import livecam_tab
+from ui.tabs.facemgr_tab import facemgr_tab
+from ui.tabs.extras_tab import extras_tab
+from ui.tabs.settings_tab import settings_tab
+
+roop.globals.keep_fps = None
+roop.globals.keep_frames = None
+roop.globals.skip_audio = None
+roop.globals.use_batch = None
+
+
+def prepare_environment():
+    roop.globals.output_path = os.path.abspath(os.path.join(os.getcwd(), "output"))
+    os.makedirs(roop.globals.output_path, exist_ok=True)
+    if not roop.globals.CFG.use_os_temp_folder:
+        os.environ["TEMP"] = os.environ["TMP"] = os.path.abspath(os.path.join(os.getcwd(), "temp"))
+    os.makedirs(os.environ["TEMP"], exist_ok=True)
+    os.environ["GRADIO_TEMP_DIR"] = os.environ["TEMP"]
+    os.environ['GRADIO_ANALYTICS_ENABLED'] = '0'
+
+def run():
+    from roop.core import decode_execution_providers, set_display_ui
+
+    prepare_environment()
+
+    set_display_ui(show_msg)
+    if roop.globals.CFG.provider == "cuda" and util.has_cuda_device() == False:
+       roop.globals.CFG.provider = "cpu"
+
+    roop.globals.execution_providers = decode_execution_providers([roop.globals.CFG.provider])
+    gputype = util.get_device()
+    if gputype == 'cuda':
+        util.print_cuda_info()
+        
+    print(f'Using provider {roop.globals.execution_providers} - Device:{gputype}')
+    
+    run_server = True
+    uii.ui_restart_server = False
+    mycss = """
+        span {color: var(--block-info-text-color)}
+        #fixedheight {
+            max-height: 238.4px;
+            overflow-y: auto !important;
+        }
+        .image-container.svelte-1l6wqyv {height: 100%}
+
+    """
+
+    while run_server:
+        server_name = roop.globals.CFG.server_name
+        if server_name is None or len(server_name) < 1:
+            server_name = None
+        server_port = roop.globals.CFG.server_port
+        if server_port <= 0:
+            server_port = None
+        ssl_verify = False if server_name == '0.0.0.0' else True
+        with gr.Blocks(title=f'{roop.metadata.name} {roop.metadata.version}', theme=roop.globals.CFG.selected_theme, css=mycss, delete_cache=(60, 86400)) as ui:
+            with gr.Row(variant='compact'):
+                    gr.Markdown(f"### [{roop.metadata.name} {roop.metadata.version}](https://github.com/C0untFloyd/roop-unleashed)")
+                    gr.HTML(util.create_version_html(), elem_id="versions")
+            faceswap_tab()
+            livecam_tab()
+            facemgr_tab()
+            extras_tab()
+            settings_tab()
+        launch_browser = roop.globals.CFG.launch_browser
+
+        uii.ui_restart_server = False
+        try:
+            ui.queue().launch(inbrowser=launch_browser, server_name=server_name, server_port=server_port, share=roop.globals.CFG.server_share, ssl_verify=ssl_verify, prevent_thread_lock=True, show_error=True)
+        except Exception as e:
+            print(f'Exception {e} when launching Gradio Server!')
+            uii.ui_restart_server = True
+            run_server = False
+        try:
+            while uii.ui_restart_server == False:
+                time.sleep(1.0)
+
+        except (KeyboardInterrupt, OSError):
+            print("Keyboard interruption in main thread... closing server.")
+            run_server = False
+        ui.close()
+
+
+def show_msg(msg: str):
+    gr.Info(msg)
+

ui/tabs/extras_tab.py

@@ -0,0 +1,245 @@
+import os
+import gradio as gr
+import shutil
+import roop.utilities as util
+import roop.util_ffmpeg as ffmpeg
+import roop.globals
+from roop.utilities import clean_dir
+
+frame_filters_map = { 
+    "Colorize B/W Images (Deoldify Artistic)" : {"colorizer" : {"subtype": "deoldify_artistic"}},
+    "Colorize B/W Images (Deoldify Stable)" : {"colorizer" : {"subtype": "deoldify_stable"}},
+    "Background remove" : {"removebg" : {"subtype": ""}},
+    "Filter Stylize" : {"filter_generic" : {"subtype" : "stylize" }},
+    "Filter Detail Enhance" : {"filter_generic" : {"subtype" : "detailenhance" }},
+    "Filter Pencil Sketch" : {"filter_generic" : {"subtype" : "pencil" }},
+    "Filter Cartoon" : {"filter_generic" : {"subtype" : "cartoon" }},
+    "Filter C64" : {"filter_generic" : {"subtype" : "C64" }}
+    }
+
+frame_upscalers_map = {
+    "ESRGAN x2" : {"upscale" : {"subtype": "esrganx2"}},
+    "ESRGAN x4" : {"upscale" : {"subtype": "esrganx4"}},
+    "LSDIR x4" : {"upscale" : {"subtype": "lsdirx4"}}
+}
+
+def extras_tab():
+    filternames = ["None"]
+    for f in frame_filters_map.keys():
+        filternames.append(f)
+    upscalernames = ["None"]
+    for f in frame_upscalers_map.keys():
+        upscalernames.append(f)
+
+    with gr.Tab("🎉 Extras"):
+        with gr.Row():
+            files_to_process = gr.Files(label='File(s) to process', file_count="multiple", file_types=["image", "video"])
+        with gr.Row(variant='panel'):
+            with gr.Accordion(label="Video/GIF", open=False):
+                with gr.Row(variant='panel'):
+                    with gr.Column():
+                        gr.Markdown("""
+                                    # Poor man's video editor
+                                    Re-encoding uses your configuration from the Settings Tab.
+    """)
+                    with gr.Column():
+                        cut_start_time = gr.Slider(0, 1000000, value=0, label="Start Frame", step=1.0, interactive=True)
+                    with gr.Column():
+                        cut_end_time = gr.Slider(1, 1000000, value=1, label="End Frame", step=1.0, interactive=True)
+                    with gr.Column():
+                        extras_chk_encode = gr.Checkbox(label='Re-encode videos (necessary for videos with different codecs)', value=False)
+                        start_cut_video = gr.Button("Cut video")
+                        start_extract_frames = gr.Button("Extract frames")
+                        start_join_videos = gr.Button("Join videos")
+
+                with gr.Row(variant='panel'):
+                    with gr.Column():
+                        gr.Markdown("""
+                                    # Create video/gif from images
+    """)
+                    with gr.Column():
+                        extras_fps = gr.Slider(minimum=0, maximum=120, value=30, label="Video FPS", step=1.0, interactive=True)
+                        extras_images_folder = gr.Textbox(show_label=False, placeholder="/content/", interactive=True)
+                    with gr.Column():
+                        extras_chk_creategif = gr.Checkbox(label='Create GIF from video', value=False)
+                        extras_create_video=gr.Button("Create")
+                with gr.Row(variant='panel'):
+                    with gr.Column():
+                        gr.Markdown("""
+                                    # Create video from gif
+    """)
+                    with gr.Column():
+                        extras_video_fps = gr.Slider(minimum=0, maximum=120, value=0, label="Video FPS", step=1.0, interactive=True)
+                    with gr.Column():
+                        extras_create_video_from_gif=gr.Button("Create")
+                with gr.Row(variant='panel'):
+                    with gr.Column(scale=2):
+                        gr.Markdown("""
+                                    # Repair video
+
+                                    Uses FFMpeg to fix corrupt videos. 
+    """)
+                    with gr.Column():
+                        extras_repair_video=gr.Button("Repair")
+
+
+        with gr.Row(variant='panel'):
+            with gr.Accordion(label="Full frame processing", open=True):
+                with gr.Row(variant='panel'):
+                    filterselection = gr.Dropdown(filternames, value="None", label="Colorizer/FilterFX", interactive=True)
+                    upscalerselection = gr.Dropdown(upscalernames, value="None", label="Enhancer", interactive=True)
+                with gr.Row(variant='panel'):
+                    start_frame_process=gr.Button("Start processing")
+
+        with gr.Row():
+            gr.Button("👀 Open Output Folder", size='sm').click(fn=lambda: util.open_folder(roop.globals.output_path))
+        with gr.Row():
+            extra_files_output = gr.Files(label='Resulting output files', file_count="multiple")
+
+    start_cut_video.click(fn=on_cut_video, inputs=[files_to_process, cut_start_time, cut_end_time, extras_chk_encode], outputs=[extra_files_output])
+    start_extract_frames.click(fn=on_extras_extract_frames, inputs=[files_to_process], outputs=[extra_files_output])
+    start_join_videos.click(fn=on_join_videos, inputs=[files_to_process, extras_chk_encode], outputs=[extra_files_output])
+    extras_create_video.click(fn=on_extras_create_video, inputs=[files_to_process, extras_images_folder, extras_fps, extras_chk_creategif], outputs=[extra_files_output])
+    extras_create_video_from_gif.click(fn=on_extras_create_video_from_gif, inputs=[files_to_process, extras_video_fps], outputs=[extra_files_output])
+    extras_repair_video.click(fn=on_extras_repair_video, inputs=[files_to_process], outputs=[extra_files_output])
+    start_frame_process.click(fn=on_frame_process, inputs=[files_to_process, filterselection, upscalerselection], outputs=[extra_files_output])
+
+
+def on_cut_video(files, cut_start_frame, cut_end_frame, reencode):
+    if files is None:
+        return None
+    
+    resultfiles = []
+    for tf in files:
+        f = tf.name
+        destfile = util.get_destfilename_from_path(f, roop.globals.output_path, '_cut')
+        ffmpeg.cut_video(f, destfile, cut_start_frame, cut_end_frame, reencode)
+        if os.path.isfile(destfile):
+            resultfiles.append(destfile)
+        else:
+            gr.Error('Cutting video failed!')
+    return resultfiles
+
+
+def on_join_videos(files, chk_encode):
+    if files is None:
+        return None
+    
+    filenames = []
+    for f in files:
+        filenames.append(f.name)
+    destfile = util.get_destfilename_from_path(filenames[0], roop.globals.output_path, '_join')
+    sorted_filenames = util.sort_filenames_ignore_path(filenames)        
+    ffmpeg.join_videos(sorted_filenames, destfile, not chk_encode)
+    resultfiles = []
+    if os.path.isfile(destfile):
+        resultfiles.append(destfile)
+    else:
+        gr.Error('Joining videos failed!')
+    return resultfiles
+
+def on_extras_create_video_from_gif(files,fps):
+    if files is None:
+        return None
+    
+    filenames = []
+    resultfiles = []
+    for f in files:
+        filenames.append(f.name)
+
+    destfilename = os.path.join(roop.globals.output_path, "img2video." + roop.globals.CFG.output_video_format)
+    ffmpeg.create_video_from_gif(filenames[0], destfilename)
+    if os.path.isfile(destfilename):
+        resultfiles.append(destfilename)
+    return resultfiles
+
+
+def on_extras_repair_video(files):
+    if files is None:
+        return None
+    
+    resultfiles = []
+    for tf in files:
+        f = tf.name
+        destfile = util.get_destfilename_from_path(f, roop.globals.output_path, '_repair')
+        ffmpeg.repair_video(f, destfile)
+        if os.path.isfile(destfile):
+            resultfiles.append(destfile)
+        else:
+            gr.Error('Repairing video failed!')
+    return resultfiles
+
+
+
+
+
+def on_extras_create_video(files, images_path,fps, create_gif):
+    if images_path is None:
+        return None
+    resultfiles = []
+    if len(files) > 0 and util.is_video(files[0]) and create_gif:
+        destfilename = files[0]
+    else:                     
+        util.sort_rename_frames(os.path.dirname(images_path))
+        destfilename = os.path.join(roop.globals.output_path, "img2video." + roop.globals.CFG.output_video_format)
+        ffmpeg.create_video('', destfilename, fps, images_path)
+        if os.path.isfile(destfilename):
+            resultfiles.append(destfilename)
+        else:
+            return None
+    if create_gif:
+        gifname = util.get_destfilename_from_path(destfilename, './output', '.gif')
+        ffmpeg.create_gif_from_video(destfilename, gifname)
+        if os.path.isfile(destfilename):
+            resultfiles.append(gifname)
+    return resultfiles
+    
+
+def on_extras_extract_frames(files):
+    if files is None:
+        return None
+    
+    resultfiles = []
+    for tf in files:
+        f = tf.name
+        resfolder = ffmpeg.extract_frames(f)
+        for file in os.listdir(resfolder):
+            outfile = os.path.join(resfolder, file)
+            if os.path.isfile(outfile):
+                resultfiles.append(outfile)
+    return resultfiles
+
+
+def on_frame_process(files, filterselection, upscaleselection):
+    import pathlib
+    from roop.core import batch_process_with_options
+    from roop.ProcessEntry import ProcessEntry
+    from roop.ProcessOptions import ProcessOptions
+    from ui.main import prepare_environment
+
+
+    if files is None:
+        return None
+
+    if roop.globals.CFG.clear_output:
+        clean_dir(roop.globals.output_path)
+    prepare_environment()
+    list_files_process : list[ProcessEntry] = []
+
+    for tf in files:
+        list_files_process.append(ProcessEntry(tf.name, 0,0, 0))
+
+    processoroptions = {}
+    filter = next((x for x in frame_filters_map.keys() if x == filterselection), None)
+    if filter is not None:
+        processoroptions.update(frame_filters_map[filter])
+    filter = next((x for x in frame_upscalers_map.keys() if x == upscaleselection), None)
+    if filter is not None:
+        processoroptions.update(frame_upscalers_map[filter])
+    options = ProcessOptions(None, processoroptions, 0,  0, "all", 0, None, None, 0, 128, False, False)
+    batch_process_with_options(list_files_process, options, None)
+    outdir = pathlib.Path(roop.globals.output_path)
+    outfiles = [str(item) for item in outdir.rglob("*") if item.is_file()]
+    return outfiles
+
+

ui/tabs/facemgr_tab.py

@@ -0,0 +1,187 @@
+import os
+import shutil
+import cv2
+import gradio as gr
+import roop.utilities as util
+import roop.globals
+from roop.face_util import extract_face_images
+from roop.capturer import get_video_frame, get_video_frame_total
+from typing import List, Tuple, Optional
+from roop.typing import Frame, Face, FaceSet
+
+selected_face_index = -1
+thumbs = []
+images = []
+
+
+def facemgr_tab() -> None:
+    with gr.Tab("👨‍👩‍👧‍👦 Face Management"):
+        with gr.Row():
+            gr.Markdown("""
+                        # Create blending facesets
+                        Add multiple reference images into a faceset file.
+                        """)
+        with gr.Row():
+            videoimagefst = gr.Image(label="Cut face from video frame", height=576, interactive=False, visible=True, format="jpeg")
+        with gr.Row():
+            frame_num_fst = gr.Slider(1, 1, value=1, label="Frame Number", info='0:00:00', step=1.0, interactive=False)
+            fb_cutfromframe = gr.Button("Use faces from this frame", variant='secondary', interactive=False)
+        with gr.Row():
+            fb_facesetfile = gr.Files(label='Faceset', file_count='single', file_types=['.fsz'], interactive=True)
+            fb_files = gr.Files(label='Input Files', file_count="multiple", file_types=["image", "video"], interactive=True)
+        with gr.Row():
+            with gr.Column():
+                gr.Button("👀 Open Output Folder", size='sm').click(fn=lambda: util.open_folder(roop.globals.output_path))
+            with gr.Column():
+                gr.Markdown(' ')
+        with gr.Row():
+            faces = gr.Gallery(label="Faces in this Faceset", allow_preview=True, preview=True, height=128, object_fit="scale-down")
+        with gr.Row():
+            fb_remove = gr.Button("Remove selected", variant='secondary')
+            fb_update = gr.Button("Create/Update Faceset file", variant='primary')
+            fb_clear = gr.Button("Clear all", variant='stop')
+
+    fb_facesetfile.change(fn=on_faceset_changed, inputs=[fb_facesetfile], outputs=[faces])
+    fb_files.change(fn=on_fb_files_changed, inputs=[fb_files], outputs=[faces, videoimagefst, frame_num_fst, fb_cutfromframe])
+    fb_update.click(fn=on_update_clicked, outputs=[fb_facesetfile])
+    fb_remove.click(fn=on_remove_clicked, outputs=[faces])
+    fb_clear.click(fn=on_clear_clicked, outputs=[faces, fb_files, fb_facesetfile])
+    fb_cutfromframe.click(fn=on_cutfromframe_clicked, inputs=[fb_files, frame_num_fst], outputs=[faces])
+    frame_num_fst.release(fn=on_frame_num_fst_changed, inputs=[fb_files, frame_num_fst], outputs=[videoimagefst])
+    faces.select(fn=on_face_selected)
+
+
+def on_faceset_changed(faceset, progress=gr.Progress()) -> List[Frame]:
+    global thumbs, images
+
+    if faceset is None:
+        return thumbs
+
+    thumbs.clear()
+    filename = faceset.name
+        
+    if filename.lower().endswith('fsz'):
+        progress(0, desc="Retrieving faces from Faceset File", )      
+        unzipfolder = os.path.join(os.environ["TEMP"], 'faceset')
+        if os.path.isdir(unzipfolder):
+            shutil.rmtree(unzipfolder)
+        util.mkdir_with_umask(unzipfolder)
+        util.unzip(filename, unzipfolder)
+        for file in os.listdir(unzipfolder):
+            if file.endswith(".png"):
+                SELECTION_FACES_DATA = extract_face_images(os.path.join(unzipfolder,file),  (False, 0), 0.5)
+                if len(SELECTION_FACES_DATA) < 1:
+                    gr.Warning(f"No face detected in {file}!")
+                for f in SELECTION_FACES_DATA:
+                    image = f[1]
+                    images.append(image)
+                    thumbs.append(util.convert_to_gradio(image))
+        
+        return thumbs
+
+
+def on_fb_files_changed(inputfiles, progress=gr.Progress()) -> Tuple[List[Frame], Optional[gr.Image], Optional[gr.Slider], Optional[gr.Button]]:
+    global thumbs, images, total_frames, current_video_fps
+
+    if inputfiles is None or len(inputfiles) < 1:
+        return thumbs, None, None, None
+    
+    progress(0, desc="Retrieving faces from images", )
+    slider = None
+    video_image = None
+    cut_button = None
+    for f in inputfiles:
+        source_path = f.name
+        if util.has_image_extension(source_path):
+            slider = gr.Slider(interactive=False)
+            video_image = gr.Image(interactive=False)
+            cut_button = gr.Button(interactive=False)
+            roop.globals.source_path = source_path
+            SELECTION_FACES_DATA = extract_face_images(roop.globals.source_path,  (False, 0), 0.5)
+            for f in SELECTION_FACES_DATA:
+                image = f[1]
+                images.append(image)
+                thumbs.append(util.convert_to_gradio(image))
+        elif util.is_video(source_path) or source_path.lower().endswith('gif'):
+            total_frames = get_video_frame_total(source_path)
+            current_video_fps = util.detect_fps(source_path)
+            cut_button = gr.Button(interactive=True)
+            video_image, slider = display_video_frame(source_path, 1, total_frames)
+
+    return thumbs, video_image, slider, cut_button
+    
+
+def display_video_frame(filename: str, frame_num: int, total: int=0) -> Tuple[gr.Image, gr.Slider]:
+    global current_video_fps
+
+    current_frame = get_video_frame(filename, frame_num)
+    if current_video_fps == 0:
+        current_video_fps = 1
+    secs = (frame_num - 1) / current_video_fps
+    minutes = secs / 60
+    secs = secs % 60
+    hours = minutes / 60
+    minutes = minutes % 60
+    milliseconds = (secs - int(secs)) * 1000
+    timeinfo = f"{int(hours):0>2}:{int(minutes):0>2}:{int(secs):0>2}.{int(milliseconds):0>3}"
+    if total > 0:
+        return gr.Image(value=util.convert_to_gradio(current_frame), interactive=True), gr.Slider(info=timeinfo, minimum=1, maximum=total, interactive=True)  
+    return gr.Image(value=util.convert_to_gradio(current_frame), interactive=True), gr.Slider(info=timeinfo, interactive=True)  
+
+
+def on_face_selected(evt: gr.SelectData) -> None:
+    global selected_face_index
+
+    if evt is not None:
+        selected_face_index = evt.index
+
+def on_frame_num_fst_changed(inputfiles: List[gr.Files], frame_num: int) -> Frame:
+    filename = inputfiles[0].name
+    video_image, _ = display_video_frame(filename, frame_num, 0)
+    return video_image
+
+
+def on_cutfromframe_clicked(inputfiles: List[gr.Files], frame_num: int) -> List[Frame]:
+    global thumbs
+
+    filename = inputfiles[0].name
+    SELECTION_FACES_DATA = extract_face_images(filename,  (True, frame_num), 0.5)
+    for f in SELECTION_FACES_DATA:
+        image = f[1]
+        images.append(image)
+        thumbs.append(util.convert_to_gradio(image))
+    return thumbs
+
+
+def on_remove_clicked() -> List[Frame]:
+    global thumbs, images, selected_face_index
+
+    if len(thumbs) > selected_face_index:
+        f = thumbs.pop(selected_face_index)
+        del f
+        f = images.pop(selected_face_index)
+        del f
+    return thumbs
+
+def on_clear_clicked() -> Tuple[List[Frame], None, None]:
+    global thumbs, images
+
+    thumbs.clear()
+    images.clear()
+    return thumbs, None, None
+
+
+def on_update_clicked() -> Optional[str]:
+    if len(images) < 1:
+        gr.Warning(f"No faces to create faceset from!")
+        return None
+
+    imgnames = []
+    for index,img in enumerate(images):
+        filename = os.path.join(roop.globals.output_path, f'{index}.png')
+        cv2.imwrite(filename, img)
+        imgnames.append(filename)
+
+    finalzip = os.path.join(roop.globals.output_path, 'faceset.fsz')        
+    util.zip(imgnames, finalzip)
+    return finalzip

ui/tabs/faceswap_tab.py

@@ -0,0 +1,835 @@
+import os
+import shutil
+import pathlib
+import gradio as gr
+import roop.utilities as util
+import roop.globals
+import ui.globals
+from roop.face_util import extract_face_images, create_blank_image
+from roop.capturer import get_video_frame, get_video_frame_total, get_image_frame
+from roop.ProcessEntry import ProcessEntry
+from roop.ProcessOptions import ProcessOptions
+from roop.FaceSet import FaceSet
+from roop.utilities import clean_dir
+
+last_image = None
+
+
+IS_INPUT = True
+SELECTED_FACE_INDEX = 0
+
+SELECTED_INPUT_FACE_INDEX = 0
+SELECTED_TARGET_FACE_INDEX = 0
+
+input_faces = None
+target_faces = None
+face_selection = None
+previewimage = None
+
+selected_preview_index = 0
+
+is_processing = False            
+
+list_files_process : list[ProcessEntry] = []
+model_swap_choices = ["InSwapper 128", "ReSwapper 128", "ReSwapper 256"]
+
+no_face_choices = ["Use untouched original frame","Retry rotated", "Skip Frame", "Skip Frame if no similar face", "Use last swapped"]
+swap_choices = ["First found", "All input faces", "All input faces (random)", "All female", "All male", "All faces", "Selected face"]
+
+current_video_fps = 50
+
+manual_masking = False
+
+
+def faceswap_tab():
+    global no_face_choices, previewimage
+
+    with gr.Tab("🎭 Face Swap"):
+        with gr.Row(variant='panel'):
+            with gr.Column(scale=2):
+                with gr.Row():
+                    input_faces = gr.Gallery(label="Input faces gallery", allow_preview=False, preview=False, height=138, columns=64, object_fit="scale-down", interactive=False)
+                    target_faces = gr.Gallery(label="Target faces gallery", allow_preview=False, preview=False, height=138, columns=64, object_fit="scale-down", interactive=False)
+                with gr.Row():
+                    bt_move_left_input = gr.Button("⬅ Move left", size='sm')
+                    bt_move_right_input = gr.Button("➡ Move right", size='sm')
+                    bt_move_left_target = gr.Button("⬅ Move left", size='sm')
+                    bt_move_right_target = gr.Button("➡ Move right", size='sm')
+                with gr.Row():
+                    bt_remove_selected_input_face = gr.Button("❌ Remove selected", size='sm')
+                    bt_clear_input_faces = gr.Button("💥 Clear all", variant='stop', size='sm')
+                    bt_remove_selected_target_face = gr.Button("❌ Remove selected", size='sm')
+                    bt_add_local = gr.Button('Add local files from', size='sm')
+
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        with gr.Accordion(label="Advanced Masking", open=False):
+                            chk_showmaskoffsets = gr.Checkbox(
+                                label="Show mask overlay in preview",
+                                value=False,
+                                interactive=True,
+                            )
+                            chk_restoreoriginalmouth = gr.Checkbox(
+                                label="Restore original mouth area",
+                                value=False,
+                                interactive=True,
+                            )
+                            mask_top = gr.Slider(
+                                0,
+                                1.0,
+                                value=0,
+                                label="Offset Face Top",
+                                step=0.01,
+                                interactive=True,
+                            )
+                            mask_bottom = gr.Slider(
+                                0,
+                                1.0,
+                                value=0,
+                                label="Offset Face Bottom",
+                                step=0.01,
+                                interactive=True,
+                            )
+                            mask_left = gr.Slider(
+                                0,
+                                1.0,
+                                value=0,
+                                label="Offset Face Left",
+                                step=0.01,
+                                interactive=True,
+                            )
+                            mask_right = gr.Slider(
+                                0,
+                                1.0,
+                                value=0,
+                                label="Offset Face Right",
+                                step=0.01,
+                                interactive=True,
+                            )
+                            mask_erosion = gr.Slider(
+                                1.0,
+                                3.0,
+                                value=1.0,
+                                label="Erosion Iterations",
+                                step=1.00,
+                                interactive=True,
+                            )
+                            mask_blur = gr.Slider(
+                                10.0,
+                                50.0,
+                                value=20.0,
+                                label="Blur size",
+                                step=1.00,
+                                interactive=True,
+                            )
+                            bt_toggle_masking = gr.Button(
+                                "Toggle manual masking", variant="secondary", size="sm"
+                            )
+                            selected_mask_engine = gr.Dropdown(
+                                ["None", "Clip2Seg", "DFL XSeg"],
+                                value="None",
+                                label="Face masking engine",
+                            )
+                            clip_text = gr.Textbox(
+                                label="List of objects to mask and restore back on fake face",
+                                value="cup,hands,hair,banana",
+                                interactive=False,
+                            )
+                            bt_preview_mask = gr.Button(
+                                "👥 Show Mask Preview", variant="secondary"
+                            )
+                    with gr.Column(scale=2):
+                        local_folder = gr.Textbox(show_label=False, placeholder="/content/", interactive=True)
+                with gr.Row(variant='panel'):
+                    bt_srcfiles = gr.Files(label='Source Images or Facesets', file_count="multiple", file_types=["image", ".fsz", ".webp"], elem_id='filelist', height=233)
+                    bt_destfiles = gr.Files(label='Target File(s)', file_count="multiple", file_types=["image", "video", ".webp"], elem_id='filelist', height=233)
+                with gr.Row(variant='panel'):
+                    ui.globals.ui_selected_swap_model = gr.Dropdown(model_swap_choices, value=model_swap_choices[0], label="Specify Face Swap Model")
+                    forced_fps = gr.Slider(minimum=0, maximum=120, value=0, label="Video FPS", info='Overrides detected fps if not 0', step=1.0, interactive=True, container=True)
+
+            with gr.Column(scale=2):
+                previewimage = gr.Image(label="Preview Image", height=576, interactive=False, visible=True, format=get_gradio_output_format())
+                maskimage = gr.ImageEditor(label="Manual mask Image", sources=["clipboard"], transforms="", type="numpy",
+                                             brush=gr.Brush(color_mode="fixed", colors=["rgba(255, 255, 255, 1"]), interactive=True, visible=False)
+                with gr.Row(variant='panel'):
+                    fake_preview = gr.Checkbox(label="Face swap frames", value=False)
+                    bt_refresh_preview = gr.Button("🔄 Refresh", variant='secondary', size='sm')
+                    bt_use_face_from_preview = gr.Button("Use Face from this Frame", variant='primary', size='sm')
+                with gr.Row():
+                    preview_frame_num = gr.Slider(1, 1, value=1, label="Frame Number", info='0:00:00', step=1.0, interactive=True)
+                with gr.Row():
+                    text_frame_clip = gr.Markdown('Processing frame range [0 - 0]')
+                    set_frame_start = gr.Button("⬅ Set as Start", size='sm')
+                    set_frame_end = gr.Button("➡ Set as End", size='sm')
+        with gr.Row(visible=False) as dynamic_face_selection:
+            with gr.Column(scale=2):
+                face_selection = gr.Gallery(label="Detected faces", allow_preview=False, preview=False, height=138, object_fit="cover", columns=32)
+            with gr.Column():
+                bt_faceselect = gr.Button("☑ Use selected face", size='sm')
+                bt_cancelfaceselect = gr.Button("Done", size='sm')
+            with gr.Column():
+                gr.Markdown(' ') 
+
+        with gr.Row(variant='panel'):
+            with gr.Column(scale=1):
+                selected_face_detection = gr.Dropdown(swap_choices, value="First found", label="Specify face selection for swapping")
+            with gr.Column(scale=1):
+                num_swap_steps = gr.Slider(1, 5, value=1, step=1.0, label="Number of swapping steps", info="More steps may increase likeness")
+            with gr.Column(scale=2):
+                ui.globals.ui_selected_enhancer = gr.Dropdown(["None", "Codeformer", "DMDNet", "GFPGAN", "GPEN", "Restoreformer++"], value="None", label="Select post-processing")
+
+        with gr.Row(variant='panel'):
+            with gr.Column(scale=1):
+                max_face_distance = gr.Slider(0.01, 1.0, value=0.65, label="Max Face Similarity Threshold", info="0.0 = identical 1.0 = no similarity")
+            with gr.Column(scale=1):
+                ui.globals.ui_upscale = gr.Dropdown(["128px", "256px", "512px"], value="128px", label="Subsample upscale to", interactive=True)
+            with gr.Column(scale=2):
+                ui.globals.ui_blend_ratio = gr.Slider(0.0, 1.0, value=0.65, label="Original/Enhanced image blend ratio", info="Only used with active post-processing")
+
+        with gr.Row(variant='panel'):
+            with gr.Column(scale=1):
+                video_swapping_method = gr.Dropdown(["Extract Frames to media","In-Memory processing"], value="In-Memory processing", label="Select video processing method", interactive=True)
+                no_face_action = gr.Dropdown(choices=no_face_choices, value=no_face_choices[0], label="Action on no face detected", interactive=True)
+                vr_mode = gr.Checkbox(label="VR Mode", value=False)
+            with gr.Column(scale=1):
+                with gr.Group():
+                    autorotate = gr.Checkbox(label="Auto rotate horizontal Faces", value=True)
+                    roop.globals.skip_audio = gr.Checkbox(label="Skip audio", value=False)
+                    roop.globals.keep_frames = gr.Checkbox(label="Keep Frames (relevant only when extracting frames)", value=False)
+                    roop.globals.wait_after_extraction = gr.Checkbox(label="Wait for user key press before creating video ", value=False)
+
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                bt_start = gr.Button("▶ Start", variant='primary')
+            with gr.Column():
+                bt_stop = gr.Button("⏹ Stop", variant='secondary', interactive=False)
+                gr.Button("👀 Open Output Folder", size='sm').click(fn=lambda: util.open_folder(roop.globals.output_path))
+            with gr.Column(scale=2):
+                output_method = gr.Dropdown(["File","Virtual Camera", "Both"], value="File", label="Select Output Method", interactive=True)
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                resultfiles = gr.Files(label='Processed File(s)', interactive=False)
+            with gr.Column():
+                resultimage = gr.Image(type='filepath', label='Final Image', interactive=False )
+                resultvideo = gr.Video(label='Final Video', interactive=False, visible=False)
+
+    previewinputs = [ui.globals.ui_selected_swap_model, preview_frame_num, bt_destfiles, fake_preview, ui.globals.ui_selected_enhancer, selected_face_detection,
+                        max_face_distance, ui.globals.ui_blend_ratio, selected_mask_engine, clip_text, no_face_action, vr_mode, autorotate, maskimage, chk_showmaskoffsets, chk_restoreoriginalmouth, num_swap_steps, ui.globals.ui_upscale]
+    previewoutputs = [previewimage, maskimage, preview_frame_num] 
+    input_faces.select(on_select_input_face, None, None).success(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs)
+    
+    bt_move_left_input.click(fn=move_selected_input, inputs=[bt_move_left_input], outputs=[input_faces])
+    bt_move_right_input.click(fn=move_selected_input, inputs=[bt_move_right_input], outputs=[input_faces])
+    bt_move_left_target.click(fn=move_selected_target, inputs=[bt_move_left_target], outputs=[target_faces])
+    bt_move_right_target.click(fn=move_selected_target, inputs=[bt_move_right_target], outputs=[target_faces])
+
+    bt_remove_selected_input_face.click(fn=remove_selected_input_face, outputs=[input_faces])
+    bt_srcfiles.change(fn=on_srcfile_changed, show_progress='full', inputs=bt_srcfiles, outputs=[dynamic_face_selection, face_selection, input_faces, bt_srcfiles])
+
+    mask_top.release(fn=on_mask_top_changed, inputs=[mask_top], show_progress='hidden')
+    mask_bottom.release(fn=on_mask_bottom_changed, inputs=[mask_bottom], show_progress='hidden')
+    mask_left.release(fn=on_mask_left_changed, inputs=[mask_left], show_progress='hidden')
+    mask_right.release(fn=on_mask_right_changed, inputs=[mask_right], show_progress='hidden')
+    mask_erosion.release(fn=on_mask_erosion_changed, inputs=[mask_erosion], show_progress='hidden')
+    mask_blur.release(fn=on_mask_blur_changed, inputs=[mask_blur], show_progress='hidden')
+    selected_mask_engine.change(fn=on_mask_engine_changed, inputs=[selected_mask_engine], outputs=[clip_text], show_progress='hidden')
+
+    target_faces.select(on_select_target_face, None, None)
+    bt_remove_selected_target_face.click(fn=remove_selected_target_face, outputs=[target_faces])
+
+    forced_fps.change(fn=on_fps_changed, inputs=[forced_fps], show_progress='hidden')
+    bt_destfiles.change(fn=on_destfiles_changed, inputs=[bt_destfiles], outputs=[preview_frame_num, text_frame_clip], show_progress='hidden').success(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs, show_progress='hidden')
+    bt_destfiles.select(fn=on_destfiles_selected, outputs=[preview_frame_num, text_frame_clip, forced_fps], show_progress='hidden').success(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs, show_progress='hidden')
+    bt_destfiles.clear(fn=on_clear_destfiles, outputs=[target_faces, selected_face_detection])
+    resultfiles.select(fn=on_resultfiles_selected, inputs=[resultfiles], outputs=[resultimage, resultvideo])
+
+    face_selection.select(on_select_face, None, None)
+    bt_faceselect.click(fn=on_selected_face, outputs=[input_faces, target_faces, selected_face_detection])
+    bt_cancelfaceselect.click(fn=on_end_face_selection, outputs=[dynamic_face_selection, face_selection])
+
+    bt_clear_input_faces.click(fn=on_clear_input_faces, outputs=[input_faces])
+
+    bt_add_local.click(fn=on_add_local_folder, inputs=[local_folder], outputs=[bt_destfiles])
+    bt_preview_mask.click(fn=on_preview_mask, inputs=[ui.globals.ui_selected_swap_model, preview_frame_num, bt_destfiles, clip_text, selected_mask_engine], outputs=[previewimage]) 
+
+    start_event = bt_start.click(fn=start_swap, 
+        inputs=[ui.globals.ui_selected_swap_model, output_method, ui.globals.ui_selected_enhancer, selected_face_detection, roop.globals.keep_frames, roop.globals.wait_after_extraction,
+                    roop.globals.skip_audio, max_face_distance, ui.globals.ui_blend_ratio, selected_mask_engine, clip_text,video_swapping_method, no_face_action, vr_mode, autorotate, chk_restoreoriginalmouth, num_swap_steps, ui.globals.ui_upscale, maskimage],
+        outputs=[bt_start, bt_stop, resultfiles], show_progress='full')
+    after_swap_event = start_event.success(fn=on_resultfiles_finished, inputs=[resultfiles], outputs=[resultimage, resultvideo])
+
+    bt_stop.click(fn=stop_swap, cancels=[start_event, after_swap_event], outputs=[bt_start, bt_stop], queue=False)
+
+    bt_refresh_preview.click(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs)            
+    bt_toggle_masking.click(fn=on_toggle_masking, inputs=[previewimage, maskimage], outputs=[previewimage, maskimage])            
+    fake_preview.change(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs)
+    preview_frame_num.release(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs, show_progress='hidden', )
+    bt_use_face_from_preview.click(fn=on_use_face_from_selected, show_progress='full', inputs=[bt_destfiles, preview_frame_num], outputs=[dynamic_face_selection, face_selection, target_faces, selected_face_detection])
+    set_frame_start.click(fn=on_set_frame, inputs=[set_frame_start, preview_frame_num], outputs=[text_frame_clip])
+    set_frame_end.click(fn=on_set_frame, inputs=[set_frame_end, preview_frame_num], outputs=[text_frame_clip])
+
+
+def on_mask_top_changed(mask_offset):
+    set_mask_offset(0, mask_offset)
+
+def on_mask_bottom_changed(mask_offset):
+    set_mask_offset(1, mask_offset)
+
+def on_mask_left_changed(mask_offset):
+    set_mask_offset(2, mask_offset)
+
+def on_mask_right_changed(mask_offset):
+    set_mask_offset(3, mask_offset)
+
+def on_mask_erosion_changed(mask_offset):
+    set_mask_offset(4, mask_offset)
+def on_mask_blur_changed(mask_offset):
+    set_mask_offset(5, mask_offset)
+
+
+def set_mask_offset(index, mask_offset):
+    global SELECTED_INPUT_FACE_INDEX
+
+    if len(roop.globals.INPUT_FACESETS) > SELECTED_INPUT_FACE_INDEX:
+        offs = roop.globals.INPUT_FACESETS[SELECTED_INPUT_FACE_INDEX].faces[0].mask_offsets
+        offs[index] = mask_offset
+        if offs[0] + offs[1] > 0.99:
+            offs[0] = 0.99
+            offs[1] = 0.0
+        if offs[2] + offs[3] > 0.99:
+            offs[2] = 0.99
+            offs[3] = 0.0
+        roop.globals.INPUT_FACESETS[SELECTED_INPUT_FACE_INDEX].faces[0].mask_offsets = offs
+
+def on_mask_engine_changed(mask_engine):
+    if mask_engine == "Clip2Seg":
+        return gr.Textbox(interactive=True)
+    return gr.Textbox(interactive=False)
+
+
+def on_add_local_folder(folder):
+    files = util.get_local_files_from_folder(folder)
+    if files is None:
+        gr.Warning("Empty folder or folder not found!")
+    return files
+
+
+def on_srcfile_changed(srcfiles, progress=gr.Progress()):
+    global SELECTION_FACES_DATA, IS_INPUT, input_faces, face_selection, last_image
+    
+    IS_INPUT = True
+
+    if srcfiles is None or len(srcfiles) < 1:
+        return gr.Column(visible=False), None, ui.globals.ui_input_thumbs, None
+
+    for f in srcfiles:    
+        source_path = f.name
+        if source_path.lower().endswith('fsz'):
+            progress(0, desc="Retrieving faces from Faceset File")      
+            unzipfolder = os.path.join(os.environ["TEMP"], 'faceset')
+            if os.path.isdir(unzipfolder):
+                files = os.listdir(unzipfolder)
+                for file in files:
+                    os.remove(os.path.join(unzipfolder, file))
+            else:
+                os.makedirs(unzipfolder)
+            util.mkdir_with_umask(unzipfolder)
+            util.unzip(source_path, unzipfolder)
+            is_first = True
+            face_set = FaceSet()
+            for file in os.listdir(unzipfolder):
+                if file.endswith(".png"):
+                    filename = os.path.join(unzipfolder,file)
+                    progress(0, desc="Extracting faceset")      
+                    SELECTION_FACES_DATA = extract_face_images(filename,  (False, 0))
+                    for f in SELECTION_FACES_DATA:
+                        face = f[0]
+                        face.mask_offsets = (0,0,0,0,1,20)
+                        face_set.faces.append(face)
+                        if is_first: 
+                            image = util.convert_to_gradio(f[1])
+                            ui.globals.ui_input_thumbs.append(image)
+                            is_first = False
+                        face_set.ref_images.append(get_image_frame(filename))
+            if len(face_set.faces) > 0:
+                if len(face_set.faces) > 1:
+                    face_set.AverageEmbeddings()
+                roop.globals.INPUT_FACESETS.append(face_set)
+                                        
+        elif util.has_image_extension(source_path):
+            progress(0, desc="Retrieving faces from image")      
+            roop.globals.source_path = source_path
+            SELECTION_FACES_DATA = extract_face_images(roop.globals.source_path,  (False, 0))
+            progress(0.5, desc="Retrieving faces from image")
+            for f in SELECTION_FACES_DATA:
+                face_set = FaceSet()
+                face = f[0]
+                face.mask_offsets = (0,0,0,0,1,20)
+                face_set.faces.append(face)
+                image = util.convert_to_gradio(f[1])
+                ui.globals.ui_input_thumbs.append(image)
+                roop.globals.INPUT_FACESETS.append(face_set)
+                
+    progress(1.0)
+    return gr.Column(visible=False), None, ui.globals.ui_input_thumbs,None
+
+
+def on_select_input_face(evt: gr.SelectData):
+    global SELECTED_INPUT_FACE_INDEX
+
+    SELECTED_INPUT_FACE_INDEX = evt.index
+
+
+def remove_selected_input_face():
+    global SELECTED_INPUT_FACE_INDEX
+
+    if len(roop.globals.INPUT_FACESETS) > SELECTED_INPUT_FACE_INDEX:
+        f = roop.globals.INPUT_FACESETS.pop(SELECTED_INPUT_FACE_INDEX)
+        del f
+    if len(ui.globals.ui_input_thumbs) > SELECTED_INPUT_FACE_INDEX:
+        f = ui.globals.ui_input_thumbs.pop(SELECTED_INPUT_FACE_INDEX)
+        del f
+
+    return ui.globals.ui_input_thumbs
+
+def move_selected_input(button_text):
+    global SELECTED_INPUT_FACE_INDEX
+
+    if button_text == "⬅ Move left":
+        if SELECTED_INPUT_FACE_INDEX <= 0:
+            return ui.globals.ui_input_thumbs
+        offset = -1
+    else:
+        if len(ui.globals.ui_input_thumbs) <= SELECTED_INPUT_FACE_INDEX:
+            return ui.globals.ui_input_thumbs
+        offset = 1
+    
+    f = roop.globals.INPUT_FACESETS.pop(SELECTED_INPUT_FACE_INDEX)
+    roop.globals.INPUT_FACESETS.insert(SELECTED_INPUT_FACE_INDEX + offset, f)
+    f = ui.globals.ui_input_thumbs.pop(SELECTED_INPUT_FACE_INDEX)
+    ui.globals.ui_input_thumbs.insert(SELECTED_INPUT_FACE_INDEX + offset, f)
+    return ui.globals.ui_input_thumbs
+        
+
+def move_selected_target(button_text):
+    global SELECTED_TARGET_FACE_INDEX
+
+    if button_text == "⬅ Move left":
+        if SELECTED_TARGET_FACE_INDEX <= 0:
+            return ui.globals.ui_target_thumbs
+        offset = -1
+    else:
+        if len(ui.globals.ui_target_thumbs) <= SELECTED_TARGET_FACE_INDEX:
+            return ui.globals.ui_target_thumbs
+        offset = 1
+    
+    f = roop.globals.TARGET_FACES.pop(SELECTED_TARGET_FACE_INDEX)
+    roop.globals.TARGET_FACES.insert(SELECTED_TARGET_FACE_INDEX + offset, f)
+    f = ui.globals.ui_target_thumbs.pop(SELECTED_TARGET_FACE_INDEX)
+    ui.globals.ui_target_thumbs.insert(SELECTED_TARGET_FACE_INDEX + offset, f)
+    return ui.globals.ui_target_thumbs
+
+
+
+
+def on_select_target_face(evt: gr.SelectData):
+    global SELECTED_TARGET_FACE_INDEX
+
+    SELECTED_TARGET_FACE_INDEX = evt.index
+
+def remove_selected_target_face():
+    if len(ui.globals.ui_target_thumbs) > SELECTED_TARGET_FACE_INDEX:
+        f = roop.globals.TARGET_FACES.pop(SELECTED_TARGET_FACE_INDEX)
+        del f
+    if len(ui.globals.ui_target_thumbs) > SELECTED_TARGET_FACE_INDEX:
+        f = ui.globals.ui_target_thumbs.pop(SELECTED_TARGET_FACE_INDEX)
+        del f
+    return ui.globals.ui_target_thumbs
+
+
+def on_use_face_from_selected(files, frame_num):
+    global IS_INPUT, SELECTION_FACES_DATA
+
+    IS_INPUT = False
+    thumbs = []
+    
+    roop.globals.target_path = files[selected_preview_index].name
+    if util.is_image(roop.globals.target_path) and not roop.globals.target_path.lower().endswith(('gif')):
+        SELECTION_FACES_DATA = extract_face_images(roop.globals.target_path,  (False, 0))
+        if len(SELECTION_FACES_DATA) > 0:
+            for f in SELECTION_FACES_DATA:
+                image = util.convert_to_gradio(f[1])
+                thumbs.append(image)
+        else:
+            gr.Info('No faces detected!')
+            roop.globals.target_path = None
+                
+    elif util.is_video(roop.globals.target_path) or roop.globals.target_path.lower().endswith(('gif')):
+        selected_frame = frame_num
+        SELECTION_FACES_DATA = extract_face_images(roop.globals.target_path, (True, selected_frame))
+        if len(SELECTION_FACES_DATA) > 0:
+            for f in SELECTION_FACES_DATA:
+                image = util.convert_to_gradio(f[1])
+                thumbs.append(image)
+        else:
+            gr.Info('No faces detected!')
+            roop.globals.target_path = None
+    else:
+        gr.Info('Unknown image/video type!')
+        roop.globals.target_path = None
+
+    if len(thumbs) == 1:
+        roop.globals.TARGET_FACES.append(SELECTION_FACES_DATA[0][0])
+        ui.globals.ui_target_thumbs.append(thumbs[0])
+        return gr.Row(visible=False), None, ui.globals.ui_target_thumbs, gr.Dropdown(value='Selected face')
+
+    return gr.Row(visible=True), thumbs, gr.Gallery(visible=True), gr.Dropdown(visible=True)
+
+
+def on_select_face(evt: gr.SelectData):  # SelectData is a subclass of EventData
+    global SELECTED_FACE_INDEX
+    SELECTED_FACE_INDEX = evt.index
+
+
+def on_selected_face():
+    global IS_INPUT, SELECTED_FACE_INDEX, SELECTION_FACES_DATA
+    
+    fd = SELECTION_FACES_DATA[SELECTED_FACE_INDEX]
+    image = util.convert_to_gradio(fd[1])
+    if IS_INPUT:
+        face_set = FaceSet()
+        fd[0].mask_offsets = (0,0,0,0,1,20)
+        face_set.faces.append(fd[0])
+        roop.globals.INPUT_FACESETS.append(face_set)
+        ui.globals.ui_input_thumbs.append(image)
+        return ui.globals.ui_input_thumbs, gr.Gallery(visible=True), gr.Dropdown(visible=True)
+    else:
+        roop.globals.TARGET_FACES.append(fd[0])
+        ui.globals.ui_target_thumbs.append(image)
+        return gr.Gallery(visible=True), ui.globals.ui_target_thumbs, gr.Dropdown(value='Selected face')
+
+#        bt_faceselect.click(fn=on_selected_face, outputs=[dynamic_face_selection, face_selection, input_faces, target_faces])
+
+def on_end_face_selection():
+    return gr.Column(visible=False), None
+
+
+def on_preview_frame_changed(swap_model, frame_num, files, fake_preview, enhancer, detection, face_distance, blend_ratio,
+                              selected_mask_engine, clip_text, no_face_action, vr_mode, auto_rotate, maskimage, show_face_area, restore_original_mouth, num_steps, upsample):
+    global SELECTED_INPUT_FACE_INDEX, manual_masking, current_video_fps
+
+    from roop.core import live_swap, get_processing_plugins
+
+    manual_masking = False
+    mask_offsets = (0,0,0,0)
+    if len(roop.globals.INPUT_FACESETS) > SELECTED_INPUT_FACE_INDEX:
+        if not hasattr(roop.globals.INPUT_FACESETS[SELECTED_INPUT_FACE_INDEX].faces[0], 'mask_offsets'):
+            roop.globals.INPUT_FACESETS[SELECTED_INPUT_FACE_INDEX].faces[0].mask_offsets = mask_offsets
+        mask_offsets = roop.globals.INPUT_FACESETS[SELECTED_INPUT_FACE_INDEX].faces[0].mask_offsets
+
+    timeinfo = '0:00:00'
+    if files is None or selected_preview_index >= len(files) or frame_num is None:
+        return None,None, gr.Slider(info=timeinfo)
+
+    filename = files[selected_preview_index].name
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        current_frame = get_video_frame(filename, frame_num)
+        if current_video_fps == 0:
+            current_video_fps = 1
+        secs = (frame_num - 1) / current_video_fps
+        minutes = secs / 60
+        secs = secs % 60
+        hours = minutes / 60
+        minutes = minutes % 60
+        milliseconds = (secs - int(secs)) * 1000
+        timeinfo = f"{int(hours):0>2}:{int(minutes):0>2}:{int(secs):0>2}.{int(milliseconds):0>3}"  
+    else:
+        current_frame = get_image_frame(filename)
+    if current_frame is None:
+        return None, None, gr.Slider(info=timeinfo)
+    
+    layers = None
+    if maskimage is not None:
+        layers = maskimage["layers"]
+
+    if not fake_preview or len(roop.globals.INPUT_FACESETS) < 1:
+        return gr.Image(value=util.convert_to_gradio(current_frame), visible=True), gr.ImageEditor(visible=False), gr.Slider(info=timeinfo)
+
+    roop.globals.face_swap_mode = translate_swap_mode(detection)
+    roop.globals.selected_enhancer = enhancer
+    roop.globals.distance_threshold = face_distance
+    roop.globals.blend_ratio = blend_ratio
+    roop.globals.no_face_action = index_of_no_face_action(no_face_action)
+    roop.globals.vr_mode = vr_mode
+    roop.globals.autorotate_faces = auto_rotate
+    roop.globals.subsample_size = int(upsample[:3])
+
+
+    mask_engine = map_mask_engine(selected_mask_engine, clip_text)
+
+    roop.globals.execution_threads = roop.globals.CFG.max_threads
+    mask = layers[0] if layers is not None else None
+    face_index = SELECTED_INPUT_FACE_INDEX
+    if len(roop.globals.INPUT_FACESETS) <= face_index:
+        face_index = 0
+   
+    options = ProcessOptions(swap_model, get_processing_plugins(mask_engine), roop.globals.distance_threshold, roop.globals.blend_ratio,
+                              roop.globals.face_swap_mode, face_index, clip_text, maskimage, num_steps, roop.globals.subsample_size, show_face_area, restore_original_mouth)
+
+    current_frame = live_swap(current_frame, options)
+    if current_frame is None:
+        return gr.Image(visible=True), None, gr.Slider(info=timeinfo)
+    return gr.Image(value=util.convert_to_gradio(current_frame), visible=True), gr.ImageEditor(visible=False), gr.Slider(info=timeinfo)
+
+def map_mask_engine(selected_mask_engine, clip_text):
+    if selected_mask_engine == "Clip2Seg":
+        mask_engine = "mask_clip2seg"
+        if clip_text is None or len(clip_text) < 1:
+          mask_engine = None
+    elif selected_mask_engine == "DFL XSeg":
+        mask_engine = "mask_xseg"
+    else:
+        mask_engine = None
+    return mask_engine
+
+
+def on_toggle_masking(previewimage, mask):
+    global manual_masking
+
+    manual_masking = not manual_masking
+    if manual_masking:
+        layers = mask["layers"]
+        if len(layers) == 1:
+            layers = [create_blank_image(previewimage.shape[1],previewimage.shape[0])]
+        return gr.Image(visible=False), gr.ImageEditor(value={"background": previewimage, "layers": layers, "composite": None}, visible=True)
+    return gr.Image(visible=True), gr.ImageEditor(visible=False)
+
+def gen_processing_text(start, end):
+    return f'Processing frame range [{start} - {end}]'
+
+def on_set_frame(sender:str, frame_num):
+    global selected_preview_index, list_files_process
+    
+    idx = selected_preview_index
+    if list_files_process[idx].endframe == 0:
+        return gen_processing_text(0,0)
+    
+    start = list_files_process[idx].startframe
+    end = list_files_process[idx].endframe
+    if sender.lower().endswith('start'):
+        list_files_process[idx].startframe = min(frame_num, end)
+    else:
+        list_files_process[idx].endframe = max(frame_num, start)
+    
+    return gen_processing_text(list_files_process[idx].startframe,list_files_process[idx].endframe)
+
+
+def on_preview_mask(swap_model, frame_num, files, clip_text, mask_engine):
+    from roop.core import live_swap, get_processing_plugins
+    global is_processing
+
+    if is_processing or files is None or selected_preview_index >= len(files) or clip_text is None or frame_num is None:
+        return None
+        
+    filename = files[selected_preview_index].name
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        current_frame = get_video_frame(filename, frame_num
+                                        )
+    else:
+        current_frame = get_image_frame(filename)
+    if current_frame is None or mask_engine is None:
+        return None
+    if mask_engine == "Clip2Seg":
+        mask_engine = "mask_clip2seg"
+        if clip_text is None or len(clip_text) < 1:
+          mask_engine = None
+    elif mask_engine == "DFL XSeg":
+        mask_engine = "mask_xseg"
+    options = ProcessOptions(swap_model, get_processing_plugins(mask_engine), roop.globals.distance_threshold, roop.globals.blend_ratio,
+                              "all", 0, clip_text, None, 0, 128, False, False, True)
+
+    current_frame = live_swap(current_frame, options)
+    return util.convert_to_gradio(current_frame)
+
+
+def on_clear_input_faces():
+    ui.globals.ui_input_thumbs.clear()
+    roop.globals.INPUT_FACESETS.clear()
+    return ui.globals.ui_input_thumbs
+
+def on_clear_destfiles():
+    roop.globals.TARGET_FACES.clear()
+    ui.globals.ui_target_thumbs.clear()
+    return ui.globals.ui_target_thumbs, gr.Dropdown(value="First found")    
+
+
+def index_of_no_face_action(dropdown_text):
+    global no_face_choices
+
+    return no_face_choices.index(dropdown_text) 
+
+def translate_swap_mode(dropdown_text):
+    if dropdown_text == "Selected face":
+        return "selected"
+    elif dropdown_text == "First found":
+        return "first"
+    elif dropdown_text == "All input faces":
+        return "all_input"
+    elif dropdown_text == "All input faces (random)":
+        return "all_random"
+    elif dropdown_text == "All female":
+        return "all_female"
+    elif dropdown_text == "All male":
+        return "all_male"
+    
+    return "all"
+
+
+def start_swap( swap_model, output_method, enhancer, detection, keep_frames, wait_after_extraction, skip_audio, face_distance, blend_ratio,
+                selected_mask_engine, clip_text, processing_method, no_face_action, vr_mode, autorotate, restore_original_mouth, num_swap_steps, upsample, imagemask, progress=gr.Progress()):
+    from ui.main import prepare_environment
+    from roop.core import batch_process_regular
+    global is_processing, list_files_process
+
+    if list_files_process is None or len(list_files_process) <= 0:
+        return gr.Button(variant="primary"), None, None
+    
+    if roop.globals.CFG.clear_output:
+        clean_dir(roop.globals.output_path)
+
+    if not util.is_installed("ffmpeg"):
+        msg = "ffmpeg is not installed! No video processing possible."
+        gr.Warning(msg)
+
+    prepare_environment()
+
+    roop.globals.selected_enhancer = enhancer
+    roop.globals.target_path = None
+    roop.globals.distance_threshold = face_distance
+    roop.globals.blend_ratio = blend_ratio
+    roop.globals.keep_frames = keep_frames
+    roop.globals.wait_after_extraction = wait_after_extraction
+    roop.globals.skip_audio = skip_audio
+    roop.globals.face_swap_mode = translate_swap_mode(detection)
+    roop.globals.no_face_action = index_of_no_face_action(no_face_action)
+    roop.globals.vr_mode = vr_mode
+    roop.globals.autorotate_faces = autorotate
+    roop.globals.subsample_size = int(upsample[:3])
+    mask_engine = map_mask_engine(selected_mask_engine, clip_text)
+
+    if roop.globals.face_swap_mode == 'selected':
+        if len(roop.globals.TARGET_FACES) < 1:
+            gr.Error('No Target Face selected!')
+            return gr.Button(variant="primary"), None, None
+
+    is_processing = True            
+    yield gr.Button(variant="secondary", interactive=False), gr.Button(variant="primary", interactive=True), None
+    roop.globals.execution_threads = roop.globals.CFG.max_threads
+    roop.globals.video_encoder = roop.globals.CFG.output_video_codec
+    roop.globals.video_quality = roop.globals.CFG.video_quality
+    roop.globals.max_memory = roop.globals.CFG.memory_limit if roop.globals.CFG.memory_limit > 0 else None
+
+    batch_process_regular(swap_model, output_method, list_files_process, mask_engine, clip_text, processing_method == "In-Memory processing", imagemask, restore_original_mouth, num_swap_steps, progress, SELECTED_INPUT_FACE_INDEX)
+    is_processing = False
+    outdir = pathlib.Path(roop.globals.output_path)
+    outfiles = [str(item) for item in outdir.rglob("*") if item.is_file()]
+    if len(outfiles) > 0:
+        yield gr.Button(variant="primary", interactive=True),gr.Button(variant="secondary", interactive=False),gr.Files(value=outfiles)
+    else:
+        yield gr.Button(variant="primary", interactive=True),gr.Button(variant="secondary", interactive=False),None
+
+
+def stop_swap():
+    roop.globals.processing = False
+    gr.Info('Aborting processing - please wait for the remaining threads to be stopped')
+    return gr.Button(variant="primary", interactive=True),gr.Button(variant="secondary", interactive=False),None
+
+
+def on_fps_changed(fps):
+    global selected_preview_index, list_files_process
+
+    if len(list_files_process) < 1 or list_files_process[selected_preview_index].endframe < 1:
+        return
+    list_files_process[selected_preview_index].fps = fps
+
+
+def on_destfiles_changed(destfiles):
+    global selected_preview_index, list_files_process, current_video_fps
+
+    if destfiles is None or len(destfiles) < 1:
+        list_files_process.clear()
+        return gr.Slider(value=1, maximum=1, info='0:00:00'), ''
+    
+    for f in destfiles:
+        list_files_process.append(ProcessEntry(f.name, 0,0, 0))
+
+    selected_preview_index = 0
+    idx = selected_preview_index    
+    
+    filename = list_files_process[idx].filename
+    
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        total_frames = get_video_frame_total(filename)
+        if total_frames is None or total_frames < 1:
+            total_frames = 1
+            gr.Warning(f"Corrupted video {filename}, can't detect number of frames!")
+        else:
+            current_video_fps = util.detect_fps(filename)
+    else:
+        total_frames = 1
+    list_files_process[idx].endframe = total_frames
+    if total_frames > 1:
+        return gr.Slider(value=1, maximum=total_frames, info='0:00:00'), gen_processing_text(list_files_process[idx].startframe,list_files_process[idx].endframe)
+    return gr.Slider(value=1, maximum=total_frames, info='0:00:00'), ''
+
+
+def on_destfiles_selected(evt: gr.SelectData):
+    global selected_preview_index, list_files_process, current_video_fps
+
+    if evt is not None:
+        selected_preview_index = evt.index
+    idx = selected_preview_index    
+    filename = list_files_process[idx].filename
+    fps = list_files_process[idx].fps
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        total_frames = get_video_frame_total(filename)
+        current_video_fps = util.detect_fps(filename)
+        if list_files_process[idx].endframe == 0:
+            list_files_process[idx].endframe = total_frames 
+    else:
+        total_frames = 1
+    
+    if total_frames > 1:
+        return gr.Slider(value=list_files_process[idx].startframe, maximum=total_frames, info='0:00:00'), gen_processing_text(list_files_process[idx].startframe,list_files_process[idx].endframe), fps
+    return gr.Slider(value=1, maximum=total_frames, info='0:00:00'), gen_processing_text(0,0), fps
+
+
+def on_resultfiles_selected(evt: gr.SelectData, files):
+    selected_index = evt.index
+    filename = files[selected_index].name
+    return display_output(filename)
+
+def on_resultfiles_finished(files):
+    selected_index = 0
+    if files is None or len(files) < 1:
+        return None, None
+    
+    filename = files[selected_index].name
+    return display_output(filename)
+
+
+def get_gradio_output_format():
+    if roop.globals.CFG.output_image_format == "jpg":
+        return "jpeg"
+    return roop.globals.CFG.output_image_format
+
+
+def display_output(filename):
+    if util.is_video(filename) and roop.globals.CFG.output_show_video:
+        return gr.Image(visible=False), gr.Video(visible=True, value=filename)
+    else:
+        if util.is_video(filename) or filename.lower().endswith('gif'):
+            current_frame = get_video_frame(filename)
+        else:
+            current_frame = get_image_frame(filename)
+        return gr.Image(visible=True, value=util.convert_to_gradio(current_frame)), gr.Video(visible=False)

ui/tabs/livecam_tab.py

@@ -0,0 +1,57 @@
+import gradio as gr
+import roop.globals
+import ui.globals
+
+
+camera_frame = None
+
+def livecam_tab():
+    with gr.Tab("🎥 Live Cam"):
+        with gr.Row(variant='panel'):
+            gr.Markdown("""
+                        This feature will allow you to use your physical webcam and apply the selected faces to the stream. 
+                        You can also forward the stream to a virtual camera, which can be used in video calls or streaming software.<br />
+                        Supported are: v4l2loopback (linux), OBS Virtual Camera (macOS/Windows) and unitycapture (Windows).<br />
+                        **Please note:** to change the face or any other settings you need to stop and restart a running live cam.
+            """)
+
+        with gr.Row(variant='panel'):
+            with gr.Column():
+                bt_start = gr.Button("▶ Start", variant='primary')
+            with gr.Column():
+                bt_stop = gr.Button("⏹ Stop", variant='secondary', interactive=False)
+            with gr.Column():
+                camera_num = gr.Slider(0, 8, value=0, label="Camera Number", step=1.0, interactive=True)
+                cb_obs = gr.Checkbox(label="Forward stream to virtual camera", interactive=True)
+            with gr.Column():
+                dd_reso = gr.Dropdown(choices=["640x480","1280x720", "1920x1080"], value="1280x720", label="Fake Camera Resolution", interactive=True)
+                cb_xseg = gr.Checkbox(label="Use DFL Xseg masking", interactive=True, value=True)
+                cb_mouthrestore = gr.Checkbox(label="Restore original mouth area", interactive=True, value=False)
+
+        with gr.Row():
+            fake_cam_image = gr.Image(label='Fake Camera Output', interactive=False, format="jpeg")
+
+    start_event = bt_start.click(fn=start_cam,  inputs=[ui.globals.ui_selected_swap_model, cb_obs, cb_xseg, cb_mouthrestore, camera_num, dd_reso, ui.globals.ui_selected_enhancer, ui.globals.ui_blend_ratio, ui.globals.ui_upscale],outputs=[bt_start, bt_stop,fake_cam_image])
+    bt_stop.click(fn=stop_swap, cancels=[start_event], outputs=[bt_start, bt_stop], queue=False)
+
+
+def start_cam(swap_model, stream_to_obs, use_xseg, use_mouthrestore, cam, reso, enhancer, blend_ratio, upscale):
+    from roop.virtualcam import start_virtual_cam
+    from roop.utilities import convert_to_gradio
+
+    roop.globals.selected_enhancer = enhancer
+    roop.globals.blend_ratio = blend_ratio
+    roop.globals.subsample_size = int(upscale[:3])
+    start_virtual_cam(swap_model, stream_to_obs, use_xseg, use_mouthrestore, cam, reso)
+    while True:
+        yield gr.Button(interactive=False), gr.Button(interactive=True), convert_to_gradio(ui.globals.ui_camera_frame)
+        
+
+def stop_swap():
+    from roop.virtualcam import stop_virtual_cam
+    stop_virtual_cam()
+    return gr.Button(interactive=True), gr.Button(interactive=False)
+    
+
+
+

ui/tabs/settings_tab.py

@@ -0,0 +1,129 @@
+import shutil
+import os
+import gradio as gr
+import roop.globals
+import ui.globals
+from roop.utilities import clean_dir
+
+available_themes = ["Default", "gradio/glass", "gradio/monochrome", "gradio/seafoam", "gradio/soft", "gstaff/xkcd", "freddyaboulton/dracula_revamped", "ysharma/steampunk"]
+image_formats = ['jpg','png', 'webp']
+video_formats = ['avi','mkv', 'mp4', 'webm']
+video_codecs = ['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc']
+providerlist = None
+
+settings_controls = []
+
+def settings_tab():
+    from roop.core import suggest_execution_providers
+    global providerlist
+
+    providerlist = suggest_execution_providers()
+    with gr.Tab("⚙ Settings"):
+        with gr.Row():
+            with gr.Column():
+                themes = gr.Dropdown(available_themes, label="Theme", info="Change needs complete restart", value=roop.globals.CFG.selected_theme)
+            with gr.Column():
+                settings_controls.append(gr.Checkbox(label="Public Server", value=roop.globals.CFG.server_share, elem_id='server_share', interactive=True))
+                settings_controls.append(gr.Checkbox(label='Clear output folder before each run', value=roop.globals.CFG.clear_output, elem_id='clear_output', interactive=True))
+                output_template = gr.Textbox(label="Filename Output Template", info="(file extension is added automatically)", lines=1, placeholder='{file}_{time}', value=roop.globals.CFG.output_template)
+            with gr.Column():
+                input_server_name = gr.Textbox(label="Server Name", lines=1, info="Leave blank to run locally", value=roop.globals.CFG.server_name)
+            with gr.Column():
+                input_server_port = gr.Number(label="Server Port", precision=0, info="Leave at 0 to use default", value=roop.globals.CFG.server_port)
+        with gr.Row():
+            with gr.Column():
+                settings_controls.append(gr.Dropdown(providerlist, label="Provider", value=roop.globals.CFG.provider, elem_id='provider', interactive=True))
+                chk_det_size = gr.Checkbox(label="Use default Det-Size", value=True, elem_id='default_det_size', interactive=True)
+                settings_controls.append(gr.Checkbox(label="Force CPU for Face Analyser", value=roop.globals.CFG.force_cpu, elem_id='force_cpu', interactive=True))
+                max_threads = gr.Slider(1, 32, value=roop.globals.CFG.max_threads, label="Max. Number of Threads", info='default: 3', step=1.0, interactive=True)
+            with gr.Column():
+                memory_limit = gr.Slider(0, 128, value=roop.globals.CFG.memory_limit, label="Max. Memory to use (Gb)", info='0 meaning no limit', step=1.0, interactive=True)
+                settings_controls.append(gr.Dropdown(image_formats, label="Image Output Format", info='default: png', value=roop.globals.CFG.output_image_format, elem_id='output_image_format', interactive=True))
+            with gr.Column():
+                settings_controls.append(gr.Dropdown(video_codecs, label="Video Codec", info='default: libx264', value=roop.globals.CFG.output_video_codec, elem_id='output_video_codec', interactive=True))
+                settings_controls.append(gr.Dropdown(video_formats, label="Video Output Format", info='default: mp4', value=roop.globals.CFG.output_video_format, elem_id='output_video_format', interactive=True))
+                video_quality = gr.Slider(0, 100, value=roop.globals.CFG.video_quality, label="Video Quality (crf)", info='default: 14', step=1.0, interactive=True)
+            with gr.Column():
+                with gr.Group():
+                    settings_controls.append(gr.Checkbox(label='Use OS temp folder', value=roop.globals.CFG.use_os_temp_folder, elem_id='use_os_temp_folder', interactive=True))
+                    settings_controls.append(gr.Checkbox(label='Show video in browser (re-encodes output)', value=roop.globals.CFG.output_show_video, elem_id='output_show_video', interactive=True))
+                button_apply_restart = gr.Button("Restart Server", variant='primary')
+                button_clean_temp = gr.Button("Clean temp folder")
+                button_apply_settings = gr.Button("Apply Settings")
+
+    chk_det_size.select(fn=on_option_changed)
+
+    # Settings
+    for s in settings_controls:
+        s.select(fn=on_settings_changed)
+    max_threads.input(fn=lambda a,b='max_threads':on_settings_changed_misc(a,b), inputs=[max_threads])
+    memory_limit.input(fn=lambda a,b='memory_limit':on_settings_changed_misc(a,b), inputs=[memory_limit])
+    video_quality.input(fn=lambda a,b='video_quality':on_settings_changed_misc(a,b), inputs=[video_quality])
+
+    # button_clean_temp.click(fn=clean_temp, outputs=[bt_srcfiles, input_faces, target_faces, bt_destfiles])
+    button_clean_temp.click(fn=clean_temp)
+    button_apply_settings.click(apply_settings, inputs=[themes, input_server_name, input_server_port, output_template])
+    button_apply_restart.click(restart)
+
+
+def on_option_changed(evt: gr.SelectData):
+    attribname = evt.target.elem_id
+    if isinstance(evt.target, gr.Checkbox):
+        if hasattr(roop.globals, attribname):
+            setattr(roop.globals, attribname, evt.selected)
+            return
+    elif isinstance(evt.target, gr.Dropdown):
+        if hasattr(roop.globals, attribname):
+            setattr(roop.globals, attribname, evt.value)
+            return
+    raise gr.Error(f'Unhandled Setting for {evt.target}')
+
+
+def on_settings_changed_misc(new_val, attribname):
+    if hasattr(roop.globals.CFG, attribname):
+        setattr(roop.globals.CFG, attribname, new_val)
+    else:
+        print("Didn't find attrib!")
+        
+
+
+def on_settings_changed(evt: gr.SelectData):
+    attribname = evt.target.elem_id
+    if isinstance(evt.target, gr.Checkbox):
+        if hasattr(roop.globals.CFG, attribname):
+            setattr(roop.globals.CFG, attribname, evt.selected)
+            return
+    elif isinstance(evt.target, gr.Dropdown):
+        if hasattr(roop.globals.CFG, attribname):
+            setattr(roop.globals.CFG, attribname, evt.value)
+            return
+            
+    raise gr.Error(f'Unhandled Setting for {evt.target}')
+
+def clean_temp():
+    from ui.main import prepare_environment
+    
+    ui.globals.ui_input_thumbs.clear()
+    roop.globals.INPUT_FACESETS.clear()
+    roop.globals.TARGET_FACES.clear()
+    ui.globals.ui_target_thumbs = []
+    if not roop.globals.CFG.use_os_temp_folder:
+        clean_dir(os.environ["TEMP"])
+    prepare_environment()
+    gr.Info('Temp Files removed')
+    return None,None,None,None
+
+
+def apply_settings(themes, input_server_name, input_server_port, output_template):
+    from ui.main import show_msg
+
+    roop.globals.CFG.selected_theme = themes
+    roop.globals.CFG.server_name = input_server_name
+    roop.globals.CFG.server_port = input_server_port
+    roop.globals.CFG.output_template = output_template
+    roop.globals.CFG.save()
+    show_msg('Settings saved')
+
+
+def restart():
+    ui.globals.ui_restart_server = True