Upload folder using huggingface_hub

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_size = 4
+indent_style = tab
+trim_trailing_whitespace = true

.flake8

@@ -0,0 +1,3 @@
+[flake8]
+select = E3, E4, F
+per-file-ignores = facefusion/core.py:E402, facefusion/installer.py:E402

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.github/preview.png filter=lfs diff=lfs merge=lfs -text
+temp/target/test-1703080901.png filter=lfs diff=lfs merge=lfs -text
+temp/target/test-1703080957.png filter=lfs diff=lfs merge=lfs -text
+temp/target/test-1703080999.png filter=lfs diff=lfs merge=lfs -text
+temp/target/test-1703081020.png filter=lfs diff=lfs merge=lfs -text

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: henryruhs
+custom: https://paypal.me/henryruhs

.github/workflows/ci.yml

@@ -0,0 +1,35 @@
+name: ci
+
+on: [ push, pull_request ]
+
+jobs:
+ lint:
+  runs-on: ubuntu-latest
+  steps:
+  - name: Checkout
+    uses: actions/checkout@v2
+  - name: Set up Python 3.10
+    uses: actions/setup-python@v2
+    with:
+     python-version: '3.10'
+  - run: pip install flake8
+  - run: pip install mypy
+  - run: flake8 run.py facefusion tests
+  - run: mypy run.py facefusion tests
+ test:
+  strategy:
+   matrix:
+    os: [ macos-latest, ubuntu-latest, windows-latest ]
+  runs-on: ${{ matrix.os }}
+  steps:
+  - name: Checkout
+    uses: actions/checkout@v2
+  - name: Set up ffmpeg
+    uses: FedericoCarboni/setup-ffmpeg@v2
+  - name: Set up Python 3.10
+    uses: actions/setup-python@v2
+    with:
+     python-version: '3.10'
+  - run: python install.py --torch cpu --onnxruntime default
+  - run: pip install pytest
+  - run: pytest

.gitignore

@@ -0,0 +1,10 @@
+.assets
+.idea
+.vscode
+**/venv/
+**/__pycache__/
+**/pyvenv.cfg
+**/local_cache/
+**/*.DS_Store
+**/*.jpg
+**/*.mp4

Dockerfile

@@ -0,0 +1,15 @@
+FROM ubuntu:20.04
+
+RUN apt-get update && apt-get install -y ffmpeg
+
+# 安装项目依赖
+RUN pip install -r requirements.txt
+
+# 复制项目代码到容器
+COPY . /app
+
+# 设置工作目录
+WORKDIR /app
+
+# 启动 FaceFusion API
+CMD ["python", "run.py", "--api"]

LICENSE.md

@@ -0,0 +1,3 @@
+MIT license
+
+Copyright (c) 2023 Henry Ruhs

README.md

@@ -1,10 +1,9 @@
 ---
-title: Facefusionapi
-emoji: 📈
-colorFrom: pink
-colorTo: yellow
+title: facefusionapi
+emoji: 🐳
+colorFrom: purple
+colorTo: gray
 sdk: docker
-pinned: false
+app_port: 7860
 ---
-
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

facefusion/api/core.py

@@ -0,0 +1,81 @@
+import os
+import base64
+import time
+from fastapi import FastAPI, APIRouter, Body
+
+from facefusion.api.model import Params, print_globals
+import facefusion.globals as globals
+import facefusion.processors.frame.globals as frame_processors_globals
+from facefusion import core
+from facefusion.utilities import normalize_output_path
+
+app = FastAPI()
+router = APIRouter()
+
+@router.post("/")
+async def process_frames(params: Params = Body(...)) -> dict:
+    delete_files_in_directory('/workspaces/facefusion-api/facefusion/api/temp/source')
+    delete_files_in_directory('/workspaces/facefusion-api/facefusion/api/temp/target')
+    delete_files_in_directory('/workspaces/facefusion-api/facefusion/api/temp/output')
+
+    if not (params.source or params.target):
+        return {"message": "Source image or path is required"}
+
+    update_global_variables(params)
+    
+    globals.source_path = f"/workspaces/facefusion-api/facefusion/api/temp/source/{params.user_id}-{int(time.time())}.{params.source_type}"
+    globals.target_path = f"/workspaces/facefusion-api/facefusion/api/temp/target/{params.user_id}-{int(time.time())}.{params.target_type}"
+    globals.output_path = f"/workspaces/facefusion-api/facefusion/api/temp/output/{params.user_id}-{int(time.time())}.{params.target_type}"
+
+    print(globals.output_path)
+
+    print_globals()
+
+    # save_file(globals.source_path, params.source)
+    # save_file(globals.target_path, params.target)
+
+    try:
+        core.api_conditional_process()
+    except Exception as e:
+        print(e)
+        return {"message": "Error"}
+    output = image_to_base64_str(globals.output_path)
+    return {'output': output}
+
+def update_global_variables(params: Params):
+    for var_name, value in vars(params).items():
+        if value is not None:
+            if hasattr(globals, var_name):
+                setattr(globals, var_name, value)
+            elif hasattr(frame_processors_globals, var_name):
+                setattr(frame_processors_globals, var_name, value)
+
+def image_to_base64_str(image_path):
+    with open(image_path, "rb") as image_file:
+        encoded_string = base64.b64encode(image_file.read())
+        return encoded_string.decode('utf-8')
+
+def save_file(file_path: str, encoded_image: str):
+    data = base64.b64decode(encoded_image)
+
+    directory = os.path.dirname(file_path)
+
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    with open(file_path, "wb") as file:
+        file.write(data)
+
+def delete_files_in_directory(directory_path):
+    for filename in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, filename)
+        if os.path.isfile(file_path):
+            os.remove(file_path)
+            print(f"Deleted {file_path}")
+
+
+app.include_router(router)
+
+def launch():
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

facefusion/api/model.py

@@ -0,0 +1,99 @@
+from pydantic import BaseModel
+from typing import Optional, List
+from facefusion.typing import FaceSelectorMode, FaceAnalyserOrder, FaceAnalyserAge, FaceAnalyserGender, OutputVideoEncoder, FaceDetectorModel, FaceRecognizerModel, TempFrameFormat, Padding
+from facefusion.processors.frame.typings import FaceSwapperModel, FaceEnhancerModel, FrameEnhancerModel, FaceDebuggerItem
+
+class Params(BaseModel):
+    user_id : str
+    source : Optional[str]
+    target : str
+    source_type: str
+    target_type: str
+
+    # execution
+    execution_providers: Optional[List[str]] = ['CPUExecutionProvider']
+    execution_thread_count: Optional[int] = 4
+    execution_queue_count: Optional[int] = 1
+    max_memory: Optional[int] = 0
+
+    # face analyser
+    face_analyser_order: Optional[FaceAnalyserOrder] = 'left-right'
+    face_analyser_age: Optional[FaceAnalyserAge] = None
+    face_analyser_gender: Optional[FaceAnalyserGender] = None
+    face_detector_model: Optional[FaceDetectorModel] = 'retinaface'
+    face_detector_size: Optional[str] = '640x640'
+    face_detector_score: Optional[float] = 0.5
+    face_recognizer_model: Optional[FaceRecognizerModel] = 'arcface_inswapper'
+
+    # face selector
+    face_selector_mode: Optional[FaceSelectorMode] = 'reference'
+    reference_face_position: Optional[int] = 0
+    reference_face_distance: Optional[float] = 0.6
+    reference_frame_number: Optional[int] = 0
+
+    # face mask
+    face_mask_blur: Optional[float] = 0.3
+    face_mask_padding: Optional[Padding] = (0, 0, 0, 0)
+
+    # frame extraction
+    trim_frame_start: Optional[int] = None
+    trim_frame_end: Optional[int] = None
+    temp_frame_format: Optional[TempFrameFormat] = 'jpg'
+    temp_frame_quality: Optional[int] = 100
+    keep_temp: Optional[bool] = False
+
+    # output creation
+    output_image_quality: Optional[int] = 80
+    output_video_encoder: Optional[OutputVideoEncoder] = 'libx264'
+    output_video_quality: Optional[int] = 80
+    keep_fps: Optional[bool] = False
+    skip_audio: Optional[bool] = False
+
+    # frame processors
+    frame_processors: List[str] = ['face_blur']
+
+    face_swapper_model: Optional[FaceSwapperModel] = 'inswapper_128'
+    face_enhancer_model: Optional[FaceEnhancerModel] = 'gfpgan_1.4'
+    face_enhancer_blend: Optional[int] = 80
+    frame_enhancer_model: Optional[FrameEnhancerModel] = 'real_esrgan_x2plus'
+    frame_enhancer_blend: Optional[int] = 80
+    face_debugger_items: Optional[List[FaceDebuggerItem]] = ['kps', 'face-mask']
+
+
+import facefusion.globals as globals
+import facefusion.processors.frame.globals as frame_processors_globals
+def print_globals():
+    print(f'execution_providers: {globals.execution_providers}')
+    print(f'execution_thread_count: {globals.execution_thread_count}')
+    print(f'execution_queue_count: {globals.execution_queue_count}')
+    print(f'max_memory: {globals.max_memory}')
+    print(f'face_analyser_order: {globals.face_analyser_order}')
+    print(f'face_analyser_age: {globals.face_analyser_age}')
+    print(f'face_analyser_gender: {globals.face_analyser_gender}')
+    print(f'face_detector_model: {globals.face_detector_model}')
+    print(f'face_detector_size: {globals.face_detector_size}')
+    print(f'face_detector_score: {globals.face_detector_score}')
+    print(f'face_recognizer_model: {globals.face_recognizer_model}')
+    print(f'face_selector_mode: {globals.face_selector_mode}')
+    print(f'reference_face_position: {globals.reference_face_position}')
+    print(f'reference_face_distance: {globals.reference_face_distance}')
+    print(f'reference_frame_number: {globals.reference_frame_number}')
+    print(f'face_mask_blur: {globals.face_mask_blur}')
+    print(f'face_mask_padding: {globals.face_mask_padding}')
+    print(f'trim_frame_start: {globals.trim_frame_start}')
+    print(f'trim_frame_end: {globals.trim_frame_end}')
+    print(f'temp_frame_format: {globals.temp_frame_format}')
+    print(f'temp_frame_quality: {globals.temp_frame_quality}')
+    print(f'keep_temp: {globals.keep_temp}')
+    print(f'output_image_quality: {globals.output_image_quality}')
+    print(f'output_video_encoder: {globals.output_video_encoder}')
+    print(f'output_video_quality: {globals.output_video_quality}')
+    print(f'keep_fps: {globals.keep_fps}')
+    print(f'skip_audio: {globals.skip_audio}')
+    print(f'frame_processors: {globals.frame_processors}')
+    print(f'face_swapper_model: {frame_processors_globals.face_swapper_model}')
+    print(f'face_enhancer_model: {frame_processors_globals.face_enhancer_model}')
+    print(f'face_enhancer_blend: {frame_processors_globals.face_enhancer_blend}')
+    print(f'frame_enhancer_model: {frame_processors_globals.frame_enhancer_model}')
+    print(f'frame_enhancer_blend: {frame_processors_globals.frame_enhancer_blend}')
+    print(f'face_debugger_items: {frame_processors_globals.face_debugger_items}')

facefusion/api/test/test.py

@@ -0,0 +1,48 @@
+import base64
+import requests
+import time
+
+def image_to_base64_str(image_path):
+    with open(image_path, "rb") as image_file:
+        encoded_string = base64.b64encode(image_file.read())
+        return encoded_string.decode('utf-8')
+
+source_image_path = 'source.jpg'
+target_image_path = 'target.jpg'
+
+source_str = image_to_base64_str(source_image_path)
+target_str = image_to_base64_str(target_image_path)
+
+params = {
+    'user_id': 'test',
+    'source': source_str,
+    'target': target_str,
+    'source_type': 'jpg',
+    'target_type': 'jpg',
+    'frame_processors': ['face_swapper','face_enhancer'],#,'face_enhancer'
+    # 'face_mask_blur': 0.5,
+    # 'face_mask_padding': [5, 5, 5, 5],
+    'face_enhancer_model':  'gfpgan_1.4',
+    'keep_fps': True,
+    "output_image_quality":100,
+    'execution_thread_count': 40,
+    'face_selector_mode': 'one',
+}
+
+url = 'http://0.0.0.0:7860/'
+response = requests.post(url, json=params)
+
+# ステータスコードとレスポンスの内容を確認
+print("Status Code:", response.status_code)
+print("Response Body:")
+start=time.time()
+# ステータスコードが200の場合のみ処理を進める
+if response.status_code == 200:
+    output_data = base64.b64decode(response.json()['output'])
+    # print("response.json()",response.json())
+    with open(f'/workspaces/facefusion-api/facefusion/api/temp/output/{int(time.time())}a.jpg', 'wb') as f:
+        f.write(output_data)
+        end=time.time()
+        print("时间",end-start)
+else:
+    print("Error: The request did not succeed.")

facefusion/choices.py

@@ -0,0 +1,26 @@
+from typing import List
+
+import numpy
+
+from facefusion.typing import FaceSelectorMode, FaceAnalyserOrder, FaceAnalyserAge, FaceAnalyserGender, TempFrameFormat, OutputVideoEncoder
+
+
+face_analyser_orders : List[FaceAnalyserOrder] = [ 'left-right', 'right-left', 'top-bottom', 'bottom-top', 'small-large', 'large-small', 'best-worst', 'worst-best' ]
+face_analyser_ages : List[FaceAnalyserAge] = [ 'child', 'teen', 'adult', 'senior' ]
+face_analyser_genders : List[FaceAnalyserGender] = [ 'male', 'female' ]
+face_detector_models : List[str] = [ 'retinaface', 'yunet' ]
+face_detector_sizes : List[str] = [ '160x160', '320x320', '480x480', '512x512', '640x640', '768x768', '960x960', '1024x1024' ]
+face_selector_modes : List[FaceSelectorMode] = [ 'reference', 'one', 'many' ]
+temp_frame_formats : List[TempFrameFormat] = [ 'jpg', 'png' ]
+output_video_encoders : List[OutputVideoEncoder] = [ 'libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc' ]
+
+execution_thread_count_range : List[int] = numpy.arange(1, 129, 1).tolist()
+execution_queue_count_range : List[int] = numpy.arange(1, 33, 1).tolist()
+max_memory_range : List[int] = numpy.arange(0, 129, 1).tolist()
+face_detector_score_range : List[float] = numpy.arange(0.0, 1.05, 0.05).tolist()
+face_mask_blur_range : List[float] = numpy.arange(0.0, 1.05, 0.05).tolist()
+face_mask_padding_range : List[float] = numpy.arange(0, 101, 1).tolist()
+reference_face_distance_range : List[float] = numpy.arange(0.0, 1.55, 0.05).tolist()
+temp_frame_quality_range : List[int] = numpy.arange(0, 101, 1).tolist()
+output_image_quality_range : List[int] = numpy.arange(0, 101, 1).tolist()
+output_video_quality_range : List[int] = numpy.arange(0, 101, 1).tolist()

facefusion/content_analyser.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict
+from functools import lru_cache
+import threading
+import cv2
+import numpy
+import onnxruntime
+from tqdm import tqdm
+
+import facefusion.globals
+from facefusion import wording
+from facefusion.typing import Frame, ModelValue
+from facefusion.vision import get_video_frame, count_video_frame_total, read_image, detect_fps
+from facefusion.utilities import resolve_relative_path, conditional_download
+
+CONTENT_ANALYSER = None
+THREAD_LOCK : threading.Lock = threading.Lock()
+MODELS : Dict[str, ModelValue] =\
+{
+	'open_nsfw':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/open_nsfw.onnx',
+		'path': resolve_relative_path('../.assets/models/open_nsfw.onnx')
+	}
+}
+MAX_PROBABILITY = 0.80
+MAX_RATE = 5
+STREAM_COUNTER = 0
+
+
+def get_content_analyser() -> Any:
+	global CONTENT_ANALYSER
+
+	with THREAD_LOCK:
+		if CONTENT_ANALYSER is None:
+			model_path = MODELS.get('open_nsfw').get('path')
+			CONTENT_ANALYSER = onnxruntime.InferenceSession(model_path, providers = facefusion.globals.execution_providers)
+	return CONTENT_ANALYSER
+
+
+def clear_content_analyser() -> None:
+	global CONTENT_ANALYSER
+
+	CONTENT_ANALYSER = None
+
+
+def pre_check() -> bool:
+	if not facefusion.globals.skip_download:
+		download_directory_path = resolve_relative_path('../.assets/models')
+		model_url = MODELS.get('open_nsfw').get('url')
+		conditional_download(download_directory_path, [ model_url ])
+	return True
+
+
+def analyse_stream(frame : Frame, fps : float) -> bool:
+	global STREAM_COUNTER
+
+	STREAM_COUNTER = STREAM_COUNTER + 1
+	if STREAM_COUNTER % int(fps) == 0:
+		return analyse_frame(frame)
+	return False
+
+
+def prepare_frame(frame : Frame) -> Frame:
+	frame = cv2.resize(frame, (224, 224)).astype(numpy.float32)
+	frame -= numpy.array([ 104, 117, 123 ]).astype(numpy.float32)
+	frame = numpy.expand_dims(frame, axis = 0)
+	return frame
+
+
+def analyse_frame(frame : Frame) -> bool:
+	content_analyser = get_content_analyser()
+	frame = prepare_frame(frame)
+	probability = content_analyser.run(None,
+	{
+		'input:0': frame
+	})[0][0][1]
+	return probability > MAX_PROBABILITY
+
+
+@lru_cache(maxsize = None)
+def analyse_image(image_path : str) -> bool:
+	frame = read_image(image_path)
+	return analyse_frame(frame)
+
+
+@lru_cache(maxsize = None)
+def analyse_video(video_path : str, start_frame : int, end_frame : int) -> bool:
+	video_frame_total = count_video_frame_total(video_path)
+	fps = detect_fps(video_path)
+	frame_range = range(start_frame or 0, end_frame or video_frame_total)
+	rate = 0.0
+	counter = 0
+	with tqdm(total = len(frame_range), desc = wording.get('analysing'), unit = 'frame', ascii = ' =') as progress:
+		for frame_number in frame_range:
+			if frame_number % int(fps) == 0:
+				frame = get_video_frame(video_path, frame_number)
+				if analyse_frame(frame):
+					counter += 1
+			rate = counter * int(fps) / len(frame_range) * 100
+			progress.update()
+			progress.set_postfix(rate = rate)
+	return rate > MAX_RATE

facefusion/core.py

@@ -0,0 +1,362 @@
+import os
+
+os.environ['OMP_NUM_THREADS'] = '1'
+
+import signal
+import sys
+import warnings
+import platform
+import shutil
+import onnxruntime
+from argparse import ArgumentParser, HelpFormatter
+
+import facefusion.choices
+import facefusion.globals
+from facefusion.face_analyser import get_one_face
+from facefusion.face_reference import get_face_reference, set_face_reference
+from facefusion.vision import get_video_frame, read_image
+from facefusion import face_analyser, content_analyser, metadata, wording
+from facefusion.content_analyser import analyse_image, analyse_video
+from facefusion.processors.frame.core import get_frame_processors_modules, load_frame_processor_module, api_get_frame_processors_modules
+from facefusion.utilities import is_image, is_video, detect_fps, compress_image, merge_video, extract_frames, get_temp_frame_paths, restore_audio, create_temp, move_temp, clear_temp, list_module_names, encode_execution_providers, decode_execution_providers, normalize_output_path, normalize_padding, create_metavar, update_status
+
+onnxruntime.set_default_logger_severity(3)
+warnings.filterwarnings('ignore', category = UserWarning, module = 'gradio')
+warnings.filterwarnings('ignore', category = UserWarning, module = 'torchvision')
+
+
+def cli() -> None:
+	signal.signal(signal.SIGINT, lambda signal_number, frame: destroy())
+	program = ArgumentParser(formatter_class = lambda prog: HelpFormatter(prog, max_help_position = 120), add_help = False)
+	# api
+	program.add_argument('--api', help='Run in API mode', action='store_true', dest='api_mode')
+	# general
+	program.add_argument('-s', '--source', help = wording.get('source_help'), dest = 'source_path')
+	program.add_argument('-t', '--target', help = wording.get('target_help'), dest = 'target_path')
+	program.add_argument('-o', '--output', help = wording.get('output_help'), dest = 'output_path')
+	program.add_argument('-v', '--version', version = metadata.get('name') + ' ' + metadata.get('version'), action = 'version')
+	# misc
+	group_misc = program.add_argument_group('misc')
+	group_misc.add_argument('--skip-download', help = wording.get('skip_download_help'), dest = 'skip_download', action = 'store_true')
+	group_misc.add_argument('--headless', help = wording.get('headless_help'), dest = 'headless', action = 'store_true')
+	# execution
+	group_execution = program.add_argument_group('execution')
+	group_execution.add_argument('--execution-providers', help = wording.get('execution_providers_help'), dest = 'execution_providers', default = [ 'cpu' ], choices = encode_execution_providers(onnxruntime.get_available_providers()), nargs = '+')
+	group_execution.add_argument('--execution-thread-count', help = wording.get('execution_thread_count_help'), dest = 'execution_thread_count', type = int, default = 4, choices = facefusion.choices.execution_thread_count_range, metavar = create_metavar(facefusion.choices.execution_thread_count_range))
+	group_execution.add_argument('--execution-queue-count', help = wording.get('execution_queue_count_help'), dest = 'execution_queue_count', type = int, default = 1, choices = facefusion.choices.execution_queue_count_range, metavar = create_metavar(facefusion.choices.execution_queue_count_range))
+	group_execution.add_argument('--max-memory', help = wording.get('max_memory_help'), dest = 'max_memory', type = int, choices = facefusion.choices.max_memory_range, metavar = create_metavar(facefusion.choices.max_memory_range))
+	# face analyser
+	group_face_analyser = program.add_argument_group('face analyser')
+	group_face_analyser.add_argument('--face-analyser-order', help = wording.get('face_analyser_order_help'), dest = 'face_analyser_order', default = 'left-right', choices = facefusion.choices.face_analyser_orders)
+	group_face_analyser.add_argument('--face-analyser-age', help = wording.get('face_analyser_age_help'), dest = 'face_analyser_age', choices = facefusion.choices.face_analyser_ages)
+	group_face_analyser.add_argument('--face-analyser-gender', help = wording.get('face_analyser_gender_help'), dest = 'face_analyser_gender', choices = facefusion.choices.face_analyser_genders)
+	group_face_analyser.add_argument('--face-detector-model', help = wording.get('face_detector_model_help'), dest = 'face_detector_model', default = 'retinaface', choices = facefusion.choices.face_detector_models)
+	group_face_analyser.add_argument('--face-detector-size', help = wording.get('face_detector_size_help'), dest = 'face_detector_size', default = '640x640', choices = facefusion.choices.face_detector_sizes)
+	group_face_analyser.add_argument('--face-detector-score', help = wording.get('face_detector_score_help'), dest = 'face_detector_score', type = float, default = 0.5, choices = facefusion.choices.face_detector_score_range, metavar = create_metavar(facefusion.choices.face_detector_score_range))
+	# face selector
+	group_face_selector = program.add_argument_group('face selector')
+	group_face_selector.add_argument('--face-selector-mode', help = wording.get('face_selector_mode_help'), dest = 'face_selector_mode', default = 'reference', choices = facefusion.choices.face_selector_modes)
+	group_face_selector.add_argument('--reference-face-position', help = wording.get('reference_face_position_help'), dest = 'reference_face_position', type = int, default = 0)
+	group_face_selector.add_argument('--reference-face-distance', help = wording.get('reference_face_distance_help'), dest = 'reference_face_distance', type = float, default = 0.6, choices = facefusion.choices.reference_face_distance_range, metavar = create_metavar(facefusion.choices.reference_face_distance_range))
+	group_face_selector.add_argument('--reference-frame-number', help = wording.get('reference_frame_number_help'), dest = 'reference_frame_number', type = int, default = 0)
+	# face mask
+	group_face_mask = program.add_argument_group('face mask')
+	group_face_mask.add_argument('--face-mask-blur', help = wording.get('face_mask_blur_help'), dest = 'face_mask_blur', type = float, default = 0.3, choices = facefusion.choices.face_mask_blur_range, metavar = create_metavar(facefusion.choices.face_mask_blur_range))
+	group_face_mask.add_argument('--face-mask-padding', help = wording.get('face_mask_padding_help'), dest = 'face_mask_padding', type = int, default = [ 0, 0, 0, 0 ], nargs = '+')
+	# frame extraction
+	group_frame_extraction = program.add_argument_group('frame extraction')
+	group_frame_extraction.add_argument('--trim-frame-start', help = wording.get('trim_frame_start_help'), dest = 'trim_frame_start', type = int)
+	group_frame_extraction.add_argument('--trim-frame-end', help = wording.get('trim_frame_end_help'), dest = 'trim_frame_end', type = int)
+	group_frame_extraction.add_argument('--temp-frame-format', help = wording.get('temp_frame_format_help'), dest = 'temp_frame_format', default = 'jpg', choices = facefusion.choices.temp_frame_formats)
+	group_frame_extraction.add_argument('--temp-frame-quality', help = wording.get('temp_frame_quality_help'), dest = 'temp_frame_quality', type = int, default = 100, choices = facefusion.choices.temp_frame_quality_range, metavar = create_metavar(facefusion.choices.temp_frame_quality_range))
+	group_frame_extraction.add_argument('--keep-temp', help = wording.get('keep_temp_help'), dest = 'keep_temp', action = 'store_true')
+	# output creation
+	group_output_creation = program.add_argument_group('output creation')
+	group_output_creation.add_argument('--output-image-quality', help = wording.get('output_image_quality_help'), dest = 'output_image_quality', type = int, default = 80, choices = facefusion.choices.output_image_quality_range, metavar = create_metavar(facefusion.choices.output_image_quality_range))
+	group_output_creation.add_argument('--output-video-encoder', help = wording.get('output_video_encoder_help'), dest = 'output_video_encoder', default = 'libx264', choices = facefusion.choices.output_video_encoders)
+	group_output_creation.add_argument('--output-video-quality', help = wording.get('output_video_quality_help'), dest = 'output_video_quality', type = int, default = 80, choices = facefusion.choices.output_video_quality_range, metavar = create_metavar(facefusion.choices.output_video_quality_range))
+	group_output_creation.add_argument('--keep-fps', help = wording.get('keep_fps_help'), dest = 'keep_fps', action = 'store_true')
+	group_output_creation.add_argument('--skip-audio', help = wording.get('skip_audio_help'), dest = 'skip_audio', action = 'store_true')
+	# frame processors
+	available_frame_processors = list_module_names('facefusion/processors/frame/modules')
+	program = ArgumentParser(parents = [ program ], formatter_class = program.formatter_class, add_help = True)
+	group_frame_processors = program.add_argument_group('frame processors')
+	group_frame_processors.add_argument('--frame-processors', help = wording.get('frame_processors_help').format(choices = ', '.join(available_frame_processors)), dest = 'frame_processors', default = [ 'face_swapper' ], nargs = '+')
+	for frame_processor in available_frame_processors:
+		frame_processor_module = load_frame_processor_module(frame_processor)
+		frame_processor_module.register_args(group_frame_processors)
+	# uis
+	group_uis = program.add_argument_group('uis')
+	group_uis.add_argument('--ui-layouts', help = wording.get('ui_layouts_help').format(choices = ', '.join(list_module_names('facefusion/uis/layouts'))), dest = 'ui_layouts', default = [ 'default' ], nargs = '+')
+	run(program)
+
+
+def apply_args(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	# api
+	facefusion.globals.api_mode = args.api_mode
+	# general
+	facefusion.globals.source_path = args.source_path
+	facefusion.globals.target_path = args.target_path
+	facefusion.globals.output_path = normalize_output_path(facefusion.globals.source_path, facefusion.globals.target_path, args.output_path)
+	# misc
+	facefusion.globals.skip_download = args.skip_download
+	facefusion.globals.headless = args.headless
+	# execution
+	facefusion.globals.execution_providers = decode_execution_providers(args.execution_providers)
+	facefusion.globals.execution_thread_count = args.execution_thread_count
+	facefusion.globals.execution_queue_count = args.execution_queue_count
+	facefusion.globals.max_memory = args.max_memory
+	# face analyser
+	facefusion.globals.face_analyser_order = args.face_analyser_order
+	facefusion.globals.face_analyser_age = args.face_analyser_age
+	facefusion.globals.face_analyser_gender = args.face_analyser_gender
+	facefusion.globals.face_detector_model = args.face_detector_model
+	facefusion.globals.face_detector_size = args.face_detector_size
+	facefusion.globals.face_detector_score = args.face_detector_score
+	# face selector
+	facefusion.globals.face_selector_mode = args.face_selector_mode
+	facefusion.globals.reference_face_position = args.reference_face_position
+	facefusion.globals.reference_face_distance = args.reference_face_distance
+	facefusion.globals.reference_frame_number = args.reference_frame_number
+	# face mask
+	facefusion.globals.face_mask_blur = args.face_mask_blur
+	facefusion.globals.face_mask_padding = normalize_padding(args.face_mask_padding)
+	# frame extraction
+	facefusion.globals.trim_frame_start = args.trim_frame_start
+	facefusion.globals.trim_frame_end = args.trim_frame_end
+	facefusion.globals.temp_frame_format = args.temp_frame_format
+	facefusion.globals.temp_frame_quality = args.temp_frame_quality
+	facefusion.globals.keep_temp = args.keep_temp
+	# output creation
+	facefusion.globals.output_image_quality = args.output_image_quality
+	facefusion.globals.output_video_encoder = args.output_video_encoder
+	facefusion.globals.output_video_quality = args.output_video_quality
+	facefusion.globals.keep_fps = args.keep_fps
+	facefusion.globals.skip_audio = args.skip_audio
+	# frame processors
+	available_frame_processors = list_module_names('facefusion/processors/frame/modules')
+	# facefusion.globals.frame_processors = args.frame_processors
+	facefusion.globals.frame_processors = ['face_swapper','face_enhancer']
+	print("有哪些参数")
+	for frame_processor in available_frame_processors:
+		frame_processor_module = load_frame_processor_module(frame_processor)
+		frame_processor_module.apply_args(program)
+	# uis
+	facefusion.globals.ui_layouts = args.ui_layouts
+
+
+def run(program : ArgumentParser) -> None:
+	apply_args(program)
+	limit_resources()
+	if not pre_check() or not content_analyser.pre_check() or not face_analyser.pre_check():
+		return
+	for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+		if not frame_processor_module.pre_check():
+			return
+	if facefusion.globals.headless:
+		conditional_process()
+	elif facefusion.globals.api_mode:
+		import facefusion.api.core as api
+		for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+			print("开始检查",frame_processor_module)
+			if not frame_processor_module.pre_check():
+				return
+		api.launch()
+	else:
+		import facefusion.uis.core as ui
+
+		for ui_layout in ui.get_ui_layouts_modules(facefusion.globals.ui_layouts):
+			if not ui_layout.pre_check():
+				return
+		ui.launch()
+
+
+def destroy() -> None:
+	if facefusion.globals.target_path:
+		clear_temp(facefusion.globals.target_path)
+	sys.exit()
+
+
+def limit_resources() -> None:
+	if facefusion.globals.max_memory:
+		memory = facefusion.globals.max_memory * 1024 ** 3
+		if platform.system().lower() == 'darwin':
+			memory = facefusion.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(wording.get('python_not_supported').format(version = '3.9'))
+		return False
+	if not shutil.which('ffmpeg'):
+		update_status(wording.get('ffmpeg_not_installed'))
+		return False
+	return True
+
+
+def conditional_process() -> None:
+	conditional_set_face_reference()
+	for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+		if not frame_processor_module.pre_process('output'):
+			return
+	if is_image(facefusion.globals.target_path):
+		process_image()
+	if is_video(facefusion.globals.target_path):
+		process_video()
+
+
+def api_conditional_process() -> None:
+	conditional_set_face_reference()
+	for frame_processor_module in api_get_frame_processors_modules(facefusion.globals.frame_processors):
+		if not frame_processor_module.pre_process('output'):
+			return
+	if is_image(facefusion.globals.target_path):
+		api_process_image()
+	if is_video(facefusion.globals.target_path):
+		api_process_video()
+
+
+def conditional_set_face_reference() -> None:
+	if 'reference' in facefusion.globals.face_selector_mode and not get_face_reference():
+		if is_video(facefusion.globals.target_path):
+			reference_frame = get_video_frame(facefusion.globals.target_path, facefusion.globals.reference_frame_number)
+		else:
+			reference_frame = read_image(facefusion.globals.target_path)
+		reference_face = get_one_face(reference_frame, facefusion.globals.reference_face_position)
+		set_face_reference(reference_face)
+
+
+def process_image() -> None:
+	# if analyse_image(facefusion.globals.target_path):
+	# 	return
+	shutil.copy2(facefusion.globals.target_path, facefusion.globals.output_path)
+	# process frame
+	for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+		update_status(wording.get('processing'), frame_processor_module.NAME)
+		frame_processor_module.process_image(facefusion.globals.source_path, facefusion.globals.output_path, facefusion.globals.output_path)
+		frame_processor_module.post_process()
+	# compress image
+	update_status(wording.get('compressing_image'))
+	if not compress_image(facefusion.globals.output_path):
+		update_status(wording.get('compressing_image_failed'))
+	# validate image
+	if is_image(facefusion.globals.output_path):
+		update_status(wording.get('processing_image_succeed'))
+	else:
+		update_status(wording.get('processing_image_failed'))	
+
+
+def process_video() -> None:
+	# if analyse_video(facefusion.globals.target_path, facefusion.globals.trim_frame_start, facefusion.globals.trim_frame_end):
+	# 	return
+	fps = detect_fps(facefusion.globals.target_path) if facefusion.globals.keep_fps else 25.0
+	# create temp
+	update_status(wording.get('creating_temp'))
+	create_temp(facefusion.globals.target_path)
+	# extract frames
+	update_status(wording.get('extracting_frames_fps').format(fps = fps))
+	extract_frames(facefusion.globals.target_path, fps)
+	# process frame
+	temp_frame_paths = get_temp_frame_paths(facefusion.globals.target_path)
+	if temp_frame_paths:
+		for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+			update_status(wording.get('processing'), frame_processor_module.NAME)
+			frame_processor_module.process_video(facefusion.globals.source_path, temp_frame_paths)
+			frame_processor_module.post_process()
+	else:
+		update_status(wording.get('temp_frames_not_found'))
+		return
+	# merge video
+	update_status(wording.get('merging_video_fps').format(fps = fps))
+	if not merge_video(facefusion.globals.target_path, fps):
+		update_status(wording.get('merging_video_failed'))
+		return
+	# handle audio
+	if facefusion.globals.skip_audio:
+		update_status(wording.get('skipping_audio'))
+		move_temp(facefusion.globals.target_path, facefusion.globals.output_path)
+	else:
+		update_status(wording.get('restoring_audio'))
+		if not restore_audio(facefusion.globals.target_path, facefusion.globals.output_path):
+			update_status(wording.get('restoring_audio_failed'))
+			move_temp(facefusion.globals.target_path, facefusion.globals.output_path)
+	# clear temp
+	update_status(wording.get('clearing_temp'))
+	clear_temp(facefusion.globals.target_path)
+	# validate video
+	if is_video(facefusion.globals.output_path):
+		update_status(wording.get('processing_video_succeed'))
+	else:
+		update_status(wording.get('processing_video_failed'))
+
+
+def api_process_image() -> None:
+	# if analyse_image(facefusion.globals.target_path):
+	# 	return
+	shutil.copy2(facefusion.globals.target_path, facefusion.globals.output_path)
+	# process frame
+	for frame_processor_module in api_get_frame_processors_modules(facefusion.globals.frame_processors):
+		update_status(wording.get('processing'), frame_processor_module.NAME)
+		frame_processor_module.process_image(facefusion.globals.source_path, facefusion.globals.output_path, facefusion.globals.output_path)
+		frame_processor_module.post_process()
+	# compress image
+	update_status(wording.get('compressing_image'))
+	if not compress_image(facefusion.globals.output_path):
+		update_status(wording.get('compressing_image_failed'))
+	# validate image
+	if is_image(facefusion.globals.output_path):
+		update_status(wording.get('processing_image_succeed'))
+	else:
+		update_status(wording.get('processing_image_failed'))	
+
+
+def api_process_video() -> None:
+	# if analyse_video(facefusion.globals.target_path, facefusion.globals.trim_frame_start, facefusion.globals.trim_frame_end):
+	# 	return
+	fps = detect_fps(facefusion.globals.target_path) if facefusion.globals.keep_fps else 25.0
+	# create temp
+	update_status(wording.get('creating_temp'))
+	create_temp(facefusion.globals.target_path)
+	# extract frames
+	update_status(wording.get('extracting_frames_fps').format(fps = fps))
+	extract_frames(facefusion.globals.target_path, fps)
+	# process frame
+	temp_frame_paths = get_temp_frame_paths(facefusion.globals.target_path)
+	if temp_frame_paths:
+		for frame_processor_module in api_get_frame_processors_modules(facefusion.globals.frame_processors):
+			update_status(wording.get('processing'), frame_processor_module.NAME)
+			frame_processor_module.process_video(facefusion.globals.source_path, temp_frame_paths)
+			frame_processor_module.post_process()
+	else:
+		update_status(wording.get('temp_frames_not_found'))
+		return
+	# merge video
+	update_status(wording.get('merging_video_fps').format(fps = fps))
+	if not merge_video(facefusion.globals.target_path, fps):
+		update_status(wording.get('merging_video_failed'))
+		return
+	# handle audio
+	if facefusion.globals.skip_audio:
+		update_status(wording.get('skipping_audio'))
+		move_temp(facefusion.globals.target_path, facefusion.globals.output_path)
+	else:
+		update_status(wording.get('restoring_audio'))
+		if not restore_audio(facefusion.globals.target_path, facefusion.globals.output_path):
+			update_status(wording.get('restoring_audio_failed'))
+			move_temp(facefusion.globals.target_path, facefusion.globals.output_path)
+	# clear temp
+	update_status(wording.get('clearing_temp'))
+	clear_temp(facefusion.globals.target_path)
+	# validate video
+	if is_video(facefusion.globals.output_path):
+		update_status(wording.get('processing_video_succeed'))
+	else:
+		update_status(wording.get('processing_video_failed'))

facefusion/face_analyser.py

@@ -0,0 +1,309 @@
+from typing import Any, Optional, List, Dict, Tuple
+import threading
+import cv2
+import numpy
+import onnxruntime
+
+import facefusion.globals
+from facefusion.face_cache import get_faces_cache, set_faces_cache
+from facefusion.face_helper import warp_face, create_static_anchors, distance_to_kps, distance_to_bbox, apply_nms
+from facefusion.typing import Frame, Face, FaceAnalyserOrder, FaceAnalyserAge, FaceAnalyserGender, ModelValue, Bbox, Kps, Score, Embedding
+from facefusion.utilities import resolve_relative_path, conditional_download
+from facefusion.vision import resize_frame_dimension
+
+FACE_ANALYSER = None
+THREAD_SEMAPHORE : threading.Semaphore = threading.Semaphore()
+THREAD_LOCK : threading.Lock = threading.Lock()
+MODELS : Dict[str, ModelValue] =\
+{
+	'face_detector_retinaface':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/retinaface_10g.onnx',
+		'path': resolve_relative_path('../.assets/models/retinaface_10g.onnx')
+	},
+	'face_detector_yunet':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/yunet_2023mar.onnx',
+		'path': resolve_relative_path('../.assets/models/yunet_2023mar.onnx')
+	},
+	'face_recognizer_arcface_blendface':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_w600k_r50.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.onnx')
+	},
+	'face_recognizer_arcface_inswapper':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_w600k_r50.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.onnx')
+	},
+	'face_recognizer_arcface_simswap':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_simswap.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_simswap.onnx')
+	},
+	'gender_age':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gender_age.onnx',
+		'path': resolve_relative_path('../.assets/models/gender_age.onnx')
+	}
+}
+
+
+def get_face_analyser() -> Any:
+	global FACE_ANALYSER
+
+	with THREAD_LOCK:
+		if FACE_ANALYSER is None:
+			if facefusion.globals.face_detector_model == 'retinaface':
+				face_detector = onnxruntime.InferenceSession(MODELS.get('face_detector_retinaface').get('path'), providers = facefusion.globals.execution_providers)
+			if facefusion.globals.face_detector_model == 'yunet':
+				face_detector = cv2.FaceDetectorYN.create(MODELS.get('face_detector_yunet').get('path'), '', (0, 0))
+			if facefusion.globals.face_recognizer_model == 'arcface_blendface':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_blendface').get('path'), providers = facefusion.globals.execution_providers)
+			if facefusion.globals.face_recognizer_model == 'arcface_inswapper':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_inswapper').get('path'), providers = facefusion.globals.execution_providers)
+			if facefusion.globals.face_recognizer_model == 'arcface_simswap':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_simswap').get('path'), providers = facefusion.globals.execution_providers)
+			gender_age = onnxruntime.InferenceSession(MODELS.get('gender_age').get('path'), providers = facefusion.globals.execution_providers)
+			FACE_ANALYSER =\
+			{
+				'face_detector': face_detector,
+				'face_recognizer': face_recognizer,
+				'gender_age': gender_age
+			}
+	return FACE_ANALYSER
+
+
+def clear_face_analyser() -> Any:
+	global FACE_ANALYSER
+
+	FACE_ANALYSER = None
+
+
+def pre_check() -> bool:
+	if not facefusion.globals.skip_download:
+		download_directory_path = resolve_relative_path('../.assets/models')
+		model_urls =\
+		[
+			MODELS.get('face_detector_retinaface').get('url'),
+			MODELS.get('face_detector_yunet').get('url'),
+			MODELS.get('face_recognizer_arcface_inswapper').get('url'),
+			MODELS.get('face_recognizer_arcface_simswap').get('url'),
+			MODELS.get('gender_age').get('url')
+		]
+		conditional_download(download_directory_path, model_urls)
+	return True
+
+
+def extract_faces(frame: Frame) -> List[Face]:
+	face_detector_width, face_detector_height = map(int, facefusion.globals.face_detector_size.split('x'))
+	frame_height, frame_width, _ = frame.shape
+	temp_frame = resize_frame_dimension(frame, face_detector_width, face_detector_height)
+	temp_frame_height, temp_frame_width, _ = temp_frame.shape
+	ratio_height = frame_height / temp_frame_height
+	ratio_width = frame_width / temp_frame_width
+	if facefusion.globals.face_detector_model == 'retinaface':
+		bbox_list, kps_list, score_list = detect_with_retinaface(temp_frame, temp_frame_height, temp_frame_width, face_detector_height, face_detector_width, ratio_height, ratio_width)
+		return create_faces(frame, bbox_list, kps_list, score_list)
+	elif facefusion.globals.face_detector_model == 'yunet':
+		bbox_list, kps_list, score_list = detect_with_yunet(temp_frame, temp_frame_height, temp_frame_width, ratio_height, ratio_width)
+		return create_faces(frame, bbox_list, kps_list, score_list)
+	return []
+
+
+def detect_with_retinaface(temp_frame : Frame, temp_frame_height : int, temp_frame_width : int, face_detector_height : int, face_detector_width : int, ratio_height : float, ratio_width : float) -> Tuple[List[Bbox], List[Kps], List[Score]]:
+	face_detector = get_face_analyser().get('face_detector')
+	bbox_list = []
+	kps_list = []
+	score_list = []
+	feature_strides = [ 8, 16, 32 ]
+	feature_map_channel = 3
+	anchor_total = 2
+	prepare_frame = numpy.zeros((face_detector_height, face_detector_width, 3))
+	prepare_frame[:temp_frame_height, :temp_frame_width, :] = temp_frame
+	temp_frame = (prepare_frame - 127.5) / 128.0
+	temp_frame = numpy.expand_dims(temp_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	with THREAD_SEMAPHORE:
+		detections = face_detector.run(None,
+		{
+			face_detector.get_inputs()[0].name: temp_frame
+		})
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detections[index] >= facefusion.globals.face_detector_score)[0]
+		if keep_indices.any():
+			stride_height = face_detector_height // feature_stride
+			stride_width = face_detector_width // feature_stride
+			anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
+			bbox_raw = (detections[index + feature_map_channel] * feature_stride)
+			kps_raw = detections[index + feature_map_channel * 2] * feature_stride
+			for bbox in distance_to_bbox(anchors, bbox_raw)[keep_indices]:
+				bbox_list.append(numpy.array(
+				[
+					bbox[0] * ratio_width,
+					bbox[1] * ratio_height,
+					bbox[2] * ratio_width,
+					bbox[3] * ratio_height
+				]))
+			for kps in distance_to_kps(anchors, kps_raw)[keep_indices]:
+				kps_list.append(kps * [ ratio_width, ratio_height ])
+			for score in detections[index][keep_indices]:
+				score_list.append(score[0])
+	return bbox_list, kps_list, score_list
+
+
+def detect_with_yunet(temp_frame : Frame, temp_frame_height : int, temp_frame_width : int, ratio_height : float, ratio_width : float) -> Tuple[List[Bbox], List[Kps], List[Score]]:
+	face_detector = get_face_analyser().get('face_detector')
+	face_detector.setInputSize((temp_frame_width, temp_frame_height))
+	face_detector.setScoreThreshold(facefusion.globals.face_detector_score)
+	bbox_list = []
+	kps_list = []
+	score_list = []
+	with THREAD_SEMAPHORE:
+		_, detections = face_detector.detect(temp_frame)
+	if detections.any():
+		for detection in detections:
+			bbox_list.append(numpy.array(
+			[
+				detection[0] * ratio_width,
+				detection[1] * ratio_height,
+				(detection[0] + detection[2]) * ratio_width,
+				(detection[1] + detection[3]) * ratio_height
+			]))
+			kps_list.append(detection[4:14].reshape((5, 2)) * [ ratio_width, ratio_height])
+			score_list.append(detection[14])
+	return bbox_list, kps_list, score_list
+
+
+def create_faces(frame : Frame, bbox_list : List[Bbox], kps_list : List[Kps], score_list : List[Score]) -> List[Face] :
+	faces : List[Face] = []
+	if facefusion.globals.face_detector_score > 0:
+		keep_indices = apply_nms(bbox_list, 0.4)
+		for index in keep_indices:
+			bbox = bbox_list[index]
+			kps = kps_list[index]
+			score = score_list[index]
+			embedding, normed_embedding = calc_embedding(frame, kps)
+			gender, age = detect_gender_age(frame, kps)
+			faces.append(Face(
+				bbox = bbox,
+				kps = kps,
+				score = score,
+				embedding = embedding,
+				normed_embedding = normed_embedding,
+				gender = gender,
+				age = age
+			))
+	return faces
+
+
+def calc_embedding(temp_frame : Frame, kps : Kps) -> Tuple[Embedding, Embedding]:
+	face_recognizer = get_face_analyser().get('face_recognizer')
+	crop_frame, matrix = warp_face(temp_frame, kps, 'arcface_v2', (112, 112))
+	crop_frame = crop_frame.astype(numpy.float32) / 127.5 - 1
+	crop_frame = crop_frame[:, :, ::-1].transpose(2, 0, 1)
+	crop_frame = numpy.expand_dims(crop_frame, axis = 0)
+	embedding = face_recognizer.run(None,
+	{
+		face_recognizer.get_inputs()[0].name: crop_frame
+	})[0]
+	embedding = embedding.ravel()
+	normed_embedding = embedding / numpy.linalg.norm(embedding)
+	return embedding, normed_embedding
+
+
+def detect_gender_age(frame : Frame, kps : Kps) -> Tuple[int, int]:
+	gender_age = get_face_analyser().get('gender_age')
+	crop_frame, affine_matrix = warp_face(frame, kps, 'arcface_v2', (96, 96))
+	crop_frame = numpy.expand_dims(crop_frame, axis = 0).transpose(0, 3, 1, 2).astype(numpy.float32)
+	prediction = gender_age.run(None,
+	{
+		gender_age.get_inputs()[0].name: crop_frame
+	})[0][0]
+	gender = int(numpy.argmax(prediction[:2]))
+	age = int(numpy.round(prediction[2] * 100))
+	return gender, age
+
+
+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) -> List[Face]:
+	try:
+		faces_cache = get_faces_cache(frame)
+		if faces_cache:
+			faces = faces_cache
+		else:
+			faces = extract_faces(frame)
+			set_faces_cache(frame, faces)
+		if facefusion.globals.face_analyser_order:
+			faces = sort_by_order(faces, facefusion.globals.face_analyser_order)
+		if facefusion.globals.face_analyser_age:
+			faces = filter_by_age(faces, facefusion.globals.face_analyser_age)
+		if facefusion.globals.face_analyser_gender:
+			faces = filter_by_gender(faces, facefusion.globals.face_analyser_gender)
+		return faces
+	except (AttributeError, ValueError):
+		return []
+
+
+def find_similar_faces(frame : Frame, reference_face : Face, face_distance : float) -> List[Face]:
+	many_faces = get_many_faces(frame)
+	similar_faces = []
+	if many_faces:
+		for face in many_faces:
+			if hasattr(face, 'normed_embedding') and hasattr(reference_face, 'normed_embedding'):
+				current_face_distance = 1 - numpy.dot(face.normed_embedding, reference_face.normed_embedding)
+				if current_face_distance < face_distance:
+					similar_faces.append(face)
+	return similar_faces
+
+
+def sort_by_order(faces : List[Face], order : FaceAnalyserOrder) -> List[Face]:
+	if order == 'left-right':
+		return sorted(faces, key = lambda face: face.bbox[0])
+	if order == 'right-left':
+		return sorted(faces, key = lambda face: face.bbox[0], reverse = True)
+	if order == 'top-bottom':
+		return sorted(faces, key = lambda face: face.bbox[1])
+	if order == 'bottom-top':
+		return sorted(faces, key = lambda face: face.bbox[1], reverse = True)
+	if order == 'small-large':
+		return sorted(faces, key = lambda face: (face.bbox[2] - face.bbox[0]) * (face.bbox[3] - face.bbox[1]))
+	if order == 'large-small':
+		return sorted(faces, key = lambda face: (face.bbox[2] - face.bbox[0]) * (face.bbox[3] - face.bbox[1]), reverse = True)
+	if order == 'best-worst':
+		return sorted(faces, key = lambda face: face.score, reverse = True)
+	if order == 'worst-best':
+		return sorted(faces, key = lambda face: face.score)
+	return faces
+
+
+def filter_by_age(faces : List[Face], age : FaceAnalyserAge) -> List[Face]:
+	filter_faces = []
+	for face in faces:
+		if face.age < 13 and age == 'child':
+			filter_faces.append(face)
+		elif face.age < 19 and age == 'teen':
+			filter_faces.append(face)
+		elif face.age < 60 and age == 'adult':
+			filter_faces.append(face)
+		elif face.age > 59 and age == 'senior':
+			filter_faces.append(face)
+	return filter_faces
+
+
+def filter_by_gender(faces : List[Face], gender : FaceAnalyserGender) -> List[Face]:
+	filter_faces = []
+	for face in faces:
+		if face.gender == 0 and gender == 'female':
+			filter_faces.append(face)
+		if face.gender == 1 and gender == 'male':
+			filter_faces.append(face)
+	return filter_faces

facefusion/face_cache.py

@@ -0,0 +1,29 @@
+from typing import Optional, List, Dict
+import hashlib
+
+from facefusion.typing import Frame, Face
+
+FACES_CACHE : Dict[str, List[Face]] = {}
+
+
+def get_faces_cache(frame : Frame) -> Optional[List[Face]]:
+	frame_hash = create_frame_hash(frame)
+	if frame_hash in FACES_CACHE:
+		return FACES_CACHE[frame_hash]
+	return None
+
+
+def set_faces_cache(frame : Frame, faces : List[Face]) -> None:
+	frame_hash = create_frame_hash(frame)
+	if frame_hash:
+		FACES_CACHE[frame_hash] = faces
+
+
+def clear_faces_cache() -> None:
+	global FACES_CACHE
+
+	FACES_CACHE = {}
+
+
+def create_frame_hash(frame : Frame) -> Optional[str]:
+	return hashlib.sha1(frame.tobytes()).hexdigest() if frame.any() else None

facefusion/face_helper.py

@@ -0,0 +1,149 @@
+from typing import Any, Dict, Tuple, List
+from functools import lru_cache
+from cv2.typing import Size
+import cv2
+import numpy
+
+from facefusion.typing import Bbox, Kps, Frame, Matrix, Template, Padding
+
+TEMPLATES : Dict[Template, numpy.ndarray[Any, Any]] =\
+{
+	'arcface_v1': numpy.array(
+	[
+		[ 39.7300, 51.1380 ],
+		[ 72.2700, 51.1380 ],
+		[ 56.0000, 68.4930 ],
+		[ 42.4630, 87.0100 ],
+		[ 69.5370, 87.0100 ]
+	]),
+	'arcface_v2': numpy.array(
+	[
+		[ 38.2946, 51.6963 ],
+		[ 73.5318, 51.5014 ],
+		[ 56.0252, 71.7366 ],
+		[ 41.5493, 92.3655 ],
+		[ 70.7299, 92.2041 ]
+	]),
+	'ffhq': numpy.array(
+	[
+		[ 192.98138, 239.94708 ],
+		[ 318.90277, 240.1936 ],
+		[ 256.63416, 314.01935 ],
+		[ 201.26117, 371.41043 ],
+		[ 313.08905, 371.15118 ]
+	])
+}
+
+
+def warp_face(temp_frame : Frame, kps : Kps, template : Template, size : Size) -> Tuple[Frame, Matrix]:
+	normed_template = TEMPLATES.get(template) * size[1] / size[0]
+	affine_matrix = cv2.estimateAffinePartial2D(kps, normed_template, method = cv2.LMEDS)[0]
+	crop_frame = cv2.warpAffine(temp_frame, affine_matrix, (size[1], size[1]), borderMode = cv2.BORDER_REPLICATE)
+	return crop_frame, affine_matrix
+
+
+def paste_back(temp_frame : Frame, crop_frame: Frame, affine_matrix : Matrix, face_mask_blur : float, face_mask_padding : Padding) -> Frame:
+	inverse_matrix = cv2.invertAffineTransform(affine_matrix)
+	temp_frame_size = temp_frame.shape[:2][::-1]
+	mask_size = tuple(crop_frame.shape[:2])
+	mask_frame = create_static_mask_frame(mask_size, face_mask_blur, face_mask_padding)
+	inverse_mask_frame = cv2.warpAffine(mask_frame, inverse_matrix, temp_frame_size).clip(0, 1)
+	inverse_crop_frame = cv2.warpAffine(crop_frame, inverse_matrix, temp_frame_size, borderMode = cv2.BORDER_REPLICATE)
+	paste_frame = temp_frame.copy()
+	paste_frame[:, :, 0] = inverse_mask_frame * inverse_crop_frame[:, :, 0] + (1 - inverse_mask_frame) * temp_frame[:, :, 0]
+	paste_frame[:, :, 1] = inverse_mask_frame * inverse_crop_frame[:, :, 1] + (1 - inverse_mask_frame) * temp_frame[:, :, 1]
+	paste_frame[:, :, 2] = inverse_mask_frame * inverse_crop_frame[:, :, 2] + (1 - inverse_mask_frame) * temp_frame[:, :, 2]
+	return paste_frame
+
+
+def paste_back_ellipse(temp_frame : Frame, crop_frame: Frame, affine_matrix : Matrix, face_mask_blur : float, face_mask_padding : Padding) -> Frame:
+	inverse_matrix = cv2.invertAffineTransform(affine_matrix)
+	temp_frame_size = temp_frame.shape[:2][::-1]
+	mask_size = tuple(crop_frame.shape[:2])
+	mask_frame = create_ellipse_mask_frame(mask_size, face_mask_blur, face_mask_padding)
+	inverse_mask_frame = cv2.warpAffine(mask_frame, inverse_matrix, temp_frame_size).clip(0, 1)
+	inverse_crop_frame = cv2.warpAffine(crop_frame, inverse_matrix, temp_frame_size, borderMode = cv2.BORDER_REPLICATE)
+	paste_frame = temp_frame.copy()
+	paste_frame[:, :, 0] = inverse_mask_frame * inverse_crop_frame[:, :, 0] + (1 - inverse_mask_frame) * temp_frame[:, :, 0]
+	paste_frame[:, :, 1] = inverse_mask_frame * inverse_crop_frame[:, :, 1] + (1 - inverse_mask_frame) * temp_frame[:, :, 1]
+	paste_frame[:, :, 2] = inverse_mask_frame * inverse_crop_frame[:, :, 2] + (1 - inverse_mask_frame) * temp_frame[:, :, 2]
+	return paste_frame
+
+
+@lru_cache(maxsize = None)
+def create_static_mask_frame(mask_size : Size, face_mask_blur : float, face_mask_padding : Padding) -> Frame:
+	mask_frame = numpy.ones(mask_size, numpy.float32)
+	blur_amount = int(mask_size[0] * 0.5 * face_mask_blur)
+	blur_area = max(blur_amount // 2, 1)
+	mask_frame[:max(blur_area, int(mask_size[1] * face_mask_padding[0] / 100)), :] = 0
+	mask_frame[-max(blur_area, int(mask_size[1] * face_mask_padding[2] / 100)):, :] = 0
+	mask_frame[:, :max(blur_area, int(mask_size[0] * face_mask_padding[3] / 100))] = 0
+	mask_frame[:, -max(blur_area, int(mask_size[0] * face_mask_padding[1] / 100)):] = 0
+	if blur_amount > 0:
+		mask_frame = cv2.GaussianBlur(mask_frame, (0, 0), blur_amount * 0.25)
+	return mask_frame
+
+
+@lru_cache(maxsize=None)
+def create_ellipse_mask_frame(mask_size: Size, face_mask_blur: float, face_mask_padding: Padding) -> Frame:
+    mask_frame = numpy.zeros(mask_size, numpy.float32)
+    center = (mask_size[1] // 2, mask_size[0] // 2)
+    axes = (max(1, mask_size[1] // 2 - int(mask_size[1] * face_mask_padding[1] / 100)),
+            max(1, mask_size[0] // 2 - int(mask_size[0] * face_mask_padding[0] / 100)))
+    cv2.ellipse(mask_frame, center, axes, 0, 0, 360, 1, -1)
+
+    if face_mask_blur > 0:
+        blur_amount = int(mask_size[0] * 0.5 * face_mask_blur)
+        mask_frame = cv2.GaussianBlur(mask_frame, (0, 0), blur_amount * 0.25)
+
+    return mask_frame
+
+
+
+@lru_cache(maxsize = None)
+def create_static_anchors(feature_stride : int, anchor_total : int, stride_height : int, stride_width : int) -> numpy.ndarray[Any, Any]:
+	y, x = numpy.mgrid[:stride_height, :stride_width][::-1]
+	anchors = numpy.stack((y, x), axis = -1)
+	anchors = (anchors * feature_stride).reshape((-1, 2))
+	anchors = numpy.stack([ anchors ] * anchor_total, axis = 1).reshape((-1, 2))
+	return anchors
+
+
+def distance_to_bbox(points : numpy.ndarray[Any, Any], distance : numpy.ndarray[Any, Any]) -> Bbox:
+	x1 = points[:, 0] - distance[:, 0]
+	y1 = points[:, 1] - distance[:, 1]
+	x2 = points[:, 0] + distance[:, 2]
+	y2 = points[:, 1] + distance[:, 3]
+	bbox = numpy.column_stack([ x1, y1, x2, y2 ])
+	return bbox
+
+
+def distance_to_kps(points : numpy.ndarray[Any, Any], distance : numpy.ndarray[Any, Any]) -> Kps:
+	x = points[:, 0::2] + distance[:, 0::2]
+	y = points[:, 1::2] + distance[:, 1::2]
+	kps = numpy.stack((x, y), axis = -1)
+	return kps
+
+
+def apply_nms(bbox_list : List[Bbox], iou_threshold : float) -> List[int]:
+	keep_indices = []
+	dimension_list = numpy.reshape(bbox_list, (-1, 4))
+	x1 = dimension_list[:, 0]
+	y1 = dimension_list[:, 1]
+	x2 = dimension_list[:, 2]
+	y2 = dimension_list[:, 3]
+	areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+	indices = numpy.arange(len(bbox_list))
+	while indices.size > 0:
+		index = indices[0]
+		remain_indices = indices[1:]
+		keep_indices.append(index)
+		xx1 = numpy.maximum(x1[index], x1[remain_indices])
+		yy1 = numpy.maximum(y1[index], y1[remain_indices])
+		xx2 = numpy.minimum(x2[index], x2[remain_indices])
+		yy2 = numpy.minimum(y2[index], y2[remain_indices])
+		width = numpy.maximum(0, xx2 - xx1 + 1)
+		height = numpy.maximum(0, yy2 - yy1 + 1)
+		iou = width * height / (areas[index] + areas[remain_indices] - width * height)
+		indices = indices[numpy.where(iou <= iou_threshold)[0] + 1]
+	return keep_indices

facefusion/face_reference.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from facefusion.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

facefusion/globals.py

@@ -0,0 +1,50 @@
+from typing import List, Optional
+
+from facefusion.typing import FaceSelectorMode, FaceAnalyserOrder, FaceAnalyserAge, FaceAnalyserGender, OutputVideoEncoder, FaceDetectorModel, FaceRecognizerModel, TempFrameFormat, Padding
+
+# api
+api_mode : Optional[bool] = None
+# general
+source_path : Optional[str] = None
+target_path : Optional[str] = None
+output_path : Optional[str] = None
+# misc
+skip_download : Optional[bool] = None
+headless : Optional[bool] = None
+# execution
+execution_providers : List[str] = []
+execution_thread_count : Optional[int] = None
+execution_queue_count : Optional[int] = None
+max_memory : Optional[int] = None
+# face analyser
+face_analyser_order : Optional[FaceAnalyserOrder] = None
+face_analyser_age : Optional[FaceAnalyserAge] = None
+face_analyser_gender : Optional[FaceAnalyserGender] = None
+face_detector_model : Optional[FaceDetectorModel] = None
+face_detector_size : Optional[str] = None
+face_detector_score : Optional[float] = None
+face_recognizer_model : Optional[FaceRecognizerModel] = None
+# face selector
+face_selector_mode : Optional[FaceSelectorMode] = None
+reference_face_position : Optional[int] = None
+reference_face_distance : Optional[float] = None
+reference_frame_number : Optional[int] = None
+# face mask
+face_mask_blur : Optional[float] = None
+face_mask_padding : Optional[Padding] = None
+# frame extraction
+trim_frame_start : Optional[int] = None
+trim_frame_end : Optional[int] = None
+temp_frame_format : Optional[TempFrameFormat] = None
+temp_frame_quality : Optional[int] = None
+keep_temp : Optional[bool] = None
+# output creation
+output_image_quality : Optional[int] = None
+output_video_encoder : Optional[OutputVideoEncoder] = None
+output_video_quality : Optional[int] = None
+keep_fps : Optional[bool] = None
+skip_audio : Optional[bool] = None
+# frame processors
+frame_processors : List[str] = []
+# uis
+ui_layouts : List[str] = []

facefusion/installer.py

@@ -0,0 +1,63 @@
+from typing import Dict, Tuple
+import subprocess
+from argparse import ArgumentParser, HelpFormatter
+
+subprocess.call([ 'pip', 'install' , 'inquirer', '-q' ])
+
+import inquirer
+
+from facefusion import metadata, wording
+
+TORCH : Dict[str, str] =\
+{
+	'default': 'default',
+	'cpu': 'cpu',
+	'cuda': 'cu118',
+	'rocm': 'rocm5.6'
+}
+ONNXRUNTIMES : Dict[str, Tuple[str, str]] =\
+{
+	'default': ('onnxruntime', '1.16.3'),
+	'cuda': ('onnxruntime-gpu', '1.16.3'),
+	'coreml-legacy': ('onnxruntime-coreml', '1.13.1'),
+	'coreml-silicon': ('onnxruntime-silicon', '1.16.0'),
+	'directml': ('onnxruntime-directml', '1.16.3'),
+	'openvino': ('onnxruntime-openvino', '1.16.0')
+}
+
+
+def cli() -> None:
+	program = ArgumentParser(formatter_class = lambda prog: HelpFormatter(prog, max_help_position = 120))
+	program.add_argument('--torch', help = wording.get('install_dependency_help').format(dependency = 'torch'), dest = 'torch', choices = TORCH.keys())
+	program.add_argument('--onnxruntime', help = wording.get('install_dependency_help').format(dependency = 'onnxruntime'), dest = 'onnxruntime', choices = ONNXRUNTIMES.keys())
+	program.add_argument('-v', '--version', version = metadata.get('name') + ' ' + metadata.get('version'), action = 'version')
+	run(program)
+
+
+def run(program : ArgumentParser) -> None:
+	args = program.parse_args()
+
+	if args.torch and args.onnxruntime:
+		answers =\
+		{
+			'torch': args.torch,
+			'onnxruntime': args.onnxruntime
+		}
+	else:
+		answers = inquirer.prompt(
+		[
+			inquirer.List('torch', message = wording.get('install_dependency_help').format(dependency = 'torch'), choices = list(TORCH.keys())),
+			inquirer.List('onnxruntime', message = wording.get('install_dependency_help').format(dependency = 'onnxruntime'), choices = list(ONNXRUNTIMES.keys()))
+		])
+	if answers:
+		torch = answers['torch']
+		torch_wheel = TORCH[torch]
+		onnxruntime = answers['onnxruntime']
+		onnxruntime_name, onnxruntime_version = ONNXRUNTIMES[onnxruntime]
+		subprocess.call([ 'pip', 'uninstall', 'torch', '-y' ])
+		if torch_wheel == 'default':
+			subprocess.call([ 'pip', 'install', '-r', 'requirements.txt' ])
+		else:
+			subprocess.call([ 'pip', 'install', '-r', 'requirements.txt', '--extra-index-url', 'https://download.pytorch.org/whl/' + torch_wheel ])
+		subprocess.call([ 'pip', 'uninstall', 'onnxruntime', onnxruntime_name, '-y' ])
+		subprocess.call([ 'pip', 'install', onnxruntime_name + '==' + onnxruntime_version ])

facefusion/metadata.py

@@ -0,0 +1,13 @@
+METADATA =\
+{
+	'name': 'FaceFusion',
+	'description': 'Next generation face swapper and enhancer',
+	'version': '2.0.0',
+	'license': 'MIT',
+	'author': 'Henry Ruhs',
+	'url': 'https://facefusion.io'
+}
+
+
+def get(key : str) -> str:
+	return METADATA[key]

facefusion/processors/frame/choices.py

@@ -0,0 +1,13 @@
+from typing import List
+import numpy
+
+from facefusion.processors.frame.typings import FaceSwapperModel, FaceEnhancerModel, FrameEnhancerModel, FaceDebuggerItem
+
+face_swapper_models : List[FaceSwapperModel] = [ 'blendface_256', 'inswapper_128', 'inswapper_128_fp16', 'simswap_256', 'simswap_512_unofficial' ]
+face_enhancer_models : List[FaceEnhancerModel] = [ 'codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'restoreformer' ]
+frame_enhancer_models : List[FrameEnhancerModel] = [ 'real_esrgan_x2plus', 'real_esrgan_x4plus', 'real_esrnet_x4plus' ]
+
+face_enhancer_blend_range : List[int] = numpy.arange(0, 101, 1).tolist()
+frame_enhancer_blend_range : List[int] = numpy.arange(0, 101, 1).tolist()
+
+face_debugger_items : List[FaceDebuggerItem] = [ 'bbox', 'kps', 'face-mask', 'score' ]

facefusion/processors/frame/core.py

@@ -0,0 +1,105 @@
+import sys
+import importlib
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from queue import Queue
+from types import ModuleType
+from typing import Any, List
+from tqdm import tqdm
+
+import facefusion.globals
+from facefusion.typing import Process_Frames
+from facefusion import wording
+from facefusion.utilities import encode_execution_providers
+
+FRAME_PROCESSORS_MODULES : List[ModuleType] = []
+FRAME_PROCESSORS_METHODS =\
+[
+	'get_frame_processor',
+	'clear_frame_processor',
+	'get_options',
+	'set_options',
+	'register_args',
+	'apply_args',
+	'pre_check',
+	'pre_process',
+	'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('facefusion.processors.frame.modules.' + frame_processor)
+		for method_name in FRAME_PROCESSORS_METHODS:
+			if not hasattr(frame_processor_module, method_name):
+				raise NotImplementedError
+	except ModuleNotFoundError:
+		sys.exit(wording.get('frame_processor_not_loaded').format(frame_processor = frame_processor))
+	except NotImplementedError:
+		sys.exit(wording.get('frame_processor_not_implemented').format(frame_processor = frame_processor))
+	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 api_get_frame_processors_modules(frame_processors: List[str]) -> List[ModuleType]:
+    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 clear_frame_processors_modules() -> None:
+	global FRAME_PROCESSORS_MODULES
+
+	for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+		frame_processor_module.clear_frame_processor()
+	FRAME_PROCESSORS_MODULES = []
+
+
+def multi_process_frames(source_path : str, temp_frame_paths : List[str], process_frames : Process_Frames) -> None:
+	with tqdm(total = len(temp_frame_paths), desc = wording.get('processing'), unit = 'frame', ascii = ' =') as progress:
+		progress.set_postfix(
+		{
+			'execution_providers': encode_execution_providers(facefusion.globals.execution_providers),
+			'execution_thread_count': facefusion.globals.execution_thread_count,
+			'execution_queue_count': facefusion.globals.execution_queue_count
+		})
+		with ThreadPoolExecutor(max_workers = facefusion.globals.execution_thread_count) as executor:
+			futures = []
+			queue_temp_frame_paths : Queue[str] = create_queue(temp_frame_paths)
+			queue_per_future = max(len(temp_frame_paths) // facefusion.globals.execution_thread_count * facefusion.globals.execution_queue_count, 1)
+			while not queue_temp_frame_paths.empty():
+				payload_temp_frame_paths = pick_queue(queue_temp_frame_paths, queue_per_future)
+				future = executor.submit(process_frames, source_path, payload_temp_frame_paths, progress.update)
+				futures.append(future)
+			for future_done in as_completed(futures):
+				future_done.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

facefusion/processors/frame/globals.py

@@ -0,0 +1,10 @@
+from typing import List, Optional
+
+from facefusion.processors.frame.typings import FaceSwapperModel, FaceEnhancerModel, FrameEnhancerModel, FaceDebuggerItem
+
+face_swapper_model : Optional[FaceSwapperModel] = None
+face_enhancer_model : Optional[FaceEnhancerModel] = None
+face_enhancer_blend : Optional[int] = None
+frame_enhancer_model : Optional[FrameEnhancerModel] = None
+frame_enhancer_blend : Optional[int] = None
+face_debugger_items : Optional[List[FaceDebuggerItem]] = None

facefusion/processors/frame/modules/face_blur.py

@@ -0,0 +1,277 @@
+from typing import Any, List, Dict, Literal, Optional
+from argparse import ArgumentParser
+import threading
+import numpy
+import onnx
+import onnxruntime
+from onnx import numpy_helper
+import cv2
+
+import facefusion.globals
+import facefusion.processors.frame.core as frame_processors
+from facefusion import wording
+from facefusion.face_analyser import get_one_face, get_many_faces, find_similar_faces, clear_face_analyser
+from facefusion.face_helper import warp_face, paste_back_ellipse
+from facefusion.face_reference import get_face_reference
+from facefusion.content_analyser import clear_content_analyser
+from facefusion.typing import Face, Frame, Update_Process, ProcessMode, ModelValue, OptionsWithModel, Embedding
+from facefusion.utilities import conditional_download, resolve_relative_path, is_image, is_video, is_file, is_download_done, update_status
+from facefusion.vision import read_image, read_static_image, write_image
+from facefusion.processors.frame import globals as frame_processors_globals
+from facefusion.processors.frame import choices as frame_processors_choices
+
+FRAME_PROCESSOR = None
+MODEL_MATRIX = None
+THREAD_LOCK : threading.Lock = threading.Lock()
+NAME = 'FACEFUSION.FRAME_PROCESSOR.FACE_BLUR'
+MODELS : Dict[str, ModelValue] =\
+{
+	'blendface_256':
+	{
+		'type': 'blendface',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/blendface_256.onnx',
+		'path': resolve_relative_path('../.assets/models/blendface_256.onnx'),
+		'template': 'ffhq',
+		'size': (512, 256),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	},
+	'inswapper_128':
+	{
+		'type': 'inswapper',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/inswapper_128.onnx',
+		'path': resolve_relative_path('../.assets/models/inswapper_128.onnx'),
+		'template': 'arcface_v2',
+		'size': (128, 128),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	},
+	'inswapper_128_fp16':
+	{
+		'type': 'inswapper',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/inswapper_128_fp16.onnx',
+		'path': resolve_relative_path('../.assets/models/inswapper_128_fp16.onnx'),
+		'template': 'arcface_v2',
+		'size': (128, 128),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	},
+	'simswap_256':
+	{
+		'type': 'simswap',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/simswap_256.onnx',
+		'path': resolve_relative_path('../.assets/models/simswap_256.onnx'),
+		'template': 'arcface_v1',
+		'size': (112, 256),
+		'mean': [ 0.485, 0.456, 0.406 ],
+		'standard_deviation': [ 0.229, 0.224, 0.225 ]
+	},
+	'simswap_512_unofficial':
+	{
+		'type': 'simswap',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/simswap_512_unofficial.onnx',
+		'path': resolve_relative_path('../.assets/models/simswap_512_unofficial.onnx'),
+		'template': 'arcface_v1',
+		'size': (112, 512),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	}
+}
+OPTIONS : Optional[OptionsWithModel] = None
+
+
+def get_frame_processor() -> Any:
+	global FRAME_PROCESSOR
+
+	with THREAD_LOCK:
+		if FRAME_PROCESSOR is None:
+			model_path = get_options('model').get('path')
+			FRAME_PROCESSOR = onnxruntime.InferenceSession(model_path, providers = facefusion.globals.execution_providers)
+	return FRAME_PROCESSOR
+
+
+def clear_frame_processor() -> None:
+	global FRAME_PROCESSOR
+
+	FRAME_PROCESSOR = None
+
+
+def get_model_matrix() -> Any:
+	global MODEL_MATRIX
+
+	with THREAD_LOCK:
+		if MODEL_MATRIX is None:
+			model_path = get_options('model').get('path')
+			model = onnx.load(model_path)
+			MODEL_MATRIX = numpy_helper.to_array(model.graph.initializer[-1])
+	return MODEL_MATRIX
+
+
+def clear_model_matrix() -> None:
+	global MODEL_MATRIX
+
+	MODEL_MATRIX = None
+
+
+def get_options(key : Literal['model']) -> Any:
+	global OPTIONS
+
+	if OPTIONS is None:
+		OPTIONS =\
+		{
+			'model': MODELS[frame_processors_globals.face_swapper_model]
+		}
+	return OPTIONS.get(key)
+
+
+def set_options(key : Literal['model'], value : Any) -> None:
+	global OPTIONS
+
+	OPTIONS[key] = value
+
+
+def register_args(program : ArgumentParser) -> None:
+    pass
+
+
+def apply_args(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	frame_processors_globals.face_swapper_model = args.face_swapper_model
+	if args.face_swapper_model == 'blendface_256':
+		facefusion.globals.face_recognizer_model = 'arcface_blendface'
+	if args.face_swapper_model == 'inswapper_128' or args.face_swapper_model == 'inswapper_128_fp16':
+		facefusion.globals.face_recognizer_model = 'arcface_inswapper'
+	if args.face_swapper_model == 'simswap_256' or args.face_swapper_model == 'simswap_512_unofficial':
+		facefusion.globals.face_recognizer_model = 'arcface_simswap'
+
+
+def pre_check() -> bool:
+	if not facefusion.globals.skip_download:
+		download_directory_path = resolve_relative_path('../.assets/models')
+		model_url = get_options('model').get('url')
+		conditional_download(download_directory_path, [ model_url ])
+	return True
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	model_url = get_options('model').get('url')
+	model_path = get_options('model').get('path')
+	if not facefusion.globals.skip_download and not is_download_done(model_url, model_path):
+		update_status(wording.get('model_download_not_done') + wording.get('exclamation_mark'), NAME)
+		return False
+	elif not is_file(model_path):
+		update_status(wording.get('model_file_not_present') + wording.get('exclamation_mark'), NAME)
+		return False
+	if not is_image(facefusion.globals.source_path):
+		update_status(wording.get('select_image_source') + wording.get('exclamation_mark'), NAME)
+		return False
+	elif not get_one_face(read_static_image(facefusion.globals.source_path)):
+		update_status(wording.get('no_source_face_detected') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode in [ 'output', 'preview' ] and not is_image(facefusion.globals.target_path) and not is_video(facefusion.globals.target_path):
+		update_status(wording.get('select_image_or_video_target') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode == 'output' and not facefusion.globals.output_path:
+		update_status(wording.get('select_file_or_directory_output') + wording.get('exclamation_mark'), NAME)
+		return False
+	return True
+
+
+def post_process() -> None:
+	clear_frame_processor()
+	clear_model_matrix()
+	clear_face_analyser()
+	clear_content_analyser()
+	read_static_image.cache_clear()
+
+
+def apply_blur_to_face(target_face: Face, temp_frame: Frame) -> Frame:
+    print('apply_blur_to_face')
+    model_template = get_options('model').get('template')
+    model_size = get_options('model').get('size')
+    crop_frame, affine_matrix = warp_face(temp_frame, target_face.kps, model_template, model_size)
+    blurred_face = apply_blur(crop_frame)
+    temp_frame = paste_back_ellipse(temp_frame, blurred_face, affine_matrix, facefusion.globals.face_mask_blur, facefusion.globals.face_mask_padding)
+    return temp_frame
+
+
+def apply_blur(crop_frame: Frame) -> Frame:
+    blurred_frame = cv2.GaussianBlur(crop_frame, (45, 45), 0)
+    return blurred_frame
+
+
+def prepare_source_frame(source_face : Face) -> numpy.ndarray[Any, Any]:
+	source_frame = read_static_image(facefusion.globals.source_path)
+	source_frame, _ = warp_face(source_frame, source_face.kps, 'arcface_v2', (112, 112))
+	source_frame = source_frame[:, :, ::-1] / 255.0
+	source_frame = source_frame.transpose(2, 0, 1)
+	source_frame = numpy.expand_dims(source_frame, axis = 0).astype(numpy.float32)
+	return source_frame
+
+
+def prepare_source_embedding(source_face : Face) -> Embedding:
+	model_type = get_options('model').get('type')
+	if model_type == 'inswapper':
+		model_matrix = get_model_matrix()
+		source_embedding = source_face.embedding.reshape((1, -1))
+		source_embedding = numpy.dot(source_embedding, model_matrix) / numpy.linalg.norm(source_embedding)
+	else:
+		source_embedding = source_face.normed_embedding.reshape(1, -1)
+	return source_embedding
+
+
+def prepare_crop_frame(crop_frame : Frame) -> Frame:
+	model_mean = get_options('model').get('mean')
+	model_standard_deviation = get_options('model').get('standard_deviation')
+	crop_frame = crop_frame[:, :, ::-1] / 255.0
+	crop_frame = (crop_frame - model_mean) / model_standard_deviation
+	crop_frame = crop_frame.transpose(2, 0, 1)
+	crop_frame = numpy.expand_dims(crop_frame, axis = 0).astype(numpy.float32)
+	return crop_frame
+
+
+def normalize_crop_frame(crop_frame : Frame) -> Frame:
+	crop_frame = crop_frame.transpose(1, 2, 0)
+	crop_frame = (crop_frame * 255.0).round()
+	crop_frame = crop_frame[:, :, ::-1].astype(numpy.uint8)
+	return crop_frame
+
+
+def process_frame(source_face: Face, reference_face: Face, temp_frame: Frame) -> Frame:
+	if 'reference' in facefusion.globals.face_selector_mode:
+		similar_faces = find_similar_faces(temp_frame, reference_face, facefusion.globals.reference_face_distance)
+		if similar_faces:
+			for similar_face in similar_faces:
+				temp_frame = apply_blur_to_face(similar_face, temp_frame)
+	if 'one' in facefusion.globals.face_selector_mode:
+		target_face = get_one_face(temp_frame)
+		if target_face:
+			temp_frame = apply_blur_to_face(target_face, temp_frame)
+	if 'many' in facefusion.globals.face_selector_mode:
+		many_faces = get_many_faces(temp_frame)
+		if many_faces:
+			for target_face in many_faces:
+				temp_frame = apply_blur_to_face(target_face, temp_frame)
+	return temp_frame
+
+
+def process_frames(source_path : str, temp_frame_paths : List[str], update_progress : Update_Process) -> None:
+	source_face = get_one_face(read_static_image(source_path))
+	reference_face = get_face_reference() if 'reference' in facefusion.globals.face_selector_mode else None
+	for temp_frame_path in temp_frame_paths:
+		temp_frame = read_image(temp_frame_path)
+		result_frame = process_frame(source_face, reference_face, temp_frame)
+		write_image(temp_frame_path, result_frame)
+		update_progress()
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	source_face = get_one_face(read_static_image(source_path))
+	target_frame = read_static_image(target_path)
+	reference_face = get_one_face(target_frame, facefusion.globals.reference_face_position) if 'reference' in facefusion.globals.face_selector_mode else None
+	result_frame = process_frame(source_face, reference_face, target_frame)
+	write_image(output_path, result_frame)
+
+
+def process_video(source_path : str, temp_frame_paths : List[str]) -> None:
+	frame_processors.multi_process_frames(source_path, temp_frame_paths, process_frames)

facefusion/processors/frame/modules/face_debugger.py

@@ -0,0 +1,123 @@
+from typing import Any, List, Literal
+from argparse import ArgumentParser
+import cv2
+import numpy
+
+import facefusion.globals
+import facefusion.processors.frame.core as frame_processors
+from facefusion import wording
+from facefusion.face_analyser import get_one_face, get_many_faces, find_similar_faces, clear_face_analyser
+from facefusion.face_reference import get_face_reference
+from facefusion.content_analyser import clear_content_analyser
+from facefusion.typing import Face, Frame, Update_Process, ProcessMode
+from facefusion.vision import read_image, read_static_image, write_image
+from facefusion.face_helper import warp_face, create_static_mask_frame
+from facefusion.processors.frame import globals as frame_processors_globals, choices as frame_processors_choices
+
+NAME = 'FACEFUSION.FRAME_PROCESSOR.FACE_DEBUGGER'
+
+
+def get_frame_processor() -> None:
+	pass
+
+
+def clear_frame_processor() -> None:
+	pass
+
+
+def get_options(key : Literal['model']) -> None:
+	pass
+
+
+def set_options(key : Literal['model'], value : Any) -> None:
+	pass
+
+
+def register_args(program : ArgumentParser) -> None:
+	program.add_argument('--face-debugger-items', help = wording.get('face_debugger_items_help'), dest = 'face_debugger_items', default = [ 'kps', 'face-mask' ], choices = frame_processors_choices.face_debugger_items, nargs = '+')
+
+
+def apply_args(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	frame_processors_globals.face_debugger_items = args.face_debugger_items
+
+
+def pre_check() -> bool:
+	return True
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	return True
+
+
+def post_process() -> None:
+	clear_frame_processor()
+	clear_face_analyser()
+	clear_content_analyser()
+
+
+def debug_face(source_face : Face, target_face : Face, temp_frame : Frame) -> Frame:
+	primary_color = (0, 0, 255)
+	secondary_color = (0, 255, 0)
+	bounding_box = target_face.bbox.astype(numpy.int32)
+	if 'bbox' in frame_processors_globals.face_debugger_items:
+		cv2.rectangle(temp_frame, (bounding_box[0], bounding_box[1]), (bounding_box[2], bounding_box[3]), secondary_color, 2)
+	if 'face-mask' in frame_processors_globals.face_debugger_items:
+		crop_frame, affine_matrix = warp_face(temp_frame, target_face.kps, 'arcface_v2', (128, 128))
+		inverse_matrix = cv2.invertAffineTransform(affine_matrix)
+		temp_frame_size = temp_frame.shape[:2][::-1]
+		mask_frame = create_static_mask_frame(crop_frame.shape[:2], 0, facefusion.globals.face_mask_padding)
+		mask_frame[mask_frame > 0] = 255
+		inverse_mask_frame = cv2.warpAffine(mask_frame.astype(numpy.uint8), inverse_matrix, temp_frame_size)
+		inverse_mask_contours = cv2.findContours(inverse_mask_frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0]
+		cv2.drawContours(temp_frame, inverse_mask_contours, 0, primary_color, 2)
+	if bounding_box[3] - bounding_box[1] > 60 and bounding_box[2] - bounding_box[0] > 60:
+		if 'kps' in frame_processors_globals.face_debugger_items:
+			kps = target_face.kps.astype(numpy.int32)
+			for index in range(kps.shape[0]):
+				cv2.circle(temp_frame, (kps[index][0], kps[index][1]), 3, primary_color, -1)
+		if 'score' in frame_processors_globals.face_debugger_items:
+			score_text = str(round(target_face.score, 2))
+			score_position = (bounding_box[0] + 10, bounding_box[1] + 20)
+			cv2.putText(temp_frame, score_text, score_position, cv2.FONT_HERSHEY_SIMPLEX, 0.5, secondary_color, 2)
+	return temp_frame
+
+
+def process_frame(source_face : Face, reference_face : Face, temp_frame : Frame) -> Frame:
+	if 'reference' in facefusion.globals.face_selector_mode:
+		similar_faces = find_similar_faces(temp_frame, reference_face, facefusion.globals.reference_face_distance)
+		if similar_faces:
+			for similar_face in similar_faces:
+				temp_frame = debug_face(source_face, similar_face, temp_frame)
+	if 'one' in facefusion.globals.face_selector_mode:
+		target_face = get_one_face(temp_frame)
+		if target_face:
+			temp_frame = debug_face(source_face, target_face, temp_frame)
+	if 'many' in facefusion.globals.face_selector_mode:
+		many_faces = get_many_faces(temp_frame)
+		if many_faces:
+			for target_face in many_faces:
+				temp_frame = debug_face(source_face, target_face, temp_frame)
+	return temp_frame
+
+
+def process_frames(source_path : str, temp_frame_paths : List[str], update_progress : Update_Process) -> None:
+	source_face = get_one_face(read_static_image(source_path))
+	reference_face = get_face_reference() if 'reference' in facefusion.globals.face_selector_mode else None
+	for temp_frame_path in temp_frame_paths:
+		temp_frame = read_image(temp_frame_path)
+		result_frame = process_frame(source_face, reference_face, temp_frame)
+		write_image(temp_frame_path, result_frame)
+		update_progress()
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	source_face = get_one_face(read_static_image(source_path))
+	target_frame = read_static_image(target_path)
+	reference_face = get_one_face(target_frame, facefusion.globals.reference_face_position) if 'reference' in facefusion.globals.face_selector_mode else None
+	result_frame = process_frame(source_face, reference_face, target_frame)
+	write_image(output_path, result_frame)
+
+
+def process_video(source_path : str, temp_frame_paths : List[str]) -> None:
+	frame_processors.multi_process_frames(source_path, temp_frame_paths, process_frames)

facefusion/processors/frame/modules/face_enhancer.py

@@ -0,0 +1,222 @@
+from typing import Any, List, Dict, Literal, Optional
+from argparse import ArgumentParser
+import cv2
+import threading
+import numpy
+import onnxruntime
+
+import facefusion.globals
+import facefusion.processors.frame.core as frame_processors
+from facefusion import wording
+from facefusion.face_analyser import get_many_faces, clear_face_analyser
+from facefusion.face_helper import warp_face, paste_back
+from facefusion.content_analyser import clear_content_analyser
+from facefusion.typing import Face, Frame, Update_Process, ProcessMode, ModelValue, OptionsWithModel
+from facefusion.utilities import conditional_download, resolve_relative_path, is_image, is_video, is_file, is_download_done, create_metavar, update_status
+from facefusion.vision import read_image, read_static_image, write_image
+from facefusion.processors.frame import globals as frame_processors_globals
+from facefusion.processors.frame import choices as frame_processors_choices
+
+FRAME_PROCESSOR = None
+THREAD_SEMAPHORE : threading.Semaphore = threading.Semaphore()
+THREAD_LOCK : threading.Lock = threading.Lock()
+NAME = 'FACEFUSION.FRAME_PROCESSOR.FACE_ENHANCER'
+MODELS : Dict[str, ModelValue] =\
+{
+	'codeformer':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/codeformer.onnx',
+		'path': resolve_relative_path('../.assets/models/codeformer.onnx'),
+		'template': 'ffhq',
+		'size': (512, 512)
+	},
+	'gfpgan_1.2':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gfpgan_1.2.onnx',
+		'path': resolve_relative_path('../.assets/models/gfpgan_1.2.onnx'),
+		'template': 'ffhq',
+		'size': (512, 512)
+	},
+	'gfpgan_1.3':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gfpgan_1.3.onnx',
+		'path': resolve_relative_path('../.assets/models/gfpgan_1.3.onnx'),
+		'template': 'ffhq',
+		'size': (512, 512)
+	},
+	'gfpgan_1.4':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gfpgan_1.4.onnx',
+		'path': resolve_relative_path('../.assets/models/gfpgan_1.4.onnx'),
+		'template': 'ffhq',
+		'size': (512, 512)
+	},
+	'gpen_bfr_256':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gpen_bfr_256.onnx',
+		'path': resolve_relative_path('../.assets/models/gpen_bfr_256.onnx'),
+		'template': 'arcface_v2',
+		'size': (128, 256)
+	},
+	'gpen_bfr_512':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gpen_bfr_512.onnx',
+		'path': resolve_relative_path('../.assets/models/gpen_bfr_512.onnx'),
+		'template': 'ffhq',
+		'size': (512, 512)
+	},
+	'restoreformer':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/restoreformer.onnx',
+		'path': resolve_relative_path('../.assets/models/restoreformer.onnx'),
+		'template': 'ffhq',
+		'size': (512, 512)
+	}
+}
+OPTIONS : Optional[OptionsWithModel] = None
+
+
+def get_frame_processor() -> Any:
+	global FRAME_PROCESSOR
+
+	with THREAD_LOCK:
+		if FRAME_PROCESSOR is None:
+			model_path = get_options('model').get('path')
+			FRAME_PROCESSOR = onnxruntime.InferenceSession(model_path, providers = facefusion.globals.execution_providers)
+	return FRAME_PROCESSOR
+
+
+def clear_frame_processor() -> None:
+	global FRAME_PROCESSOR
+
+	FRAME_PROCESSOR = None
+
+
+def get_options(key : Literal['model']) -> Any:
+	global OPTIONS
+
+	if OPTIONS is None:
+		OPTIONS =\
+		{
+			'model': MODELS[frame_processors_globals.face_enhancer_model]
+		}
+	return OPTIONS.get(key)
+
+
+def set_options(key : Literal['model'], value : Any) -> None:
+	global OPTIONS
+
+	OPTIONS[key] = value
+
+
+def register_args(program : ArgumentParser) -> None:
+	program.add_argument('--face-enhancer-model', help = wording.get('frame_processor_model_help'), dest = 'face_enhancer_model', default = 'gfpgan_1.4', choices = frame_processors_choices.face_enhancer_models)
+	program.add_argument('--face-enhancer-blend', help = wording.get('frame_processor_blend_help'), dest = 'face_enhancer_blend', type = int, default = 80, choices = frame_processors_choices.face_enhancer_blend_range, metavar = create_metavar(frame_processors_choices.face_enhancer_blend_range))
+
+
+def apply_args(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	frame_processors_globals.face_enhancer_model = args.face_enhancer_model
+	frame_processors_globals.face_enhancer_blend = args.face_enhancer_blend
+
+
+def pre_check() -> bool:
+	if not facefusion.globals.skip_download:
+		download_directory_path = resolve_relative_path('../.assets/models')
+		model_url = get_options('model').get('url')
+		print("下载文件",download_directory_path,model_url)
+		conditional_download(download_directory_path, [ model_url ])
+	return True
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	model_url = get_options('model').get('url')
+	model_path = get_options('model').get('path')
+	if not facefusion.globals.skip_download and not is_download_done(model_url, model_path):
+		update_status(wording.get('model_download_not_done') + wording.get('exclamation_mark'), NAME)
+		return False
+	elif not is_file(model_path):
+		update_status(wording.get('model_file_not_present') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode in [ 'output', 'preview' ] and not is_image(facefusion.globals.target_path) and not is_video(facefusion.globals.target_path):
+		update_status(wording.get('select_image_or_video_target') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode == 'output' and not facefusion.globals.output_path:
+		update_status(wording.get('select_file_or_directory_output') + wording.get('exclamation_mark'), NAME)
+		return False
+	return True
+
+
+def post_process() -> None:
+	clear_frame_processor()
+	clear_face_analyser()
+	clear_content_analyser()
+	read_static_image.cache_clear()
+
+
+def enhance_face(target_face: Face, temp_frame: Frame) -> Frame:
+	frame_processor = get_frame_processor()
+	model_template = get_options('model').get('template')
+	model_size = get_options('model').get('size')
+	crop_frame, affine_matrix = warp_face(temp_frame, target_face.kps, model_template, model_size)
+	crop_frame = prepare_crop_frame(crop_frame)
+	frame_processor_inputs = {}
+	for frame_processor_input in frame_processor.get_inputs():
+		if frame_processor_input.name == 'input':
+			frame_processor_inputs[frame_processor_input.name] = crop_frame
+		if frame_processor_input.name == 'weight':
+			frame_processor_inputs[frame_processor_input.name] = numpy.array([ 1 ], dtype = numpy.double)
+	with THREAD_SEMAPHORE:
+		crop_frame = frame_processor.run(None, frame_processor_inputs)[0][0]
+	crop_frame = normalize_crop_frame(crop_frame)
+	paste_frame = paste_back(temp_frame, crop_frame, affine_matrix, facefusion.globals.face_mask_blur, (0, 0, 0, 0))
+	temp_frame = blend_frame(temp_frame, paste_frame)
+	return temp_frame
+
+
+def prepare_crop_frame(crop_frame : Frame) -> Frame:
+	crop_frame = crop_frame[:, :, ::-1] / 255.0
+	crop_frame = (crop_frame - 0.5) / 0.5
+	crop_frame = numpy.expand_dims(crop_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return crop_frame
+
+
+def normalize_crop_frame(crop_frame : Frame) -> Frame:
+	crop_frame = numpy.clip(crop_frame, -1, 1)
+	crop_frame = (crop_frame + 1) / 2
+	crop_frame = crop_frame.transpose(1, 2, 0)
+	crop_frame = (crop_frame * 255.0).round()
+	crop_frame = crop_frame.astype(numpy.uint8)[:, :, ::-1]
+	return crop_frame
+
+
+def blend_frame(temp_frame : Frame, paste_frame : Frame) -> Frame:
+	face_enhancer_blend = 1 - (frame_processors_globals.face_enhancer_blend / 100)
+	temp_frame = cv2.addWeighted(temp_frame, face_enhancer_blend, paste_frame, 1 - face_enhancer_blend, 0)
+	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_progress : Update_Process) -> None:
+	for temp_frame_path in temp_frame_paths:
+		temp_frame = read_image(temp_frame_path)
+		result_frame = process_frame(None, None, temp_frame)
+		write_image(temp_frame_path, result_frame)
+		update_progress()
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	target_frame = read_static_image(target_path)
+	result_frame = process_frame(None, None, target_frame)
+	write_image(output_path, result_frame)
+
+
+def process_video(source_path : str, temp_frame_paths : List[str]) -> None:
+	frame_processors.multi_process_frames(None, temp_frame_paths, process_frames)

facefusion/processors/frame/modules/face_swapper.py

@@ -0,0 +1,283 @@
+from typing import Any, List, Dict, Literal, Optional
+from argparse import ArgumentParser
+import threading
+import numpy
+import onnx
+import onnxruntime
+from onnx import numpy_helper
+
+import facefusion.globals
+import facefusion.processors.frame.core as frame_processors
+from facefusion import wording
+from facefusion.face_analyser import get_one_face, get_many_faces, find_similar_faces, clear_face_analyser
+from facefusion.face_helper import warp_face, paste_back
+from facefusion.face_reference import get_face_reference
+from facefusion.content_analyser import clear_content_analyser
+from facefusion.typing import Face, Frame, Update_Process, ProcessMode, ModelValue, OptionsWithModel, Embedding
+from facefusion.utilities import conditional_download, resolve_relative_path, is_image, is_video, is_file, is_download_done, update_status
+from facefusion.vision import read_image, read_static_image, write_image
+from facefusion.processors.frame import globals as frame_processors_globals
+from facefusion.processors.frame import choices as frame_processors_choices
+
+FRAME_PROCESSOR = None
+MODEL_MATRIX = None
+THREAD_LOCK : threading.Lock = threading.Lock()
+NAME = 'FACEFUSION.FRAME_PROCESSOR.FACE_SWAPPER'
+MODELS : Dict[str, ModelValue] =\
+{
+	'blendface_256':
+	{
+		'type': 'blendface',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/blendface_256.onnx',
+		'path': resolve_relative_path('../.assets/models/blendface_256.onnx'),
+		'template': 'ffhq',
+		'size': (512, 256),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	},
+	'inswapper_128':
+	{
+		'type': 'inswapper',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/inswapper_128.onnx',
+		'path': resolve_relative_path('../.assets/models/inswapper_128.onnx'),
+		'template': 'arcface_v2',
+		'size': (128, 128),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	},
+	'inswapper_128_fp16':
+	{
+		'type': 'inswapper',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/inswapper_128_fp16.onnx',
+		'path': resolve_relative_path('../.assets/models/inswapper_128_fp16.onnx'),
+		'template': 'arcface_v2',
+		'size': (128, 128),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	},
+	'simswap_256':
+	{
+		'type': 'simswap',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/simswap_256.onnx',
+		'path': resolve_relative_path('../.assets/models/simswap_256.onnx'),
+		'template': 'arcface_v1',
+		'size': (112, 256),
+		'mean': [ 0.485, 0.456, 0.406 ],
+		'standard_deviation': [ 0.229, 0.224, 0.225 ]
+	},
+	'simswap_512_unofficial':
+	{
+		'type': 'simswap',
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/simswap_512_unofficial.onnx',
+		'path': resolve_relative_path('../.assets/models/simswap_512_unofficial.onnx'),
+		'template': 'arcface_v1',
+		'size': (112, 512),
+		'mean': [ 0.0, 0.0, 0.0 ],
+		'standard_deviation': [ 1.0, 1.0, 1.0 ]
+	}
+}
+OPTIONS : Optional[OptionsWithModel] = None
+
+
+def get_frame_processor() -> Any:
+	global FRAME_PROCESSOR
+
+	with THREAD_LOCK:
+		if FRAME_PROCESSOR is None:
+			model_path = get_options('model').get('path')
+			FRAME_PROCESSOR = onnxruntime.InferenceSession(model_path, providers = facefusion.globals.execution_providers)
+	return FRAME_PROCESSOR
+
+
+def clear_frame_processor() -> None:
+	global FRAME_PROCESSOR
+
+	FRAME_PROCESSOR = None
+
+
+def get_model_matrix() -> Any:
+	global MODEL_MATRIX
+
+	with THREAD_LOCK:
+		if MODEL_MATRIX is None:
+			model_path = get_options('model').get('path')
+			model = onnx.load(model_path)
+			MODEL_MATRIX = numpy_helper.to_array(model.graph.initializer[-1])
+	return MODEL_MATRIX
+
+
+def clear_model_matrix() -> None:
+	global MODEL_MATRIX
+
+	MODEL_MATRIX = None
+
+
+def get_options(key : Literal['model']) -> Any:
+	global OPTIONS
+
+	if OPTIONS is None:
+		OPTIONS =\
+		{
+			'model': MODELS[frame_processors_globals.face_swapper_model]
+		}
+	return OPTIONS.get(key)
+
+
+def set_options(key : Literal['model'], value : Any) -> None:
+	global OPTIONS
+
+	OPTIONS[key] = value
+
+
+def register_args(program : ArgumentParser) -> None:
+	program.add_argument('--face-swapper-model', help = wording.get('frame_processor_model_help'), dest = 'face_swapper_model', default = 'inswapper_128', choices = frame_processors_choices.face_swapper_models)
+
+
+def apply_args(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	frame_processors_globals.face_swapper_model = args.face_swapper_model
+	if args.face_swapper_model == 'blendface_256':
+		facefusion.globals.face_recognizer_model = 'arcface_blendface'
+	if args.face_swapper_model == 'inswapper_128' or args.face_swapper_model == 'inswapper_128_fp16':
+		facefusion.globals.face_recognizer_model = 'arcface_inswapper'
+	if args.face_swapper_model == 'simswap_256' or args.face_swapper_model == 'simswap_512_unofficial':
+		facefusion.globals.face_recognizer_model = 'arcface_simswap'
+
+
+def pre_check() -> bool:
+	if not facefusion.globals.skip_download:
+		download_directory_path = resolve_relative_path('../.assets/models')
+		model_url = get_options('model').get('url')
+		conditional_download(download_directory_path, [ model_url ])
+	return True
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	model_url = get_options('model').get('url')
+	model_path = get_options('model').get('path')
+	if not facefusion.globals.skip_download and not is_download_done(model_url, model_path):
+		update_status(wording.get('model_download_not_done') + wording.get('exclamation_mark'), NAME)
+		return False
+	elif not is_file(model_path):
+		update_status(wording.get('model_file_not_present') + wording.get('exclamation_mark'), NAME)
+		return False
+	if not is_image(facefusion.globals.source_path):
+		update_status(wording.get('select_image_source') + wording.get('exclamation_mark'), NAME)
+		return False
+	elif not get_one_face(read_static_image(facefusion.globals.source_path)):
+		update_status(wording.get('no_source_face_detected') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode in [ 'output', 'preview' ] and not is_image(facefusion.globals.target_path) and not is_video(facefusion.globals.target_path):
+		update_status(wording.get('select_image_or_video_target') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode == 'output' and not facefusion.globals.output_path:
+		update_status(wording.get('select_file_or_directory_output') + wording.get('exclamation_mark'), NAME)
+		return False
+	return True
+
+
+def post_process() -> None:
+	clear_frame_processor()
+	clear_model_matrix()
+	clear_face_analyser()
+	clear_content_analyser()
+	read_static_image.cache_clear()
+
+
+def swap_face(source_face : Face, target_face : Face, temp_frame : Frame) -> Frame:
+	frame_processor = get_frame_processor()
+	model_template = get_options('model').get('template')
+	model_size = get_options('model').get('size')
+	model_type = get_options('model').get('type')
+	crop_frame, affine_matrix = warp_face(temp_frame, target_face.kps, model_template, model_size)
+	crop_frame = prepare_crop_frame(crop_frame)
+	frame_processor_inputs = {}
+	for frame_processor_input in frame_processor.get_inputs():
+		if frame_processor_input.name == 'source':
+			if model_type == 'blendface':
+				frame_processor_inputs[frame_processor_input.name] = prepare_source_frame(source_face)
+			else:
+				frame_processor_inputs[frame_processor_input.name] = prepare_source_embedding(source_face)
+		if frame_processor_input.name == 'target':
+			frame_processor_inputs[frame_processor_input.name] = crop_frame
+	crop_frame = frame_processor.run(None, frame_processor_inputs)[0][0]
+	crop_frame = normalize_crop_frame(crop_frame)
+	temp_frame = paste_back(temp_frame, crop_frame, affine_matrix, facefusion.globals.face_mask_blur, facefusion.globals.face_mask_padding)
+	return temp_frame
+
+
+def prepare_source_frame(source_face : Face) -> numpy.ndarray[Any, Any]:
+	source_frame = read_static_image(facefusion.globals.source_path)
+	source_frame, _ = warp_face(source_frame, source_face.kps, 'arcface_v2', (112, 112))
+	source_frame = source_frame[:, :, ::-1] / 255.0
+	source_frame = source_frame.transpose(2, 0, 1)
+	source_frame = numpy.expand_dims(source_frame, axis = 0).astype(numpy.float32)
+	return source_frame
+
+
+def prepare_source_embedding(source_face : Face) -> Embedding:
+	model_type = get_options('model').get('type')
+	if model_type == 'inswapper':
+		model_matrix = get_model_matrix()
+		source_embedding = source_face.embedding.reshape((1, -1))
+		source_embedding = numpy.dot(source_embedding, model_matrix) / numpy.linalg.norm(source_embedding)
+	else:
+		source_embedding = source_face.normed_embedding.reshape(1, -1)
+	return source_embedding
+
+
+def prepare_crop_frame(crop_frame : Frame) -> Frame:
+	model_mean = get_options('model').get('mean')
+	model_standard_deviation = get_options('model').get('standard_deviation')
+	crop_frame = crop_frame[:, :, ::-1] / 255.0
+	crop_frame = (crop_frame - model_mean) / model_standard_deviation
+	crop_frame = crop_frame.transpose(2, 0, 1)
+	crop_frame = numpy.expand_dims(crop_frame, axis = 0).astype(numpy.float32)
+	return crop_frame
+
+
+def normalize_crop_frame(crop_frame : Frame) -> Frame:
+	crop_frame = crop_frame.transpose(1, 2, 0)
+	crop_frame = (crop_frame * 255.0).round()
+	crop_frame = crop_frame[:, :, ::-1].astype(numpy.uint8)
+	return crop_frame
+
+
+def process_frame(source_face : Face, reference_face : Face, temp_frame : Frame) -> Frame:
+	if 'reference' in facefusion.globals.face_selector_mode:
+		similar_faces = find_similar_faces(temp_frame, reference_face, facefusion.globals.reference_face_distance)
+		if similar_faces:
+			for similar_face in similar_faces:
+				temp_frame = swap_face(source_face, similar_face, temp_frame)
+	if 'one' in facefusion.globals.face_selector_mode:
+		target_face = get_one_face(temp_frame)
+		if target_face:
+			temp_frame = swap_face(source_face, target_face, temp_frame)
+	if 'many' in facefusion.globals.face_selector_mode:
+		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)
+	return temp_frame
+
+
+def process_frames(source_path : str, temp_frame_paths : List[str], update_progress : Update_Process) -> None:
+	source_face = get_one_face(read_static_image(source_path))
+	reference_face = get_face_reference() if 'reference' in facefusion.globals.face_selector_mode else None
+	for temp_frame_path in temp_frame_paths:
+		temp_frame = read_image(temp_frame_path)
+		result_frame = process_frame(source_face, reference_face, temp_frame)
+		write_image(temp_frame_path, result_frame)
+		update_progress()
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	source_face = get_one_face(read_static_image(source_path))
+	target_frame = read_static_image(target_path)
+	reference_face = get_one_face(target_frame, facefusion.globals.reference_face_position) if 'reference' in facefusion.globals.face_selector_mode else None
+	result_frame = process_frame(source_face, reference_face, target_frame)
+	write_image(output_path, result_frame)
+
+
+def process_video(source_path : str, temp_frame_paths : List[str]) -> None:
+	frame_processors.multi_process_frames(source_path, temp_frame_paths, process_frames)

facefusion/processors/frame/modules/frame_enhancer.py

@@ -0,0 +1,165 @@
+from typing import Any, List, Dict, Literal, Optional
+from argparse import ArgumentParser
+import threading
+import cv2
+from basicsr.archs.rrdbnet_arch import RRDBNet
+from realesrgan import RealESRGANer
+
+import facefusion.globals
+import facefusion.processors.frame.core as frame_processors
+from facefusion import wording
+from facefusion.face_analyser import clear_face_analyser
+from facefusion.content_analyser import clear_content_analyser
+from facefusion.typing import Frame, Face, Update_Process, ProcessMode, ModelValue, OptionsWithModel
+from facefusion.utilities import conditional_download, resolve_relative_path, is_file, is_download_done, map_device, create_metavar, update_status
+from facefusion.vision import read_image, read_static_image, write_image
+from facefusion.processors.frame import globals as frame_processors_globals
+from facefusion.processors.frame import choices as frame_processors_choices
+
+FRAME_PROCESSOR = None
+THREAD_SEMAPHORE : threading.Semaphore = threading.Semaphore()
+THREAD_LOCK : threading.Lock = threading.Lock()
+NAME = 'FACEFUSION.FRAME_PROCESSOR.FRAME_ENHANCER'
+MODELS: Dict[str, ModelValue] =\
+{
+	'real_esrgan_x2plus':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/real_esrgan_x2plus.pth',
+		'path': resolve_relative_path('../.assets/models/real_esrgan_x2plus.pth'),
+		'scale': 2
+	},
+	'real_esrgan_x4plus':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/real_esrgan_x4plus.pth',
+		'path': resolve_relative_path('../.assets/models/real_esrgan_x4plus.pth'),
+		'scale': 4
+	},
+	'real_esrnet_x4plus':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/real_esrnet_x4plus.pth',
+		'path': resolve_relative_path('../.assets/models/real_esrnet_x4plus.pth'),
+		'scale': 4
+	}
+}
+OPTIONS : Optional[OptionsWithModel] = None
+
+
+def get_frame_processor() -> Any:
+	global FRAME_PROCESSOR
+
+	with THREAD_LOCK:
+		if FRAME_PROCESSOR is None:
+			model_path = get_options('model').get('path')
+			model_scale = get_options('model').get('scale')
+			FRAME_PROCESSOR = RealESRGANer(
+				model_path = model_path,
+				model = RRDBNet(
+					num_in_ch = 3,
+					num_out_ch = 3,
+					scale = model_scale
+				),
+				device = map_device(facefusion.globals.execution_providers),
+				scale = model_scale
+			)
+	return FRAME_PROCESSOR
+
+
+def clear_frame_processor() -> None:
+	global FRAME_PROCESSOR
+
+	FRAME_PROCESSOR = None
+
+
+def get_options(key : Literal['model']) -> Any:
+	global OPTIONS
+
+	if OPTIONS is None:
+		OPTIONS =\
+		{
+			'model': MODELS[frame_processors_globals.frame_enhancer_model]
+		}
+	return OPTIONS.get(key)
+
+
+def set_options(key : Literal['model'], value : Any) -> None:
+	global OPTIONS
+
+	OPTIONS[key] = value
+
+
+def register_args(program : ArgumentParser) -> None:
+	program.add_argument('--frame-enhancer-model', help = wording.get('frame_processor_model_help'), dest = 'frame_enhancer_model', default = 'real_esrgan_x2plus', choices = frame_processors_choices.frame_enhancer_models)
+	program.add_argument('--frame-enhancer-blend', help = wording.get('frame_processor_blend_help'), dest = 'frame_enhancer_blend', type = int, default = 80, choices = frame_processors_choices.frame_enhancer_blend_range, metavar = create_metavar(frame_processors_choices.frame_enhancer_blend_range))
+
+
+def apply_args(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	frame_processors_globals.frame_enhancer_model = args.frame_enhancer_model
+	frame_processors_globals.frame_enhancer_blend = args.frame_enhancer_blend
+
+
+def pre_check() -> bool:
+	if not facefusion.globals.skip_download:
+		download_directory_path = resolve_relative_path('../.assets/models')
+		model_url = get_options('model').get('url')
+		conditional_download(download_directory_path, [ model_url ])
+	return True
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	model_url = get_options('model').get('url')
+	model_path = get_options('model').get('path')
+	if not facefusion.globals.skip_download and not is_download_done(model_url, model_path):
+		update_status(wording.get('model_download_not_done') + wording.get('exclamation_mark'), NAME)
+		return False
+	elif not is_file(model_path):
+		update_status(wording.get('model_file_not_present') + wording.get('exclamation_mark'), NAME)
+		return False
+	if mode == 'output' and not facefusion.globals.output_path:
+		update_status(wording.get('select_file_or_directory_output') + wording.get('exclamation_mark'), NAME)
+		return False
+	return True
+
+
+def post_process() -> None:
+	clear_frame_processor()
+	clear_face_analyser()
+	clear_content_analyser()
+	read_static_image.cache_clear()
+
+
+def enhance_frame(temp_frame : Frame) -> Frame:
+	with THREAD_SEMAPHORE:
+		paste_frame, _ = get_frame_processor().enhance(temp_frame)
+		temp_frame = blend_frame(temp_frame, paste_frame)
+	return temp_frame
+
+
+def blend_frame(temp_frame : Frame, paste_frame : Frame) -> Frame:
+	frame_enhancer_blend = 1 - (frame_processors_globals.frame_enhancer_blend / 100)
+	paste_frame_height, paste_frame_width = paste_frame.shape[0:2]
+	temp_frame = cv2.resize(temp_frame, (paste_frame_width, paste_frame_height))
+	temp_frame = cv2.addWeighted(temp_frame, frame_enhancer_blend, paste_frame, 1 - frame_enhancer_blend, 0)
+	return temp_frame
+
+
+def process_frame(source_face : Face, reference_face : Face, temp_frame : Frame) -> Frame:
+	return enhance_frame(temp_frame)
+
+
+def process_frames(source_path : str, temp_frame_paths : List[str], update_progress : Update_Process) -> None:
+	for temp_frame_path in temp_frame_paths:
+		temp_frame = read_image(temp_frame_path)
+		result_frame = process_frame(None, None, temp_frame)
+		write_image(temp_frame_path, result_frame)
+		update_progress()
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	target_frame = read_static_image(target_path)
+	result = process_frame(None, None, target_frame)
+	write_image(output_path, result)
+
+
+def process_video(source_path : str, temp_frame_paths : List[str]) -> None:
+	frame_processors.multi_process_frames(None, temp_frame_paths, process_frames)

facefusion/processors/frame/typings.py

@@ -0,0 +1,7 @@
+from typing import Literal
+
+FaceSwapperModel = Literal['blendface_256', 'inswapper_128', 'inswapper_128_fp16', 'simswap_256', 'simswap_512_unofficial']
+FaceEnhancerModel = Literal['codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'restoreformer']
+FrameEnhancerModel = Literal['real_esrgan_x2plus', 'real_esrgan_x4plus', 'real_esrnet_x4plus']
+
+FaceDebuggerItem = Literal['bbox', 'kps', 'face-mask', 'score']

facefusion/typing.py

@@ -0,0 +1,41 @@
+from collections import namedtuple
+from typing import Any, Literal, Callable, List, Tuple, Dict, TypedDict
+import numpy
+
+Bbox = numpy.ndarray[Any, Any]
+Kps = numpy.ndarray[Any, Any]
+Score = float
+Embedding = numpy.ndarray[Any, Any]
+Face = namedtuple('Face',
+[
+	'bbox',
+	'kps',
+	'score',
+	'embedding',
+	'normed_embedding',
+	'gender',
+	'age'
+])
+Frame = numpy.ndarray[Any, Any]
+Matrix = numpy.ndarray[Any, Any]
+Padding = Tuple[int, int, int, int]
+
+Update_Process = Callable[[], None]
+Process_Frames = Callable[[str, List[str], Update_Process], None]
+
+Template = Literal['arcface_v1', 'arcface_v2', 'ffhq']
+ProcessMode = Literal['output', 'preview', 'stream']
+FaceSelectorMode = Literal['reference', 'one', 'many']
+FaceAnalyserOrder = Literal['left-right', 'right-left', 'top-bottom', 'bottom-top', 'small-large', 'large-small', 'best-worst', 'worst-best']
+FaceAnalyserAge = Literal['child', 'teen', 'adult', 'senior']
+FaceAnalyserGender = Literal['male', 'female']
+FaceDetectorModel = Literal['retinaface', 'yunet']
+FaceRecognizerModel = Literal['arcface_blendface', 'arcface_inswapper', 'arcface_simswap']
+TempFrameFormat = Literal['jpg', 'png']
+OutputVideoEncoder = Literal['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc']
+
+ModelValue = Dict[str, Any]
+OptionsWithModel = TypedDict('OptionsWithModel',
+{
+	'model' : ModelValue
+})

facefusion/uis/assets/fixes.css

@@ -0,0 +1,7 @@
+:root:root:root button:not([class])
+{
+	border-radius: 0.375rem;
+	float: left;
+	overflow: hidden;
+	width: 100%;
+}

facefusion/uis/assets/overrides.css

@@ -0,0 +1,44 @@
+:root:root:root input[type="number"]
+{
+	max-width: 6rem;
+}
+
+:root:root:root [type="checkbox"],
+:root:root:root [type="radio"]
+{
+	border-radius: 50%;
+	height: 1.125rem;
+	width: 1.125rem;
+}
+
+:root:root:root input[type="range"]
+{
+	height: 0.5rem;
+}
+
+:root:root:root input[type="range"]::-moz-range-thumb,
+:root:root:root input[type="range"]::-webkit-slider-thumb
+{
+	background: var(--neutral-300);
+	border: unset;
+	border-radius: 50%;
+	height: 1.125rem;
+	width: 1.125rem;
+}
+
+:root:root:root input[type="range"]::-webkit-slider-thumb
+{
+	margin-top: 0.375rem;
+}
+
+:root:root:root .grid-wrap.fixed-height
+{
+	min-height: unset;
+}
+
+:root:root:root .grid-container
+{
+	grid-auto-rows: minmax(5em, 1fr);
+	grid-template-columns: repeat(var(--grid-cols), minmax(5em, 1fr));
+	grid-template-rows: repeat(var(--grid-rows), minmax(5em, 1fr));
+}

facefusion/uis/choices.py

@@ -0,0 +1,7 @@
+from typing import List
+
+from facefusion.uis.typing import WebcamMode
+
+common_options : List[str] = [ 'keep-fps', 'keep-temp', 'skip-audio', 'skip-download' ]
+webcam_modes : List[WebcamMode] = [ 'inline', 'udp', 'v4l2' ]
+webcam_resolutions : List[str] = [ '320x240', '640x480', '800x600', '1024x768', '1280x720', '1280x960', '1920x1080', '2560x1440', '3840x2160' ]

facefusion/uis/components/about.py

@@ -0,0 +1,23 @@
+from typing import Optional
+import gradio
+
+from facefusion import metadata, wording
+
+ABOUT_BUTTON : Optional[gradio.HTML] = None
+DONATE_BUTTON : Optional[gradio.HTML] = None
+
+
+def render() -> None:
+	global ABOUT_BUTTON
+	global DONATE_BUTTON
+
+	ABOUT_BUTTON = gradio.Button(
+		value = metadata.get('name') + ' ' + metadata.get('version'),
+		variant = 'primary',
+		link = metadata.get('url')
+	)
+	DONATE_BUTTON = gradio.Button(
+		value = wording.get('donate_button_label'),
+		link = 'https://donate.facefusion.io',
+		size = 'sm'
+	)

facefusion/uis/components/benchmark.py

@@ -0,0 +1,131 @@
+from typing import Any, Optional, List, Dict, Generator
+import time
+import tempfile
+import statistics
+import gradio
+
+import facefusion.globals
+from facefusion import wording
+from facefusion.face_analyser import get_face_analyser
+from facefusion.face_cache import clear_faces_cache
+from facefusion.processors.frame.core import get_frame_processors_modules
+from facefusion.vision import count_video_frame_total
+from facefusion.core import limit_resources, conditional_process
+from facefusion.utilities import normalize_output_path, clear_temp
+from facefusion.uis.core import get_ui_component
+
+BENCHMARK_RESULTS_DATAFRAME : Optional[gradio.Dataframe] = None
+BENCHMARK_START_BUTTON : Optional[gradio.Button] = None
+BENCHMARK_CLEAR_BUTTON : Optional[gradio.Button] = None
+BENCHMARKS : Dict[str, str] =\
+{
+	'240p': '.assets/examples/target-240p.mp4',
+	'360p': '.assets/examples/target-360p.mp4',
+	'540p': '.assets/examples/target-540p.mp4',
+	'720p': '.assets/examples/target-720p.mp4',
+	'1080p': '.assets/examples/target-1080p.mp4',
+	'1440p': '.assets/examples/target-1440p.mp4',
+	'2160p': '.assets/examples/target-2160p.mp4'
+}
+
+
+def render() -> None:
+	global BENCHMARK_RESULTS_DATAFRAME
+	global BENCHMARK_START_BUTTON
+	global BENCHMARK_CLEAR_BUTTON
+
+	BENCHMARK_RESULTS_DATAFRAME = gradio.Dataframe(
+		label = wording.get('benchmark_results_dataframe_label'),
+		headers =
+		[
+			'target_path',
+			'benchmark_cycles',
+			'average_run',
+			'fastest_run',
+			'slowest_run',
+			'relative_fps'
+		],
+		datatype =
+		[
+			'str',
+			'number',
+			'number',
+			'number',
+			'number',
+			'number'
+		]
+	)
+	BENCHMARK_START_BUTTON = gradio.Button(
+		value = wording.get('start_button_label'),
+		variant = 'primary',
+		size = 'sm'
+	)
+	BENCHMARK_CLEAR_BUTTON = gradio.Button(
+		value = wording.get('clear_button_label'),
+		size = 'sm'
+	)
+
+
+def listen() -> None:
+	benchmark_runs_checkbox_group = get_ui_component('benchmark_runs_checkbox_group')
+	benchmark_cycles_slider = get_ui_component('benchmark_cycles_slider')
+	if benchmark_runs_checkbox_group and benchmark_cycles_slider:
+		BENCHMARK_START_BUTTON.click(start, inputs = [ benchmark_runs_checkbox_group, benchmark_cycles_slider ], outputs = BENCHMARK_RESULTS_DATAFRAME)
+	BENCHMARK_CLEAR_BUTTON.click(clear, outputs = BENCHMARK_RESULTS_DATAFRAME)
+
+
+def start(benchmark_runs : List[str], benchmark_cycles : int) -> Generator[List[Any], None, None]:
+	facefusion.globals.source_path = '.assets/examples/source.jpg'
+	target_paths = [ BENCHMARKS[benchmark_run] for benchmark_run in benchmark_runs if benchmark_run in BENCHMARKS ]
+	benchmark_results = []
+	if target_paths:
+		pre_process()
+		for target_path in target_paths:
+			benchmark_results.append(benchmark(target_path, benchmark_cycles))
+			yield benchmark_results
+		post_process()
+
+
+def pre_process() -> None:
+	limit_resources()
+	get_face_analyser()
+	for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+		frame_processor_module.get_frame_processor()
+
+
+def post_process() -> None:
+	clear_faces_cache()
+
+
+def benchmark(target_path : str, benchmark_cycles : int) -> List[Any]:
+	process_times = []
+	total_fps = 0.0
+	for i in range(benchmark_cycles):
+		facefusion.globals.target_path = target_path
+		facefusion.globals.output_path = normalize_output_path(facefusion.globals.source_path, facefusion.globals.target_path, tempfile.gettempdir())
+		video_frame_total = count_video_frame_total(facefusion.globals.target_path)
+		start_time = time.perf_counter()
+		conditional_process()
+		end_time = time.perf_counter()
+		process_time = end_time - start_time
+		total_fps += video_frame_total / process_time
+		process_times.append(process_time)
+	average_run = round(statistics.mean(process_times), 2)
+	fastest_run = round(min(process_times), 2)
+	slowest_run = round(max(process_times), 2)
+	relative_fps = round(total_fps / benchmark_cycles, 2)
+	return\
+	[
+		facefusion.globals.target_path,
+		benchmark_cycles,
+		average_run,
+		fastest_run,
+		slowest_run,
+		relative_fps
+	]
+
+
+def clear() -> gradio.Dataframe:
+	if facefusion.globals.target_path:
+		clear_temp(facefusion.globals.target_path)
+	return gradio.Dataframe(value = None)

facefusion/uis/components/benchmark_options.py

@@ -0,0 +1,29 @@
+from typing import Optional
+import gradio
+
+from facefusion import wording
+from facefusion.uis.core import register_ui_component
+from facefusion.uis.components.benchmark import BENCHMARKS
+
+BENCHMARK_RUNS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+BENCHMARK_CYCLES_SLIDER : Optional[gradio.Button] = None
+
+
+def render() -> None:
+	global BENCHMARK_RUNS_CHECKBOX_GROUP
+	global BENCHMARK_CYCLES_SLIDER
+
+	BENCHMARK_RUNS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = wording.get('benchmark_runs_checkbox_group_label'),
+		value = list(BENCHMARKS.keys()),
+		choices = list(BENCHMARKS.keys())
+	)
+	BENCHMARK_CYCLES_SLIDER = gradio.Slider(
+		label = wording.get('benchmark_cycles_slider_label'),
+		value = 3,
+		step = 1,
+		minimum = 1,
+		maximum = 10
+	)
+	register_ui_component('benchmark_runs_checkbox_group', BENCHMARK_RUNS_CHECKBOX_GROUP)
+	register_ui_component('benchmark_cycles_slider', BENCHMARK_CYCLES_SLIDER)

facefusion/uis/components/common_options.py

@@ -0,0 +1,38 @@
+from typing import Optional, List
+import gradio
+
+import facefusion.globals
+from facefusion import wording
+from facefusion.uis import choices as uis_choices
+
+COMMON_OPTIONS_CHECKBOX_GROUP : Optional[gradio.Checkboxgroup] = None
+
+
+def render() -> None:
+	global COMMON_OPTIONS_CHECKBOX_GROUP
+
+	value = []
+	if facefusion.globals.keep_fps:
+		value.append('keep-fps')
+	if facefusion.globals.keep_temp:
+		value.append('keep-temp')
+	if facefusion.globals.skip_audio:
+		value.append('skip-audio')
+	if facefusion.globals.skip_download:
+		value.append('skip-download')
+	COMMON_OPTIONS_CHECKBOX_GROUP = gradio.Checkboxgroup(
+		label = wording.get('common_options_checkbox_group_label'),
+		choices = uis_choices.common_options,
+		value = value
+	)
+
+
+def listen() -> None:
+	COMMON_OPTIONS_CHECKBOX_GROUP.change(update, inputs = COMMON_OPTIONS_CHECKBOX_GROUP)
+
+
+def update(common_options : List[str]) -> None:
+	facefusion.globals.keep_fps = 'keep-fps' in common_options
+	facefusion.globals.keep_temp = 'keep-temp' in common_options
+	facefusion.globals.skip_audio = 'skip-audio' in common_options
+	facefusion.globals.skip_download = 'skip-download' in common_options

facefusion/uis/components/execution.py

@@ -0,0 +1,34 @@
+from typing import List, Optional
+import gradio
+import onnxruntime
+
+import facefusion.globals
+from facefusion import wording
+from facefusion.face_analyser import clear_face_analyser
+from facefusion.processors.frame.core import clear_frame_processors_modules
+from facefusion.utilities import encode_execution_providers, decode_execution_providers
+
+EXECUTION_PROVIDERS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
+
+
+def render() -> None:
+	global EXECUTION_PROVIDERS_CHECKBOX_GROUP
+
+	EXECUTION_PROVIDERS_CHECKBOX_GROUP = gradio.CheckboxGroup(
+		label = wording.get('execution_providers_checkbox_group_label'),
+		choices = encode_execution_providers(onnxruntime.get_available_providers()),
+		value = encode_execution_providers(facefusion.globals.execution_providers)
+	)
+
+
+def listen() -> None:
+	EXECUTION_PROVIDERS_CHECKBOX_GROUP.change(update_execution_providers, inputs = EXECUTION_PROVIDERS_CHECKBOX_GROUP, outputs = EXECUTION_PROVIDERS_CHECKBOX_GROUP)
+
+
+def update_execution_providers(execution_providers : List[str]) -> gradio.CheckboxGroup:
+	clear_face_analyser()
+	clear_frame_processors_modules()
+	if not execution_providers:
+		execution_providers = encode_execution_providers(onnxruntime.get_available_providers())
+	facefusion.globals.execution_providers = decode_execution_providers(execution_providers)
+	return gradio.CheckboxGroup(value = execution_providers)

facefusion/uis/components/execution_queue_count.py

@@ -0,0 +1,28 @@
+from typing import Optional
+import gradio
+
+import facefusion.globals
+import facefusion.choices
+from facefusion import wording
+
+EXECUTION_QUEUE_COUNT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global EXECUTION_QUEUE_COUNT_SLIDER
+
+	EXECUTION_QUEUE_COUNT_SLIDER = gradio.Slider(
+		label = wording.get('execution_queue_count_slider_label'),
+		value = facefusion.globals.execution_queue_count,
+		step = facefusion.choices.execution_queue_count_range[1] - facefusion.choices.execution_queue_count_range[0],
+		minimum = facefusion.choices.execution_queue_count_range[0],
+		maximum = facefusion.choices.execution_queue_count_range[-1]
+	)
+
+
+def listen() -> None:
+	EXECUTION_QUEUE_COUNT_SLIDER.change(update_execution_queue_count, inputs = EXECUTION_QUEUE_COUNT_SLIDER)
+
+
+def update_execution_queue_count(execution_queue_count : int = 1) -> None:
+	facefusion.globals.execution_queue_count = execution_queue_count

facefusion/uis/components/execution_thread_count.py

@@ -0,0 +1,29 @@
+from typing import Optional
+import gradio
+
+import facefusion.globals
+import facefusion.choices
+from facefusion import wording
+
+EXECUTION_THREAD_COUNT_SLIDER : Optional[gradio.Slider] = None
+
+
+def render() -> None:
+	global EXECUTION_THREAD_COUNT_SLIDER
+
+	EXECUTION_THREAD_COUNT_SLIDER = gradio.Slider(
+		label = wording.get('execution_thread_count_slider_label'),
+		value = facefusion.globals.execution_thread_count,
+		step = facefusion.choices.execution_thread_count_range[1] - facefusion.choices.execution_thread_count_range[0],
+		minimum = facefusion.choices.execution_thread_count_range[0],
+		maximum = facefusion.choices.execution_thread_count_range[-1]
+	)
+
+
+def listen() -> None:
+	EXECUTION_THREAD_COUNT_SLIDER.change(update_execution_thread_count, inputs = EXECUTION_THREAD_COUNT_SLIDER)
+
+
+def update_execution_thread_count(execution_thread_count : int = 1) -> None:
+	facefusion.globals.execution_thread_count = execution_thread_count
+