Upload 5 files

ui/tabs/extras_tab.py

@@ -4,6 +4,7 @@ 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"}},
@@ -62,6 +63,26 @@ def extras_tab():
                     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'):
@@ -78,7 +99,9 @@ def extras_tab():
     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=[extras_images_folder, extras_fps, extras_chk_creategif], 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])
 
 
@@ -115,17 +138,55 @@ def on_join_videos(files, chk_encode):
         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)
 
-
-def on_extras_create_video(images_path,fps, create_gif):
-    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)
-    resultfiles = []
+    ffmpeg.create_video_from_gif(filenames[0], destfilename)
     if os.path.isfile(destfilename):
         resultfiles.append(destfilename)
-    else:
+    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)
@@ -161,7 +222,7 @@ def on_frame_process(files, filterselection, upscaleselection):
         return None
 
     if roop.globals.CFG.clear_output:
-        shutil.rmtree(roop.globals.output_path)
+        clean_dir(roop.globals.output_path)
     prepare_environment()
     list_files_process : list[ProcessEntry] = []
 
@@ -175,7 +236,7 @@ def on_frame_process(files, filterselection, upscaleselection):
     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(processoroptions, 0,  0, "all", 0, None, None, None, False)
+    options = ProcessOptions(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()]

ui/tabs/facemgr_tab.py

@@ -22,7 +22,7 @@ def facemgr_tab() -> None:
                         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)
+            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)

ui/tabs/faceswap_tab.py

@@ -10,6 +10,7 @@ from roop.capturer import get_video_frame, get_video_frame_total, get_image_fram
 from roop.ProcessEntry import ProcessEntry
 from roop.ProcessOptions import ProcessOptions
 from roop.FaceSet import FaceSet
+from roop.utilities import clean_dir
 
 last_image = None
 
@@ -30,7 +31,10 @@ selected_preview_index = 0
 is_processing = False            
 
 list_files_process : list[ProcessEntry] = []
-no_face_choices = ["Use untouched original frame","Retry rotated", "Skip Frame", "Skip Frame if no similar face"]
+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
 
@@ -44,42 +48,113 @@ def faceswap_tab():
         with gr.Row(variant='panel'):
             with gr.Column(scale=2):
                 with gr.Row():
-                    with gr.Column(min_width=160):
-                        input_faces = gr.Gallery(label="Input faces", allow_preview=False, preview=False, height=128, object_fit="scale-down", columns=8)
+                    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)
-                            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')
-                        bt_remove_selected_input_face = gr.Button("❌ Remove selected", size='sm')
-                        bt_clear_input_faces = gr.Button("💥 Clear all", variant='stop', size='sm')
-                    with gr.Column(min_width=160):
-                        target_faces = gr.Gallery(label="Target faces", allow_preview=False, preview=False, height=128, object_fit="scale-down", columns=8)
-                        bt_remove_selected_target_face = gr.Button("❌ Remove selected", size='sm')
-                        bt_add_local = gr.Button('Add local files from', size='sm')
+                            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 File(s)', file_count="multiple", file_types=["image", ".fsz"], elem_id='filelist', height=233)
-                    bt_destfiles = gr.Files(label='Target File(s)', file_count="multiple", file_types=["image", "video"], elem_id='filelist', height=233)
+                    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'):
-                    gr.Markdown('')
+                    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)
+                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')
+                    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():
@@ -88,28 +163,29 @@ def faceswap_tab():
                     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=256, object_fit="cover", columns=8)
+                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(["First found", "All female", "All male", "All faces", "Selected face"], value="First found", label="Specify face selection for swapping")
+                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):
-                num_swap_steps = gr.Slider(1, 5, value=1, step=1.0, label="Number of swapping steps", info="More steps can increase likeness")
+                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)
@@ -122,16 +198,14 @@ def faceswap_tab():
                     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')
-                gr.Button("👀 Open Output Folder", size='sm').click(fn=lambda: util.open_folder(roop.globals.output_path))
             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):
-                gr.Markdown(' ') 
+                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)
@@ -139,12 +213,18 @@ def faceswap_tab():
                 resultimage = gr.Image(type='filepath', label='Final Image', interactive=False )
                 resultvideo = gr.Video(label='Final Video', interactive=False, visible=False)
 
-    previewinputs = [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, num_swap_steps]
+    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).then(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs)
+    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.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')
@@ -154,34 +234,32 @@ def faceswap_tab():
     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').then(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').then(fn=on_preview_frame_changed, inputs=previewinputs, outputs=previewoutputs, 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_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=[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_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, num_swap_steps, maskimage],
+        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.then(fn=on_resultfiles_finished, inputs=[resultfiles], outputs=[resultimage, resultvideo])
-    
+    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)
@@ -190,8 +268,7 @@ def faceswap_tab():
     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)
 
@@ -230,7 +307,6 @@ def on_mask_engine_changed(mask_engine):
     return gr.Textbox(interactive=False)
 
 
-
 def on_add_local_folder(folder):
     files = util.get_local_files_from_folder(folder)
     if files is None:
@@ -244,9 +320,8 @@ def on_srcfile_changed(srcfiles, progress=gr.Progress()):
     IS_INPUT = True
 
     if srcfiles is None or len(srcfiles) < 1:
-        return gr.Column(visible=False), None, ui.globals.ui_input_thumbs
+        return gr.Column(visible=False), None, ui.globals.ui_input_thumbs, None
 
-    thumbs = []
     for f in srcfiles:    
         source_path = f.name
         if source_path.lower().endswith('fsz'):
@@ -296,13 +371,7 @@ def on_srcfile_changed(srcfiles, progress=gr.Progress()):
                 roop.globals.INPUT_FACESETS.append(face_set)
                 
     progress(1.0)
-
-    # old style with selecting input faces commented out
-    # if len(thumbs) < 1:     
-    #     return gr.Column(visible=False), None, ui.globals.ui_input_thumbs
-    # return gr.Column(visible=True), thumbs, gr.Gallery(visible=True)
-
-    return gr.Column(visible=False), None, ui.globals.ui_input_thumbs
+    return gr.Column(visible=False), None, ui.globals.ui_input_thumbs,None
 
 
 def on_select_input_face(evt: gr.SelectData):
@@ -323,13 +392,53 @@ def remove_selected_input_face():
 
     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(roop.globals.TARGET_FACES) > SELECTED_TARGET_FACE_INDEX:
+    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:
@@ -338,9 +447,6 @@ def remove_selected_target_face():
     return ui.globals.ui_target_thumbs
 
 
-
-
-
 def on_use_face_from_selected(files, frame_num):
     global IS_INPUT, SELECTION_FACES_DATA
 
@@ -368,6 +474,9 @@ def on_use_face_from_selected(files, frame_num):
         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])
@@ -377,11 +486,10 @@ def on_use_face_from_selected(files, frame_num):
     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
@@ -399,15 +507,15 @@ def on_selected_face():
         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(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, num_steps):
+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
@@ -454,6 +562,8 @@ def on_preview_frame_changed(frame_num, files, fake_preview, enhancer, detection
     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)
 
@@ -463,8 +573,8 @@ def on_preview_frame_changed(frame_num, files, fake_preview, enhancer, detection
     if len(roop.globals.INPUT_FACESETS) <= face_index:
         face_index = 0
    
-    options = ProcessOptions(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, show_face_area)
+    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:
@@ -481,7 +591,6 @@ def map_mask_engine(selected_mask_engine, clip_text):
     else:
         mask_engine = None
     return mask_engine
-    
 
 
 def on_toggle_masking(previewimage, mask):
@@ -513,7 +622,6 @@ def on_set_frame(sender:str, frame_num):
         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(frame_num, files, clip_text, mask_engine):
@@ -538,13 +646,12 @@ def on_preview_mask(frame_num, files, clip_text, mask_engine):
     elif mask_engine == "DFL XSeg":
         mask_engine = "mask_xseg"
     options = ProcessOptions(get_processing_plugins(mask_engine), roop.globals.distance_threshold, roop.globals.blend_ratio,
-                              "all", 0, clip_text, None, 0, False, True)
+                              "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()
@@ -566,6 +673,10 @@ def translate_swap_mode(dropdown_text):
         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":
@@ -574,9 +685,8 @@ def translate_swap_mode(dropdown_text):
     return "all"
 
 
-
-def start_swap( 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, num_swap_steps, imagemask, progress=gr.Progress()):
+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
@@ -585,7 +695,7 @@ def start_swap( enhancer, detection, keep_frames, wait_after_extraction, skip_au
         return gr.Button(variant="primary"), None, None
     
     if roop.globals.CFG.clear_output:
-        shutil.rmtree(roop.globals.output_path)
+        clean_dir(roop.globals.output_path)
 
     if not util.is_installed("ffmpeg"):
         msg = "ffmpeg is not installed! No video processing possible."
@@ -604,6 +714,7 @@ def start_swap( enhancer, detection, keep_frames, wait_after_extraction, skip_au
     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':
@@ -618,7 +729,7 @@ def start_swap( enhancer, detection, keep_frames, wait_after_extraction, skip_au
     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(list_files_process, mask_engine, clip_text, processing_method == "In-Memory processing", imagemask, num_swap_steps, progress, SELECTED_INPUT_FACE_INDEX)
+    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()]
@@ -659,15 +770,17 @@ def on_destfiles_changed(destfiles):
     
     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 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):
@@ -689,8 +802,7 @@ def on_destfiles_selected(evt: gr.SelectData):
     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
@@ -706,6 +818,12 @@ def on_resultfiles_finished(files):
     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)

ui/tabs/livecam_tab.py

@@ -25,21 +25,24 @@ def livecam_tab():
                 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)
+            fake_cam_image = gr.Image(label='Fake Camera Output', interactive=False, format="jpeg")
 
-    start_event = bt_start.click(fn=start_cam,  inputs=[cb_obs, camera_num, dd_reso, ui.globals.ui_selected_enhancer, ui.globals.ui_blend_ratio],outputs=[bt_start, bt_stop,fake_cam_image])
+    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(stream_to_obs, cam, reso, enhancer, blend_ratio):
+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
 
-    start_virtual_cam(stream_to_obs, cam, reso)
     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)
         

ui/tabs/settings_tab.py

@@ -3,6 +3,7 @@ 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']
@@ -102,14 +103,13 @@ def on_settings_changed(evt: gr.SelectData):
 def clean_temp():
     from ui.main import prepare_environment
     
-    if not roop.globals.CFG.use_os_temp_folder:
-        shutil.rmtree(os.environ["TEMP"])
-    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