facefusion/core.py

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()