feat: init

app.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+import os
+
+os.environ['OMP_NUM_THREADS'] = '1'
+
+from facefusion import core
+
+if __name__ == '__main__':
+	core.cli()

facefusion/app_context.py

@@ -0,0 +1,16 @@
+import os
+import sys
+
+from facefusion.typing import AppContext
+
+
+def detect_app_context() -> AppContext:
+	frame = sys._getframe(1)
+
+	while frame:
+		if os.path.join('facefusion', 'jobs') in frame.f_code.co_filename:
+			return 'cli'
+		if os.path.join('facefusion', 'uis') in frame.f_code.co_filename:
+			return 'ui'
+		frame = frame.f_back
+	return 'cli'

facefusion/args.py

@@ -0,0 +1,117 @@
+from facefusion import state_manager
+from facefusion.filesystem import is_image, is_video, list_directory
+from facefusion.jobs import job_store
+from facefusion.normalizer import normalize_fps, normalize_padding
+from facefusion.processors.core import get_processors_modules
+from facefusion.typing import ApplyStateItem, Args
+from facefusion.vision import create_image_resolutions, create_video_resolutions, detect_image_resolution, detect_video_fps, detect_video_resolution, pack_resolution
+
+
+def reduce_step_args(args : Args) -> Args:
+	step_args =\
+	{
+		key: args[key] for key in args if key in job_store.get_step_keys()
+	}
+	return step_args
+
+
+def collect_step_args() -> Args:
+	step_args =\
+	{
+		key: state_manager.get_item(key) for key in job_store.get_step_keys() #type:ignore[arg-type]
+	}
+	return step_args
+
+
+def collect_job_args() -> Args:
+	job_args =\
+	{
+		key: state_manager.get_item(key) for key in job_store.get_job_keys() #type:ignore[arg-type]
+	}
+	return job_args
+
+
+def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
+	# general
+	apply_state_item('command', args.get('command'))
+	# paths
+	apply_state_item('jobs_path', args.get('jobs_path'))
+	apply_state_item('source_paths', args.get('source_paths'))
+	apply_state_item('target_path', args.get('target_path'))
+	apply_state_item('output_path', args.get('output_path'))
+	# face detector
+	apply_state_item('face_detector_model', args.get('face_detector_model'))
+	apply_state_item('face_detector_size', args.get('face_detector_size'))
+	apply_state_item('face_detector_angles', args.get('face_detector_angles'))
+	apply_state_item('face_detector_score', args.get('face_detector_score'))
+	# face landmarker
+	apply_state_item('face_landmarker_model', args.get('face_landmarker_model'))
+	apply_state_item('face_landmarker_score', args.get('face_landmarker_score'))
+	# face selector
+	state_manager.init_item('face_selector_mode', args.get('face_selector_mode'))
+	state_manager.init_item('face_selector_order', args.get('face_selector_order'))
+	state_manager.init_item('face_selector_age_start', args.get('face_selector_age_start'))
+	state_manager.init_item('face_selector_age_end', args.get('face_selector_age_end'))
+	state_manager.init_item('face_selector_gender', args.get('face_selector_gender'))
+	state_manager.init_item('face_selector_race', args.get('face_selector_race'))
+	state_manager.init_item('reference_face_position', args.get('reference_face_position'))
+	state_manager.init_item('reference_face_distance', args.get('reference_face_distance'))
+	state_manager.init_item('reference_frame_number', args.get('reference_frame_number'))
+	# face masker
+	apply_state_item('face_mask_types', args.get('face_mask_types'))
+	apply_state_item('face_mask_blur', args.get('face_mask_blur'))
+	apply_state_item('face_mask_padding', normalize_padding(args.get('face_mask_padding')))
+	apply_state_item('face_mask_regions', args.get('face_mask_regions'))
+	# frame extraction
+	apply_state_item('trim_frame_start', args.get('trim_frame_start'))
+	apply_state_item('trim_frame_end', args.get('trim_frame_end'))
+	apply_state_item('temp_frame_format', args.get('temp_frame_format'))
+	apply_state_item('keep_temp', args.get('keep_temp'))
+	# output creation
+	apply_state_item('output_image_quality', args.get('output_image_quality'))
+	if is_image(args.get('target_path')):
+		output_image_resolution = detect_image_resolution(args.get('target_path'))
+		output_image_resolutions = create_image_resolutions(output_image_resolution)
+		if args.get('output_image_resolution') in output_image_resolutions:
+			apply_state_item('output_image_resolution', args.get('output_image_resolution'))
+		else:
+			apply_state_item('output_image_resolution', pack_resolution(output_image_resolution))
+	apply_state_item('output_audio_encoder', args.get('output_audio_encoder'))
+	apply_state_item('output_video_encoder', args.get('output_video_encoder'))
+	apply_state_item('output_video_preset', args.get('output_video_preset'))
+	apply_state_item('output_video_quality', args.get('output_video_quality'))
+	if is_video(args.get('target_path')):
+		output_video_resolution = detect_video_resolution(args.get('target_path'))
+		output_video_resolutions = create_video_resolutions(output_video_resolution)
+		if args.get('output_video_resolution') in output_video_resolutions:
+			apply_state_item('output_video_resolution', args.get('output_video_resolution'))
+		else:
+			apply_state_item('output_video_resolution', pack_resolution(output_video_resolution))
+	if args.get('output_video_fps') or is_video(args.get('target_path')):
+		output_video_fps = normalize_fps(args.get('output_video_fps')) or detect_video_fps(args.get('target_path'))
+		apply_state_item('output_video_fps', output_video_fps)
+	apply_state_item('skip_audio', args.get('skip_audio'))
+	# processors
+	available_processors = list_directory('facefusion/processors/modules')
+	apply_state_item('processors', args.get('processors'))
+	for processor_module in get_processors_modules(available_processors):
+		processor_module.apply_args(args, apply_state_item)
+	# uis
+	apply_state_item('open_browser', args.get('open_browser'))
+	apply_state_item('ui_layouts', args.get('ui_layouts'))
+	apply_state_item('ui_workflow', args.get('ui_workflow'))
+	# execution
+	apply_state_item('execution_device_id', args.get('execution_device_id'))
+	apply_state_item('execution_providers', args.get('execution_providers'))
+	apply_state_item('execution_thread_count', args.get('execution_thread_count'))
+	apply_state_item('execution_queue_count', args.get('execution_queue_count'))
+	# memory
+	apply_state_item('video_memory_strategy', args.get('video_memory_strategy'))
+	apply_state_item('system_memory_limit', args.get('system_memory_limit'))
+	# misc
+	apply_state_item('skip_download', args.get('skip_download'))
+	apply_state_item('log_level', args.get('log_level'))
+	# jobs
+	apply_state_item('job_id', args.get('job_id'))
+	apply_state_item('job_status', args.get('job_status'))
+	apply_state_item('step_index', args.get('step_index'))

facefusion/audio.py

@@ -0,0 +1,139 @@
+from functools import lru_cache
+from typing import Any, List, Optional
+
+import numpy
+import scipy
+from numpy._typing import NDArray
+
+from facefusion.ffmpeg import read_audio_buffer
+from facefusion.filesystem import is_audio
+from facefusion.typing import Audio, AudioFrame, Fps, Mel, MelFilterBank, Spectrogram
+from facefusion.voice_extractor import batch_extract_voice
+
+
+@lru_cache(maxsize = 128)
+def read_static_audio(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
+	return read_audio(audio_path, fps)
+
+
+def read_audio(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
+	sample_rate = 48000
+	channel_total = 2
+
+	if is_audio(audio_path):
+		audio_buffer = read_audio_buffer(audio_path, sample_rate, channel_total)
+		audio = numpy.frombuffer(audio_buffer, dtype = numpy.int16).reshape(-1, 2)
+		audio = prepare_audio(audio)
+		spectrogram = create_spectrogram(audio)
+		audio_frames = extract_audio_frames(spectrogram, fps)
+		return audio_frames
+	return None
+
+
+@lru_cache(maxsize = 128)
+def read_static_voice(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
+	return read_voice(audio_path, fps)
+
+
+def read_voice(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
+	sample_rate = 48000
+	channel_total = 2
+	chunk_size = 240 * 1024
+	step_size = 180 * 1024
+
+	if is_audio(audio_path):
+		audio_buffer = read_audio_buffer(audio_path, sample_rate, channel_total)
+		audio = numpy.frombuffer(audio_buffer, dtype = numpy.int16).reshape(-1, 2)
+		audio = batch_extract_voice(audio, chunk_size, step_size)
+		audio = prepare_voice(audio)
+		spectrogram = create_spectrogram(audio)
+		audio_frames = extract_audio_frames(spectrogram, fps)
+		return audio_frames
+	return None
+
+
+def get_audio_frame(audio_path : str, fps : Fps, frame_number : int = 0) -> Optional[AudioFrame]:
+	if is_audio(audio_path):
+		audio_frames = read_static_audio(audio_path, fps)
+		if frame_number in range(len(audio_frames)):
+			return audio_frames[frame_number]
+	return None
+
+
+def get_voice_frame(audio_path : str, fps : Fps, frame_number : int = 0) -> Optional[AudioFrame]:
+	if is_audio(audio_path):
+		voice_frames = read_static_voice(audio_path, fps)
+		if frame_number in range(len(voice_frames)):
+			return voice_frames[frame_number]
+	return None
+
+
+def create_empty_audio_frame() -> AudioFrame:
+	mel_filter_total = 80
+	step_size = 16
+	audio_frame = numpy.zeros((mel_filter_total, step_size)).astype(numpy.int16)
+	return audio_frame
+
+
+def prepare_audio(audio : Audio) -> Audio:
+	if audio.ndim > 1:
+		audio = numpy.mean(audio, axis = 1)
+	audio = audio / numpy.max(numpy.abs(audio), axis = 0)
+	audio = scipy.signal.lfilter([ 1.0, -0.97 ], [ 1.0 ], audio)
+	return audio
+
+
+def prepare_voice(audio : Audio) -> Audio:
+	sample_rate = 48000
+	resample_rate = 16000
+
+	audio = scipy.signal.resample(audio, int(len(audio) * resample_rate / sample_rate))
+	audio = prepare_audio(audio)
+	return audio
+
+
+def convert_hertz_to_mel(hertz : float) -> float:
+	return 2595 * numpy.log10(1 + hertz / 700)
+
+
+def convert_mel_to_hertz(mel : Mel) -> NDArray[Any]:
+	return 700 * (10 ** (mel / 2595) - 1)
+
+
+def create_mel_filter_bank() -> MelFilterBank:
+	mel_filter_total = 80
+	mel_bin_total = 800
+	sample_rate = 16000
+	min_frequency = 55.0
+	max_frequency = 7600.0
+	mel_filter_bank = numpy.zeros((mel_filter_total, mel_bin_total // 2 + 1))
+	mel_frequency_range = numpy.linspace(convert_hertz_to_mel(min_frequency), convert_hertz_to_mel(max_frequency), mel_filter_total + 2)
+	indices = numpy.floor((mel_bin_total + 1) * convert_mel_to_hertz(mel_frequency_range) / sample_rate).astype(numpy.int16)
+
+	for index in range(mel_filter_total):
+		start = indices[index]
+		end = indices[index + 1]
+		mel_filter_bank[index, start:end] = scipy.signal.windows.triang(end - start)
+	return mel_filter_bank
+
+
+def create_spectrogram(audio : Audio) -> Spectrogram:
+	mel_bin_total = 800
+	mel_bin_overlap = 600
+	mel_filter_bank = create_mel_filter_bank()
+	spectrogram = scipy.signal.stft(audio, nperseg = mel_bin_total, nfft = mel_bin_total, noverlap = mel_bin_overlap)[2]
+	spectrogram = numpy.dot(mel_filter_bank, numpy.abs(spectrogram))
+	return spectrogram
+
+
+def extract_audio_frames(spectrogram : Spectrogram, fps : Fps) -> List[AudioFrame]:
+	mel_filter_total = 80
+	step_size = 16
+	audio_frames = []
+	indices = numpy.arange(0, spectrogram.shape[1], mel_filter_total / fps).astype(numpy.int16)
+	indices = indices[indices >= step_size]
+
+	for index in indices:
+		start = max(0, index - step_size)
+		audio_frames.append(spectrogram[:, start:index])
+	return audio_frames

facefusion/choices.py

@@ -0,0 +1,64 @@
+import logging
+from typing import List, Sequence
+
+from facefusion.common_helper import create_float_range, create_int_range
+from facefusion.typing import Angle, ExecutionProviderSet, FaceDetectorSet, FaceLandmarkerModel, FaceMaskRegion, FaceMaskType, FaceSelectorMode, FaceSelectorOrder, Gender, JobStatus, LogLevelSet, OutputAudioEncoder, OutputVideoEncoder, OutputVideoPreset, Race, Score, TempFrameFormat, UiWorkflow, VideoMemoryStrategy
+
+video_memory_strategies : List[VideoMemoryStrategy] = [ 'strict', 'moderate', 'tolerant' ]
+
+face_detector_set : FaceDetectorSet =\
+{
+	'many': [ '640x640' ],
+	'retinaface': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'scrfd': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'yoloface': [ '640x640' ]
+}
+face_landmarker_models : List[FaceLandmarkerModel] = [ 'many', '2dfan4', 'peppa_wutz' ]
+face_selector_modes : List[FaceSelectorMode] = [ 'many', 'one', 'reference' ]
+face_selector_orders : List[FaceSelectorOrder] = [ 'left-right', 'right-left', 'top-bottom', 'bottom-top', 'small-large', 'large-small', 'best-worst', 'worst-best' ]
+face_selector_genders : List[Gender] = ['female', 'male']
+face_selector_races : List[Race] = ['white', 'black', 'latino', 'asian', 'indian', 'arabic']
+face_mask_types : List[FaceMaskType] = [ 'box', 'occlusion', 'region' ]
+face_mask_regions : List[FaceMaskRegion] = [ 'skin', 'left-eyebrow', 'right-eyebrow', 'left-eye', 'right-eye', 'glasses', 'nose', 'mouth', 'upper-lip', 'lower-lip' ]
+temp_frame_formats : List[TempFrameFormat] = [ 'bmp', 'jpg', 'png' ]
+output_audio_encoders : List[OutputAudioEncoder] = [ 'aac', 'libmp3lame', 'libopus', 'libvorbis' ]
+output_video_encoders : List[OutputVideoEncoder] = [ 'libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf', 'h264_videotoolbox', 'hevc_videotoolbox' ]
+output_video_presets : List[OutputVideoPreset] = [ 'ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow' ]
+
+image_template_sizes : List[float] = [ 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 3.5, 4 ]
+video_template_sizes : List[int] = [ 240, 360, 480, 540, 720, 1080, 1440, 2160, 4320 ]
+
+log_level_set : LogLevelSet =\
+{
+	'error': logging.ERROR,
+	'warn': logging.WARNING,
+	'info': logging.INFO,
+	'debug': logging.DEBUG
+}
+
+execution_provider_set : ExecutionProviderSet =\
+{
+	'cpu': 'CPUExecutionProvider',
+	'coreml': 'CoreMLExecutionProvider',
+	'cuda': 'CUDAExecutionProvider',
+	'directml': 'DmlExecutionProvider',
+	'openvino': 'OpenVINOExecutionProvider',
+	'rocm': 'ROCMExecutionProvider',
+	'tensorrt': 'TensorrtExecutionProvider'
+}
+
+ui_workflows : List[UiWorkflow] = [ 'instant_runner', 'job_runner', 'job_manager' ]
+job_statuses : List[JobStatus] = [ 'drafted', 'queued', 'completed', 'failed' ]
+
+execution_thread_count_range : Sequence[int] = create_int_range(1, 32, 1)
+execution_queue_count_range : Sequence[int] = create_int_range(1, 4, 1)
+system_memory_limit_range : Sequence[int] = create_int_range(0, 128, 4)
+face_detector_angles : Sequence[Angle] = create_int_range(0, 270, 90)
+face_detector_score_range : Sequence[Score] = create_float_range(0.0, 1.0, 0.05)
+face_landmarker_score_range : Sequence[Score] = create_float_range(0.0, 1.0, 0.05)
+face_mask_blur_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
+face_mask_padding_range : Sequence[int] = create_int_range(0, 100, 1)
+face_selector_age_range : Sequence[int] = create_int_range(0, 100, 1)
+reference_face_distance_range : Sequence[float] = create_float_range(0.0, 1.5, 0.05)
+output_image_quality_range : Sequence[int] = create_int_range(0, 100, 1)
+output_video_quality_range : Sequence[int] = create_int_range(0, 100, 1)

facefusion/common_helper.py

@@ -0,0 +1,72 @@
+import platform
+from typing import Any, Optional, Sequence
+
+
+def is_linux() -> bool:
+	return platform.system().lower() == 'linux'
+
+
+def is_macos() -> bool:
+	return platform.system().lower() == 'darwin'
+
+
+def is_windows() -> bool:
+	return platform.system().lower() == 'windows'
+
+
+def create_int_metavar(int_range : Sequence[int]) -> str:
+	return '[' + str(int_range[0]) + '..' + str(int_range[-1]) + ':' + str(calc_int_step(int_range)) + ']'
+
+
+def create_float_metavar(float_range : Sequence[float]) -> str:
+	return '[' + str(float_range[0]) + '..' + str(float_range[-1]) + ':' + str(calc_float_step(float_range)) + ']'
+
+
+def create_int_range(start : int, end : int, step : int) -> Sequence[int]:
+	int_range = []
+	current = start
+
+	while current <= end:
+		int_range.append(current)
+		current += step
+	return int_range
+
+
+def create_float_range(start : float, end : float, step : float) -> Sequence[float]:
+	float_range = []
+	current = start
+
+	while current <= end:
+		float_range.append(round(current, 2))
+		current = round(current + step, 2)
+	return float_range
+
+
+def calc_int_step(int_range : Sequence[int]) -> int:
+	return int_range[1] - int_range[0]
+
+
+def calc_float_step(float_range : Sequence[float]) -> float:
+	return round(float_range[1] - float_range[0], 2)
+
+
+def cast_int(value : Any) -> Optional[Any]:
+	try:
+		return int(value)
+	except (ValueError, TypeError):
+		return None
+
+
+def cast_float(value : Any) -> Optional[Any]:
+	try:
+		return float(value)
+	except (ValueError, TypeError):
+		return None
+
+
+def get_first(__list__ : Any) -> Any:
+	return next(iter(__list__), None)
+
+
+def get_last(__list__ : Any) -> Any:
+	return next(reversed(__list__), None)

facefusion/config.py

@@ -0,0 +1,92 @@
+from configparser import ConfigParser
+from typing import Any, List, Optional
+
+from facefusion import state_manager
+from facefusion.common_helper import cast_float, cast_int
+
+CONFIG = None
+
+
+def get_config() -> ConfigParser:
+	global CONFIG
+
+	if CONFIG is None:
+		CONFIG = ConfigParser()
+		CONFIG.read(state_manager.get_item('config_path'), encoding = 'utf-8')
+	return CONFIG
+
+
+def clear_config() -> None:
+	global CONFIG
+
+	CONFIG = None
+
+
+def get_str_value(key : str, fallback : Optional[str] = None) -> Optional[str]:
+	value = get_value_by_notation(key)
+
+	if value or fallback:
+		return str(value or fallback)
+	return None
+
+
+def get_int_value(key : str, fallback : Optional[str] = None) -> Optional[int]:
+	value = get_value_by_notation(key)
+
+	if value or fallback:
+		return cast_int(value or fallback)
+	return None
+
+
+def get_float_value(key : str, fallback : Optional[str] = None) -> Optional[float]:
+	value = get_value_by_notation(key)
+
+	if value or fallback:
+		return cast_float(value or fallback)
+	return None
+
+
+def get_bool_value(key : str, fallback : Optional[str] = None) -> Optional[bool]:
+	value = get_value_by_notation(key)
+
+	if value == 'True' or fallback == 'True':
+		return True
+	if value == 'False' or fallback == 'False':
+		return False
+	return None
+
+
+def get_str_list(key : str, fallback : Optional[str] = None) -> Optional[List[str]]:
+	value = get_value_by_notation(key)
+
+	if value or fallback:
+		return [ str(value) for value in (value or fallback).split(' ') ]
+	return None
+
+
+def get_int_list(key : str, fallback : Optional[str] = None) -> Optional[List[int]]:
+	value = get_value_by_notation(key)
+
+	if value or fallback:
+		return [ cast_int(value) for value in (value or fallback).split(' ') ]
+	return None
+
+
+def get_float_list(key : str, fallback : Optional[str] = None) -> Optional[List[float]]:
+	value = get_value_by_notation(key)
+
+	if value or fallback:
+		return [ cast_float(value) for value in (value or fallback).split(' ') ]
+	return None
+
+
+def get_value_by_notation(key : str) -> Optional[Any]:
+	config = get_config()
+
+	if '.' in key:
+		section, name = key.split('.')
+		if section in config and name in config[section]:
+			return config[section][name]
+	if key in config:
+		return config[key]
+	return None

facefusion/content_analyser.py

@@ -0,0 +1,124 @@
+from functools import lru_cache
+
+import cv2
+import numpy
+from tqdm import tqdm
+
+from facefusion import inference_manager, state_manager, wording
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.typing import Fps, InferencePool, ModelOptions, ModelSet, VisionFrame
+from facefusion.vision import count_video_frame_total, detect_video_fps, get_video_frame, read_image
+
+MODEL_SET : ModelSet =\
+{
+	'open_nsfw':
+	{
+		'hashes':
+		{
+			'content_analyser':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/open_nsfw.hash',
+				'path': resolve_relative_path('../.assets/models/open_nsfw.hash')
+			}
+		},
+		'sources':
+		{
+			'content_analyser':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/open_nsfw.onnx',
+				'path': resolve_relative_path('../.assets/models/open_nsfw.onnx')
+			}
+		},
+		'size': (224, 224),
+		'mean': [ 104, 117, 123 ]
+	}
+}
+PROBABILITY_LIMIT = 0.80
+RATE_LIMIT = 10
+STREAM_COUNTER = 0
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def get_model_options() -> ModelOptions:
+	return MODEL_SET.get('open_nsfw')
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def analyse_stream(vision_frame : VisionFrame, video_fps : Fps) -> bool:
+	global STREAM_COUNTER
+
+	STREAM_COUNTER = STREAM_COUNTER + 1
+	if STREAM_COUNTER % int(video_fps) == 0:
+		return analyse_frame(vision_frame)
+	return False
+
+
+def analyse_frame(vision_frame : VisionFrame) -> bool:
+	vision_frame = prepare_frame(vision_frame)
+	probability = forward(vision_frame)
+
+	return probability > PROBABILITY_LIMIT
+
+
+def forward(vision_frame : VisionFrame) -> float:
+	content_analyser = get_inference_pool().get('content_analyser')
+
+	with conditional_thread_semaphore():
+		probability = content_analyser.run(None,
+		{
+			'input': vision_frame
+		})[0][0][1]
+
+	return probability
+
+
+def prepare_frame(vision_frame : VisionFrame) -> VisionFrame:
+	model_size = get_model_options().get('size')
+	model_mean = get_model_options().get('mean')
+	vision_frame = cv2.resize(vision_frame, model_size).astype(numpy.float32)
+	vision_frame -= numpy.array(model_mean).astype(numpy.float32)
+	vision_frame = numpy.expand_dims(vision_frame, axis = 0)
+	return vision_frame
+
+
+@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)
+	video_fps = detect_video_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 = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
+		for frame_number in frame_range:
+			if frame_number % int(video_fps) == 0:
+				frame = get_video_frame(video_path, frame_number)
+				if analyse_frame(frame):
+					counter += 1
+			rate = counter * int(video_fps) / len(frame_range) * 100
+			progress.update()
+			progress.set_postfix(rate = rate)
+	return rate > RATE_LIMIT

facefusion/core.py

@@ -0,0 +1,445 @@
+import shutil
+import signal
+import sys
+from time import time
+
+import numpy
+
+from facefusion import content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, logger, process_manager, state_manager, voice_extractor, wording
+from facefusion.args import apply_args, collect_job_args, reduce_step_args
+from facefusion.common_helper import get_first
+from facefusion.content_analyser import analyse_image, analyse_video
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.exit_helper import conditional_exit, graceful_exit, hard_exit
+from facefusion.face_analyser import get_average_face, get_many_faces, get_one_face
+from facefusion.face_selector import sort_and_filter_faces
+from facefusion.face_store import append_reference_face, clear_reference_faces, get_reference_faces
+from facefusion.ffmpeg import copy_image, extract_frames, finalize_image, merge_video, replace_audio, restore_audio
+from facefusion.filesystem import filter_audio_paths, is_image, is_video, list_directory, resolve_relative_path
+from facefusion.jobs import job_helper, job_manager, job_runner
+from facefusion.jobs.job_list import compose_job_list
+from facefusion.memory import limit_system_memory
+from facefusion.processors.core import get_processors_modules
+from facefusion.program import create_program
+from facefusion.program_helper import validate_args
+from facefusion.statistics import conditional_log_statistics
+from facefusion.temp_helper import clear_temp_directory, create_temp_directory, get_temp_file_path, get_temp_frame_paths, move_temp_file
+from facefusion.typing import Args, ErrorCode
+from facefusion.vision import get_video_frame, pack_resolution, read_image, read_static_images, restrict_image_resolution, restrict_video_fps, restrict_video_resolution, unpack_resolution
+
+
+def cli() -> None:
+	signal.signal(signal.SIGINT, lambda signal_number, frame: graceful_exit(0))
+	program = create_program()
+
+	if validate_args(program):
+		args = vars(program.parse_args())
+		apply_args(args, state_manager.init_item)
+
+		if state_manager.get_item('command'):
+			logger.init(state_manager.get_item('log_level'))
+			route(args)
+		else:
+			program.print_help()
+
+
+def route(args : Args) -> None:
+	system_memory_limit = state_manager.get_item('system_memory_limit')
+	if system_memory_limit and system_memory_limit > 0:
+		limit_system_memory(system_memory_limit)
+	if state_manager.get_item('command') == 'force-download':
+		error_code = force_download()
+		return conditional_exit(error_code)
+	if state_manager.get_item('command') in [ 'job-list', 'job-create', 'job-submit', 'job-submit-all', 'job-delete', 'job-delete-all', 'job-add-step', 'job-remix-step', 'job-insert-step', 'job-remove-step' ]:
+		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+			hard_exit(1)
+		error_code = route_job_manager(args)
+		hard_exit(error_code)
+	if not pre_check():
+		return conditional_exit(2)
+	if state_manager.get_item('command') == 'run':
+		import facefusion.uis.core as ui
+
+		if not common_pre_check() or not processors_pre_check():
+			return conditional_exit(2)
+		for ui_layout in ui.get_ui_layouts_modules(state_manager.get_item('ui_layouts')):
+			if not ui_layout.pre_check():
+				return conditional_exit(2)
+		ui.launch()
+	if state_manager.get_item('command') == 'headless-run':
+		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+			hard_exit(1)
+		error_core = process_headless(args)
+		hard_exit(error_core)
+	if state_manager.get_item('command') in [ 'job-run', 'job-run-all', 'job-retry', 'job-retry-all' ]:
+		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+			hard_exit(1)
+		error_code = route_job_runner()
+		hard_exit(error_code)
+
+
+def pre_check() -> bool:
+	if sys.version_info < (3, 9):
+		logger.error(wording.get('python_not_supported').format(version = '3.9'), __name__)
+		return False
+	if not shutil.which('curl'):
+		logger.error(wording.get('curl_not_installed'), __name__)
+		return False
+	if not shutil.which('ffmpeg'):
+		logger.error(wording.get('ffmpeg_not_installed'), __name__)
+		return False
+	return True
+
+
+def common_pre_check() -> bool:
+	modules =\
+	[
+		content_analyser,
+		face_classifier,
+		face_detector,
+		face_landmarker,
+		face_masker,
+		face_recognizer,
+		voice_extractor
+	]
+
+	return all(module.pre_check() for module in modules)
+
+
+def processors_pre_check() -> bool:
+	for processor_module in get_processors_modules(state_manager.get_item('processors')):
+		if not processor_module.pre_check():
+			return False
+	return True
+
+
+def conditional_process() -> ErrorCode:
+	start_time = time()
+	for processor_module in get_processors_modules(state_manager.get_item('processors')):
+		if not processor_module.pre_process('output'):
+			return 2
+	conditional_append_reference_faces()
+	if is_image(state_manager.get_item('target_path')):
+		return process_image(start_time)
+	if is_video(state_manager.get_item('target_path')):
+		return process_video(start_time)
+	return 0
+
+
+def conditional_append_reference_faces() -> None:
+	if 'reference' in state_manager.get_item('face_selector_mode') and not get_reference_faces():
+		source_frames = read_static_images(state_manager.get_item('source_paths'))
+		source_faces = get_many_faces(source_frames)
+		source_face = get_average_face(source_faces)
+		if is_video(state_manager.get_item('target_path')):
+			reference_frame = get_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+		else:
+			reference_frame = read_image(state_manager.get_item('target_path'))
+		reference_faces = sort_and_filter_faces(get_many_faces([ reference_frame ]))
+		reference_face = get_one_face(reference_faces, state_manager.get_item('reference_face_position'))
+		append_reference_face('origin', reference_face)
+
+		if source_face and reference_face:
+			for processor_module in get_processors_modules(state_manager.get_item('processors')):
+				abstract_reference_frame = processor_module.get_reference_frame(source_face, reference_face, reference_frame)
+				if numpy.any(abstract_reference_frame):
+					abstract_reference_faces = sort_and_filter_faces(get_many_faces([ abstract_reference_frame ]))
+					abstract_reference_face = get_one_face(abstract_reference_faces, state_manager.get_item('reference_face_position'))
+					append_reference_face(processor_module.__name__, abstract_reference_face)
+
+
+def force_download() -> ErrorCode:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	available_processors = list_directory('facefusion/processors/modules')
+	common_modules =\
+	[
+		content_analyser,
+		face_classifier,
+		face_detector,
+		face_landmarker,
+		face_recognizer,
+		face_masker,
+		voice_extractor
+	]
+	processor_modules = get_processors_modules(available_processors)
+
+	for module in common_modules + processor_modules:
+		if hasattr(module, 'MODEL_SET'):
+			for model in module.MODEL_SET.values():
+				model_hashes = model.get('hashes')
+				model_sources = model.get('sources')
+
+				if model_hashes and model_sources:
+					if not conditional_download_hashes(download_directory_path, model_hashes) or not conditional_download_sources(download_directory_path, model_sources):
+						return 1
+
+	return 0
+
+
+def route_job_manager(args : Args) -> ErrorCode:
+	if state_manager.get_item('command') == 'job-list':
+		job_headers, job_contents = compose_job_list(state_manager.get_item('job_status'))
+
+		if job_contents:
+			logger.table(job_headers, job_contents)
+			return 0
+		return 1
+	if state_manager.get_item('command') == 'job-create':
+		if job_manager.create_job(state_manager.get_item('job_id')):
+			logger.info(wording.get('job_created').format(job_id = state_manager.get_item('job_id')), __name__)
+			return 0
+		logger.error(wording.get('job_not_created').format(job_id = state_manager.get_item('job_id')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-submit':
+		if job_manager.submit_job(state_manager.get_item('job_id')):
+			logger.info(wording.get('job_submitted').format(job_id = state_manager.get_item('job_id')), __name__)
+			return 0
+		logger.error(wording.get('job_not_submitted').format(job_id = state_manager.get_item('job_id')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-submit-all':
+		if job_manager.submit_jobs():
+			logger.info(wording.get('job_all_submitted'), __name__)
+			return 0
+		logger.error(wording.get('job_all_not_submitted'), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-delete':
+		if job_manager.delete_job(state_manager.get_item('job_id')):
+			logger.info(wording.get('job_deleted').format(job_id = state_manager.get_item('job_id')), __name__)
+			return 0
+		logger.error(wording.get('job_not_deleted').format(job_id = state_manager.get_item('job_id')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-delete-all':
+		if job_manager.delete_jobs():
+			logger.info(wording.get('job_all_deleted'), __name__)
+			return 0
+		logger.error(wording.get('job_all_not_deleted'), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-add-step':
+		step_args = reduce_step_args(args)
+
+		if job_manager.add_step(state_manager.get_item('job_id'), step_args):
+			logger.info(wording.get('job_step_added').format(job_id = state_manager.get_item('job_id')), __name__)
+			return 0
+		logger.error(wording.get('job_step_not_added').format(job_id = state_manager.get_item('job_id')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-remix-step':
+		step_args = reduce_step_args(args)
+
+		if job_manager.remix_step(state_manager.get_item('job_id'), state_manager.get_item('step_index'), step_args):
+			logger.info(wording.get('job_remix_step_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
+			return 0
+		logger.error(wording.get('job_remix_step_not_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-insert-step':
+		step_args = reduce_step_args(args)
+
+		if job_manager.insert_step(state_manager.get_item('job_id'), state_manager.get_item('step_index'), step_args):
+			logger.info(wording.get('job_step_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
+			return 0
+		logger.error(wording.get('job_step_not_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-remove-step':
+		if job_manager.remove_step(state_manager.get_item('job_id'), state_manager.get_item('step_index')):
+			logger.info(wording.get('job_step_removed').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
+			return 0
+		logger.error(wording.get('job_step_not_removed').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
+		return 1
+	return 1
+
+
+def route_job_runner() -> ErrorCode:
+	if state_manager.get_item('command') == 'job-run':
+		logger.info(wording.get('running_job').format(job_id = state_manager.get_item('job_id')), __name__)
+		if job_runner.run_job(state_manager.get_item('job_id'), process_step):
+			logger.info(wording.get('processing_job_succeed').format(job_id = state_manager.get_item('job_id')), __name__)
+			return 0
+		logger.info(wording.get('processing_job_failed').format(job_id = state_manager.get_item('job_id')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-run-all':
+		logger.info(wording.get('running_jobs'), __name__)
+		if job_runner.run_jobs(process_step):
+			logger.info(wording.get('processing_jobs_succeed'), __name__)
+			return 0
+		logger.info(wording.get('processing_jobs_failed'), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-retry':
+		logger.info(wording.get('retrying_job').format(job_id = state_manager.get_item('job_id')), __name__)
+		if job_runner.retry_job(state_manager.get_item('job_id'), process_step):
+			logger.info(wording.get('processing_job_succeed').format(job_id = state_manager.get_item('job_id')), __name__)
+			return 0
+		logger.info(wording.get('processing_job_failed').format(job_id = state_manager.get_item('job_id')), __name__)
+		return 1
+	if state_manager.get_item('command') == 'job-retry-all':
+		logger.info(wording.get('retrying_jobs'), __name__)
+		if job_runner.retry_jobs(process_step):
+			logger.info(wording.get('processing_jobs_succeed'), __name__)
+			return 0
+		logger.info(wording.get('processing_jobs_failed'), __name__)
+		return 1
+	return 2
+
+
+def process_step(job_id : str, step_index : int, step_args : Args) -> bool:
+	clear_reference_faces()
+	step_total = job_manager.count_step_total(job_id)
+	step_args.update(collect_job_args())
+	apply_args(step_args, state_manager.set_item)
+
+	logger.info(wording.get('processing_step').format(step_current = step_index + 1, step_total = step_total), __name__)
+	if common_pre_check() and processors_pre_check():
+		error_code = conditional_process()
+		return error_code == 0
+	return False
+
+
+def process_headless(args : Args) -> ErrorCode:
+	job_id = job_helper.suggest_job_id('headless')
+	step_args = reduce_step_args(args)
+
+	if job_manager.create_job(job_id) and job_manager.add_step(job_id, step_args) and job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step):
+		return 0
+	return 1
+
+
+def process_image(start_time : float) -> ErrorCode:
+	if analyse_image(state_manager.get_item('target_path')):
+		return 3
+	# clear temp
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+	# create temp
+	logger.debug(wording.get('creating_temp'), __name__)
+	create_temp_directory(state_manager.get_item('target_path'))
+	# copy image
+	process_manager.start()
+	temp_image_resolution = pack_resolution(restrict_image_resolution(state_manager.get_item('target_path'), unpack_resolution(state_manager.get_item('output_image_resolution'))))
+	logger.info(wording.get('copying_image').format(resolution = temp_image_resolution), __name__)
+	if copy_image(state_manager.get_item('target_path'), temp_image_resolution):
+		logger.debug(wording.get('copying_image_succeed'), __name__)
+	else:
+		logger.error(wording.get('copying_image_failed'), __name__)
+		process_manager.end()
+		return 1
+	# process image
+	temp_file_path = get_temp_file_path(state_manager.get_item('target_path'))
+	for processor_module in get_processors_modules(state_manager.get_item('processors')):
+		logger.info(wording.get('processing'), processor_module.__name__)
+		processor_module.process_image(state_manager.get_item('source_paths'), temp_file_path, temp_file_path)
+		processor_module.post_process()
+	if is_process_stopping():
+		process_manager.end()
+		return 4
+	# finalize image
+	logger.info(wording.get('finalizing_image').format(resolution = state_manager.get_item('output_image_resolution')), __name__)
+	if finalize_image(state_manager.get_item('target_path'), state_manager.get_item('output_path'), state_manager.get_item('output_image_resolution')):
+		logger.debug(wording.get('finalizing_image_succeed'), __name__)
+	else:
+		logger.warn(wording.get('finalizing_image_skipped'), __name__)
+	# clear temp
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+	# validate image
+	if is_image(state_manager.get_item('output_path')):
+		seconds = '{:.2f}'.format((time() - start_time) % 60)
+		logger.info(wording.get('processing_image_succeed').format(seconds = seconds), __name__)
+		conditional_log_statistics()
+	else:
+		logger.error(wording.get('processing_image_failed'), __name__)
+		process_manager.end()
+		return 1
+	process_manager.end()
+	return 0
+
+
+def process_video(start_time : float) -> ErrorCode:
+	if analyse_video(state_manager.get_item('target_path'), state_manager.get_item('trim_frame_start'), state_manager.get_item('trim_frame_end')):
+		return 3
+	# clear temp
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+	# create temp
+	logger.debug(wording.get('creating_temp'), __name__)
+	create_temp_directory(state_manager.get_item('target_path'))
+	# extract frames
+	process_manager.start()
+	temp_video_resolution = pack_resolution(restrict_video_resolution(state_manager.get_item('target_path'), unpack_resolution(state_manager.get_item('output_video_resolution'))))
+	temp_video_fps = restrict_video_fps(state_manager.get_item('target_path'), state_manager.get_item('output_video_fps'))
+	logger.info(wording.get('extracting_frames').format(resolution = temp_video_resolution, fps = temp_video_fps), __name__)
+	if extract_frames(state_manager.get_item('target_path'), temp_video_resolution, temp_video_fps):
+		logger.debug(wording.get('extracting_frames_succeed'), __name__)
+	else:
+		if is_process_stopping():
+			process_manager.end()
+			return 4
+		logger.error(wording.get('extracting_frames_failed'), __name__)
+		process_manager.end()
+		return 1
+	# process frames
+	temp_frame_paths = get_temp_frame_paths(state_manager.get_item('target_path'))
+	if temp_frame_paths:
+		for processor_module in get_processors_modules(state_manager.get_item('processors')):
+			logger.info(wording.get('processing'), processor_module.__name__)
+			processor_module.process_video(state_manager.get_item('source_paths'), temp_frame_paths)
+			processor_module.post_process()
+		if is_process_stopping():
+			return 4
+	else:
+		logger.error(wording.get('temp_frames_not_found'), __name__)
+		process_manager.end()
+		return 1
+	# merge video
+	logger.info(wording.get('merging_video').format(resolution = state_manager.get_item('output_video_resolution'), fps = state_manager.get_item('output_video_fps')), __name__)
+	if merge_video(state_manager.get_item('target_path'), state_manager.get_item('output_video_resolution'), state_manager.get_item('output_video_fps')):
+		logger.debug(wording.get('merging_video_succeed'), __name__)
+	else:
+		if is_process_stopping():
+			process_manager.end()
+			return 4
+		logger.error(wording.get('merging_video_failed'), __name__)
+		process_manager.end()
+		return 1
+	# handle audio
+	if state_manager.get_item('skip_audio'):
+		logger.info(wording.get('skipping_audio'), __name__)
+		move_temp_file(state_manager.get_item('target_path'), state_manager.get_item('output_path'))
+	else:
+		source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
+		if source_audio_path:
+			if replace_audio(state_manager.get_item('target_path'), source_audio_path, state_manager.get_item('output_path')):
+				logger.debug(wording.get('replacing_audio_succeed'), __name__)
+			else:
+				if is_process_stopping():
+					process_manager.end()
+					return 4
+				logger.warn(wording.get('replacing_audio_skipped'), __name__)
+				move_temp_file(state_manager.get_item('target_path'), state_manager.get_item('output_path'))
+		else:
+			if restore_audio(state_manager.get_item('target_path'), state_manager.get_item('output_path'), state_manager.get_item('output_video_fps')):
+				logger.debug(wording.get('restoring_audio_succeed'), __name__)
+			else:
+				if is_process_stopping():
+					process_manager.end()
+					return 4
+				logger.warn(wording.get('restoring_audio_skipped'), __name__)
+				move_temp_file(state_manager.get_item('target_path'), state_manager.get_item('output_path'))
+	# clear temp
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+	# validate video
+	if is_video(state_manager.get_item('output_path')):
+		seconds = '{:.2f}'.format((time() - start_time))
+		logger.info(wording.get('processing_video_succeed').format(seconds = seconds), __name__)
+		conditional_log_statistics()
+	else:
+		logger.error(wording.get('processing_video_failed'), __name__)
+		process_manager.end()
+		return 1
+	process_manager.end()
+	return 0
+
+
+def is_process_stopping() -> bool:
+	if process_manager.is_stopping():
+		process_manager.end()
+		logger.info(wording.get('processing_stopped'), __name__)
+	return process_manager.is_pending()

facefusion/date_helper.py

@@ -0,0 +1,28 @@
+from datetime import datetime, timedelta
+from typing import Optional, Tuple
+
+from facefusion import wording
+
+
+def get_current_date_time() -> datetime:
+	return datetime.now().astimezone()
+
+
+def split_time_delta(time_delta : timedelta) -> Tuple[int, int, int, int]:
+	days, hours = divmod(time_delta.total_seconds(), 86400)
+	hours, minutes = divmod(hours, 3600)
+	minutes, seconds = divmod(minutes, 60)
+	return int(days), int(hours), int(minutes), int(seconds)
+
+
+def describe_time_ago(date_time : datetime) -> Optional[str]:
+	time_ago = datetime.now(date_time.tzinfo) - date_time
+	days, hours, minutes, _ = split_time_delta(time_ago)
+
+	if timedelta(days = 1) < time_ago:
+		return wording.get('time_ago_days').format(days = days, hours = hours, minutes = minutes)
+	if timedelta(hours = 1) < time_ago:
+		return wording.get('time_ago_hours').format(hours = hours, minutes = minutes)
+	if timedelta(minutes = 1) < time_ago:
+		return wording.get('time_ago_minutes').format(minutes = minutes)
+	return wording.get('time_ago_now')

facefusion/download.py

@@ -0,0 +1,131 @@
+import os
+import shutil
+import ssl
+import subprocess
+import urllib.request
+from functools import lru_cache
+from typing import List, Tuple
+from urllib.parse import urlparse
+
+from tqdm import tqdm
+
+from facefusion import logger, process_manager, state_manager, wording
+from facefusion.common_helper import is_macos
+from facefusion.filesystem import get_file_size, is_file, remove_file
+from facefusion.hash_helper import validate_hash
+from facefusion.typing import DownloadSet
+
+if is_macos():
+	ssl._create_default_https_context = ssl._create_unverified_context
+
+
+def conditional_download(download_directory_path : str, urls : List[str]) -> None:
+	for url in urls:
+		download_file_name = os.path.basename(urlparse(url).path)
+		download_file_path = os.path.join(download_directory_path, download_file_name)
+		initial_size = get_file_size(download_file_path)
+		download_size = get_download_size(url)
+
+		if initial_size < download_size:
+			with tqdm(total = download_size, initial = initial_size, desc = wording.get('downloading'), unit = 'B', unit_scale = True, unit_divisor = 1024, ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
+				subprocess.Popen([ shutil.which('curl'), '--create-dirs', '--silent', '--insecure', '--location', '--continue-at', '-', '--output', download_file_path, url ])
+				current_size = initial_size
+
+				progress.set_postfix(file = download_file_name)
+				while current_size < download_size:
+					if is_file(download_file_path):
+						current_size = get_file_size(download_file_path)
+						progress.update(current_size - progress.n)
+
+
+@lru_cache(maxsize = None)
+def get_download_size(url : str) -> int:
+	try:
+		response = urllib.request.urlopen(url, timeout = 10)
+		content_length = response.headers.get('Content-Length')
+		return int(content_length)
+	except (OSError, TypeError, ValueError):
+		return 0
+
+
+def is_download_done(url : str, file_path : str) -> bool:
+	if is_file(file_path):
+		return get_download_size(url) == get_file_size(file_path)
+	return False
+
+
+def conditional_download_hashes(download_directory_path : str, hashes : DownloadSet) -> bool:
+	hash_paths = [ hashes.get(hash_key).get('path') for hash_key in hashes.keys() ]
+
+	process_manager.check()
+	if not state_manager.get_item('skip_download'):
+		_, invalid_hash_paths = validate_hash_paths(hash_paths)
+		if invalid_hash_paths:
+			for index in hashes:
+				if hashes.get(index).get('path') in invalid_hash_paths:
+					invalid_hash_url = hashes.get(index).get('url')
+					conditional_download(download_directory_path, [ invalid_hash_url ])
+
+	valid_hash_paths, invalid_hash_paths = validate_hash_paths(hash_paths)
+	for valid_hash_path in valid_hash_paths:
+		valid_hash_file_name, _ = os.path.splitext(os.path.basename(valid_hash_path))
+		logger.debug(wording.get('validating_hash_succeed').format(hash_file_name = valid_hash_file_name), __name__)
+	for invalid_hash_path in invalid_hash_paths:
+		invalid_hash_file_name, _ = os.path.splitext(os.path.basename(invalid_hash_path))
+		logger.error(wording.get('validating_hash_failed').format(hash_file_name = invalid_hash_file_name), __name__)
+
+	if not invalid_hash_paths:
+		process_manager.end()
+	return not invalid_hash_paths
+
+
+def conditional_download_sources(download_directory_path : str, sources : DownloadSet) -> bool:
+	source_paths = [ sources.get(source_key).get('path') for source_key in sources.keys() ]
+
+	process_manager.check()
+	if not state_manager.get_item('skip_download'):
+		_, invalid_source_paths = validate_source_paths(source_paths)
+		if invalid_source_paths:
+			for index in sources:
+				if sources.get(index).get('path') in invalid_source_paths:
+					invalid_source_url = sources.get(index).get('url')
+					conditional_download(download_directory_path, [ invalid_source_url ])
+
+	valid_source_paths, invalid_source_paths = validate_source_paths(source_paths)
+	for valid_source_path in valid_source_paths:
+		valid_source_file_name, _ = os.path.splitext(os.path.basename(valid_source_path))
+		logger.debug(wording.get('validating_source_succeed').format(source_file_name = valid_source_file_name), __name__)
+	for invalid_source_path in invalid_source_paths:
+		invalid_source_file_name, _ = os.path.splitext(os.path.basename(invalid_source_path))
+		logger.error(wording.get('validating_source_failed').format(source_file_name = invalid_source_file_name), __name__)
+
+		if remove_file(invalid_source_path):
+			logger.error(wording.get('deleting_corrupt_source').format(source_file_name = invalid_source_file_name), __name__)
+
+	if not invalid_source_paths:
+		process_manager.end()
+	return not invalid_source_paths
+
+
+def validate_hash_paths(hash_paths : List[str]) -> Tuple[List[str], List[str]]:
+	valid_hash_paths = []
+	invalid_hash_paths = []
+
+	for hash_path in hash_paths:
+		if is_file(hash_path):
+			valid_hash_paths.append(hash_path)
+		else:
+			invalid_hash_paths.append(hash_path)
+	return valid_hash_paths, invalid_hash_paths
+
+
+def validate_source_paths(source_paths : List[str]) -> Tuple[List[str], List[str]]:
+	valid_source_paths = []
+	invalid_source_paths = []
+
+	for source_path in source_paths:
+		if validate_hash(source_path):
+			valid_source_paths.append(source_path)
+		else:
+			invalid_source_paths.append(source_path)
+	return valid_source_paths, invalid_source_paths

facefusion/execution.py

@@ -0,0 +1,134 @@
+import subprocess
+import xml.etree.ElementTree as ElementTree
+from functools import lru_cache
+from typing import Any, List
+
+from onnxruntime import get_available_providers, set_default_logger_severity
+
+from facefusion.choices import execution_provider_set
+from facefusion.typing import ExecutionDevice, ExecutionProviderKey, ExecutionProviderSet, ValueAndUnit
+
+set_default_logger_severity(3)
+
+
+def get_execution_provider_choices() -> List[ExecutionProviderKey]:
+	return list(get_available_execution_provider_set().keys())
+
+
+def has_execution_provider(execution_provider_key : ExecutionProviderKey) -> bool:
+	return execution_provider_key in get_execution_provider_choices()
+
+
+def get_available_execution_provider_set() -> ExecutionProviderSet:
+	available_execution_providers = get_available_providers()
+	available_execution_provider_set : ExecutionProviderSet = {}
+
+	for execution_provider_key, execution_provider_value in execution_provider_set.items():
+		if execution_provider_value in available_execution_providers:
+			available_execution_provider_set[execution_provider_key] = execution_provider_value
+	return available_execution_provider_set
+
+
+def create_execution_providers(execution_device_id : str, execution_provider_keys : List[ExecutionProviderKey]) -> List[Any]:
+	execution_providers : List[Any] = []
+
+	for execution_provider_key in execution_provider_keys:
+		if execution_provider_key == 'cuda':
+			execution_providers.append((execution_provider_set.get(execution_provider_key),
+			{
+				'device_id': execution_device_id,
+				'cudnn_conv_algo_search': 'EXHAUSTIVE' if use_exhaustive() else 'DEFAULT'
+			}))
+		if execution_provider_key == 'tensorrt':
+			execution_providers.append((execution_provider_set.get(execution_provider_key),
+			{
+				'device_id': execution_device_id,
+				'trt_engine_cache_enable': True,
+				'trt_engine_cache_path': '.caches',
+				'trt_timing_cache_enable': True,
+				'trt_timing_cache_path': '.caches',
+				'trt_builder_optimization_level': 5
+			}))
+		if execution_provider_key == 'openvino':
+			execution_providers.append((execution_provider_set.get(execution_provider_key),
+			{
+				'device_type': 'GPU.' + execution_device_id,
+				'precision': 'FP32'
+			}))
+		if execution_provider_key in [ 'directml', 'rocm' ]:
+			execution_providers.append((execution_provider_set.get(execution_provider_key),
+			{
+				'device_id': execution_device_id
+			}))
+		if execution_provider_key == 'coreml':
+			execution_providers.append(execution_provider_set.get(execution_provider_key))
+
+	if 'cpu' in execution_provider_keys:
+		execution_providers.append(execution_provider_set.get('cpu'))
+
+	return execution_providers
+
+
+def use_exhaustive() -> bool:
+	execution_devices = detect_static_execution_devices()
+	product_names = ('GeForce GTX 1630', 'GeForce GTX 1650', 'GeForce GTX 1660')
+
+	return any(execution_device.get('product').get('name').startswith(product_names) for execution_device in execution_devices)
+
+
+def run_nvidia_smi() -> subprocess.Popen[bytes]:
+	commands = [ 'nvidia-smi', '--query', '--xml-format' ]
+	return subprocess.Popen(commands, stdout = subprocess.PIPE)
+
+
+@lru_cache(maxsize = None)
+def detect_static_execution_devices() -> List[ExecutionDevice]:
+	return detect_execution_devices()
+
+
+def detect_execution_devices() -> List[ExecutionDevice]:
+	execution_devices : List[ExecutionDevice] = []
+
+	try:
+		output, _ = run_nvidia_smi().communicate()
+		root_element = ElementTree.fromstring(output)
+	except Exception:
+		root_element = ElementTree.Element('xml')
+
+	for gpu_element in root_element.findall('gpu'):
+		execution_devices.append(
+		{
+			'driver_version': root_element.find('driver_version').text,
+			'framework':
+			{
+				'name': 'CUDA',
+				'version': root_element.find('cuda_version').text
+			},
+			'product':
+			{
+				'vendor': 'NVIDIA',
+				'name': gpu_element.find('product_name').text.replace('NVIDIA ', '')
+			},
+			'video_memory':
+			{
+				'total': create_value_and_unit(gpu_element.find('fb_memory_usage/total').text),
+				'free': create_value_and_unit(gpu_element.find('fb_memory_usage/free').text)
+			},
+			'utilization':
+			{
+				'gpu': create_value_and_unit(gpu_element.find('utilization/gpu_util').text),
+				'memory': create_value_and_unit(gpu_element.find('utilization/memory_util').text)
+			}
+		})
+	return execution_devices
+
+
+def create_value_and_unit(text : str) -> ValueAndUnit:
+	value, unit = text.split()
+	value_and_unit : ValueAndUnit =\
+	{
+		'value': int(value),
+		'unit': str(unit)
+	}
+
+	return value_and_unit

facefusion/exit_helper.py

@@ -0,0 +1,24 @@
+import sys
+from time import sleep
+
+from facefusion import process_manager, state_manager
+from facefusion.temp_helper import clear_temp_directory
+from facefusion.typing import ErrorCode
+
+
+def hard_exit(error_code : ErrorCode) -> None:
+	sys.exit(error_code)
+
+
+def conditional_exit(error_code : ErrorCode) -> None:
+	if state_manager.get_item('command') == 'headless-run':
+		hard_exit(error_code)
+
+
+def graceful_exit(error_code : ErrorCode) -> None:
+	process_manager.stop()
+	while process_manager.is_processing():
+		sleep(0.5)
+	if state_manager.get_item('target_path'):
+		clear_temp_directory(state_manager.get_item('target_path'))
+	hard_exit(error_code)

facefusion/face_analyser.py

@@ -0,0 +1,124 @@
+from typing import List, Optional
+
+import numpy
+
+from facefusion import state_manager
+from facefusion.common_helper import get_first
+from facefusion.face_classifier import classify_face
+from facefusion.face_detector import detect_faces, detect_rotated_faces
+from facefusion.face_helper import apply_nms, convert_to_face_landmark_5, estimate_face_angle, get_nms_threshold
+from facefusion.face_landmarker import detect_face_landmarks, estimate_face_landmark_68_5
+from facefusion.face_recognizer import calc_embedding
+from facefusion.face_store import get_static_faces, set_static_faces
+from facefusion.typing import BoundingBox, Face, FaceLandmark5, FaceLandmarkSet, FaceScoreSet, Score, VisionFrame
+
+
+def create_faces(vision_frame : VisionFrame, bounding_boxes : List[BoundingBox], face_scores : List[Score], face_landmarks_5 : List[FaceLandmark5]) -> List[Face]:
+	faces = []
+	nms_threshold = get_nms_threshold(state_manager.get_item('face_detector_model'), state_manager.get_item('face_detector_angles'))
+	keep_indices = apply_nms(bounding_boxes, face_scores, state_manager.get_item('face_detector_score'), nms_threshold)
+
+	for index in keep_indices:
+		bounding_box = bounding_boxes[index]
+		face_score = face_scores[index]
+		face_landmark_5 = face_landmarks_5[index]
+		face_landmark_5_68 = face_landmark_5
+		face_landmark_68_5 = estimate_face_landmark_68_5(face_landmark_5_68)
+		face_landmark_68 = face_landmark_68_5
+		face_landmark_score_68 = 0.0
+		face_angle = estimate_face_angle(face_landmark_68_5)
+
+		if state_manager.get_item('face_landmarker_score') > 0:
+			face_landmark_68, face_landmark_score_68 = detect_face_landmarks(vision_frame, bounding_box, face_angle)
+		if face_landmark_score_68 > state_manager.get_item('face_landmarker_score'):
+			face_landmark_5_68 = convert_to_face_landmark_5(face_landmark_68)
+
+		face_landmark_set : FaceLandmarkSet =\
+		{
+			'5': face_landmark_5,
+			'5/68': face_landmark_5_68,
+			'68': face_landmark_68,
+			'68/5': face_landmark_68_5
+		}
+		face_score_set : FaceScoreSet =\
+		{
+			'detector': face_score,
+			'landmarker': face_landmark_score_68
+		}
+		embedding, normed_embedding = calc_embedding(vision_frame, face_landmark_set.get('5/68'))
+		gender, age, race = classify_face(vision_frame, face_landmark_set.get('5/68'))
+		faces.append(Face(
+			bounding_box = bounding_box,
+			score_set = face_score_set,
+			landmark_set = face_landmark_set,
+			angle = face_angle,
+			embedding = embedding,
+			normed_embedding = normed_embedding,
+			gender = gender,
+			age = age,
+			race = race
+		))
+	return faces
+
+
+def get_one_face(faces : List[Face], position : int = 0) -> Optional[Face]:
+	if faces:
+		position = min(position, len(faces) - 1)
+		return faces[position]
+	return None
+
+
+def get_average_face(faces : List[Face]) -> Optional[Face]:
+	embeddings = []
+	normed_embeddings = []
+
+	if faces:
+		first_face = get_first(faces)
+
+		for face in faces:
+			embeddings.append(face.embedding)
+			normed_embeddings.append(face.normed_embedding)
+
+		return Face(
+			bounding_box = first_face.bounding_box,
+			score_set = first_face.score_set,
+			landmark_set = first_face.landmark_set,
+			angle = first_face.angle,
+			embedding = numpy.mean(embeddings, axis = 0),
+			normed_embedding = numpy.mean(normed_embeddings, axis = 0),
+			gender = first_face.gender,
+			age = first_face.age,
+			race = first_face.race
+		)
+	return None
+
+
+def get_many_faces(vision_frames : List[VisionFrame]) -> List[Face]:
+	many_faces : List[Face] = []
+
+	for vision_frame in vision_frames:
+		if numpy.any(vision_frame):
+			static_faces = get_static_faces(vision_frame)
+			if static_faces:
+				many_faces.extend(static_faces)
+			else:
+				all_bounding_boxes = []
+				all_face_scores = []
+				all_face_landmarks_5 = []
+
+				for face_detector_angle in state_manager.get_item('face_detector_angles'):
+					if face_detector_angle == 0:
+						bounding_boxes, face_scores, face_landmarks_5 = detect_faces(vision_frame)
+					else:
+						bounding_boxes, face_scores, face_landmarks_5 = detect_rotated_faces(vision_frame, face_detector_angle)
+					all_bounding_boxes.extend(bounding_boxes)
+					all_face_scores.extend(face_scores)
+					all_face_landmarks_5.extend(face_landmarks_5)
+
+				if all_bounding_boxes and all_face_scores and all_face_landmarks_5 and state_manager.get_item('face_detector_score') > 0:
+					faces = create_faces(vision_frame, all_bounding_boxes, all_face_scores, all_face_landmarks_5)
+
+					if faces:
+						many_faces.extend(faces)
+						set_static_faces(vision_frame, faces)
+	return many_faces

facefusion/face_classifier.py

@@ -0,0 +1,128 @@
+from typing import List, Tuple
+
+import numpy
+
+from facefusion import inference_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_helper import warp_face_by_face_landmark_5
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.typing import Age, FaceLandmark5, Gender, InferencePool, ModelOptions, ModelSet, Race, VisionFrame
+
+MODEL_SET : ModelSet =\
+{
+	'fairface':
+	{
+		'hashes':
+		{
+			'face_classifier':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/fairface.hash',
+				'path': resolve_relative_path('../.assets/models/fairface.hash')
+			}
+		},
+		'sources':
+		{
+			'face_classifier':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/fairface.onnx',
+				'path': resolve_relative_path('../.assets/models/fairface.onnx')
+			}
+		},
+		'template': 'arcface_112_v2',
+		'size': (224, 224),
+		'mean': [ 0.485, 0.456, 0.406 ],
+		'standard_deviation': [ 0.229, 0.224, 0.225 ]
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def get_model_options() -> ModelOptions:
+	return MODEL_SET.get('fairface')
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def classify_face(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Gender, Age, Race]:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	model_mean = get_model_options().get('mean')
+	model_standard_deviation = get_model_options().get('standard_deviation')
+	crop_vision_frame, _ = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, model_size)
+	crop_vision_frame = crop_vision_frame.astype(numpy.float32)[:, :, ::-1] / 255
+	crop_vision_frame -= model_mean
+	crop_vision_frame /= model_standard_deviation
+	crop_vision_frame = crop_vision_frame.transpose(2, 0, 1)
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
+	gender_id, age_id, race_id = forward(crop_vision_frame)
+	gender = categorize_gender(gender_id[0])
+	age = categorize_age(age_id[0])
+	race = categorize_race(race_id[0])
+	return gender, age, race
+
+
+def forward(crop_vision_frame : VisionFrame) -> Tuple[List[int], List[int], List[int]]:
+	face_classifier = get_inference_pool().get('face_classifier')
+
+	with conditional_thread_semaphore():
+		race_id, gender_id, age_id = face_classifier.run(None,
+		{
+			'input': crop_vision_frame
+		})
+
+	return gender_id, age_id, race_id
+
+
+def categorize_gender(gender_id : int) -> Gender:
+	if gender_id == 1:
+		return 'female'
+	return 'male'
+
+
+def categorize_age(age_id : int) -> Age:
+	if age_id == 0:
+		return range(0, 2)
+	if age_id == 1:
+		return range(3, 9)
+	if age_id == 2:
+		return range(10, 19)
+	if age_id == 3:
+		return range(20, 29)
+	if age_id == 4:
+		return range(30, 39)
+	if age_id == 5:
+		return range(40, 49)
+	if age_id == 6:
+		return range(50, 59)
+	if age_id == 7:
+		return range(60, 69)
+	return range(70, 100)
+
+
+def categorize_race(race_id : int) -> Race:
+	if race_id == 1:
+		return 'black'
+	if race_id == 2:
+		return 'latino'
+	if race_id == 3 or race_id == 4:
+		return 'asian'
+	if race_id == 5:
+		return 'indian'
+	if race_id == 6:
+		return 'arabic'
+	return 'white'

facefusion/face_detector.py

@@ -0,0 +1,309 @@
+from typing import List, Tuple
+
+import cv2
+import numpy
+
+from facefusion import inference_manager, state_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_helper import create_rotated_matrix_and_size, create_static_anchors, distance_to_bounding_box, distance_to_face_landmark_5, normalize_bounding_box, transform_bounding_box, transform_points
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import thread_semaphore
+from facefusion.typing import Angle, BoundingBox, Detection, DownloadSet, FaceLandmark5, InferencePool, ModelSet, Score, VisionFrame
+from facefusion.vision import resize_frame_resolution, unpack_resolution
+
+MODEL_SET : ModelSet =\
+{
+	'retinaface':
+	{
+		'hashes':
+		{
+			'retinaface':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/retinaface_10g.hash',
+				'path': resolve_relative_path('../.assets/models/retinaface_10g.hash')
+			}
+		},
+		'sources':
+		{
+			'retinaface':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/retinaface_10g.onnx',
+				'path': resolve_relative_path('../.assets/models/retinaface_10g.onnx')
+			}
+		}
+	},
+	'scrfd':
+	{
+		'hashes':
+		{
+			'scrfd':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/scrfd_2.5g.hash',
+				'path': resolve_relative_path('../.assets/models/scrfd_2.5g.hash')
+			}
+		},
+		'sources':
+		{
+			'scrfd':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/scrfd_2.5g.onnx',
+				'path': resolve_relative_path('../.assets/models/scrfd_2.5g.onnx')
+			}
+		}
+	},
+	'yoloface':
+	{
+		'hashes':
+		{
+			'yoloface':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/yoloface_8n.hash',
+				'path': resolve_relative_path('../.assets/models/yoloface_8n.hash')
+			}
+		},
+		'sources':
+		{
+			'yoloface':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/yoloface_8n.onnx',
+				'path': resolve_relative_path('../.assets/models/yoloface_8n.onnx')
+			}
+		}
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	_, model_sources = collect_model_downloads()
+	model_context = __name__ + '.' + state_manager.get_item('face_detector_model')
+	return inference_manager.get_inference_pool(model_context, model_sources)
+
+
+def clear_inference_pool() -> None:
+	model_context = __name__ + '.' + state_manager.get_item('face_detector_model')
+	inference_manager.clear_inference_pool(model_context)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_hashes = {}
+	model_sources = {}
+
+	if state_manager.get_item('face_detector_model') in [ 'many', 'retinaface' ]:
+		model_hashes['retinaface'] = MODEL_SET.get('retinaface').get('hashes').get('retinaface')
+		model_sources['retinaface'] = MODEL_SET.get('retinaface').get('sources').get('retinaface')
+	if state_manager.get_item('face_detector_model') in [ 'many', 'scrfd' ]:
+		model_hashes['scrfd'] = MODEL_SET.get('scrfd').get('hashes').get('scrfd')
+		model_sources['scrfd'] = MODEL_SET.get('scrfd').get('sources').get('scrfd')
+	if state_manager.get_item('face_detector_model') in [ 'many', 'yoloface' ]:
+		model_hashes['yoloface'] = MODEL_SET.get('yoloface').get('hashes').get('yoloface')
+		model_sources['yoloface'] = MODEL_SET.get('yoloface').get('sources').get('yoloface')
+	return model_hashes, model_sources
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes, model_sources = collect_model_downloads()
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def detect_faces(vision_frame : VisionFrame) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
+	all_bounding_boxes : List[BoundingBox] = []
+	all_face_scores : List[Score] = []
+	all_face_landmarks_5 : List[FaceLandmark5] = []
+
+	if state_manager.get_item('face_detector_model') in [ 'many', 'retinaface' ]:
+		bounding_boxes, face_scores, face_landmarks_5 = detect_with_retinaface(vision_frame, state_manager.get_item('face_detector_size'))
+		all_bounding_boxes.extend(bounding_boxes)
+		all_face_scores.extend(face_scores)
+		all_face_landmarks_5.extend(face_landmarks_5)
+
+	if state_manager.get_item('face_detector_model') in [ 'many', 'scrfd' ]:
+		bounding_boxes, face_scores, face_landmarks_5 = detect_with_scrfd(vision_frame, state_manager.get_item('face_detector_size'))
+		all_bounding_boxes.extend(bounding_boxes)
+		all_face_scores.extend(face_scores)
+		all_face_landmarks_5.extend(face_landmarks_5)
+
+	if state_manager.get_item('face_detector_model') in [ 'many', 'yoloface' ]:
+		bounding_boxes, face_scores, face_landmarks_5 = detect_with_yoloface(vision_frame, state_manager.get_item('face_detector_size'))
+		all_bounding_boxes.extend(bounding_boxes)
+		all_face_scores.extend(face_scores)
+		all_face_landmarks_5.extend(face_landmarks_5)
+
+	all_bounding_boxes = [ normalize_bounding_box(all_bounding_box) for all_bounding_box in all_bounding_boxes ]
+	return all_bounding_boxes, all_face_scores, all_face_landmarks_5
+
+
+def detect_rotated_faces(vision_frame : VisionFrame, angle : Angle) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
+	rotated_matrix, rotated_size = create_rotated_matrix_and_size(angle, vision_frame.shape[:2][::-1])
+	rotated_vision_frame = cv2.warpAffine(vision_frame, rotated_matrix, rotated_size)
+	rotated_inverse_matrix = cv2.invertAffineTransform(rotated_matrix)
+	bounding_boxes, face_scores, face_landmarks_5 = detect_faces(rotated_vision_frame)
+	bounding_boxes = [ transform_bounding_box(bounding_box, rotated_inverse_matrix) for bounding_box in bounding_boxes ]
+	face_landmarks_5 = [ transform_points(face_landmark_5, rotated_inverse_matrix) for face_landmark_5 in face_landmarks_5 ]
+	return bounding_boxes, face_scores, face_landmarks_5
+
+
+def detect_with_retinaface(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
+	bounding_boxes = []
+	face_scores = []
+	face_landmarks_5 = []
+	feature_strides = [ 8, 16, 32 ]
+	feature_map_channel = 3
+	anchor_total = 2
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	temp_vision_frame = resize_frame_resolution(vision_frame, (face_detector_width, face_detector_height))
+	ratio_height = vision_frame.shape[0] / temp_vision_frame.shape[0]
+	ratio_width = vision_frame.shape[1] / temp_vision_frame.shape[1]
+	detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
+	detection = forward_with_retinaface(detect_vision_frame)
+
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detection[index] >= state_manager.get_item('face_detector_score'))[0]
+
+		if numpy.any(keep_indices):
+			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)
+			bounding_box_raw = detection[index + feature_map_channel] * feature_stride
+			face_landmark_5_raw = detection[index + feature_map_channel * 2] * feature_stride
+
+			for bounding_box in distance_to_bounding_box(anchors, bounding_box_raw)[keep_indices]:
+				bounding_boxes.append(numpy.array(
+				[
+					bounding_box[0] * ratio_width,
+					bounding_box[1] * ratio_height,
+					bounding_box[2] * ratio_width,
+					bounding_box[3] * ratio_height,
+				]))
+
+			for score in detection[index][keep_indices]:
+				face_scores.append(score[0])
+
+			for face_landmark_5 in distance_to_face_landmark_5(anchors, face_landmark_5_raw)[keep_indices]:
+				face_landmarks_5.append(face_landmark_5 * [ ratio_width, ratio_height ])
+
+	return bounding_boxes, face_scores, face_landmarks_5
+
+
+def detect_with_scrfd(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
+	bounding_boxes = []
+	face_scores = []
+	face_landmarks_5 = []
+	feature_strides = [ 8, 16, 32 ]
+	feature_map_channel = 3
+	anchor_total = 2
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	temp_vision_frame = resize_frame_resolution(vision_frame, (face_detector_width, face_detector_height))
+	ratio_height = vision_frame.shape[0] / temp_vision_frame.shape[0]
+	ratio_width = vision_frame.shape[1] / temp_vision_frame.shape[1]
+	detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
+	detection = forward_with_scrfd(detect_vision_frame)
+
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detection[index] >= state_manager.get_item('face_detector_score'))[0]
+
+		if numpy.any(keep_indices):
+			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)
+			bounding_box_raw = detection[index + feature_map_channel] * feature_stride
+			face_landmark_5_raw = detection[index + feature_map_channel * 2] * feature_stride
+
+			for bounding_box in distance_to_bounding_box(anchors, bounding_box_raw)[keep_indices]:
+				bounding_boxes.append(numpy.array(
+				[
+					bounding_box[0] * ratio_width,
+					bounding_box[1] * ratio_height,
+					bounding_box[2] * ratio_width,
+					bounding_box[3] * ratio_height,
+				]))
+
+			for score in detection[index][keep_indices]:
+				face_scores.append(score[0])
+
+			for face_landmark_5 in distance_to_face_landmark_5(anchors, face_landmark_5_raw)[keep_indices]:
+				face_landmarks_5.append(face_landmark_5 * [ ratio_width, ratio_height ])
+
+	return bounding_boxes, face_scores, face_landmarks_5
+
+
+def detect_with_yoloface(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
+	bounding_boxes = []
+	face_scores = []
+	face_landmarks_5 = []
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	temp_vision_frame = resize_frame_resolution(vision_frame, (face_detector_width, face_detector_height))
+	ratio_height = vision_frame.shape[0] / temp_vision_frame.shape[0]
+	ratio_width = vision_frame.shape[1] / temp_vision_frame.shape[1]
+	detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
+	detection = forward_with_yoloface(detect_vision_frame)
+	detection = numpy.squeeze(detection).T
+	bounding_box_raw, score_raw, face_landmark_5_raw = numpy.split(detection, [ 4, 5 ], axis = 1)
+	keep_indices = numpy.where(score_raw > state_manager.get_item('face_detector_score'))[0]
+
+	if numpy.any(keep_indices):
+		bounding_box_raw, face_landmark_5_raw, score_raw = bounding_box_raw[keep_indices], face_landmark_5_raw[keep_indices], score_raw[keep_indices]
+
+		for bounding_box in bounding_box_raw:
+			bounding_boxes.append(numpy.array(
+			[
+				(bounding_box[0] - bounding_box[2] / 2) * ratio_width,
+				(bounding_box[1] - bounding_box[3] / 2) * ratio_height,
+				(bounding_box[0] + bounding_box[2] / 2) * ratio_width,
+				(bounding_box[1] + bounding_box[3] / 2) * ratio_height,
+			]))
+
+		face_scores = score_raw.ravel().tolist()
+		face_landmark_5_raw[:, 0::3] = (face_landmark_5_raw[:, 0::3]) * ratio_width
+		face_landmark_5_raw[:, 1::3] = (face_landmark_5_raw[:, 1::3]) * ratio_height
+
+		for face_landmark_5 in face_landmark_5_raw:
+			face_landmarks_5.append(numpy.array(face_landmark_5.reshape(-1, 3)[:, :2]))
+
+	return bounding_boxes, face_scores, face_landmarks_5
+
+
+def forward_with_retinaface(detect_vision_frame : VisionFrame) -> Detection:
+	face_detector = get_inference_pool().get('retinaface')
+
+	with thread_semaphore():
+		detection = face_detector.run(None,
+		{
+			'input': detect_vision_frame
+		})
+
+	return detection
+
+
+def forward_with_scrfd(detect_vision_frame : VisionFrame) -> Detection:
+	face_detector = get_inference_pool().get('scrfd')
+
+	with thread_semaphore():
+		detection = face_detector.run(None,
+		{
+			'input': detect_vision_frame
+		})
+
+	return detection
+
+
+def forward_with_yoloface(detect_vision_frame : VisionFrame) -> Detection:
+	face_detector = get_inference_pool().get('yoloface')
+
+	with thread_semaphore():
+		detection = face_detector.run(None,
+		{
+			'input': detect_vision_frame
+		})
+
+	return detection
+
+
+def prepare_detect_frame(temp_vision_frame : VisionFrame, face_detector_size : str) -> VisionFrame:
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	detect_vision_frame = numpy.zeros((face_detector_height, face_detector_width, 3))
+	detect_vision_frame[:temp_vision_frame.shape[0], :temp_vision_frame.shape[1], :] = temp_vision_frame
+	detect_vision_frame = (detect_vision_frame - 127.5) / 128.0
+	detect_vision_frame = numpy.expand_dims(detect_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return detect_vision_frame

facefusion/face_helper.py

@@ -0,0 +1,210 @@
+from functools import lru_cache
+from typing import List, Sequence, Tuple
+
+import cv2
+import numpy
+from cv2.typing import Size
+
+from facefusion.typing import Anchors, Angle, BoundingBox, Distance, FaceDetectorModel, FaceLandmark5, FaceLandmark68, Mask, Matrix, Points, Scale, Score, Translation, VisionFrame, WarpTemplate, WarpTemplateSet
+
+WARP_TEMPLATES : WarpTemplateSet =\
+{
+	'arcface_112_v1': numpy.array(
+	[
+		[ 0.35473214, 0.45658929 ],
+		[ 0.64526786, 0.45658929 ],
+		[ 0.50000000, 0.61154464 ],
+		[ 0.37913393, 0.77687500 ],
+		[ 0.62086607, 0.77687500 ]
+	]),
+	'arcface_112_v2': numpy.array(
+	[
+		[ 0.34191607, 0.46157411 ],
+		[ 0.65653393, 0.45983393 ],
+		[ 0.50022500, 0.64050536 ],
+		[ 0.37097589, 0.82469196 ],
+		[ 0.63151696, 0.82325089 ]
+	]),
+	'arcface_128_v2': numpy.array(
+	[
+		[ 0.36167656, 0.40387734 ],
+		[ 0.63696719, 0.40235469 ],
+		[ 0.50019687, 0.56044219 ],
+		[ 0.38710391, 0.72160547 ],
+		[ 0.61507734, 0.72034453 ]
+	]),
+	'ffhq_512': numpy.array(
+	[
+		[ 0.37691676, 0.46864664 ],
+		[ 0.62285697, 0.46912813 ],
+		[ 0.50123859, 0.61331904 ],
+		[ 0.39308822, 0.72541100 ],
+		[ 0.61150205, 0.72490465 ]
+	])
+}
+
+
+def estimate_matrix_by_face_landmark_5(face_landmark_5 : FaceLandmark5, warp_template : WarpTemplate, crop_size : Size) -> Matrix:
+	normed_warp_template = WARP_TEMPLATES.get(warp_template) * crop_size
+	affine_matrix = cv2.estimateAffinePartial2D(face_landmark_5, normed_warp_template, method = cv2.RANSAC, ransacReprojThreshold = 100)[0]
+	return affine_matrix
+
+
+def warp_face_by_face_landmark_5(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5, warp_template : WarpTemplate, crop_size : Size) -> Tuple[VisionFrame, Matrix]:
+	affine_matrix = estimate_matrix_by_face_landmark_5(face_landmark_5, warp_template, crop_size)
+	crop_vision_frame = cv2.warpAffine(temp_vision_frame, affine_matrix, crop_size, borderMode = cv2.BORDER_REPLICATE, flags = cv2.INTER_AREA)
+	return crop_vision_frame, affine_matrix
+
+
+def warp_face_by_bounding_box(temp_vision_frame : VisionFrame, bounding_box : BoundingBox, crop_size : Size) -> Tuple[VisionFrame, Matrix]:
+	source_points = numpy.array([ [ bounding_box[0], bounding_box[1] ], [bounding_box[2], bounding_box[1] ], [ bounding_box[0], bounding_box[3] ] ]).astype(numpy.float32)
+	target_points = numpy.array([ [ 0, 0 ], [ crop_size[0], 0 ], [ 0, crop_size[1] ] ]).astype(numpy.float32)
+	affine_matrix = cv2.getAffineTransform(source_points, target_points)
+	if bounding_box[2] - bounding_box[0] > crop_size[0] or bounding_box[3] - bounding_box[1] > crop_size[1]:
+		interpolation_method = cv2.INTER_AREA
+	else:
+		interpolation_method = cv2.INTER_LINEAR
+	crop_vision_frame = cv2.warpAffine(temp_vision_frame, affine_matrix, crop_size, flags = interpolation_method)
+	return crop_vision_frame, affine_matrix
+
+
+def warp_face_by_translation(temp_vision_frame : VisionFrame, translation : Translation, scale : float, crop_size : Size) -> Tuple[VisionFrame, Matrix]:
+	affine_matrix = numpy.array([ [ scale, 0, translation[0] ], [ 0, scale, translation[1] ] ])
+	crop_vision_frame = cv2.warpAffine(temp_vision_frame, affine_matrix, crop_size)
+	return crop_vision_frame, affine_matrix
+
+
+def paste_back(temp_vision_frame : VisionFrame, crop_vision_frame : VisionFrame, crop_mask : Mask, affine_matrix : Matrix) -> VisionFrame:
+	inverse_matrix = cv2.invertAffineTransform(affine_matrix)
+	temp_size = temp_vision_frame.shape[:2][::-1]
+	inverse_mask = cv2.warpAffine(crop_mask, inverse_matrix, temp_size).clip(0, 1)
+	inverse_vision_frame = cv2.warpAffine(crop_vision_frame, inverse_matrix, temp_size, borderMode = cv2.BORDER_REPLICATE)
+	paste_vision_frame = temp_vision_frame.copy()
+	paste_vision_frame[:, :, 0] = inverse_mask * inverse_vision_frame[:, :, 0] + (1 - inverse_mask) * temp_vision_frame[:, :, 0]
+	paste_vision_frame[:, :, 1] = inverse_mask * inverse_vision_frame[:, :, 1] + (1 - inverse_mask) * temp_vision_frame[:, :, 1]
+	paste_vision_frame[:, :, 2] = inverse_mask * inverse_vision_frame[:, :, 2] + (1 - inverse_mask) * temp_vision_frame[:, :, 2]
+	return paste_vision_frame
+
+
+@lru_cache(maxsize = None)
+def create_static_anchors(feature_stride : int, anchor_total : int, stride_height : int, stride_width : int) -> Anchors:
+	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 create_rotated_matrix_and_size(angle : Angle, size : Size) -> Tuple[Matrix, Size]:
+	rotated_matrix = cv2.getRotationMatrix2D((size[0] / 2, size[1] / 2), angle, 1)
+	rotated_size = numpy.dot(numpy.abs(rotated_matrix[:, :2]), size)
+	rotated_matrix[:, -1] += (rotated_size - size) * 0.5 #type:ignore[misc]
+	rotated_size = int(rotated_size[0]), int(rotated_size[1])
+	return rotated_matrix, rotated_size
+
+
+def create_bounding_box(face_landmark_68 : FaceLandmark68) -> BoundingBox:
+	min_x, min_y = numpy.min(face_landmark_68, axis = 0)
+	max_x, max_y = numpy.max(face_landmark_68, axis = 0)
+	bounding_box = normalize_bounding_box(numpy.array([ min_x, min_y, max_x, max_y ]))
+	return bounding_box
+
+
+def normalize_bounding_box(bounding_box : BoundingBox) -> BoundingBox:
+	x1, y1, x2, y2 = bounding_box
+	x1, x2 = sorted([ x1, x2 ])
+	y1, y2 = sorted([ y1, y2 ])
+	return numpy.array([ x1, y1, x2, y2 ])
+
+
+def transform_points(points : Points, matrix : Matrix) -> Points:
+	points = points.reshape(-1, 1, 2)
+	points = cv2.transform(points, matrix) #type:ignore[assignment]
+	points = points.reshape(-1, 2)
+	return points
+
+
+def transform_bounding_box(bounding_box : BoundingBox, matrix : Matrix) -> BoundingBox:
+	points = numpy.array(
+	[
+		[ bounding_box[0], bounding_box[1] ],
+		[ bounding_box[2], bounding_box[1] ],
+		[ bounding_box[2], bounding_box[3] ],
+		[ bounding_box[0], bounding_box[3] ]
+	])
+	points = transform_points(points, matrix)
+	x1, y1 = numpy.min(points, axis = 0)
+	x2, y2 = numpy.max(points, axis = 0)
+	return normalize_bounding_box(numpy.array([ x1, y1, x2, y2 ]))
+
+
+def distance_to_bounding_box(points : Points, distance : Distance) -> BoundingBox:
+	x1 = points[:, 0] - distance[:, 0]
+	y1 = points[:, 1] - distance[:, 1]
+	x2 = points[:, 0] + distance[:, 2]
+	y2 = points[:, 1] + distance[:, 3]
+	bounding_box = numpy.column_stack([ x1, y1, x2, y2 ])
+	return bounding_box
+
+
+def distance_to_face_landmark_5(points : Points, distance : Distance) -> FaceLandmark5:
+	x = points[:, 0::2] + distance[:, 0::2]
+	y = points[:, 1::2] + distance[:, 1::2]
+	face_landmark_5 = numpy.stack((x, y), axis = -1)
+	return face_landmark_5
+
+
+def scale_face_landmark_5(face_landmark_5 : FaceLandmark5, scale : Scale) -> FaceLandmark5:
+	face_landmark_5_scale = face_landmark_5 - face_landmark_5[2]
+	face_landmark_5_scale *= scale
+	face_landmark_5_scale += face_landmark_5[2]
+	return face_landmark_5_scale
+
+
+def convert_to_face_landmark_5(face_landmark_68 : FaceLandmark68) -> FaceLandmark5:
+	face_landmark_5 = numpy.array(
+	[
+		numpy.mean(face_landmark_68[36:42], axis = 0),
+		numpy.mean(face_landmark_68[42:48], axis = 0),
+		face_landmark_68[30],
+		face_landmark_68[48],
+		face_landmark_68[54]
+	])
+	return face_landmark_5
+
+
+def estimate_face_angle(face_landmark_68 : FaceLandmark68) -> Angle:
+	x1, y1 = face_landmark_68[0]
+	x2, y2 = face_landmark_68[16]
+	theta = numpy.arctan2(y2 - y1, x2 - x1)
+	theta = numpy.degrees(theta) % 360
+	angles = numpy.linspace(0, 360, 5)
+	index = numpy.argmin(numpy.abs(angles - theta))
+	face_angle = int(angles[index] % 360)
+	return face_angle
+
+
+def apply_nms(bounding_boxes : List[BoundingBox], face_scores : List[Score], score_threshold : float, nms_threshold : float) -> Sequence[int]:
+	normed_bounding_boxes = [ (x1, y1, x2 - x1, y2 - y1) for (x1, y1, x2, y2) in bounding_boxes ]
+	keep_indices = cv2.dnn.NMSBoxes(normed_bounding_boxes, face_scores, score_threshold = score_threshold, nms_threshold = nms_threshold)
+	return keep_indices
+
+
+def get_nms_threshold(face_detector_model : FaceDetectorModel, face_detector_angles : List[Angle]) -> float:
+	if face_detector_model == 'many':
+		return 0.1
+	if len(face_detector_angles) == 2:
+		return 0.3
+	if len(face_detector_angles) == 3:
+		return 0.2
+	if len(face_detector_angles) == 4:
+		return 0.1
+	return 0.4
+
+
+def merge_matrix(matrices : List[Matrix]) -> Matrix:
+	merged_matrix = numpy.vstack([ matrices[0], [ 0, 0, 1 ] ])
+	for matrix in matrices[1:]:
+		matrix = numpy.vstack([ matrix, [ 0, 0, 1 ] ])
+		merged_matrix = numpy.dot(merged_matrix, matrix)
+	return merged_matrix[:2, :]

facefusion/face_landmarker.py

@@ -0,0 +1,217 @@
+from typing import Tuple
+
+import cv2
+import numpy
+
+from facefusion import inference_manager, state_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_helper import create_rotated_matrix_and_size, estimate_matrix_by_face_landmark_5, transform_points, warp_face_by_translation
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.typing import Angle, BoundingBox, DownloadSet, FaceLandmark5, FaceLandmark68, InferencePool, ModelSet, Prediction, Score, VisionFrame
+
+MODEL_SET : ModelSet =\
+{
+	'2dfan4':
+	{
+		'hashes':
+		{
+			'2dfan4':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/2dfan4.hash',
+				'path': resolve_relative_path('../.assets/models/2dfan4.hash')
+			}
+		},
+		'sources':
+		{
+			'2dfan4':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/2dfan4.onnx',
+				'path': resolve_relative_path('../.assets/models/2dfan4.onnx')
+			}
+		},
+		'size': (256, 256)
+	},
+	'peppa_wutz':
+	{
+		'hashes':
+		{
+			'peppa_wutz':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/peppa_wutz.hash',
+				'path': resolve_relative_path('../.assets/models/peppa_wutz.hash')
+			}
+		},
+		'sources':
+		{
+			'peppa_wutz':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/peppa_wutz.onnx',
+				'path': resolve_relative_path('../.assets/models/peppa_wutz.onnx')
+			}
+		},
+		'size': (256, 256)
+	},
+	'fan_68_5':
+	{
+		'hashes':
+		{
+			'fan_68_5':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/fan_68_5.hash',
+				'path': resolve_relative_path('../.assets/models/fan_68_5.hash')
+			}
+		},
+		'sources':
+		{
+			'fan_68_5':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/fan_68_5.onnx',
+				'path': resolve_relative_path('../.assets/models/fan_68_5.onnx')
+			}
+		}
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	_, model_sources = collect_model_downloads()
+	model_context = __name__ + '.' + state_manager.get_item('face_landmarker_model')
+	return inference_manager.get_inference_pool(model_context, model_sources)
+
+
+def clear_inference_pool() -> None:
+	model_context = __name__ + '.' + state_manager.get_item('face_landmarker_model')
+	inference_manager.clear_inference_pool(model_context)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_hashes =\
+	{
+		'fan_68_5': MODEL_SET.get('fan_68_5').get('hashes').get('fan_68_5')
+	}
+	model_sources =\
+	{
+		'fan_68_5': MODEL_SET.get('fan_68_5').get('sources').get('fan_68_5')
+	}
+
+	if state_manager.get_item('face_landmarker_model') in [ 'many', '2dfan4' ]:
+		model_hashes['2dfan4'] = MODEL_SET.get('2dfan4').get('hashes').get('2dfan4')
+		model_sources['2dfan4'] = MODEL_SET.get('2dfan4').get('sources').get('2dfan4')
+	if state_manager.get_item('face_landmarker_model') in [ 'many', 'peppa_wutz' ]:
+		model_hashes['peppa_wutz'] = MODEL_SET.get('peppa_wutz').get('hashes').get('peppa_wutz')
+		model_sources['peppa_wutz'] = MODEL_SET.get('peppa_wutz').get('sources').get('peppa_wutz')
+	return model_hashes, model_sources
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes, model_sources = collect_model_downloads()
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def detect_face_landmarks(vision_frame : VisionFrame, bounding_box : BoundingBox, face_angle : Angle) -> Tuple[FaceLandmark68, Score]:
+	face_landmark_2dfan4 = None
+	face_landmark_peppa_wutz = None
+	face_landmark_score_2dfan4 = 0.0
+	face_landmark_score_peppa_wutz = 0.0
+
+	if state_manager.get_item('face_landmarker_model') in [ 'many', '2dfan4' ]:
+		face_landmark_2dfan4, face_landmark_score_2dfan4 = detect_with_2dfan4(vision_frame, bounding_box, face_angle)
+	if state_manager.get_item('face_landmarker_model') in [ 'many', 'peppa_wutz' ]:
+		face_landmark_peppa_wutz, face_landmark_score_peppa_wutz = detect_with_peppa_wutz(vision_frame, bounding_box, face_angle)
+
+	if face_landmark_score_2dfan4 > face_landmark_score_peppa_wutz - 0.2:
+		return face_landmark_2dfan4, face_landmark_score_2dfan4
+	return face_landmark_peppa_wutz, face_landmark_score_peppa_wutz
+
+
+def detect_with_2dfan4(temp_vision_frame: VisionFrame, bounding_box: BoundingBox, face_angle: Angle) -> Tuple[FaceLandmark68, Score]:
+	model_size = MODEL_SET.get('2dfan4').get('size')
+	scale = 195 / numpy.subtract(bounding_box[2:], bounding_box[:2]).max().clip(1, None)
+	translation = (model_size[0] - numpy.add(bounding_box[2:], bounding_box[:2]) * scale) * 0.5
+	rotated_matrix, rotated_size = create_rotated_matrix_and_size(face_angle, model_size)
+	crop_vision_frame, affine_matrix = warp_face_by_translation(temp_vision_frame, translation, scale, model_size)
+	crop_vision_frame = cv2.warpAffine(crop_vision_frame, rotated_matrix, rotated_size)
+	crop_vision_frame = conditional_optimize_contrast(crop_vision_frame)
+	crop_vision_frame = crop_vision_frame.transpose(2, 0, 1).astype(numpy.float32) / 255.0
+	face_landmark_68, face_heatmap = forward_with_2dfan4(crop_vision_frame)
+	face_landmark_68 = face_landmark_68[:, :, :2][0] / 64 * 256
+	face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(rotated_matrix))
+	face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(affine_matrix))
+	face_landmark_score_68 = numpy.amax(face_heatmap, axis = (2, 3))
+	face_landmark_score_68 = numpy.mean(face_landmark_score_68)
+	face_landmark_score_68 = numpy.interp(face_landmark_score_68, [ 0, 0.9 ], [ 0, 1 ])
+	return face_landmark_68, face_landmark_score_68
+
+
+def detect_with_peppa_wutz(temp_vision_frame : VisionFrame, bounding_box : BoundingBox, face_angle : Angle) -> Tuple[FaceLandmark68, Score]:
+	model_size = MODEL_SET.get('peppa_wutz').get('size')
+	scale = 195 / numpy.subtract(bounding_box[2:], bounding_box[:2]).max().clip(1, None)
+	translation = (model_size[0] - numpy.add(bounding_box[2:], bounding_box[:2]) * scale) * 0.5
+	rotated_matrix, rotated_size = create_rotated_matrix_and_size(face_angle, model_size)
+	crop_vision_frame, affine_matrix = warp_face_by_translation(temp_vision_frame, translation, scale, model_size)
+	crop_vision_frame = cv2.warpAffine(crop_vision_frame, rotated_matrix, rotated_size)
+	crop_vision_frame = conditional_optimize_contrast(crop_vision_frame)
+	crop_vision_frame = crop_vision_frame.transpose(2, 0, 1).astype(numpy.float32) / 255.0
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
+	prediction = forward_with_peppa_wutz(crop_vision_frame)
+	face_landmark_68 = prediction.reshape(-1, 3)[:, :2] / 64 * model_size[0]
+	face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(rotated_matrix))
+	face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(affine_matrix))
+	face_landmark_score_68 = prediction.reshape(-1, 3)[:, 2].mean()
+	face_landmark_score_68 = numpy.interp(face_landmark_score_68, [ 0, 0.95 ], [ 0, 1 ])
+	return face_landmark_68, face_landmark_score_68
+
+
+def conditional_optimize_contrast(crop_vision_frame : VisionFrame) -> VisionFrame:
+	crop_vision_frame = cv2.cvtColor(crop_vision_frame, cv2.COLOR_RGB2Lab)
+	if numpy.mean(crop_vision_frame[:, :, 0]) < 30: # type:ignore[arg-type]
+		crop_vision_frame[:, :, 0] = cv2.createCLAHE(clipLimit = 2).apply(crop_vision_frame[:, :, 0])
+	crop_vision_frame = cv2.cvtColor(crop_vision_frame, cv2.COLOR_Lab2RGB)
+	return crop_vision_frame
+
+
+def estimate_face_landmark_68_5(face_landmark_5 : FaceLandmark5) -> FaceLandmark68:
+	affine_matrix = estimate_matrix_by_face_landmark_5(face_landmark_5, 'ffhq_512', (1, 1))
+	face_landmark_5 = cv2.transform(face_landmark_5.reshape(1, -1, 2), affine_matrix).reshape(-1, 2)
+	face_landmark_68_5 = forward_fan_68_5(face_landmark_5)
+	face_landmark_68_5 = cv2.transform(face_landmark_68_5.reshape(1, -1, 2), cv2.invertAffineTransform(affine_matrix)).reshape(-1, 2)
+	return face_landmark_68_5
+
+
+def forward_with_2dfan4(crop_vision_frame : VisionFrame) -> Tuple[Prediction, Prediction]:
+	face_landmarker = get_inference_pool().get('2dfan4')
+
+	with conditional_thread_semaphore():
+		prediction = face_landmarker.run(None,
+		{
+			'input': [ crop_vision_frame ]
+		})
+
+	return prediction
+
+
+def forward_with_peppa_wutz(crop_vision_frame : VisionFrame) -> Prediction:
+	face_landmarker = get_inference_pool().get('peppa_wutz')
+
+	with conditional_thread_semaphore():
+		prediction = face_landmarker.run(None,
+		{
+			'input': crop_vision_frame
+		})[0]
+
+	return prediction
+
+
+def forward_fan_68_5(face_landmark_5 : FaceLandmark5) -> FaceLandmark68:
+	face_landmarker = get_inference_pool().get('fan_68_5')
+
+	with conditional_thread_semaphore():
+		face_landmark_68_5 = face_landmarker.run(None,
+		{
+			'input': [ face_landmark_5 ]
+		})[0][0]
+
+	return face_landmark_68_5

facefusion/face_masker.py

@@ -0,0 +1,173 @@
+from functools import lru_cache
+from typing import Dict, List, Tuple
+
+import cv2
+import numpy
+from cv2.typing import Size
+
+from facefusion import inference_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.typing import DownloadSet, FaceLandmark68, FaceMaskRegion, InferencePool, Mask, ModelSet, Padding, VisionFrame
+
+MODEL_SET : ModelSet =\
+{
+	'face_occluder':
+	{
+		'hashes':
+		{
+			'face_occluder':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/dfl_xseg.hash',
+				'path': resolve_relative_path('../.assets/models/dfl_xseg.hash')
+			}
+		},
+		'sources':
+		{
+			'face_occluder':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/dfl_xseg.onnx',
+				'path': resolve_relative_path('../.assets/models/dfl_xseg.onnx')
+			}
+		},
+		'size': (256, 256)
+	},
+	'face_parser':
+	{
+		'hashes':
+		{
+			'face_parser':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/bisenet_resnet_34.hash',
+				'path': resolve_relative_path('../.assets/models/bisenet_resnet_34.hash')
+			}
+		},
+		'sources':
+		{
+			'face_parser':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/bisenet_resnet_34.onnx',
+				'path': resolve_relative_path('../.assets/models/bisenet_resnet_34.onnx')
+			}
+		},
+		'size': (512, 512)
+	}
+}
+FACE_MASK_REGIONS : Dict[FaceMaskRegion, int] =\
+{
+	'skin': 1,
+	'left-eyebrow': 2,
+	'right-eyebrow': 3,
+	'left-eye': 4,
+	'right-eye': 5,
+	'glasses': 6,
+	'nose': 10,
+	'mouth': 11,
+	'upper-lip': 12,
+	'lower-lip': 13
+}
+
+
+def get_inference_pool() -> InferencePool:
+	_, model_sources = collect_model_downloads()
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_hashes =\
+	{
+		'face_occluder': MODEL_SET.get('face_occluder').get('hashes').get('face_occluder'),
+		'face_parser': MODEL_SET.get('face_parser').get('hashes').get('face_parser')
+	}
+	model_sources =\
+	{
+		'face_occluder': MODEL_SET.get('face_occluder').get('sources').get('face_occluder'),
+		'face_parser': MODEL_SET.get('face_parser').get('sources').get('face_parser')
+	}
+	return model_hashes, model_sources
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes, model_sources = collect_model_downloads()
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+@lru_cache(maxsize = None)
+def create_static_box_mask(crop_size : Size, face_mask_blur : float, face_mask_padding : Padding) -> Mask:
+	blur_amount = int(crop_size[0] * 0.5 * face_mask_blur)
+	blur_area = max(blur_amount // 2, 1)
+	box_mask : Mask = numpy.ones(crop_size).astype(numpy.float32)
+	box_mask[:max(blur_area, int(crop_size[1] * face_mask_padding[0] / 100)), :] = 0
+	box_mask[-max(blur_area, int(crop_size[1] * face_mask_padding[2] / 100)):, :] = 0
+	box_mask[:, :max(blur_area, int(crop_size[0] * face_mask_padding[3] / 100))] = 0
+	box_mask[:, -max(blur_area, int(crop_size[0] * face_mask_padding[1] / 100)):] = 0
+	if blur_amount > 0:
+		box_mask = cv2.GaussianBlur(box_mask, (0, 0), blur_amount * 0.25)
+	return box_mask
+
+
+def create_occlusion_mask(crop_vision_frame : VisionFrame) -> Mask:
+	model_size = MODEL_SET.get('face_occluder').get('size')
+	prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
+	prepare_vision_frame = numpy.expand_dims(prepare_vision_frame, axis = 0).astype(numpy.float32) / 255
+	prepare_vision_frame = prepare_vision_frame.transpose(0, 1, 2, 3)
+	occlusion_mask = forward_occlude_face(prepare_vision_frame)
+	occlusion_mask = occlusion_mask.transpose(0, 1, 2).clip(0, 1).astype(numpy.float32)
+	occlusion_mask = cv2.resize(occlusion_mask, crop_vision_frame.shape[:2][::-1])
+	occlusion_mask = (cv2.GaussianBlur(occlusion_mask.clip(0, 1), (0, 0), 5).clip(0.5, 1) - 0.5) * 2
+	return occlusion_mask
+
+
+def create_region_mask(crop_vision_frame : VisionFrame, face_mask_regions : List[FaceMaskRegion]) -> Mask:
+	model_size = MODEL_SET.get('face_parser').get('size')
+	prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
+	prepare_vision_frame = prepare_vision_frame[:, :, ::-1].astype(numpy.float32) / 255
+	prepare_vision_frame = numpy.subtract(prepare_vision_frame, numpy.array([ 0.485, 0.456, 0.406 ]).astype(numpy.float32))
+	prepare_vision_frame = numpy.divide(prepare_vision_frame, numpy.array([ 0.229, 0.224, 0.225 ]).astype(numpy.float32))
+	prepare_vision_frame = numpy.expand_dims(prepare_vision_frame, axis = 0)
+	prepare_vision_frame = prepare_vision_frame.transpose(0, 3, 1, 2)
+	region_mask = forward_parse_face(prepare_vision_frame)
+	region_mask = numpy.isin(region_mask.argmax(0), [ FACE_MASK_REGIONS[region] for region in face_mask_regions ])
+	region_mask = cv2.resize(region_mask.astype(numpy.float32), crop_vision_frame.shape[:2][::-1])
+	region_mask = (cv2.GaussianBlur(region_mask.clip(0, 1), (0, 0), 5).clip(0.5, 1) - 0.5) * 2
+	return region_mask
+
+
+def create_mouth_mask(face_landmark_68 : FaceLandmark68) -> Mask:
+	convex_hull = cv2.convexHull(face_landmark_68[numpy.r_[3:14, 31:36]].astype(numpy.int32))
+	mouth_mask : Mask = numpy.zeros((512, 512)).astype(numpy.float32)
+	mouth_mask = cv2.fillConvexPoly(mouth_mask, convex_hull, 1.0) #type:ignore[call-overload]
+	mouth_mask = cv2.erode(mouth_mask.clip(0, 1), numpy.ones((21, 3)))
+	mouth_mask = cv2.GaussianBlur(mouth_mask, (0, 0), sigmaX = 1, sigmaY = 15)
+	return mouth_mask
+
+
+def forward_occlude_face(prepare_vision_frame : VisionFrame) -> Mask:
+	face_occluder = get_inference_pool().get('face_occluder')
+
+	with conditional_thread_semaphore():
+		occlusion_mask : Mask = face_occluder.run(None,
+		{
+			'input': prepare_vision_frame
+		})[0][0]
+
+	return occlusion_mask
+
+
+def forward_parse_face(prepare_vision_frame : VisionFrame) -> Mask:
+	face_parser = get_inference_pool().get('face_parser')
+
+	with conditional_thread_semaphore():
+		region_mask : Mask = face_parser.run(None,
+		{
+			'input': prepare_vision_frame
+		})[0][0]
+
+	return region_mask

facefusion/face_recognizer.py

@@ -0,0 +1,81 @@
+from typing import Tuple
+
+import numpy
+
+from facefusion import inference_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_helper import warp_face_by_face_landmark_5
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.typing import Embedding, FaceLandmark5, InferencePool, ModelOptions, ModelSet, VisionFrame
+
+MODEL_SET : ModelSet =\
+{
+	'arcface':
+	{
+		'hashes':
+		{
+			'face_recognizer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/arcface_w600k_r50.hash',
+				'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.hash')
+			}
+		},
+		'sources':
+		{
+			'face_recognizer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/arcface_w600k_r50.onnx',
+				'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.onnx')
+			}
+		},
+		'template': 'arcface_112_v2',
+		'size': (112, 112)
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def get_model_options() -> ModelOptions:
+	return MODEL_SET.get('arcface')
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def calc_embedding(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Embedding, Embedding]:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	crop_vision_frame, matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, model_size)
+	crop_vision_frame = crop_vision_frame / 127.5 - 1
+	crop_vision_frame = crop_vision_frame[:, :, ::-1].transpose(2, 0, 1).astype(numpy.float32)
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
+	embedding = forward(crop_vision_frame)
+	embedding = embedding.ravel()
+	normed_embedding = embedding / numpy.linalg.norm(embedding)
+	return embedding, normed_embedding
+
+
+def forward(crop_vision_frame : VisionFrame) -> Embedding:
+	face_recognizer = get_inference_pool().get('face_recognizer')
+
+	with conditional_thread_semaphore():
+		embedding = face_recognizer.run(None,
+		{
+			'input': crop_vision_frame
+		})[0]
+
+	return embedding

facefusion/face_selector.py

@@ -0,0 +1,91 @@
+from typing import List
+
+import numpy
+
+from facefusion import state_manager
+from facefusion.typing import Face, FaceSelectorOrder, FaceSet, Gender, Race
+
+
+def find_similar_faces(faces : List[Face], reference_faces : FaceSet, face_distance : float) -> List[Face]:
+	similar_faces : List[Face] = []
+
+	if faces and reference_faces:
+		for reference_set in reference_faces:
+			if not similar_faces:
+				for reference_face in reference_faces[reference_set]:
+					for face in faces:
+						if compare_faces(face, reference_face, face_distance):
+							similar_faces.append(face)
+	return similar_faces
+
+
+def compare_faces(face : Face, reference_face : Face, face_distance : float) -> bool:
+	current_face_distance = calc_face_distance(face, reference_face)
+	return current_face_distance < face_distance
+
+
+def calc_face_distance(face : Face, reference_face : Face) -> float:
+	if hasattr(face, 'normed_embedding') and hasattr(reference_face, 'normed_embedding'):
+		return 1 - numpy.dot(face.normed_embedding, reference_face.normed_embedding)
+	return 0
+
+
+def sort_and_filter_faces(faces : List[Face]) -> List[Face]:
+	if faces:
+		if state_manager.get_item('face_selector_order'):
+			faces = sort_by_order(faces, state_manager.get_item('face_selector_order'))
+		if state_manager.get_item('face_selector_gender'):
+			faces = filter_by_gender(faces, state_manager.get_item('face_selector_gender'))
+		if state_manager.get_item('face_selector_race'):
+			faces = filter_by_race(faces, state_manager.get_item('face_selector_race'))
+		if state_manager.get_item('face_selector_age_start') or state_manager.get_item('face_selector_age_end'):
+			faces = filter_by_age(faces, state_manager.get_item('face_selector_age_start'), state_manager.get_item('face_selector_age_end'))
+	return faces
+
+
+def sort_by_order(faces : List[Face], order : FaceSelectorOrder) -> List[Face]:
+	if order == 'left-right':
+		return sorted(faces, key = lambda face: face.bounding_box[0])
+	if order == 'right-left':
+		return sorted(faces, key = lambda face: face.bounding_box[0], reverse = True)
+	if order == 'top-bottom':
+		return sorted(faces, key = lambda face: face.bounding_box[1])
+	if order == 'bottom-top':
+		return sorted(faces, key = lambda face: face.bounding_box[1], reverse = True)
+	if order == 'small-large':
+		return sorted(faces, key = lambda face: (face.bounding_box[2] - face.bounding_box[0]) * (face.bounding_box[3] - face.bounding_box[1]))
+	if order == 'large-small':
+		return sorted(faces, key = lambda face: (face.bounding_box[2] - face.bounding_box[0]) * (face.bounding_box[3] - face.bounding_box[1]), reverse = True)
+	if order == 'best-worst':
+		return sorted(faces, key = lambda face: face.score_set.get('detector'), reverse = True)
+	if order == 'worst-best':
+		return sorted(faces, key = lambda face: face.score_set.get('detector'))
+	return faces
+
+
+def filter_by_gender(faces : List[Face], gender : Gender) -> List[Face]:
+	filter_faces = []
+
+	for face in faces:
+		if face.gender == gender:
+			filter_faces.append(face)
+	return filter_faces
+
+
+def filter_by_age(faces : List[Face], face_selector_age_start : int, face_selector_age_end : int) -> List[Face]:
+	filter_faces = []
+	age = range(face_selector_age_start, face_selector_age_end)
+
+	for face in faces:
+		if set(face.age) & set(age):
+			filter_faces.append(face)
+	return filter_faces
+
+
+def filter_by_race(faces : List[Face], race : Race) -> List[Face]:
+	filter_faces = []
+
+	for face in faces:
+		if face.race == race:
+			filter_faces.append(face)
+	return filter_faces

facefusion/face_store.py

@@ -0,0 +1,53 @@
+import hashlib
+from typing import List, Optional
+
+import numpy
+
+from facefusion.typing import Face, FaceSet, FaceStore, VisionFrame
+
+FACE_STORE : FaceStore =\
+{
+	'static_faces': {},
+	'reference_faces': {}
+}
+
+
+def get_face_store() -> FaceStore:
+	return FACE_STORE
+
+
+def get_static_faces(vision_frame : VisionFrame) -> Optional[List[Face]]:
+	frame_hash = create_frame_hash(vision_frame)
+	if frame_hash in FACE_STORE['static_faces']:
+		return FACE_STORE['static_faces'][frame_hash]
+	return None
+
+
+def set_static_faces(vision_frame : VisionFrame, faces : List[Face]) -> None:
+	frame_hash = create_frame_hash(vision_frame)
+	if frame_hash:
+		FACE_STORE['static_faces'][frame_hash] = faces
+
+
+def clear_static_faces() -> None:
+	FACE_STORE['static_faces'] = {}
+
+
+def create_frame_hash(vision_frame : VisionFrame) -> Optional[str]:
+	return hashlib.sha1(vision_frame.tobytes()).hexdigest() if numpy.any(vision_frame) else None
+
+
+def get_reference_faces() -> Optional[FaceSet]:
+	if FACE_STORE['reference_faces']:
+		return FACE_STORE['reference_faces']
+	return None
+
+
+def append_reference_face(name : str, face : Face) -> None:
+	if name not in FACE_STORE['reference_faces']:
+		FACE_STORE['reference_faces'][name] = []
+	FACE_STORE['reference_faces'][name].append(face)
+
+
+def clear_reference_faces() -> None:
+	FACE_STORE['reference_faces'] = {}

facefusion/ffmpeg.py

@@ -0,0 +1,176 @@
+import os
+import shutil
+import subprocess
+import tempfile
+from typing import List, Optional
+
+import filetype
+
+from facefusion import logger, process_manager, state_manager
+from facefusion.filesystem import remove_file
+from facefusion.temp_helper import get_temp_file_path, get_temp_frames_pattern
+from facefusion.typing import AudioBuffer, Fps, OutputVideoPreset
+from facefusion.vision import restrict_video_fps
+
+
+def run_ffmpeg(args : List[str]) -> subprocess.Popen[bytes]:
+	commands = [ shutil.which('ffmpeg'), '-hide_banner', '-loglevel', 'error' ]
+	commands.extend(args)
+	process = subprocess.Popen(commands, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
+
+	while process_manager.is_processing():
+		try:
+			if state_manager.get_item('log_level') == 'debug':
+				log_debug(process)
+			process.wait(timeout = 0.5)
+		except subprocess.TimeoutExpired:
+			continue
+		return process
+
+	if process_manager.is_stopping():
+		process.terminate()
+	return process
+
+
+def open_ffmpeg(args : List[str]) -> subprocess.Popen[bytes]:
+	commands = [ shutil.which('ffmpeg'), '-hide_banner', '-loglevel', 'quiet' ]
+	commands.extend(args)
+	return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
+
+
+def log_debug(process : subprocess.Popen[bytes]) -> None:
+	_, stderr = process.communicate()
+	errors = stderr.decode().split(os.linesep)
+
+	for error in errors:
+		if error.strip():
+			logger.debug(error.strip(), __name__)
+
+
+def extract_frames(target_path : str, temp_video_resolution : str, temp_video_fps : Fps) -> bool:
+	trim_frame_start = state_manager.get_item('trim_frame_start')
+	trim_frame_end = state_manager.get_item('trim_frame_end')
+	temp_frames_pattern = get_temp_frames_pattern(target_path, '%08d')
+	commands = [ '-i', target_path, '-s', str(temp_video_resolution), '-q:v', '0' ]
+
+	if isinstance(trim_frame_start, int) and isinstance(trim_frame_end, int):
+		commands.extend([ '-vf', 'trim=start_frame=' + str(trim_frame_start) + ':end_frame=' + str(trim_frame_end) + ',fps=' + str(temp_video_fps) ])
+	elif isinstance(trim_frame_start, int):
+		commands.extend([ '-vf', 'trim=start_frame=' + str(trim_frame_start) + ',fps=' + str(temp_video_fps) ])
+	elif isinstance(trim_frame_end, int):
+		commands.extend([ '-vf', 'trim=end_frame=' + str(trim_frame_end) + ',fps=' + str(temp_video_fps) ])
+	else:
+		commands.extend([ '-vf', 'fps=' + str(temp_video_fps) ])
+	commands.extend([ '-vsync', '0', temp_frames_pattern ])
+	return run_ffmpeg(commands).returncode == 0
+
+
+def merge_video(target_path : str, output_video_resolution : str, output_video_fps : Fps) -> bool:
+	temp_video_fps = restrict_video_fps(target_path, output_video_fps)
+	temp_file_path = get_temp_file_path(target_path)
+	temp_frames_pattern = get_temp_frames_pattern(target_path, '%08d')
+	commands = [ '-r', str(temp_video_fps), '-i', temp_frames_pattern, '-s', str(output_video_resolution), '-c:v', state_manager.get_item('output_video_encoder') ]
+
+	if state_manager.get_item('output_video_encoder') in [ 'libx264', 'libx265' ]:
+		output_video_compression = round(51 - (state_manager.get_item('output_video_quality') * 0.51))
+		commands.extend([ '-crf', str(output_video_compression), '-preset', state_manager.get_item('output_video_preset') ])
+	if state_manager.get_item('output_video_encoder') in [ 'libvpx-vp9' ]:
+		output_video_compression = round(63 - (state_manager.get_item('output_video_quality') * 0.63))
+		commands.extend([ '-crf', str(output_video_compression) ])
+	if state_manager.get_item('output_video_encoder') in [ 'h264_nvenc', 'hevc_nvenc' ]:
+		output_video_compression = round(51 - (state_manager.get_item('output_video_quality') * 0.51))
+		commands.extend([ '-cq', str(output_video_compression), '-preset', map_nvenc_preset(state_manager.get_item('output_video_preset')) ])
+	if state_manager.get_item('output_video_encoder') in [ 'h264_amf', 'hevc_amf' ]:
+		output_video_compression = round(51 - (state_manager.get_item('output_video_quality') * 0.51))
+		commands.extend([ '-qp_i', str(output_video_compression), '-qp_p', str(output_video_compression), '-quality', map_amf_preset(state_manager.get_item('output_video_preset')) ])
+	if state_manager.get_item('output_video_encoder') in [ 'h264_videotoolbox', 'hevc_videotoolbox' ]:
+		commands.extend([ '-q:v', str(state_manager.get_item('output_video_quality')) ])
+	commands.extend([ '-vf', 'framerate=fps=' + str(output_video_fps), '-pix_fmt', 'yuv420p', '-colorspace', 'bt709', '-y', temp_file_path ])
+	return run_ffmpeg(commands).returncode == 0
+
+
+def concat_video(output_path : str, temp_output_paths : List[str]) -> bool:
+	concat_video_path = tempfile.mktemp()
+
+	with open(concat_video_path, 'w') as concat_video_file:
+		for temp_output_path in temp_output_paths:
+			concat_video_file.write('file \'' + os.path.abspath(temp_output_path) + '\'' + os.linesep)
+		concat_video_file.flush()
+		concat_video_file.close()
+	commands = [ '-f', 'concat', '-safe', '0', '-i', concat_video_file.name, '-c:v', 'copy', '-c:a', state_manager.get_item('output_audio_encoder'), '-y', os.path.abspath(output_path) ]
+	process = run_ffmpeg(commands)
+	process.communicate()
+	remove_file(concat_video_path)
+	return process.returncode == 0
+
+
+def copy_image(target_path : str, temp_image_resolution : str) -> bool:
+	temp_file_path = get_temp_file_path(target_path)
+	temp_image_compression = calc_image_compression(target_path, 100)
+	commands = [ '-i', target_path, '-s', str(temp_image_resolution), '-q:v', str(temp_image_compression), '-y', temp_file_path ]
+	return run_ffmpeg(commands).returncode == 0
+
+
+def finalize_image(target_path : str, output_path : str, output_image_resolution : str) -> bool:
+	temp_file_path = get_temp_file_path(target_path)
+	output_image_compression = calc_image_compression(target_path, state_manager.get_item('output_image_quality'))
+	commands = [ '-i', temp_file_path, '-s', str(output_image_resolution), '-q:v', str(output_image_compression), '-y', output_path ]
+	return run_ffmpeg(commands).returncode == 0
+
+
+def calc_image_compression(image_path : str, image_quality : int) -> int:
+	is_webp = filetype.guess_mime(image_path) == 'image/webp'
+	if is_webp:
+		image_quality = 100 - image_quality
+	return round(31 - (image_quality * 0.31))
+
+
+def read_audio_buffer(target_path : str, sample_rate : int, channel_total : int) -> Optional[AudioBuffer]:
+	commands = [ '-i', target_path, '-vn', '-f', 's16le', '-acodec', 'pcm_s16le', '-ar', str(sample_rate), '-ac', str(channel_total), '-' ]
+	process = open_ffmpeg(commands)
+	audio_buffer, _ = process.communicate()
+	if process.returncode == 0:
+		return audio_buffer
+	return None
+
+
+def restore_audio(target_path : str, output_path : str, output_video_fps : Fps) -> bool:
+	trim_frame_start = state_manager.get_item('trim_frame_start')
+	trim_frame_end = state_manager.get_item('trim_frame_end')
+	temp_file_path = get_temp_file_path(target_path)
+	commands = [ '-i', temp_file_path ]
+
+	if isinstance(trim_frame_start, int):
+		start_time = trim_frame_start / output_video_fps
+		commands.extend([ '-ss', str(start_time) ])
+	if isinstance(trim_frame_end, int):
+		end_time = trim_frame_end / output_video_fps
+		commands.extend([ '-to', str(end_time) ])
+	commands.extend([ '-i', target_path, '-c:v', 'copy', '-c:a', state_manager.get_item('output_audio_encoder'), '-map', '0:v:0', '-map', '1:a:0', '-shortest', '-y', output_path ])
+	return run_ffmpeg(commands).returncode == 0
+
+
+def replace_audio(target_path : str, audio_path : str, output_path : str) -> bool:
+	temp_file_path = get_temp_file_path(target_path)
+	commands = [ '-i', temp_file_path, '-i', audio_path, '-c:a', state_manager.get_item('output_audio_encoder'), '-af', 'apad', '-shortest', '-y', output_path ]
+	return run_ffmpeg(commands).returncode == 0
+
+
+def map_nvenc_preset(output_video_preset : OutputVideoPreset) -> Optional[str]:
+	if output_video_preset in [ 'ultrafast', 'superfast', 'veryfast', 'faster', 'fast' ]:
+		return 'fast'
+	if output_video_preset == 'medium':
+		return 'medium'
+	if output_video_preset in [ 'slow', 'slower', 'veryslow' ]:
+		return 'slow'
+	return None
+
+
+def map_amf_preset(output_video_preset : OutputVideoPreset) -> Optional[str]:
+	if output_video_preset in [ 'ultrafast', 'superfast', 'veryfast' ]:
+		return 'speed'
+	if output_video_preset in [ 'faster', 'fast', 'medium' ]:
+		return 'balanced'
+	if output_video_preset in [ 'slow', 'slower', 'veryslow' ]:
+		return 'quality'
+	return None

facefusion/filesystem.py

@@ -0,0 +1,140 @@
+import os
+import shutil
+from pathlib import Path
+from typing import List, Optional
+
+import filetype
+
+from facefusion.common_helper import is_windows
+
+if is_windows():
+	import ctypes
+
+
+def get_file_size(file_path : str) -> int:
+	if is_file(file_path):
+		return os.path.getsize(file_path)
+	return 0
+
+
+def same_file_extension(file_paths : List[str]) -> bool:
+	file_extensions : List[str] = []
+
+	for file_path in file_paths:
+		_, file_extension = os.path.splitext(file_path.lower())
+
+		if file_extensions and file_extension not in file_extensions:
+			return False
+		file_extensions.append(file_extension)
+	return True
+
+
+def is_file(file_path : str) -> bool:
+	return bool(file_path and os.path.isfile(file_path))
+
+
+def is_directory(directory_path : str) -> bool:
+	return bool(directory_path and os.path.isdir(directory_path))
+
+
+def in_directory(file_path : str) -> bool:
+	if file_path and not is_directory(file_path):
+		return is_directory(os.path.dirname(file_path))
+	return False
+
+
+def is_audio(audio_path : str) -> bool:
+	return is_file(audio_path) and filetype.helpers.is_audio(audio_path)
+
+
+def has_audio(audio_paths : List[str]) -> bool:
+	if audio_paths:
+		return any(is_audio(audio_path) for audio_path in audio_paths)
+	return False
+
+
+def is_image(image_path : str) -> bool:
+	return is_file(image_path) and filetype.helpers.is_image(image_path)
+
+
+def has_image(image_paths: List[str]) -> bool:
+	if image_paths:
+		return any(is_image(image_path) for image_path in image_paths)
+	return False
+
+
+def is_video(video_path : str) -> bool:
+	return is_file(video_path) and filetype.helpers.is_video(video_path)
+
+
+def filter_audio_paths(paths : List[str]) -> List[str]:
+	if paths:
+		return [ path for path in paths if is_audio(path) ]
+	return []
+
+
+def filter_image_paths(paths : List[str]) -> List[str]:
+	if paths:
+		return [ path for path in paths if is_image(path) ]
+	return []
+
+
+def resolve_relative_path(path : str) -> str:
+	return os.path.abspath(os.path.join(os.path.dirname(__file__), path))
+
+
+def sanitize_path_for_windows(full_path : str) -> Optional[str]:
+	buffer_size = 0
+
+	while True:
+		unicode_buffer = ctypes.create_unicode_buffer(buffer_size)
+		buffer_limit = ctypes.windll.kernel32.GetShortPathNameW(full_path, unicode_buffer, buffer_size) #type:ignore[attr-defined]
+
+		if buffer_size > buffer_limit:
+			return unicode_buffer.value
+		if buffer_limit == 0:
+			return None
+		buffer_size = buffer_limit
+
+
+def copy_file(file_path : str, move_path : str) -> bool:
+	if is_file(file_path):
+		shutil.copy(file_path, move_path)
+		return is_file(move_path)
+	return False
+
+
+def move_file(file_path : str, move_path : str) -> bool:
+	if is_file(file_path):
+		shutil.move(file_path, move_path)
+		return not is_file(file_path) and is_file(move_path)
+	return False
+
+
+def remove_file(file_path : str) -> bool:
+	if is_file(file_path):
+		os.remove(file_path)
+		return not is_file(file_path)
+	return False
+
+
+def create_directory(directory_path : str) -> bool:
+	if directory_path and not is_file(directory_path):
+		Path(directory_path).mkdir(parents = True, exist_ok = True)
+		return is_directory(directory_path)
+	return False
+
+
+def list_directory(directory_path : str) -> Optional[List[str]]:
+	if is_directory(directory_path):
+		files = os.listdir(directory_path)
+		files = [ Path(file).stem for file in files if not Path(file).stem.startswith(('.', '__')) ]
+		return sorted(files)
+	return None
+
+
+def remove_directory(directory_path : str) -> bool:
+	if is_directory(directory_path):
+		shutil.rmtree(directory_path, ignore_errors = True)
+		return not is_directory(directory_path)
+	return False

facefusion/hash_helper.py

@@ -0,0 +1,32 @@
+import os
+import zlib
+from typing import Optional
+
+from facefusion.filesystem import is_file
+
+
+def create_hash(content : bytes) -> str:
+	return format(zlib.crc32(content), '08x')
+
+
+def validate_hash(validate_path : str) -> bool:
+	hash_path = get_hash_path(validate_path)
+
+	if is_file(hash_path):
+		with open(hash_path, 'r') as hash_file:
+			hash_content = hash_file.read().strip()
+
+		with open(validate_path, 'rb') as validate_file:
+			validate_content = validate_file.read()
+
+		return create_hash(validate_content) == hash_content
+	return False
+
+
+def get_hash_path(validate_path : str) -> Optional[str]:
+	if is_file(validate_path):
+		validate_directory_path, _ = os.path.split(validate_path)
+		validate_file_name, _ = os.path.splitext(_)
+
+		return os.path.join(validate_directory_path, validate_file_name + '.hash')
+	return None

facefusion/inference_manager.py

@@ -0,0 +1,79 @@
+from functools import lru_cache
+from time import sleep
+from typing import List
+
+import onnx
+from onnxruntime import InferenceSession
+
+from facefusion import process_manager, state_manager
+from facefusion.app_context import detect_app_context
+from facefusion.execution import create_execution_providers, has_execution_provider
+from facefusion.thread_helper import thread_lock
+from facefusion.typing import DownloadSet, ExecutionProviderKey, InferencePool, InferencePoolSet, ModelInitializer
+
+INFERENCE_POOLS : InferencePoolSet =\
+{
+	'cli': {}, # type:ignore[typeddict-item]
+	'ui': {} # type:ignore[typeddict-item]
+}
+
+
+def get_inference_pool(model_context : str, model_sources : DownloadSet) -> InferencePool:
+	global INFERENCE_POOLS
+
+	with thread_lock():
+		while process_manager.is_checking():
+			sleep(0.5)
+		app_context = detect_app_context()
+		inference_context = get_inference_context(model_context)
+
+		if app_context == 'cli' and INFERENCE_POOLS.get('ui').get(inference_context):
+			INFERENCE_POOLS['cli'][inference_context] = INFERENCE_POOLS.get('ui').get(inference_context)
+		if app_context == 'ui' and INFERENCE_POOLS.get('cli').get(inference_context):
+			INFERENCE_POOLS['ui'][inference_context] = INFERENCE_POOLS.get('cli').get(inference_context)
+		if not INFERENCE_POOLS.get(app_context).get(inference_context):
+			execution_provider_keys = resolve_execution_provider_keys(model_context)
+			INFERENCE_POOLS[app_context][inference_context] = create_inference_pool(model_sources, state_manager.get_item('execution_device_id'), execution_provider_keys)
+
+		return INFERENCE_POOLS.get(app_context).get(inference_context)
+
+
+def create_inference_pool(model_sources : DownloadSet, execution_device_id : str, execution_provider_keys : List[ExecutionProviderKey]) -> InferencePool:
+	inference_pool : InferencePool = {}
+
+	for model_name in model_sources.keys():
+		inference_pool[model_name] = create_inference_session(model_sources.get(model_name).get('path'), execution_device_id, execution_provider_keys)
+	return inference_pool
+
+
+def clear_inference_pool(model_context : str) -> None:
+	global INFERENCE_POOLS
+
+	app_context = detect_app_context()
+	inference_context = get_inference_context(model_context)
+
+	if INFERENCE_POOLS.get(app_context).get(inference_context):
+		del INFERENCE_POOLS[app_context][inference_context]
+
+
+def create_inference_session(model_path : str, execution_device_id : str, execution_provider_keys : List[ExecutionProviderKey]) -> InferenceSession:
+	execution_providers = create_execution_providers(execution_device_id, execution_provider_keys)
+	return InferenceSession(model_path, providers = execution_providers)
+
+
+@lru_cache(maxsize = None)
+def get_static_model_initializer(model_path : str) -> ModelInitializer:
+	model = onnx.load(model_path)
+	return onnx.numpy_helper.to_array(model.graph.initializer[-1])
+
+
+def resolve_execution_provider_keys(model_context : str) -> List[ExecutionProviderKey]:
+	if has_execution_provider('coreml') and (model_context.startswith('facefusion.processors.modules.age_modifier') or model_context.startswith('facefusion.processors.modules.frame_colorizer')):
+		return [ 'cpu' ]
+	return state_manager.get_item('execution_providers')
+
+
+def get_inference_context(model_context : str) -> str:
+	execution_provider_keys = resolve_execution_provider_keys(model_context)
+	inference_context = model_context + '.' + '_'.join(execution_provider_keys)
+	return inference_context

facefusion/installer.py

@@ -0,0 +1,93 @@
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+from argparse import ArgumentParser, HelpFormatter
+from typing import Dict, Tuple
+
+from facefusion import metadata, wording
+from facefusion.common_helper import is_linux, is_macos, is_windows
+
+ONNXRUNTIMES : Dict[str, Tuple[str, str]] = {}
+
+if is_macos():
+	ONNXRUNTIMES['default'] = ('onnxruntime', '1.19.2')
+else:
+	ONNXRUNTIMES['default'] = ('onnxruntime', '1.19.2')
+	ONNXRUNTIMES['cuda'] = ('onnxruntime-gpu', '1.19.2')
+	ONNXRUNTIMES['openvino'] = ('onnxruntime-openvino', '1.19.0')
+if is_linux():
+	ONNXRUNTIMES['rocm'] = ('onnxruntime-rocm', '1.18.0')
+if is_windows():
+	ONNXRUNTIMES['directml'] = ('onnxruntime-directml', '1.17.3')
+
+
+def cli() -> None:
+	signal.signal(signal.SIGINT, lambda signal_number, frame: sys.exit(0))
+	program = ArgumentParser(formatter_class = lambda prog: HelpFormatter(prog, max_help_position = 50))
+	program.add_argument('--onnxruntime', help = wording.get('help.install_dependency').format(dependency = 'onnxruntime'), choices = ONNXRUNTIMES.keys(), required = True)
+	program.add_argument('--skip-conda', help = wording.get('help.skip_conda'), action = 'store_true')
+	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()
+	has_conda = 'CONDA_PREFIX' in os.environ
+	onnxruntime_name, onnxruntime_version = ONNXRUNTIMES.get(args.onnxruntime)
+
+	if not args.skip_conda and not has_conda:
+		sys.stdout.write(wording.get('conda_not_activated') + os.linesep)
+		sys.exit(1)
+
+	subprocess.call([ shutil.which('pip'), 'install', '-r', 'requirements.txt', '--force-reinstall' ])
+
+	if args.onnxruntime == 'rocm':
+		python_id = 'cp' + str(sys.version_info.major) + str(sys.version_info.minor)
+
+		if python_id == 'cp310':
+			wheel_name = 'onnxruntime_rocm-' + onnxruntime_version +'-' + python_id + '-' + python_id + '-linux_x86_64.whl'
+			wheel_path = os.path.join(tempfile.gettempdir(), wheel_name)
+			wheel_url = 'https://repo.radeon.com/rocm/manylinux/rocm-rel-6.2/' + wheel_name
+			subprocess.call([ shutil.which('curl'), '--silent', '--location', '--continue-at', '-', '--output', wheel_path, wheel_url ])
+			subprocess.call([ shutil.which('pip'), 'uninstall', 'onnxruntime', wheel_path, '-y', '-q' ])
+			subprocess.call([ shutil.which('pip'), 'install', wheel_path, '--force-reinstall' ])
+			os.remove(wheel_path)
+	else:
+		subprocess.call([ shutil.which('pip'), 'uninstall', 'onnxruntime', onnxruntime_name, '-y', '-q' ])
+		subprocess.call([ shutil.which('pip'), 'install', onnxruntime_name + '==' + onnxruntime_version, '--force-reinstall' ])
+
+	if args.onnxruntime == 'cuda' and has_conda:
+		library_paths = []
+
+		if is_linux():
+			if os.getenv('LD_LIBRARY_PATH'):
+				library_paths = os.getenv('LD_LIBRARY_PATH').split(os.pathsep)
+
+			python_id = 'python' + str(sys.version_info.major) + '.' + str(sys.version_info.minor)
+			library_paths.extend(
+			[
+				os.path.join(os.getenv('CONDA_PREFIX'), 'lib'),
+				os.path.join(os.getenv('CONDA_PREFIX'), 'lib', python_id, 'site-packages', 'tensorrt_libs')
+			])
+			library_paths = [ library_path for library_path in library_paths if os.path.exists(library_path) ]
+
+			subprocess.call([ shutil.which('conda'), 'env', 'config', 'vars', 'set', 'LD_LIBRARY_PATH=' + os.pathsep.join(library_paths) ])
+
+		if is_windows():
+			if os.getenv('PATH'):
+				library_paths = os.getenv('PATH').split(os.pathsep)
+
+			library_paths.extend(
+			[
+				os.path.join(os.getenv('CONDA_PREFIX'), 'Lib'),
+				os.path.join(os.getenv('CONDA_PREFIX'), 'Lib', 'site-packages', 'tensorrt_libs')
+			])
+			library_paths = [ library_path for library_path in library_paths if os.path.exists(library_path) ]
+
+			subprocess.call([ shutil.which('conda'), 'env', 'config', 'vars', 'set', 'PATH=' + os.pathsep.join(library_paths) ])
+
+	if onnxruntime_version < '1.19.0':
+		subprocess.call([ shutil.which('pip'), 'install', 'numpy==1.26.4', '--force-reinstall' ])

facefusion/jobs/job_helper.py

@@ -0,0 +1,15 @@
+import os
+from datetime import datetime
+from typing import Optional
+
+
+def get_step_output_path(job_id : str, step_index : int, output_path : str) -> Optional[str]:
+	if output_path:
+		output_directory_path, _ = os.path.split(output_path)
+		output_file_name, output_file_extension = os.path.splitext(_)
+		return os.path.join(output_directory_path, output_file_name + '-' + job_id + '-' + str(step_index) + output_file_extension)
+	return None
+
+
+def suggest_job_id(job_prefix : str = 'job') -> str:
+	return job_prefix + '-' + datetime.now().strftime('%Y-%m-%d-%H-%M-%S')

facefusion/jobs/job_list.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+from typing import Optional, Tuple
+
+from facefusion.date_helper import describe_time_ago
+from facefusion.jobs import job_manager
+from facefusion.typing import JobStatus, TableContents, TableHeaders
+
+
+def compose_job_list(job_status : JobStatus) -> Tuple[TableHeaders, TableContents]:
+	jobs = job_manager.find_jobs(job_status)
+	job_headers : TableHeaders = [ 'job id', 'steps', 'date created', 'date updated', 'job status' ]
+	job_contents : TableContents = []
+
+	for index, job_id in enumerate(jobs):
+		if job_manager.validate_job(job_id):
+			job = jobs[job_id]
+			step_total = job_manager.count_step_total(job_id)
+			date_created = prepare_describe_datetime(job.get('date_created'))
+			date_updated = prepare_describe_datetime(job.get('date_updated'))
+			job_contents.append(
+			[
+				job_id,
+				step_total,
+				date_created,
+				date_updated,
+				job_status
+			])
+	return job_headers, job_contents
+
+
+def prepare_describe_datetime(date_time : Optional[str]) -> Optional[str]:
+	if date_time:
+		return describe_time_ago(datetime.fromisoformat(date_time))
+	return None

facefusion/jobs/job_manager.py

@@ -0,0 +1,263 @@
+import glob
+import os
+from copy import copy
+from typing import List, Optional
+
+from facefusion.choices import job_statuses
+from facefusion.date_helper import get_current_date_time
+from facefusion.filesystem import create_directory, is_directory, is_file, move_file, remove_directory, remove_file
+from facefusion.jobs.job_helper import get_step_output_path
+from facefusion.json import read_json, write_json
+from facefusion.temp_helper import create_base_directory
+from facefusion.typing import Args, Job, JobSet, JobStatus, JobStep, JobStepStatus
+
+JOBS_PATH : Optional[str] = None
+
+
+def init_jobs(jobs_path : str) -> bool:
+	global JOBS_PATH
+
+	JOBS_PATH = jobs_path
+	job_status_paths = [ os.path.join(JOBS_PATH, job_status) for job_status in job_statuses ]
+
+	create_base_directory()
+	for job_status_path in job_status_paths:
+		create_directory(job_status_path)
+	return all(is_directory(status_path) for status_path in job_status_paths)
+
+
+def clear_jobs(jobs_path : str) -> bool:
+	return remove_directory(jobs_path)
+
+
+def create_job(job_id : str) -> bool:
+	job : Job =\
+	{
+		'version': '1',
+		'date_created': get_current_date_time().isoformat(),
+		'date_updated': None,
+		'steps': []
+	}
+
+	return create_job_file(job_id, job)
+
+
+def submit_job(job_id : str) -> bool:
+	drafted_job_ids = find_job_ids('drafted')
+	steps = get_steps(job_id)
+
+	if job_id in drafted_job_ids and steps:
+		return set_steps_status(job_id, 'queued') and move_job_file(job_id, 'queued')
+	return False
+
+
+def submit_jobs() -> bool:
+	drafted_job_ids = find_job_ids('drafted')
+
+	if drafted_job_ids:
+		for job_id in drafted_job_ids:
+			if not submit_job(job_id):
+				return False
+		return True
+	return False
+
+
+def delete_job(job_id : str) -> bool:
+	return delete_job_file(job_id)
+
+
+def delete_jobs() -> bool:
+	job_ids = find_job_ids('drafted') + find_job_ids('queued') + find_job_ids('failed') + find_job_ids('completed')
+
+	if job_ids:
+		for job_id in job_ids:
+			if not delete_job(job_id):
+				return False
+		return True
+	return False
+
+
+def find_jobs(job_status : JobStatus) -> JobSet:
+	job_ids = find_job_ids(job_status)
+	jobs : JobSet = {}
+
+	for job_id in job_ids:
+		jobs[job_id] = read_job_file(job_id)
+	return jobs
+
+
+def find_job_ids(job_status : JobStatus) -> List[str]:
+	job_pattern = os.path.join(JOBS_PATH, job_status, '*.json')
+	job_files = glob.glob(job_pattern)
+	job_files.sort(key = os.path.getmtime)
+	job_ids = []
+
+	for job_file in job_files:
+		job_id, _ = os.path.splitext(os.path.basename(job_file))
+		job_ids.append(job_id)
+	return job_ids
+
+
+def validate_job(job_id : str) -> bool:
+	job = read_job_file(job_id)
+	return bool(job and 'version' in job and 'date_created' in job and 'date_updated' in job and 'steps' in job)
+
+
+def has_step(job_id : str, step_index : int) -> bool:
+	step_total = count_step_total(job_id)
+	return step_index in range(step_total)
+
+
+def add_step(job_id : str, step_args : Args) -> bool:
+	job = read_job_file(job_id)
+
+	if job:
+		job.get('steps').append(
+		{
+			'args': step_args,
+			'status': 'drafted'
+		})
+		return update_job_file(job_id, job)
+	return False
+
+
+def remix_step(job_id : str, step_index : int, step_args : Args) -> bool:
+	steps = get_steps(job_id)
+	step_args = copy(step_args)
+
+	if step_index and step_index < 0:
+		step_index = count_step_total(job_id) - 1
+
+	if has_step(job_id, step_index):
+		output_path = steps[step_index].get('args').get('output_path')
+		step_args['target_path'] = get_step_output_path(job_id, step_index, output_path)
+		return add_step(job_id, step_args)
+	return False
+
+
+def insert_step(job_id : str, step_index : int, step_args : Args) -> bool:
+	job = read_job_file(job_id)
+	step_args = copy(step_args)
+
+	if step_index and step_index < 0:
+		step_index = count_step_total(job_id) - 1
+
+	if job and has_step(job_id, step_index):
+		job.get('steps').insert(step_index,
+		{
+			'args': step_args,
+			'status': 'drafted'
+		})
+		return update_job_file(job_id, job)
+	return False
+
+
+def remove_step(job_id : str, step_index : int) -> bool:
+	job = read_job_file(job_id)
+
+	if step_index and step_index < 0:
+		step_index = count_step_total(job_id) - 1
+
+	if job and has_step(job_id, step_index):
+		job.get('steps').pop(step_index)
+		return update_job_file(job_id, job)
+	return False
+
+
+def get_steps(job_id : str) -> List[JobStep]:
+	job = read_job_file(job_id)
+
+	if job:
+		return job.get('steps')
+	return []
+
+
+def count_step_total(job_id : str) -> int:
+	steps = get_steps(job_id)
+
+	if steps:
+		return len(steps)
+	return 0
+
+
+def set_step_status(job_id : str, step_index : int, step_status : JobStepStatus) -> bool:
+	job = read_job_file(job_id)
+
+	if job:
+		steps = job.get('steps')
+
+		if has_step(job_id, step_index):
+			steps[step_index]['status'] = step_status
+			return update_job_file(job_id, job)
+	return False
+
+
+def set_steps_status(job_id : str, step_status : JobStepStatus) -> bool:
+	job = read_job_file(job_id)
+
+	if job:
+		for step in job.get('steps'):
+			step['status'] = step_status
+		return update_job_file(job_id, job)
+	return False
+
+
+def read_job_file(job_id : str) -> Optional[Job]:
+	job_path = find_job_path(job_id)
+	return read_json(job_path) #type:ignore[return-value]
+
+
+def create_job_file(job_id : str, job : Job) -> bool:
+	job_path = find_job_path(job_id)
+
+	if not is_file(job_path):
+		job_create_path = suggest_job_path(job_id, 'drafted')
+		return write_json(job_create_path, job) #type:ignore[arg-type]
+	return False
+
+
+def update_job_file(job_id : str, job : Job) -> bool:
+	job_path = find_job_path(job_id)
+
+	if is_file(job_path):
+		job['date_updated'] = get_current_date_time().isoformat()
+		return write_json(job_path, job) #type:ignore[arg-type]
+	return False
+
+
+def move_job_file(job_id : str, job_status : JobStatus) -> bool:
+	job_path = find_job_path(job_id)
+	job_move_path = suggest_job_path(job_id, job_status)
+	return move_file(job_path, job_move_path)
+
+
+def delete_job_file(job_id : str) -> bool:
+	job_path = find_job_path(job_id)
+	return remove_file(job_path)
+
+
+def suggest_job_path(job_id : str, job_status : JobStatus) -> Optional[str]:
+	job_file_name = get_job_file_name(job_id)
+
+	if job_file_name:
+		return os.path.join(JOBS_PATH, job_status, job_file_name)
+	return None
+
+
+def find_job_path(job_id : str) -> Optional[str]:
+	job_file_name = get_job_file_name(job_id)
+
+	if job_file_name:
+		for job_status in job_statuses:
+			job_pattern = os.path.join(JOBS_PATH, job_status, job_file_name)
+			job_paths = glob.glob(job_pattern)
+
+			for job_path in job_paths:
+				return job_path
+	return None
+
+
+def get_job_file_name(job_id : str) -> Optional[str]:
+	if job_id:
+		return job_id + '.json'
+	return None

facefusion/jobs/job_runner.py

@@ -0,0 +1,106 @@
+from facefusion.ffmpeg import concat_video
+from facefusion.filesystem import is_image, is_video, move_file, remove_file
+from facefusion.jobs import job_helper, job_manager
+from facefusion.typing import JobOutputSet, JobStep, ProcessStep
+
+
+def run_job(job_id : str, process_step : ProcessStep) -> bool:
+	queued_job_ids = job_manager.find_job_ids('queued')
+
+	if job_id in queued_job_ids:
+		if run_steps(job_id, process_step) and finalize_steps(job_id):
+			clean_steps(job_id)
+			return job_manager.move_job_file(job_id, 'completed')
+		clean_steps(job_id)
+		job_manager.move_job_file(job_id, 'failed')
+	return False
+
+
+def run_jobs(process_step : ProcessStep) -> bool:
+	queued_job_ids = job_manager.find_job_ids('queued')
+
+	if queued_job_ids:
+		for job_id in queued_job_ids:
+			if not run_job(job_id, process_step):
+				return False
+		return True
+	return False
+
+
+def retry_job(job_id : str, process_step : ProcessStep) -> bool:
+	failed_job_ids = job_manager.find_job_ids('failed')
+
+	if job_id in failed_job_ids:
+		return job_manager.set_steps_status(job_id, 'queued') and job_manager.move_job_file(job_id, 'queued') and run_job(job_id, process_step)
+	return False
+
+
+def retry_jobs(process_step : ProcessStep) -> bool:
+	failed_job_ids = job_manager.find_job_ids('failed')
+
+	if failed_job_ids:
+		for job_id in failed_job_ids:
+			if not retry_job(job_id, process_step):
+				return False
+		return True
+	return False
+
+
+def run_step(job_id : str, step_index : int, step : JobStep, process_step : ProcessStep) -> bool:
+	step_args = step.get('args')
+
+	if job_manager.set_step_status(job_id, step_index, 'started') and process_step(job_id, step_index, step_args):
+		output_path = step_args.get('output_path')
+		step_output_path = job_helper.get_step_output_path(job_id, step_index, output_path)
+
+		return move_file(output_path, step_output_path) and job_manager.set_step_status(job_id, step_index, 'completed')
+	job_manager.set_step_status(job_id, step_index, 'failed')
+	return False
+
+
+def run_steps(job_id : str, process_step : ProcessStep) -> bool:
+	steps = job_manager.get_steps(job_id)
+
+	if steps:
+		for index, step in enumerate(steps):
+			if not run_step(job_id, index, step, process_step):
+				return False
+		return True
+	return False
+
+
+def finalize_steps(job_id : str) -> bool:
+	output_set = collect_output_set(job_id)
+
+	for output_path, temp_output_paths in output_set.items():
+		if all(map(is_video, temp_output_paths)):
+			if not concat_video(output_path, temp_output_paths):
+				return False
+		if any(map(is_image, temp_output_paths)):
+			for temp_output_path in temp_output_paths:
+				if not move_file(temp_output_path, output_path):
+					return False
+	return True
+
+
+def clean_steps(job_id: str) -> bool:
+	output_set = collect_output_set(job_id)
+
+	for temp_output_paths in output_set.values():
+		for temp_output_path in temp_output_paths:
+			if not remove_file(temp_output_path):
+				return False
+	return True
+
+
+def collect_output_set(job_id : str) -> JobOutputSet:
+	steps = job_manager.get_steps(job_id)
+	output_set : JobOutputSet = {}
+
+	for index, step in enumerate(steps):
+		output_path = step.get('args').get('output_path')
+
+		if output_path:
+			step_output_path = job_manager.get_step_output_path(job_id, index, output_path)
+			output_set.setdefault(output_path, []).append(step_output_path)
+	return output_set

facefusion/jobs/job_store.py

@@ -0,0 +1,27 @@
+from typing import List
+
+from facefusion.typing import JobStore
+
+JOB_STORE : JobStore =\
+{
+	'job_keys': [],
+	'step_keys': []
+}
+
+
+def get_job_keys() -> List[str]:
+	return JOB_STORE.get('job_keys')
+
+
+def get_step_keys() -> List[str]:
+	return JOB_STORE.get('step_keys')
+
+
+def register_job_keys(step_keys : List[str]) -> None:
+	for step_key in step_keys:
+		JOB_STORE['job_keys'].append(step_key)
+
+
+def register_step_keys(job_keys : List[str]) -> None:
+	for job_key in job_keys:
+		JOB_STORE['step_keys'].append(job_key)

facefusion/json.py

@@ -0,0 +1,22 @@
+import json
+from json import JSONDecodeError
+from typing import Optional
+
+from facefusion.filesystem import is_file
+from facefusion.typing import Content
+
+
+def read_json(json_path : str) -> Optional[Content]:
+	if is_file(json_path):
+		try:
+			with open(json_path, 'r') as json_file:
+				return json.load(json_file)
+		except JSONDecodeError:
+			pass
+	return None
+
+
+def write_json(json_path : str, content : Content) -> bool:
+	with open(json_path, 'w') as json_file:
+		json.dump(content, json_file, indent = 4)
+	return is_file(json_path)

facefusion/logger.py

@@ -0,0 +1,80 @@
+from logging import Logger, basicConfig, getLogger
+from typing import Tuple
+
+from facefusion.choices import log_level_set
+from facefusion.common_helper import get_first, get_last
+from facefusion.typing import LogLevel, TableContents, TableHeaders
+
+
+def init(log_level : LogLevel) -> None:
+	basicConfig(format = '%(message)s')
+	get_package_logger().setLevel(log_level_set.get(log_level))
+
+
+def get_package_logger() -> Logger:
+	return getLogger('facefusion')
+
+
+def debug(message : str, module_name : str) -> None:
+	get_package_logger().debug(create_message(message, module_name))
+
+
+def info(message : str, module_name : str) -> None:
+	get_package_logger().info(create_message(message, module_name))
+
+
+def warn(message : str, module_name : str) -> None:
+	get_package_logger().warning(create_message(message, module_name))
+
+
+def error(message : str, module_name : str) -> None:
+	get_package_logger().error(create_message(message, module_name))
+
+
+def create_message(message : str, module_name : str) -> str:
+	scopes = module_name.split('.')
+	first_scope = get_first(scopes)
+	last_scope = get_last(scopes)
+
+	if first_scope and last_scope:
+		return '[' + first_scope.upper() + '.' + last_scope.upper() + '] ' + message
+	return message
+
+
+def table(headers : TableHeaders, contents : TableContents) -> None:
+	package_logger = get_package_logger()
+	table_column, table_separator = create_table_parts(headers, contents)
+
+	package_logger.info(table_separator)
+	package_logger.info(table_column.format(*headers))
+	package_logger.info(table_separator)
+
+	for content in contents:
+		content = [ value if value else '' for value in content ]
+		package_logger.info(table_column.format(*content))
+
+	package_logger.info(table_separator)
+
+
+def create_table_parts(headers : TableHeaders, contents : TableContents) -> Tuple[str, str]:
+	column_parts = []
+	separator_parts = []
+	widths = [ len(header) for header in headers ]
+
+	for content in contents:
+		for index, value in enumerate(content):
+			widths[index] = max(widths[index], len(str(value)))
+
+	for width in widths:
+		column_parts.append('{:<' + str(width) + '}')
+		separator_parts.append('-' * width)
+
+	return '| ' + ' | '.join(column_parts) + ' |', '+-' + '-+-'.join(separator_parts) + '-+'
+
+
+def enable() -> None:
+	get_package_logger().disabled = False
+
+
+def disable() -> None:
+	get_package_logger().disabled = True

facefusion/memory.py

@@ -0,0 +1,21 @@
+from facefusion.common_helper import is_macos, is_windows
+
+if is_windows():
+	import ctypes
+else:
+	import resource
+
+
+def limit_system_memory(system_memory_limit : int = 1) -> bool:
+	if is_macos():
+		system_memory_limit = system_memory_limit * (1024 ** 6)
+	else:
+		system_memory_limit = system_memory_limit * (1024 ** 3)
+	try:
+		if is_windows():
+			ctypes.windll.kernel32.SetProcessWorkingSetSize(-1, ctypes.c_size_t(system_memory_limit), ctypes.c_size_t(system_memory_limit)) #type:ignore[attr-defined]
+		else:
+			resource.setrlimit(resource.RLIMIT_DATA, (system_memory_limit, system_memory_limit))
+		return True
+	except Exception:
+		return False

facefusion/metadata.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+METADATA =\
+{
+	'name': 'FaceFusion',
+	'description': 'Industry leading face manipulation platform',
+	'version': '3.0.0',
+	'license': 'MIT',
+	'author': 'Henry Ruhs',
+	'url': 'https://facefusion.io'
+}
+
+
+def get(key : str) -> Optional[str]:
+	if key in METADATA:
+		return METADATA.get(key)
+	return None

facefusion/normalizer.py

@@ -0,0 +1,21 @@
+from typing import List, Optional
+
+from facefusion.typing import Fps, Padding
+
+
+def normalize_padding(padding : Optional[List[int]]) -> Optional[Padding]:
+	if padding and len(padding) == 1:
+		return tuple([ padding[0] ] * 4) #type:ignore[return-value]
+	if padding and len(padding) == 2:
+		return tuple([ padding[0], padding[1], padding[0], padding[1] ]) #type:ignore[return-value]
+	if padding and len(padding) == 3:
+		return tuple([ padding[0], padding[1], padding[2], padding[1] ]) #type:ignore[return-value]
+	if padding and len(padding) == 4:
+		return tuple(padding) #type:ignore[return-value]
+	return None
+
+
+def normalize_fps(fps : Optional[float]) -> Optional[Fps]:
+	if isinstance(fps, (int, float)):
+		return max(1.0, min(fps, 60.0))
+	return None

facefusion/process_manager.py

@@ -0,0 +1,53 @@
+from typing import Generator, List
+
+from facefusion.typing import ProcessState, QueuePayload
+
+PROCESS_STATE : ProcessState = 'pending'
+
+
+def get_process_state() -> ProcessState:
+	return PROCESS_STATE
+
+
+def set_process_state(process_state : ProcessState) -> None:
+	global PROCESS_STATE
+
+	PROCESS_STATE = process_state
+
+
+def is_checking() -> bool:
+	return get_process_state() == 'checking'
+
+
+def is_processing() -> bool:
+	return get_process_state() == 'processing'
+
+
+def is_stopping() -> bool:
+	return get_process_state() == 'stopping'
+
+
+def is_pending() -> bool:
+	return get_process_state() == 'pending'
+
+
+def check() -> None:
+	set_process_state('checking')
+
+
+def start() -> None:
+	set_process_state('processing')
+
+
+def stop() -> None:
+	set_process_state('stopping')
+
+
+def end() -> None:
+	set_process_state('pending')
+
+
+def manage(queue_payloads : List[QueuePayload]) -> Generator[QueuePayload, None, None]:
+	for query_payload in queue_payloads:
+		if is_processing():
+			yield query_payload

facefusion/processors/choices.py

@@ -0,0 +1,46 @@
+from typing import List, Sequence
+
+from facefusion.common_helper import create_float_range, create_int_range
+from facefusion.processors.typing import AgeModifierModel, ExpressionRestorerModel, FaceDebuggerItem, FaceEditorModel, FaceEnhancerModel, FaceSwapperSet, FrameColorizerModel, FrameEnhancerModel, LipSyncerModel
+
+age_modifier_models : List[AgeModifierModel] = [ 'styleganex_age' ]
+expression_restorer_models : List[ExpressionRestorerModel] = [ 'live_portrait' ]
+face_debugger_items : List[FaceDebuggerItem] = [ 'bounding-box', 'face-landmark-5', 'face-landmark-5/68', 'face-landmark-68', 'face-landmark-68/5', 'face-mask', 'face-detector-score', 'face-landmarker-score', 'age', 'gender', 'race' ]
+face_editor_models : List[FaceEditorModel] = [ 'live_portrait' ]
+face_enhancer_models : List[FaceEnhancerModel] = [ 'codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'gpen_bfr_1024', 'gpen_bfr_2048', 'restoreformer_plus_plus' ]
+face_swapper_set : FaceSwapperSet =\
+{
+	'blendswap_256': [ '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
+	'ghost_1_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
+	'ghost_2_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
+	'ghost_3_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
+	'inswapper_128': [ '128x128', '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
+	'inswapper_128_fp16': [ '128x128', '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
+	'simswap_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
+	'simswap_unofficial_512': [ '512x512', '768x768', '1024x1024' ],
+	'uniface_256': [ '256x256', '512x512', '768x768', '1024x1024' ]
+}
+frame_colorizer_models : List[FrameColorizerModel] = [ 'ddcolor', 'ddcolor_artistic', 'deoldify', 'deoldify_artistic', 'deoldify_stable' ]
+frame_colorizer_sizes : List[str] = [ '192x192', '256x256', '384x384', '512x512' ]
+frame_enhancer_models : List[FrameEnhancerModel] = [ 'clear_reality_x4', 'lsdir_x4', 'nomos8k_sc_x4', 'real_esrgan_x2', 'real_esrgan_x2_fp16', 'real_esrgan_x4', 'real_esrgan_x4_fp16', 'real_esrgan_x8', 'real_esrgan_x8_fp16', 'real_hatgan_x4', 'span_kendata_x4', 'ultra_sharp_x4' ]
+lip_syncer_models : List[LipSyncerModel] = [ 'wav2lip_96', 'wav2lip_gan_96' ]
+
+age_modifier_direction_range : Sequence[int] = create_int_range(-100, 100, 1)
+expression_restorer_factor_range : Sequence[int] = create_int_range(0, 100, 1)
+face_editor_eyebrow_direction_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_eye_gaze_horizontal_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_eye_gaze_vertical_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_eye_open_ratio_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_lip_open_ratio_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_mouth_grim_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_mouth_pout_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_mouth_purse_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_mouth_smile_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_mouth_position_horizontal_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_mouth_position_vertical_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_head_pitch_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_head_yaw_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_editor_head_roll_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
+face_enhancer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
+frame_colorizer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
+frame_enhancer_blend_range : Sequence[int] = create_int_range(0, 100, 1)

facefusion/processors/core.py

@@ -0,0 +1,110 @@
+import importlib
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from queue import Queue
+from types import ModuleType
+from typing import Any, List
+
+from tqdm import tqdm
+
+from facefusion import logger, state_manager, wording
+from facefusion.exit_helper import hard_exit
+from facefusion.typing import ProcessFrames, QueuePayload
+
+PROCESSORS_METHODS =\
+[
+	'get_inference_pool',
+	'clear_inference_pool',
+	'register_args',
+	'apply_args',
+	'pre_check',
+	'pre_process',
+	'post_process',
+	'get_reference_frame',
+	'process_frame',
+	'process_frames',
+	'process_image',
+	'process_video'
+]
+
+
+def load_processor_module(processor : str) -> Any:
+	try:
+		processor_module = importlib.import_module('facefusion.processors.modules.' + processor)
+		for method_name in PROCESSORS_METHODS:
+			if not hasattr(processor_module, method_name):
+				raise NotImplementedError
+	except ModuleNotFoundError as exception:
+		logger.error(wording.get('processor_not_loaded').format(processor = processor), __name__)
+		logger.debug(exception.msg, __name__)
+		hard_exit(1)
+	except NotImplementedError:
+		logger.error(wording.get('processor_not_implemented').format(processor = processor), __name__)
+		hard_exit(1)
+	return processor_module
+
+
+def get_processors_modules(processors : List[str]) -> List[ModuleType]:
+	processor_modules = []
+
+	for processor in processors:
+		processor_module = load_processor_module(processor)
+		processor_modules.append(processor_module)
+	return processor_modules
+
+
+def clear_processors_modules(processors : List[str]) -> None:
+	for processor in processors:
+		processor_module = load_processor_module(processor)
+		processor_module.clear_inference_pool()
+
+
+def multi_process_frames(source_paths : List[str], temp_frame_paths : List[str], process_frames : ProcessFrames) -> None:
+	queue_payloads = create_queue_payloads(temp_frame_paths)
+	with tqdm(total = len(queue_payloads), desc = wording.get('processing'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
+		progress.set_postfix(
+		{
+			'execution_providers': state_manager.get_item('execution_providers'),
+			'execution_thread_count': state_manager.get_item('execution_thread_count'),
+			'execution_queue_count': state_manager.get_item('execution_queue_count')
+		})
+		with ThreadPoolExecutor(max_workers = state_manager.get_item('execution_thread_count')) as executor:
+			futures = []
+			queue : Queue[QueuePayload] = create_queue(queue_payloads)
+			queue_per_future = max(len(queue_payloads) // state_manager.get_item('execution_thread_count') * state_manager.get_item('execution_queue_count'), 1)
+
+			while not queue.empty():
+				future = executor.submit(process_frames, source_paths, pick_queue(queue, queue_per_future), progress.update)
+				futures.append(future)
+
+			for future_done in as_completed(futures):
+				future_done.result()
+
+
+def create_queue(queue_payloads : List[QueuePayload]) -> Queue[QueuePayload]:
+	queue : Queue[QueuePayload] = Queue()
+	for queue_payload in queue_payloads:
+		queue.put(queue_payload)
+	return queue
+
+
+def pick_queue(queue : Queue[QueuePayload], queue_per_future : int) -> List[QueuePayload]:
+	queues = []
+	for _ in range(queue_per_future):
+		if not queue.empty():
+			queues.append(queue.get())
+	return queues
+
+
+def create_queue_payloads(temp_frame_paths : List[str]) -> List[QueuePayload]:
+	queue_payloads = []
+	temp_frame_paths = sorted(temp_frame_paths, key = os.path.basename)
+
+	for frame_number, frame_path in enumerate(temp_frame_paths):
+		frame_payload : QueuePayload =\
+		{
+			'frame_number': frame_number,
+			'frame_path': frame_path
+		}
+		queue_payloads.append(frame_payload)
+	return queue_payloads

facefusion/processors/live_portrait.py

@@ -0,0 +1,101 @@
+from typing import Tuple
+
+import numpy
+import scipy
+
+from facefusion.processors.typing import LivePortraitExpression, LivePortraitPitch, LivePortraitRoll, LivePortraitRotation, LivePortraitYaw
+
+EXPRESSION_MIN = numpy.array(
+[
+	[
+		[ -2.88067125e-02, -8.12731311e-02, -1.70541159e-03 ],
+		[ -4.88598682e-02, -3.32196616e-02, -1.67431499e-04 ],
+		[ -6.75425082e-02, -4.28681746e-02, -1.98950816e-04 ],
+		[ -7.23103955e-02, -3.28503326e-02, -7.31324719e-04 ],
+		[ -3.87073644e-02, -6.01546466e-02, -5.50269964e-04 ],
+		[ -6.38048723e-02, -2.23840728e-01, -7.13261834e-04 ],
+		[ -3.02710701e-02, -3.93195450e-02, -8.24086510e-06 ],
+		[ -2.95799859e-02, -5.39318882e-02, -1.74219604e-04 ],
+		[ -2.92359516e-02, -1.53050944e-02, -6.30460854e-05 ],
+		[ -5.56493877e-03, -2.34344602e-02, -1.26858242e-04 ],
+		[ -4.37593013e-02, -2.77768299e-02, -2.70503685e-02 ],
+		[ -1.76926646e-02, -1.91676542e-02, -1.15090821e-04 ],
+		[ -8.34268332e-03, -3.99775570e-03, -3.27481248e-05 ],
+		[ -3.40162888e-02, -2.81868968e-02, -1.96679524e-04 ],
+		[ -2.91855410e-02, -3.97511162e-02, -2.81230678e-05 ],
+		[ -1.50395725e-02, -2.49494594e-02, -9.42573533e-05 ],
+		[ -1.67938769e-02, -2.00953931e-02, -4.00750607e-04 ],
+		[ -1.86435618e-02, -2.48535164e-02, -2.74416432e-02 ],
+		[ -4.61211195e-03, -1.21660791e-02, -2.93173041e-04 ],
+		[ -4.10017073e-02, -7.43824020e-02, -4.42762971e-02 ],
+		[ -1.90370996e-02, -3.74363363e-02, -1.34740388e-02 ]
+	]
+]).astype(numpy.float32)
+EXPRESSION_MAX = numpy.array(
+[
+	[
+		[ 4.46682945e-02, 7.08772913e-02, 4.08344204e-04 ],
+		[ 2.14308221e-02, 6.15894832e-02, 4.85319615e-05 ],
+		[ 3.02363783e-02, 4.45043296e-02, 1.28298725e-05 ],
+		[ 3.05869691e-02, 3.79812494e-02, 6.57040102e-04 ],
+		[ 4.45670523e-02, 3.97259220e-02, 7.10966764e-04 ],
+		[ 9.43699256e-02, 9.85926315e-02, 2.02551950e-04 ],
+		[ 1.61131397e-02, 2.92906128e-02, 3.44733417e-06 ],
+		[ 5.23825921e-02, 1.07065082e-01, 6.61510974e-04 ],
+		[ 2.85718683e-03, 8.32320191e-03, 2.39314613e-04 ],
+		[ 2.57947259e-02, 1.60935968e-02, 2.41853559e-05 ],
+		[ 4.90833223e-02, 3.43903080e-02, 3.22353356e-02 ],
+		[ 1.44766076e-02, 3.39248963e-02, 1.42291479e-04 ],
+		[ 8.75749043e-04, 6.82212645e-03, 2.76097053e-05 ],
+		[ 1.86958015e-02, 3.84016186e-02, 7.33085908e-05 ],
+		[ 2.01714113e-02, 4.90544215e-02, 2.34028921e-05 ],
+		[ 2.46518422e-02, 3.29151377e-02, 3.48571630e-05 ],
+		[ 2.22457591e-02, 1.21796541e-02, 1.56396593e-04 ],
+		[ 1.72109623e-02, 3.01626958e-02, 1.36556877e-02 ],
+		[ 1.83460284e-02, 1.61141958e-02, 2.87440169e-04 ],
+		[ 3.57594155e-02, 1.80554688e-01, 2.75554154e-02 ],
+		[ 2.17450950e-02, 8.66811201e-02, 3.34241726e-02 ]
+	]
+]).astype(numpy.float32)
+
+
+def limit_expression(expression : LivePortraitExpression) -> LivePortraitExpression:
+	return numpy.clip(expression, EXPRESSION_MIN, EXPRESSION_MAX)
+
+
+def limit_euler_angles(target_pitch : LivePortraitPitch, target_yaw : LivePortraitYaw, target_roll : LivePortraitRoll, output_pitch : LivePortraitPitch, output_yaw : LivePortraitYaw, output_roll : LivePortraitRoll) -> Tuple[LivePortraitPitch, LivePortraitYaw, LivePortraitRoll]:
+	pitch_min, pitch_max, yaw_min, yaw_max, roll_min, roll_max = calc_euler_limits(target_pitch, target_yaw, target_roll)
+	output_pitch = numpy.clip(output_pitch, pitch_min, pitch_max)
+	output_yaw = numpy.clip(output_yaw, yaw_min, yaw_max)
+	output_roll = numpy.clip(output_roll, roll_min, roll_max)
+	return output_pitch, output_yaw, output_roll
+
+
+def calc_euler_limits(pitch : LivePortraitPitch, yaw : LivePortraitYaw, roll : LivePortraitRoll) -> Tuple[float, float, float, float, float, float]:
+	pitch_min = -30.0
+	pitch_max = 30.0
+	yaw_min = -60.0
+	yaw_max = 60.0
+	roll_min = -20.0
+	roll_max = 20.0
+
+	if pitch < 0:
+		pitch_min = min(pitch, pitch_min)
+	else:
+		pitch_max = max(pitch, pitch_max)
+	if yaw < 0:
+		yaw_min = min(yaw, yaw_min)
+	else:
+		yaw_max = max(yaw, yaw_max)
+	if roll < 0:
+		roll_min = min(roll, roll_min)
+	else:
+		roll_max = max(roll, roll_max)
+
+	return pitch_min, pitch_max, yaw_min, yaw_max, roll_min, roll_max
+
+
+def create_rotation(pitch : LivePortraitPitch, yaw : LivePortraitYaw, roll : LivePortraitRoll) -> LivePortraitRotation:
+	rotation = scipy.spatial.transform.Rotation.from_euler('xyz', [ pitch, yaw, roll ], degrees = True).as_matrix()
+	rotation = rotation.astype(numpy.float32)
+	return rotation

facefusion/processors/modules/age_modifier.py

@@ -0,0 +1,268 @@
+from argparse import ArgumentParser
+from typing import Any, List
+
+import cv2
+import numpy
+from cv2.typing import Size
+from numpy.typing import NDArray
+
+import facefusion.jobs.job_manager
+import facefusion.jobs.job_store
+import facefusion.processors.core as processors
+from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, wording
+from facefusion.common_helper import create_int_metavar
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_analyser import get_many_faces, get_one_face
+from facefusion.face_helper import merge_matrix, paste_back, scale_face_landmark_5, warp_face_by_face_landmark_5
+from facefusion.face_masker import create_occlusion_mask, create_static_box_mask
+from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
+from facefusion.face_store import get_reference_faces
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.processors import choices as processors_choices
+from facefusion.processors.typing import AgeModifierInputs
+from facefusion.program_helper import find_argument_group
+from facefusion.thread_helper import thread_semaphore
+from facefusion.typing import ApplyStateItem, Args, Face, InferencePool, Mask, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
+from facefusion.vision import read_image, read_static_image, write_image
+
+MODEL_SET : ModelSet =\
+{
+	'styleganex_age':
+	{
+		'hashes':
+		{
+			'age_modifier':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/styleganex_age.hash',
+				'path': resolve_relative_path('../.assets/models/styleganex_age.hash')
+			}
+		},
+		'sources':
+		{
+			'age_modifier':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/styleganex_age.onnx',
+				'path': resolve_relative_path('../.assets/models/styleganex_age.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	model_context = __name__ + '.' + state_manager.get_item('age_modifier_model')
+	return inference_manager.get_inference_pool(model_context, model_sources)
+
+
+def clear_inference_pool() -> None:
+	model_context = __name__ + '.' + state_manager.get_item('age_modifier_model')
+	inference_manager.clear_inference_pool(model_context)
+
+
+def get_model_options() -> ModelOptions:
+	age_modifier_model = state_manager.get_item('age_modifier_model')
+	return MODEL_SET.get(age_modifier_model)
+
+
+def register_args(program : ArgumentParser) -> None:
+	group_processors = find_argument_group(program, 'processors')
+	if group_processors:
+		group_processors.add_argument('--age-modifier-model', help = wording.get('help.age_modifier_model'), default = config.get_str_value('processors.age_modifier_model', 'styleganex_age'), choices = processors_choices.age_modifier_models)
+		group_processors.add_argument('--age-modifier-direction', help = wording.get('help.age_modifier_direction'), type = int, default = config.get_int_value('processors.age_modifier_direction', '0'), choices = processors_choices.age_modifier_direction_range, metavar = create_int_metavar(processors_choices.age_modifier_direction_range))
+		facefusion.jobs.job_store.register_step_keys([ 'age_modifier_model', 'age_modifier_direction' ])
+
+
+def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
+	apply_state_item('age_modifier_model', args.get('age_modifier_model'))
+	apply_state_item('age_modifier_direction', args.get('age_modifier_direction'))
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
+		logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+		logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not same_file_extension([ state_manager.get_item('target_path'), state_manager.get_item('output_path') ]):
+		logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
+		return False
+	return True
+
+
+def post_process() -> None:
+	read_static_image.cache_clear()
+	if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
+		clear_inference_pool()
+	if state_manager.get_item('video_memory_strategy') == 'strict':
+		content_analyser.clear_inference_pool()
+		face_classifier.clear_inference_pool()
+		face_detector.clear_inference_pool()
+		face_landmarker.clear_inference_pool()
+		face_masker.clear_inference_pool()
+		face_recognizer.clear_inference_pool()
+
+
+def modify_age(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	crop_size = (model_size[0] // 2, model_size[1] // 2)
+	face_landmark_5 = target_face.landmark_set.get('5/68').copy()
+	extend_face_landmark_5 = scale_face_landmark_5(face_landmark_5, 2.0)
+	crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, crop_size)
+	extend_vision_frame, extend_affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, extend_face_landmark_5, model_template, model_size)
+	extend_vision_frame_raw = extend_vision_frame.copy()
+	box_mask = create_static_box_mask(model_size, state_manager.get_item('face_mask_blur'), (0, 0, 0, 0))
+	crop_masks =\
+	[
+		box_mask
+	]
+
+	if 'occlusion' in state_manager.get_item('face_mask_types'):
+		occlusion_mask = create_occlusion_mask(crop_vision_frame)
+		combined_matrix = merge_matrix([ extend_affine_matrix, cv2.invertAffineTransform(affine_matrix) ])
+		occlusion_mask = cv2.warpAffine(occlusion_mask, combined_matrix, model_size)
+		crop_masks.append(occlusion_mask)
+
+	crop_vision_frame = prepare_vision_frame(crop_vision_frame)
+	extend_vision_frame = prepare_vision_frame(extend_vision_frame)
+	extend_vision_frame = forward(crop_vision_frame, extend_vision_frame)
+	extend_vision_frame = normalize_extend_frame(extend_vision_frame)
+	extend_vision_frame = fix_color(extend_vision_frame_raw, extend_vision_frame)
+	extend_crop_mask = cv2.pyrUp(numpy.minimum.reduce(crop_masks).clip(0, 1))
+	extend_affine_matrix *= extend_vision_frame.shape[0] / 512
+	paste_vision_frame = paste_back(temp_vision_frame, extend_vision_frame, extend_crop_mask, extend_affine_matrix)
+	return paste_vision_frame
+
+
+def forward(crop_vision_frame : VisionFrame, extend_vision_frame : VisionFrame) -> VisionFrame:
+	age_modifier = get_inference_pool().get('age_modifier')
+	age_modifier_inputs = {}
+
+	for age_modifier_input in age_modifier.get_inputs():
+		if age_modifier_input.name == 'target':
+			age_modifier_inputs[age_modifier_input.name] = crop_vision_frame
+		if age_modifier_input.name == 'target_with_background':
+			age_modifier_inputs[age_modifier_input.name] = extend_vision_frame
+		if age_modifier_input.name == 'direction':
+			age_modifier_inputs[age_modifier_input.name] = prepare_direction(state_manager.get_item('age_modifier_direction'))
+
+	with thread_semaphore():
+		crop_vision_frame = age_modifier.run(None, age_modifier_inputs)[0][0]
+
+	return crop_vision_frame
+
+
+def fix_color(extend_vision_frame_raw : VisionFrame, extend_vision_frame : VisionFrame) -> VisionFrame:
+	color_difference = compute_color_difference(extend_vision_frame_raw, extend_vision_frame, (48, 48))
+	color_difference_mask = create_static_box_mask(extend_vision_frame.shape[:2][::-1], 1.0, (0, 0, 0, 0))
+	color_difference_mask = numpy.stack((color_difference_mask, ) * 3, axis = -1)
+	extend_vision_frame = normalize_color_difference(color_difference, color_difference_mask, extend_vision_frame)
+	return extend_vision_frame
+
+
+def compute_color_difference(extend_vision_frame_raw : VisionFrame, extend_vision_frame : VisionFrame, size : Size) -> VisionFrame:
+	extend_vision_frame_raw = extend_vision_frame_raw.astype(numpy.float32) / 255
+	extend_vision_frame_raw = cv2.resize(extend_vision_frame_raw, size, interpolation = cv2.INTER_AREA)
+	extend_vision_frame = extend_vision_frame.astype(numpy.float32) / 255
+	extend_vision_frame = cv2.resize(extend_vision_frame, size, interpolation = cv2.INTER_AREA)
+	color_difference = extend_vision_frame_raw - extend_vision_frame
+	return color_difference
+
+
+def normalize_color_difference(color_difference : VisionFrame, color_difference_mask : Mask, extend_vision_frame : VisionFrame) -> VisionFrame:
+	color_difference = cv2.resize(color_difference, extend_vision_frame.shape[:2][::-1], interpolation = cv2.INTER_CUBIC)
+	color_difference_mask = 1 - color_difference_mask.clip(0, 0.75)
+	extend_vision_frame = extend_vision_frame.astype(numpy.float32) / 255
+	extend_vision_frame += color_difference * color_difference_mask
+	extend_vision_frame = extend_vision_frame.clip(0, 1)
+	extend_vision_frame = numpy.multiply(extend_vision_frame, 255).astype(numpy.uint8)
+	return extend_vision_frame
+
+
+def prepare_direction(direction : int) -> NDArray[Any]:
+	direction = numpy.interp(float(direction), [ -100, 100 ], [ 2.5, -2.5 ]) #type:ignore[assignment]
+	return numpy.array(direction).astype(numpy.float32)
+
+
+def prepare_vision_frame(vision_frame : VisionFrame) -> VisionFrame:
+	vision_frame = vision_frame[:, :, ::-1] / 255.0
+	vision_frame = (vision_frame - 0.5) / 0.5
+	vision_frame = numpy.expand_dims(vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return vision_frame
+
+
+def normalize_extend_frame(extend_vision_frame : VisionFrame) -> VisionFrame:
+	extend_vision_frame = numpy.clip(extend_vision_frame, -1, 1)
+	extend_vision_frame = (extend_vision_frame + 1) / 2
+	extend_vision_frame = extend_vision_frame.transpose(1, 2, 0).clip(0, 255)
+	extend_vision_frame = (extend_vision_frame * 255.0)
+	extend_vision_frame = extend_vision_frame.astype(numpy.uint8)[:, :, ::-1]
+	extend_vision_frame = cv2.pyrDown(extend_vision_frame)
+	return extend_vision_frame
+
+
+def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	return modify_age(target_face, temp_vision_frame)
+
+
+def process_frame(inputs : AgeModifierInputs) -> VisionFrame:
+	reference_faces = inputs.get('reference_faces')
+	target_vision_frame = inputs.get('target_vision_frame')
+	many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
+
+	if state_manager.get_item('face_selector_mode') == 'many':
+		if many_faces:
+			for target_face in many_faces:
+				target_vision_frame = modify_age(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'one':
+		target_face = get_one_face(many_faces)
+		if target_face:
+			target_vision_frame = modify_age(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'reference':
+		similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
+		if similar_faces:
+			for similar_face in similar_faces:
+				target_vision_frame = modify_age(similar_face, target_vision_frame)
+	return target_vision_frame
+
+
+def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+
+	for queue_payload in process_manager.manage(queue_payloads):
+		target_vision_path = queue_payload['frame_path']
+		target_vision_frame = read_image(target_vision_path)
+		output_vision_frame = process_frame(
+		{
+			'reference_faces': reference_faces,
+			'target_vision_frame': target_vision_frame
+		})
+		write_image(target_vision_path, output_vision_frame)
+		update_progress(1)
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+	target_vision_frame = read_static_image(target_path)
+	output_vision_frame = process_frame(
+	{
+		'reference_faces': reference_faces,
+		'target_vision_frame': target_vision_frame
+	})
+	write_image(output_path, output_vision_frame)
+
+
+def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
+	processors.multi_process_frames(None, temp_frame_paths, process_frames)

facefusion/processors/modules/expression_restorer.py

@@ -0,0 +1,290 @@
+from argparse import ArgumentParser
+from typing import List, Tuple
+
+import cv2
+import numpy
+
+import facefusion.jobs.job_manager
+import facefusion.jobs.job_store
+import facefusion.processors.core as processors
+from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, wording
+from facefusion.common_helper import create_int_metavar
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_analyser import get_many_faces, get_one_face
+from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
+from facefusion.face_masker import create_occlusion_mask, create_static_box_mask
+from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
+from facefusion.face_store import get_reference_faces
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.processors import choices as processors_choices
+from facefusion.processors.live_portrait import create_rotation, limit_expression
+from facefusion.processors.typing import ExpressionRestorerInputs
+from facefusion.processors.typing import LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw
+from facefusion.program_helper import find_argument_group
+from facefusion.thread_helper import conditional_thread_semaphore, thread_semaphore
+from facefusion.typing import ApplyStateItem, Args, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
+from facefusion.vision import get_video_frame, read_image, read_static_image, write_image
+
+MODEL_SET : ModelSet =\
+{
+	'live_portrait':
+	{
+		'hashes':
+		{
+			'feature_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_feature_extractor.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_feature_extractor.hash')
+			},
+			'motion_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_motion_extractor.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_motion_extractor.hash')
+			},
+			'generator':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_generator.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_generator.hash')
+			}
+		},
+		'sources':
+		{
+			'feature_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_feature_extractor.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_feature_extractor.onnx')
+			},
+			'motion_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_motion_extractor.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_motion_extractor.onnx')
+			},
+			'generator':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_generator.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_generator.onnx')
+			}
+		},
+		'template': 'arcface_128_v2',
+		'size': (512, 512)
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	model_context = __name__ + '.' + state_manager.get_item('expression_restorer_model')
+	return inference_manager.get_inference_pool(model_context, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def get_model_options() -> ModelOptions:
+	expression_restorer_model = state_manager.get_item('expression_restorer_model')
+	return MODEL_SET.get(expression_restorer_model)
+
+
+def register_args(program : ArgumentParser) -> None:
+	group_processors = find_argument_group(program, 'processors')
+	if group_processors:
+		group_processors.add_argument('--expression-restorer-model', help = wording.get('help.expression_restorer_model'), default = config.get_str_value('processors.expression_restorer_model', 'live_portrait'), choices = processors_choices.expression_restorer_models)
+		group_processors.add_argument('--expression-restorer-factor', help = wording.get('help.expression_restorer_factor'), type = int, default = config.get_int_value('processors.expression_restorer_factor', '80'), choices = processors_choices.expression_restorer_factor_range, metavar = create_int_metavar(processors_choices.expression_restorer_factor_range))
+		facefusion.jobs.job_store.register_step_keys([ 'expression_restorer_model','expression_restorer_factor' ])
+
+
+def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
+	apply_state_item('expression_restorer_model', args.get('expression_restorer_model'))
+	apply_state_item('expression_restorer_factor', args.get('expression_restorer_factor'))
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
+		logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+		logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not same_file_extension([ state_manager.get_item('target_path'), state_manager.get_item('output_path') ]):
+		logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
+		return False
+	return True
+
+
+def post_process() -> None:
+	read_static_image.cache_clear()
+	if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
+		clear_inference_pool()
+	if state_manager.get_item('video_memory_strategy') == 'strict':
+		content_analyser.clear_inference_pool()
+		face_classifier.clear_inference_pool()
+		face_detector.clear_inference_pool()
+		face_landmarker.clear_inference_pool()
+		face_masker.clear_inference_pool()
+		face_recognizer.clear_inference_pool()
+
+
+def restore_expression(source_vision_frame : VisionFrame, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	expression_restorer_factor = float(numpy.interp(float(state_manager.get_item('expression_restorer_factor')), [ 0, 100 ], [ 0, 1.2 ]))
+	source_vision_frame = cv2.resize(source_vision_frame, temp_vision_frame.shape[:2][::-1])
+	source_crop_vision_frame, _ = warp_face_by_face_landmark_5(source_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
+	target_crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
+	box_mask = create_static_box_mask(target_crop_vision_frame.shape[:2][::-1], state_manager.get_item('face_mask_blur'), (0, 0, 0, 0))
+	crop_masks =\
+	[
+		box_mask
+	]
+
+	if 'occlusion' in state_manager.get_item('face_mask_types'):
+		occlusion_mask = create_occlusion_mask(target_crop_vision_frame)
+		crop_masks.append(occlusion_mask)
+
+	source_crop_vision_frame = prepare_crop_frame(source_crop_vision_frame)
+	target_crop_vision_frame = prepare_crop_frame(target_crop_vision_frame)
+	target_crop_vision_frame = apply_restore(source_crop_vision_frame, target_crop_vision_frame, expression_restorer_factor)
+	target_crop_vision_frame = normalize_crop_frame(target_crop_vision_frame)
+	crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
+	temp_vision_frame = paste_back(temp_vision_frame, target_crop_vision_frame, crop_mask, affine_matrix)
+	return temp_vision_frame
+
+
+def apply_restore(source_crop_vision_frame : VisionFrame, target_crop_vision_frame : VisionFrame, expression_restorer_factor : float) -> VisionFrame:
+	feature_volume = forward_extract_feature(target_crop_vision_frame)
+	source_expression = forward_extract_motion(source_crop_vision_frame)[5]
+	pitch, yaw, roll, scale, translation, target_expression, motion_points = forward_extract_motion(target_crop_vision_frame)
+	rotation = create_rotation(pitch, yaw, roll)
+	source_expression[:, [ 0, 4, 5, 8, 9 ]] = target_expression[:, [ 0, 4, 5, 8, 9 ]]
+	source_expression = source_expression * expression_restorer_factor + target_expression * (1 - expression_restorer_factor)
+	source_expression = limit_expression(source_expression)
+	source_motion_points = scale * (motion_points @ rotation.T + source_expression) + translation
+	target_motion_points = scale * (motion_points @ rotation.T + target_expression) + translation
+	crop_vision_frame = forward_generate_frame(feature_volume, source_motion_points, target_motion_points)
+	return crop_vision_frame
+
+
+def forward_extract_feature(crop_vision_frame : VisionFrame) -> LivePortraitFeatureVolume:
+	feature_extractor = get_inference_pool().get('feature_extractor')
+
+	with conditional_thread_semaphore():
+		feature_volume = feature_extractor.run(None,
+		{
+			'input': crop_vision_frame
+		})[0]
+
+	return feature_volume
+
+
+def forward_extract_motion(crop_vision_frame : VisionFrame) -> Tuple[LivePortraitPitch, LivePortraitYaw, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitExpression, LivePortraitMotionPoints]:
+	motion_extractor = get_inference_pool().get('motion_extractor')
+
+	with conditional_thread_semaphore():
+		pitch, yaw, roll, scale, translation, expression, motion_points = motion_extractor.run(None,
+		{
+			'input': crop_vision_frame
+		})
+
+	return pitch, yaw, roll, scale, translation, expression, motion_points
+
+
+def forward_generate_frame(feature_volume : LivePortraitFeatureVolume, source_motion_points : LivePortraitMotionPoints, target_motion_points : LivePortraitMotionPoints) -> VisionFrame:
+	generator = get_inference_pool().get('generator')
+
+	with thread_semaphore():
+		crop_vision_frame = generator.run(None,
+		{
+			'feature_volume': feature_volume,
+			'source': source_motion_points,
+			'target': target_motion_points
+		})[0][0]
+
+	return crop_vision_frame
+
+
+def prepare_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
+	model_size = get_model_options().get('size')
+	prepare_size = (model_size[0] // 2, model_size[1] // 2)
+	crop_vision_frame = cv2.resize(crop_vision_frame, prepare_size, interpolation = cv2.INTER_AREA)
+	crop_vision_frame = crop_vision_frame[:, :, ::-1] / 255.0
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return crop_vision_frame
+
+
+def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
+	crop_vision_frame = crop_vision_frame.transpose(1, 2, 0).clip(0, 1)
+	crop_vision_frame = (crop_vision_frame * 255.0)
+	crop_vision_frame = crop_vision_frame.astype(numpy.uint8)[:, :, ::-1]
+	return crop_vision_frame
+
+
+def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	pass
+
+
+def process_frame(inputs : ExpressionRestorerInputs) -> VisionFrame:
+	reference_faces = inputs.get('reference_faces')
+	source_vision_frame = inputs.get('source_vision_frame')
+	target_vision_frame = inputs.get('target_vision_frame')
+	many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
+
+	if state_manager.get_item('face_selector_mode') == 'many':
+		if many_faces:
+			for target_face in many_faces:
+				target_vision_frame = restore_expression(source_vision_frame, target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'one':
+		target_face = get_one_face(many_faces)
+		if target_face:
+			target_vision_frame = restore_expression(source_vision_frame, target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'reference':
+		similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
+		if similar_faces:
+			for similar_face in similar_faces:
+				target_vision_frame = restore_expression(source_vision_frame, similar_face, target_vision_frame)
+	return target_vision_frame
+
+
+def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+
+	for queue_payload in process_manager.manage(queue_payloads):
+		frame_number = queue_payload.get('frame_number')
+		if state_manager.get_item('trim_frame_start'):
+			frame_number += state_manager.get_item('trim_frame_start')
+		source_vision_frame = get_video_frame(state_manager.get_item('target_path'), frame_number)
+		target_vision_path = queue_payload.get('frame_path')
+		target_vision_frame = read_image(target_vision_path)
+		output_vision_frame = process_frame(
+		{
+			'reference_faces': reference_faces,
+			'source_vision_frame': source_vision_frame,
+			'target_vision_frame': target_vision_frame
+		})
+		write_image(target_vision_path, output_vision_frame)
+		update_progress(1)
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+	source_vision_frame = read_static_image(state_manager.get_item('target_path'))
+	target_vision_frame = read_static_image(target_path)
+	output_vision_frame = process_frame(
+	{
+		'reference_faces': reference_faces,
+		'source_vision_frame': source_vision_frame,
+		'target_vision_frame': target_vision_frame
+	})
+	write_image(output_path, output_vision_frame)
+
+
+def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
+	processors.multi_process_frames(None, temp_frame_paths, process_frames)

facefusion/processors/modules/face_debugger.py

@@ -0,0 +1,222 @@
+from argparse import ArgumentParser
+from typing import List
+
+import cv2
+import numpy
+
+import facefusion.jobs.job_manager
+import facefusion.jobs.job_store
+import facefusion.processors.core as processors
+from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, logger, process_manager, state_manager, wording
+from facefusion.face_analyser import get_many_faces, get_one_face
+from facefusion.face_helper import warp_face_by_face_landmark_5
+from facefusion.face_masker import create_occlusion_mask, create_region_mask, create_static_box_mask
+from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
+from facefusion.face_store import get_reference_faces
+from facefusion.filesystem import in_directory, same_file_extension
+from facefusion.processors import choices as processors_choices
+from facefusion.processors.typing import FaceDebuggerInputs
+from facefusion.program_helper import find_argument_group
+from facefusion.typing import ApplyStateItem, Args, Face, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
+from facefusion.vision import read_image, read_static_image, write_image
+
+
+def get_inference_pool() -> None:
+	pass
+
+
+def clear_inference_pool() -> None:
+	pass
+
+
+def register_args(program : ArgumentParser) -> None:
+	group_processors = find_argument_group(program, 'processors')
+	if group_processors:
+		group_processors.add_argument('--face-debugger-items', help = wording.get('help.face_debugger_items').format(choices = ', '.join(processors_choices.face_debugger_items)), default = config.get_str_list('processors.face_debugger_items', 'face-landmark-5/68 face-mask'), choices = processors_choices.face_debugger_items, nargs = '+', metavar = 'FACE_DEBUGGER_ITEMS')
+		facefusion.jobs.job_store.register_step_keys([ 'face_debugger_items' ])
+
+
+def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
+	apply_state_item('face_debugger_items', args.get('face_debugger_items'))
+
+
+def pre_check() -> bool:
+	return True
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+		logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not same_file_extension([ state_manager.get_item('target_path'), state_manager.get_item('output_path') ]):
+		logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
+		return False
+	return True
+
+
+def post_process() -> None:
+	read_static_image.cache_clear()
+	if state_manager.get_item('video_memory_strategy') == 'strict':
+		content_analyser.clear_inference_pool()
+		face_classifier.clear_inference_pool()
+		face_detector.clear_inference_pool()
+		face_landmarker.clear_inference_pool()
+		face_masker.clear_inference_pool()
+		face_recognizer.clear_inference_pool()
+
+
+def debug_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	primary_color = (0, 0, 255)
+	primary_light_color = (100, 100, 255)
+	secondary_color = (0, 255, 0)
+	tertiary_color = (255, 255, 0)
+	bounding_box = target_face.bounding_box.astype(numpy.int32)
+	temp_vision_frame = temp_vision_frame.copy()
+	has_face_landmark_5_fallback = numpy.array_equal(target_face.landmark_set.get('5'), target_face.landmark_set.get('5/68'))
+	has_face_landmark_68_fallback = numpy.array_equal(target_face.landmark_set.get('68'), target_face.landmark_set.get('68/5'))
+	face_debugger_items = state_manager.get_item('face_debugger_items')
+
+	if 'bounding-box' in face_debugger_items:
+		x1, y1, x2, y2 = bounding_box
+		cv2.rectangle(temp_vision_frame, (x1, y1), (x2, y2), primary_color, 2)
+
+		if target_face.angle == 0:
+			cv2.line(temp_vision_frame, (x1, y1), (x2, y1), primary_light_color, 3)
+		elif target_face.angle == 180:
+			cv2.line(temp_vision_frame, (x1, y2), (x2, y2), primary_light_color, 3)
+		elif target_face.angle == 90:
+			cv2.line(temp_vision_frame, (x2, y1), (x2, y2), primary_light_color, 3)
+		elif target_face.angle == 270:
+			cv2.line(temp_vision_frame, (x1, y1), (x1, y2), primary_light_color, 3)
+
+	if 'face-mask' in face_debugger_items:
+		crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), 'arcface_128_v2', (512, 512))
+		inverse_matrix = cv2.invertAffineTransform(affine_matrix)
+		temp_size = temp_vision_frame.shape[:2][::-1]
+		crop_masks = []
+
+		if 'box' in state_manager.get_item('face_mask_types'):
+			box_mask = create_static_box_mask(crop_vision_frame.shape[:2][::-1], 0, state_manager.get_item('face_mask_padding'))
+			crop_masks.append(box_mask)
+
+		if 'occlusion' in state_manager.get_item('face_mask_types'):
+			occlusion_mask = create_occlusion_mask(crop_vision_frame)
+			crop_masks.append(occlusion_mask)
+
+		if 'region' in state_manager.get_item('face_mask_types'):
+			region_mask = create_region_mask(crop_vision_frame, state_manager.get_item('face_mask_regions'))
+			crop_masks.append(region_mask)
+
+		crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
+		crop_mask = (crop_mask * 255).astype(numpy.uint8)
+		inverse_vision_frame = cv2.warpAffine(crop_mask, inverse_matrix, temp_size)
+		inverse_vision_frame = cv2.threshold(inverse_vision_frame, 100, 255, cv2.THRESH_BINARY)[1]
+		inverse_vision_frame[inverse_vision_frame > 0] = 255 #type:ignore[operator]
+		inverse_contours = cv2.findContours(inverse_vision_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)[0]
+		cv2.drawContours(temp_vision_frame, inverse_contours, -1, tertiary_color if has_face_landmark_5_fallback else secondary_color, 2)
+
+	if 'face-landmark-5' in face_debugger_items and numpy.any(target_face.landmark_set.get('5')):
+		face_landmark_5 = target_face.landmark_set.get('5').astype(numpy.int32)
+		for index in range(face_landmark_5.shape[0]):
+			cv2.circle(temp_vision_frame, (face_landmark_5[index][0], face_landmark_5[index][1]), 3, primary_color, -1)
+
+	if 'face-landmark-5/68' in face_debugger_items and numpy.any(target_face.landmark_set.get('5/68')):
+		face_landmark_5_68 = target_face.landmark_set.get('5/68').astype(numpy.int32)
+		for index in range(face_landmark_5_68.shape[0]):
+			cv2.circle(temp_vision_frame, (face_landmark_5_68[index][0], face_landmark_5_68[index][1]), 3, tertiary_color if has_face_landmark_5_fallback else secondary_color, -1)
+
+	if 'face-landmark-68' in face_debugger_items and numpy.any(target_face.landmark_set.get('68')):
+		face_landmark_68 = target_face.landmark_set.get('68').astype(numpy.int32)
+		for index in range(face_landmark_68.shape[0]):
+			cv2.circle(temp_vision_frame, (face_landmark_68[index][0], face_landmark_68[index][1]), 3, tertiary_color if has_face_landmark_68_fallback else secondary_color, -1)
+
+	if 'face-landmark-68/5' in face_debugger_items and numpy.any(target_face.landmark_set.get('68')):
+		face_landmark_68 = target_face.landmark_set.get('68/5').astype(numpy.int32)
+		for index in range(face_landmark_68.shape[0]):
+			cv2.circle(temp_vision_frame, (face_landmark_68[index][0], face_landmark_68[index][1]), 3, tertiary_color, -1)
+
+	if bounding_box[3] - bounding_box[1] > 50 and bounding_box[2] - bounding_box[0] > 50:
+		top = bounding_box[1]
+		left = bounding_box[0] - 20
+
+		if 'face-detector-score' in face_debugger_items:
+			face_score_text = str(round(target_face.score_set.get('detector'), 2))
+			top = top + 20
+			cv2.putText(temp_vision_frame, face_score_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
+
+		if 'face-landmarker-score' in face_debugger_items:
+			face_score_text = str(round(target_face.score_set.get('landmarker'), 2))
+			top = top + 20
+			cv2.putText(temp_vision_frame, face_score_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, tertiary_color if has_face_landmark_5_fallback else secondary_color, 2)
+
+		if 'age' in face_debugger_items:
+			face_age_text = str(target_face.age.start) + '-' + str(target_face.age.stop)
+			top = top + 20
+			cv2.putText(temp_vision_frame, face_age_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
+
+		if 'gender' in face_debugger_items:
+			face_gender_text = target_face.gender
+			top = top + 20
+			cv2.putText(temp_vision_frame, face_gender_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
+
+		if 'race' in face_debugger_items:
+			face_race_text = target_face.race
+			top = top + 20
+			cv2.putText(temp_vision_frame, face_race_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
+
+	return temp_vision_frame
+
+
+def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	pass
+
+
+def process_frame(inputs : FaceDebuggerInputs) -> VisionFrame:
+	reference_faces = inputs.get('reference_faces')
+	target_vision_frame = inputs.get('target_vision_frame')
+	many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
+
+	if state_manager.get_item('face_selector_mode') == 'many':
+		if many_faces:
+			for target_face in many_faces:
+				target_vision_frame = debug_face(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'one':
+		target_face = get_one_face(many_faces)
+		if target_face:
+			target_vision_frame = debug_face(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'reference':
+		similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
+		if similar_faces:
+			for similar_face in similar_faces:
+				target_vision_frame = debug_face(similar_face, target_vision_frame)
+	return target_vision_frame
+
+
+def process_frames(source_paths : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+
+	for queue_payload in process_manager.manage(queue_payloads):
+		target_vision_path = queue_payload['frame_path']
+		target_vision_frame = read_image(target_vision_path)
+		output_vision_frame = process_frame(
+		{
+			'reference_faces': reference_faces,
+			'target_vision_frame': target_vision_frame
+		})
+		write_image(target_vision_path, output_vision_frame)
+		update_progress(1)
+
+
+def process_image(source_paths : List[str], target_path : str, output_path : str) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+	target_vision_frame = read_static_image(target_path)
+	output_vision_frame = process_frame(
+	{
+		'reference_faces': reference_faces,
+		'target_vision_frame': target_vision_frame
+	})
+	write_image(output_path, output_vision_frame)
+
+
+def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
+	processors.multi_process_frames(source_paths, temp_frame_paths, process_frames)

facefusion/processors/modules/face_editor.py

@@ -0,0 +1,528 @@
+from argparse import ArgumentParser
+from typing import List, Tuple
+
+import cv2
+import numpy
+
+import facefusion.jobs.job_manager
+import facefusion.jobs.job_store
+import facefusion.processors.core as processors
+from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, wording
+from facefusion.common_helper import create_float_metavar
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_analyser import get_many_faces, get_one_face
+from facefusion.face_helper import paste_back, scale_face_landmark_5, warp_face_by_face_landmark_5
+from facefusion.face_masker import create_static_box_mask
+from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
+from facefusion.face_store import get_reference_faces
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.processors import choices as processors_choices
+from facefusion.processors.live_portrait import create_rotation, limit_euler_angles, limit_expression
+from facefusion.processors.typing import FaceEditorInputs, LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitRotation, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw
+from facefusion.program_helper import find_argument_group
+from facefusion.thread_helper import conditional_thread_semaphore, thread_semaphore
+from facefusion.typing import ApplyStateItem, Args, Face, FaceLandmark68, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
+from facefusion.vision import read_image, read_static_image, write_image
+
+MODEL_SET : ModelSet =\
+{
+	'live_portrait':
+	{
+		'hashes':
+		{
+			'feature_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_feature_extractor.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_feature_extractor.hash')
+			},
+			'motion_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_motion_extractor.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_motion_extractor.hash')
+			},
+			'eye_retargeter':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_eye_retargeter.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_eye_retargeter.hash')
+			},
+			'lip_retargeter':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_lip_retargeter.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_lip_retargeter.hash')
+			},
+			'stitcher':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_stitcher.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_stitcher.hash')
+			},
+			'generator':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_generator.hash',
+				'path': resolve_relative_path('../.assets/models/live_portrait_generator.hash')
+			}
+		},
+		'sources':
+		{
+			'feature_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_feature_extractor.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_feature_extractor.onnx')
+			},
+			'motion_extractor':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_motion_extractor.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_motion_extractor.onnx')
+			},
+			'eye_retargeter':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_eye_retargeter.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_eye_retargeter.onnx')
+			},
+			'lip_retargeter':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_lip_retargeter.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_lip_retargeter.onnx')
+			},
+			'stitcher':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_stitcher.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_stitcher.onnx')
+			},
+			'generator':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/live_portrait_generator.onnx',
+				'path': resolve_relative_path('../.assets/models/live_portrait_generator.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	model_context = __name__ + '.' + state_manager.get_item('face_editor_model')
+	return inference_manager.get_inference_pool(model_context, model_sources)
+
+
+def clear_inference_pool() -> None:
+	model_context = __name__ + '.' + state_manager.get_item('face_editor_model')
+	inference_manager.clear_inference_pool(model_context)
+
+
+def get_model_options() -> ModelOptions:
+	face_editor_model = state_manager.get_item('face_editor_model')
+	return MODEL_SET.get(face_editor_model)
+
+
+def register_args(program : ArgumentParser) -> None:
+	group_processors = find_argument_group(program, 'processors')
+	if group_processors:
+		group_processors.add_argument('--face-editor-model', help = wording.get('help.face_editor_model'), default = config.get_str_value('processors.face_editor_model', 'live_portrait'), choices = processors_choices.face_editor_models)
+		group_processors.add_argument('--face-editor-eyebrow-direction', help = wording.get('help.face_editor_eyebrow_direction'), type = float, default = config.get_float_value('processors.face_editor_eyebrow_direction', '0'), choices = processors_choices.face_editor_eyebrow_direction_range, metavar = create_float_metavar(processors_choices.face_editor_eyebrow_direction_range))
+		group_processors.add_argument('--face-editor-eye-gaze-horizontal', help = wording.get('help.face_editor_eye_gaze_horizontal'), type = float, default = config.get_float_value('processors.face_editor_eye_gaze_horizontal', '0'), choices = processors_choices.face_editor_eye_gaze_horizontal_range, metavar = create_float_metavar(processors_choices.face_editor_eye_gaze_horizontal_range))
+		group_processors.add_argument('--face-editor-eye-gaze-vertical', help = wording.get('help.face_editor_eye_gaze_vertical'), type = float, default = config.get_float_value('processors.face_editor_eye_gaze_vertical', '0'), choices = processors_choices.face_editor_eye_gaze_vertical_range, metavar = create_float_metavar(processors_choices.face_editor_eye_gaze_vertical_range))
+		group_processors.add_argument('--face-editor-eye-open-ratio', help = wording.get('help.face_editor_eye_open_ratio'), type = float, default = config.get_float_value('processors.face_editor_eye_open_ratio', '0'), choices = processors_choices.face_editor_eye_open_ratio_range, metavar = create_float_metavar(processors_choices.face_editor_eye_open_ratio_range))
+		group_processors.add_argument('--face-editor-lip-open-ratio', help = wording.get('help.face_editor_lip_open_ratio'), type = float, default = config.get_float_value('processors.face_editor_lip_open_ratio', '0'), choices = processors_choices.face_editor_lip_open_ratio_range, metavar = create_float_metavar(processors_choices.face_editor_lip_open_ratio_range))
+		group_processors.add_argument('--face-editor-mouth-grim', help = wording.get('help.face_editor_mouth_grim'), type = float, default = config.get_float_value('processors.face_editor_mouth_grim', '0'), choices = processors_choices.face_editor_mouth_grim_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_grim_range))
+		group_processors.add_argument('--face-editor-mouth-pout', help = wording.get('help.face_editor_mouth_pout'), type = float, default = config.get_float_value('processors.face_editor_mouth_pout', '0'), choices = processors_choices.face_editor_mouth_pout_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_pout_range))
+		group_processors.add_argument('--face-editor-mouth-purse', help = wording.get('help.face_editor_mouth_purse'), type = float, default = config.get_float_value('processors.face_editor_mouth_purse', '0'), choices = processors_choices.face_editor_mouth_purse_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_purse_range))
+		group_processors.add_argument('--face-editor-mouth-smile', help = wording.get('help.face_editor_mouth_smile'), type = float, default = config.get_float_value('processors.face_editor_mouth_smile', '0'), choices = processors_choices.face_editor_mouth_smile_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_smile_range))
+		group_processors.add_argument('--face-editor-mouth-position-horizontal', help = wording.get('help.face_editor_mouth_position_horizontal'), type = float, default = config.get_float_value('processors.face_editor_mouth_position_horizontal', '0'), choices = processors_choices.face_editor_mouth_position_horizontal_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_position_horizontal_range))
+		group_processors.add_argument('--face-editor-mouth-position-vertical', help = wording.get('help.face_editor_mouth_position_vertical'), type = float, default = config.get_float_value('processors.face_editor_mouth_position_vertical', '0'), choices = processors_choices.face_editor_mouth_position_vertical_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_position_vertical_range))
+		group_processors.add_argument('--face-editor-head-pitch', help = wording.get('help.face_editor_head_pitch'), type = float, default = config.get_float_value('processors.face_editor_head_pitch', '0'), choices = processors_choices.face_editor_head_pitch_range, metavar = create_float_metavar(processors_choices.face_editor_head_pitch_range))
+		group_processors.add_argument('--face-editor-head-yaw', help = wording.get('help.face_editor_head_yaw'), type = float, default = config.get_float_value('processors.face_editor_head_yaw', '0'), choices = processors_choices.face_editor_head_yaw_range, metavar = create_float_metavar(processors_choices.face_editor_head_yaw_range))
+		group_processors.add_argument('--face-editor-head-roll', help = wording.get('help.face_editor_head_roll'), type = float, default = config.get_float_value('processors.face_editor_head_roll', '0'), choices = processors_choices.face_editor_head_roll_range, metavar = create_float_metavar(processors_choices.face_editor_head_roll_range))
+		facefusion.jobs.job_store.register_step_keys([ 'face_editor_model', 'face_editor_eyebrow_direction', 'face_editor_eye_gaze_horizontal', 'face_editor_eye_gaze_vertical', 'face_editor_eye_open_ratio', 'face_editor_lip_open_ratio', 'face_editor_mouth_grim', 'face_editor_mouth_pout', 'face_editor_mouth_purse', 'face_editor_mouth_smile', 'face_editor_mouth_position_horizontal', 'face_editor_mouth_position_vertical', 'face_editor_head_pitch', 'face_editor_head_yaw', 'face_editor_head_roll' ])
+
+
+def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
+	apply_state_item('face_editor_model', args.get('face_editor_model'))
+	apply_state_item('face_editor_eyebrow_direction', args.get('face_editor_eyebrow_direction'))
+	apply_state_item('face_editor_eye_gaze_horizontal', args.get('face_editor_eye_gaze_horizontal'))
+	apply_state_item('face_editor_eye_gaze_vertical', args.get('face_editor_eye_gaze_vertical'))
+	apply_state_item('face_editor_eye_open_ratio', args.get('face_editor_eye_open_ratio'))
+	apply_state_item('face_editor_lip_open_ratio', args.get('face_editor_lip_open_ratio'))
+	apply_state_item('face_editor_mouth_grim', args.get('face_editor_mouth_grim'))
+	apply_state_item('face_editor_mouth_pout', args.get('face_editor_mouth_pout'))
+	apply_state_item('face_editor_mouth_purse', args.get('face_editor_mouth_purse'))
+	apply_state_item('face_editor_mouth_smile', args.get('face_editor_mouth_smile'))
+	apply_state_item('face_editor_mouth_position_horizontal', args.get('face_editor_mouth_position_horizontal'))
+	apply_state_item('face_editor_mouth_position_vertical', args.get('face_editor_mouth_position_vertical'))
+	apply_state_item('face_editor_head_pitch', args.get('face_editor_head_pitch'))
+	apply_state_item('face_editor_head_yaw', args.get('face_editor_head_yaw'))
+	apply_state_item('face_editor_head_roll', args.get('face_editor_head_roll'))
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
+		logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+		logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not same_file_extension([ state_manager.get_item('target_path'), state_manager.get_item('output_path') ]):
+		logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
+		return False
+	return True
+
+
+def post_process() -> None:
+	read_static_image.cache_clear()
+	if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
+		clear_inference_pool()
+	if state_manager.get_item('video_memory_strategy') == 'strict':
+		content_analyser.clear_inference_pool()
+		face_classifier.clear_inference_pool()
+		face_detector.clear_inference_pool()
+		face_landmarker.clear_inference_pool()
+		face_masker.clear_inference_pool()
+		face_recognizer.clear_inference_pool()
+
+
+def edit_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	face_landmark_5 = scale_face_landmark_5(target_face.landmark_set.get('5/68'), 1.5)
+	crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, model_size)
+	box_mask = create_static_box_mask(crop_vision_frame.shape[:2][::-1], state_manager.get_item('face_mask_blur'), (0, 0, 0, 0))
+	crop_vision_frame = prepare_crop_frame(crop_vision_frame)
+	crop_vision_frame = apply_edit(crop_vision_frame, target_face.landmark_set.get('68'))
+	crop_vision_frame = normalize_crop_frame(crop_vision_frame)
+	temp_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, box_mask, affine_matrix)
+	return temp_vision_frame
+
+
+def apply_edit(crop_vision_frame : VisionFrame, face_landmark_68 : FaceLandmark68) -> VisionFrame:
+	feature_volume = forward_extract_feature(crop_vision_frame)
+	pitch, yaw, roll, scale, translation, expression, motion_points = forward_extract_motion(crop_vision_frame)
+	rotation = create_rotation(pitch, yaw, roll)
+	motion_points_target = scale * (motion_points @ rotation.T + expression) + translation
+	expression = edit_eye_gaze(expression)
+	expression = edit_mouth_grim(expression)
+	expression = edit_mouth_position(expression)
+	expression = edit_mouth_pout(expression)
+	expression = edit_mouth_purse(expression)
+	expression = edit_mouth_smile(expression)
+	expression = edit_eyebrow_direction(expression)
+	expression = limit_expression(expression)
+	rotation = edit_head_rotation(pitch, yaw, roll)
+	motion_points_source = motion_points @ rotation.T
+	motion_points_source += expression
+	motion_points_source *= scale
+	motion_points_source += translation
+	motion_points_source += edit_eye_open(motion_points_target, face_landmark_68)
+	motion_points_source += edit_lip_open(motion_points_target, face_landmark_68)
+	motion_points_source = forward_stitch_motion_points(motion_points_source, motion_points_target)
+	crop_vision_frame = forward_generate_frame(feature_volume, motion_points_source, motion_points_target)
+	return crop_vision_frame
+
+
+def forward_extract_feature(crop_vision_frame : VisionFrame) -> LivePortraitFeatureVolume:
+	feature_extractor = get_inference_pool().get('feature_extractor')
+
+	with conditional_thread_semaphore():
+		feature_volume = feature_extractor.run(None,
+		{
+			'input': crop_vision_frame
+		})[0]
+
+	return feature_volume
+
+
+def forward_extract_motion(crop_vision_frame : VisionFrame) -> Tuple[LivePortraitPitch, LivePortraitYaw, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitExpression, LivePortraitMotionPoints]:
+	motion_extractor = get_inference_pool().get('motion_extractor')
+
+	with conditional_thread_semaphore():
+		pitch, yaw, roll, scale, translation, expression, motion_points = motion_extractor.run(None,
+		{
+			'input': crop_vision_frame
+		})
+
+	return pitch, yaw, roll, scale, translation, expression, motion_points
+
+
+def forward_retarget_eye(eye_motion_points : LivePortraitMotionPoints) -> LivePortraitMotionPoints:
+	eye_retargeter = get_inference_pool().get('eye_retargeter')
+
+	with conditional_thread_semaphore():
+		eye_motion_points = eye_retargeter.run(None,
+		{
+			'input': eye_motion_points
+		})[0]
+
+	return eye_motion_points
+
+
+def forward_retarget_lip(lip_motion_points : LivePortraitMotionPoints) -> LivePortraitMotionPoints:
+	lip_retargeter = get_inference_pool().get('lip_retargeter')
+
+	with conditional_thread_semaphore():
+		lip_motion_points = lip_retargeter.run(None,
+		{
+			'input': lip_motion_points
+		})[0]
+
+	return lip_motion_points
+
+
+def forward_stitch_motion_points(source_motion_points : LivePortraitMotionPoints, target_motion_points : LivePortraitMotionPoints) -> LivePortraitMotionPoints:
+	stitcher = get_inference_pool().get('stitcher')
+
+	with thread_semaphore():
+		motion_points = stitcher.run(None,
+		{
+			'source': source_motion_points,
+			'target': target_motion_points
+		})[0]
+
+	return motion_points
+
+
+def forward_generate_frame(feature_volume : LivePortraitFeatureVolume, source_motion_points : LivePortraitMotionPoints, target_motion_points : LivePortraitMotionPoints) -> VisionFrame:
+	generator = get_inference_pool().get('generator')
+
+	with thread_semaphore():
+		crop_vision_frame = generator.run(None,
+		{
+			'feature_volume': feature_volume,
+			'source': source_motion_points,
+			'target': target_motion_points
+		})[0][0]
+
+	return crop_vision_frame
+
+
+def edit_eyebrow_direction(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_eyebrow = state_manager.get_item('face_editor_eyebrow_direction')
+
+	if face_editor_eyebrow > 0:
+		expression[0, 1, 1] += numpy.interp(face_editor_eyebrow, [ -1, 1 ], [ -0.015, 0.015 ])
+		expression[0, 2, 1] -= numpy.interp(face_editor_eyebrow, [ -1, 1 ], [ -0.020, 0.020 ])
+	else:
+		expression[0, 1, 0] -= numpy.interp(face_editor_eyebrow, [ -1, 1 ], [ -0.015, 0.015 ])
+		expression[0, 2, 0] += numpy.interp(face_editor_eyebrow, [ -1, 1 ], [ -0.020, 0.020 ])
+		expression[0, 1, 1] += numpy.interp(face_editor_eyebrow, [ -1, 1 ], [ -0.005, 0.005 ])
+		expression[0, 2, 1] -= numpy.interp(face_editor_eyebrow, [ -1, 1 ], [ -0.005, 0.005 ])
+	return expression
+
+
+def edit_eye_gaze(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_eye_gaze_horizontal = state_manager.get_item('face_editor_eye_gaze_horizontal')
+	face_editor_eye_gaze_vertical = state_manager.get_item('face_editor_eye_gaze_vertical')
+
+	if face_editor_eye_gaze_horizontal > 0:
+		expression[0, 11, 0] += numpy.interp(face_editor_eye_gaze_horizontal, [ -1, 1 ], [ -0.015, 0.015 ])
+		expression[0, 15, 0] += numpy.interp(face_editor_eye_gaze_horizontal, [ -1, 1 ], [ -0.020, 0.020 ])
+	else:
+		expression[0, 11, 0] += numpy.interp(face_editor_eye_gaze_horizontal, [ -1, 1 ], [ -0.020, 0.020 ])
+		expression[0, 15, 0] += numpy.interp(face_editor_eye_gaze_horizontal, [ -1, 1 ], [ -0.015, 0.015 ])
+	expression[0, 1, 1] += numpy.interp(face_editor_eye_gaze_vertical, [ -1, 1 ], [ -0.0025, 0.0025 ])
+	expression[0, 2, 1] -= numpy.interp(face_editor_eye_gaze_vertical, [ -1, 1 ], [ -0.0025, 0.0025 ])
+	expression[0, 11, 1] -= numpy.interp(face_editor_eye_gaze_vertical, [ -1, 1 ], [ -0.010, 0.010 ])
+	expression[0, 13, 1] -= numpy.interp(face_editor_eye_gaze_vertical, [ -1, 1 ], [ -0.005, 0.005 ])
+	expression[0, 15, 1] -= numpy.interp(face_editor_eye_gaze_vertical, [ -1, 1 ], [ -0.010, 0.010 ])
+	expression[0, 16, 1] -= numpy.interp(face_editor_eye_gaze_vertical, [ -1, 1 ], [ -0.005, 0.005 ])
+	return expression
+
+
+def edit_eye_open(motion_points : LivePortraitMotionPoints, face_landmark_68 : FaceLandmark68) -> LivePortraitMotionPoints:
+	face_editor_eye_open_ratio = state_manager.get_item('face_editor_eye_open_ratio')
+	left_eye_ratio = calc_distance_ratio(face_landmark_68, 37, 40, 39, 36)
+	right_eye_ratio = calc_distance_ratio(face_landmark_68, 43, 46, 45, 42)
+
+	if face_editor_eye_open_ratio < 0:
+		eye_motion_points = numpy.concatenate([ motion_points.ravel(), [ left_eye_ratio, right_eye_ratio, 0.0 ] ])
+	else:
+		eye_motion_points = numpy.concatenate([ motion_points.ravel(), [ left_eye_ratio, right_eye_ratio, 0.6 ] ])
+	eye_motion_points = eye_motion_points.reshape(1, -1).astype(numpy.float32)
+	eye_motion_points = forward_retarget_eye(eye_motion_points) * numpy.abs(face_editor_eye_open_ratio)
+	eye_motion_points = eye_motion_points.reshape(-1, 21, 3)
+	return eye_motion_points
+
+
+def edit_lip_open(motion_points : LivePortraitMotionPoints, face_landmark_68 : FaceLandmark68) -> LivePortraitMotionPoints:
+	face_editor_lip_open_ratio = state_manager.get_item('face_editor_lip_open_ratio')
+	lip_ratio = calc_distance_ratio(face_landmark_68, 62, 66, 54, 48)
+
+	if face_editor_lip_open_ratio < 0:
+		lip_motion_points = numpy.concatenate([ motion_points.ravel(), [ lip_ratio, 0.0 ] ])
+	else:
+		lip_motion_points = numpy.concatenate([ motion_points.ravel(), [ lip_ratio, 1.0 ] ])
+	lip_motion_points = lip_motion_points.reshape(1, -1).astype(numpy.float32)
+	lip_motion_points = forward_retarget_lip(lip_motion_points)	* numpy.abs(face_editor_lip_open_ratio)
+	lip_motion_points = lip_motion_points.reshape(-1, 21, 3)
+	return lip_motion_points
+
+
+def edit_mouth_grim(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_mouth_grim = state_manager.get_item('face_editor_mouth_grim')
+	if face_editor_mouth_grim > 0:
+		expression[0, 17, 2] -= numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.005, 0.005 ])
+		expression[0, 19, 2] += numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.01, 0.01 ])
+		expression[0, 20, 1] -= numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.06, 0.06 ])
+		expression[0, 20, 2] -= numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.03, 0.03 ])
+	else:
+		expression[0, 19, 1] -= numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.05, 0.05 ])
+		expression[0, 19, 2] -= numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.02, 0.02 ])
+		expression[0, 20, 2] -= numpy.interp(face_editor_mouth_grim, [ -1, 1 ], [ -0.03, 0.03 ])
+	return expression
+
+
+def edit_mouth_position(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_mouth_position_horizontal = state_manager.get_item('face_editor_mouth_position_horizontal')
+	face_editor_mouth_position_vertical = state_manager.get_item('face_editor_mouth_position_vertical')
+	expression[0, 19, 0] += numpy.interp(face_editor_mouth_position_horizontal, [ -1, 1 ], [ -0.05, 0.05 ])
+	expression[0, 20, 0] += numpy.interp(face_editor_mouth_position_horizontal, [ -1, 1 ], [ -0.04, 0.04 ])
+	if face_editor_mouth_position_vertical > 0:
+		expression[0, 19, 1] -= numpy.interp(face_editor_mouth_position_vertical, [ -1, 1 ], [ -0.04, 0.04 ])
+		expression[0, 20, 1] -= numpy.interp(face_editor_mouth_position_vertical, [ -1, 1 ], [ -0.02, 0.02 ])
+	else:
+		expression[0, 19, 1] -= numpy.interp(face_editor_mouth_position_vertical, [ -1, 1 ], [ -0.05, 0.05 ])
+		expression[0, 20, 1] -= numpy.interp(face_editor_mouth_position_vertical, [ -1, 1 ], [ -0.04, 0.04 ])
+	return expression
+
+
+def edit_mouth_pout(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_mouth_pout = state_manager.get_item('face_editor_mouth_pout')
+	if face_editor_mouth_pout > 0:
+		expression[0, 19, 1] -= numpy.interp(face_editor_mouth_pout, [ -1, 1 ], [ -0.022, 0.022 ])
+		expression[0, 19, 2] += numpy.interp(face_editor_mouth_pout, [ -1, 1 ], [ -0.025, 0.025 ])
+		expression[0, 20, 2] -= numpy.interp(face_editor_mouth_pout, [ -1, 1 ], [ -0.002, 0.002 ])
+	else:
+		expression[0, 19, 1] += numpy.interp(face_editor_mouth_pout, [ -1, 1 ], [ -0.022, 0.022 ])
+		expression[0, 19, 2] += numpy.interp(face_editor_mouth_pout, [ -1, 1 ], [ -0.025, 0.025 ])
+		expression[0, 20, 2] -= numpy.interp(face_editor_mouth_pout, [ -1, 1 ], [ -0.002, 0.002 ])
+	return expression
+
+
+def edit_mouth_purse(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_mouth_purse = state_manager.get_item('face_editor_mouth_purse')
+	if face_editor_mouth_purse > 0:
+		expression[0, 19, 1] -= numpy.interp(face_editor_mouth_purse, [ -1, 1 ], [ -0.04, 0.04 ])
+		expression[0, 19, 2] -= numpy.interp(face_editor_mouth_purse, [ -1, 1 ], [ -0.02, 0.02 ])
+	else:
+		expression[0, 14, 1] -= numpy.interp(face_editor_mouth_purse, [ -1, 1 ], [ -0.02, 0.02 ])
+		expression[0, 17, 2] += numpy.interp(face_editor_mouth_purse, [ -1, 1 ], [ -0.01, 0.01 ])
+		expression[0, 19, 2] -= numpy.interp(face_editor_mouth_purse, [ -1, 1 ], [ -0.015, 0.015 ])
+		expression[0, 20, 2] -= numpy.interp(face_editor_mouth_purse, [ -1, 1 ], [ -0.002, 0.002 ])
+	return expression
+
+
+def edit_mouth_smile(expression : LivePortraitExpression) -> LivePortraitExpression:
+	face_editor_mouth_smile = state_manager.get_item('face_editor_mouth_smile')
+	if face_editor_mouth_smile > 0:
+		expression[0, 20, 1] -= numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.015, 0.015 ])
+		expression[0, 14, 1] -= numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.025, 0.025 ])
+		expression[0, 17, 1] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.01, 0.01 ])
+		expression[0, 17, 2] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.004, 0.004 ])
+		expression[0, 3, 1] -= numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.0045, 0.0045 ])
+		expression[0, 7, 1] -= numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.0045, 0.0045 ])
+	else:
+		expression[0, 14, 1] -= numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.02, 0.02 ])
+		expression[0, 17, 1] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.003, 0.003 ])
+		expression[0, 19, 1] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.02, 0.02 ])
+		expression[0, 19, 2] -= numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.005, 0.005 ])
+		expression[0, 20, 2] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.01, 0.01 ])
+		expression[0, 3, 1] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.0045, 0.0045 ])
+		expression[0, 7, 1] += numpy.interp(face_editor_mouth_smile, [ -1, 1 ], [ -0.0045, 0.0045 ])
+	return expression
+
+
+def edit_head_rotation(pitch : LivePortraitPitch, yaw : LivePortraitYaw, roll : LivePortraitRoll) -> LivePortraitRotation:
+	face_editor_head_pitch = state_manager.get_item('face_editor_head_pitch')
+	face_editor_head_yaw = state_manager.get_item('face_editor_head_yaw')
+	face_editor_head_roll = state_manager.get_item('face_editor_head_roll')
+	edit_pitch = pitch + float(numpy.interp(face_editor_head_pitch, [ -1, 1 ], [ 20, -20 ]))
+	edit_yaw = yaw + float(numpy.interp(face_editor_head_yaw, [ -1, 1 ], [ 60, -60 ]))
+	edit_roll = roll + float(numpy.interp(face_editor_head_roll, [ -1, 1 ], [ -15, 15 ]))
+	edit_pitch, edit_yaw, edit_roll = limit_euler_angles(pitch, yaw, roll, edit_pitch, edit_yaw, edit_roll)
+	rotation = create_rotation(edit_pitch, edit_yaw, edit_roll)
+	return rotation
+
+
+def calc_distance_ratio(face_landmark_68 : FaceLandmark68, top_index : int, bottom_index : int, left_index : int, right_index : int) -> float:
+	vertical_direction = face_landmark_68[top_index] - face_landmark_68[bottom_index]
+	horizontal_direction = face_landmark_68[left_index] - face_landmark_68[right_index]
+	distance_ratio = float(numpy.linalg.norm(vertical_direction) / (numpy.linalg.norm(horizontal_direction) + 1e-6))
+	return distance_ratio
+
+
+def prepare_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
+	model_size = get_model_options().get('size')
+	prepare_size = (model_size[0] // 2, model_size[1] // 2)
+	crop_vision_frame = cv2.resize(crop_vision_frame, prepare_size, interpolation = cv2.INTER_AREA)
+	crop_vision_frame = crop_vision_frame[:, :, ::-1] / 255.0
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return crop_vision_frame
+
+
+def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
+	crop_vision_frame = crop_vision_frame.transpose(1, 2, 0).clip(0, 1)
+	crop_vision_frame = (crop_vision_frame * 255.0)
+	crop_vision_frame = crop_vision_frame.astype(numpy.uint8)[:, :, ::-1]
+	return crop_vision_frame
+
+
+def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	pass
+
+
+def process_frame(inputs : FaceEditorInputs) -> VisionFrame:
+	reference_faces = inputs.get('reference_faces')
+	target_vision_frame = inputs.get('target_vision_frame')
+	many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
+
+	if state_manager.get_item('face_selector_mode') == 'many':
+		if many_faces:
+			for target_face in many_faces:
+				target_vision_frame = edit_face(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'one':
+		target_face = get_one_face(many_faces)
+		if target_face:
+			target_vision_frame = edit_face(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'reference':
+		similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
+		if similar_faces:
+			for similar_face in similar_faces:
+				target_vision_frame = edit_face(similar_face, target_vision_frame)
+	return target_vision_frame
+
+
+def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+
+	for queue_payload in process_manager.manage(queue_payloads):
+		target_vision_path = queue_payload['frame_path']
+		target_vision_frame = read_image(target_vision_path)
+		output_vision_frame = process_frame(
+		{
+			'reference_faces': reference_faces,
+			'target_vision_frame': target_vision_frame
+		})
+		write_image(target_vision_path, output_vision_frame)
+		update_progress(1)
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+	target_vision_frame = read_static_image(target_path)
+	output_vision_frame = process_frame(
+	{
+		'reference_faces': reference_faces,
+		'target_vision_frame': target_vision_frame
+	})
+	write_image(output_path, output_vision_frame)
+
+
+def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
+	processors.multi_process_frames(None, temp_frame_paths, process_frames)

facefusion/processors/modules/face_enhancer.py

@@ -0,0 +1,397 @@
+from argparse import ArgumentParser
+from typing import List
+
+import cv2
+import numpy
+
+import facefusion.jobs.job_manager
+import facefusion.jobs.job_store
+import facefusion.processors.core as processors
+from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, wording
+from facefusion.common_helper import create_int_metavar
+from facefusion.download import conditional_download_hashes, conditional_download_sources
+from facefusion.face_analyser import get_many_faces, get_one_face
+from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
+from facefusion.face_masker import create_occlusion_mask, create_static_box_mask
+from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
+from facefusion.face_store import get_reference_faces
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.processors import choices as processors_choices
+from facefusion.processors.typing import FaceEnhancerInputs
+from facefusion.program_helper import find_argument_group
+from facefusion.thread_helper import thread_semaphore
+from facefusion.typing import ApplyStateItem, Args, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
+from facefusion.vision import read_image, read_static_image, write_image
+
+MODEL_SET : ModelSet =\
+{
+	'codeformer':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/codeformer.hash',
+				'path': resolve_relative_path('../.assets/models/codeformer.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/codeformer.onnx',
+				'path': resolve_relative_path('../.assets/models/codeformer.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	},
+	'gfpgan_1.2':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gfpgan_1.2.hash',
+				'path': resolve_relative_path('../.assets/models/gfpgan_1.2.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gfpgan_1.2.onnx',
+				'path': resolve_relative_path('../.assets/models/gfpgan_1.2.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	},
+	'gfpgan_1.3':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gfpgan_1.3.hash',
+				'path': resolve_relative_path('../.assets/models/gfpgan_1.3.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gfpgan_1.3.onnx',
+				'path': resolve_relative_path('../.assets/models/gfpgan_1.3.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	},
+	'gfpgan_1.4':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gfpgan_1.4.hash',
+				'path': resolve_relative_path('../.assets/models/gfpgan_1.4.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gfpgan_1.4.onnx',
+				'path': resolve_relative_path('../.assets/models/gfpgan_1.4.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	},
+	'gpen_bfr_256':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_256.hash',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_256.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_256.onnx',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_256.onnx')
+			}
+		},
+		'template': 'arcface_128_v2',
+		'size': (256, 256)
+	},
+	'gpen_bfr_512':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_512.hash',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_512.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_512.onnx',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_512.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	},
+	'gpen_bfr_1024':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_1024.hash',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_1024.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_1024.onnx',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_1024.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (1024, 1024)
+	},
+	'gpen_bfr_2048':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_2048.hash',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_2048.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/gpen_bfr_2048.onnx',
+				'path': resolve_relative_path('../.assets/models/gpen_bfr_2048.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (2048, 2048)
+	},
+	'restoreformer_plus_plus':
+	{
+		'hashes':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/restoreformer_plus_plus.hash',
+				'path': resolve_relative_path('../.assets/models/restoreformer_plus_plus.hash')
+			}
+		},
+		'sources':
+		{
+			'face_enhancer':
+			{
+				'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models-3.0.0/restoreformer_plus_plus.onnx',
+				'path': resolve_relative_path('../.assets/models/restoreformer_plus_plus.onnx')
+			}
+		},
+		'template': 'ffhq_512',
+		'size': (512, 512)
+	}
+}
+
+
+def get_inference_pool() -> InferencePool:
+	model_sources = get_model_options().get('sources')
+	model_context = __name__ + '.' + state_manager.get_item('face_enhancer_model')
+	return inference_manager.get_inference_pool(model_context, model_sources)
+
+
+def clear_inference_pool() -> None:
+	model_context = __name__ + '.' + state_manager.get_item('face_enhancer_model')
+	inference_manager.clear_inference_pool(model_context)
+
+
+def get_model_options() -> ModelOptions:
+	face_enhancer_model = state_manager.get_item('face_enhancer_model')
+	return MODEL_SET.get(face_enhancer_model)
+
+
+def register_args(program : ArgumentParser) -> None:
+	group_processors = find_argument_group(program, 'processors')
+	if group_processors:
+		group_processors.add_argument('--face-enhancer-model', help = wording.get('help.face_enhancer_model'), default = config.get_str_value('processors.face_enhancer_model', 'gfpgan_1.4'), choices = processors_choices.face_enhancer_models)
+		group_processors.add_argument('--face-enhancer-blend', help = wording.get('help.face_enhancer_blend'), type = int, default = config.get_int_value('processors.face_enhancer_blend', '80'), choices = processors_choices.face_enhancer_blend_range, metavar = create_int_metavar(processors_choices.face_enhancer_blend_range))
+		facefusion.jobs.job_store.register_step_keys([ 'face_enhancer_model', 'face_enhancer_blend' ])
+
+
+def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
+	apply_state_item('face_enhancer_model', args.get('face_enhancer_model'))
+	apply_state_item('face_enhancer_blend', args.get('face_enhancer_blend'))
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(download_directory_path, model_hashes) and conditional_download_sources(download_directory_path, model_sources)
+
+
+def pre_process(mode : ProcessMode) -> bool:
+	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
+		logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+		logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
+		return False
+	if mode == 'output' and not same_file_extension([ state_manager.get_item('target_path'), state_manager.get_item('output_path') ]):
+		logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
+		return False
+	return True
+
+
+def post_process() -> None:
+	read_static_image.cache_clear()
+	if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
+		clear_inference_pool()
+	if state_manager.get_item('video_memory_strategy') == 'strict':
+		content_analyser.clear_inference_pool()
+		face_classifier.clear_inference_pool()
+		face_detector.clear_inference_pool()
+		face_landmarker.clear_inference_pool()
+		face_masker.clear_inference_pool()
+		face_recognizer.clear_inference_pool()
+
+
+def enhance_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
+	box_mask = create_static_box_mask(crop_vision_frame.shape[:2][::-1], state_manager.get_item('face_mask_blur'), (0, 0, 0, 0))
+	crop_masks =\
+	[
+		box_mask
+	]
+
+	if 'occlusion' in state_manager.get_item('face_mask_types'):
+		occlusion_mask = create_occlusion_mask(crop_vision_frame)
+		crop_masks.append(occlusion_mask)
+
+	crop_vision_frame = prepare_crop_frame(crop_vision_frame)
+	crop_vision_frame = forward(crop_vision_frame)
+	crop_vision_frame = normalize_crop_frame(crop_vision_frame)
+	crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
+	paste_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, crop_mask, affine_matrix)
+	temp_vision_frame = blend_frame(temp_vision_frame, paste_vision_frame)
+	return temp_vision_frame
+
+
+def forward(crop_vision_frame : VisionFrame) -> VisionFrame:
+	face_enhancer = get_inference_pool().get('face_enhancer')
+	face_enhancer_inputs = {}
+
+	for face_enhancer_input in face_enhancer.get_inputs():
+		if face_enhancer_input.name == 'input':
+			face_enhancer_inputs[face_enhancer_input.name] = crop_vision_frame
+		if face_enhancer_input.name == 'weight':
+			weight = numpy.array([ 1 ]).astype(numpy.double)
+			face_enhancer_inputs[face_enhancer_input.name] = weight
+
+	with thread_semaphore():
+		crop_vision_frame = face_enhancer.run(None, face_enhancer_inputs)[0][0]
+
+	return crop_vision_frame
+
+
+def prepare_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
+	crop_vision_frame = crop_vision_frame[:, :, ::-1] / 255.0
+	crop_vision_frame = (crop_vision_frame - 0.5) / 0.5
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return crop_vision_frame
+
+
+def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
+	crop_vision_frame = numpy.clip(crop_vision_frame, -1, 1)
+	crop_vision_frame = (crop_vision_frame + 1) / 2
+	crop_vision_frame = crop_vision_frame.transpose(1, 2, 0)
+	crop_vision_frame = (crop_vision_frame * 255.0).round()
+	crop_vision_frame = crop_vision_frame.astype(numpy.uint8)[:, :, ::-1]
+	return crop_vision_frame
+
+
+def blend_frame(temp_vision_frame : VisionFrame, paste_vision_frame : VisionFrame) -> VisionFrame:
+	face_enhancer_blend = 1 - (state_manager.get_item('face_enhancer_blend') / 100)
+	temp_vision_frame = cv2.addWeighted(temp_vision_frame, face_enhancer_blend, paste_vision_frame, 1 - face_enhancer_blend, 0)
+	return temp_vision_frame
+
+
+def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
+	return enhance_face(target_face, temp_vision_frame)
+
+
+def process_frame(inputs : FaceEnhancerInputs) -> VisionFrame:
+	reference_faces = inputs.get('reference_faces')
+	target_vision_frame = inputs.get('target_vision_frame')
+	many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
+
+	if state_manager.get_item('face_selector_mode') == 'many':
+		if many_faces:
+			for target_face in many_faces:
+				target_vision_frame = enhance_face(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'one':
+		target_face = get_one_face(many_faces)
+		if target_face:
+			target_vision_frame = enhance_face(target_face, target_vision_frame)
+	if state_manager.get_item('face_selector_mode') == 'reference':
+		similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
+		if similar_faces:
+			for similar_face in similar_faces:
+				target_vision_frame = enhance_face(similar_face, target_vision_frame)
+	return target_vision_frame
+
+
+def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+
+	for queue_payload in process_manager.manage(queue_payloads):
+		target_vision_path = queue_payload['frame_path']
+		target_vision_frame = read_image(target_vision_path)
+		output_vision_frame = process_frame(
+		{
+			'reference_faces': reference_faces,
+			'target_vision_frame': target_vision_frame
+		})
+		write_image(target_vision_path, output_vision_frame)
+		update_progress(1)
+
+
+def process_image(source_path : str, target_path : str, output_path : str) -> None:
+	reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+	target_vision_frame = read_static_image(target_path)
+	output_vision_frame = process_frame(
+	{
+		'reference_faces': reference_faces,
+		'target_vision_frame': target_vision_frame
+	})
+	write_image(output_path, output_vision_frame)
+
+
+def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
+	processors.multi_process_frames(None, temp_frame_paths, process_frames)