Migrated from GitHub

.editorconfig

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

.flake8

@@ -0,0 +1,6 @@
+[flake8]
+select = E22, E23, E24, E27, E3, E4, E7, F, I1, I2
+per-file-ignores = facefusion.py:E402, install.py:E402
+plugins = flake8-import-order
+application_import_names = facefusion
+import-order-style = pycharm

LICENSE.md

@@ -0,0 +1,3 @@
+OpenRAIL-AS license
+
+Copyright (c) 2025 Henry Ruhs

ORIGINAL_README.md

@@ -0,0 +1,61 @@
+FaceFusion
+==========
+
+> Industry leading face manipulation platform.
+
+[![Build Status](https://img.shields.io/github/actions/workflow/status/facefusion/facefusion/ci.yml.svg?branch=master)](https://github.com/facefusion/facefusion/actions?query=workflow:ci)
+[![Coverage Status](https://img.shields.io/coveralls/facefusion/facefusion.svg)](https://coveralls.io/r/facefusion/facefusion)
+![License](https://img.shields.io/badge/license-OpenRAIL--AS-green)
+
+
+Preview
+-------
+
+![Preview](https://raw.githubusercontent.com/facefusion/facefusion/master/.github/preview.png?sanitize=true)
+
+
+Installation
+------------
+
+Be aware, the [installation](https://docs.facefusion.io/installation) needs technical skills and is not recommended for beginners. In case you are not comfortable using a terminal, our [Windows Installer](http://windows-installer.facefusion.io) and [macOS Installer](http://macos-installer.facefusion.io) get you started.
+
+
+Usage
+-----
+
+Run the command:
+
+```
+python facefusion.py [commands] [options]
+
+options:
+  -h, --help                                      show this help message and exit
+  -v, --version                                   show program's version number and exit
+
+commands:
+    run                                           run the program
+    headless-run                                  run the program in headless mode
+    batch-run                                     run the program in batch mode
+    force-download                                force automate downloads and exit
+    benchmark                                     benchmark the program
+    job-list                                      list jobs by status
+    job-create                                    create a drafted job
+    job-submit                                    submit a drafted job to become a queued job
+    job-submit-all                                submit all drafted jobs to become a queued jobs
+    job-delete                                    delete a drafted, queued, failed or completed job
+    job-delete-all                                delete all drafted, queued, failed and completed jobs
+    job-add-step                                  add a step to a drafted job
+    job-remix-step                                remix a previous step from a drafted job
+    job-insert-step                               insert a step to a drafted job
+    job-remove-step                               remove a step from a drafted job
+    job-run                                       run a queued job
+    job-run-all                                   run all queued jobs
+    job-retry                                     retry a failed job
+    job-retry-all                                 retry all failed jobs
+```
+
+
+Documentation
+-------------
+
+Read the [documentation](https://docs.facefusion.io) for a deep dive.

facefusion.ini

@@ -0,0 +1,123 @@
+[paths]
+temp_path =
+jobs_path =
+source_paths =
+target_path =
+output_path =
+
+[patterns]
+source_pattern =
+target_pattern =
+output_pattern =
+
+[face_detector]
+face_detector_model =
+face_detector_size =
+face_detector_angles =
+face_detector_score =
+
+[face_landmarker]
+face_landmarker_model =
+face_landmarker_score =
+
+[face_selector]
+face_selector_mode =
+face_selector_order =
+face_selector_age_start =
+face_selector_age_end =
+face_selector_gender =
+face_selector_race =
+reference_face_position =
+reference_face_distance =
+reference_frame_number =
+
+[face_masker]
+face_occluder_model =
+face_parser_model =
+face_mask_types =
+face_mask_areas =
+face_mask_regions =
+face_mask_blur =
+face_mask_padding =
+
+[frame_extraction]
+trim_frame_start =
+trim_frame_end =
+temp_frame_format =
+keep_temp =
+
+[output_creation]
+output_image_quality =
+output_image_resolution =
+output_audio_encoder =
+output_audio_quality =
+output_audio_volume =
+output_video_encoder =
+output_video_preset =
+output_video_quality =
+output_video_resolution =
+output_video_fps =
+
+[processors]
+processors =
+age_modifier_model =
+age_modifier_direction =
+deep_swapper_model =
+deep_swapper_morph =
+expression_restorer_model =
+expression_restorer_factor =
+face_debugger_items =
+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 =
+face_enhancer_model =
+face_enhancer_blend =
+face_enhancer_weight =
+face_swapper_model =
+face_swapper_pixel_boost =
+frame_colorizer_model =
+frame_colorizer_size =
+frame_colorizer_blend =
+frame_enhancer_model =
+frame_enhancer_blend =
+lip_syncer_model =
+lip_syncer_weight =
+
+[uis]
+open_browser =
+ui_layouts =
+ui_workflow =
+
+[download]
+download_providers =
+download_scope =
+
+[benchmark]
+benchmark_resolutions =
+benchmark_cycle_count =
+
+[execution]
+execution_device_id =
+execution_providers =
+execution_thread_count =
+execution_queue_count =
+
+[memory]
+video_memory_strategy =
+system_memory_limit =
+
+[misc]
+log_level =
+halt_on_error =

facefusion.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.types 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,140 @@
+from facefusion import state_manager
+from facefusion.filesystem import get_file_name, is_image, is_video, resolve_file_paths
+from facefusion.jobs import job_store
+from facefusion.normalizer import normalize_fps, normalize_padding
+from facefusion.processors.core import get_processors_modules
+from facefusion.types 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 reduce_job_args(args : Args) -> Args:
+	job_args =\
+	{
+		key: args[key] for key in args if key in job_store.get_job_keys()
+	}
+	return job_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('temp_path', args.get('temp_path'))
+	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'))
+	# patterns
+	apply_state_item('source_pattern', args.get('source_pattern'))
+	apply_state_item('target_pattern', args.get('target_pattern'))
+	apply_state_item('output_pattern', args.get('output_pattern'))
+	# 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
+	apply_state_item('face_selector_mode', args.get('face_selector_mode'))
+	apply_state_item('face_selector_order', args.get('face_selector_order'))
+	apply_state_item('face_selector_age_start', args.get('face_selector_age_start'))
+	apply_state_item('face_selector_age_end', args.get('face_selector_age_end'))
+	apply_state_item('face_selector_gender', args.get('face_selector_gender'))
+	apply_state_item('face_selector_race', args.get('face_selector_race'))
+	apply_state_item('reference_face_position', args.get('reference_face_position'))
+	apply_state_item('reference_face_distance', args.get('reference_face_distance'))
+	apply_state_item('reference_frame_number', args.get('reference_frame_number'))
+	# face masker
+	apply_state_item('face_occluder_model', args.get('face_occluder_model'))
+	apply_state_item('face_parser_model', args.get('face_parser_model'))
+	apply_state_item('face_mask_types', args.get('face_mask_types'))
+	apply_state_item('face_mask_areas', args.get('face_mask_areas'))
+	apply_state_item('face_mask_regions', args.get('face_mask_regions'))
+	apply_state_item('face_mask_blur', args.get('face_mask_blur'))
+	apply_state_item('face_mask_padding', normalize_padding(args.get('face_mask_padding')))
+	# 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_audio_quality', args.get('output_audio_quality'))
+	apply_state_item('output_audio_volume', args.get('output_audio_volume'))
+	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)
+	# processors
+	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('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'))
+	# download
+	apply_state_item('download_providers', args.get('download_providers'))
+	apply_state_item('download_scope', args.get('download_scope'))
+	# benchmark
+	apply_state_item('benchmark_resolutions', args.get('benchmark_resolutions'))
+	apply_state_item('benchmark_cycle_count', args.get('benchmark_cycle_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('log_level', args.get('log_level'))
+	apply_state_item('halt_on_error', args.get('halt_on_error'))
+	# 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,143 @@
+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.types import Audio, AudioFrame, Fps, Mel, MelFilterBank, Spectrogram
+from facefusion.voice_extractor import batch_extract_voice
+
+
+@lru_cache()
+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]]:
+	audio_sample_rate = 48000
+	audio_sample_size = 16
+	audio_channel_total = 2
+
+	if is_audio(audio_path):
+		audio_buffer = read_audio_buffer(audio_path, audio_sample_rate, audio_sample_size, audio_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()
+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]]:
+	voice_sample_rate = 48000
+	voice_sample_size = 16
+	voice_channel_total = 2
+	voice_chunk_size = 240 * 1024
+	voice_step_size = 180 * 1024
+
+	if is_audio(audio_path):
+		audio_buffer = read_audio_buffer(audio_path, voice_sample_rate, voice_sample_size, voice_channel_total)
+		audio = numpy.frombuffer(audio_buffer, dtype = numpy.int16).reshape(-1, 2)
+		audio = batch_extract_voice(audio, voice_chunk_size, voice_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 extract_audio_frames(spectrogram : Spectrogram, fps : Fps) -> List[AudioFrame]:
+	audio_frames = []
+	mel_filter_total = 80
+	audio_step_size = 16
+	indices = numpy.arange(0, spectrogram.shape[1], mel_filter_total / fps).astype(numpy.int16)
+	indices = indices[indices >= audio_step_size]
+
+	for index in indices:
+		start = max(0, index - audio_step_size)
+		audio_frames.append(spectrogram[:, start:index])
+
+	return audio_frames
+
+
+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
+	audio_step_size = 16
+	audio_frame = numpy.zeros((mel_filter_total, audio_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:
+	audio_sample_rate = 48000
+	audio_resample_rate = 16000
+	audio_resample_factor = round(len(audio) * audio_resample_rate / audio_sample_rate)
+	audio = scipy.signal.resample(audio, audio_resample_factor)
+	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:
+	audio_sample_rate = 16000
+	audio_min_frequency = 55.0
+	audio_max_frequency = 7600.0
+	mel_filter_total = 80
+	mel_bin_total = 800
+	mel_filter_bank = numpy.zeros((mel_filter_total, mel_bin_total // 2 + 1))
+	mel_frequency_range = numpy.linspace(convert_hertz_to_mel(audio_min_frequency), convert_hertz_to_mel(audio_max_frequency), mel_filter_total + 2)
+	indices = numpy.floor((mel_bin_total + 1) * convert_mel_to_hertz(mel_frequency_range) / audio_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

facefusion/benchmarker.py

@@ -0,0 +1,106 @@
+import hashlib
+import os
+import statistics
+import tempfile
+from time import perf_counter
+from typing import Generator, List
+
+import facefusion.choices
+from facefusion import core, state_manager
+from facefusion.cli_helper import render_table
+from facefusion.download import conditional_download, resolve_download_url
+from facefusion.filesystem import get_file_extension
+from facefusion.types import BenchmarkCycleSet
+from facefusion.vision import count_video_frame_total, detect_video_fps, detect_video_resolution, pack_resolution
+
+
+def pre_check() -> bool:
+	conditional_download('.assets/examples',
+	[
+		resolve_download_url('examples-3.0.0', 'source.jpg'),
+		resolve_download_url('examples-3.0.0', 'source.mp3'),
+		resolve_download_url('examples-3.0.0', 'target-240p.mp4'),
+		resolve_download_url('examples-3.0.0', 'target-360p.mp4'),
+		resolve_download_url('examples-3.0.0', 'target-540p.mp4'),
+		resolve_download_url('examples-3.0.0', 'target-720p.mp4'),
+		resolve_download_url('examples-3.0.0', 'target-1080p.mp4'),
+		resolve_download_url('examples-3.0.0', 'target-1440p.mp4'),
+		resolve_download_url('examples-3.0.0', 'target-2160p.mp4')
+	])
+	return True
+
+
+def run() -> Generator[List[BenchmarkCycleSet], None, None]:
+	benchmark_resolutions = state_manager.get_item('benchmark_resolutions')
+	benchmark_cycle_count = state_manager.get_item('benchmark_cycle_count')
+
+	state_manager.init_item('source_paths', [ '.assets/examples/source.jpg', '.assets/examples/source.mp3' ])
+	state_manager.init_item('face_landmarker_score', 0)
+	state_manager.init_item('temp_frame_format', 'bmp')
+	state_manager.init_item('output_audio_volume', 0)
+	state_manager.init_item('output_video_preset', 'ultrafast')
+	state_manager.init_item('video_memory_strategy', 'tolerant')
+
+	benchmarks = []
+	target_paths = [facefusion.choices.benchmark_set.get(benchmark_resolution) for benchmark_resolution in benchmark_resolutions if benchmark_resolution in facefusion.choices.benchmark_set]
+
+	for target_path in target_paths:
+		state_manager.set_item('target_path', target_path)
+		state_manager.set_item('output_path', suggest_output_path(state_manager.get_item('target_path')))
+		benchmarks.append(cycle(benchmark_cycle_count))
+		yield benchmarks
+
+
+def cycle(cycle_count : int) -> BenchmarkCycleSet:
+	process_times = []
+	video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+	output_video_resolution = detect_video_resolution(state_manager.get_item('target_path'))
+	state_manager.set_item('output_video_resolution', pack_resolution(output_video_resolution))
+	state_manager.set_item('output_video_fps', detect_video_fps(state_manager.get_item('target_path')))
+
+	core.conditional_process()
+
+	for index in range(cycle_count):
+		start_time = perf_counter()
+		core.conditional_process()
+		end_time = perf_counter()
+		process_times.append(end_time - start_time)
+
+	average_run = round(statistics.mean(process_times), 2)
+	fastest_run = round(min(process_times), 2)
+	slowest_run = round(max(process_times), 2)
+	relative_fps = round(video_frame_total * cycle_count / sum(process_times), 2)
+
+	return\
+	{
+		'target_path': state_manager.get_item('target_path'),
+		'cycle_count': cycle_count,
+		'average_run': average_run,
+		'fastest_run': fastest_run,
+		'slowest_run': slowest_run,
+		'relative_fps': relative_fps
+	}
+
+
+def suggest_output_path(target_path : str) -> str:
+	target_file_extension = get_file_extension(target_path)
+	return os.path.join(tempfile.gettempdir(), hashlib.sha1().hexdigest()[:8] + target_file_extension)
+
+
+def render() -> None:
+	benchmarks = []
+	headers =\
+	[
+		'target_path',
+		'cycle_count',
+		'average_run',
+		'fastest_run',
+		'slowest_run',
+		'relative_fps'
+	]
+
+	for benchmark in run():
+		benchmarks = benchmark
+
+	contents = [ list(benchmark_set.values()) for benchmark_set in benchmarks ]
+	render_table(headers, contents)

facefusion/choices.py

@@ -0,0 +1,165 @@
+import logging
+from typing import List, Sequence
+
+from facefusion.common_helper import create_float_range, create_int_range
+from facefusion.types import Angle, AudioEncoder, AudioFormat, AudioTypeSet, BenchmarkResolution, BenchmarkSet, DownloadProvider, DownloadProviderSet, DownloadScope, EncoderSet, ExecutionProvider, ExecutionProviderSet, FaceDetectorModel, FaceDetectorSet, FaceLandmarkerModel, FaceMaskArea, FaceMaskAreaSet, FaceMaskRegion, FaceMaskRegionSet, FaceMaskType, FaceOccluderModel, FaceParserModel, FaceSelectorMode, FaceSelectorOrder, Gender, ImageFormat, ImageTypeSet, JobStatus, LogLevel, LogLevelSet, Race, Score, TempFrameFormat, UiWorkflow, VideoEncoder, VideoFormat, VideoMemoryStrategy, VideoPreset, VideoTypeSet, WebcamMode
+
+face_detector_set : FaceDetectorSet =\
+{
+	'many': [ '640x640' ],
+	'retinaface': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'scrfd': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'yolo_face': [ '640x640' ]
+}
+face_detector_models : List[FaceDetectorModel] = list(face_detector_set.keys())
+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_occluder_models : List[FaceOccluderModel] = [ 'xseg_1', 'xseg_2', 'xseg_3' ]
+face_parser_models : List[FaceParserModel] = [ 'bisenet_resnet_18', 'bisenet_resnet_34' ]
+face_mask_types : List[FaceMaskType] = [ 'box', 'occlusion', 'area', 'region' ]
+face_mask_area_set : FaceMaskAreaSet =\
+{
+	'upper-face': [ 0, 1, 2, 31, 32, 33, 34, 35, 14, 15, 16, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17 ],
+	'lower-face': [ 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 35, 34, 33, 32, 31 ],
+	'mouth': [ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 ]
+}
+face_mask_region_set : FaceMaskRegionSet =\
+{
+	'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
+}
+face_mask_areas : List[FaceMaskArea] = list(face_mask_area_set.keys())
+face_mask_regions : List[FaceMaskRegion] = list(face_mask_region_set.keys())
+
+audio_type_set : AudioTypeSet =\
+{
+	'flac': 'audio/flac',
+	'm4a': 'audio/mp4',
+	'mp3': 'audio/mpeg',
+	'ogg': 'audio/ogg',
+	'opus': 'audio/opus',
+	'wav': 'audio/x-wav'
+}
+image_type_set : ImageTypeSet =\
+{
+	'bmp': 'image/bmp',
+	'jpeg': 'image/jpeg',
+	'png': 'image/png',
+	'tiff': 'image/tiff',
+	'webp': 'image/webp'
+}
+video_type_set : VideoTypeSet =\
+{
+	'avi': 'video/x-msvideo',
+	'm4v': 'video/mp4',
+	'mkv': 'video/x-matroska',
+	'mp4': 'video/mp4',
+	'mov': 'video/quicktime',
+	'webm': 'video/webm'
+}
+audio_formats : List[AudioFormat] = list(audio_type_set.keys())
+image_formats : List[ImageFormat] = list(image_type_set.keys())
+video_formats : List[VideoFormat] = list(video_type_set.keys())
+temp_frame_formats : List[TempFrameFormat] = [ 'bmp', 'jpeg', 'png', 'tiff' ]
+
+output_encoder_set : EncoderSet =\
+{
+	'audio': [ 'flac', 'aac', 'libmp3lame', 'libopus', 'libvorbis', 'pcm_s16le', 'pcm_s32le' ],
+	'video': [ 'libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf', 'h264_qsv', 'hevc_qsv', 'h264_videotoolbox', 'hevc_videotoolbox', 'rawvideo' ]
+}
+output_audio_encoders : List[AudioEncoder] = output_encoder_set.get('audio')
+output_video_encoders : List[VideoEncoder] = output_encoder_set.get('video')
+output_video_presets : List[VideoPreset] = [ '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 ]
+
+benchmark_set : BenchmarkSet =\
+{
+	'240p': '.assets/examples/target-240p.mp4',
+	'360p': '.assets/examples/target-360p.mp4',
+	'540p': '.assets/examples/target-540p.mp4',
+	'720p': '.assets/examples/target-720p.mp4',
+	'1080p': '.assets/examples/target-1080p.mp4',
+	'1440p': '.assets/examples/target-1440p.mp4',
+	'2160p': '.assets/examples/target-2160p.mp4'
+}
+benchmark_resolutions : List[BenchmarkResolution] = list(benchmark_set.keys())
+
+webcam_modes : List[WebcamMode] = [ 'inline', 'udp', 'v4l2' ]
+webcam_resolutions : List[str] = [ '320x240', '640x480', '800x600', '1024x768', '1280x720', '1280x960', '1920x1080', '2560x1440', '3840x2160' ]
+
+execution_provider_set : ExecutionProviderSet =\
+{
+	'cuda': 'CUDAExecutionProvider',
+	'tensorrt': 'TensorrtExecutionProvider',
+	'directml': 'DmlExecutionProvider',
+	'rocm': 'ROCMExecutionProvider',
+	'openvino': 'OpenVINOExecutionProvider',
+	'coreml': 'CoreMLExecutionProvider',
+	'cpu': 'CPUExecutionProvider'
+}
+execution_providers : List[ExecutionProvider] = list(execution_provider_set.keys())
+download_provider_set : DownloadProviderSet =\
+{
+	'github':
+	{
+		'urls':
+		[
+			'https://github.com'
+		],
+		'path': '/facefusion/facefusion-assets/releases/download/{base_name}/{file_name}'
+	},
+	'huggingface':
+	{
+		'urls':
+		[
+			'https://huggingface.co',
+			'https://hf-mirror.com'
+		],
+		'path': '/facefusion/{base_name}/resolve/main/{file_name}'
+	}
+}
+download_providers : List[DownloadProvider] = list(download_provider_set.keys())
+download_scopes : List[DownloadScope] = [ 'lite', 'full' ]
+
+video_memory_strategies : List[VideoMemoryStrategy] = [ 'strict', 'moderate', 'tolerant' ]
+
+log_level_set : LogLevelSet =\
+{
+	'error': logging.ERROR,
+	'warn': logging.WARNING,
+	'info': logging.INFO,
+	'debug': logging.DEBUG
+}
+log_levels : List[LogLevel] = list(log_level_set.keys())
+
+ui_workflows : List[UiWorkflow] = [ 'instant_runner', 'job_runner', 'job_manager' ]
+job_statuses : List[JobStatus] = [ 'drafted', 'queued', 'completed', 'failed' ]
+
+benchmark_cycle_count_range : Sequence[int] = create_int_range(1, 10, 1)
+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.0, 0.05)
+output_image_quality_range : Sequence[int] = create_int_range(0, 100, 1)
+output_audio_quality_range : Sequence[int] = create_int_range(0, 100, 1)
+output_audio_volume_range : Sequence[int] = create_int_range(0, 100, 1)
+output_video_quality_range : Sequence[int] = create_int_range(0, 100, 1)

facefusion/cli_helper.py

@@ -0,0 +1,35 @@
+from typing import Tuple
+
+from facefusion.logger import get_package_logger
+from facefusion.types import TableContents, TableHeaders
+
+
+def render_table(headers : TableHeaders, contents : TableContents) -> None:
+	package_logger = get_package_logger()
+	table_column, table_separator = create_table_parts(headers, contents)
+
+	package_logger.critical(table_separator)
+	package_logger.critical(table_column.format(*headers))
+	package_logger.critical(table_separator)
+
+	for content in contents:
+		content = [ str(value) for value in content ]
+		package_logger.critical(table_column.format(*content))
+
+	package_logger.critical(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) + '-+'

facefusion/common_helper.py

@@ -0,0 +1,84 @@
+import platform
+from typing import Any, Iterable, Optional, Reversible, 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[int]:
+	try:
+		return int(value)
+	except (ValueError, TypeError):
+		return None
+
+
+def cast_float(value : Any) -> Optional[float]:
+	try:
+		return float(value)
+	except (ValueError, TypeError):
+		return None
+
+
+def cast_bool(value : Any) -> Optional[bool]:
+	if value == 'True':
+		return True
+	if value == 'False':
+		return False
+	return None
+
+
+def get_first(__list__ : Any) -> Any:
+	if isinstance(__list__, Iterable):
+		return next(iter(__list__), None)
+	return None
+
+
+def get_last(__list__ : Any) -> Any:
+	if isinstance(__list__, Reversible):
+		return next(reversed(__list__), None)
+	return None

facefusion/config.py

@@ -0,0 +1,74 @@
+from configparser import ConfigParser
+from typing import List, Optional
+
+from facefusion import state_manager
+from facefusion.common_helper import cast_bool, cast_float, cast_int
+
+CONFIG_PARSER = None
+
+
+def get_config_parser() -> ConfigParser:
+	global CONFIG_PARSER
+
+	if CONFIG_PARSER is None:
+		CONFIG_PARSER = ConfigParser()
+		CONFIG_PARSER.read(state_manager.get_item('config_path'), encoding = 'utf-8')
+	return CONFIG_PARSER
+
+
+def clear_config_parser() -> None:
+	global CONFIG_PARSER
+
+	CONFIG_PARSER = None
+
+
+def get_str_value(section : str, option : str, fallback : Optional[str] = None) -> Optional[str]:
+	config_parser = get_config_parser()
+
+	if config_parser.has_option(section, option) and config_parser.get(section, option).strip():
+		return config_parser.get(section, option)
+	return fallback
+
+
+def get_int_value(section : str, option : str, fallback : Optional[str] = None) -> Optional[int]:
+	config_parser = get_config_parser()
+
+	if config_parser.has_option(section, option) and config_parser.get(section, option).strip():
+		return config_parser.getint(section, option)
+	return cast_int(fallback)
+
+
+def get_float_value(section : str, option : str, fallback : Optional[str] = None) -> Optional[float]:
+	config_parser = get_config_parser()
+
+	if config_parser.has_option(section, option) and config_parser.get(section, option).strip():
+		return config_parser.getfloat(section, option)
+	return cast_float(fallback)
+
+
+def get_bool_value(section : str, option : str, fallback : Optional[str] = None) -> Optional[bool]:
+	config_parser = get_config_parser()
+
+	if config_parser.has_option(section, option) and config_parser.get(section, option).strip():
+		return config_parser.getboolean(section, option)
+	return cast_bool(fallback)
+
+
+def get_str_list(section : str, option : str, fallback : Optional[str] = None) -> Optional[List[str]]:
+	config_parser = get_config_parser()
+
+	if config_parser.has_option(section, option) and config_parser.get(section, option).strip():
+		return config_parser.get(section, option).split()
+	if fallback:
+		return fallback.split()
+	return None
+
+
+def get_int_list(section : str, option : str, fallback : Optional[str] = None) -> Optional[List[int]]:
+	config_parser = get_config_parser()
+
+	if config_parser.has_option(section, option) and config_parser.get(section, option).strip():
+		return list(map(int, config_parser.get(section, option).split()))
+	if fallback:
+		return list(map(int, fallback.split()))
+	return None

facefusion/content_analyser.py

@@ -0,0 +1,225 @@
+from functools import lru_cache
+from typing import List, Tuple
+
+import numpy
+from tqdm import tqdm
+
+from facefusion import inference_manager, state_manager, wording
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
+from facefusion.execution import has_execution_provider
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.types import Detection, DownloadScope, DownloadSet, ExecutionProvider, Fps, InferencePool, ModelSet, VisionFrame
+from facefusion.vision import detect_video_fps, fit_frame, read_image, read_video_frame
+
+STREAM_COUNTER = 0
+
+
+@lru_cache(maxsize = None)
+def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
+	return\
+	{
+		'nsfw_1':
+		{
+			'hashes':
+			{
+				'content_analyser':
+				{
+					'url': resolve_download_url('models-3.3.0', 'nsfw_1.hash'),
+					'path': resolve_relative_path('../.assets/models/nsfw_1.hash')
+				}
+			},
+			'sources':
+			{
+				'content_analyser':
+				{
+					'url': resolve_download_url('models-3.3.0', 'nsfw_1.onnx'),
+					'path': resolve_relative_path('../.assets/models/nsfw_1.onnx')
+				}
+			},
+			'size': (640, 640),
+			'mean': (0.0, 0.0, 0.0),
+			'standard_deviation': (1.0, 1.0, 1.0)
+		},
+		'nsfw_2':
+		{
+			'hashes':
+			{
+				'content_analyser':
+				{
+					'url': resolve_download_url('models-3.3.0', 'nsfw_2.hash'),
+					'path': resolve_relative_path('../.assets/models/nsfw_2.hash')
+				}
+			},
+			'sources':
+			{
+				'content_analyser':
+				{
+					'url': resolve_download_url('models-3.3.0', 'nsfw_2.onnx'),
+					'path': resolve_relative_path('../.assets/models/nsfw_2.onnx')
+				}
+			},
+			'size': (384, 384),
+			'mean': (0.5, 0.5, 0.5),
+			'standard_deviation': (0.5, 0.5, 0.5)
+		},
+		'nsfw_3':
+		{
+			'hashes':
+			{
+				'content_analyser':
+				{
+					'url': resolve_download_url('models-3.3.0', 'nsfw_3.hash'),
+					'path': resolve_relative_path('../.assets/models/nsfw_3.hash')
+				}
+			},
+			'sources':
+			{
+				'content_analyser':
+				{
+					'url': resolve_download_url('models-3.3.0', 'nsfw_3.onnx'),
+					'path': resolve_relative_path('../.assets/models/nsfw_3.onnx')
+				}
+			},
+			'size': (448, 448),
+			'mean': (0.48145466, 0.4578275, 0.40821073),
+			'standard_deviation': (0.26862954, 0.26130258, 0.27577711)
+		}
+	}
+
+
+def get_inference_pool() -> InferencePool:
+	model_names = [ 'nsfw_1', 'nsfw_2', 'nsfw_3' ]
+	_, model_source_set = collect_model_downloads()
+
+	return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
+
+
+def clear_inference_pool() -> None:
+	model_names = [ 'nsfw_1', 'nsfw_2', 'nsfw_3' ]
+	inference_manager.clear_inference_pool(__name__, model_names)
+
+
+def resolve_execution_providers() -> List[ExecutionProvider]:
+	if has_execution_provider('coreml'):
+		return [ 'cpu' ]
+	return state_manager.get_item('execution_providers')
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_set = create_static_model_set('full')
+	model_hash_set = {}
+	model_source_set = {}
+
+	for content_analyser_model in [ 'nsfw_1', 'nsfw_2', 'nsfw_3' ]:
+		model_hash_set[content_analyser_model] = model_set.get(content_analyser_model).get('hashes').get('content_analyser')
+		model_source_set[content_analyser_model] = model_set.get(content_analyser_model).get('sources').get('content_analyser')
+
+	return model_hash_set, model_source_set
+
+
+def pre_check() -> bool:
+	model_hash_set, model_source_set = collect_model_downloads()
+
+	return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
+
+
+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:
+	return detect_nsfw(vision_frame)
+
+
+@lru_cache(maxsize = None)
+def analyse_image(image_path : str) -> bool:
+	vision_frame = read_image(image_path)
+	return analyse_frame(vision_frame)
+
+
+@lru_cache(maxsize = None)
+def analyse_video(video_path : str, trim_frame_start : int, trim_frame_end : int) -> bool:
+	video_fps = detect_video_fps(video_path)
+	frame_range = range(trim_frame_start, trim_frame_end)
+	rate = 0.0
+	total = 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:
+				vision_frame = read_video_frame(video_path, frame_number)
+				total += 1
+				if analyse_frame(vision_frame):
+					counter += 1
+			if counter > 0 and total > 0:
+				rate = counter / total * 100
+			progress.set_postfix(rate = rate)
+			progress.update()
+
+	return bool(rate > 10.0)
+
+
+def detect_nsfw(vision_frame : VisionFrame) -> bool:
+	is_nsfw_1 = detect_with_nsfw_1(vision_frame)
+	is_nsfw_2 = detect_with_nsfw_2(vision_frame)
+	is_nsfw_3 = detect_with_nsfw_3(vision_frame)
+
+	return is_nsfw_1 and is_nsfw_2 or is_nsfw_1 and is_nsfw_3 or is_nsfw_2 and is_nsfw_3
+
+
+def detect_with_nsfw_1(vision_frame : VisionFrame) -> bool:
+	detect_vision_frame = prepare_detect_frame(vision_frame, 'nsfw_1')
+	detection = forward_nsfw(detect_vision_frame, 'nsfw_1')
+	detection_score = numpy.max(numpy.amax(detection[:, 4:], axis = 1))
+	return bool(detection_score > 0.2)
+
+
+def detect_with_nsfw_2(vision_frame : VisionFrame) -> bool:
+	detect_vision_frame = prepare_detect_frame(vision_frame, 'nsfw_2')
+	detection = forward_nsfw(detect_vision_frame, 'nsfw_2')
+	detection_score = detection[0] - detection[1]
+	return bool(detection_score > 0.25)
+
+
+def detect_with_nsfw_3(vision_frame : VisionFrame) -> bool:
+	detect_vision_frame = prepare_detect_frame(vision_frame, 'nsfw_3')
+	detection = forward_nsfw(detect_vision_frame, 'nsfw_3')
+	detection_score = (detection[2] + detection[3]) - (detection[0] + detection[1])
+	return bool(detection_score > 10.5)
+
+
+def forward_nsfw(vision_frame : VisionFrame, nsfw_model : str) -> Detection:
+	content_analyser = get_inference_pool().get(nsfw_model)
+
+	with conditional_thread_semaphore():
+		detection = content_analyser.run(None,
+		{
+			'input': vision_frame
+		})[0]
+
+	if nsfw_model in [ 'nsfw_2', 'nsfw_3' ]:
+		return detection[0]
+
+	return detection
+
+
+def prepare_detect_frame(temp_vision_frame : VisionFrame, model_name : str) -> VisionFrame:
+	model_set = create_static_model_set('full').get(model_name)
+	model_size = model_set.get('size')
+	model_mean = model_set.get('mean')
+	model_standard_deviation = model_set.get('standard_deviation')
+
+	detect_vision_frame = fit_frame(temp_vision_frame, model_size)
+	detect_vision_frame = detect_vision_frame[:, :, ::-1] / 255.0
+	detect_vision_frame -= model_mean
+	detect_vision_frame /= model_standard_deviation
+	detect_vision_frame = numpy.expand_dims(detect_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return detect_vision_frame

facefusion/core.py

@@ -0,0 +1,517 @@
+import inspect
+import itertools
+import shutil
+import signal
+import sys
+from time import time
+
+import numpy
+
+from facefusion import benchmarker, cli_helper, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, hash_helper, logger, process_manager, state_manager, video_manager, voice_extractor, wording
+from facefusion.args import apply_args, collect_job_args, reduce_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 hard_exit, signal_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, get_file_name, is_image, is_video, resolve_file_paths, resolve_file_pattern
+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.temp_helper import clear_temp_directory, create_temp_directory, get_temp_file_path, move_temp_file, resolve_temp_frame_paths
+from facefusion.types import Args, ErrorCode
+from facefusion.vision import pack_resolution, read_image, read_static_images, read_video_frame, restrict_image_resolution, restrict_trim_frame, restrict_video_fps, restrict_video_resolution, unpack_resolution
+
+
+def cli() -> None:
+	if pre_check():
+		signal.signal(signal.SIGINT, signal_exit)
+		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()
+		else:
+			hard_exit(2)
+	else:
+		hard_exit(2)
+
+
+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 hard_exit(error_code)
+
+	if state_manager.get_item('command') == 'benchmark':
+		if not common_pre_check() or not processors_pre_check() or not benchmarker.pre_check():
+			return hard_exit(2)
+		benchmarker.render()
+
+	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 state_manager.get_item('command') == 'run':
+		import facefusion.uis.core as ui
+
+		if not common_pre_check() or not processors_pre_check():
+			return hard_exit(2)
+		for ui_layout in ui.get_ui_layouts_modules(state_manager.get_item('ui_layouts')):
+			if not ui_layout.pre_check():
+				return hard_exit(2)
+		ui.init()
+		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') == 'batch-run':
+		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+			hard_exit(1)
+		error_core = process_batch(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, 10):
+		logger.error(wording.get('python_not_supported').format(version = '3.10'), __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:
+	common_modules =\
+	[
+		content_analyser,
+		face_classifier,
+		face_detector,
+		face_landmarker,
+		face_masker,
+		face_recognizer,
+		voice_extractor
+	]
+
+	content_analyser_content = inspect.getsource(content_analyser).encode()
+	is_valid = hash_helper.create_hash(content_analyser_content) == 'b159fd9d'
+
+	return all(module.pre_check() for module in common_modules) and is_valid
+
+
+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 force_download() -> ErrorCode:
+	common_modules =\
+	[
+		content_analyser,
+		face_classifier,
+		face_detector,
+		face_landmarker,
+		face_masker,
+		face_recognizer,
+		voice_extractor
+	]
+	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
+	processor_modules = get_processors_modules(available_processors)
+
+	for module in common_modules + processor_modules:
+		if hasattr(module, 'create_static_model_set'):
+			for model in module.create_static_model_set(state_manager.get_item('download_scope')).values():
+				model_hash_set = model.get('hashes')
+				model_source_set = model.get('sources')
+
+				if model_hash_set and model_source_set:
+					if not conditional_download_hashes(model_hash_set) or not conditional_download_sources(model_source_set):
+						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:
+			cli_helper.render_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(state_manager.get_item('halt_on_error')):
+			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(state_manager.get_item('halt_on_error')):
+			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, state_manager.get_item('halt_on_error')):
+			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, state_manager.get_item('halt_on_error')):
+			logger.info(wording.get('processing_jobs_succeed'), __name__)
+			return 0
+		logger.info(wording.get('processing_jobs_failed'), __name__)
+		return 1
+	return 2
+
+
+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_batch(args : Args) -> ErrorCode:
+	job_id = job_helper.suggest_job_id('batch')
+	step_args = reduce_step_args(args)
+	job_args = reduce_job_args(args)
+	source_paths = resolve_file_pattern(job_args.get('source_pattern'))
+	target_paths = resolve_file_pattern(job_args.get('target_pattern'))
+
+	if job_manager.create_job(job_id):
+		if source_paths and target_paths:
+			for index, (source_path, target_path) in enumerate(itertools.product(source_paths, target_paths)):
+				step_args['source_paths'] = [ source_path ]
+				step_args['target_path'] = target_path
+				step_args['output_path'] = job_args.get('output_pattern').format(index = index)
+				if not job_manager.add_step(job_id, step_args):
+					return 1
+			if job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step):
+				return 0
+
+		if not source_paths and target_paths:
+			for index, target_path in enumerate(target_paths):
+				step_args['target_path'] = target_path
+				step_args['output_path'] = job_args.get('output_pattern').format(index = index)
+				if not job_manager.add_step(job_id, step_args):
+					return 1
+			if job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step):
+				return 0
+	return 1
+
+
+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 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 = read_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 process_image(start_time : float) -> ErrorCode:
+	if analyse_image(state_manager.get_item('target_path')):
+		return 3
+
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+	logger.debug(wording.get('creating_temp'), __name__)
+	create_temp_directory(state_manager.get_item('target_path'))
+
+	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
+
+	temp_image_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_image_path, temp_image_path)
+		processor_module.post_process()
+	if is_process_stopping():
+		process_manager.end()
+		return 4
+
+	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__)
+
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+
+	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__)
+	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:
+	trim_frame_start, trim_frame_end = restrict_trim_frame(state_manager.get_item('target_path'), state_manager.get_item('trim_frame_start'), state_manager.get_item('trim_frame_end'))
+	if analyse_video(state_manager.get_item('target_path'), trim_frame_start, trim_frame_end):
+		return 3
+
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+	logger.debug(wording.get('creating_temp'), __name__)
+	create_temp_directory(state_manager.get_item('target_path'))
+
+	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, trim_frame_start, trim_frame_end):
+		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
+
+	temp_frame_paths = resolve_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
+
+	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'), temp_video_fps, state_manager.get_item('output_video_resolution'), state_manager.get_item('output_video_fps'), trim_frame_start, trim_frame_end):
+		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
+
+	if state_manager.get_item('output_audio_volume') == 0:
+		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')):
+				video_manager.clear_video_pool()
+				logger.debug(wording.get('replacing_audio_succeed'), __name__)
+			else:
+				video_manager.clear_video_pool()
+				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'), trim_frame_start, trim_frame_end):
+				video_manager.clear_video_pool()
+				logger.debug(wording.get('restoring_audio_succeed'), __name__)
+			else:
+				video_manager.clear_video_pool()
+				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'))
+
+	logger.debug(wording.get('clearing_temp'), __name__)
+	clear_temp_directory(state_manager.get_item('target_path'))
+
+	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__)
+	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/curl_builder.py

@@ -0,0 +1,27 @@
+import itertools
+import shutil
+
+from facefusion import metadata
+from facefusion.types import Commands
+
+
+def run(commands : Commands) -> Commands:
+	user_agent = metadata.get('name') + '/' + metadata.get('version')
+
+	return [ shutil.which('curl'), '--user-agent', user_agent, '--insecure', '--location', '--silent' ] + commands
+
+
+def chain(*commands : Commands) -> Commands:
+	return list(itertools.chain(*commands))
+
+
+def head(url : str) -> Commands:
+	return [ '-I', url ]
+
+
+def download(url : str, download_file_path : str) -> Commands:
+	return [ '--create-dirs', '--continue-at', '-', '--output', download_file_path, url ]
+
+
+def set_timeout(timeout : int) -> Commands:
+	return [ '--connect-timeout', str(timeout) ]

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,174 @@
+import os
+import subprocess
+from functools import lru_cache
+from typing import List, Optional, Tuple
+from urllib.parse import urlparse
+
+from tqdm import tqdm
+
+import facefusion.choices
+from facefusion import curl_builder, logger, process_manager, state_manager, wording
+from facefusion.filesystem import get_file_name, get_file_size, is_file, remove_file
+from facefusion.hash_helper import validate_hash
+from facefusion.types import Commands, DownloadProvider, DownloadSet
+
+
+def open_curl(commands : Commands) -> subprocess.Popen[bytes]:
+	commands = curl_builder.run(commands)
+	return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
+
+
+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_static_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:
+				commands = curl_builder.chain(
+					curl_builder.download(url, download_file_path),
+					curl_builder.set_timeout(10)
+				)
+				open_curl(commands)
+				current_size = initial_size
+				progress.set_postfix(download_providers = state_manager.get_item('download_providers'), file_name = 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_static_download_size(url : str) -> int:
+	commands = curl_builder.chain(
+		curl_builder.head(url),
+		curl_builder.set_timeout(5)
+	)
+	process = open_curl(commands)
+	lines = reversed(process.stdout.readlines())
+
+	for line in lines:
+		__line__ = line.decode().lower()
+		if 'content-length:' in __line__:
+			_, content_length = __line__.split('content-length:')
+			return int(content_length)
+
+	return 0
+
+
+@lru_cache(maxsize = None)
+def ping_static_url(url : str) -> bool:
+	commands = curl_builder.chain(
+		curl_builder.head(url),
+		curl_builder.set_timeout(5)
+	)
+	process = open_curl(commands)
+	process.communicate()
+	return process.returncode == 0
+
+
+def conditional_download_hashes(hash_set : DownloadSet) -> bool:
+	hash_paths = [ hash_set.get(hash_key).get('path') for hash_key in hash_set.keys() ]
+
+	process_manager.check()
+	_, invalid_hash_paths = validate_hash_paths(hash_paths)
+	if invalid_hash_paths:
+		for index in hash_set:
+			if hash_set.get(index).get('path') in invalid_hash_paths:
+				invalid_hash_url = hash_set.get(index).get('url')
+				if invalid_hash_url:
+					download_directory_path = os.path.dirname(hash_set.get(index).get('path'))
+					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 = get_file_name(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 = get_file_name(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(source_set : DownloadSet) -> bool:
+	source_paths = [ source_set.get(source_key).get('path') for source_key in source_set.keys() ]
+
+	process_manager.check()
+	_, invalid_source_paths = validate_source_paths(source_paths)
+	if invalid_source_paths:
+		for index in source_set:
+			if source_set.get(index).get('path') in invalid_source_paths:
+				invalid_source_url = source_set.get(index).get('url')
+				if invalid_source_url:
+					download_directory_path = os.path.dirname(source_set.get(index).get('path'))
+					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 = get_file_name(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 = get_file_name(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
+
+
+def resolve_download_url(base_name : str, file_name : str) -> Optional[str]:
+	download_providers = state_manager.get_item('download_providers')
+
+	for download_provider in download_providers:
+		download_url = resolve_download_url_by_provider(download_provider, base_name, file_name)
+		if download_url:
+			return download_url
+
+	return None
+
+
+def resolve_download_url_by_provider(download_provider : DownloadProvider, base_name : str, file_name : str) -> Optional[str]:
+	download_provider_value = facefusion.choices.download_provider_set.get(download_provider)
+
+	for download_provider_url in download_provider_value.get('urls'):
+		if ping_static_url(download_provider_url):
+			return download_provider_url + download_provider_value.get('path').format(base_name = base_name, file_name = file_name)
+
+	return None

facefusion/execution.py

@@ -0,0 +1,156 @@
+import shutil
+import subprocess
+import xml.etree.ElementTree as ElementTree
+from functools import lru_cache
+from typing import List, Optional
+
+from onnxruntime import get_available_providers, set_default_logger_severity
+
+import facefusion.choices
+from facefusion.types import ExecutionDevice, ExecutionProvider, InferenceSessionProvider, ValueAndUnit
+
+set_default_logger_severity(3)
+
+
+def has_execution_provider(execution_provider : ExecutionProvider) -> bool:
+	return execution_provider in get_available_execution_providers()
+
+
+def get_available_execution_providers() -> List[ExecutionProvider]:
+	inference_session_providers = get_available_providers()
+	available_execution_providers : List[ExecutionProvider] = []
+
+	for execution_provider, execution_provider_value in facefusion.choices.execution_provider_set.items():
+		if execution_provider_value in inference_session_providers:
+			index = facefusion.choices.execution_providers.index(execution_provider)
+			available_execution_providers.insert(index, execution_provider)
+
+	return available_execution_providers
+
+
+def create_inference_session_providers(execution_device_id : str, execution_providers : List[ExecutionProvider]) -> List[InferenceSessionProvider]:
+	inference_session_providers : List[InferenceSessionProvider] = []
+
+	for execution_provider in execution_providers:
+		if execution_provider == 'cuda':
+			inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'device_id': execution_device_id,
+				'cudnn_conv_algo_search': resolve_cudnn_conv_algo_search()
+			}))
+		if execution_provider == 'tensorrt':
+			inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'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 in [ 'directml', 'rocm' ]:
+			inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'device_id': execution_device_id
+			}))
+		if execution_provider == 'openvino':
+			inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'device_type': resolve_openvino_device_type(execution_device_id),
+				'precision': 'FP32'
+			}))
+		if execution_provider == 'coreml':
+			inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'SpecializationStrategy': 'FastPrediction',
+				'ModelCacheDirectory': '.caches'
+			}))
+
+	if 'cpu' in execution_providers:
+		inference_session_providers.append(facefusion.choices.execution_provider_set.get('cpu'))
+
+	return inference_session_providers
+
+
+def resolve_cudnn_conv_algo_search() -> str:
+	execution_devices = detect_static_execution_devices()
+	product_names = ('GeForce GTX 1630', 'GeForce GTX 1650', 'GeForce GTX 1660')
+
+	for execution_device in execution_devices:
+		if execution_device.get('product').get('name').startswith(product_names):
+			return 'DEFAULT'
+
+	return 'EXHAUSTIVE'
+
+
+def resolve_openvino_device_type(execution_device_id : str) -> str:
+	if execution_device_id == '0':
+		return 'GPU'
+	if execution_device_id == '∞':
+		return 'MULTI:GPU'
+	return 'GPU.' + execution_device_id
+
+
+def run_nvidia_smi() -> subprocess.Popen[bytes]:
+	commands = [ shutil.which('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.findtext('driver_version'),
+			'framework':
+			{
+				'name': 'CUDA',
+				'version': root_element.findtext('cuda_version')
+			},
+			'product':
+			{
+				'vendor': 'NVIDIA',
+				'name': gpu_element.findtext('product_name').replace('NVIDIA', '').strip()
+			},
+			'video_memory':
+			{
+				'total': create_value_and_unit(gpu_element.findtext('fb_memory_usage/total')),
+				'free': create_value_and_unit(gpu_element.findtext('fb_memory_usage/free'))
+			},
+			'temperature':
+			{
+				'gpu': create_value_and_unit(gpu_element.findtext('temperature/gpu_temp')),
+				'memory': create_value_and_unit(gpu_element.findtext('temperature/memory_temp'))
+			},
+			'utilization':
+			{
+				'gpu': create_value_and_unit(gpu_element.findtext('utilization/gpu_util')),
+				'memory': create_value_and_unit(gpu_element.findtext('utilization/memory_util'))
+			}
+		})
+
+	return execution_devices
+
+
+def create_value_and_unit(text : str) -> Optional[ValueAndUnit]:
+	if ' ' in text:
+		value, unit = text.split()
+
+		return\
+		{
+			'value': int(value),
+			'unit': str(unit)
+		}
+	return None

facefusion/exit_helper.py

@@ -0,0 +1,26 @@
+import signal
+import sys
+from time import sleep
+from types import FrameType
+
+from facefusion import process_manager, state_manager
+from facefusion.temp_helper import clear_temp_directory
+from facefusion.types import ErrorCode
+
+
+def hard_exit(error_code : ErrorCode) -> None:
+	signal.signal(signal.SIGINT, signal.SIG_IGN)
+	sys.exit(error_code)
+
+
+def signal_exit(signum : int, frame : FrameType) -> None:
+	graceful_exit(0)
+
+
+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_landmark, 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.types 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_landmark(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,134 @@
+from functools import lru_cache
+from typing import List, Tuple
+
+import numpy
+
+from facefusion import inference_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
+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.types import Age, DownloadScope, FaceLandmark5, Gender, InferencePool, ModelOptions, ModelSet, Race, VisionFrame
+
+
+@lru_cache(maxsize = None)
+def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
+	return\
+	{
+		'fairface':
+		{
+			'hashes':
+			{
+				'face_classifier':
+				{
+					'url': resolve_download_url('models-3.0.0', 'fairface.hash'),
+					'path': resolve_relative_path('../.assets/models/fairface.hash')
+				}
+			},
+			'sources':
+			{
+				'face_classifier':
+				{
+					'url': resolve_download_url('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_names = [ 'fairface' ]
+	model_source_set = get_model_options().get('sources')
+
+	return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
+
+
+def clear_inference_pool() -> None:
+	model_names = [ 'fairface' ]
+	inference_manager.clear_inference_pool(__name__, model_names)
+
+
+def get_model_options() -> ModelOptions:
+	return create_static_model_set('full').get('fairface')
+
+
+def pre_check() -> bool:
+	model_hash_set = get_model_options().get('hashes')
+	model_source_set = get_model_options().get('sources')
+
+	return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
+
+
+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.0
+	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,323 @@
+from functools import lru_cache
+from typing import List, Sequence, Tuple
+
+import cv2
+import numpy
+
+from facefusion import inference_manager, state_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
+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.types import Angle, BoundingBox, Detection, DownloadScope, DownloadSet, FaceLandmark5, InferencePool, ModelSet, Score, VisionFrame
+from facefusion.vision import restrict_frame, unpack_resolution
+
+
+@lru_cache(maxsize = None)
+def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
+	return\
+	{
+		'retinaface':
+		{
+			'hashes':
+			{
+				'retinaface':
+				{
+					'url': resolve_download_url('models-3.0.0', 'retinaface_10g.hash'),
+					'path': resolve_relative_path('../.assets/models/retinaface_10g.hash')
+				}
+			},
+			'sources':
+			{
+				'retinaface':
+				{
+					'url': resolve_download_url('models-3.0.0', 'retinaface_10g.onnx'),
+					'path': resolve_relative_path('../.assets/models/retinaface_10g.onnx')
+				}
+			}
+		},
+		'scrfd':
+		{
+			'hashes':
+			{
+				'scrfd':
+				{
+					'url': resolve_download_url('models-3.0.0', 'scrfd_2.5g.hash'),
+					'path': resolve_relative_path('../.assets/models/scrfd_2.5g.hash')
+				}
+			},
+			'sources':
+			{
+				'scrfd':
+				{
+					'url': resolve_download_url('models-3.0.0', 'scrfd_2.5g.onnx'),
+					'path': resolve_relative_path('../.assets/models/scrfd_2.5g.onnx')
+				}
+			}
+		},
+		'yolo_face':
+		{
+			'hashes':
+			{
+				'yolo_face':
+				{
+					'url': resolve_download_url('models-3.0.0', 'yoloface_8n.hash'),
+					'path': resolve_relative_path('../.assets/models/yoloface_8n.hash')
+				}
+			},
+			'sources':
+			{
+				'yolo_face':
+				{
+					'url': resolve_download_url('models-3.0.0', 'yoloface_8n.onnx'),
+					'path': resolve_relative_path('../.assets/models/yoloface_8n.onnx')
+				}
+			}
+		}
+	}
+
+
+def get_inference_pool() -> InferencePool:
+	model_names = [ state_manager.get_item('face_detector_model') ]
+	_, model_source_set = collect_model_downloads()
+
+	return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
+
+
+def clear_inference_pool() -> None:
+	model_names = [ state_manager.get_item('face_detector_model') ]
+	inference_manager.clear_inference_pool(__name__, model_names)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_set = create_static_model_set('full')
+	model_hash_set = {}
+	model_source_set = {}
+
+	for face_detector_model in [ 'retinaface', 'scrfd', 'yolo_face' ]:
+		if state_manager.get_item('face_detector_model') in [ 'many', face_detector_model ]:
+			model_hash_set[face_detector_model] = model_set.get(face_detector_model).get('hashes').get(face_detector_model)
+			model_source_set[face_detector_model] = model_set.get(face_detector_model).get('sources').get(face_detector_model)
+
+	return model_hash_set, model_source_set
+
+
+def pre_check() -> bool:
+	model_hash_set, model_source_set = collect_model_downloads()
+
+	return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
+
+
+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', 'yolo_face' ]:
+		bounding_boxes, face_scores, face_landmarks_5 = detect_with_yolo_face(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_score = state_manager.get_item('face_detector_score')
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	temp_vision_frame = restrict_frame(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)
+	detect_vision_frame = normalize_detect_frame(detect_vision_frame, [ -1, 1 ])
+	detection = forward_with_retinaface(detect_vision_frame)
+
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detection[index] >= 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_boxes_raw = detection[index + feature_map_channel] * feature_stride
+			face_landmarks_5_raw = detection[index + feature_map_channel * 2] * feature_stride
+
+			for bounding_box_raw in distance_to_bounding_box(anchors, bounding_boxes_raw)[keep_indices]:
+				bounding_boxes.append(numpy.array(
+				[
+					bounding_box_raw[0] * ratio_width,
+					bounding_box_raw[1] * ratio_height,
+					bounding_box_raw[2] * ratio_width,
+					bounding_box_raw[3] * ratio_height
+				]))
+
+			for face_score_raw in detection[index][keep_indices]:
+				face_scores.append(face_score_raw[0])
+
+			for face_landmark_raw_5 in distance_to_face_landmark_5(anchors, face_landmarks_5_raw)[keep_indices]:
+				face_landmarks_5.append(face_landmark_raw_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_score = state_manager.get_item('face_detector_score')
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	temp_vision_frame = restrict_frame(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)
+	detect_vision_frame = normalize_detect_frame(detect_vision_frame, [ -1, 1 ])
+	detection = forward_with_scrfd(detect_vision_frame)
+
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detection[index] >= 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_boxes_raw = detection[index + feature_map_channel] * feature_stride
+			face_landmarks_5_raw = detection[index + feature_map_channel * 2] * feature_stride
+
+			for bounding_box_raw in distance_to_bounding_box(anchors, bounding_boxes_raw)[keep_indices]:
+				bounding_boxes.append(numpy.array(
+				[
+					bounding_box_raw[0] * ratio_width,
+					bounding_box_raw[1] * ratio_height,
+					bounding_box_raw[2] * ratio_width,
+					bounding_box_raw[3] * ratio_height
+				]))
+
+			for face_score_raw in detection[index][keep_indices]:
+				face_scores.append(face_score_raw[0])
+
+			for face_landmark_raw_5 in distance_to_face_landmark_5(anchors, face_landmarks_5_raw)[keep_indices]:
+				face_landmarks_5.append(face_landmark_raw_5 * [ ratio_width, ratio_height ])
+
+	return bounding_boxes, face_scores, face_landmarks_5
+
+
+def detect_with_yolo_face(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
+	bounding_boxes = []
+	face_scores = []
+	face_landmarks_5 = []
+	face_detector_score = state_manager.get_item('face_detector_score')
+	face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
+	temp_vision_frame = restrict_frame(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)
+	detect_vision_frame = normalize_detect_frame(detect_vision_frame, [ 0, 1 ])
+	detection = forward_with_yolo_face(detect_vision_frame)
+	detection = numpy.squeeze(detection).T
+	bounding_boxes_raw, face_scores_raw, face_landmarks_5_raw = numpy.split(detection, [ 4, 5 ], axis = 1)
+	keep_indices = numpy.where(face_scores_raw > face_detector_score)[0]
+
+	if numpy.any(keep_indices):
+		bounding_boxes_raw, face_scores_raw, face_landmarks_5_raw = bounding_boxes_raw[keep_indices], face_scores_raw[keep_indices], face_landmarks_5_raw[keep_indices]
+
+		for bounding_box_raw in bounding_boxes_raw:
+			bounding_boxes.append(numpy.array(
+			[
+				(bounding_box_raw[0] - bounding_box_raw[2] / 2) * ratio_width,
+				(bounding_box_raw[1] - bounding_box_raw[3] / 2) * ratio_height,
+				(bounding_box_raw[0] + bounding_box_raw[2] / 2) * ratio_width,
+				(bounding_box_raw[1] + bounding_box_raw[3] / 2) * ratio_height
+			]))
+
+		face_scores = face_scores_raw.ravel().tolist()
+		face_landmarks_5_raw[:, 0::3] = (face_landmarks_5_raw[:, 0::3]) * ratio_width
+		face_landmarks_5_raw[:, 1::3] = (face_landmarks_5_raw[:, 1::3]) * ratio_height
+
+		for face_landmark_raw_5 in face_landmarks_5_raw:
+			face_landmarks_5.append(numpy.array(face_landmark_raw_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_yolo_face(detect_vision_frame : VisionFrame) -> Detection:
+	face_detector = get_inference_pool().get('yolo_face')
+
+	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 = numpy.expand_dims(detect_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
+	return detect_vision_frame
+
+
+def normalize_detect_frame(detect_vision_frame : VisionFrame, normalize_range : Sequence[int]) -> VisionFrame:
+	if normalize_range == [ -1, 1 ]:
+		return (detect_vision_frame - 127.5) / 128.0
+	if normalize_range == [ 0, 1 ]:
+		return detect_vision_frame / 255.0
+	return detect_vision_frame

facefusion/face_helper.py

@@ -0,0 +1,254 @@
+from functools import lru_cache
+from typing import List, Sequence, Tuple
+
+import cv2
+import numpy
+from cv2.typing import Size
+
+from facefusion.types import Anchors, Angle, BoundingBox, Distance, FaceDetectorModel, FaceLandmark5, FaceLandmark68, Mask, Matrix, Points, Scale, Score, Translation, VisionFrame, WarpTemplate, WarpTemplateSet
+
+WARP_TEMPLATE_SET : 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': numpy.array(
+	[
+		[ 0.36167656, 0.40387734 ],
+		[ 0.63696719, 0.40235469 ],
+		[ 0.50019687, 0.56044219 ],
+		[ 0.38710391, 0.72160547 ],
+		[ 0.61507734, 0.72034453 ]
+	]),
+	'dfl_whole_face': numpy.array(
+	[
+		[ 0.35342266, 0.39285716 ],
+		[ 0.62797622, 0.39285716 ],
+		[ 0.48660713, 0.54017860 ],
+		[ 0.38839287, 0.68750011 ],
+		[ 0.59821427, 0.68750011 ]
+	]),
+	'ffhq_512': numpy.array(
+	[
+		[ 0.37691676, 0.46864664 ],
+		[ 0.62285697, 0.46912813 ],
+		[ 0.50123859, 0.61331904 ],
+		[ 0.39308822, 0.72541100 ],
+		[ 0.61150205, 0.72490465 ]
+	]),
+	'mtcnn_512': numpy.array(
+	[
+		[ 0.36562865, 0.46733799 ],
+		[ 0.63305391, 0.46585885 ],
+		[ 0.50019127, 0.61942959 ],
+		[ 0.39032951, 0.77598822 ],
+		[ 0.61178945, 0.77476328 ]
+	]),
+	'styleganex_384': numpy.array(
+	[
+		[ 0.42353745, 0.52289879 ],
+		[ 0.57725008, 0.52319972 ],
+		[ 0.50123859, 0.61331904 ],
+		[ 0.43364461, 0.68337652 ],
+		[ 0.57015325, 0.68306005 ]
+	])
+}
+
+
+def estimate_matrix_by_face_landmark_5(face_landmark_5 : FaceLandmark5, warp_template : WarpTemplate, crop_size : Size) -> Matrix:
+	normed_warp_template = WARP_TEMPLATE_SET.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:
+	paste_bounding_box, paste_matrix = calc_paste_area(temp_vision_frame, crop_vision_frame, affine_matrix)
+	x_min, y_min, x_max, y_max = paste_bounding_box
+	paste_width = x_max - x_min
+	paste_height = y_max - y_min
+	inverse_mask = cv2.warpAffine(crop_mask, paste_matrix, (paste_width, paste_height)).clip(0, 1)
+	inverse_mask = numpy.expand_dims(inverse_mask, axis = -1)
+	inverse_vision_frame = cv2.warpAffine(crop_vision_frame, paste_matrix, (paste_width, paste_height), borderMode = cv2.BORDER_REPLICATE)
+	temp_vision_frame = temp_vision_frame.copy()
+	paste_vision_frame = temp_vision_frame[y_min:y_max, x_min:x_max]
+	paste_vision_frame = paste_vision_frame * (1 - inverse_mask) + inverse_vision_frame * inverse_mask
+	temp_vision_frame[y_min:y_max, x_min:x_max] = paste_vision_frame.astype(temp_vision_frame.dtype)
+	return temp_vision_frame
+
+
+def calc_paste_area(temp_vision_frame : VisionFrame, crop_vision_frame : VisionFrame, affine_matrix : Matrix) -> Tuple[BoundingBox, Matrix]:
+	temp_height, temp_width = temp_vision_frame.shape[:2]
+	crop_height, crop_width = crop_vision_frame.shape[:2]
+	inverse_matrix = cv2.invertAffineTransform(affine_matrix)
+	crop_points = numpy.array([ [ 0, 0 ], [ crop_width, 0 ], [ crop_width, crop_height ], [ 0, crop_height ] ])
+	paste_region_points = transform_points(crop_points, inverse_matrix)
+	min_point = numpy.floor(paste_region_points.min(axis = 0)).astype(int)
+	max_point = numpy.ceil(paste_region_points.max(axis = 0)).astype(int)
+	x_min, y_min = numpy.clip(min_point, 0, [ temp_width, temp_height ])
+	x_max, y_max = numpy.clip(max_point, 0, [ temp_width, temp_height ])
+	paste_bounding_box = numpy.array([ x_min, y_min, x_max, y_max ])
+	paste_matrix = inverse_matrix.copy()
+	paste_matrix[0, 2] -= x_min
+	paste_matrix[1, 2] -= y_min
+	return paste_bounding_box, paste_matrix
+
+
+@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], 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, 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,222 @@
+from functools import lru_cache
+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, resolve_download_url
+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.types import Angle, BoundingBox, DownloadScope, DownloadSet, FaceLandmark5, FaceLandmark68, InferencePool, ModelSet, Prediction, Score, VisionFrame
+
+
+@lru_cache(maxsize = None)
+def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
+	return\
+	{
+		'2dfan4':
+		{
+			'hashes':
+			{
+				'2dfan4':
+				{
+					'url': resolve_download_url('models-3.0.0', '2dfan4.hash'),
+					'path': resolve_relative_path('../.assets/models/2dfan4.hash')
+				}
+			},
+			'sources':
+			{
+				'2dfan4':
+				{
+					'url': resolve_download_url('models-3.0.0', '2dfan4.onnx'),
+					'path': resolve_relative_path('../.assets/models/2dfan4.onnx')
+				}
+			},
+			'size': (256, 256)
+		},
+		'peppa_wutz':
+		{
+			'hashes':
+			{
+				'peppa_wutz':
+				{
+					'url': resolve_download_url('models-3.0.0', 'peppa_wutz.hash'),
+					'path': resolve_relative_path('../.assets/models/peppa_wutz.hash')
+				}
+			},
+			'sources':
+			{
+				'peppa_wutz':
+				{
+					'url': resolve_download_url('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': resolve_download_url('models-3.0.0', 'fan_68_5.hash'),
+					'path': resolve_relative_path('../.assets/models/fan_68_5.hash')
+				}
+			},
+			'sources':
+			{
+				'fan_68_5':
+				{
+					'url': resolve_download_url('models-3.0.0', 'fan_68_5.onnx'),
+					'path': resolve_relative_path('../.assets/models/fan_68_5.onnx')
+				}
+			}
+		}
+	}
+
+
+def get_inference_pool() -> InferencePool:
+	model_names = [ state_manager.get_item('face_landmarker_model'), 'fan_68_5' ]
+	_, model_source_set = collect_model_downloads()
+
+	return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
+
+
+def clear_inference_pool() -> None:
+	model_names = [ state_manager.get_item('face_landmarker_model'), 'fan_68_5' ]
+	inference_manager.clear_inference_pool(__name__, model_names)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_set = create_static_model_set('full')
+	model_hash_set =\
+	{
+		'fan_68_5': model_set.get('fan_68_5').get('hashes').get('fan_68_5')
+	}
+	model_source_set =\
+	{
+		'fan_68_5': model_set.get('fan_68_5').get('sources').get('fan_68_5')
+	}
+
+	for face_landmarker_model in [ '2dfan4', 'peppa_wutz' ]:
+		if state_manager.get_item('face_landmarker_model') in [ 'many', face_landmarker_model ]:
+			model_hash_set[face_landmarker_model] = model_set.get(face_landmarker_model).get('hashes').get(face_landmarker_model)
+			model_source_set[face_landmarker_model] = model_set.get(face_landmarker_model).get('sources').get(face_landmarker_model)
+
+	return model_hash_set, model_source_set
+
+
+def pre_check() -> bool:
+	model_hash_set, model_source_set = collect_model_downloads()
+
+	return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
+
+
+def detect_face_landmark(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 = create_static_model_set('full').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 = create_static_model_set('full').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,240 @@
+from functools import lru_cache
+from typing import List, Tuple
+
+import cv2
+import numpy
+
+import facefusion.choices
+from facefusion import inference_manager, state_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
+from facefusion.filesystem import resolve_relative_path
+from facefusion.thread_helper import conditional_thread_semaphore
+from facefusion.types import DownloadScope, DownloadSet, FaceLandmark68, FaceMaskArea, FaceMaskRegion, InferencePool, Mask, ModelSet, Padding, VisionFrame
+
+
+@lru_cache(maxsize = None)
+def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
+	return\
+	{
+		'xseg_1':
+		{
+			'hashes':
+			{
+				'face_occluder':
+				{
+					'url': resolve_download_url('models-3.1.0', 'xseg_1.hash'),
+					'path': resolve_relative_path('../.assets/models/xseg_1.hash')
+				}
+			},
+			'sources':
+			{
+				'face_occluder':
+				{
+					'url': resolve_download_url('models-3.1.0', 'xseg_1.onnx'),
+					'path': resolve_relative_path('../.assets/models/xseg_1.onnx')
+				}
+			},
+			'size': (256, 256)
+		},
+		'xseg_2':
+		{
+			'hashes':
+			{
+				'face_occluder':
+				{
+					'url': resolve_download_url('models-3.1.0', 'xseg_2.hash'),
+					'path': resolve_relative_path('../.assets/models/xseg_2.hash')
+				}
+			},
+			'sources':
+			{
+				'face_occluder':
+				{
+					'url': resolve_download_url('models-3.1.0', 'xseg_2.onnx'),
+					'path': resolve_relative_path('../.assets/models/xseg_2.onnx')
+				}
+			},
+			'size': (256, 256)
+		},
+		'xseg_3':
+		{
+			'hashes':
+			{
+				'face_occluder':
+				{
+					'url': resolve_download_url('models-3.2.0', 'xseg_3.hash'),
+					'path': resolve_relative_path('../.assets/models/xseg_3.hash')
+				}
+			},
+			'sources':
+			{
+				'face_occluder':
+				{
+					'url': resolve_download_url('models-3.2.0', 'xseg_3.onnx'),
+					'path': resolve_relative_path('../.assets/models/xseg_3.onnx')
+				}
+			},
+			'size': (256, 256)
+		},
+		'bisenet_resnet_18':
+		{
+			'hashes':
+			{
+				'face_parser':
+				{
+					'url': resolve_download_url('models-3.1.0', 'bisenet_resnet_18.hash'),
+					'path': resolve_relative_path('../.assets/models/bisenet_resnet_18.hash')
+				}
+			},
+			'sources':
+			{
+				'face_parser':
+				{
+					'url': resolve_download_url('models-3.1.0', 'bisenet_resnet_18.onnx'),
+					'path': resolve_relative_path('../.assets/models/bisenet_resnet_18.onnx')
+				}
+			},
+			'size': (512, 512)
+		},
+		'bisenet_resnet_34':
+		{
+			'hashes':
+			{
+				'face_parser':
+				{
+					'url': resolve_download_url('models-3.0.0', 'bisenet_resnet_34.hash'),
+					'path': resolve_relative_path('../.assets/models/bisenet_resnet_34.hash')
+				}
+			},
+			'sources':
+			{
+				'face_parser':
+				{
+					'url': resolve_download_url('models-3.0.0', 'bisenet_resnet_34.onnx'),
+					'path': resolve_relative_path('../.assets/models/bisenet_resnet_34.onnx')
+				}
+			},
+			'size': (512, 512)
+		}
+	}
+
+
+def get_inference_pool() -> InferencePool:
+	model_names = [ state_manager.get_item('face_occluder_model'), state_manager.get_item('face_parser_model') ]
+	_, model_source_set = collect_model_downloads()
+
+	return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
+
+
+def clear_inference_pool() -> None:
+	model_names = [ state_manager.get_item('face_occluder_model'), state_manager.get_item('face_parser_model') ]
+	inference_manager.clear_inference_pool(__name__, model_names)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_set = create_static_model_set('full')
+	model_hash_set = {}
+	model_source_set = {}
+
+	for face_occluder_model in [ 'xseg_1', 'xseg_2', 'xseg_3' ]:
+		if state_manager.get_item('face_occluder_model') == face_occluder_model:
+			model_hash_set[face_occluder_model] = model_set.get(face_occluder_model).get('hashes').get('face_occluder')
+			model_source_set[face_occluder_model] = model_set.get(face_occluder_model).get('sources').get('face_occluder')
+
+	for face_parser_model in [ 'bisenet_resnet_18', 'bisenet_resnet_34' ]:
+		if state_manager.get_item('face_parser_model') == face_parser_model:
+			model_hash_set[face_parser_model] = model_set.get(face_parser_model).get('hashes').get('face_parser')
+			model_source_set[face_parser_model] = model_set.get(face_parser_model).get('sources').get('face_parser')
+
+	return model_hash_set, model_source_set
+
+
+def pre_check() -> bool:
+	model_hash_set, model_source_set = collect_model_downloads()
+
+	return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
+
+
+def create_box_mask(crop_vision_frame : VisionFrame, face_mask_blur : float, face_mask_padding : Padding) -> Mask:
+	crop_size = crop_vision_frame.shape[:2][::-1]
+	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_name = state_manager.get_item('face_occluder_model')
+	model_size = create_static_model_set('full').get(model_name).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.0
+	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_area_mask(crop_vision_frame : VisionFrame, face_landmark_68 : FaceLandmark68, face_mask_areas : List[FaceMaskArea]) -> Mask:
+	crop_size = crop_vision_frame.shape[:2][::-1]
+	landmark_points = []
+
+	for face_mask_area in face_mask_areas:
+		if face_mask_area in facefusion.choices.face_mask_area_set:
+			landmark_points.extend(facefusion.choices.face_mask_area_set.get(face_mask_area))
+
+	convex_hull = cv2.convexHull(face_landmark_68[landmark_points].astype(numpy.int32))
+	area_mask = numpy.zeros(crop_size).astype(numpy.float32)
+	cv2.fillConvexPoly(area_mask, convex_hull, 1.0) # type: ignore[call-overload]
+	area_mask = (cv2.GaussianBlur(area_mask.clip(0, 1), (0, 0), 5).clip(0.5, 1) - 0.5) * 2
+	return area_mask
+
+
+def create_region_mask(crop_vision_frame : VisionFrame, face_mask_regions : List[FaceMaskRegion]) -> Mask:
+	model_name = state_manager.get_item('face_parser_model')
+	model_size = create_static_model_set('full').get(model_name).get('size')
+	prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
+	prepare_vision_frame = prepare_vision_frame[:, :, ::-1].astype(numpy.float32) / 255.0
+	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), [ facefusion.choices.face_mask_region_set.get(face_mask_region) for face_mask_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 forward_occlude_face(prepare_vision_frame : VisionFrame) -> Mask:
+	model_name = state_manager.get_item('face_occluder_model')
+	face_occluder = get_inference_pool().get(model_name)
+
+	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:
+	model_name = state_manager.get_item('face_parser_model')
+	face_parser = get_inference_pool().get(model_name)
+
+	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,87 @@
+from functools import lru_cache
+from typing import Tuple
+
+import numpy
+
+from facefusion import inference_manager
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
+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.types import DownloadScope, Embedding, FaceLandmark5, InferencePool, ModelOptions, ModelSet, VisionFrame
+
+
+@lru_cache(maxsize = None)
+def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
+	return\
+	{
+		'arcface':
+		{
+			'hashes':
+			{
+				'face_recognizer':
+				{
+					'url': resolve_download_url('models-3.0.0', 'arcface_w600k_r50.hash'),
+					'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.hash')
+				}
+			},
+			'sources':
+			{
+				'face_recognizer':
+				{
+					'url': resolve_download_url('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_names = [ 'arcface' ]
+	model_source_set = get_model_options().get('sources')
+
+	return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
+
+
+def clear_inference_pool() -> None:
+	model_names = [ 'arcface' ]
+	inference_manager.clear_inference_pool(__name__, model_names)
+
+
+def get_model_options() -> ModelOptions:
+	return create_static_model_set('full').get('arcface')
+
+
+def pre_check() -> bool:
+	model_hash_set = get_model_options().get('hashes')
+	model_source_set = get_model_options().get('sources')
+
+	return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
+
+
+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,108 @@
+from typing import List
+
+import numpy
+
+from facefusion import state_manager
+from facefusion.types import Face, FaceSelectorOrder, FaceSet, Gender, Race, Score
+
+
+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)
+	current_face_distance = float(numpy.interp(current_face_distance, [ 0, 2 ], [ 0, 1 ]))
+	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_faces_by_order(faces, state_manager.get_item('face_selector_order'))
+		if state_manager.get_item('face_selector_gender'):
+			faces = filter_faces_by_gender(faces, state_manager.get_item('face_selector_gender'))
+		if state_manager.get_item('face_selector_race'):
+			faces = filter_faces_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_faces_by_age(faces, state_manager.get_item('face_selector_age_start'), state_manager.get_item('face_selector_age_end'))
+	return faces
+
+
+def sort_faces_by_order(faces : List[Face], order : FaceSelectorOrder) -> List[Face]:
+	if order == 'left-right':
+		return sorted(faces, key = get_bounding_box_left)
+	if order == 'right-left':
+		return sorted(faces, key = get_bounding_box_left, reverse = True)
+	if order == 'top-bottom':
+		return sorted(faces, key = get_bounding_box_top)
+	if order == 'bottom-top':
+		return sorted(faces, key = get_bounding_box_top, reverse = True)
+	if order == 'small-large':
+		return sorted(faces, key = get_bounding_box_area)
+	if order == 'large-small':
+		return sorted(faces, key = get_bounding_box_area, reverse = True)
+	if order == 'best-worst':
+		return sorted(faces, key = get_face_detector_score, reverse = True)
+	if order == 'worst-best':
+		return sorted(faces, key = get_face_detector_score)
+	return faces
+
+
+def get_bounding_box_left(face : Face) -> float:
+	return face.bounding_box[0]
+
+
+def get_bounding_box_top(face : Face) -> float:
+	return face.bounding_box[1]
+
+
+def get_bounding_box_area(face : Face) -> float:
+	return (face.bounding_box[2] - face.bounding_box[0]) * (face.bounding_box[3] - face.bounding_box[1])
+
+
+def get_face_detector_score(face : Face) -> Score:
+	return face.score_set.get('detector')
+
+
+def filter_faces_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_faces_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_faces_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,43 @@
+from typing import List, Optional
+
+from facefusion.hash_helper import create_hash
+from facefusion.types 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]]:
+	vision_hash = create_hash(vision_frame.tobytes())
+	return FACE_STORE.get('static_faces').get(vision_hash)
+
+
+def set_static_faces(vision_frame : VisionFrame, faces : List[Face]) -> None:
+	vision_hash = create_hash(vision_frame.tobytes())
+	if vision_hash:
+		FACE_STORE['static_faces'][vision_hash] = faces
+
+
+def clear_static_faces() -> None:
+	FACE_STORE['static_faces'].clear()
+
+
+def get_reference_faces() -> Optional[FaceSet]:
+	return FACE_STORE.get('reference_faces')
+
+
+def append_reference_face(name : str, face : Face) -> None:
+	if name not in FACE_STORE.get('reference_faces'):
+		FACE_STORE['reference_faces'][name] = []
+	FACE_STORE['reference_faces'][name].append(face)
+
+
+def clear_reference_faces() -> None:
+	FACE_STORE['reference_faces'].clear()

facefusion/ffmpeg.py

@@ -0,0 +1,286 @@
+import os
+import subprocess
+import tempfile
+from functools import partial
+from typing import List, Optional, cast
+
+from tqdm import tqdm
+
+import facefusion.choices
+from facefusion import ffmpeg_builder, logger, process_manager, state_manager, wording
+from facefusion.filesystem import get_file_format, remove_file
+from facefusion.temp_helper import get_temp_file_path, get_temp_frames_pattern
+from facefusion.types import AudioBuffer, AudioEncoder, Commands, EncoderSet, Fps, UpdateProgress, VideoEncoder, VideoFormat
+from facefusion.vision import detect_video_duration, detect_video_fps, predict_video_frame_total
+
+
+def run_ffmpeg_with_progress(commands : Commands, update_progress : UpdateProgress) -> subprocess.Popen[bytes]:
+	log_level = state_manager.get_item('log_level')
+	commands.extend(ffmpeg_builder.set_progress())
+	commands.extend(ffmpeg_builder.cast_stream())
+	commands = ffmpeg_builder.run(commands)
+	process = subprocess.Popen(commands, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
+
+	while process_manager.is_processing():
+		try:
+
+			while __line__ := process.stdout.readline().decode().lower():
+				if 'frame=' in __line__:
+					_, frame_number = __line__.split('frame=')
+					update_progress(int(frame_number))
+
+			if 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 update_progress(progress : tqdm, frame_number : int) -> None:
+	progress.update(frame_number - progress.n)
+
+
+def run_ffmpeg(commands : Commands) -> subprocess.Popen[bytes]:
+	log_level = state_manager.get_item('log_level')
+	commands = ffmpeg_builder.run(commands)
+	process = subprocess.Popen(commands, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
+
+	while process_manager.is_processing():
+		try:
+			if 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(commands : Commands) -> subprocess.Popen[bytes]:
+	commands = ffmpeg_builder.run(commands)
+	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 get_available_encoder_set() -> EncoderSet:
+	available_encoder_set : EncoderSet =\
+	{
+		'audio': [],
+		'video': []
+	}
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.get_encoders()
+	)
+	process = run_ffmpeg(commands)
+
+	while line := process.stdout.readline().decode().lower():
+		if line.startswith(' a'):
+			audio_encoder = line.split()[1]
+
+			if audio_encoder in facefusion.choices.output_audio_encoders:
+				index = facefusion.choices.output_audio_encoders.index(audio_encoder) #type:ignore[arg-type]
+				available_encoder_set['audio'].insert(index, audio_encoder) #type:ignore[arg-type]
+		if line.startswith(' v'):
+			video_encoder = line.split()[1]
+
+			if video_encoder in facefusion.choices.output_video_encoders:
+				index = facefusion.choices.output_video_encoders.index(video_encoder) #type:ignore[arg-type]
+				available_encoder_set['video'].insert(index, video_encoder) #type:ignore[arg-type]
+
+	return available_encoder_set
+
+
+def extract_frames(target_path : str, temp_video_resolution : str, temp_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
+	extract_frame_total = predict_video_frame_total(target_path, temp_video_fps, trim_frame_start, trim_frame_end)
+	temp_frames_pattern = get_temp_frames_pattern(target_path, '%08d')
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input(target_path),
+		ffmpeg_builder.set_media_resolution(temp_video_resolution),
+		ffmpeg_builder.set_frame_quality(0),
+		ffmpeg_builder.select_frame_range(trim_frame_start, trim_frame_end, temp_video_fps),
+		ffmpeg_builder.prevent_frame_drop(),
+		ffmpeg_builder.set_output(temp_frames_pattern)
+	)
+
+	with tqdm(total = extract_frame_total, desc = wording.get('extracting'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
+		process = run_ffmpeg_with_progress(commands, partial(update_progress, progress))
+		return process.returncode == 0
+
+
+def copy_image(target_path : str, temp_image_resolution : str) -> bool:
+	temp_image_path = get_temp_file_path(target_path)
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input(target_path),
+		ffmpeg_builder.set_media_resolution(temp_image_resolution),
+		ffmpeg_builder.set_image_quality(target_path, 100),
+		ffmpeg_builder.force_output(temp_image_path)
+	)
+	return run_ffmpeg(commands).returncode == 0
+
+
+def finalize_image(target_path : str, output_path : str, output_image_resolution : str) -> bool:
+	output_image_quality = state_manager.get_item('output_image_quality')
+	temp_image_path = get_temp_file_path(target_path)
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input(temp_image_path),
+		ffmpeg_builder.set_media_resolution(output_image_resolution),
+		ffmpeg_builder.set_image_quality(target_path, output_image_quality),
+		ffmpeg_builder.force_output(output_path)
+	)
+	return run_ffmpeg(commands).returncode == 0
+
+
+def read_audio_buffer(target_path : str, audio_sample_rate : int, audio_sample_size : int, audio_channel_total : int) -> Optional[AudioBuffer]:
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input(target_path),
+		ffmpeg_builder.ignore_video_stream(),
+		ffmpeg_builder.set_audio_sample_rate(audio_sample_rate),
+		ffmpeg_builder.set_audio_sample_size(audio_sample_size),
+		ffmpeg_builder.set_audio_channel_total(audio_channel_total),
+		ffmpeg_builder.cast_stream()
+	)
+
+	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, trim_frame_start : int, trim_frame_end : int) -> bool:
+	output_audio_encoder = state_manager.get_item('output_audio_encoder')
+	output_audio_quality = state_manager.get_item('output_audio_quality')
+	output_audio_volume = state_manager.get_item('output_audio_volume')
+	target_video_fps = detect_video_fps(target_path)
+	temp_video_path = get_temp_file_path(target_path)
+	temp_video_format = cast(VideoFormat, get_file_format(temp_video_path))
+	temp_video_duration = detect_video_duration(temp_video_path)
+
+	output_audio_encoder = fix_audio_encoder(temp_video_format, output_audio_encoder)
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input(temp_video_path),
+		ffmpeg_builder.select_media_range(trim_frame_start, trim_frame_end, target_video_fps),
+		ffmpeg_builder.set_input(target_path),
+		ffmpeg_builder.copy_video_encoder(),
+		ffmpeg_builder.set_audio_encoder(output_audio_encoder),
+		ffmpeg_builder.set_audio_quality(output_audio_encoder, output_audio_quality),
+		ffmpeg_builder.set_audio_volume(output_audio_volume),
+		ffmpeg_builder.select_media_stream('0:v:0'),
+		ffmpeg_builder.select_media_stream('1:a:0'),
+		ffmpeg_builder.set_video_duration(temp_video_duration),
+		ffmpeg_builder.force_output(output_path)
+	)
+	return run_ffmpeg(commands).returncode == 0
+
+
+def replace_audio(target_path : str, audio_path : str, output_path : str) -> bool:
+	output_audio_encoder = state_manager.get_item('output_audio_encoder')
+	output_audio_quality = state_manager.get_item('output_audio_quality')
+	output_audio_volume = state_manager.get_item('output_audio_volume')
+	temp_video_path = get_temp_file_path(target_path)
+	temp_video_format = cast(VideoFormat, get_file_format(temp_video_path))
+	temp_video_duration = detect_video_duration(temp_video_path)
+
+	output_audio_encoder = fix_audio_encoder(temp_video_format, output_audio_encoder)
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input(temp_video_path),
+		ffmpeg_builder.set_input(audio_path),
+		ffmpeg_builder.copy_video_encoder(),
+		ffmpeg_builder.set_audio_encoder(output_audio_encoder),
+		ffmpeg_builder.set_audio_quality(output_audio_encoder, output_audio_quality),
+		ffmpeg_builder.set_audio_volume(output_audio_volume),
+		ffmpeg_builder.set_video_duration(temp_video_duration),
+		ffmpeg_builder.force_output(output_path)
+	)
+	return run_ffmpeg(commands).returncode == 0
+
+
+def merge_video(target_path : str, temp_video_fps : Fps, output_video_resolution : str, output_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
+	output_video_encoder = state_manager.get_item('output_video_encoder')
+	output_video_quality = state_manager.get_item('output_video_quality')
+	output_video_preset = state_manager.get_item('output_video_preset')
+	merge_frame_total = predict_video_frame_total(target_path, output_video_fps, trim_frame_start, trim_frame_end)
+	temp_video_path = get_temp_file_path(target_path)
+	temp_video_format = cast(VideoFormat, get_file_format(temp_video_path))
+	temp_frames_pattern = get_temp_frames_pattern(target_path, '%08d')
+
+	output_video_encoder = fix_video_encoder(temp_video_format, output_video_encoder)
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input_fps(temp_video_fps),
+		ffmpeg_builder.set_input(temp_frames_pattern),
+		ffmpeg_builder.set_media_resolution(output_video_resolution),
+		ffmpeg_builder.set_video_encoder(output_video_encoder),
+		ffmpeg_builder.set_video_quality(output_video_encoder, output_video_quality),
+		ffmpeg_builder.set_video_preset(output_video_encoder, output_video_preset),
+		ffmpeg_builder.set_video_fps(output_video_fps),
+		ffmpeg_builder.set_pixel_format(output_video_encoder),
+		ffmpeg_builder.set_video_colorspace('bt709'),
+		ffmpeg_builder.force_output(temp_video_path)
+	)
+
+	with tqdm(total = merge_frame_total, desc = wording.get('merging'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
+		process = run_ffmpeg_with_progress(commands, partial(update_progress, progress))
+		return process.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()
+
+	output_path = os.path.abspath(output_path)
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.unsafe_concat(),
+		ffmpeg_builder.set_input(concat_video_file.name),
+		ffmpeg_builder.copy_video_encoder(),
+		ffmpeg_builder.copy_audio_encoder(),
+		ffmpeg_builder.force_output(output_path)
+	)
+	process = run_ffmpeg(commands)
+	process.communicate()
+	remove_file(concat_video_path)
+	return process.returncode == 0
+
+
+def fix_audio_encoder(video_format : VideoFormat, audio_encoder : AudioEncoder) -> AudioEncoder:
+	if video_format == 'avi' and audio_encoder == 'libopus':
+		return 'aac'
+	if video_format == 'm4v':
+		return 'aac'
+	if video_format == 'mov' and audio_encoder in [ 'flac', 'libopus' ]:
+		return 'aac'
+	if video_format == 'webm':
+		return 'libopus'
+	return audio_encoder
+
+
+def fix_video_encoder(video_format : VideoFormat, video_encoder : VideoEncoder) -> VideoEncoder:
+	if video_format == 'm4v':
+		return 'libx264'
+	if video_format in [ 'mkv', 'mp4' ] and video_encoder == 'rawvideo':
+		return 'libx264'
+	if video_format == 'mov' and video_encoder == 'libvpx-vp9':
+		return 'libx264'
+	if video_format == 'webm':
+		return 'libvpx-vp9'
+	return video_encoder

facefusion/ffmpeg_builder.py

@@ -0,0 +1,248 @@
+import itertools
+import shutil
+from typing import Optional
+
+import numpy
+
+from facefusion.filesystem import get_file_format
+from facefusion.types import AudioEncoder, Commands, Duration, Fps, StreamMode, VideoEncoder, VideoPreset
+
+
+def run(commands : Commands) -> Commands:
+	return [ shutil.which('ffmpeg'), '-loglevel', 'error' ] + commands
+
+
+def chain(*commands : Commands) -> Commands:
+	return list(itertools.chain(*commands))
+
+
+def get_encoders() -> Commands:
+	return [ '-encoders' ]
+
+
+def set_hardware_accelerator(value : str) -> Commands:
+	return [ '-hwaccel', value ]
+
+
+def set_progress() -> Commands:
+	return [ '-progress' ]
+
+
+def set_input(input_path : str) -> Commands:
+	return [ '-i', input_path ]
+
+
+def set_input_fps(input_fps : Fps) -> Commands:
+	return [ '-r', str(input_fps)]
+
+
+def set_output(output_path : str) -> Commands:
+	return [ output_path ]
+
+
+def force_output(output_path : str) -> Commands:
+	return [ '-y', output_path ]
+
+
+def cast_stream() -> Commands:
+	return [ '-' ]
+
+
+def set_stream_mode(stream_mode : StreamMode) -> Commands:
+	if stream_mode == 'udp':
+		return [ '-f', 'mpegts' ]
+	if stream_mode == 'v4l2':
+		return [ '-f', 'v4l2' ]
+	return []
+
+
+def set_stream_quality(stream_quality : int) -> Commands:
+	return [ '-b:v', str(stream_quality) + 'k' ]
+
+
+def unsafe_concat() -> Commands:
+	return [ '-f', 'concat', '-safe', '0' ]
+
+
+def set_pixel_format(video_encoder : VideoEncoder) -> Commands:
+	if video_encoder == 'rawvideo':
+		return [ '-pix_fmt', 'rgb24' ]
+	return [ '-pix_fmt', 'yuv420p' ]
+
+
+def set_frame_quality(frame_quality : int) -> Commands:
+	return [ '-q:v', str(frame_quality) ]
+
+
+def select_frame_range(frame_start : int, frame_end : int, video_fps : Fps) -> Commands:
+	if isinstance(frame_start, int) and isinstance(frame_end, int):
+		return [ '-vf', 'trim=start_frame=' + str(frame_start) + ':end_frame=' + str(frame_end) + ',fps=' + str(video_fps) ]
+	if isinstance(frame_start, int):
+		return [ '-vf', 'trim=start_frame=' + str(frame_start) + ',fps=' + str(video_fps) ]
+	if isinstance(frame_end, int):
+		return [ '-vf', 'trim=end_frame=' + str(frame_end) + ',fps=' + str(video_fps) ]
+	return [ '-vf', 'fps=' + str(video_fps) ]
+
+
+def prevent_frame_drop() -> Commands:
+	return [ '-vsync', '0' ]
+
+
+def select_media_range(frame_start : int, frame_end : int, media_fps : Fps) -> Commands:
+	commands = []
+
+	if isinstance(frame_start, int):
+		commands.extend([ '-ss', str(frame_start / media_fps) ])
+	if isinstance(frame_end, int):
+		commands.extend([ '-to', str(frame_end / media_fps) ])
+	return commands
+
+
+def select_media_stream(media_stream : str) -> Commands:
+	return [ '-map', media_stream ]
+
+
+def set_media_resolution(video_resolution : str) -> Commands:
+	return [ '-s', video_resolution ]
+
+
+def set_image_quality(image_path : str, image_quality : int) -> Commands:
+	if get_file_format(image_path) == 'webp':
+		image_compression = image_quality
+	else:
+		image_compression = round(31 - (image_quality * 0.31))
+	return [ '-q:v', str(image_compression) ]
+
+
+def set_audio_encoder(audio_codec : str) -> Commands:
+	return [ '-c:a', audio_codec ]
+
+
+def copy_audio_encoder() -> Commands:
+	return set_audio_encoder('copy')
+
+
+def set_audio_sample_rate(audio_sample_rate : int) -> Commands:
+	return [ '-ar', str(audio_sample_rate) ]
+
+
+def set_audio_sample_size(audio_sample_size : int) -> Commands:
+	if audio_sample_size == 16:
+		return [ '-f', 's16le' ]
+	if audio_sample_size == 32:
+		return [ '-f', 's32le' ]
+	return []
+
+
+def set_audio_channel_total(audio_channel_total : int) -> Commands:
+	return [ '-ac', str(audio_channel_total) ]
+
+
+def set_audio_quality(audio_encoder : AudioEncoder, audio_quality : int) -> Commands:
+	if audio_encoder == 'aac':
+		audio_compression = round(numpy.interp(audio_quality, [ 0, 100 ], [ 0.1, 2.0 ]), 1)
+		return [ '-q:a', str(audio_compression) ]
+	if audio_encoder == 'libmp3lame':
+		audio_compression = round(numpy.interp(audio_quality, [ 0, 100 ], [ 9, 0 ]))
+		return [ '-q:a', str(audio_compression) ]
+	if audio_encoder == 'libopus':
+		audio_bit_rate = round(numpy.interp(audio_quality, [ 0, 100 ], [ 64, 256 ]))
+		return [ '-b:a', str(audio_bit_rate) + 'k' ]
+	if audio_encoder == 'libvorbis':
+		audio_compression = round(numpy.interp(audio_quality, [ 0, 100 ], [ -1, 10 ]), 1)
+		return [ '-q:a', str(audio_compression) ]
+	return []
+
+
+def set_audio_volume(audio_volume : int) -> Commands:
+	return [ '-filter:a', 'volume=' + str(audio_volume / 100) ]
+
+
+def set_video_encoder(video_encoder : str) -> Commands:
+	return [ '-c:v', video_encoder ]
+
+
+def copy_video_encoder() -> Commands:
+	return set_video_encoder('copy')
+
+
+def set_video_quality(video_encoder : VideoEncoder, video_quality : int) -> Commands:
+	if video_encoder in [ 'libx264', 'libx265' ]:
+		video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
+		return [ '-crf', str(video_compression) ]
+	if video_encoder == 'libvpx-vp9':
+		video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 63, 0 ]))
+		return [ '-crf', str(video_compression) ]
+	if video_encoder in [ 'h264_nvenc', 'hevc_nvenc' ]:
+		video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
+		return [ '-cq', str(video_compression) ]
+	if video_encoder in [ 'h264_amf', 'hevc_amf' ]:
+		video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
+		return [ '-qp_i', str(video_compression), '-qp_p', str(video_compression), '-qp_b', str(video_compression) ]
+	if video_encoder in [ 'h264_qsv', 'hevc_qsv' ]:
+		video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
+		return [ '-qp', str(video_compression) ]
+	if video_encoder in [ 'h264_videotoolbox', 'hevc_videotoolbox' ]:
+		video_bit_rate = round(numpy.interp(video_quality, [ 0, 100 ], [ 1024, 50512 ]))
+		return [ '-b:v', str(video_bit_rate) + 'k' ]
+	return []
+
+
+def set_video_preset(video_encoder : VideoEncoder, video_preset : VideoPreset) -> Commands:
+	if video_encoder in [ 'libx264', 'libx265' ]:
+		return [ '-preset', video_preset ]
+	if video_encoder in [ 'h264_nvenc', 'hevc_nvenc' ]:
+		return [ '-preset', map_nvenc_preset(video_preset) ]
+	if video_encoder in [ 'h264_amf', 'hevc_amf' ]:
+		return [ '-quality', map_amf_preset(video_preset) ]
+	if video_encoder in [ 'h264_qsv', 'hevc_qsv' ]:
+		return [ '-preset', map_qsv_preset(video_preset) ]
+	return []
+
+
+def set_video_colorspace(video_colorspace : str) -> Commands:
+	return [ '-colorspace', video_colorspace ]
+
+
+def set_video_fps(video_fps : Fps) -> Commands:
+	return [ '-vf', 'framerate=fps=' + str(video_fps) ]
+
+
+def set_video_duration(video_duration : Duration) -> Commands:
+	return [ '-t', str(video_duration) ]
+
+
+def capture_video() -> Commands:
+	return [ '-f', 'rawvideo', '-pix_fmt', 'rgb24' ]
+
+
+def ignore_video_stream() -> Commands:
+	return [ '-vn' ]
+
+
+def map_nvenc_preset(video_preset : VideoPreset) -> Optional[str]:
+	if video_preset in [ 'ultrafast', 'superfast', 'veryfast', 'faster', 'fast' ]:
+		return 'fast'
+	if video_preset == 'medium':
+		return 'medium'
+	if video_preset in [ 'slow', 'slower', 'veryslow' ]:
+		return 'slow'
+	return None
+
+
+def map_amf_preset(video_preset : VideoPreset) -> Optional[str]:
+	if video_preset in [ 'ultrafast', 'superfast', 'veryfast' ]:
+		return 'speed'
+	if video_preset in [ 'faster', 'fast', 'medium' ]:
+		return 'balanced'
+	if video_preset in [ 'slow', 'slower', 'veryslow' ]:
+		return 'quality'
+	return None
+
+
+def map_qsv_preset(video_preset : VideoPreset) -> Optional[str]:
+	if video_preset in [ 'ultrafast', 'superfast', 'veryfast' ]:
+		return 'veryfast'
+	if video_preset in [ 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow' ]:
+		return video_preset
+	return None

facefusion/filesystem.py

@@ -0,0 +1,188 @@
+import glob
+import os
+import shutil
+from typing import List, Optional
+
+import facefusion.choices
+
+
+def get_file_size(file_path : str) -> int:
+	if is_file(file_path):
+		return os.path.getsize(file_path)
+	return 0
+
+
+def get_file_name(file_path : str) -> Optional[str]:
+	file_name, _ = os.path.splitext(os.path.basename(file_path))
+
+	if file_name:
+		return file_name
+	return None
+
+
+def get_file_extension(file_path : str) -> Optional[str]:
+	_, file_extension = os.path.splitext(file_path)
+
+	if file_extension:
+		return file_extension.lower()
+	return None
+
+
+def get_file_format(file_path : str) -> Optional[str]:
+	file_extension = get_file_extension(file_path)
+
+	if file_extension:
+		if file_extension == '.jpg':
+			return 'jpeg'
+		if file_extension == '.tif':
+			return 'tiff'
+		return file_extension.lstrip('.')
+	return None
+
+
+def same_file_extension(first_file_path : str, second_file_path : str) -> bool:
+	first_file_extension = get_file_extension(first_file_path)
+	second_file_extension = get_file_extension(second_file_path)
+
+	if first_file_extension and second_file_extension:
+		return get_file_extension(first_file_path) == get_file_extension(second_file_path)
+	return False
+
+
+def is_file(file_path : str) -> bool:
+	if file_path:
+		return os.path.isfile(file_path)
+	return False
+
+
+def is_audio(audio_path : str) -> bool:
+	return is_file(audio_path) and get_file_format(audio_path) in facefusion.choices.audio_formats
+
+
+def has_audio(audio_paths : List[str]) -> bool:
+	if audio_paths:
+		return any(map(is_audio, audio_paths))
+	return False
+
+
+def are_audios(audio_paths : List[str]) -> bool:
+	if audio_paths:
+		return all(map(is_audio, audio_paths))
+	return False
+
+
+def is_image(image_path : str) -> bool:
+	return is_file(image_path) and get_file_format(image_path) in facefusion.choices.image_formats
+
+
+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 are_images(image_paths : List[str]) -> bool:
+	if image_paths:
+		return all(map(is_image, image_paths))
+	return False
+
+
+def is_video(video_path : str) -> bool:
+	return is_file(video_path) and get_file_format(video_path) in facefusion.choices.video_formats
+
+
+def has_video(video_paths : List[str]) -> bool:
+	if video_paths:
+		return any(map(is_video, video_paths))
+	return False
+
+
+def are_videos(video_paths : List[str]) -> bool:
+	if video_paths:
+		return any(map(is_video, video_paths))
+	return False
+
+
+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 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 resolve_file_paths(directory_path : str) -> List[str]:
+	file_paths : List[str] = []
+
+	if is_directory(directory_path):
+		file_names_and_extensions = sorted(os.listdir(directory_path))
+
+		for file_name_and_extension in file_names_and_extensions:
+			if not file_name_and_extension.startswith(('.', '__')):
+				file_path = os.path.join(directory_path, file_name_and_extension)
+				file_paths.append(file_path)
+
+	return file_paths
+
+
+def resolve_file_pattern(file_pattern : str) -> List[str]:
+	if in_directory(file_pattern):
+		return sorted(glob.glob(file_pattern))
+	return []
+
+
+def is_directory(directory_path : str) -> bool:
+	if directory_path:
+		return os.path.isdir(directory_path)
+	return False
+
+
+def in_directory(file_path : str) -> bool:
+	if file_path:
+		directory_path = os.path.dirname(file_path)
+		if directory_path:
+			return not is_directory(file_path) and is_directory(directory_path)
+	return False
+
+
+def create_directory(directory_path : str) -> bool:
+	if directory_path and not is_file(directory_path):
+		os.makedirs(directory_path, exist_ok = True)
+		return is_directory(directory_path)
+	return False
+
+
+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
+
+
+def resolve_relative_path(path : str) -> str:
+	return os.path.abspath(os.path.join(os.path.dirname(__file__), path))

facefusion/hash_helper.py

@@ -0,0 +1,32 @@
+import os
+import zlib
+from typing import Optional
+
+from facefusion.filesystem import get_file_name, 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) as hash_file:
+			hash_content = hash_file.read()
+
+		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, file_name_and_extension = os.path.split(validate_path)
+		validate_file_name = get_file_name(file_name_and_extension)
+
+		return os.path.join(validate_directory_path, validate_file_name + '.hash')
+	return None

facefusion/inference_manager.py

@@ -0,0 +1,74 @@
+import importlib
+from time import sleep
+from typing import List
+
+from onnxruntime import InferenceSession
+
+from facefusion import process_manager, state_manager
+from facefusion.app_context import detect_app_context
+from facefusion.execution import create_inference_session_providers
+from facefusion.filesystem import is_file
+from facefusion.types import DownloadSet, ExecutionProvider, InferencePool, InferencePoolSet
+
+INFERENCE_POOL_SET : InferencePoolSet =\
+{
+	'cli': {},
+	'ui': {}
+}
+
+
+def get_inference_pool(module_name : str, model_names : List[str], model_source_set : DownloadSet) -> InferencePool:
+	while process_manager.is_checking():
+		sleep(0.5)
+	execution_device_id = state_manager.get_item('execution_device_id')
+	execution_providers = resolve_execution_providers(module_name)
+	app_context = detect_app_context()
+	inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)
+
+	if app_context == 'cli' and INFERENCE_POOL_SET.get('ui').get(inference_context):
+		INFERENCE_POOL_SET['cli'][inference_context] = INFERENCE_POOL_SET.get('ui').get(inference_context)
+	if app_context == 'ui' and INFERENCE_POOL_SET.get('cli').get(inference_context):
+		INFERENCE_POOL_SET['ui'][inference_context] = INFERENCE_POOL_SET.get('cli').get(inference_context)
+	if not INFERENCE_POOL_SET.get(app_context).get(inference_context):
+		INFERENCE_POOL_SET[app_context][inference_context] = create_inference_pool(model_source_set, execution_device_id, execution_providers)
+
+	return INFERENCE_POOL_SET.get(app_context).get(inference_context)
+
+
+def create_inference_pool(model_source_set : DownloadSet, execution_device_id : str, execution_providers : List[ExecutionProvider]) -> InferencePool:
+	inference_pool : InferencePool = {}
+
+	for model_name in model_source_set.keys():
+		model_path = model_source_set.get(model_name).get('path')
+		if is_file(model_path):
+			inference_pool[model_name] = create_inference_session(model_path, execution_device_id, execution_providers)
+
+	return inference_pool
+
+
+def clear_inference_pool(module_name : str, model_names : List[str]) -> None:
+	execution_device_id = state_manager.get_item('execution_device_id')
+	execution_providers = resolve_execution_providers(module_name)
+	app_context = detect_app_context()
+	inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)
+
+	if INFERENCE_POOL_SET.get(app_context).get(inference_context):
+		del INFERENCE_POOL_SET[app_context][inference_context]
+
+
+def create_inference_session(model_path : str, execution_device_id : str, execution_providers : List[ExecutionProvider]) -> InferenceSession:
+	inference_session_providers = create_inference_session_providers(execution_device_id, execution_providers)
+	return InferenceSession(model_path, providers = inference_session_providers)
+
+
+def get_inference_context(module_name : str, model_names : List[str], execution_device_id : str, execution_providers : List[ExecutionProvider]) -> str:
+	inference_context = '.'.join([ module_name ] + model_names + [ execution_device_id ] + list(execution_providers))
+	return inference_context
+
+
+def resolve_execution_providers(module_name : str) -> List[ExecutionProvider]:
+	module = importlib.import_module(module_name)
+
+	if hasattr(module, 'resolve_execution_providers'):
+		return getattr(module, 'resolve_execution_providers')()
+	return state_manager.get_item('execution_providers')

facefusion/installer.py

@@ -0,0 +1,96 @@
+import os
+import shutil
+import signal
+import subprocess
+import sys
+from argparse import ArgumentParser, HelpFormatter
+from functools import partial
+from types import FrameType
+
+from facefusion import metadata, wording
+from facefusion.common_helper import is_linux, is_windows
+
+ONNXRUNTIME_SET =\
+{
+	'default': ('onnxruntime', '1.22.0')
+}
+if is_windows() or is_linux():
+	ONNXRUNTIME_SET['cuda'] = ('onnxruntime-gpu', '1.22.0')
+	ONNXRUNTIME_SET['openvino'] = ('onnxruntime-openvino', '1.22.0')
+if is_windows():
+	ONNXRUNTIME_SET['directml'] = ('onnxruntime-directml', '1.17.3')
+if is_linux():
+	ONNXRUNTIME_SET['rocm'] = ('onnxruntime-rocm', '1.21.0')
+
+
+def cli() -> None:
+	signal.signal(signal.SIGINT, signal_exit)
+	program = ArgumentParser(formatter_class = partial(HelpFormatter, max_help_position = 50))
+	program.add_argument('--onnxruntime', help = wording.get('help.install_dependency').format(dependency = 'onnxruntime'), choices = ONNXRUNTIME_SET.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 signal_exit(signum : int, frame : FrameType) -> None:
+	sys.exit(0)
+
+
+def run(program : ArgumentParser) -> None:
+	args = program.parse_args()
+	has_conda = 'CONDA_PREFIX' in os.environ
+	onnxruntime_name, onnxruntime_version = ONNXRUNTIME_SET.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)
+
+	with open('requirements.txt') as file:
+
+		for line in file.readlines():
+			__line__ = line.strip()
+			if not __line__.startswith('onnxruntime'):
+				subprocess.call([ shutil.which('pip'), 'install', line, '--force-reinstall' ])
+
+	if args.onnxruntime == 'rocm':
+		python_id = 'cp' + str(sys.version_info.major) + str(sys.version_info.minor)
+
+		if python_id in [ 'cp310', 'cp312' ]:
+			wheel_name = 'onnxruntime_rocm-' + onnxruntime_version + '-' + python_id + '-' + python_id + '-linux_x86_64.whl'
+			wheel_url = 'https://repo.radeon.com/rocm/manylinux/rocm-rel-6.4/' + wheel_name
+			subprocess.call([ shutil.which('pip'), 'install', wheel_url, '--force-reinstall' ])
+	else:
+		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 = list(dict.fromkeys([ 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 = list(dict.fromkeys([ 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 args.onnxruntime == 'directml':
+		subprocess.call([ shutil.which('pip'), 'install', 'numpy==1.26.4', '--force-reinstall' ])

facefusion/jobs/job_helper.py

@@ -0,0 +1,18 @@
+import os
+from datetime import datetime
+from typing import Optional
+
+from facefusion.filesystem import get_file_extension, get_file_name
+
+
+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 = get_file_name(_)
+		output_file_extension = get_file_extension(_)
+		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.types 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,265 @@
+import os
+from copy import copy
+from typing import List, Optional
+
+import facefusion.choices
+from facefusion.date_helper import get_current_date_time
+from facefusion.filesystem import create_directory, get_file_name, is_directory, is_file, move_file, remove_directory, remove_file, resolve_file_pattern
+from facefusion.jobs.job_helper import get_step_output_path
+from facefusion.json import read_json, write_json
+from facefusion.types 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 facefusion.choices.job_statuses ]
+
+	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(halt_on_error : bool) -> bool:
+	drafted_job_ids = find_job_ids('drafted')
+	has_error = False
+
+	if drafted_job_ids:
+		for job_id in drafted_job_ids:
+			if not submit_job(job_id):
+				has_error = True
+				if halt_on_error:
+					return False
+		return not has_error
+	return False
+
+
+def delete_job(job_id : str) -> bool:
+	return delete_job_file(job_id)
+
+
+def delete_jobs(halt_on_error : bool) -> bool:
+	job_ids = find_job_ids('drafted') + find_job_ids('queued') + find_job_ids('failed') + find_job_ids('completed')
+	has_error = False
+
+	if job_ids:
+		for job_id in job_ids:
+			if not delete_job(job_id):
+				has_error = True
+				if halt_on_error:
+					return False
+		return not has_error
+	return False
+
+
+def find_jobs(job_status : JobStatus) -> JobSet:
+	job_ids = find_job_ids(job_status)
+	job_set : JobSet = {}
+
+	for job_id in job_ids:
+		job_set[job_id] = read_job_file(job_id)
+	return job_set
+
+
+def find_job_ids(job_status : JobStatus) -> List[str]:
+	job_pattern = os.path.join(JOBS_PATH, job_status, '*.json')
+	job_paths = resolve_file_pattern(job_pattern)
+	job_paths.sort(key = os.path.getmtime)
+	job_ids = []
+
+	for job_path in job_paths:
+		job_id = get_file_name(job_path)
+		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 facefusion.choices.job_statuses:
+			job_pattern = os.path.join(JOBS_PATH, job_status, job_file_name)
+			job_paths = resolve_file_pattern(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,112 @@
+from facefusion.ffmpeg import concat_video
+from facefusion.filesystem import are_images, are_videos, move_file, remove_file
+from facefusion.jobs import job_helper, job_manager
+from facefusion.types 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, halt_on_error : bool) -> bool:
+	queued_job_ids = job_manager.find_job_ids('queued')
+	has_error = False
+
+	if queued_job_ids:
+		for job_id in queued_job_ids:
+			if not run_job(job_id, process_step):
+				has_error = True
+				if halt_on_error:
+					return False
+		return not has_error
+	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, halt_on_error : bool) -> bool:
+	failed_job_ids = job_manager.find_job_ids('failed')
+	has_error = False
+
+	if failed_job_ids:
+		for job_id in failed_job_ids:
+			if not retry_job(job_id, process_step):
+				has_error = True
+				if halt_on_error:
+					return False
+		return not has_error
+	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 are_videos(temp_output_paths):
+			if not concat_video(output_path, temp_output_paths):
+				return False
+		if are_images(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)
+	job_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)
+			job_output_set.setdefault(output_path, []).append(step_output_path)
+	return job_output_set

facefusion/jobs/job_store.py

@@ -0,0 +1,27 @@
+from typing import List
+
+from facefusion.types 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.types import Content
+
+
+def read_json(json_path : str) -> Optional[Content]:
+	if is_file(json_path):
+		try:
+			with open(json_path) 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,48 @@
+from logging import Logger, basicConfig, getLogger
+
+import facefusion.choices
+from facefusion.common_helper import get_first, get_last
+from facefusion.types import LogLevel
+
+
+def init(log_level : LogLevel) -> None:
+	basicConfig(format = '%(message)s')
+	get_package_logger().setLevel(facefusion.choices.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:
+	module_names = module_name.split('.')
+	first_module_name = get_first(module_names)
+	last_module_name = get_last(module_names)
+
+	if first_module_name and last_module_name:
+		return '[' + first_module_name.upper() + '.' + last_module_name.upper() + '] ' + message
+	return message
+
+
+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.3.2',
+	'license': 'OpenRAIL-AS',
+	'author': 'Henry Ruhs',
+	'url': 'https://facefusion.io'
+}
+
+
+def get(key : str) -> Optional[str]:
+	if key in METADATA:
+		return METADATA.get(key)
+	return None

facefusion/model_helper.py

@@ -0,0 +1,11 @@
+from functools import lru_cache
+
+import onnx
+
+from facefusion.types import ModelInitializer
+
+
+@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])

facefusion/normalizer.py

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