Delete roop

roop/capturer.py

@@ -1,22 +0,0 @@
-from typing import Optional
-import cv2
-
-from roop.typing import Frame
-
-
-def get_video_frame(video_path: str, frame_number: int = 0) -> Optional[Frame]:
-    capture = cv2.VideoCapture(video_path)
-    frame_total = capture.get(cv2.CAP_PROP_FRAME_COUNT)
-    capture.set(cv2.CAP_PROP_POS_FRAMES, min(frame_total, frame_number - 1))
-    has_frame, frame = capture.read()
-    capture.release()
-    if has_frame:
-        return frame
-    return None
-
-
-def get_video_frame_total(video_path: str) -> int:
-    capture = cv2.VideoCapture(video_path)
-    video_frame_total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
-    capture.release()
-    return video_frame_total

roop/core.py

@@ -1,220 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import sys
-# single thread doubles cuda performance - needs to be set before torch import
-if any(arg.startswith('--execution-provider') for arg in sys.argv):
-    os.environ['OMP_NUM_THREADS'] = '1'
-# reduce tensorflow log level
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-import warnings
-from typing import List
-import platform
-import signal
-import shutil
-import argparse
-import onnxruntime
-import tensorflow
-import roop.globals as globals
-import roop.metadata as metadata
-import roop.ui as ui
-from roop.predictor import predict_image, predict_video
-from roop.processors.frame.core import get_frame_processors_modules
-from roop.utilities import has_image_extension, is_image, is_video, detect_fps, create_video, extract_frames, get_temp_frame_paths, restore_audio, create_temp, move_temp, clean_temp, normalize_output_path
-
-warnings.filterwarnings('ignore', category=FutureWarning, module='insightface')
-warnings.filterwarnings('ignore', category=UserWarning, module='torchvision')
-
-
-def parse_args() -> None:
-    signal.signal(signal.SIGINT, lambda signal_number, frame: destroy())
-    program = argparse.ArgumentParser(formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=100))
-    program.add_argument('-s', '--source', help='select an source image', dest='source_path')
-    program.add_argument('-t', '--target', help='select an target image or video', dest='target_path')
-    program.add_argument('-o', '--output', help='select output file or directory', dest='output_path')
-    program.add_argument('--frame-processor', help='frame processors (choices: face_swapper, face_enhancer, ...)', dest='frame_processor', default=['face_swapper'], nargs='+')
-    program.add_argument('--keep-fps', help='keep target fps', dest='keep_fps', action='store_true')
-    program.add_argument('--keep-frames', help='keep temporary frames', dest='keep_frames', action='store_true')
-    program.add_argument('--skip-audio', help='skip target audio', dest='skip_audio', action='store_true')
-    program.add_argument('--many-faces', help='process every face', dest='many_faces', action='store_true')
-    program.add_argument('--reference-face-position', help='position of the reference face', dest='reference_face_position', type=int, default=0)
-    program.add_argument('--reference-frame-number', help='number of the reference frame', dest='reference_frame_number', type=int, default=0)
-    program.add_argument('--similar-face-distance', help='face distance used for recognition', dest='similar_face_distance', type=float, default=0.85)
-    program.add_argument('--temp-frame-format', help='image format used for frame extraction', dest='temp_frame_format', default='png', choices=['jpg', 'png'])
-    program.add_argument('--temp-frame-quality', help='image quality used for frame extraction', dest='temp_frame_quality', type=int, default=0, choices=range(101), metavar='[0-100]')
-    program.add_argument('--output-video-encoder', help='encoder used for the output video', dest='output_video_encoder', default='libx264', choices=['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc'])
-    program.add_argument('--output-video-quality', help='quality used for the output video', dest='output_video_quality', type=int, default=35, choices=range(101), metavar='[0-100]')
-    program.add_argument('--max-memory', help='maximum amount of RAM in GB', dest='max_memory', type=int)
-    program.add_argument('--execution-provider', help='available execution provider (choices: cpu, ...)', dest='execution_provider', default=['cpu'], choices=suggest_execution_providers(), nargs='+')
-    program.add_argument('--execution-threads', help='number of execution threads', dest='execution_threads', type=int, default=suggest_execution_threads())
-    program.add_argument('-v', '--version', action='version', version=f'{metadata.name} {metadata.version}')
-
-    args = program.parse_args()
-
-    globals.source_path = args.source_path
-    globals.target_path = args.target_path
-    globals.output_path = normalize_output_path(globals.source_path, globals.target_path, args.output_path)
-    globals.headless = globals.source_path is not None and globals.target_path is not None and globals.output_path is not None
-    globals.frame_processors = args.frame_processor
-    globals.keep_fps = args.keep_fps
-    globals.keep_frames = args.keep_frames
-    globals.skip_audio = args.skip_audio
-    globals.many_faces = args.many_faces
-    globals.reference_face_position = args.reference_face_position
-    globals.reference_frame_number = args.reference_frame_number
-    globals.similar_face_distance = args.similar_face_distance
-    globals.temp_frame_format = args.temp_frame_format
-    globals.temp_frame_quality = args.temp_frame_quality
-    globals.output_video_encoder = args.output_video_encoder
-    globals.output_video_quality = args.output_video_quality
-    globals.max_memory = args.max_memory
-    globals.execution_providers = decode_execution_providers(args.execution_provider)
-    globals.execution_threads = args.execution_threads
-
-
-def encode_execution_providers(execution_providers: List[str]) -> List[str]:
-    return [execution_provider.replace('ExecutionProvider', '').lower() for execution_provider in execution_providers]
-
-
-def decode_execution_providers(execution_providers: List[str]) -> List[str]:
-    return [provider for provider, encoded_execution_provider in zip(onnxruntime.get_available_providers(), encode_execution_providers(onnxruntime.get_available_providers()))
-            if any(execution_provider in encoded_execution_provider for execution_provider in execution_providers)]
-
-
-def suggest_execution_providers() -> List[str]:
-    return encode_execution_providers(onnxruntime.get_available_providers())
-
-
-def suggest_execution_threads() -> int:
-    if 'CUDAExecutionProvider' in onnxruntime.get_available_providers():
-        return 8
-    return 1
-
-
-def limit_resources() -> None:
-    # prevent tensorflow memory leak
-    gpus = tensorflow.config.experimental.list_physical_devices('GPU')
-    for gpu in gpus:
-        tensorflow.config.experimental.set_virtual_device_configuration(gpu, [
-            tensorflow.config.experimental.VirtualDeviceConfiguration(memory_limit=2048)
-        ])
-    # limit memory usage
-    if globals.max_memory:
-        memory = globals.max_memory * 1024 ** 3
-        if platform.system().lower() == 'darwin':
-            memory = globals.max_memory * 1024 ** 6
-        if platform.system().lower() == 'windows':
-            import ctypes
-            kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
-            kernel32.SetProcessWorkingSetSize(-1, ctypes.c_size_t(memory), ctypes.c_size_t(memory))
-        else:
-            import resource
-            resource.setrlimit(resource.RLIMIT_DATA, (memory, memory))
-
-
-def pre_check() -> bool:
-    if sys.version_info < (3, 9):
-        update_status('Python version is not supported - please upgrade to 3.9 or higher.')
-        return False
-    if not shutil.which('ffmpeg'):
-        update_status('ffmpeg is not installed.')
-        return False
-    return True
-
-
-def update_status(message: str, scope: str = 'ROOP.CORE') -> None:
-    print(f'[{scope}] {message}')
-    if not globals.headless:
-        ui.update_status(message)
-
-
-def start() -> None:
-    for frame_processor in get_frame_processors_modules(globals.frame_processors):
-        if not frame_processor.pre_start():
-            return
-    # process image to image
-    if has_image_extension(globals.target_path):
-        if predict_image(globals.target_path):
-            destroy()
-        shutil.copy2(globals.target_path, globals.output_path)
-        # process frame
-        for frame_processor in get_frame_processors_modules(globals.frame_processors):
-            update_status('Progressing...', frame_processor.NAME)
-            frame_processor.process_image(globals.source_path, globals.output_path, globals.output_path)
-            frame_processor.post_process()
-        # validate image
-        if is_image(globals.target_path):
-            update_status('Processing to image succeed!')
-        else:
-            update_status('Processing to image failed!')
-        return
-    # process image to videos
-    if predict_video(globals.target_path):
-        destroy()
-    update_status('Creating temporary resources...')
-    create_temp(globals.target_path)
-    # extract frames
-    if globals.keep_fps:
-        fps = detect_fps(globals.target_path)
-        update_status(f'Extracting frames with {fps} FPS...')
-        extract_frames(globals.target_path, fps)
-    else:
-        update_status('Extracting frames with 30 FPS...')
-        extract_frames(globals.target_path)
-    # process frame
-    temp_frame_paths = get_temp_frame_paths(globals.target_path)
-    if temp_frame_paths:
-        for frame_processor in get_frame_processors_modules(globals.frame_processors):
-            update_status('Progressing...', frame_processor.NAME)
-            frame_processor.process_video(globals.source_path, temp_frame_paths)
-            frame_processor.post_process()
-    else:
-        update_status('Frames not found...')
-        return
-    # create video
-    if globals.keep_fps:
-        fps = detect_fps(globals.target_path)
-        update_status(f'Creating video with {fps} FPS...')
-        create_video(globals.target_path, fps)
-    else:
-        update_status('Creating video with 30 FPS...')
-        create_video(globals.target_path)
-    # handle audio
-    if globals.skip_audio:
-        move_temp(globals.target_path, globals.output_path)
-        update_status('Skipping audio...')
-    else:
-        if globals.keep_fps:
-            update_status('Restoring audio...')
-        else:
-            update_status('Restoring audio might cause issues as fps are not kept...')
-        restore_audio(globals.target_path, globals.output_path)
-    # clean temp
-    update_status('Cleaning temporary resources...')
-    clean_temp(globals.target_path)
-    # validate video
-    if is_video(globals.target_path):
-        update_status('Processing to video succeed!')
-    else:
-        update_status('Processing to video failed!')
-
-
-def destroy() -> None:
-    if globals.target_path:
-        clean_temp(globals.target_path)
-    sys.exit()
-
-
-def run() -> None:
-    parse_args()
-    if not pre_check():
-        return
-    for frame_processor in get_frame_processors_modules(globals.frame_processors):
-        if not frame_processor.pre_check():
-            return
-    limit_resources()
-    if globals.headless:
-        start()
-    else:
-        window = ui.init(start, destroy)
-        window.mainloop()

roop/face_analyser.py

@@ -1,54 +0,0 @@
-import threading
-from typing import Any, Optional, List
-import insightface
-import numpy
-
-import roop.globals
-from roop.typing import Frame, Face
-
-FACE_ANALYSER = None
-THREAD_LOCK = threading.Lock()
-
-
-def get_face_analyser() -> Any:
-    global FACE_ANALYSER
-
-    with THREAD_LOCK:
-        if FACE_ANALYSER is None:
-            FACE_ANALYSER = insightface.app.FaceAnalysis(name='buffalo_l', providers=roop.globals.execution_providers)
-            FACE_ANALYSER.prepare(ctx_id=0)
-    return FACE_ANALYSER
-
-
-def clear_face_analyser() -> Any:
-    global FACE_ANALYSER
-
-    FACE_ANALYSER = None
-
-
-def get_one_face(frame: Frame, position: int = 0) -> Optional[Face]:
-    many_faces = get_many_faces(frame)
-    if many_faces:
-        try:
-            return many_faces[position]
-        except IndexError:
-            return many_faces[-1]
-    return None
-
-
-def get_many_faces(frame: Frame) -> Optional[List[Face]]:
-    try:
-        return get_face_analyser().get(frame)
-    except ValueError:
-        return None
-
-
-def find_similar_face(frame: Frame, reference_face: Face) -> Optional[Face]:
-    many_faces = get_many_faces(frame)
-    if many_faces:
-        for face in many_faces:
-            if hasattr(face, 'normed_embedding') and hasattr(reference_face, 'normed_embedding'):
-                distance = numpy.sum(numpy.square(face.normed_embedding - reference_face.normed_embedding))
-                if distance < roop.globals.similar_face_distance:
-                    return face
-    return None

roop/face_reference.py

@@ -1,21 +0,0 @@
-from typing import Optional
-
-from roop.typing import Face
-
-FACE_REFERENCE = None
-
-
-def get_face_reference() -> Optional[Face]:
-    return FACE_REFERENCE
-
-
-def set_face_reference(face: Face) -> None:
-    global FACE_REFERENCE
-
-    FACE_REFERENCE = face
-
-
-def clear_face_reference() -> None:
-    global FACE_REFERENCE
-
-    FACE_REFERENCE = None

roop/globals.py

@@ -1,22 +0,0 @@
-from typing import List, Optional
-
-source_path: Optional[str] = None
-target_path: Optional[str] = None
-output_path: Optional[str] = None
-headless: Optional[bool] = None
-frame_processors: List[str] = []
-keep_fps: Optional[bool] = None
-keep_frames: Optional[bool] = None
-skip_audio: Optional[bool] = None
-many_faces: Optional[bool] = None
-reference_face_position: Optional[int] = None
-reference_frame_number: Optional[int] = None
-similar_face_distance: Optional[float] = None
-temp_frame_format: Optional[str] = None
-temp_frame_quality: Optional[int] = None
-output_video_encoder: Optional[str] = None
-output_video_quality: Optional[int] = None
-max_memory: Optional[int] = None
-execution_providers: List[str] = []
-execution_threads: Optional[int] = None
-log_level: str = 'error'

roop/metadata.py

@@ -1,2 +0,0 @@
-name = 'roop'
-version = '1.3.2'

roop/predictor.py

@@ -1,43 +0,0 @@
-import threading
-import numpy
-import opennsfw2
-from PIL import Image
-from keras import Model
-
-from roop.typing import Frame
-
-PREDICTOR = None
-THREAD_LOCK = threading.Lock()
-MAX_PROBABILITY = 0.85
-
-
-def get_predictor() -> Model:
-    global PREDICTOR
-
-    with THREAD_LOCK:
-        if PREDICTOR is None:
-            PREDICTOR = opennsfw2.make_open_nsfw_model()
-    return PREDICTOR
-
-
-def clear_predictor() -> None:
-    global PREDICTOR
-
-    PREDICTOR = None
-
-
-def predict_frame(target_frame: Frame) -> bool:
-    image = Image.fromarray(target_frame)
-    image = opennsfw2.preprocess_image(image, opennsfw2.Preprocessing.YAHOO)
-    views = numpy.expand_dims(image, axis=0)
-    _, probability = get_predictor().predict(views)[0]
-    return probability > MAX_PROBABILITY
-
-
-def predict_image(target_path: str) -> bool:
-    return opennsfw2.predict_image(target_path) > MAX_PROBABILITY
-
-
-def predict_video(target_path: str) -> bool:
-    _, probabilities = opennsfw2.predict_video_frames(video_path=target_path, frame_interval=100)
-    return any(probability > MAX_PROBABILITY for probability in probabilities)

roop/processors/frame/core.py

@@ -1,91 +0,0 @@
-import os
-import sys
-import importlib
-import psutil
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from queue import Queue
-from types import ModuleType
-from typing import Any, List, Callable
-from tqdm import tqdm
-
-import roop
-
-FRAME_PROCESSORS_MODULES: List[ModuleType] = []
-FRAME_PROCESSORS_INTERFACE = [
-    'pre_check',
-    'pre_start',
-    'process_frame',
-    'process_frames',
-    'process_image',
-    'process_video',
-    'post_process'
-]
-
-
-def load_frame_processor_module(frame_processor: str) -> Any:
-    try:
-        frame_processor_module = importlib.import_module(f'roop.processors.frame.{frame_processor}')
-        for method_name in FRAME_PROCESSORS_INTERFACE:
-            if not hasattr(frame_processor_module, method_name):
-                raise NotImplementedError
-    except ModuleNotFoundError:
-        sys.exit(f'Frame processor {frame_processor} not found.')
-    except NotImplementedError:
-        sys.exit(f'Frame processor {frame_processor} not implemented correctly.')
-    return frame_processor_module
-
-
-def get_frame_processors_modules(frame_processors: List[str]) -> List[ModuleType]:
-    global FRAME_PROCESSORS_MODULES
-
-    if not FRAME_PROCESSORS_MODULES:
-        for frame_processor in frame_processors:
-            frame_processor_module = load_frame_processor_module(frame_processor)
-            FRAME_PROCESSORS_MODULES.append(frame_processor_module)
-    return FRAME_PROCESSORS_MODULES
-
-
-def multi_process_frame(source_path: str, temp_frame_paths: List[str], process_frames: Callable[[str, List[str], Any], None], update: Callable[[], None]) -> None:
-    with ThreadPoolExecutor(max_workers=roop.globals.execution_threads) as executor:
-        futures = []
-        queue = create_queue(temp_frame_paths)
-        queue_per_future = max(len(temp_frame_paths) // roop.globals.execution_threads, 1)
-        while not queue.empty():
-            future = executor.submit(process_frames, source_path, pick_queue(queue, queue_per_future), update)
-            futures.append(future)
-        for future in as_completed(futures):
-            future.result()
-
-
-def create_queue(temp_frame_paths: List[str]) -> Queue[str]:
-    queue: Queue[str] = Queue()
-    for frame_path in temp_frame_paths:
-        queue.put(frame_path)
-    return queue
-
-
-def pick_queue(queue: Queue[str], queue_per_future: int) -> List[str]:
-    queues = []
-    for _ in range(queue_per_future):
-        if not queue.empty():
-            queues.append(queue.get())
-    return queues
-
-
-def process_video(source_path: str, frame_paths: list[str], process_frames: Callable[[str, List[str], Any], None]) -> None:
-    progress_bar_format = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]'
-    total = len(frame_paths)
-    with tqdm(total=total, desc='Processing', unit='frame', dynamic_ncols=True, bar_format=progress_bar_format) as progress:
-        multi_process_frame(source_path, frame_paths, process_frames, lambda: update_progress(progress))
-
-
-def update_progress(progress: Any = None) -> None:
-    process = psutil.Process(os.getpid())
-    memory_usage = process.memory_info().rss / 1024 / 1024 / 1024
-    progress.set_postfix({
-        'memory_usage': '{:.2f}'.format(memory_usage).zfill(5) + 'GB',
-        'execution_providers': roop.globals.execution_providers,
-        'execution_threads': roop.globals.execution_threads
-    })
-    progress.refresh()
-    progress.update(1)

roop/processors/frame/face_enhancer.py

@@ -1,104 +0,0 @@
-from typing import Any, List, Callable
-import cv2
-import threading
-from gfpgan.utils import GFPGANer
-
-import roop.globals
-import roop.processors.frame.core
-from roop.core import update_status
-from roop.face_analyser import get_many_faces
-from roop.typing import Frame, Face
-from roop.utilities import conditional_download, resolve_relative_path, is_image, is_video
-
-FACE_ENHANCER = None
-THREAD_SEMAPHORE = threading.Semaphore()
-THREAD_LOCK = threading.Lock()
-NAME = 'ROOP.FACE-ENHANCER'
-
-
-def get_face_enhancer() -> Any:
-    global FACE_ENHANCER
-
-    with THREAD_LOCK:
-        if FACE_ENHANCER is None:
-            model_path = resolve_relative_path('../models/GFPGANv1.4.pth')
-            # todo: set models path -> https://github.com/TencentARC/GFPGAN/issues/399
-            FACE_ENHANCER = GFPGANer(model_path=model_path, upscale=1, device=get_device())
-    return FACE_ENHANCER
-
-
-def get_device() -> str:
-    if 'CUDAExecutionProvider' in roop.globals.execution_providers:
-        return 'cuda'
-    if 'CoreMLExecutionProvider' in roop.globals.execution_providers:
-        return 'mps'
-    return 'cpu'
-
-
-def clear_face_enhancer() -> None:
-    global FACE_ENHANCER
-
-    FACE_ENHANCER = None
-
-
-def pre_check() -> bool:
-    download_directory_path = resolve_relative_path('../models')
-    conditional_download(download_directory_path, ['https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/GFPGANv1.4.pth'])
-    return True
-
-
-def pre_start() -> bool:
-    if not is_image(roop.globals.target_path) and not is_video(roop.globals.target_path):
-        update_status('Select an image or video for target path.', NAME)
-        return False
-    return True
-
-
-def post_process() -> None:
-    clear_face_enhancer()
-
-
-def enhance_face(target_face: Face, temp_frame: Frame) -> Frame:
-    start_x, start_y, end_x, end_y = map(int, target_face['bbox'])
-    padding_x = int((end_x - start_x) * 0.5)
-    padding_y = int((end_y - start_y) * 0.5)
-    start_x = max(0, start_x - padding_x)
-    start_y = max(0, start_y - padding_y)
-    end_x = max(0, end_x + padding_x)
-    end_y = max(0, end_y + padding_y)
-    temp_face = temp_frame[start_y:end_y, start_x:end_x]
-    if temp_face.size:
-        with THREAD_SEMAPHORE:
-            _, _, temp_face = get_face_enhancer().enhance(
-                temp_face,
-                paste_back=True
-            )
-        temp_frame[start_y:end_y, start_x:end_x] = temp_face
-    return temp_frame
-
-
-def process_frame(source_face: Face, reference_face: Face, temp_frame: Frame) -> Frame:
-    many_faces = get_many_faces(temp_frame)
-    if many_faces:
-        for target_face in many_faces:
-            temp_frame = enhance_face(target_face, temp_frame)
-    return temp_frame
-
-
-def process_frames(source_path: str, temp_frame_paths: List[str], update: Callable[[], None]) -> None:
-    for temp_frame_path in temp_frame_paths:
-        temp_frame = cv2.imread(temp_frame_path)
-        result = process_frame(None, None, temp_frame)
-        cv2.imwrite(temp_frame_path, result)
-        if update:
-            update()
-
-
-def process_image(source_path: str, target_path: str, output_path: str) -> None:
-    target_frame = cv2.imread(target_path)
-    result = process_frame(None, None, target_frame)
-    cv2.imwrite(output_path, result)
-
-
-def process_video(source_path: str, temp_frame_paths: List[str]) -> None:
-    roop.processors.frame.core.process_video(None, temp_frame_paths, process_frames)

roop/processors/frame/face_swapper.py

@@ -1,100 +0,0 @@
-from typing import Any, List, Callable
-import cv2
-import insightface
-import threading
-
-import roop.globals
-import roop.processors.frame.core
-from roop.core import update_status
-from roop.face_analyser import get_one_face, get_many_faces, find_similar_face
-from roop.face_reference import get_face_reference, set_face_reference, clear_face_reference
-from roop.typing import Face, Frame
-from roop.utilities import conditional_download, resolve_relative_path, is_image, is_video
-
-FACE_SWAPPER = None
-THREAD_LOCK = threading.Lock()
-NAME = 'ROOP.FACE-SWAPPER'
-
-
-def get_face_swapper() -> Any:
-    global FACE_SWAPPER
-
-    with THREAD_LOCK:
-        if FACE_SWAPPER is None:
-            model_path = resolve_relative_path('../models/inswapper_128.onnx')
-            FACE_SWAPPER = insightface.model_zoo.get_model(model_path, providers=roop.globals.execution_providers)
-    return FACE_SWAPPER
-
-
-def clear_face_swapper() -> None:
-    global FACE_SWAPPER
-
-    FACE_SWAPPER = None
-
-
-def pre_check() -> bool:
-    download_directory_path = resolve_relative_path('../models')
-    conditional_download(download_directory_path, ['https://huggingface.co/CountFloyd/deepfake/resolve/main/inswapper_128.onnx'])
-    return True
-
-
-def pre_start() -> bool:
-    if not is_image(roop.globals.source_path):
-        update_status('Select an image for source path.', NAME)
-        return False
-    elif not get_one_face(cv2.imread(roop.globals.source_path)):
-        update_status('No face in source path detected.', NAME)
-        return False
-    if not is_image(roop.globals.target_path) and not is_video(roop.globals.target_path):
-        update_status('Select an image or video for target path.', NAME)
-        return False
-    return True
-
-
-def post_process() -> None:
-    clear_face_swapper()
-    clear_face_reference()
-
-
-def swap_face(source_face: Face, target_face: Face, temp_frame: Frame) -> Frame:
-    return get_face_swapper().get(temp_frame, target_face, source_face, paste_back=True)
-
-
-def process_frame(source_face: Face, reference_face: Face, temp_frame: Frame) -> Frame:
-    if roop.globals.many_faces:
-        many_faces = get_many_faces(temp_frame)
-        if many_faces:
-            for target_face in many_faces:
-                temp_frame = swap_face(source_face, target_face, temp_frame)
-    else:
-        target_face = find_similar_face(temp_frame, reference_face)
-        if target_face:
-            temp_frame = swap_face(source_face, target_face, temp_frame)
-    return temp_frame
-
-
-def process_frames(source_path: str, temp_frame_paths: List[str], update: Callable[[], None]) -> None:
-    source_face = get_one_face(cv2.imread(source_path))
-    reference_face = None if roop.globals.many_faces else get_face_reference()
-    for temp_frame_path in temp_frame_paths:
-        temp_frame = cv2.imread(temp_frame_path)
-        result = process_frame(source_face, reference_face, temp_frame)
-        cv2.imwrite(temp_frame_path, result)
-        if update:
-            update()
-
-
-def process_image(source_path: str, target_path: str, output_path: str) -> None:
-    source_face = get_one_face(cv2.imread(source_path))
-    target_frame = cv2.imread(target_path)
-    reference_face = None if roop.globals.many_faces else get_one_face(target_frame, roop.globals.reference_face_position)
-    result = process_frame(source_face, reference_face, target_frame)
-    cv2.imwrite(output_path, result)
-
-
-def process_video(source_path: str, temp_frame_paths: List[str]) -> None:
-    if not roop.globals.many_faces and not get_face_reference():
-        reference_frame = cv2.imread(temp_frame_paths[roop.globals.reference_frame_number])
-        reference_face = get_one_face(reference_frame, roop.globals.reference_face_position)
-        set_face_reference(reference_face)
-    roop.processors.frame.core.process_video(source_path, temp_frame_paths, process_frames)

roop/typing.py

@@ -1,7 +0,0 @@
-from typing import Any
-
-from insightface.app.common import Face
-import numpy
-
-Face = Face
-Frame = numpy.ndarray[Any, Any]

roop/ui.json

@@ -1,161 +0,0 @@
-{
-  "CTk": {
-    "fg_color": ["gray95", "gray10"]
-  },
-  "CTkToplevel": {
-    "fg_color": ["gray95", "gray10"]
-  },
-  "CTkFrame": {
-    "corner_radius": 6,
-    "border_width": 0,
-    "fg_color": ["gray90", "gray13"],
-    "top_fg_color": ["gray85", "gray16"],
-    "border_color": ["gray65", "gray28"]
-  },
-  "CTkButton": {
-    "corner_radius": 6,
-    "border_width": 0,
-    "fg_color": ["#3a7ebf", "#1f538d"],
-    "hover_color": ["#325882", "#14375e"],
-    "border_color": ["#3E454A", "#949A9F"],
-    "text_color": ["#DCE4EE", "#DCE4EE"],
-    "text_color_disabled": ["gray74", "gray60"]
-  },
-  "CTkLabel": {
-    "corner_radius": 0,
-    "fg_color": "transparent",
-    "text_color": ["gray14", "gray84"]
-  },
-  "CTkEntry": {
-    "corner_radius": 6,
-    "border_width": 2,
-    "fg_color": ["#F9F9FA", "#343638"],
-    "border_color": ["#979DA2", "#565B5E"],
-    "text_color": ["gray14", "gray84"],
-    "placeholder_text_color": ["gray52", "gray62"]
-  },
-  "CTkCheckbox": {
-    "corner_radius": 6,
-    "border_width": 3,
-    "fg_color": ["#3a7ebf", "#1f538d"],
-    "border_color": ["#3E454A", "#949A9F"],
-    "hover_color": ["#325882", "#14375e"],
-    "checkmark_color": ["#DCE4EE", "gray90"],
-    "text_color": ["gray14", "gray84"],
-    "text_color_disabled": ["gray60", "gray45"]
-  },
-  "CTkSwitch": {
-    "corner_radius": 1000,
-    "border_width": 3,
-    "button_length": 0,
-    "fg_color": ["#939BA2", "#4A4D50"],
-    "progress_color": ["#3a7ebf", "#1f538d"],
-    "button_color": ["gray36", "#D5D9DE"],
-    "button_hover_color": ["gray20", "gray100"],
-    "text_color": ["gray14", "gray84"],
-    "text_color_disabled": ["gray60", "gray45"]
-  },
-  "CTkRadiobutton": {
-    "corner_radius": 1000,
-    "border_width_checked": 6,
-    "border_width_unchecked": 3,
-    "fg_color": ["#3a7ebf", "#1f538d"],
-    "border_color": ["#3E454A", "#949A9F"],
-    "hover_color": ["#325882", "#14375e"],
-    "text_color": ["gray14", "gray84"],
-    "text_color_disabled": ["gray60", "gray45"]
-  },
-  "CTkProgressBar": {
-    "corner_radius": 1000,
-    "border_width": 0,
-    "fg_color": ["#939BA2", "#4A4D50"],
-    "progress_color": ["#3a7ebf", "#1f538d"],
-    "border_color": ["gray", "gray"]
-  },
-  "CTkSlider": {
-    "corner_radius": 1000,
-    "button_corner_radius": 1000,
-    "border_width": 6,
-    "button_length": 0,
-    "fg_color": ["#939BA2", "#4A4D50"],
-    "progress_color": ["gray40", "#AAB0B5"],
-    "button_color": ["#3a7ebf", "#1f538d"],
-    "button_hover_color": ["#325882", "#14375e"]
-  },
-  "CTkOptionMenu": {
-    "corner_radius": 6,
-    "fg_color": ["#3a7ebf", "#1f538d"],
-    "button_color": ["#325882", "#14375e"],
-    "button_hover_color": ["#234567", "#1e2c40"],
-    "text_color": ["#DCE4EE", "#DCE4EE"],
-    "text_color_disabled": ["gray74", "gray60"]
-  },
-  "CTkComboBox": {
-    "corner_radius": 6,
-    "border_width": 2,
-    "fg_color": ["#F9F9FA", "#343638"],
-    "border_color": ["#979DA2", "#565B5E"],
-    "button_color": ["#979DA2", "#565B5E"],
-    "button_hover_color": ["#6E7174", "#7A848D"],
-    "text_color": ["gray14", "gray84"],
-    "text_color_disabled": ["gray50", "gray45"]
-  },
-  "CTkScrollbar": {
-    "corner_radius": 1000,
-    "border_spacing": 4,
-    "fg_color": "transparent",
-    "button_color": ["gray55", "gray41"],
-    "button_hover_color": ["gray40", "gray53"]
-  },
-  "CTkSegmentedButton": {
-    "corner_radius": 6,
-    "border_width": 2,
-    "fg_color": ["#979DA2", "gray29"],
-    "selected_color": ["#3a7ebf", "#1f538d"],
-    "selected_hover_color": ["#325882", "#14375e"],
-    "unselected_color": ["#979DA2", "gray29"],
-    "unselected_hover_color": ["gray70", "gray41"],
-    "text_color": ["#DCE4EE", "#DCE4EE"],
-    "text_color_disabled": ["gray74", "gray60"]
-  },
-  "CTkTextbox": {
-    "corner_radius": 6,
-    "border_width": 0,
-    "fg_color": ["gray100", "gray20"],
-    "border_color": ["#979DA2", "#565B5E"],
-    "text_color": ["gray14", "gray84"],
-    "scrollbar_button_color": ["gray55", "gray41"],
-    "scrollbar_button_hover_color": ["gray40", "gray53"]
-  },
-  "CTkScrollableFrame": {
-    "label_fg_color": ["gray80", "gray21"]
-  },
-  "DropdownMenu": {
-    "fg_color": ["gray90", "gray20"],
-    "hover_color": ["gray75", "gray28"],
-    "text_color": ["gray14", "gray84"]
-  },
-  "CTkFont": {
-    "macOS": {
-      "family": "Avenir",
-      "size": 12,
-      "weight": "normal"
-    },
-    "Windows": {
-      "family": "Corbel",
-      "size": 12,
-      "weight": "normal"
-    },
-    "Linux": {
-      "family": "Montserrat",
-      "size": 12,
-      "weight": "normal"
-    }
-  },
-  "RoopDropArea": {
-    "fg_color": ["gray90", "gray13"]
-  },
-  "RoopDonate": {
-    "text_color": ["#3a7ebf", "gray60"]
-  }
-}

roop/ui.py

@@ -1,285 +0,0 @@
-import os
-import sys
-import webbrowser
-import customtkinter as ctk
-from tkinterdnd2 import TkinterDnD, DND_ALL
-from typing import Any, Callable, Tuple, Optional
-import cv2
-from PIL import Image, ImageOps
-
-import roop.globals
-import roop.metadata
-from roop.face_analyser import get_one_face
-from roop.capturer import get_video_frame, get_video_frame_total
-from roop.face_reference import get_face_reference, set_face_reference, clear_face_reference
-from roop.predictor import predict_frame, clear_predictor
-from roop.processors.frame.core import get_frame_processors_modules
-from roop.utilities import is_image, is_video, resolve_relative_path
-
-ROOT = None
-ROOT_HEIGHT = 700
-ROOT_WIDTH = 600
-
-PREVIEW = None
-PREVIEW_MAX_HEIGHT = 700
-PREVIEW_MAX_WIDTH = 1200
-
-RECENT_DIRECTORY_SOURCE = None
-RECENT_DIRECTORY_TARGET = None
-RECENT_DIRECTORY_OUTPUT = None
-
-preview_label = None
-preview_slider = None
-source_label = None
-target_label = None
-status_label = None
-
-
-# todo: remove by native support -> https://github.com/TomSchimansky/CustomTkinter/issues/934
-class CTk(ctk.CTk, TkinterDnD.DnDWrapper):
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
-        self.TkdndVersion = TkinterDnD._require(self)
-
-
-def init(start: Callable[[], None], destroy: Callable[[], None]) -> ctk.CTk:
-    global ROOT, PREVIEW
-
-    ROOT = create_root(start, destroy)
-    PREVIEW = create_preview(ROOT)
-
-    return ROOT
-
-
-def create_root(start: Callable[[], None], destroy: Callable[[], None]) -> ctk.CTk:
-    global source_label, target_label, status_label
-
-    ctk.deactivate_automatic_dpi_awareness()
-    ctk.set_appearance_mode('system')
-    ctk.set_default_color_theme(resolve_relative_path('ui.json'))
-
-    root = CTk()
-    root.minsize(ROOT_WIDTH, ROOT_HEIGHT)
-    root.title(f'{roop.metadata.name} {roop.metadata.version}')
-    root.configure()
-    root.protocol('WM_DELETE_WINDOW', lambda: destroy())
-
-    source_label = ctk.CTkLabel(root, text=None, fg_color=ctk.ThemeManager.theme.get('RoopDropArea').get('fg_color'))
-    source_label.place(relx=0.1, rely=0.1, relwidth=0.3, relheight=0.25)
-    source_label.drop_target_register(DND_ALL)
-    source_label.dnd_bind('<<Drop>>', lambda event: select_source_path(event.data))
-    if roop.globals.source_path:
-        select_source_path(roop.globals.source_path)
-
-    target_label = ctk.CTkLabel(root, text=None, fg_color=ctk.ThemeManager.theme.get('RoopDropArea').get('fg_color'))
-    target_label.place(relx=0.6, rely=0.1, relwidth=0.3, relheight=0.25)
-    target_label.drop_target_register(DND_ALL)
-    target_label.dnd_bind('<<Drop>>', lambda event: select_target_path(event.data))
-    if roop.globals.target_path:
-        select_target_path(roop.globals.target_path)
-
-    source_button = ctk.CTkButton(root, text='Select a face', cursor='hand2', command=lambda: select_source_path())
-    source_button.place(relx=0.1, rely=0.4, relwidth=0.3, relheight=0.1)
-
-    target_button = ctk.CTkButton(root, text='Select a target', cursor='hand2', command=lambda: select_target_path())
-    target_button.place(relx=0.6, rely=0.4, relwidth=0.3, relheight=0.1)
-
-    keep_fps_value = ctk.BooleanVar(value=roop.globals.keep_fps)
-    keep_fps_checkbox = ctk.CTkSwitch(root, text='Keep target fps', variable=keep_fps_value, cursor='hand2', command=lambda: setattr(roop.globals, 'keep_fps', not roop.globals.keep_fps))
-    keep_fps_checkbox.place(relx=0.1, rely=0.6)
-
-    keep_frames_value = ctk.BooleanVar(value=roop.globals.keep_frames)
-    keep_frames_switch = ctk.CTkSwitch(root, text='Keep temporary frames', variable=keep_frames_value, cursor='hand2', command=lambda: setattr(roop.globals, 'keep_frames', keep_frames_value.get()))
-    keep_frames_switch.place(relx=0.1, rely=0.65)
-
-    skip_audio_value = ctk.BooleanVar(value=roop.globals.skip_audio)
-    skip_audio_switch = ctk.CTkSwitch(root, text='Skip target audio', variable=skip_audio_value, cursor='hand2', command=lambda: setattr(roop.globals, 'skip_audio', skip_audio_value.get()))
-    skip_audio_switch.place(relx=0.6, rely=0.6)
-
-    many_faces_value = ctk.BooleanVar(value=roop.globals.many_faces)
-    many_faces_switch = ctk.CTkSwitch(root, text='Many faces', variable=many_faces_value, cursor='hand2', command=lambda: setattr(roop.globals, 'many_faces', many_faces_value.get()))
-    many_faces_switch.place(relx=0.6, rely=0.65)
-
-    start_button = ctk.CTkButton(root, text='Start', cursor='hand2', command=lambda: select_output_path(start))
-    start_button.place(relx=0.15, rely=0.75, relwidth=0.2, relheight=0.05)
-
-    stop_button = ctk.CTkButton(root, text='Destroy', cursor='hand2', command=lambda: destroy())
-    stop_button.place(relx=0.4, rely=0.75, relwidth=0.2, relheight=0.05)
-
-    preview_button = ctk.CTkButton(root, text='Preview', cursor='hand2', command=lambda: toggle_preview())
-    preview_button.place(relx=0.65, rely=0.75, relwidth=0.2, relheight=0.05)
-
-    status_label = ctk.CTkLabel(root, text=None, justify='center')
-    status_label.place(relx=0.1, rely=0.9, relwidth=0.8)
-
-    donate_label = ctk.CTkLabel(root, text='^_^ Donate to project ^_^', justify='center', cursor='hand2')
-    donate_label.place(relx=0.1, rely=0.95, relwidth=0.8)
-    donate_label.configure(text_color=ctk.ThemeManager.theme.get('RoopDonate').get('text_color'))
-    donate_label.bind('<Button>', lambda event: webbrowser.open('https://github.com/sponsors/s0md3v'))
-
-    return root
-
-
-def create_preview(parent: ctk.CTkToplevel) -> ctk.CTkToplevel:
-    global preview_label, preview_slider
-
-    preview = ctk.CTkToplevel(parent)
-    preview.withdraw()
-    preview.configure()
-    preview.protocol('WM_DELETE_WINDOW', lambda: toggle_preview())
-    preview.resizable(width=False, height=False)
-
-    preview_label = ctk.CTkLabel(preview, text=None)
-    preview_label.pack(fill='both', expand=True)
-
-    preview_slider = ctk.CTkSlider(preview, from_=0, to=0, command=lambda frame_value: update_preview(frame_value))
-
-    preview.bind('<Up>', lambda event: update_face_reference(1))
-    preview.bind('<Down>', lambda event: update_face_reference(-1))
-    return preview
-
-
-def update_status(text: str) -> None:
-    status_label.configure(text=text)
-    ROOT.update()
-
-
-def select_source_path(source_path: Optional[str] = None) -> None:
-    global RECENT_DIRECTORY_SOURCE
-
-    if PREVIEW:
-        PREVIEW.withdraw()
-    if source_path is None:
-        source_path = ctk.filedialog.askopenfilename(title='select an source image', initialdir=RECENT_DIRECTORY_SOURCE)
-    if is_image(source_path):
-        roop.globals.source_path = source_path
-        RECENT_DIRECTORY_SOURCE = os.path.dirname(roop.globals.source_path)
-        image = render_image_preview(roop.globals.source_path, (200, 200))
-        source_label.configure(image=image)
-    else:
-        roop.globals.source_path = None
-        source_label.configure(image=None)
-
-
-def select_target_path(target_path: Optional[str] = None) -> None:
-    global RECENT_DIRECTORY_TARGET
-
-    if PREVIEW:
-        PREVIEW.withdraw()
-    clear_face_reference()
-    if target_path is None:
-        target_path = ctk.filedialog.askopenfilename(title='select an target image or video', initialdir=RECENT_DIRECTORY_TARGET)
-    if is_image(target_path):
-        roop.globals.target_path = target_path
-        RECENT_DIRECTORY_TARGET = os.path.dirname(roop.globals.target_path)
-        image = render_image_preview(roop.globals.target_path, (200, 200))
-        target_label.configure(image=image)
-    elif is_video(target_path):
-        roop.globals.target_path = target_path
-        RECENT_DIRECTORY_TARGET = os.path.dirname(roop.globals.target_path)
-        video_frame = render_video_preview(target_path, (200, 200))
-        target_label.configure(image=video_frame)
-    else:
-        roop.globals.target_path = None
-        target_label.configure(image=None)
-
-
-def select_output_path(start: Callable[[], None]) -> None:
-    global RECENT_DIRECTORY_OUTPUT
-
-    if is_image(roop.globals.target_path):
-        output_path = ctk.filedialog.asksaveasfilename(title='save image output file', defaultextension='.png', initialfile='output.png', initialdir=RECENT_DIRECTORY_OUTPUT)
-    elif is_video(roop.globals.target_path):
-        output_path = ctk.filedialog.asksaveasfilename(title='save video output file', defaultextension='.mp4', initialfile='output.mp4', initialdir=RECENT_DIRECTORY_OUTPUT)
-    else:
-        output_path = None
-    if output_path:
-        roop.globals.output_path = output_path
-        RECENT_DIRECTORY_OUTPUT = os.path.dirname(roop.globals.output_path)
-        start()
-
-
-def render_image_preview(image_path: str, size: Tuple[int, int]) -> ctk.CTkImage:
-    image = Image.open(image_path)
-    if size:
-        image = ImageOps.fit(image, size, Image.LANCZOS)
-    return ctk.CTkImage(image, size=image.size)
-
-
-def render_video_preview(video_path: str, size: Tuple[int, int], frame_number: int = 0) -> ctk.CTkImage:
-    capture = cv2.VideoCapture(video_path)
-    if frame_number:
-        capture.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
-    has_frame, frame = capture.read()
-    if has_frame:
-        image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-        if size:
-            image = ImageOps.fit(image, size, Image.LANCZOS)
-        return ctk.CTkImage(image, size=image.size)
-    capture.release()
-    cv2.destroyAllWindows()
-
-
-def toggle_preview() -> None:
-    if PREVIEW.state() == 'normal':
-        PREVIEW.unbind('<Right>')
-        PREVIEW.unbind('<Left>')
-        PREVIEW.withdraw()
-        clear_predictor()
-    elif roop.globals.source_path and roop.globals.target_path:
-        init_preview()
-        update_preview(roop.globals.reference_frame_number)
-        PREVIEW.deiconify()
-
-
-def init_preview() -> None:
-    PREVIEW.title('Preview [ ↕ Reference face ]')
-    if is_image(roop.globals.target_path):
-        preview_slider.pack_forget()
-    if is_video(roop.globals.target_path):
-        video_frame_total = get_video_frame_total(roop.globals.target_path)
-        if video_frame_total > 0:
-            PREVIEW.title('Preview [ ↕ Reference face ] [ ↔ Frame number ]')
-            PREVIEW.bind('<Right>', lambda event: update_frame(int(video_frame_total / 20)))
-            PREVIEW.bind('<Left>', lambda event: update_frame(int(video_frame_total / -20)))
-        preview_slider.configure(to=video_frame_total)
-        preview_slider.pack(fill='x')
-        preview_slider.set(roop.globals.reference_frame_number)
-
-
-def update_preview(frame_number: int = 0) -> None:
-    if roop.globals.source_path and roop.globals.target_path:
-        temp_frame = get_video_frame(roop.globals.target_path, frame_number)
-        if predict_frame(temp_frame):
-            sys.exit()
-        source_face = get_one_face(cv2.imread(roop.globals.source_path))
-        if not get_face_reference():
-            reference_frame = get_video_frame(roop.globals.target_path, roop.globals.reference_frame_number)
-            reference_face = get_one_face(reference_frame, roop.globals.reference_face_position)
-            set_face_reference(reference_face)
-        else:
-            reference_face = get_face_reference()
-        for frame_processor in get_frame_processors_modules(roop.globals.frame_processors):
-            temp_frame = frame_processor.process_frame(
-                source_face,
-                reference_face,
-                temp_frame
-            )
-        image = Image.fromarray(cv2.cvtColor(temp_frame, cv2.COLOR_BGR2RGB))
-        image = ImageOps.contain(image, (PREVIEW_MAX_WIDTH, PREVIEW_MAX_HEIGHT), Image.LANCZOS)
-        image = ctk.CTkImage(image, size=image.size)
-        preview_label.configure(image=image)
-
-
-def update_face_reference(steps: int) -> None:
-    clear_face_reference()
-    reference_frame_number = int(preview_slider.get())
-    roop.globals.reference_face_position += steps
-    roop.globals.reference_frame_number = reference_frame_number
-    update_preview(reference_frame_number)
-
-
-def update_frame(steps: int) -> None:
-    frame_number = preview_slider.get() + steps
-    preview_slider.set(frame_number)
-    update_preview(preview_slider.get())

roop/utilities.py

@@ -1,149 +0,0 @@
-import glob
-import mimetypes
-import os
-import platform
-import shutil
-import ssl
-import subprocess
-import urllib
-from pathlib import Path
-from typing import List, Optional
-from tqdm import tqdm
-
-import roop.globals
-
-TEMP_DIRECTORY = 'temp'
-TEMP_VIDEO_FILE = 'temp.mp4'
-
-# monkey patch ssl for mac
-if platform.system().lower() == 'darwin':
-    ssl._create_default_https_context = ssl._create_unverified_context
-
-
-def run_ffmpeg(args: List[str]) -> bool:
-    commands = ['ffmpeg', '-hide_banner', '-loglevel', roop.globals.log_level]
-    commands.extend(args)
-    try:
-        subprocess.check_output(commands, stderr=subprocess.STDOUT)
-        return True
-    except Exception:
-        pass
-    return False
-
-
-def detect_fps(target_path: str) -> float:
-    command = ['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=r_frame_rate', '-of', 'default=noprint_wrappers=1:nokey=1', target_path]
-    output = subprocess.check_output(command).decode().strip().split('/')
-    try:
-        numerator, denominator = map(int, output)
-        return numerator / denominator
-    except Exception:
-        pass
-    return 30
-
-
-def extract_frames(target_path: str, fps: float = 30) -> bool:
-    temp_directory_path = get_temp_directory_path(target_path)
-    temp_frame_quality = roop.globals.temp_frame_quality * 31 // 100
-    return run_ffmpeg(['-hwaccel', 'auto', '-i', target_path, '-q:v', str(temp_frame_quality), '-pix_fmt', 'rgb24', '-vf', 'fps=' + str(fps), os.path.join(temp_directory_path, '%04d.' + roop.globals.temp_frame_format)])
-
-
-def create_video(target_path: str, fps: float = 30) -> bool:
-    temp_output_path = get_temp_output_path(target_path)
-    temp_directory_path = get_temp_directory_path(target_path)
-    output_video_quality = (roop.globals.output_video_quality + 1) * 51 // 100
-    commands = ['-hwaccel', 'auto', '-r', str(fps), '-i', os.path.join(temp_directory_path, '%04d.' + roop.globals.temp_frame_format), '-c:v', roop.globals.output_video_encoder]
-    if roop.globals.output_video_encoder in ['libx264', 'libx265', 'libvpx']:
-        commands.extend(['-crf', str(output_video_quality)])
-    if roop.globals.output_video_encoder in ['h264_nvenc', 'hevc_nvenc']:
-        commands.extend(['-cq', str(output_video_quality)])
-    commands.extend(['-pix_fmt', 'yuv420p', '-vf', 'colorspace=bt709:iall=bt601-6-625:fast=1', '-y', temp_output_path])
-    return run_ffmpeg(commands)
-
-
-def restore_audio(target_path: str, output_path: str) -> None:
-    temp_output_path = get_temp_output_path(target_path)
-    done = run_ffmpeg(['-i', temp_output_path, '-i', target_path, '-c:v', 'copy', '-map', '0:v:0', '-map', '1:a:0', '-y', output_path])
-    if not done:
-        move_temp(target_path, output_path)
-
-
-def get_temp_frame_paths(target_path: str) -> List[str]:
-    temp_directory_path = get_temp_directory_path(target_path)
-    return glob.glob((os.path.join(glob.escape(temp_directory_path), '*.' + roop.globals.temp_frame_format)))
-
-
-def get_temp_directory_path(target_path: str) -> str:
-    target_name, _ = os.path.splitext(os.path.basename(target_path))
-    target_directory_path = os.path.dirname(target_path)
-    return os.path.join(target_directory_path, TEMP_DIRECTORY, target_name)
-
-
-def get_temp_output_path(target_path: str) -> str:
-    temp_directory_path = get_temp_directory_path(target_path)
-    return os.path.join(temp_directory_path, TEMP_VIDEO_FILE)
-
-
-def normalize_output_path(source_path: str, target_path: str, output_path: str) -> Optional[str]:
-    if source_path and target_path and output_path:
-        source_name, _ = os.path.splitext(os.path.basename(source_path))
-        target_name, target_extension = os.path.splitext(os.path.basename(target_path))
-        if os.path.isdir(output_path):
-            return os.path.join(output_path, source_name + '-' + target_name + target_extension)
-    return output_path
-
-
-def create_temp(target_path: str) -> None:
-    temp_directory_path = get_temp_directory_path(target_path)
-    Path(temp_directory_path).mkdir(parents=True, exist_ok=True)
-
-
-def move_temp(target_path: str, output_path: str) -> None:
-    temp_output_path = get_temp_output_path(target_path)
-    if os.path.isfile(temp_output_path):
-        if os.path.isfile(output_path):
-            os.remove(output_path)
-        shutil.move(temp_output_path, output_path)
-
-
-def clean_temp(target_path: str) -> None:
-    temp_directory_path = get_temp_directory_path(target_path)
-    parent_directory_path = os.path.dirname(temp_directory_path)
-    if not roop.globals.keep_frames and os.path.isdir(temp_directory_path):
-        shutil.rmtree(temp_directory_path)
-    if os.path.exists(parent_directory_path) and not os.listdir(parent_directory_path):
-        os.rmdir(parent_directory_path)
-
-
-def has_image_extension(image_path: str) -> bool:
-    return image_path.lower().endswith(('png', 'jpg', 'jpeg', 'webp'))
-
-
-def is_image(image_path: str) -> bool:
-    if image_path and os.path.isfile(image_path):
-        mimetype, _ = mimetypes.guess_type(image_path)
-        return bool(mimetype and mimetype.startswith('image/'))
-    return False
-
-
-def is_video(video_path: str) -> bool:
-    if video_path and os.path.isfile(video_path):
-        mimetype, _ = mimetypes.guess_type(video_path)
-        return bool(mimetype and mimetype.startswith('video/'))
-    return False
-
-
-def conditional_download(download_directory_path: str, urls: List[str]) -> None:
-    if not os.path.exists(download_directory_path):
-        os.makedirs(download_directory_path)
-    for url in urls:
-        download_file_path = os.path.join(download_directory_path, os.path.basename(url))
-        if not os.path.exists(download_file_path):
-            request = urllib.request.urlopen(url)  # type: ignore[attr-defined]
-            total = int(request.headers.get('Content-Length', 0))
-            with tqdm(total=total, desc='Downloading', unit='B', unit_scale=True, unit_divisor=1024) as progress:
-                urllib.request.urlretrieve(url, download_file_path, reporthook=lambda count, block_size, total_size: progress.update(block_size))  # type: ignore[attr-defined]
-
-
-def resolve_relative_path(path: str) -> str:
-    return os.path.abspath(os.path.join(os.path.dirname(__file__), path))