Add facefusion directory as regular files

facefusion

@@ -1 +0,0 @@
-Subproject commit 126845c24c5c60699311d1f822de1a056d83b3bd

facefusion/.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

facefusion/.flake8

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

facefusion/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: henryruhs
+custom: [ buymeacoffee.com/henryruhs, paypal.me/henryruhs ]

facefusion/.github/workflows/ci.yml

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

facefusion/.gitignore

@@ -0,0 +1,3 @@
+.assets
+.idea
+.vscode

facefusion/.install/LICENSE.md

@@ -0,0 +1,3 @@
+CC-BY-4.0 license
+
+Copyright (c) 2024 Henry Ruhs

facefusion/.install/facefusion.nsi

@@ -0,0 +1,183 @@
+!include MUI2.nsh
+!include nsDialogs.nsh
+!include LogicLib.nsh
+
+RequestExecutionLevel admin
+ManifestDPIAware true
+
+Name 'FaceFusion 2.6.0'
+OutFile 'FaceFusion_2.6.0.exe'
+
+!define MUI_ICON 'facefusion.ico'
+
+!insertmacro MUI_PAGE_DIRECTORY
+Page custom InstallPage PostInstallPage
+!insertmacro MUI_PAGE_INSTFILES
+!insertmacro MUI_LANGUAGE English
+
+Var UseDefault
+Var UseCuda
+Var UseDirectMl
+Var UseOpenVino
+
+Function .onInit
+	StrCpy $INSTDIR 'C:\FaceFusion'
+FunctionEnd
+
+Function InstallPage
+	nsDialogs::Create 1018
+	!insertmacro MUI_HEADER_TEXT 'Choose Your Accelerator' 'Choose your accelerator based on the graphics card.'
+
+	${NSD_CreateRadioButton} 0 40u 100% 10u 'Default'
+	Pop $UseDefault
+
+	${NSD_CreateRadioButton} 0 55u 100% 10u 'CUDA (NVIDIA)'
+	Pop $UseCuda
+
+	${NSD_CreateRadioButton} 0 70u 100% 10u 'DirectML (AMD, Intel, NVIDIA)'
+	Pop $UseDirectMl
+
+	${NSD_CreateRadioButton} 0 85u 100% 10u 'OpenVINO (Intel)'
+	Pop $UseOpenVino
+
+	${NSD_Check} $UseDefault
+
+	nsDialogs::Show
+FunctionEnd
+
+Function PostInstallPage
+	${NSD_GetState} $UseDefault $UseDefault
+	${NSD_GetState} $UseCuda $UseCuda
+	${NSD_GetState} $UseDirectMl $UseDirectMl
+	${NSD_GetState} $UseOpenVino $UseOpenVino
+FunctionEnd
+
+Function Destroy
+	${If} ${Silent}
+		Quit
+	${Else}
+		Abort
+	${EndIf}
+FunctionEnd
+
+Section 'Prepare Your Platform'
+	DetailPrint 'Install GIT'
+	inetc::get 'https://github.com/git-for-windows/git/releases/download/v2.45.1.windows.1/Git-2.45.1-64-bit.exe' '$TEMP\Git.exe'
+	ExecWait '$TEMP\Git.exe /CURRENTUSER /VERYSILENT /DIR=$LOCALAPPDATA\Programs\Git' $0
+	Delete '$TEMP\Git.exe'
+
+	${If} $0 > 0
+		DetailPrint 'Git installation aborted with error code $0'
+		Call Destroy
+	${EndIf}
+
+	DetailPrint 'Uninstall Conda'
+	ExecWait '$LOCALAPPDATA\Programs\Miniconda3\Uninstall-Miniconda3.exe /S _?=$LOCALAPPDATA\Programs\Miniconda3'
+	RMDir /r '$LOCALAPPDATA\Programs\Miniconda3'
+
+	DetailPrint 'Install Conda'
+	inetc::get 'https://repo.anaconda.com/miniconda/Miniconda3-py310_24.3.0-0-Windows-x86_64.exe' '$TEMP\Miniconda3.exe'
+	ExecWait '$TEMP\Miniconda3.exe /InstallationType=JustMe /AddToPath=1 /S /D=$LOCALAPPDATA\Programs\Miniconda3' $1
+	Delete '$TEMP\Miniconda3.exe'
+
+	${If} $1 > 0
+		DetailPrint 'Conda installation aborted with error code $1'
+		Call Destroy
+	${EndIf}
+SectionEnd
+
+Section 'Download Your Copy'
+	SetOutPath $INSTDIR
+
+	DetailPrint 'Download Your Copy'
+	RMDir /r $INSTDIR
+	nsExec::Exec '$LOCALAPPDATA\Programs\Git\cmd\git.exe clone https://github.com/facefusion/facefusion --branch 2.6.0 .'
+SectionEnd
+
+Section 'Setup Your Environment'
+	DetailPrint 'Setup Your Environment'
+	nsExec::Exec '$LOCALAPPDATA\Programs\Miniconda3\Scripts\conda.exe init --all'
+	nsExec::Exec '$LOCALAPPDATA\Programs\Miniconda3\Scripts\conda.exe create --name facefusion python=3.10 --yes'
+SectionEnd
+
+Section 'Create Install Batch'
+	SetOutPath $INSTDIR
+
+	FileOpen $0 install-ffmpeg.bat w
+	FileOpen $1 install-accelerator.bat w
+	FileOpen $2 install-application.bat w
+
+	FileWrite $0 '@echo off && conda activate facefusion && conda install conda-forge::ffmpeg=7.0.0 --yes'
+	${If} $UseCuda == 1
+		FileWrite $1 '@echo off && conda activate facefusion && conda install cudatoolkit=11.8 cudnn=8.9.2.26 conda-forge::gputil=1.4.0 conda-forge::zlib-wapi --yes'
+		FileWrite $2 '@echo off && conda activate facefusion && python install.py --onnxruntime cuda-11.8'
+	${ElseIf} $UseDirectMl == 1
+		FileWrite $2 '@echo off && conda activate facefusion && python install.py --onnxruntime directml'
+	${ElseIf} $UseOpenVino == 1
+		FileWrite $1 '@echo off && conda activate facefusion && conda install conda-forge::openvino=2023.1.0 --yes'
+		FileWrite $2 '@echo off && conda activate facefusion && python install.py --onnxruntime openvino'
+	${Else}
+		FileWrite $2 '@echo off && conda activate facefusion && python install.py --onnxruntime default'
+	${EndIf}
+
+	FileClose $0
+	FileClose $1
+	FileClose $2
+SectionEnd
+
+Section 'Install Your FFmpeg'
+	SetOutPath $INSTDIR
+
+	DetailPrint 'Install Your FFmpeg'
+	nsExec::ExecToLog 'install-ffmpeg.bat'
+SectionEnd
+
+Section 'Install Your Accelerator'
+	SetOutPath $INSTDIR
+
+	DetailPrint 'Install Your Accelerator'
+	nsExec::ExecToLog 'install-accelerator.bat'
+SectionEnd
+
+Section 'Install The Application'
+	SetOutPath $INSTDIR
+
+	DetailPrint 'Install The Application'
+	nsExec::ExecToLog 'install-application.bat'
+SectionEnd
+
+Section 'Create Run Batch'
+	SetOutPath $INSTDIR
+	FileOpen $0 run.bat w
+	FileWrite $0 '@echo off && conda activate facefusion && python run.py %*'
+	FileClose $0
+SectionEnd
+
+Section 'Register The Application'
+	DetailPrint 'Register The Application'
+
+	CreateDirectory $SMPROGRAMS\FaceFusion
+	CreateShortcut '$SMPROGRAMS\FaceFusion\FaceFusion.lnk' $INSTDIR\run.bat '--open-browser' $INSTDIR\.install\facefusion.ico
+	CreateShortcut '$SMPROGRAMS\FaceFusion\FaceFusion Benchmark.lnk' $INSTDIR\run.bat '--ui-layouts benchmark --open-browser' $INSTDIR\.install\facefusion.ico
+	CreateShortcut '$SMPROGRAMS\FaceFusion\FaceFusion Webcam.lnk' $INSTDIR\run.bat '--ui-layouts webcam --open-browser' $INSTDIR\.install\facefusion.ico
+
+	CreateShortcut $DESKTOP\FaceFusion.lnk $INSTDIR\run.bat '--open-browser' $INSTDIR\.install\facefusion.ico
+
+	WriteUninstaller $INSTDIR\Uninstall.exe
+
+	WriteRegStr HKLM SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\FaceFusion DisplayName 'FaceFusion'
+	WriteRegStr HKLM SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\FaceFusion DisplayVersion '2.6.0'
+	WriteRegStr HKLM SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\FaceFusion Publisher 'Henry Ruhs'
+	WriteRegStr HKLM SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\FaceFusion InstallLocation $INSTDIR
+	WriteRegStr HKLM SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\FaceFusion UninstallString $INSTDIR\uninstall.exe
+SectionEnd
+
+Section 'Uninstall'
+	nsExec::Exec '$LOCALAPPDATA\Programs\Miniconda3\Scripts\conda.exe env remove --name facefusion --yes'
+
+	Delete $DESKTOP\FaceFusion.lnk
+	RMDir /r $SMPROGRAMS\FaceFusion
+	RMDir /r $INSTDIR
+
+	DeleteRegKey HKLM SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\FaceFusion
+SectionEnd

facefusion/LICENSE.md

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

facefusion/README.md

@@ -0,0 +1,113 @@
+FaceFusion
+==========
+
+> Next generation face swapper and enhancer.
+
+[![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)
+![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](https://buymeacoffee.com/henryruhs/e/251939) can have you up and running in minutes.
+
+
+Usage
+-----
+
+Run the command:
+
+```
+python run.py [options]
+
+options:
+  -h, --help                                                                                                                                                                            show this help message and exit
+  -c CONFIG_PATH, --config CONFIG_PATH                                                                                                                                                  choose the config file to override defaults
+  -s SOURCE_PATHS, --source SOURCE_PATHS                                                                                                                                                choose single or multiple source images or audios
+  -t TARGET_PATH, --target TARGET_PATH                                                                                                                                                  choose single target image or video
+  -o OUTPUT_PATH, --output OUTPUT_PATH                                                                                                                                                  specify the output file or directory
+  -v, --version                                                                                                                                                                         show program's version number and exit
+
+misc:
+  --force-download                                                                                                                                                                      force automate downloads and exit
+  --skip-download                                                                                                                                                                       omit automate downloads and remote lookups
+  --headless                                                                                                                                                                            run the program without a user interface
+  --log-level {error,warn,info,debug}                                                                                                                                                   adjust the message severity displayed in the terminal
+
+execution:
+  --execution-device-id EXECUTION_DEVICE_ID                                                                                                                                             specify the device used for processing
+  --execution-providers EXECUTION_PROVIDERS [EXECUTION_PROVIDERS ...]                                                                                                                   accelerate the model inference using different providers (choices: cpu, ...)
+  --execution-thread-count [1-128]                                                                                                                                                      specify the amount of parallel threads while processing
+  --execution-queue-count [1-32]                                                                                                                                                        specify the amount of frames each thread is processing
+
+memory:
+  --video-memory-strategy {strict,moderate,tolerant}                                                                                                                                    balance fast frame processing and low VRAM usage
+  --system-memory-limit [0-128]                                                                                                                                                         limit the available RAM that can be used while processing
+
+face analyser:
+  --face-analyser-order {left-right,right-left,top-bottom,bottom-top,small-large,large-small,best-worst,worst-best}                                                                     specify the order in which the face analyser detects faces
+  --face-analyser-age {child,teen,adult,senior}                                                                                                                                         filter the detected faces based on their age
+  --face-analyser-gender {female,male}                                                                                                                                                  filter the detected faces based on their gender
+  --face-detector-model {many,retinaface,scrfd,yoloface,yunet}                                                                                                                          choose the model responsible for detecting the face
+  --face-detector-size FACE_DETECTOR_SIZE                                                                                                                                               specify the size of the frame provided to the face detector
+  --face-detector-score [0.0-0.95]                                                                                                                                                      filter the detected faces base on the confidence score
+  --face-landmarker-score [0.0-0.95]                                                                                                                                                    filter the detected landmarks base on the confidence score
+
+face selector:
+  --face-selector-mode {many,one,reference}                                                                                                                                             use reference based tracking or simple matching
+  --reference-face-position REFERENCE_FACE_POSITION                                                                                                                                     specify the position used to create the reference face
+  --reference-face-distance [0.0-1.45]                                                                                                                                                  specify the desired similarity between the reference face and target face
+  --reference-frame-number REFERENCE_FRAME_NUMBER                                                                                                                                       specify the frame used to create the reference face
+
+face mask:
+  --face-mask-types FACE_MASK_TYPES [FACE_MASK_TYPES ...]                                                                                                                               mix and match different face mask types (choices: box, occlusion, region)
+  --face-mask-blur [0.0-0.95]                                                                                                                                                           specify the degree of blur applied the box mask
+  --face-mask-padding FACE_MASK_PADDING [FACE_MASK_PADDING ...]                                                                                                                         apply top, right, bottom and left padding to the box mask
+  --face-mask-regions FACE_MASK_REGIONS [FACE_MASK_REGIONS ...]                                                                                                                         choose the facial features used for the region mask (choices: skin, left-eyebrow, right-eyebrow, left-eye, right-eye, glasses, nose, mouth, upper-lip, lower-lip)
+
+frame extraction:
+  --trim-frame-start TRIM_FRAME_START                                                                                                                                                   specify the the start frame of the target video
+  --trim-frame-end TRIM_FRAME_END                                                                                                                                                       specify the the end frame of the target video
+  --temp-frame-format {bmp,jpg,png}                                                                                                                                                     specify the temporary resources format
+  --keep-temp                                                                                                                                                                           keep the temporary resources after processing
+
+output creation:
+  --output-image-quality [0-100]                                                                                                                                                        specify the image quality which translates to the compression factor
+  --output-image-resolution OUTPUT_IMAGE_RESOLUTION                                                                                                                                     specify the image output resolution based on the target image
+  --output-video-encoder {libx264,libx265,libvpx-vp9,h264_nvenc,hevc_nvenc,h264_amf,hevc_amf}                                                                                           specify the encoder use for the video compression
+  --output-video-preset {ultrafast,superfast,veryfast,faster,fast,medium,slow,slower,veryslow}                                                                                          balance fast video processing and video file size
+  --output-video-quality [0-100]                                                                                                                                                        specify the video quality which translates to the compression factor
+  --output-video-resolution OUTPUT_VIDEO_RESOLUTION                                                                                                                                     specify the video output resolution based on the target video
+  --output-video-fps OUTPUT_VIDEO_FPS                                                                                                                                                   specify the video output fps based on the target video
+  --skip-audio                                                                                                                                                                          omit the audio from the target video
+
+frame processors:
+  --frame-processors FRAME_PROCESSORS [FRAME_PROCESSORS ...]                                                                                                                            load a single or multiple frame processors. (choices: face_debugger, face_enhancer, face_swapper, frame_colorizer, frame_enhancer, lip_syncer, ...)
+  --face-debugger-items FACE_DEBUGGER_ITEMS [FACE_DEBUGGER_ITEMS ...]                                                                                                                   load a single or multiple frame processors (choices: bounding-box, face-landmark-5, face-landmark-5/68, face-landmark-68, face-landmark-68/5, face-mask, face-detector-score, face-landmarker-score, age, gender)
+  --face-enhancer-model {codeformer,gfpgan_1.2,gfpgan_1.3,gfpgan_1.4,gpen_bfr_256,gpen_bfr_512,gpen_bfr_1024,gpen_bfr_2048,restoreformer_plus_plus}                                     choose the model responsible for enhancing the face
+  --face-enhancer-blend [0-100]                                                                                                                                                         blend the enhanced into the previous face
+  --face-swapper-model {blendswap_256,inswapper_128,inswapper_128_fp16,simswap_256,simswap_512_unofficial,uniface_256}                                                                  choose the model responsible for swapping the face
+  --frame-colorizer-model {ddcolor,ddcolor_artistic,deoldify,deoldify_artistic,deoldify_stable}                                                                                         choose the model responsible for colorizing the frame
+  --frame-colorizer-blend [0-100]                                                                                                                                                       blend the colorized into the previous frame
+  --frame-colorizer-size {192x192,256x256,384x384,512x512}                                                                                                                              specify the size of the frame provided to the frame colorizer
+  --frame-enhancer-model {clear_reality_x4,lsdir_x4,nomos8k_sc_x4,real_esrgan_x2,real_esrgan_x2_fp16,real_esrgan_x4,real_esrgan_x4_fp16,real_hatgan_x4,span_kendata_x4,ultra_sharp_x4}  choose the model responsible for enhancing the frame
+  --frame-enhancer-blend [0-100]                                                                                                                                                        blend the enhanced into the previous frame
+  --lip-syncer-model {wav2lip_gan}                                                                                                                                                      choose the model responsible for syncing the lips
+
+uis:
+  --open-browser                                                                                                                                                                        open the browser once the program is ready
+  --ui-layouts UI_LAYOUTS [UI_LAYOUTS ...]                                                                                                                                              launch a single or multiple UI layouts (choices: benchmark, default, webcam, ...)
+```
+
+
+Documentation
+-------------
+
+Read the [documentation](https://docs.facefusion.io) for a deep dive.

facefusion/core.py

@@ -0,0 +1,443 @@
+import os
+
+os.environ['OMP_NUM_THREADS'] = '1'
+
+import signal
+import sys
+import warnings
+import shutil
+import numpy
+import onnxruntime
+from time import sleep, time
+from argparse import ArgumentParser, HelpFormatter
+
+import facefusion.choices
+import facefusion.globals
+from facefusion.face_analyser import get_one_face, get_average_face
+from facefusion.face_store import get_reference_faces, append_reference_face
+from facefusion import face_analyser, face_masker, content_analyser, config, process_manager, metadata, logger, wording, voice_extractor
+from facefusion.content_analyser import analyse_image, analyse_video
+from facefusion.processors.frame.core import get_frame_processors_modules, load_frame_processor_module
+from facefusion.common_helper import create_metavar, get_first
+from facefusion.execution import encode_execution_providers, decode_execution_providers
+from facefusion.normalizer import normalize_output_path, normalize_padding, normalize_fps
+from facefusion.memory import limit_system_memory
+from facefusion.statistics import conditional_log_statistics
+from facefusion.download import conditional_download
+from facefusion.filesystem import get_temp_frame_paths, get_temp_file_path, create_temp, move_temp, clear_temp, is_image, is_video, filter_audio_paths, resolve_relative_path, list_directory
+from facefusion.ffmpeg import extract_frames, merge_video, copy_image, finalize_image, restore_audio, replace_audio
+from facefusion.vision import read_image, read_static_images, detect_image_resolution, restrict_video_fps, create_image_resolutions, get_video_frame, detect_video_resolution, detect_video_fps, restrict_video_resolution, restrict_image_resolution, create_video_resolutions, pack_resolution, unpack_resolution
+
+onnxruntime.set_default_logger_severity(3)
+warnings.filterwarnings('ignore', category = UserWarning, module = 'gradio')
+
+
+def cli() -> None:
+    signal.signal(signal.SIGINT, lambda signal_number, frame: destroy())
+    program = ArgumentParser(formatter_class=lambda prog: HelpFormatter(prog, max_help_position=200), add_help=False)
+    # general
+    program.add_argument('-c', '--config', help=wording.get('help.config'), dest='config_path', default='facefusion.ini')
+    apply_config(program)
+    program.add_argument('-s', '--source', help=wording.get('help.source'), action='append', dest='source_paths', default=config.get_str_list('general.source_paths'))
+    program.add_argument('-t', '--target', help=wording.get('help.target'), dest='target_path', default=config.get_str_value('general.target_path'))
+    program.add_argument('-o', '--output', help=wording.get('help.output'), dest='output_path', default=config.get_str_value('general.output_path'))
+    program.add_argument('-v', '--version', version=metadata.get('name') + ' ' + metadata.get('version'), action='version')
+    # misc
+    group_misc = program.add_argument_group('misc')
+    group_misc.add_argument('--force-download', help=wording.get('help.force_download'), action='store_true', default=config.get_bool_value('misc.force_download'))
+    group_misc.add_argument('--skip-download', help=wording.get('help.skip_download'), action='store_true', default=config.get_bool_value('misc.skip_download'))
+    group_misc.add_argument('--headless', help=wording.get('help.headless'), action='store_true', default=config.get_bool_value('misc.headless'))
+    group_misc.add_argument('--log-level', help=wording.get('help.log_level'), default=config.get_str_value('misc.log_level', 'info'), choices=logger.get_log_levels())
+    # execution
+    execution_providers = encode_execution_providers(onnxruntime.get_available_providers())
+    group_execution = program.add_argument_group('execution')
+    group_execution.add_argument('--execution-device-id', help=wording.get('help.execution_device_id'), default=config.get_str_value('execution.face_detector_size', '0'))
+    group_execution.add_argument('--execution-providers', help=wording.get('help.execution_providers').format(choices=', '.join(execution_providers)), default=config.get_str_list('execution.execution_providers', 'cpu'), choices=execution_providers, nargs='+', metavar='EXECUTION_PROVIDERS')
+    group_execution.add_argument('--execution-thread-count', help=wording.get('help.execution_thread_count'), type=int, default=config.get_int_value('execution.execution_thread_count', '4'), choices=facefusion.choices.execution_thread_count_range, metavar=create_metavar(facefusion.choices.execution_thread_count_range))
+    group_execution.add_argument('--execution-queue-count', help=wording.get('help.execution_queue_count'), type=int, default=config.get_int_value('execution.execution_queue_count', '1'), choices=facefusion.choices.execution_queue_count_range, metavar=create_metavar(facefusion.choices.execution_queue_count_range))
+    # memory
+    group_memory = program.add_argument_group('memory')
+    group_memory.add_argument('--video-memory-strategy', help=wording.get('help.video_memory_strategy'), default=config.get_str_value('memory.video_memory_strategy', 'strict'), choices=facefusion.choices.video_memory_strategies)
+    group_memory.add_argument('--system-memory-limit', help=wording.get('help.system_memory_limit'), type=int, default=config.get_int_value('memory.system_memory_limit', '0'), choices=facefusion.choices.system_memory_limit_range, metavar=create_metavar(facefusion.choices.system_memory_limit_range))
+    # face analyser
+    group_face_analyser = program.add_argument_group('face analyser')
+    group_face_analyser.add_argument('--face-analyser-order', help=wording.get('help.face_analyser_order'), default=config.get_str_value('face_analyser.face_analyser_order', 'left-right'), choices=facefusion.choices.face_analyser_orders)
+    group_face_analyser.add_argument('--face-analyser-age', help=wording.get('help.face_analyser_age'), default=config.get_str_value('face_analyser.face_analyser_age'), choices=facefusion.choices.face_analyser_ages)
+    group_face_analyser.add_argument('--face-analyser-gender', help=wording.get('help.face_analyser_gender'), default=config.get_str_value('face_analyser.face_analyser_gender'), choices=facefusion.choices.face_analyser_genders)
+    group_face_analyser.add_argument('--face-detector-model', help=wording.get('help.face_detector_model'), default=config.get_str_value('face_analyser.face_detector_model', 'yoloface'), choices=facefusion.choices.face_detector_set.keys())
+    group_face_analyser.add_argument('--face-detector-size', help=wording.get('help.face_detector_size'), default=config.get_str_value('face_analyser.face_detector_size', '640x640'))
+    group_face_analyser.add_argument('--face-detector-score', help=wording.get('help.face_detector_score'), type=float, default=config.get_float_value('face_analyser.face_detector_score', '0.5'), choices=facefusion.choices.face_detector_score_range, metavar=create_metavar(facefusion.choices.face_detector_score_range))
+    group_face_analyser.add_argument('--face-landmarker-score', help=wording.get('help.face_landmarker_score'), type=float, default=config.get_float_value('face_analyser.face_landmarker_score', '0.5'), choices=facefusion.choices.face_landmarker_score_range, metavar=create_metavar(facefusion.choices.face_landmarker_score_range))
+    # face selector
+    group_face_selector = program.add_argument_group('face selector')
+    group_face_selector.add_argument('--face-selector-mode', help=wording.get('help.face_selector_mode'), default=config.get_str_value('face_selector.face_selector_mode', 'reference'), choices=facefusion.choices.face_selector_modes)
+    group_face_selector.add_argument('--reference-face-position', help=wording.get('help.reference_face_position'), type=int, default=config.get_int_value('face_selector.reference_face_position', '0'))
+    group_face_selector.add_argument('--reference-face-distance', help=wording.get('help.reference_face_distance'), type=float, default=config.get_float_value('face_selector.reference_face_distance', '0.6'), choices=facefusion.choices.reference_face_distance_range, metavar=create_metavar(facefusion.choices.reference_face_distance_range))
+    group_face_selector.add_argument('--reference-frame-number', help=wording.get('help.reference_frame_number'), type=int, default=config.get_int_value('face_selector.reference_frame_number', '0'))
+    # face mask
+    group_face_mask = program.add_argument_group('face mask')
+    group_face_mask.add_argument('--face-mask-types', help=wording.get('help.face_mask_types').format(choices=', '.join(facefusion.choices.face_mask_types)), default=config.get_str_list('face_mask.face_mask_types', 'box'), choices=facefusion.choices.face_mask_types, nargs='+', metavar='FACE_MASK_TYPES')
+    group_face_mask.add_argument('--face-mask-blur', help=wording.get('help.face_mask_blur'), type=float, default=config.get_float_value('face_mask.face_mask_blur', '0.3'), choices=facefusion.choices.face_mask_blur_range, metavar=create_metavar(facefusion.choices.face_mask_blur_range))
+    group_face_mask.add_argument('--face-mask-padding', help=wording.get('help.face_mask_padding'), type=int, default=config.get_int_list('face_mask.face_mask_padding', '0 0 0 0'), nargs='+')
+    group_face_mask.add_argument('--face-mask-regions', help=wording.get('help.face_mask_regions').format(choices=', '.join(facefusion.choices.face_mask_regions)), default=config.get_str_list('face_mask.face_mask_regions', ' '.join(facefusion.choices.face_mask_regions)), choices=facefusion.choices.face_mask_regions, nargs='+', metavar='FACE_MASK_REGIONS')
+    # frame extraction
+    group_frame_extraction = program.add_argument_group('frame extraction')
+    group_frame_extraction.add_argument('--trim-frame-start', help=wording.get('help.trim_frame_start'), type=int, default=facefusion.config.get_int_value('frame_extraction.trim_frame_start'))
+    group_frame_extraction.add_argument('--trim-frame-end', help=wording.get('help.trim_frame_end'), type=int, default=facefusion.config.get_int_value('frame_extraction.trim_frame_end'))
+    group_frame_extraction.add_argument('--temp-frame-format', help=wording.get('help.temp_frame_format'), default=config.get_str_value('frame_extraction.temp_frame_format', 'png'), choices=facefusion.choices.temp_frame_formats)
+    group_frame_extraction.add_argument('--keep-temp', help=wording.get('help.keep_temp'), action='store_true', default=config.get_bool_value('frame_extraction.keep_temp'))
+    # output creation
+    group_output_creation = program.add_argument_group('output creation')
+    group_output_creation.add_argument('--output-image-quality', help=wording.get('help.output_image_quality'), type=int, default=config.get_int_value('output_creation.output_image_quality', '80'), choices=facefusion.choices.output_image_quality_range, metavar=create_metavar(facefusion.choices.output_image_quality_range))
+    group_output_creation.add_argument('--output-image-resolution', help=wording.get('help.output_image_resolution'), default=config.get_str_value('output_creation.output_image_resolution'))
+    group_output_creation.add_argument('--output-video-encoder', help=wording.get('help.output_video_encoder'), default=config.get_str_value('output_creation.output_video_encoder', 'libx264'), choices=facefusion.choices.output_video_encoders)
+    group_output_creation.add_argument('--output-video-preset', help=wording.get('help.output_video_preset'), default=config.get_str_value('output_creation.output_video_preset', 'veryfast'), choices=facefusion.choices.output_video_presets)
+    group_output_creation.add_argument('--output-video-quality', help=wording.get('help.output_video_quality'), type=int, default=config.get_int_value('output_creation.output_video_quality', '80'), choices=facefusion.choices.output_video_quality_range, metavar=create_metavar(facefusion.choices.output_video_quality_range))
+    group_output_creation.add_argument('--output-video-resolution', help=wording.get('help.output_video_resolution'), default=config.get_str_value('output_creation.output_video_resolution'))
+    group_output_creation.add_argument('--output-video-fps', help=wording.get('help.output_video_fps'), type=float, default=config.get_str_value('output_creation.output_video_fps'))
+    group_output_creation.add_argument('--skip-audio', help=wording.get('help.skip_audio'), action='store_true', default=config.get_bool_value('output_creation.skip_audio'))
+    # frame processors
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    modules_path = os.path.join(base_dir, "facefusion", "processors", "frame", "modules")
+    available_frame_processors = list_directory(modules_path)
+    
+    # Debug statement to print available frame processors
+    print(f"Available frame processors: {available_frame_processors}")
+
+    if not isinstance(available_frame_processors, list):
+        available_frame_processors = list(available_frame_processors)
+    
+    program = ArgumentParser(parents=[program], formatter_class=program.formatter_class, add_help=True)
+    group_frame_processors = program.add_argument_group('frame processors')
+    group_frame_processors.add_argument('--frame-processors', help=wording.get('help.frame_processors').format(choices=', '.join(available_frame_processors)), default=config.get_str_list('frame_processors.frame_processors', 'face_swapper'), nargs='+')
+    for frame_processor in available_frame_processors:
+        frame_processor_module = load_frame_processor_module(frame_processor)
+        frame_processor_module.register_args(group_frame_processors)
+    run(program)
+
+
+def apply_config(program: ArgumentParser) -> None:
+    known_args = program.parse_known_args()
+    facefusion.globals.config_path = get_first(known_args).config_path
+
+
+def validate_args(program: ArgumentParser) -> None:
+    try:
+        for action in program._actions:
+            if action.default:
+                if isinstance(action.default, list):
+                    for default in action.default:
+                        program._check_value(action, default)
+                else:
+                    program._check_value(action, action.default)
+    except Exception as exception:
+        program.error(str(exception))
+
+
+def apply_args(program: ArgumentParser) -> None:
+    args = program.parse_args()
+    # general
+    facefusion.globals.source_paths = args.source_paths
+    facefusion.globals.target_path = args.target_path
+    facefusion.globals.output_path = args.output_path
+    # misc
+    facefusion.globals.force_download = args.force_download
+    facefusion.globals.skip_download = args.skip_download
+    facefusion.globals.headless = args.headless
+    facefusion.globals.log_level = args.log_level
+    # execution
+    facefusion.globals.execution_device_id = args.execution_device_id
+    facefusion.globals.execution_providers = decode_execution_providers(args.execution_providers)
+    facefusion.globals.execution_thread_count = args.execution_thread_count
+    facefusion.globals.execution_queue_count = args.execution_queue_count
+    # memory
+    facefusion.globals.video_memory_strategy = args.video_memory_strategy
+    facefusion.globals.system_memory_limit = args.system_memory_limit
+    # face analyser
+    facefusion.globals.face_analyser_order = args.face_analyser_order
+    facefusion.globals.face_analyser_age = args.face_analyser_age
+    facefusion.globals.face_analyser_gender = args.face_analyser_gender
+    facefusion.globals.face_detector_model = args.face_detector_model
+    if args.face_detector_size in facefusion.choices.face_detector_set[args.face_detector_model]:
+        facefusion.globals.face_detector_size = args.face_detector_size
+    else:
+        facefusion.globals.face_detector_size = '640x640'
+    facefusion.globals.face_detector_score = args.face_detector_score
+    facefusion.globals.face_landmarker_score = args.face_landmarker_score
+    # face selector
+    facefusion.globals.face_selector_mode = args.face_selector_mode
+    facefusion.globals.reference_face_position = args.reference_face_position
+    facefusion.globals.reference_face_distance = args.reference_face_distance
+    facefusion.globals.reference_frame_number = args.reference_frame_number
+    # face mask
+    facefusion.globals.face_mask_types = args.face_mask_types
+    facefusion.globals.face_mask_blur = args.face_mask_blur
+    facefusion.globals.face_mask_padding = normalize_padding(args.face_mask_padding)
+    facefusion.globals.face_mask_regions = args.face_mask_regions
+    # frame extraction
+    facefusion.globals.trim_frame_start = args.trim_frame_start
+    facefusion.globals.trim_frame_end = args.trim_frame_end
+    facefusion.globals.temp_frame_format = args.temp_frame_format
+    facefusion.globals.keep_temp = args.keep_temp
+    # output creation
+    facefusion.globals.output_image_quality = args.output_image_quality
+    if is_image(args.target_path):
+        output_image_resolution = detect_image_resolution(args.target_path)
+        output_image_resolutions = create_image_resolutions(output_image_resolution)
+        if args.output_image_resolution in output_image_resolutions:
+            facefusion.globals.output_image_resolution = args.output_image_resolution
+        else:
+            facefusion.globals.output_image_resolution = pack_resolution(output_image_resolution)
+    facefusion.globals.output_video_encoder = args.output_video_encoder
+    facefusion.globals.output_video_preset = args.output_video_preset
+    facefusion.globals.output_video_quality = args.output_video_quality
+    if is_video(args.target_path):
+        output_video_resolution = detect_video_resolution(args.target_path)
+        output_video_resolutions = create_video_resolutions(output_video_resolution)
+        if args.output_video_resolution in output_video_resolutions:
+            facefusion.globals.output_video_resolution = args.output_video_resolution
+        else:
+            facefusion.globals.output_video_resolution = pack_resolution(output_video_resolution)
+    if args.output_video_fps or is_video(args.target_path):
+        facefusion.globals.output_video_fps = normalize_fps(args.output_video_fps) or detect_video_fps(args.target_path)
+    facefusion.globals.skip_audio = args.skip_audio
+    # frame processors
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    modules_path = os.path.join(base_dir, "facefusion", "processors", "frame", "modules")
+    available_frame_processors = list_directory(modules_path)
+    facefusion.globals.frame_processors = args.frame_processors
+    for frame_processor in available_frame_processors:
+        frame_processor_module = load_frame_processor_module(frame_processor)
+        frame_processor_module.apply_args(program)
+    # uis
+    # facefusion.globals.open_browser = args.open_browser
+    # facefusion.globals.ui_layouts = args.ui_layouts
+
+
+def run(program: ArgumentParser) -> None:
+    validate_args(program)
+    apply_args(program)
+    logger.init(facefusion.globals.log_level)
+
+    if facefusion.globals.system_memory_limit > 0:
+        limit_system_memory(facefusion.globals.system_memory_limit)
+    if facefusion.globals.force_download:
+        force_download()
+        return
+    if not pre_check() or not content_analyser.pre_check() or not face_analyser.pre_check() or not face_masker.pre_check() or not voice_extractor.pre_check():
+        return
+    for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+        if not frame_processor_module.pre_check():
+            return
+    if facefusion.globals.headless:
+        conditional_process()
+    else:
+        conditional_process()  # Run process directly without UI
+
+
+def destroy() -> None:
+    process_manager.stop()
+    while process_manager.is_processing():
+        sleep(0.5)
+    if facefusion.globals.target_path:
+        clear_temp(facefusion.globals.target_path)
+    sys.exit(0)
+
+
+def pre_check() -> bool:
+    if sys.version_info < (3, 9):
+        logger.error(wording.get('python_not_supported').format(version='3.9'), __name__.upper())
+        return False
+    if not shutil.which('ffmpeg'):
+        logger.error(wording.get('ffmpeg_not_installed'), __name__.upper())
+        return False
+    return True
+
+
+def conditional_process() -> None:
+    start_time = time()
+    for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+        while not frame_processor_module.post_check():
+            logger.disable()
+            sleep(0.5)
+        logger.enable()
+        if not frame_processor_module.pre_process('output'):
+            return
+    conditional_append_reference_faces()
+    if is_image(facefusion.globals.target_path):
+        process_image(start_time)
+    if is_video(facefusion.globals.target_path):
+        process_video(start_time)
+
+
+def conditional_append_reference_faces() -> None:
+    if 'reference' in facefusion.globals.face_selector_mode and not get_reference_faces():
+        source_frames = read_static_images(facefusion.globals.source_paths)
+        source_face = get_average_face(source_frames)
+        if is_video(facefusion.globals.target_path):
+            reference_frame = get_video_frame(facefusion.globals.target_path, facefusion.globals.reference_frame_number)
+        else:
+            reference_frame = read_image(facefusion.globals.target_path)
+        reference_face = get_one_face(reference_frame, facefusion.globals.reference_face_position)
+        append_reference_face('origin', reference_face)
+        if source_face and reference_face:
+            for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+                abstract_reference_frame = frame_processor_module.get_reference_frame(source_face, reference_face, reference_frame)
+                if numpy.any(abstract_reference_frame):
+                    reference_frame = abstract_reference_frame
+                    reference_face = get_one_face(reference_frame, facefusion.globals.reference_face_position)
+                    append_reference_face(frame_processor_module.__name__, reference_face)
+
+
+def force_download() -> None:
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    download_directory_path = os.path.join(base_dir, "assets", "models")
+    modules_path = os.path.join(base_dir, "facefusion", "processors", "frame", "modules")
+    available_frame_processors = list_directory(modules_path)
+    model_list = [
+        content_analyser.MODELS,
+        face_analyser.MODELS,
+        face_masker.MODELS,
+        voice_extractor.MODELS
+    ]
+
+    for frame_processor_module in get_frame_processors_modules(available_frame_processors):
+        if hasattr(frame_processor_module, 'MODELS'):
+            model_list.append(frame_processor_module.MODELS)
+    model_urls = [models[model].get('url') for models in model_list for model in models]
+    conditional_download(download_directory_path, model_urls)
+
+
+def process_image(start_time: float) -> None:
+    normed_output_path = normalize_output_path(facefusion.globals.target_path, facefusion.globals.output_path)
+    if analyse_image(facefusion.globals.target_path):
+        return
+    # clear temp
+    logger.debug(wording.get('clearing_temp'), __name__.upper())
+    clear_temp(facefusion.globals.target_path)
+    # create temp
+    logger.debug(wording.get('creating_temp'), __name__.upper())
+    create_temp(facefusion.globals.target_path)
+    # copy image
+    process_manager.start()
+    temp_image_resolution = pack_resolution(restrict_image_resolution(facefusion.globals.target_path, unpack_resolution(facefusion.globals.output_image_resolution)))
+    logger.info(wording.get('copying_image').format(resolution=temp_image_resolution), __name__.upper())
+    if copy_image(facefusion.globals.target_path, temp_image_resolution):
+        logger.debug(wording.get('copying_image_succeed'), __name__.upper())
+    else:
+        logger.error(wording.get('copying_image_failed'), __name__.upper())
+        return
+    # process image
+    temp_file_path = get_temp_file_path(facefusion.globals.target_path)
+    for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+        logger.info(wording.get('processing'), frame_processor_module.NAME)
+        frame_processor_module.process_image(facefusion.globals.source_paths, temp_file_path, temp_file_path)
+        frame_processor_module.post_process()
+    if is_process_stopping():
+        return
+    # finalize image
+    logger.info(wording.get('finalizing_image').format(resolution=facefusion.globals.output_image_resolution), __name__.upper())
+    if finalize_image(facefusion.globals.target_path, normed_output_path, facefusion.globals.output_image_resolution):
+        logger.debug(wording.get('finalizing_image_succeed'), __name__.upper())
+    else:
+        logger.warn(wording.get('finalizing_image_skipped'), __name__.upper())
+    # clear temp
+    logger.debug(wording.get('clearing_temp'), __name__.upper())
+    clear_temp(facefusion.globals.target_path)
+    # validate image
+    if is_image(normed_output_path):
+        seconds = '{:.2f}'.format((time() - start_time) % 60)
+        logger.info(wording.get('processing_image_succeed').format(seconds=seconds), __name__.upper())
+        conditional_log_statistics()
+    else:
+        logger.error(wording.get('processing_image_failed'), __name__.upper())
+    process_manager.end()
+
+
+def process_video(start_time: float) -> None:
+    normed_output_path = normalize_output_path(facefusion.globals.target_path, facefusion.globals.output_path)
+    if analyse_video(facefusion.globals.target_path, facefusion.globals.trim_frame_start, facefusion.globals.trim_frame_end):
+        return
+    # clear temp
+    logger.debug(wording.get('clearing_temp'), __name__.upper())
+    clear_temp(facefusion.globals.target_path)
+    # create temp
+    logger.debug(wording.get('creating_temp'), __name__.upper())
+    create_temp(facefusion.globals.target_path)
+    # extract frames
+    process_manager.start()
+    temp_video_resolution = pack_resolution(restrict_video_resolution(facefusion.globals.target_path, unpack_resolution(facefusion.globals.output_video_resolution)))
+    temp_video_fps = restrict_video_fps(facefusion.globals.target_path, facefusion.globals.output_video_fps)
+    logger.info(wording.get('extracting_frames').format(resolution=temp_video_resolution, fps=temp_video_fps), __name__.upper())
+    if extract_frames(facefusion.globals.target_path, temp_video_resolution, temp_video_fps):
+        logger.debug(wording.get('extracting_frames_succeed'), __name__.upper())
+    else:
+        if is_process_stopping():
+            return
+        logger.error(wording.get('extracting_frames_failed'), __name__.upper())
+        return
+    # process frames
+    temp_frame_paths = get_temp_frame_paths(facefusion.globals.target_path)
+    if temp_frame_paths:
+        for frame_processor_module in get_frame_processors_modules(facefusion.globals.frame_processors):
+            logger.info(wording.get('processing'), frame_processor_module.NAME)
+            frame_processor_module.process_video(facefusion.globals.source_paths, temp_frame_paths)
+            frame_processor_module.post_process()
+        if is_process_stopping():
+            return
+    else:
+        logger.error(wording.get('temp_frames_not_found'), __name__.upper())
+        return
+    # merge video
+    logger.info(wording.get('merging_video').format(resolution=facefusion.globals.output_video_resolution, fps=facefusion.globals.output_video_fps), __name__.upper())
+    if merge_video(facefusion.globals.target_path, facefusion.globals.output_video_resolution, facefusion.globals.output_video_fps):
+        logger.debug(wording.get('merging_video_succeed'), __name__.upper())
+    else:
+        if is_process_stopping():
+            return
+        logger.error(wording.get('merging_video_failed'), __name__.upper())
+        return
+    # handle audio
+    if facefusion.globals.skip_audio:
+        logger.info(wording.get('skipping_audio'), __name__.upper())
+        move_temp(facefusion.globals.target_path, normed_output_path)
+    else:
+        if 'lip_syncer' in facefusion.globals.frame_processors:
+            source_audio_path = get_first(filter_audio_paths(facefusion.globals.source_paths))
+            if source_audio_path and replace_audio(facefusion.globals.target_path, source_audio_path, normed_output_path):
+                logger.debug(wording.get('restoring_audio_succeed'), __name__.upper())
+            else:
+                if is_process_stopping():
+                    return
+                logger.warn(wording.get('restoring_audio_skipped'), __name__.upper())
+                move_temp(facefusion.globals.target_path, normed_output_path)
+        else:
+            if restore_audio(facefusion.globals.target_path, normed_output_path, facefusion.globals.output_video_fps):
+                logger.debug(wording.get('restoring_audio_succeed'), __name__.upper())
+            else:
+                if is_process_stopping():
+                    return
+                logger.warn(wording.get('restoring_audio_skipped'), __name__.upper())
+                move_temp(facefusion.globals.target_path, normed_output_path)
+    # clear temp
+    logger.debug(wording.get('clearing_temp'), __name__.upper())
+    clear_temp(facefusion.globals.target_path)
+    # validate video
+    if is_video(normed_output_path):
+        seconds = '{:.2f}'.format((time() - start_time))
+        logger.info(wording.get('processing_video_succeed').format(seconds=seconds), __name__.upper())
+        conditional_log_statistics()
+    else:
+        logger.error(wording.get('processing_video_failed'), __name__.upper())
+    process_manager.end()
+
+
+def is_process_stopping() -> bool:
+    if process_manager.is_stopping():
+        process_manager.end()
+        logger.info(wording.get('processing_stopped'), __name__.upper())
+    return process_manager.is_pending()
+
+
+if __name__ == "__main__":
+    cli()

facefusion/facefusion.ini

@@ -0,0 +1,74 @@
+[general]
+source_paths =
+target_path =
+output_path =
+
+[misc]
+force_download =
+skip_download =
+headless =
+log_level =
+
+[execution]
+execution_device_id =
+execution_providers =
+execution_thread_count =
+execution_queue_count =
+
+[memory]
+video_memory_strategy =
+system_memory_limit =
+
+[face_analyser]
+face_analyser_order =
+face_analyser_age =
+face_analyser_gender =
+face_detector_model =
+face_detector_size =
+face_detector_score =
+face_landmarker_score =
+
+[face_selector]
+face_selector_mode =
+reference_face_position =
+reference_face_distance =
+reference_frame_number =
+
+[face_mask]
+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_video_encoder =
+output_video_preset =
+output_video_quality =
+output_video_resolution =
+output_video_fps =
+skip_audio =
+
+[frame_processors]
+frame_processors =
+face_debugger_items =
+face_enhancer_model =
+face_enhancer_blend =
+face_swapper_model =
+frame_colorizer_model =
+frame_colorizer_blend =
+frame_colorizer_size =
+frame_enhancer_model =
+frame_enhancer_blend =
+lip_syncer_model =
+
+[uis]
+open_browser =
+ui_layouts =

facefusion/facefusion/audio.py

@@ -0,0 +1,137 @@
+from typing import Optional, Any, List
+from functools import lru_cache
+import numpy
+import scipy
+
+from facefusion.filesystem import is_audio
+from facefusion.ffmpeg import read_audio_buffer
+from facefusion.my_typing import Fps, Audio, AudioFrame, Spectrogram, MelFilterBank
+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 = 1024 * 240
+	step_size = 1024 * 180
+
+	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 : numpy.ndarray[Any, Any]) -> 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 : numpy.ndarray[Any, Any]) -> 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 : numpy.ndarray[Any, Any]) -> numpy.ndarray[Any, 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/facefusion/choices.py

@@ -0,0 +1,37 @@
+from typing import List, Dict
+
+from facefusion.my_typing import VideoMemoryStrategy, FaceSelectorMode, FaceAnalyserOrder, FaceAnalyserAge, FaceAnalyserGender, FaceDetectorModel, FaceMaskType, FaceMaskRegion, TempFrameFormat, OutputVideoEncoder, OutputVideoPreset
+from facefusion.common_helper import create_int_range, create_float_range
+
+video_memory_strategies : List[VideoMemoryStrategy] = [ 'strict', 'moderate', 'tolerant' ]
+face_analyser_orders : List[FaceAnalyserOrder] = [ 'left-right', 'right-left', 'top-bottom', 'bottom-top', 'small-large', 'large-small', 'best-worst', 'worst-best' ]
+face_analyser_ages : List[FaceAnalyserAge] = [ 'child', 'teen', 'adult', 'senior' ]
+face_analyser_genders : List[FaceAnalyserGender] = [ 'female', 'male' ]
+face_detector_set : Dict[FaceDetectorModel, List[str]] =\
+{
+	'many': [ '640x640' ],
+	'retinaface': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'scrfd': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
+	'yoloface': [ '640x640' ],
+	'yunet': [ '160x160', '320x320', '480x480', '512x512', '640x640', '768x768', '960x960', '1024x1024' ]
+}
+face_selector_modes : List[FaceSelectorMode] = [ 'many', 'one', 'reference' ]
+face_mask_types : List[FaceMaskType] = [ 'box', 'occlusion', 'region' ]
+face_mask_regions : List[FaceMaskRegion] = [ 'skin', 'left-eyebrow', 'right-eyebrow', 'left-eye', 'right-eye', 'glasses', 'nose', 'mouth', 'upper-lip', 'lower-lip' ]
+temp_frame_formats : List[TempFrameFormat] = [ 'bmp', 'jpg', 'png' ]
+output_video_encoders : List[OutputVideoEncoder] = [ 'libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf' ]
+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_thread_count_range : List[int] = create_int_range(1, 128, 1)
+execution_queue_count_range : List[int] = create_int_range(1, 32, 1)
+system_memory_limit_range : List[int] = create_int_range(0, 128, 1)
+face_detector_score_range : List[float] = create_float_range(0.0, 1.0, 0.05)
+face_landmarker_score_range : List[float] = create_float_range(0.0, 1.0, 0.05)
+face_mask_blur_range : List[float] = create_float_range(0.0, 1.0, 0.05)
+face_mask_padding_range : List[int] = create_int_range(0, 100, 1)
+reference_face_distance_range : List[float] = create_float_range(0.0, 1.5, 0.05)
+output_image_quality_range : List[int] = create_int_range(0, 100, 1)
+output_video_quality_range : List[int] = create_int_range(0, 100, 1)

facefusion/facefusion/common_helper.py

@@ -0,0 +1,46 @@
+from typing import List, Any
+import platform
+
+
+def create_metavar(ranges : List[Any]) -> str:
+	return '[' + str(ranges[0]) + '-' + str(ranges[-1]) + ']'
+
+
+def create_int_range(start : int, end : int, step : int) -> List[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) -> List[float]:
+	float_range = []
+	current = start
+
+	while current <= end:
+		float_range.append(round(current, 2))
+		current = round(current + step, 2)
+	return float_range
+
+
+def is_linux() -> bool:
+	return to_lower_case(platform.system()) == 'linux'
+
+
+def is_macos() -> bool:
+	return to_lower_case(platform.system()) == 'darwin'
+
+
+def is_windows() -> bool:
+	return to_lower_case(platform.system()) == 'windows'
+
+
+def to_lower_case(__string__ : Any) -> str:
+	return str(__string__).lower()
+
+
+def get_first(__list__ : Any) -> Any:
+	return next(iter(__list__), None)

facefusion/facefusion/config.py

@@ -0,0 +1,91 @@
+from configparser import ConfigParser
+from typing import Any, Optional, List
+
+import facefusion.globals
+
+CONFIG = None
+
+
+def get_config() -> ConfigParser:
+	global CONFIG
+
+	if CONFIG is None:
+		CONFIG = ConfigParser()
+		CONFIG.read(facefusion.globals.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 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 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 [ 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 [ 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/facefusion/content_analyser.py

@@ -0,0 +1,112 @@
+from typing import Any
+from functools import lru_cache
+from time import sleep
+import cv2
+import numpy
+import onnxruntime
+from tqdm import tqdm
+
+import facefusion.globals
+from facefusion import process_manager, wording
+from facefusion.thread_helper import thread_lock, conditional_thread_semaphore
+from facefusion.my_typing import VisionFrame, ModelSet, Fps
+from facefusion.execution import apply_execution_provider_options
+from facefusion.vision import get_video_frame, count_video_frame_total, read_image, detect_video_fps
+from facefusion.filesystem import resolve_relative_path, is_file
+from facefusion.download import conditional_download
+
+CONTENT_ANALYSER = None
+MODELS : ModelSet =\
+{
+	'open_nsfw':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/open_nsfw.onnx',
+		'path': resolve_relative_path('../.assets/models/open_nsfw.onnx')
+	}
+}
+PROBABILITY_LIMIT = 0.80
+RATE_LIMIT = 10
+STREAM_COUNTER = 0
+
+
+def get_content_analyser() -> Any:
+	global CONTENT_ANALYSER
+
+	with thread_lock():
+		while process_manager.is_checking():
+			sleep(0.5)
+		if CONTENT_ANALYSER is None:
+			model_path = MODELS.get('open_nsfw').get('path')
+			CONTENT_ANALYSER = onnxruntime.InferenceSession(model_path, providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+	return CONTENT_ANALYSER
+
+
+def clear_content_analyser() -> None:
+	global CONTENT_ANALYSER
+
+	CONTENT_ANALYSER = None
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_url = MODELS.get('open_nsfw').get('url')
+	model_path = MODELS.get('open_nsfw').get('path')
+
+	if not facefusion.globals.skip_download:
+		process_manager.check()
+		conditional_download(download_directory_path, [ model_url ])
+		process_manager.end()
+	return is_file(model_path)
+
+
+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:
+	content_analyser = get_content_analyser()
+	vision_frame = prepare_frame(vision_frame)
+	with conditional_thread_semaphore(facefusion.globals.execution_providers):
+		probability = content_analyser.run(None,
+		{
+			content_analyser.get_inputs()[0].name: vision_frame
+		})[0][0][1]
+	return probability > PROBABILITY_LIMIT
+
+
+def prepare_frame(vision_frame : VisionFrame) -> VisionFrame:
+	vision_frame = cv2.resize(vision_frame, (224, 224)).astype(numpy.float32)
+	vision_frame -= numpy.array([ 104, 117, 123 ]).astype(numpy.float32)
+	vision_frame = numpy.expand_dims(vision_frame, axis = 0)
+	return vision_frame
+
+
+@lru_cache(maxsize = None)
+def analyse_image(image_path : str) -> bool:
+	frame = read_image(image_path)
+	return analyse_frame(frame)
+
+
+@lru_cache(maxsize = None)
+def analyse_video(video_path : str, start_frame : int, end_frame : int) -> bool:
+	video_frame_total = count_video_frame_total(video_path)
+	video_fps = detect_video_fps(video_path)
+	frame_range = range(start_frame or 0, end_frame or video_frame_total)
+	rate = 0.0
+	counter = 0
+
+	with tqdm(total = len(frame_range), desc = wording.get('analysing'), unit = 'frame', ascii = ' =', disable = facefusion.globals.log_level in [ 'warn', 'error' ]) as progress:
+		for frame_number in frame_range:
+			if frame_number % int(video_fps) == 0:
+				frame = get_video_frame(video_path, frame_number)
+				if analyse_frame(frame):
+					counter += 1
+			rate = counter * int(video_fps) / len(frame_range) * 100
+			progress.update()
+			progress.set_postfix(rate = rate)
+	return rate > RATE_LIMIT

facefusion/facefusion/download.py

@@ -0,0 +1,48 @@
+import os
+import subprocess
+import ssl
+import urllib.request
+from typing import List
+from functools import lru_cache
+from tqdm import tqdm
+
+import facefusion.globals
+from facefusion import wording
+from facefusion.common_helper import is_macos
+from facefusion.filesystem import get_file_size, is_file
+
+if is_macos():
+	ssl._create_default_https_context = ssl._create_unverified_context
+
+
+def conditional_download(download_directory_path : str, urls : List[str]) -> None:
+	for url in urls:
+		download_file_path = os.path.join(download_directory_path, os.path.basename(url))
+		initial_size = get_file_size(download_file_path)
+		download_size = get_download_size(url)
+		if initial_size < download_size:
+			with tqdm(total = download_size, initial = initial_size, desc = wording.get('downloading'), unit = 'B', unit_scale = True, unit_divisor = 1024, ascii = ' =', disable = facefusion.globals.log_level in [ 'warn', 'error' ]) as progress:
+				subprocess.Popen([ 'curl', '--create-dirs', '--silent', '--insecure', '--location', '--continue-at', '-', '--output', download_file_path, url ])
+				current_size = initial_size
+				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)
+		if download_size and not is_download_done(url, download_file_path):
+			os.remove(download_file_path)
+			conditional_download(download_directory_path, [ url ])
+
+
+@lru_cache(maxsize = None)
+def get_download_size(url : str) -> int:
+	try:
+		response = urllib.request.urlopen(url, timeout = 10)
+		return int(response.getheader('Content-Length'))
+	except (OSError, ValueError):
+		return 0
+
+
+def is_download_done(url : str, file_path : str) -> bool:
+	if is_file(file_path):
+		return get_download_size(url) == get_file_size(file_path)
+	return False

facefusion/facefusion/execution.py

@@ -0,0 +1,112 @@
+from typing import List, Any
+from functools import lru_cache
+import subprocess
+import xml.etree.ElementTree as ElementTree
+import onnxruntime
+
+from facefusion.my_typing import ExecutionDevice, ValueAndUnit
+
+
+def encode_execution_providers(execution_providers : List[str]) -> List[str]:
+	return [ execution_provider.replace('ExecutionProvider', '').lower() for execution_provider in execution_providers ]
+
+
+def decode_execution_providers(execution_providers : List[str]) -> List[str]:
+	available_execution_providers = onnxruntime.get_available_providers()
+	encoded_execution_providers = encode_execution_providers(available_execution_providers)
+
+	return [ execution_provider for execution_provider, encoded_execution_provider in zip(available_execution_providers, encoded_execution_providers) if any(execution_provider in encoded_execution_provider for execution_provider in execution_providers) ]
+
+
+def has_execution_provider(execution_provider : str) -> bool:
+	return execution_provider in onnxruntime.get_available_providers()
+
+
+def apply_execution_provider_options(execution_device_id : str, execution_providers : List[str]) -> List[Any]:
+	execution_providers_with_options : List[Any] = []
+
+	for execution_provider in execution_providers:
+		if execution_provider == 'CUDAExecutionProvider':
+			execution_providers_with_options.append((execution_provider,
+			{
+				'device_id': execution_device_id,
+				'cudnn_conv_algo_search': 'EXHAUSTIVE' if use_exhaustive() else 'DEFAULT'
+			}))
+		elif execution_provider == 'OpenVINOExecutionProvider':
+			execution_providers_with_options.append((execution_provider,
+			{
+				'device_id': execution_device_id,
+				'device_type': execution_device_id + '_FP32'
+			}))
+		elif execution_provider in [ 'DmlExecutionProvider', 'ROCMExecutionProvider' ]:
+			execution_providers_with_options.append((execution_provider,
+			{
+				'device_id': execution_device_id
+			}))
+		else:
+			execution_providers_with_options.append(execution_provider)
+	return execution_providers_with_options
+
+
+def use_exhaustive() -> bool:
+	execution_devices = detect_static_execution_devices()
+	product_names = ('GeForce GTX 1630', 'GeForce GTX 1650', 'GeForce GTX 1660')
+
+	return any(execution_device.get('product').get('name').startswith(product_names) for execution_device in execution_devices)
+
+
+def run_nvidia_smi() -> subprocess.Popen[bytes]:
+	commands = [ 'nvidia-smi', '--query', '--xml-format' ]
+	return subprocess.Popen(commands, stdout = subprocess.PIPE)
+
+
+@lru_cache(maxsize = None)
+def detect_static_execution_devices() -> List[ExecutionDevice]:
+	return detect_execution_devices()
+
+
+def detect_execution_devices() -> List[ExecutionDevice]:
+	execution_devices : List[ExecutionDevice] = []
+	try:
+		output, _ = run_nvidia_smi().communicate()
+		root_element = ElementTree.fromstring(output)
+	except Exception:
+		root_element = ElementTree.Element('xml')
+
+	for gpu_element in root_element.findall('gpu'):
+		execution_devices.append(
+		{
+			'driver_version': root_element.find('driver_version').text,
+			'framework':
+			{
+				'name': 'CUDA',
+				'version': root_element.find('cuda_version').text
+			},
+			'product':
+			{
+				'vendor': 'NVIDIA',
+				'name': gpu_element.find('product_name').text.replace('NVIDIA ', '')
+			},
+			'video_memory':
+			{
+				'total': create_value_and_unit(gpu_element.find('fb_memory_usage/total').text),
+				'free': create_value_and_unit(gpu_element.find('fb_memory_usage/free').text)
+			},
+			'utilization':
+			{
+				'gpu': create_value_and_unit(gpu_element.find('utilization/gpu_util').text),
+				'memory': create_value_and_unit(gpu_element.find('utilization/memory_util').text)
+			}
+		})
+	return execution_devices
+
+
+def create_value_and_unit(text : str) -> ValueAndUnit:
+	value, unit = text.split()
+	value_and_unit : ValueAndUnit =\
+	{
+		'value': value,
+		'unit': unit
+	}
+
+	return value_and_unit

facefusion/facefusion/face_analyser.py

@@ -0,0 +1,586 @@
+from typing import Any, Optional, List, Tuple
+from time import sleep
+import cv2
+import numpy
+import onnxruntime
+
+import facefusion.globals
+from facefusion import process_manager
+from facefusion.common_helper import get_first
+from facefusion.face_helper import estimate_matrix_by_face_landmark_5, warp_face_by_face_landmark_5, warp_face_by_translation, create_static_anchors, distance_to_face_landmark_5, distance_to_bounding_box, convert_face_landmark_68_to_5, apply_nms, categorize_age, categorize_gender
+from facefusion.face_store import get_static_faces, set_static_faces
+from facefusion.execution import apply_execution_provider_options
+from facefusion.download import conditional_download
+from facefusion.filesystem import resolve_relative_path, is_file
+from facefusion.thread_helper import thread_lock, thread_semaphore, conditional_thread_semaphore
+from facefusion.my_typing import VisionFrame, Face, FaceSet, FaceAnalyserOrder, FaceAnalyserAge, FaceAnalyserGender, ModelSet, BoundingBox, FaceLandmarkSet, FaceLandmark5, FaceLandmark68, Score, FaceScoreSet, Embedding
+from facefusion.vision import resize_frame_resolution, unpack_resolution
+
+FACE_ANALYSER = None
+MODELS : ModelSet =\
+{
+	'face_detector_retinaface':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/retinaface_10g.onnx',
+		'path': resolve_relative_path('../.assets/models/retinaface_10g.onnx')
+	},
+	'face_detector_scrfd':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/scrfd_2.5g.onnx',
+		'path': resolve_relative_path('../.assets/models/scrfd_2.5g.onnx')
+	},
+	'face_detector_yoloface':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/yoloface_8n.onnx',
+		'path': resolve_relative_path('../.assets/models/yoloface_8n.onnx')
+	},
+	'face_detector_yunet':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/yunet_2023mar.onnx',
+		'path': resolve_relative_path('../.assets/models/yunet_2023mar.onnx')
+	},
+	'face_recognizer_arcface_blendswap':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_w600k_r50.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.onnx')
+	},
+	'face_recognizer_arcface_inswapper':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_w600k_r50.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.onnx')
+	},
+	'face_recognizer_arcface_simswap':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_simswap.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_simswap.onnx')
+	},
+	'face_recognizer_arcface_uniface':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/arcface_w600k_r50.onnx',
+		'path': resolve_relative_path('../.assets/models/arcface_w600k_r50.onnx')
+	},
+	'face_landmarker_68':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/2dfan4.onnx',
+		'path': resolve_relative_path('../.assets/models/2dfan4.onnx')
+	},
+	'face_landmarker_68_5':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/face_landmarker_68_5.onnx',
+		'path': resolve_relative_path('../.assets/models/face_landmarker_68_5.onnx')
+	},
+	'gender_age':
+	{
+		'url': 'https://github.com/facefusion/facefusion-assets/releases/download/models/gender_age.onnx',
+		'path': resolve_relative_path('../.assets/models/gender_age.onnx')
+	}
+}
+
+
+def get_face_analyser() -> Any:
+	global FACE_ANALYSER
+
+	face_detectors = {}
+	face_landmarkers = {}
+
+	with thread_lock():
+		while process_manager.is_checking():
+			sleep(0.5)
+		if FACE_ANALYSER is None:
+			if facefusion.globals.face_detector_model in [ 'many', 'retinaface' ]:
+				face_detectors['retinaface'] = onnxruntime.InferenceSession(MODELS.get('face_detector_retinaface').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			if facefusion.globals.face_detector_model in [ 'many', 'scrfd' ]:
+				face_detectors['scrfd'] = onnxruntime.InferenceSession(MODELS.get('face_detector_scrfd').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			if facefusion.globals.face_detector_model in [ 'many', 'yoloface' ]:
+				face_detectors['yoloface'] = onnxruntime.InferenceSession(MODELS.get('face_detector_yoloface').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			if facefusion.globals.face_detector_model in [ 'yunet' ]:
+				face_detectors['yunet'] = cv2.FaceDetectorYN.create(MODELS.get('face_detector_yunet').get('path'), '', (0, 0))
+			if facefusion.globals.face_recognizer_model == 'arcface_blendswap':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_blendswap').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			if facefusion.globals.face_recognizer_model == 'arcface_inswapper':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_inswapper').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			if facefusion.globals.face_recognizer_model == 'arcface_simswap':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_simswap').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			if facefusion.globals.face_recognizer_model == 'arcface_uniface':
+				face_recognizer = onnxruntime.InferenceSession(MODELS.get('face_recognizer_arcface_uniface').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			face_landmarkers['68'] = onnxruntime.InferenceSession(MODELS.get('face_landmarker_68').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			face_landmarkers['68_5'] = onnxruntime.InferenceSession(MODELS.get('face_landmarker_68_5').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			gender_age = onnxruntime.InferenceSession(MODELS.get('gender_age').get('path'), providers = apply_execution_provider_options(facefusion.globals.execution_device_id, facefusion.globals.execution_providers))
+			FACE_ANALYSER =\
+			{
+				'face_detectors': face_detectors,
+				'face_recognizer': face_recognizer,
+				'face_landmarkers': face_landmarkers,
+				'gender_age': gender_age
+			}
+	return FACE_ANALYSER
+
+
+def clear_face_analyser() -> Any:
+	global FACE_ANALYSER
+
+	FACE_ANALYSER = None
+
+
+def pre_check() -> bool:
+	download_directory_path = resolve_relative_path('../.assets/models')
+	model_urls =\
+	[
+		MODELS.get('face_landmarker_68').get('url'),
+		MODELS.get('face_landmarker_68_5').get('url'),
+		MODELS.get('gender_age').get('url')
+	]
+	model_paths =\
+	[
+		MODELS.get('face_landmarker_68').get('path'),
+		MODELS.get('face_landmarker_68_5').get('path'),
+		MODELS.get('gender_age').get('path')
+	]
+
+	if facefusion.globals.face_detector_model in [ 'many', 'retinaface' ]:
+		model_urls.append(MODELS.get('face_detector_retinaface').get('url'))
+		model_paths.append(MODELS.get('face_detector_retinaface').get('path'))
+	if facefusion.globals.face_detector_model in [ 'many', 'scrfd' ]:
+		model_urls.append(MODELS.get('face_detector_scrfd').get('url'))
+		model_paths.append(MODELS.get('face_detector_scrfd').get('path'))
+	if facefusion.globals.face_detector_model in [ 'many', 'yoloface' ]:
+		model_urls.append(MODELS.get('face_detector_yoloface').get('url'))
+		model_paths.append(MODELS.get('face_detector_yoloface').get('path'))
+	if facefusion.globals.face_detector_model in [ 'yunet' ]:
+		model_urls.append(MODELS.get('face_detector_yunet').get('url'))
+		model_paths.append(MODELS.get('face_detector_yunet').get('path'))
+	if facefusion.globals.face_recognizer_model == 'arcface_blendswap':
+		model_urls.append(MODELS.get('face_recognizer_arcface_blendswap').get('url'))
+		model_paths.append(MODELS.get('face_recognizer_arcface_blendswap').get('path'))
+	if facefusion.globals.face_recognizer_model == 'arcface_inswapper':
+		model_urls.append(MODELS.get('face_recognizer_arcface_inswapper').get('url'))
+		model_paths.append(MODELS.get('face_recognizer_arcface_inswapper').get('path'))
+	if facefusion.globals.face_recognizer_model == 'arcface_simswap':
+		model_urls.append(MODELS.get('face_recognizer_arcface_simswap').get('url'))
+		model_paths.append(MODELS.get('face_recognizer_arcface_simswap').get('path'))
+	if facefusion.globals.face_recognizer_model == 'arcface_uniface':
+		model_urls.append(MODELS.get('face_recognizer_arcface_uniface').get('url'))
+		model_paths.append(MODELS.get('face_recognizer_arcface_uniface').get('path'))
+
+	if not facefusion.globals.skip_download:
+		process_manager.check()
+		conditional_download(download_directory_path, model_urls)
+		process_manager.end()
+	return all(is_file(model_path) for model_path in model_paths)
+
+
+def detect_with_retinaface(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[FaceLandmark5], List[Score]]:
+	face_detector = get_face_analyser().get('face_detectors').get('retinaface')
+	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]
+	feature_strides = [ 8, 16, 32 ]
+	feature_map_channel = 3
+	anchor_total = 2
+	bounding_box_list = []
+	face_landmark_5_list = []
+	score_list = []
+
+	detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
+	with thread_semaphore():
+		detections = face_detector.run(None,
+		{
+			face_detector.get_inputs()[0].name: detect_vision_frame
+		})
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detections[index] >= facefusion.globals.face_detector_score)[0]
+		if keep_indices.any():
+			stride_height = face_detector_height // feature_stride
+			stride_width = face_detector_width // feature_stride
+			anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
+			bounding_box_raw = detections[index + feature_map_channel] * feature_stride
+			face_landmark_5_raw = detections[index + feature_map_channel * 2] * feature_stride
+			for bounding_box in distance_to_bounding_box(anchors, bounding_box_raw)[keep_indices]:
+				bounding_box_list.append(numpy.array(
+				[
+					bounding_box[0] * ratio_width,
+					bounding_box[1] * ratio_height,
+					bounding_box[2] * ratio_width,
+					bounding_box[3] * ratio_height
+				]))
+			for face_landmark_5 in distance_to_face_landmark_5(anchors, face_landmark_5_raw)[keep_indices]:
+				face_landmark_5_list.append(face_landmark_5 * [ ratio_width, ratio_height ])
+			for score in detections[index][keep_indices]:
+				score_list.append(score[0])
+	return bounding_box_list, face_landmark_5_list, score_list
+
+
+def detect_with_scrfd(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[FaceLandmark5], List[Score]]:
+	face_detector = get_face_analyser().get('face_detectors').get('scrfd')
+	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]
+	feature_strides = [ 8, 16, 32 ]
+	feature_map_channel = 3
+	anchor_total = 2
+	bounding_box_list = []
+	face_landmark_5_list = []
+	score_list = []
+
+	detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
+	with thread_semaphore():
+		detections = face_detector.run(None,
+		{
+			face_detector.get_inputs()[0].name: detect_vision_frame
+		})
+	for index, feature_stride in enumerate(feature_strides):
+		keep_indices = numpy.where(detections[index] >= facefusion.globals.face_detector_score)[0]
+		if keep_indices.any():
+			stride_height = face_detector_height // feature_stride
+			stride_width = face_detector_width // feature_stride
+			anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
+			bounding_box_raw = detections[index + feature_map_channel] * feature_stride
+			face_landmark_5_raw = detections[index + feature_map_channel * 2] * feature_stride
+			for bounding_box in distance_to_bounding_box(anchors, bounding_box_raw)[keep_indices]:
+				bounding_box_list.append(numpy.array(
+				[
+					bounding_box[0] * ratio_width,
+					bounding_box[1] * ratio_height,
+					bounding_box[2] * ratio_width,
+					bounding_box[3] * ratio_height
+				]))
+			for face_landmark_5 in distance_to_face_landmark_5(anchors, face_landmark_5_raw)[keep_indices]:
+				face_landmark_5_list.append(face_landmark_5 * [ ratio_width, ratio_height ])
+			for score in detections[index][keep_indices]:
+				score_list.append(score[0])
+	return bounding_box_list, face_landmark_5_list, score_list
+
+
+def detect_with_yoloface(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[FaceLandmark5], List[Score]]:
+	face_detector = get_face_analyser().get('face_detectors').get('yoloface')
+	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]
+	bounding_box_list = []
+	face_landmark_5_list = []
+	score_list = []
+
+	detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
+	with thread_semaphore():
+		detections = face_detector.run(None,
+		{
+			face_detector.get_inputs()[0].name: detect_vision_frame
+		})
+	detections = numpy.squeeze(detections).T
+	bounding_box_raw, score_raw, face_landmark_5_raw = numpy.split(detections, [ 4, 5 ], axis = 1)
+	keep_indices = numpy.where(score_raw > facefusion.globals.face_detector_score)[0]
+	if keep_indices.any():
+		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_box_list.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_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_landmark_5_list.append(numpy.array(face_landmark_5.reshape(-1, 3)[:, :2]))
+		score_list = score_raw.ravel().tolist()
+	return bounding_box_list, face_landmark_5_list, score_list
+
+
+def detect_with_yunet(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[FaceLandmark5], List[Score]]:
+	face_detector = get_face_analyser().get('face_detectors').get('yunet')
+	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]
+	bounding_box_list = []
+	face_landmark_5_list = []
+	score_list = []
+
+	face_detector.setInputSize((temp_vision_frame.shape[1], temp_vision_frame.shape[0]))
+	face_detector.setScoreThreshold(facefusion.globals.face_detector_score)
+	with thread_semaphore():
+		_, detections = face_detector.detect(temp_vision_frame)
+	if numpy.any(detections):
+		for detection in detections:
+			bounding_box_list.append(numpy.array(
+			[
+				detection[0] * ratio_width,
+				detection[1] * ratio_height,
+				(detection[0] + detection[2]) * ratio_width,
+				(detection[1] + detection[3]) * ratio_height
+			]))
+			face_landmark_5_list.append(detection[4:14].reshape((5, 2)) * [ ratio_width, ratio_height ])
+			score_list.append(detection[14])
+	return bounding_box_list, face_landmark_5_list, score_list
+
+
+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
+
+
+def create_faces(vision_frame : VisionFrame, bounding_box_list : List[BoundingBox], face_landmark_5_list : List[FaceLandmark5], score_list : List[Score]) -> List[Face]:
+	faces = []
+	if facefusion.globals.face_detector_score > 0:
+		sort_indices = numpy.argsort(-numpy.array(score_list))
+		bounding_box_list = [ bounding_box_list[index] for index in sort_indices ]
+		face_landmark_5_list = [face_landmark_5_list[index] for index in sort_indices]
+		score_list = [ score_list[index] for index in sort_indices ]
+		iou_threshold = 0.1 if facefusion.globals.face_detector_model == 'many' else 0.4
+		keep_indices = apply_nms(bounding_box_list, iou_threshold)
+		for index in keep_indices:
+			bounding_box = bounding_box_list[index]
+			face_landmark_5_68 = face_landmark_5_list[index]
+			face_landmark_68_5 = expand_face_landmark_68_from_5(face_landmark_5_68)
+			face_landmark_68 = face_landmark_68_5
+			face_landmark_68_score = 0.0
+			if facefusion.globals.face_landmarker_score > 0:
+				face_landmark_68, face_landmark_68_score = detect_face_landmark_68(vision_frame, bounding_box)
+				if face_landmark_68_score > facefusion.globals.face_landmarker_score:
+					face_landmark_5_68 = convert_face_landmark_68_to_5(face_landmark_68)
+			landmarks : FaceLandmarkSet =\
+			{
+				'5': face_landmark_5_list[index],
+				'5/68': face_landmark_5_68,
+				'68': face_landmark_68,
+				'68/5': face_landmark_68_5
+			}
+			scores : FaceScoreSet = \
+			{
+				'detector': score_list[index],
+				'landmarker': face_landmark_68_score
+			}
+			embedding, normed_embedding = calc_embedding(vision_frame, landmarks.get('5/68'))
+			gender, age = detect_gender_age(vision_frame, bounding_box)
+			faces.append(Face(
+				bounding_box = bounding_box,
+				landmarks = landmarks,
+				scores = scores,
+				embedding = embedding,
+				normed_embedding = normed_embedding,
+				gender = gender,
+				age = age
+			))
+	return faces
+
+
+def calc_embedding(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Embedding, Embedding]:
+	face_recognizer = get_face_analyser().get('face_recognizer')
+	crop_vision_frame, matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, 'arcface_112_v2', (112, 112))
+	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)
+	with conditional_thread_semaphore(facefusion.globals.execution_providers):
+		embedding = face_recognizer.run(None,
+		{
+			face_recognizer.get_inputs()[0].name: crop_vision_frame
+		})[0]
+	embedding = embedding.ravel()
+	normed_embedding = embedding / numpy.linalg.norm(embedding)
+	return embedding, normed_embedding
+
+
+def detect_face_landmark_68(temp_vision_frame : VisionFrame, bounding_box : BoundingBox) -> Tuple[FaceLandmark68, Score]:
+	face_landmarker = get_face_analyser().get('face_landmarkers').get('68')
+	scale = 195 / numpy.subtract(bounding_box[2:], bounding_box[:2]).max()
+	translation = (256 - numpy.add(bounding_box[2:], bounding_box[:2]) * scale) * 0.5
+	crop_vision_frame, affine_matrix = warp_face_by_translation(temp_vision_frame, translation, scale, (256, 256))
+	crop_vision_frame = cv2.cvtColor(crop_vision_frame, cv2.COLOR_RGB2Lab)
+	if numpy.mean(crop_vision_frame[:, :, 0]) < 30:
+		crop_vision_frame[:, :, 0] = cv2.createCLAHE(clipLimit = 2).apply(crop_vision_frame[:, :, 0])
+	crop_vision_frame = cv2.cvtColor(crop_vision_frame, cv2.COLOR_Lab2RGB)
+	crop_vision_frame = crop_vision_frame.transpose(2, 0, 1).astype(numpy.float32) / 255.0
+	with conditional_thread_semaphore(facefusion.globals.execution_providers):
+		face_landmark_68, face_heatmap = face_landmarker.run(None,
+		{
+			face_landmarker.get_inputs()[0].name: [ crop_vision_frame ]
+		})
+	face_landmark_68 = face_landmark_68[:, :, :2][0] / 64
+	face_landmark_68 = face_landmark_68.reshape(1, -1, 2) * 256
+	face_landmark_68 = cv2.transform(face_landmark_68, cv2.invertAffineTransform(affine_matrix))
+	face_landmark_68 = face_landmark_68.reshape(-1, 2)
+	face_landmark_68_score = numpy.amax(face_heatmap, axis = (2, 3))
+	face_landmark_68_score = numpy.mean(face_landmark_68_score)
+	return face_landmark_68, face_landmark_68_score
+
+
+def expand_face_landmark_68_from_5(face_landmark_5 : FaceLandmark5) -> FaceLandmark68:
+	face_landmarker = get_face_analyser().get('face_landmarkers').get('68_5')
+	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)
+	with conditional_thread_semaphore(facefusion.globals.execution_providers):
+		face_landmark_68_5 = face_landmarker.run(None,
+		{
+			face_landmarker.get_inputs()[0].name: [ face_landmark_5 ]
+		})[0][0]
+	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 detect_gender_age(temp_vision_frame : VisionFrame, bounding_box : BoundingBox) -> Tuple[int, int]:
+	gender_age = get_face_analyser().get('gender_age')
+	bounding_box = bounding_box.reshape(2, -1)
+	scale = 64 / numpy.subtract(*bounding_box[::-1]).max()
+	translation = 48 - bounding_box.sum(axis = 0) * scale * 0.5
+	crop_vision_frame, affine_matrix = warp_face_by_translation(temp_vision_frame, translation, scale, (96, 96))
+	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)
+	with conditional_thread_semaphore(facefusion.globals.execution_providers):
+		prediction = gender_age.run(None,
+		{
+			gender_age.get_inputs()[0].name: crop_vision_frame
+		})[0][0]
+	gender = int(numpy.argmax(prediction[:2]))
+	age = int(numpy.round(prediction[2] * 100))
+	return gender, age
+
+
+def get_one_face(vision_frame : VisionFrame, position : int = 0) -> Optional[Face]:
+	many_faces = get_many_faces(vision_frame)
+	if many_faces:
+		try:
+			return many_faces[position]
+		except IndexError:
+			return many_faces[-1]
+	return None
+
+
+def get_average_face(vision_frames : List[VisionFrame], position : int = 0) -> Optional[Face]:
+	average_face = None
+	faces = []
+	embedding_list = []
+	normed_embedding_list = []
+
+	for vision_frame in vision_frames:
+		face = get_one_face(vision_frame, position)
+		if face:
+			faces.append(face)
+			embedding_list.append(face.embedding)
+			normed_embedding_list.append(face.normed_embedding)
+	if faces:
+		first_face = get_first(faces)
+		average_face = Face(
+			bounding_box = first_face.bounding_box,
+			landmarks = first_face.landmarks,
+			scores = first_face.scores,
+			embedding = numpy.mean(embedding_list, axis = 0),
+			normed_embedding = numpy.mean(normed_embedding_list, axis = 0),
+			gender = first_face.gender,
+			age = first_face.age
+		)
+	return average_face
+
+
+def get_many_faces(vision_frame : VisionFrame) -> List[Face]:
+	faces = []
+	try:
+		faces_cache = get_static_faces(vision_frame)
+		if faces_cache:
+			faces = faces_cache
+		else:
+			bounding_box_list = []
+			face_landmark_5_list = []
+			score_list = []
+
+			if facefusion.globals.face_detector_model in [ 'many', 'retinaface']:
+				bounding_box_list_retinaface, face_landmark_5_list_retinaface, score_list_retinaface = detect_with_retinaface(vision_frame, facefusion.globals.face_detector_size)
+				bounding_box_list.extend(bounding_box_list_retinaface)
+				face_landmark_5_list.extend(face_landmark_5_list_retinaface)
+				score_list.extend(score_list_retinaface)
+			if facefusion.globals.face_detector_model in [ 'many', 'scrfd' ]:
+				bounding_box_list_scrfd, face_landmark_5_list_scrfd, score_list_scrfd = detect_with_scrfd(vision_frame, facefusion.globals.face_detector_size)
+				bounding_box_list.extend(bounding_box_list_scrfd)
+				face_landmark_5_list.extend(face_landmark_5_list_scrfd)
+				score_list.extend(score_list_scrfd)
+			if facefusion.globals.face_detector_model in [ 'many', 'yoloface' ]:
+				bounding_box_list_yoloface, face_landmark_5_list_yoloface, score_list_yoloface = detect_with_yoloface(vision_frame, facefusion.globals.face_detector_size)
+				bounding_box_list.extend(bounding_box_list_yoloface)
+				face_landmark_5_list.extend(face_landmark_5_list_yoloface)
+				score_list.extend(score_list_yoloface)
+			if facefusion.globals.face_detector_model in [ 'yunet' ]:
+				bounding_box_list_yunet, face_landmark_5_list_yunet, score_list_yunet = detect_with_yunet(vision_frame, facefusion.globals.face_detector_size)
+				bounding_box_list.extend(bounding_box_list_yunet)
+				face_landmark_5_list.extend(face_landmark_5_list_yunet)
+				score_list.extend(score_list_yunet)
+			if bounding_box_list and face_landmark_5_list and score_list:
+				faces = create_faces(vision_frame, bounding_box_list, face_landmark_5_list, score_list)
+			if faces:
+				set_static_faces(vision_frame, faces)
+		if facefusion.globals.face_analyser_order:
+			faces = sort_by_order(faces, facefusion.globals.face_analyser_order)
+		if facefusion.globals.face_analyser_age:
+			faces = filter_by_age(faces, facefusion.globals.face_analyser_age)
+		if facefusion.globals.face_analyser_gender:
+			faces = filter_by_gender(faces, facefusion.globals.face_analyser_gender)
+	except (AttributeError, ValueError):
+		pass
+	return faces
+
+
+def find_similar_faces(reference_faces : FaceSet, vision_frame : VisionFrame, face_distance : float) -> List[Face]:
+	similar_faces : List[Face] = []
+	many_faces = get_many_faces(vision_frame)
+
+	if reference_faces:
+		for reference_set in reference_faces:
+			if not similar_faces:
+				for reference_face in reference_faces[reference_set]:
+					for face in many_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_by_order(faces : List[Face], order : FaceAnalyserOrder) -> 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.scores.get('detector'), reverse = True)
+	if order == 'worst-best':
+		return sorted(faces, key = lambda face: face.scores.get('detector'))
+	return faces
+
+
+def filter_by_age(faces : List[Face], age : FaceAnalyserAge) -> List[Face]:
+	filter_faces = []
+	for face in faces:
+		if categorize_age(face.age) == age:
+			filter_faces.append(face)
+	return filter_faces
+
+
+def filter_by_gender(faces : List[Face], gender : FaceAnalyserGender) -> List[Face]:
+	filter_faces = []
+	for face in faces:
+		if categorize_gender(face.gender) == gender:
+			filter_faces.append(face)
+	return filter_faces