Upload 168 files

.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 = E3, E4, F, I1, I2
+per-file-ignores = facefusion.py:E402, install.py:E402
+plugins = flake8-import-order
+application_import_names = facefusion
+import-order-style = pycharm

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.github/preview.png filter=lfs diff=lfs merge=lfs -text

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: [ buymeacoffee.com/facefusion, ko-fi.com/facefusion ]

.github/workflows/ci.yml

@@ -0,0 +1,58 @@
+name: ci
+
+on: [ push, pull_request ]
+
+jobs:
+ lint:
+  runs-on: ubuntu-latest
+  steps:
+  - name: Checkout
+    uses: actions/checkout@v4
+  - name: Set up Python 3.12
+    uses: actions/setup-python@v5
+    with:
+     python-version: '3.12'
+  - run: pip install flake8
+  - run: pip install flake8-import-order
+  - run: pip install mypy
+  - run: flake8 facefusion.py install.py
+  - run: flake8 facefusion tests
+  - run: mypy facefusion.py install.py
+  - run: mypy facefusion tests
+ test:
+  strategy:
+   matrix:
+    os: [ macos-latest, ubuntu-latest, windows-latest ]
+  runs-on: ${{ matrix.os }}
+  steps:
+  - name: Checkout
+    uses: actions/checkout@v4
+  - name: Set up FFmpeg
+    uses: AnimMouse/setup-ffmpeg@v1
+  - name: Set up Python 3.12
+    uses: actions/setup-python@v5
+    with:
+     python-version: '3.12'
+  - run: python install.py --onnxruntime default --skip-conda
+  - run: pip install pytest
+  - run: pytest
+ report:
+  needs: test
+  runs-on: ubuntu-latest
+  steps:
+  - name: Checkout
+    uses: actions/checkout@v4
+  - name: Set up FFmpeg
+    uses: FedericoCarboni/setup-ffmpeg@v3
+  - name: Set up Python 3.12
+    uses: actions/setup-python@v5
+    with:
+     python-version: '3.12'
+  - run: python install.py --onnxruntime default --skip-conda
+  - run: pip install coveralls
+  - run: pip install pytest
+  - run: pip install pytest-cov
+  - run: pytest tests --cov facefusion
+  - run: coveralls --service github
+    env:
+     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -0,0 +1,6 @@
+__pycache__
+.assets
+.caches
+.jobs
+.idea
+.vscode

LICENSE.md

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

README.md

@@ -1,12 +1,60 @@
----
-title: Fusionface
-emoji: 📈
-colorFrom: pink
-colorTo: red
-sdk: streamlit
-sdk_version: 1.42.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+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-MIT-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
+    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,115 @@
+[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_blur =
+face_mask_padding =
+face_mask_regions =
+
+[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_video_encoder =
+output_video_preset =
+output_video_quality =
+output_video_resolution =
+output_video_fps =
+skip_audio =
+
+[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 =
+
+[uis]
+open_browser =
+ui_layouts =
+ui_workflow =
+
+[execution]
+execution_device_id =
+execution_providers =
+execution_thread_count =
+execution_queue_count =
+
+[download]
+download_providers =
+download_scope =
+
+[memory]
+video_memory_strategy =
+system_memory_limit =
+
+[misc]
+log_level =

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.typing import AppContext
+
+
+def detect_app_context() -> AppContext:
+	frame = sys._getframe(1)
+
+	while frame:
+		if os.path.join('facefusion', 'jobs') in frame.f_code.co_filename:
+			return 'cli'
+		if os.path.join('facefusion', 'uis') in frame.f_code.co_filename:
+			return 'ui'
+		frame = frame.f_back
+	return 'cli'

facefusion/args.py

@@ -0,0 +1,134 @@
+from facefusion import state_manager
+from facefusion.filesystem import is_image, is_video, list_directory
+from facefusion.jobs import job_store
+from facefusion.normalizer import normalize_fps, normalize_padding
+from facefusion.processors.core import get_processors_modules
+from facefusion.typing import ApplyStateItem, Args
+from facefusion.vision import create_image_resolutions, create_video_resolutions, detect_image_resolution, detect_video_fps, detect_video_resolution, pack_resolution
+
+
+def reduce_step_args(args : Args) -> Args:
+	step_args =\
+	{
+		key: args[key] for key in args if key in job_store.get_step_keys()
+	}
+	return step_args
+
+
+def 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_blur', args.get('face_mask_blur'))
+	apply_state_item('face_mask_padding', normalize_padding(args.get('face_mask_padding')))
+	apply_state_item('face_mask_regions', args.get('face_mask_regions'))
+	# frame extraction
+	apply_state_item('trim_frame_start', args.get('trim_frame_start'))
+	apply_state_item('trim_frame_end', args.get('trim_frame_end'))
+	apply_state_item('temp_frame_format', args.get('temp_frame_format'))
+	apply_state_item('keep_temp', args.get('keep_temp'))
+	# output creation
+	apply_state_item('output_image_quality', args.get('output_image_quality'))
+	if is_image(args.get('target_path')):
+		output_image_resolution = detect_image_resolution(args.get('target_path'))
+		output_image_resolutions = create_image_resolutions(output_image_resolution)
+		if args.get('output_image_resolution') in output_image_resolutions:
+			apply_state_item('output_image_resolution', args.get('output_image_resolution'))
+		else:
+			apply_state_item('output_image_resolution', pack_resolution(output_image_resolution))
+	apply_state_item('output_audio_encoder', args.get('output_audio_encoder'))
+	apply_state_item('output_video_encoder', args.get('output_video_encoder'))
+	apply_state_item('output_video_preset', args.get('output_video_preset'))
+	apply_state_item('output_video_quality', args.get('output_video_quality'))
+	if is_video(args.get('target_path')):
+		output_video_resolution = detect_video_resolution(args.get('target_path'))
+		output_video_resolutions = create_video_resolutions(output_video_resolution)
+		if args.get('output_video_resolution') in output_video_resolutions:
+			apply_state_item('output_video_resolution', args.get('output_video_resolution'))
+		else:
+			apply_state_item('output_video_resolution', pack_resolution(output_video_resolution))
+	if args.get('output_video_fps') or is_video(args.get('target_path')):
+		output_video_fps = normalize_fps(args.get('output_video_fps')) or detect_video_fps(args.get('target_path'))
+		apply_state_item('output_video_fps', output_video_fps)
+	apply_state_item('skip_audio', args.get('skip_audio'))
+	# processors
+	available_processors = [ file.get('name') for file in list_directory('facefusion/processors/modules') ]
+	apply_state_item('processors', args.get('processors'))
+	for processor_module in get_processors_modules(available_processors):
+		processor_module.apply_args(args, apply_state_item)
+	# uis
+	apply_state_item('open_browser', args.get('open_browser'))
+	apply_state_item('ui_layouts', args.get('ui_layouts'))
+	apply_state_item('ui_workflow', args.get('ui_workflow'))
+	# execution
+	apply_state_item('execution_device_id', args.get('execution_device_id'))
+	apply_state_item('execution_providers', args.get('execution_providers'))
+	apply_state_item('execution_thread_count', args.get('execution_thread_count'))
+	apply_state_item('execution_queue_count', args.get('execution_queue_count'))
+	# download
+	apply_state_item('download_providers', args.get('download_providers'))
+	apply_state_item('download_scope', args.get('download_scope'))
+	# 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'))
+	# jobs
+	apply_state_item('job_id', args.get('job_id'))
+	apply_state_item('job_status', args.get('job_status'))
+	apply_state_item('step_index', args.get('step_index'))

facefusion/audio.py

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

facefusion/choices.py

@@ -0,0 +1,97 @@
+import logging
+from typing import List, Sequence
+
+from facefusion.common_helper import create_float_range, create_int_range
+from facefusion.typing import Angle, DownloadProvider, DownloadProviderSet, DownloadScope, ExecutionProvider, ExecutionProviderSet, FaceDetectorModel, FaceDetectorSet, FaceLandmarkerModel, FaceMaskRegion, FaceMaskRegionSet, FaceMaskType, FaceOccluderModel, FaceParserModel, FaceSelectorMode, FaceSelectorOrder, Gender, JobStatus, LogLevel, LogLevelSet, OutputAudioEncoder, OutputVideoEncoder, OutputVideoPreset, Race, Score, TempFrameFormat, UiWorkflow, VideoMemoryStrategy
+
+face_detector_set : FaceDetectorSet =\
+{
+	'many': [ '640x640' ],
+	'retinaface': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'scrfd': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'yoloface': [ '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' ]
+face_parser_models : List[FaceParserModel] = [ 'bisenet_resnet_18', 'bisenet_resnet_34' ]
+face_mask_types : List[FaceMaskType] = [ 'box', 'occlusion', 'region' ]
+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_regions : List[FaceMaskRegion] = list(face_mask_region_set.keys())
+temp_frame_formats : List[TempFrameFormat] = [ 'bmp', 'jpg', 'png' ]
+output_audio_encoders : List[OutputAudioEncoder] = [ 'aac', 'libmp3lame', 'libopus', 'libvorbis' ]
+output_video_encoders : List[OutputVideoEncoder] = [ 'libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf', 'h264_qsv', 'hevc_qsv', 'h264_videotoolbox', 'hevc_videotoolbox' ]
+output_video_presets : List[OutputVideoPreset] = [ 'ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow' ]
+
+image_template_sizes : List[float] = [ 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 3.5, 4 ]
+video_template_sizes : List[int] = [ 240, 360, 480, 540, 720, 1080, 1440, 2160, 4320 ]
+
+execution_provider_set : ExecutionProviderSet =\
+{
+	'cpu': 'CPUExecutionProvider',
+	'coreml': 'CoreMLExecutionProvider',
+	'cuda': 'CUDAExecutionProvider',
+	'directml': 'DmlExecutionProvider',
+	'openvino': 'OpenVINOExecutionProvider',
+	'rocm': 'ROCMExecutionProvider',
+	'tensorrt': 'TensorrtExecutionProvider'
+}
+execution_providers : List[ExecutionProvider] = list(execution_provider_set.keys())
+download_provider_set : DownloadProviderSet =\
+{
+	'github':
+	{
+		'url': 'https://github.com',
+		'path': '/facefusion/facefusion-assets/releases/download/{base_name}/{file_name}'
+	},
+	'huggingface':
+	{
+		'url': 'https://huggingface.co',
+		'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' ]
+
+execution_thread_count_range : Sequence[int] = create_int_range(1, 32, 1)
+execution_queue_count_range : Sequence[int] = create_int_range(1, 4, 1)
+system_memory_limit_range : Sequence[int] = create_int_range(0, 128, 4)
+face_detector_angles : Sequence[Angle] = create_int_range(0, 270, 90)
+face_detector_score_range : Sequence[Score] = create_float_range(0.0, 1.0, 0.05)
+face_landmarker_score_range : Sequence[Score] = create_float_range(0.0, 1.0, 0.05)
+face_mask_blur_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
+face_mask_padding_range : Sequence[int] = create_int_range(0, 100, 1)
+face_selector_age_range : Sequence[int] = create_int_range(0, 100, 1)
+reference_face_distance_range : Sequence[float] = create_float_range(0.0, 1.5, 0.05)
+output_image_quality_range : Sequence[int] = create_int_range(0, 100, 1)
+output_video_quality_range : Sequence[int] = create_int_range(0, 100, 1)

facefusion/common_helper.py

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

facefusion/config.py

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

facefusion/content_analyser.py

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

facefusion/core.py

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

facefusion/date_helper.py

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

facefusion/download.py

@@ -0,0 +1,163 @@
+import os
+import shutil
+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 logger, process_manager, state_manager, wording
+from facefusion.filesystem import get_file_size, is_file, remove_file
+from facefusion.hash_helper import validate_hash
+from facefusion.typing import DownloadProvider, DownloadSet
+
+
+def open_curl(args : List[str]) -> subprocess.Popen[bytes]:
+	commands = [ shutil.which('curl'), '--silent', '--insecure', '--location' ]
+	commands.extend(args)
+	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 = [ '--create-dirs', '--continue-at', '-', '--output', download_file_path, url ]
+				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 = [ '-I', url ]
+	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 = [ '-I', url ]
+	process = open_curl(commands)
+	process.communicate()
+	return process.returncode == 0
+
+
+def conditional_download_hashes(hashes : DownloadSet) -> bool:
+	hash_paths = [ hashes.get(hash_key).get('path') for hash_key in hashes.keys() ]
+
+	process_manager.check()
+	_, invalid_hash_paths = validate_hash_paths(hash_paths)
+	if invalid_hash_paths:
+		for index in hashes:
+			if hashes.get(index).get('path') in invalid_hash_paths:
+				invalid_hash_url = hashes.get(index).get('url')
+				if invalid_hash_url:
+					download_directory_path = os.path.dirname(hashes.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, _ = os.path.splitext(os.path.basename(valid_hash_path))
+		logger.debug(wording.get('validating_hash_succeed').format(hash_file_name = valid_hash_file_name), __name__)
+	for invalid_hash_path in invalid_hash_paths:
+		invalid_hash_file_name, _ = os.path.splitext(os.path.basename(invalid_hash_path))
+		logger.error(wording.get('validating_hash_failed').format(hash_file_name = invalid_hash_file_name), __name__)
+
+	if not invalid_hash_paths:
+		process_manager.end()
+	return not invalid_hash_paths
+
+
+def conditional_download_sources(sources : DownloadSet) -> bool:
+	source_paths = [ sources.get(source_key).get('path') for source_key in sources.keys() ]
+
+	process_manager.check()
+	_, invalid_source_paths = validate_source_paths(source_paths)
+	if invalid_source_paths:
+		for index in sources:
+			if sources.get(index).get('path') in invalid_source_paths:
+				invalid_source_url = sources.get(index).get('url')
+				if invalid_source_url:
+					download_directory_path = os.path.dirname(sources.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, _ = os.path.splitext(os.path.basename(valid_source_path))
+		logger.debug(wording.get('validating_source_succeed').format(source_file_name = valid_source_file_name), __name__)
+	for invalid_source_path in invalid_source_paths:
+		invalid_source_file_name, _ = os.path.splitext(os.path.basename(invalid_source_path))
+		logger.error(wording.get('validating_source_failed').format(source_file_name = invalid_source_file_name), __name__)
+
+		if remove_file(invalid_source_path):
+			logger.error(wording.get('deleting_corrupt_source').format(source_file_name = invalid_source_file_name), __name__)
+
+	if not invalid_source_paths:
+		process_manager.end()
+	return not invalid_source_paths
+
+
+def validate_hash_paths(hash_paths : List[str]) -> Tuple[List[str], List[str]]:
+	valid_hash_paths = []
+	invalid_hash_paths = []
+
+	for hash_path in hash_paths:
+		if is_file(hash_path):
+			valid_hash_paths.append(hash_path)
+		else:
+			invalid_hash_paths.append(hash_path)
+	return valid_hash_paths, invalid_hash_paths
+
+
+def validate_source_paths(source_paths : List[str]) -> Tuple[List[str], List[str]]:
+	valid_source_paths = []
+	invalid_source_paths = []
+
+	for source_path in source_paths:
+		if validate_hash(source_path):
+			valid_source_paths.append(source_path)
+		else:
+			invalid_source_paths.append(source_path)
+	return valid_source_paths, invalid_source_paths
+
+
+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:
+		if ping_download_provider(download_provider):
+			return resolve_download_url_by_provider(download_provider, base_name, file_name)
+	return None
+
+
+def ping_download_provider(download_provider : DownloadProvider) -> bool:
+	download_provider_value = facefusion.choices.download_provider_set.get(download_provider)
+	return ping_static_url(download_provider_value.get('url'))
+
+
+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)
+	return download_provider_value.get('url') + download_provider_value.get('path').format(base_name = base_name, file_name = file_name)

facefusion/execution.py

@@ -0,0 +1,139 @@
+import shutil
+import subprocess
+import xml.etree.ElementTree as ElementTree
+from functools import lru_cache
+from typing import Any, List, Optional
+
+from onnxruntime import get_available_providers, set_default_logger_severity
+
+import facefusion.choices
+from facefusion.typing import ExecutionDevice, ExecutionProvider, 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_execution_providers = get_available_providers()
+	available_execution_providers = []
+
+	for execution_provider, execution_provider_value in facefusion.choices.execution_provider_set.items():
+		if execution_provider_value in inference_execution_providers:
+			available_execution_providers.append(execution_provider)
+
+	return available_execution_providers
+
+
+def create_inference_execution_providers(execution_device_id : str, execution_providers : List[ExecutionProvider]) -> List[Any]:
+	inference_execution_providers : List[Any] = []
+
+	for execution_provider in execution_providers:
+		if execution_provider == 'cuda':
+			inference_execution_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'device_id': execution_device_id,
+				'cudnn_conv_algo_search': 'DEFAULT' if is_geforce_16_series() else 'EXHAUSTIVE'
+			}))
+		if execution_provider == 'tensorrt':
+			inference_execution_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 == 'openvino':
+			inference_execution_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'device_type': 'GPU' if execution_device_id == '0' else 'GPU.' + execution_device_id,
+				'precision': 'FP32'
+			}))
+		if execution_provider in [ 'directml', 'rocm' ]:
+			inference_execution_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
+			{
+				'device_id': execution_device_id
+			}))
+		if execution_provider == 'coreml':
+			inference_execution_providers.append(facefusion.choices.execution_provider_set.get(execution_provider))
+
+	if 'cpu' in execution_providers:
+		inference_execution_providers.append(facefusion.choices.execution_provider_set.get('cpu'))
+
+	return inference_execution_providers
+
+
+def is_geforce_16_series() -> bool:
+	execution_devices = detect_static_execution_devices()
+	product_names = ('GeForce GTX 1630', 'GeForce GTX 1650', 'GeForce GTX 1660')
+
+	return any(execution_device.get('product').get('name').startswith(product_names) for execution_device in execution_devices)
+
+
+def run_nvidia_smi() -> subprocess.Popen[bytes]:
+	commands = [ 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 facefusion import process_manager, state_manager
+from facefusion.temp_helper import clear_temp_directory
+from facefusion.typing import ErrorCode
+
+
+def hard_exit(error_code : ErrorCode) -> None:
+	signal.signal(signal.SIGINT, signal.SIG_IGN)
+	sys.exit(error_code)
+
+
+def conditional_exit(error_code : ErrorCode) -> None:
+	if state_manager.get_item('command') == 'headless-run':
+		hard_exit(error_code)
+
+
+def graceful_exit(error_code : ErrorCode) -> None:
+	process_manager.stop()
+	while process_manager.is_processing():
+		sleep(0.5)
+	if state_manager.get_item('target_path'):
+		clear_temp_directory(state_manager.get_item('target_path'))
+	hard_exit(error_code)

facefusion/face_analyser.py

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

facefusion/face_classifier.py

@@ -0,0 +1,131 @@
+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.typing 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_sources = get_model_options().get('sources')
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def get_model_options() -> ModelOptions:
+	return create_static_model_set('full').get('fairface')
+
+
+def pre_check() -> bool:
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(model_hashes) and conditional_download_sources(model_sources)
+
+
+def classify_face(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Gender, Age, Race]:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	model_mean = get_model_options().get('mean')
+	model_standard_deviation = get_model_options().get('standard_deviation')
+	crop_vision_frame, _ = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, model_size)
+	crop_vision_frame = crop_vision_frame.astype(numpy.float32)[:, :, ::-1] / 255
+	crop_vision_frame -= model_mean
+	crop_vision_frame /= model_standard_deviation
+	crop_vision_frame = crop_vision_frame.transpose(2, 0, 1)
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
+	gender_id, age_id, race_id = forward(crop_vision_frame)
+	gender = categorize_gender(gender_id[0])
+	age = categorize_age(age_id[0])
+	race = categorize_race(race_id[0])
+	return gender, age, race
+
+
+def forward(crop_vision_frame : VisionFrame) -> Tuple[List[int], List[int], List[int]]:
+	face_classifier = get_inference_pool().get('face_classifier')
+
+	with conditional_thread_semaphore():
+		race_id, gender_id, age_id = face_classifier.run(None,
+		{
+			'input': crop_vision_frame
+		})
+
+	return gender_id, age_id, race_id
+
+
+def categorize_gender(gender_id : int) -> Gender:
+	if gender_id == 1:
+		return 'female'
+	return 'male'
+
+
+def categorize_age(age_id : int) -> Age:
+	if age_id == 0:
+		return range(0, 2)
+	if age_id == 1:
+		return range(3, 9)
+	if age_id == 2:
+		return range(10, 19)
+	if age_id == 3:
+		return range(20, 29)
+	if age_id == 4:
+		return range(30, 39)
+	if age_id == 5:
+		return range(40, 49)
+	if age_id == 6:
+		return range(50, 59)
+	if age_id == 7:
+		return range(60, 69)
+	return range(70, 100)
+
+
+def categorize_race(race_id : int) -> Race:
+	if race_id == 1:
+		return 'black'
+	if race_id == 2:
+		return 'latino'
+	if race_id == 3 or race_id == 4:
+		return 'asian'
+	if race_id == 5:
+		return 'indian'
+	if race_id == 6:
+		return 'arabic'
+	return 'white'

facefusion/face_detector.py

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

facefusion/face_helper.py

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

facefusion/face_landmarker.py

@@ -0,0 +1,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.typing 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_sources = collect_model_downloads()
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_set = create_static_model_set('full')
+	model_hashes =\
+	{
+		'fan_68_5': model_set.get('fan_68_5').get('hashes').get('fan_68_5')
+	}
+	model_sources =\
+	{
+		'fan_68_5': model_set.get('fan_68_5').get('sources').get('fan_68_5')
+	}
+
+	if state_manager.get_item('face_landmarker_model') in [ 'many', '2dfan4' ]:
+		model_hashes['2dfan4'] = model_set.get('2dfan4').get('hashes').get('2dfan4')
+		model_sources['2dfan4'] = model_set.get('2dfan4').get('sources').get('2dfan4')
+
+	if state_manager.get_item('face_landmarker_model') in [ 'many', 'peppa_wutz' ]:
+		model_hashes['peppa_wutz'] = model_set.get('peppa_wutz').get('hashes').get('peppa_wutz')
+		model_sources['peppa_wutz'] = model_set.get('peppa_wutz').get('sources').get('peppa_wutz')
+
+	return model_hashes, model_sources
+
+
+def pre_check() -> bool:
+	model_hashes, model_sources = collect_model_downloads()
+
+	return conditional_download_hashes(model_hashes) and conditional_download_sources(model_sources)
+
+
+def detect_face_landmarks(vision_frame : VisionFrame, bounding_box : BoundingBox, face_angle : Angle) -> Tuple[FaceLandmark68, Score]:
+	face_landmark_2dfan4 = None
+	face_landmark_peppa_wutz = None
+	face_landmark_score_2dfan4 = 0.0
+	face_landmark_score_peppa_wutz = 0.0
+
+	if state_manager.get_item('face_landmarker_model') in [ 'many', '2dfan4' ]:
+		face_landmark_2dfan4, face_landmark_score_2dfan4 = detect_with_2dfan4(vision_frame, bounding_box, face_angle)
+
+	if state_manager.get_item('face_landmarker_model') in [ 'many', 'peppa_wutz' ]:
+		face_landmark_peppa_wutz, face_landmark_score_peppa_wutz = detect_with_peppa_wutz(vision_frame, bounding_box, face_angle)
+
+	if face_landmark_score_2dfan4 > face_landmark_score_peppa_wutz - 0.2:
+		return face_landmark_2dfan4, face_landmark_score_2dfan4
+	return face_landmark_peppa_wutz, face_landmark_score_peppa_wutz
+
+
+def detect_with_2dfan4(temp_vision_frame: VisionFrame, bounding_box: BoundingBox, face_angle: Angle) -> Tuple[FaceLandmark68, Score]:
+	model_size = 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,217 @@
+from functools import lru_cache
+from typing import List, Tuple
+
+import cv2
+import numpy
+from cv2.typing import Size
+
+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.typing import DownloadScope, DownloadSet, FaceLandmark68, 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)
+		},
+		'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_sources = collect_model_downloads()
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
+	model_hashes = {}
+	model_sources = {}
+	model_set = create_static_model_set('full')
+
+	if state_manager.get_item('face_occluder_model') == 'xseg_1':
+		model_hashes['xseg_1'] = model_set.get('xseg_1').get('hashes').get('face_occluder')
+		model_sources['xseg_1'] = model_set.get('xseg_1').get('sources').get('face_occluder')
+
+	if state_manager.get_item('face_occluder_model') == 'xseg_2':
+		model_hashes['xseg_2'] = model_set.get('xseg_2').get('hashes').get('face_occluder')
+		model_sources['xseg_2'] = model_set.get('xseg_2').get('sources').get('face_occluder')
+
+	if state_manager.get_item('face_parser_model') == 'bisenet_resnet_18':
+		model_hashes['bisenet_resnet_18'] = model_set.get('bisenet_resnet_18').get('hashes').get('face_parser')
+		model_sources['bisenet_resnet_18'] = model_set.get('bisenet_resnet_18').get('sources').get('face_parser')
+
+	if state_manager.get_item('face_parser_model') == 'bisenet_resnet_34':
+		model_hashes['bisenet_resnet_34'] = model_set.get('bisenet_resnet_34').get('hashes').get('face_parser')
+		model_sources['bisenet_resnet_34'] = model_set.get('bisenet_resnet_34').get('sources').get('face_parser')
+
+	return model_hashes, model_sources
+
+
+def pre_check() -> bool:
+	model_hashes, model_sources = collect_model_downloads()
+
+	return conditional_download_hashes(model_hashes) and conditional_download_sources(model_sources)
+
+
+@lru_cache(maxsize = None)
+def create_static_box_mask(crop_size : Size, face_mask_blur : float, face_mask_padding : Padding) -> Mask:
+	blur_amount = int(crop_size[0] * 0.5 * face_mask_blur)
+	blur_area = max(blur_amount // 2, 1)
+	box_mask : Mask = numpy.ones(crop_size).astype(numpy.float32)
+	box_mask[:max(blur_area, int(crop_size[1] * face_mask_padding[0] / 100)), :] = 0
+	box_mask[-max(blur_area, int(crop_size[1] * face_mask_padding[2] / 100)):, :] = 0
+	box_mask[:, :max(blur_area, int(crop_size[0] * face_mask_padding[3] / 100))] = 0
+	box_mask[:, -max(blur_area, int(crop_size[0] * face_mask_padding[1] / 100)):] = 0
+	if blur_amount > 0:
+		box_mask = cv2.GaussianBlur(box_mask, (0, 0), blur_amount * 0.25)
+	return box_mask
+
+
+def create_occlusion_mask(crop_vision_frame : VisionFrame) -> Mask:
+	face_occluder_model = state_manager.get_item('face_occluder_model')
+	model_size = create_static_model_set('full').get(face_occluder_model).get('size')
+	prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
+	prepare_vision_frame = numpy.expand_dims(prepare_vision_frame, axis = 0).astype(numpy.float32) / 255
+	prepare_vision_frame = prepare_vision_frame.transpose(0, 1, 2, 3)
+	occlusion_mask = forward_occlude_face(prepare_vision_frame)
+	occlusion_mask = occlusion_mask.transpose(0, 1, 2).clip(0, 1).astype(numpy.float32)
+	occlusion_mask = cv2.resize(occlusion_mask, crop_vision_frame.shape[:2][::-1])
+	occlusion_mask = (cv2.GaussianBlur(occlusion_mask.clip(0, 1), (0, 0), 5).clip(0.5, 1) - 0.5) * 2
+	return occlusion_mask
+
+
+def create_region_mask(crop_vision_frame : VisionFrame, face_mask_regions : List[FaceMaskRegion]) -> Mask:
+	face_parser_model = state_manager.get_item('face_parser_model')
+	model_size = create_static_model_set('full').get(face_parser_model).get('size')
+	prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
+	prepare_vision_frame = prepare_vision_frame[:, :, ::-1].astype(numpy.float32) / 255
+	prepare_vision_frame = numpy.subtract(prepare_vision_frame, numpy.array([ 0.485, 0.456, 0.406 ]).astype(numpy.float32))
+	prepare_vision_frame = numpy.divide(prepare_vision_frame, numpy.array([ 0.229, 0.224, 0.225 ]).astype(numpy.float32))
+	prepare_vision_frame = numpy.expand_dims(prepare_vision_frame, axis = 0)
+	prepare_vision_frame = prepare_vision_frame.transpose(0, 3, 1, 2)
+	region_mask = forward_parse_face(prepare_vision_frame)
+	region_mask = numpy.isin(region_mask.argmax(0), [ 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 create_mouth_mask(face_landmark_68 : FaceLandmark68) -> Mask:
+	convex_hull = cv2.convexHull(face_landmark_68[numpy.r_[3:14, 31:36]].astype(numpy.int32))
+	mouth_mask : Mask = numpy.zeros((512, 512)).astype(numpy.float32)
+	mouth_mask = cv2.fillConvexPoly(mouth_mask, convex_hull, 1.0) #type:ignore[call-overload]
+	mouth_mask = cv2.erode(mouth_mask.clip(0, 1), numpy.ones((21, 3)))
+	mouth_mask = cv2.GaussianBlur(mouth_mask, (0, 0), sigmaX = 1, sigmaY = 15)
+	return mouth_mask
+
+
+def forward_occlude_face(prepare_vision_frame : VisionFrame) -> Mask:
+	face_occluder_model = state_manager.get_item('face_occluder_model')
+	face_occluder = get_inference_pool().get(face_occluder_model)
+
+	with conditional_thread_semaphore():
+		occlusion_mask : Mask = face_occluder.run(None,
+		{
+			'input': prepare_vision_frame
+		})[0][0]
+
+	return occlusion_mask
+
+
+def forward_parse_face(prepare_vision_frame : VisionFrame) -> Mask:
+	face_parser_model = state_manager.get_item('face_parser_model')
+	face_parser = get_inference_pool().get(face_parser_model)
+
+	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,84 @@
+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.typing 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_sources = get_model_options().get('sources')
+	return inference_manager.get_inference_pool(__name__, model_sources)
+
+
+def clear_inference_pool() -> None:
+	inference_manager.clear_inference_pool(__name__)
+
+
+def get_model_options() -> ModelOptions:
+	return create_static_model_set('full').get('arcface')
+
+
+def pre_check() -> bool:
+	model_hashes = get_model_options().get('hashes')
+	model_sources = get_model_options().get('sources')
+
+	return conditional_download_hashes(model_hashes) and conditional_download_sources(model_sources)
+
+
+def calc_embedding(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Embedding, Embedding]:
+	model_template = get_model_options().get('template')
+	model_size = get_model_options().get('size')
+	crop_vision_frame, matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, model_size)
+	crop_vision_frame = crop_vision_frame / 127.5 - 1
+	crop_vision_frame = crop_vision_frame[:, :, ::-1].transpose(2, 0, 1).astype(numpy.float32)
+	crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
+	embedding = forward(crop_vision_frame)
+	embedding = embedding.ravel()
+	normed_embedding = embedding / numpy.linalg.norm(embedding)
+	return embedding, normed_embedding
+
+
+def forward(crop_vision_frame : VisionFrame) -> Embedding:
+	face_recognizer = get_inference_pool().get('face_recognizer')
+
+	with conditional_thread_semaphore():
+		embedding = face_recognizer.run(None,
+		{
+			'input': crop_vision_frame
+		})[0]
+
+	return embedding

facefusion/face_selector.py

@@ -0,0 +1,91 @@
+from typing import List
+
+import numpy
+
+from facefusion import state_manager
+from facefusion.typing import Face, FaceSelectorOrder, FaceSet, Gender, Race
+
+
+def find_similar_faces(faces : List[Face], reference_faces : FaceSet, face_distance : float) -> List[Face]:
+	similar_faces : List[Face] = []
+
+	if faces and reference_faces:
+		for reference_set in reference_faces:
+			if not similar_faces:
+				for reference_face in reference_faces[reference_set]:
+					for face in faces:
+						if compare_faces(face, reference_face, face_distance):
+							similar_faces.append(face)
+	return similar_faces
+
+
+def compare_faces(face : Face, reference_face : Face, face_distance : float) -> bool:
+	current_face_distance = calc_face_distance(face, reference_face)
+	return current_face_distance < face_distance
+
+
+def calc_face_distance(face : Face, reference_face : Face) -> float:
+	if hasattr(face, 'normed_embedding') and hasattr(reference_face, 'normed_embedding'):
+		return 1 - numpy.dot(face.normed_embedding, reference_face.normed_embedding)
+	return 0
+
+
+def sort_and_filter_faces(faces : List[Face]) -> List[Face]:
+	if faces:
+		if state_manager.get_item('face_selector_order'):
+			faces = sort_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 = lambda face: face.bounding_box[0])
+	if order == 'right-left':
+		return sorted(faces, key = lambda face: face.bounding_box[0], reverse = True)
+	if order == 'top-bottom':
+		return sorted(faces, key = lambda face: face.bounding_box[1])
+	if order == 'bottom-top':
+		return sorted(faces, key = lambda face: face.bounding_box[1], reverse = True)
+	if order == 'small-large':
+		return sorted(faces, key = lambda face: (face.bounding_box[2] - face.bounding_box[0]) * (face.bounding_box[3] - face.bounding_box[1]))
+	if order == 'large-small':
+		return sorted(faces, key = lambda face: (face.bounding_box[2] - face.bounding_box[0]) * (face.bounding_box[3] - face.bounding_box[1]), reverse = True)
+	if order == 'best-worst':
+		return sorted(faces, key = lambda face: face.score_set.get('detector'), reverse = True)
+	if order == 'worst-best':
+		return sorted(faces, key = lambda face: face.score_set.get('detector'))
+	return faces
+
+
+def filter_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,53 @@
+import hashlib
+from typing import List, Optional
+
+import numpy
+
+from facefusion.typing import Face, FaceSet, FaceStore, VisionFrame
+
+FACE_STORE : FaceStore =\
+{
+	'static_faces': {},
+	'reference_faces': {}
+}
+
+
+def get_face_store() -> FaceStore:
+	return FACE_STORE
+
+
+def get_static_faces(vision_frame : VisionFrame) -> Optional[List[Face]]:
+	frame_hash = create_frame_hash(vision_frame)
+	if frame_hash in FACE_STORE['static_faces']:
+		return FACE_STORE['static_faces'][frame_hash]
+	return None
+
+
+def set_static_faces(vision_frame : VisionFrame, faces : List[Face]) -> None:
+	frame_hash = create_frame_hash(vision_frame)
+	if frame_hash:
+		FACE_STORE['static_faces'][frame_hash] = faces
+
+
+def clear_static_faces() -> None:
+	FACE_STORE['static_faces'] = {}
+
+
+def create_frame_hash(vision_frame : VisionFrame) -> Optional[str]:
+	return hashlib.sha1(vision_frame.tobytes()).hexdigest() if numpy.any(vision_frame) else None
+
+
+def get_reference_faces() -> Optional[FaceSet]:
+	if FACE_STORE['reference_faces']:
+		return FACE_STORE['reference_faces']
+	return None
+
+
+def append_reference_face(name : str, face : Face) -> None:
+	if name not in FACE_STORE['reference_faces']:
+		FACE_STORE['reference_faces'][name] = []
+	FACE_STORE['reference_faces'][name].append(face)
+
+
+def clear_reference_faces() -> None:
+	FACE_STORE['reference_faces'] = {}

facefusion/ffmpeg.py

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

facefusion/filesystem.py

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

facefusion/hash_helper.py

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

facefusion/inference_manager.py

@@ -0,0 +1,63 @@
+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_execution_providers
+from facefusion.thread_helper import thread_lock
+from facefusion.typing import DownloadSet, ExecutionProvider, InferencePool, InferencePoolSet
+
+INFERENCE_POOLS : InferencePoolSet =\
+{
+	'cli': {}, #type:ignore[typeddict-item]
+	'ui': {} #type:ignore[typeddict-item]
+}
+
+
+def get_inference_pool(model_context : str, model_sources : DownloadSet) -> InferencePool:
+	global INFERENCE_POOLS
+
+	with thread_lock():
+		while process_manager.is_checking():
+			sleep(0.5)
+		app_context = detect_app_context()
+		inference_context = get_inference_context(model_context)
+
+		if app_context == 'cli' and INFERENCE_POOLS.get('ui').get(inference_context):
+			INFERENCE_POOLS['cli'][inference_context] = INFERENCE_POOLS.get('ui').get(inference_context)
+		if app_context == 'ui' and INFERENCE_POOLS.get('cli').get(inference_context):
+			INFERENCE_POOLS['ui'][inference_context] = INFERENCE_POOLS.get('cli').get(inference_context)
+		if not INFERENCE_POOLS.get(app_context).get(inference_context):
+			INFERENCE_POOLS[app_context][inference_context] = create_inference_pool(model_sources, state_manager.get_item('execution_device_id'), state_manager.get_item('execution_providers'))
+
+		return INFERENCE_POOLS.get(app_context).get(inference_context)
+
+
+def create_inference_pool(model_sources : DownloadSet, execution_device_id : str, execution_providers : List[ExecutionProvider]) -> InferencePool:
+	inference_pool : InferencePool = {}
+
+	for model_name in model_sources.keys():
+		inference_pool[model_name] = create_inference_session(model_sources.get(model_name).get('path'), execution_device_id, execution_providers)
+	return inference_pool
+
+
+def clear_inference_pool(model_context : str) -> None:
+	global INFERENCE_POOLS
+
+	app_context = detect_app_context()
+	inference_context = get_inference_context(model_context)
+
+	if INFERENCE_POOLS.get(app_context).get(inference_context):
+		del INFERENCE_POOLS[app_context][inference_context]
+
+
+def create_inference_session(model_path : str, execution_device_id : str, execution_providers : List[ExecutionProvider]) -> InferenceSession:
+	inference_execution_providers = create_inference_execution_providers(execution_device_id, execution_providers)
+	return InferenceSession(model_path, providers = inference_execution_providers)
+
+
+def get_inference_context(model_context : str) -> str:
+	inference_context = model_context + '.' + '_'.join(state_manager.get_item('execution_providers'))
+	return inference_context

facefusion/installer.py

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

facefusion/jobs/job_helper.py

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

facefusion/jobs/job_list.py

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

facefusion/jobs/job_manager.py

@@ -0,0 +1,260 @@
+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, 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.typing import Args, Job, JobSet, JobStatus, JobStep, JobStepStatus
+
+JOBS_PATH : Optional[str] = None
+
+
+def init_jobs(jobs_path : str) -> bool:
+	global JOBS_PATH
+
+	JOBS_PATH = jobs_path
+	job_status_paths = [ os.path.join(JOBS_PATH, job_status) for job_status in 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() -> bool:
+	drafted_job_ids = find_job_ids('drafted')
+
+	if drafted_job_ids:
+		for job_id in drafted_job_ids:
+			if not submit_job(job_id):
+				return False
+		return True
+	return False
+
+
+def delete_job(job_id : str) -> bool:
+	return delete_job_file(job_id)
+
+
+def delete_jobs() -> bool:
+	job_ids = find_job_ids('drafted') + find_job_ids('queued') + find_job_ids('failed') + find_job_ids('completed')
+
+	if job_ids:
+		for job_id in job_ids:
+			if not delete_job(job_id):
+				return False
+		return True
+	return False
+
+
+def find_jobs(job_status : JobStatus) -> JobSet:
+	job_ids = find_job_ids(job_status)
+	jobs : JobSet = {}
+
+	for job_id in job_ids:
+		jobs[job_id] = read_job_file(job_id)
+	return jobs
+
+
+def find_job_ids(job_status : JobStatus) -> List[str]:
+	job_pattern = os.path.join(JOBS_PATH, job_status, '*.json')
+	job_paths = resolve_file_pattern(job_pattern)
+	job_paths.sort(key = os.path.getmtime)
+	job_ids = []
+
+	for job_path in job_paths:
+		job_id, _ = os.path.splitext(os.path.basename(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,106 @@
+from facefusion.ffmpeg import concat_video
+from facefusion.filesystem import is_image, is_video, move_file, remove_file
+from facefusion.jobs import job_helper, job_manager
+from facefusion.typing import JobOutputSet, JobStep, ProcessStep
+
+
+def run_job(job_id : str, process_step : ProcessStep) -> bool:
+	queued_job_ids = job_manager.find_job_ids('queued')
+
+	if job_id in queued_job_ids:
+		if run_steps(job_id, process_step) and finalize_steps(job_id):
+			clean_steps(job_id)
+			return job_manager.move_job_file(job_id, 'completed')
+		clean_steps(job_id)
+		job_manager.move_job_file(job_id, 'failed')
+	return False
+
+
+def run_jobs(process_step : ProcessStep) -> bool:
+	queued_job_ids = job_manager.find_job_ids('queued')
+
+	if queued_job_ids:
+		for job_id in queued_job_ids:
+			if not run_job(job_id, process_step):
+				return False
+		return True
+	return False
+
+
+def retry_job(job_id : str, process_step : ProcessStep) -> bool:
+	failed_job_ids = job_manager.find_job_ids('failed')
+
+	if job_id in failed_job_ids:
+		return job_manager.set_steps_status(job_id, 'queued') and job_manager.move_job_file(job_id, 'queued') and run_job(job_id, process_step)
+	return False
+
+
+def retry_jobs(process_step : ProcessStep) -> bool:
+	failed_job_ids = job_manager.find_job_ids('failed')
+
+	if failed_job_ids:
+		for job_id in failed_job_ids:
+			if not retry_job(job_id, process_step):
+				return False
+		return True
+	return False
+
+
+def run_step(job_id : str, step_index : int, step : JobStep, process_step : ProcessStep) -> bool:
+	step_args = step.get('args')
+
+	if job_manager.set_step_status(job_id, step_index, 'started') and process_step(job_id, step_index, step_args):
+		output_path = step_args.get('output_path')
+		step_output_path = job_helper.get_step_output_path(job_id, step_index, output_path)
+
+		return move_file(output_path, step_output_path) and job_manager.set_step_status(job_id, step_index, 'completed')
+	job_manager.set_step_status(job_id, step_index, 'failed')
+	return False
+
+
+def run_steps(job_id : str, process_step : ProcessStep) -> bool:
+	steps = job_manager.get_steps(job_id)
+
+	if steps:
+		for index, step in enumerate(steps):
+			if not run_step(job_id, index, step, process_step):
+				return False
+		return True
+	return False
+
+
+def finalize_steps(job_id : str) -> bool:
+	output_set = collect_output_set(job_id)
+
+	for output_path, temp_output_paths in output_set.items():
+		if all(map(is_video, temp_output_paths)):
+			if not concat_video(output_path, temp_output_paths):
+				return False
+		if any(map(is_image, temp_output_paths)):
+			for temp_output_path in temp_output_paths:
+				if not move_file(temp_output_path, output_path):
+					return False
+	return True
+
+
+def clean_steps(job_id: str) -> bool:
+	output_set = collect_output_set(job_id)
+
+	for temp_output_paths in output_set.values():
+		for temp_output_path in temp_output_paths:
+			if not remove_file(temp_output_path):
+				return False
+	return True
+
+
+def collect_output_set(job_id : str) -> JobOutputSet:
+	steps = job_manager.get_steps(job_id)
+	output_set : JobOutputSet = {}
+
+	for index, step in enumerate(steps):
+		output_path = step.get('args').get('output_path')
+
+		if output_path:
+			step_output_path = job_manager.get_step_output_path(job_id, index, output_path)
+			output_set.setdefault(output_path, []).append(step_output_path)
+	return output_set

facefusion/jobs/job_store.py

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

facefusion/json.py

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

facefusion/logger.py

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

facefusion/memory.py

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

facefusion/metadata.py

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

facefusion/model_helper.py

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