add groups to capabilities

keep v4 style
merge master into v4 - post adjustments
2026-07-28 12:59:03 +02:00 · 2026-07-02 20:39:09 +02:00 · 2026-07-01 17:21:33 +02:00 · 2026-07-01 17:10:31 +02:00 · 2026-07-01 16:02:19 +02:00 · 2026-07-01 14:44:53 +02:00
209 changed files with 9321 additions and 5793 deletions
@@ -35,6 +35,9 @@ jobs:
     python-version: '3.12'
  - run: python install.py default --skip-conda
  - run: pip install pytest
+  - run: pip install pytest-mock
+  - run: pip install httpx
+  - run: pip install python-multipart
  - run: pytest
 report:
  needs: test
@@ -52,6 +55,9 @@ jobs:
  - run: pip install coveralls
  - run: pip install pytest
  - run: pip install pytest-cov
+  - run: pip install pytest-mock
+  - run: pip install httpx
+  - run: pip install python-multipart
  - run: pytest tests --cov facefusion
  - run: coveralls --service github
    env:
@@ -4,4 +4,5 @@ __pycache__
 .caches
 .idea
 .jobs
+.libraries
 .vscode
@@ -8,12 +8,6 @@ FaceFusion
 ![License](https://img.shields.io/badge/license-OpenRAIL--AS-green)


-Preview
-------
-
-![Preview](https://raw.githubusercontent.com/facefusion/facefusion/master/.github/preview.png?sanitize=true)
-
-
 Installation
 ------------

@@ -34,10 +28,10 @@ options:

 commands:
    run                                           run the program
-    headless-run                                  run the program in headless mode
    batch-run                                     run the program in batch mode
    force-download                                force automate downloads and exit
    benchmark                                     benchmark the program
+    api                                           start the API server
    job-list                                      list jobs by status
    job-create                                    create a drafted job
    job-submit                                    submit a drafted job to become a queued job
@@ -1,3 +1,6 @@
+[workflow]
+workflow =
+
 [paths]
 temp_path =
 jobs_path =
@@ -51,7 +54,6 @@ voice_extractor_model =
 trim_frame_start =
 trim_frame_end =
 temp_frame_format =
-keep_temp =

 [frame_distribution]
 target_frame_amount =
@@ -62,6 +64,7 @@ output_image_scale =
 output_audio_encoder =
 output_audio_quality =
 output_audio_volume =
+output_audio_fps =
 output_video_encoder =
 output_video_preset =
 output_video_quality =
@@ -110,11 +113,6 @@ frame_enhancer_blend =
 lip_syncer_model =
 lip_syncer_weight =

-[uis]
-open_browser =
-ui_layouts =
-ui_workflow =
-
 [download]
 download_providers =
 download_scope =
@@ -124,6 +122,11 @@ benchmark_mode =
 benchmark_resolutions =
 benchmark_cycle_count =

+[api]
+api_host =
+api_port =
+api_security_strategy =
+
 [execution]
 execution_device_ids =
 execution_providers =
@@ -0,0 +1,14 @@
+from typing import Optional
+
+from starlette.datastructures import Headers
+from starlette.types import Scope
+
+
+def get_sec_websocket_protocol(scope : Scope) -> Optional[str]:
+	protocol_header = Headers(scope = scope).get('Sec-WebSocket-Protocol')
+
+	if protocol_header:
+		protocol, _, _ = protocol_header.partition(',')
+		return protocol.strip()
+
+	return None
@@ -0,0 +1,91 @@
+import asyncio
+import os
+import uuid
+from typing import List, Optional
+
+from starlette.datastructures import UploadFile
+
+import facefusion.choices
+from facefusion import ffmpeg, process_manager, state_manager
+from facefusion.filesystem import create_directory, get_file_extension, get_file_format, is_audio, is_image, is_video
+from facefusion.types import ImageMetadata, MediaType
+from facefusion.vision import detect_image_resolution
+
+
+def extract_image_metadata(file_path : str) -> ImageMetadata:
+	metadata : ImageMetadata =\
+	{
+		'resolution': detect_image_resolution(file_path)
+	}
+	return metadata
+
+
+def detect_media_type_by_path(file_path : str) -> Optional[MediaType]:
+	if is_audio(file_path):
+		return 'audio'
+	if is_image(file_path):
+		return 'image'
+	if is_video(file_path):
+		return 'video'
+	return None
+
+
+def detect_media_type_by_format(file_format : str) -> Optional[MediaType]:
+	if file_format in facefusion.choices.audio_set:
+		return 'audio'
+	if file_format in facefusion.choices.image_set:
+		return 'image'
+	if file_format in facefusion.choices.video_set:
+		return 'video'
+	return None
+
+
+def validate_asset_files(upload_files : List[UploadFile]) -> bool:
+	available_encoder_set = ffmpeg.get_static_available_encoder_set()
+
+	for upload_file in upload_files:
+		file_format = get_file_format(upload_file.filename)
+		media_type = detect_media_type_by_format(file_format)
+
+		if media_type == 'audio' and facefusion.choices.audio_set.get(file_format) not in available_encoder_set.get('audio'): #type:ignore[call-overload]
+			return False
+
+		if media_type == 'image' and facefusion.choices.image_set.get(file_format) not in available_encoder_set.get('image'): #type:ignore[call-overload]
+			return False
+
+		if media_type == 'video' and facefusion.choices.video_set.get(file_format) not in available_encoder_set.get('video'): #type:ignore[call-overload]
+			return False
+
+	return True
+
+
+async def save_asset_files(upload_files : List[UploadFile]) -> List[str]:
+	asset_paths : List[str] = []
+	api_security_strategy = state_manager.get_item('api_security_strategy')
+
+	for upload_file in upload_files:
+		file_format = get_file_format(upload_file.filename)
+		file_extension = get_file_extension(upload_file.filename)
+		media_type = detect_media_type_by_format(file_format)
+		temp_path = state_manager.get_temp_path()
+
+		create_directory(temp_path)
+
+		asset_file_name = uuid.uuid4().hex
+		asset_path = os.path.join(temp_path, asset_file_name + file_extension)
+		file_content = await upload_file.read()
+
+		process_manager.start()
+
+		if media_type == 'audio' and await asyncio.to_thread(ffmpeg.sanitize_audio, file_content, asset_path, api_security_strategy):
+			asset_paths.append(asset_path)
+
+		if media_type == 'image' and await asyncio.to_thread(ffmpeg.sanitize_image, file_content, asset_path):
+			asset_paths.append(asset_path)
+
+		if media_type == 'video' and await asyncio.to_thread(ffmpeg.sanitize_video, file_content, asset_path, api_security_strategy):
+			asset_paths.append(asset_path)
+
+		process_manager.end()
+
+	return asset_paths
@@ -0,0 +1,92 @@
+import uuid
+from datetime import datetime, timedelta
+from typing import List, Optional, cast
+
+from facefusion.apis.asset_helper import detect_media_type_by_path, extract_image_metadata
+from facefusion.ffprobe import extract_audio_metadata, extract_video_metadata
+from facefusion.filesystem import get_file_format, get_file_name, get_file_size
+from facefusion.types import AssetId, AssetSet, AssetStore, AssetType, AudioAsset, AudioFormat, ImageAsset, ImageFormat, SessionId, VideoAsset, VideoFormat
+
+ASSET_STORE : AssetStore = {}
+
+
+def create_asset(session_id : SessionId, asset_type : AssetType, asset_path : str) -> Optional[AudioAsset | ImageAsset | VideoAsset]:
+	asset_id = str(uuid.uuid4())
+	asset_name = get_file_name(asset_path)
+	asset_format = get_file_format(asset_path)
+	asset_size = get_file_size(asset_path)
+	media_type = detect_media_type_by_path(asset_path)
+	created_at = datetime.now()
+	expires_at = created_at + timedelta(hours = 2)
+
+	if session_id not in ASSET_STORE:
+		ASSET_STORE[session_id] = {}
+
+	if media_type == 'audio':
+		ASSET_STORE[session_id][asset_id] = cast(AudioAsset,
+		{
+			'id': asset_id,
+			'created_at': created_at,
+			'expires_at': expires_at,
+			'type': asset_type,
+			'media': media_type,
+			'name': asset_name,
+			'format': cast(AudioFormat, asset_format),
+			'size': asset_size,
+			'path': asset_path,
+			'metadata': extract_audio_metadata(asset_path)
+		})
+
+	if media_type == 'image':
+		ASSET_STORE[session_id][asset_id] = cast(ImageAsset,
+		{
+			'id': asset_id,
+			'created_at': created_at,
+			'expires_at': expires_at,
+			'type': asset_type,
+			'media': media_type,
+			'name': asset_name,
+			'format': cast(ImageFormat, asset_format),
+			'size': asset_size,
+			'path': asset_path,
+			'metadata': extract_image_metadata(asset_path)
+		})
+
+	if media_type == 'video':
+		ASSET_STORE[session_id][asset_id] = cast(VideoAsset,
+		{
+			'id': asset_id,
+			'created_at': created_at,
+			'expires_at': expires_at,
+			'type': asset_type,
+			'media': media_type,
+			'name': asset_name,
+			'format': cast(VideoFormat, asset_format),
+			'size': asset_size,
+			'path': asset_path,
+			'metadata': extract_video_metadata(asset_path)
+		})
+
+	return ASSET_STORE[session_id].get(asset_id)
+
+
+def get_assets(session_id : SessionId) -> Optional[AssetSet]:
+	return ASSET_STORE.get(session_id)
+
+
+def get_asset(session_id : SessionId, asset_id : AssetId) -> Optional[AudioAsset | ImageAsset | VideoAsset]:
+	if session_id in ASSET_STORE:
+		return ASSET_STORE.get(session_id).get(asset_id)
+	return None
+
+
+def delete_assets(session_id : SessionId, asset_ids : List[AssetId]) -> None:
+	if session_id in ASSET_STORE:
+		for asset_id in asset_ids:
+			if asset_id in ASSET_STORE.get(session_id):
+				del ASSET_STORE[session_id][asset_id]
+	return None
+
+
+def clear() -> None:
+	ASSET_STORE.clear()
@@ -0,0 +1,58 @@
+from types import ModuleType
+from typing import List
+
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.middleware.cors import CORSMiddleware
+from starlette.routing import Route, WebSocketRoute
+
+from facefusion.apis.endpoints.assets import delete_assets, get_asset, get_assets, upload_asset
+from facefusion.apis.endpoints.capabilities import get_capabilities
+from facefusion.apis.endpoints.metrics import get_metrics, websocket_metrics
+from facefusion.apis.endpoints.ping import websocket_ping
+from facefusion.apis.endpoints.session import create_session, destroy_session, get_session, refresh_session
+from facefusion.apis.endpoints.state import get_state, set_state
+from facefusion.apis.endpoints.stream import delete_stream, post_stream, websocket_stream
+from facefusion.apis.middlewares.session import create_session_guard
+from facefusion.libraries import aom as aom_module, datachannel as datachannel_module, opus as opus_module, vpx as vpx_module
+
+
+def get_common_modules() -> List[ModuleType]:
+	return [ aom_module, datachannel_module, opus_module, vpx_module ]
+
+
+def pre_check() -> bool:
+	for common_module in get_common_modules():
+		if not common_module.pre_check():
+			return False
+
+	return True
+
+
+def create_api() -> Starlette:
+	session_guard = Middleware(create_session_guard)
+	routes =\
+		[
+			Route('/session', create_session, methods = [ 'POST' ]),
+			Route('/session', get_session, methods = [ 'GET' ], middleware = [ session_guard ]),
+			Route('/session', refresh_session, methods = [ 'PUT' ]),
+			Route('/session', destroy_session, methods = [ 'DELETE' ], middleware = [ session_guard ]),
+			Route('/state', get_state, methods = [ 'GET' ], middleware = [ session_guard ]),
+			Route('/state', set_state, methods = [ 'PUT' ], middleware = [ session_guard ]),
+			Route('/assets', get_assets, methods = [ 'GET' ], middleware = [ session_guard ]),
+			Route('/assets', upload_asset, methods = [ 'POST' ], middleware = [ session_guard ]),
+			Route('/assets/{asset_id}', get_asset, methods = [ 'GET' ], middleware = [ session_guard ]),
+			Route('/assets', delete_assets, methods = [ 'DELETE' ], middleware = [ session_guard ]),
+			Route('/capabilities', get_capabilities, methods = [ 'GET' ]),
+			Route('/metrics', get_metrics, methods = [ 'GET' ], middleware = [ session_guard ]),
+			Route('/stream', post_stream, methods = [ 'POST' ], middleware = [ session_guard ]),
+			Route('/stream', delete_stream, methods = [ 'DELETE' ], name = 'delete_stream', middleware = [ session_guard ]),
+			WebSocketRoute('/metrics', websocket_metrics, middleware = [ session_guard ]),
+			WebSocketRoute('/ping', websocket_ping, middleware = [ session_guard ]),
+			WebSocketRoute('/stream', websocket_stream, middleware = [ session_guard ])
+		]
+
+	api = Starlette(routes = routes)
+	api.add_middleware(CORSMiddleware, allow_origins = [ '*' ], allow_methods = [ '*' ], allow_headers = [ '*' ])
+
+	return api
@@ -0,0 +1,135 @@
+import os
+from typing import List
+
+from starlette.requests import Request
+from starlette.responses import FileResponse, JSONResponse, Response
+from starlette.status import HTTP_200_OK, HTTP_201_CREATED, HTTP_400_BAD_REQUEST, HTTP_404_NOT_FOUND, HTTP_415_UNSUPPORTED_MEDIA_TYPE
+
+from facefusion import session_context, session_manager
+from facefusion.apis import asset_store
+from facefusion.apis.asset_helper import save_asset_files, validate_asset_files
+from facefusion.apis.endpoints.session import extract_access_token
+from facefusion.filesystem import remove_file
+
+
+async def upload_asset(request : Request) -> Response:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+	asset_type = request.query_params.get('type')
+
+	if session_id and asset_type in [ 'source', 'target' ]:
+		session_context.set_session_id(session_id)
+
+		form = await request.form()
+		upload_files = form.getlist('file')
+
+		if upload_files and validate_asset_files(upload_files):
+			asset_paths = await save_asset_files(upload_files)
+
+			if asset_paths:
+				asset_ids : List[str] = []
+
+				for asset_path in asset_paths:
+					asset = asset_store.create_asset(session_id, asset_type, asset_path)
+
+					if asset:
+						asset_id = asset.get('id')
+
+						if asset_id:
+							asset_ids.append(asset_id)
+
+				if asset_ids:
+					return JSONResponse(
+					{
+						'asset_ids': asset_ids
+					}, status_code = HTTP_201_CREATED)
+
+			return Response(status_code = HTTP_415_UNSUPPORTED_MEDIA_TYPE)
+
+	return Response(status_code = HTTP_400_BAD_REQUEST)
+
+
+async def get_assets(request : Request) -> Response:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+
+	if session_id:
+		asset_set = asset_store.get_assets(session_id)
+		assets = []
+
+		if asset_set:
+			for asset in asset_set.values():
+				assets.append(
+				{
+					'id': asset.get('id'),
+					'created_at': asset.get('created_at').isoformat(),
+					'expires_at': asset.get('expires_at').isoformat(),
+					'type': asset.get('type'),
+					'media': asset.get('media'),
+					'name': asset.get('name'),
+					'format': asset.get('format'),
+					'size': asset.get('size'),
+					'metadata': asset.get('metadata')
+				})
+
+		return JSONResponse(
+		{
+			'assets': assets
+		}, status_code = HTTP_200_OK)
+
+	return Response(status_code = HTTP_400_BAD_REQUEST)
+
+
+async def get_asset(request : Request) -> Response:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+	asset_id = request.path_params.get('asset_id')
+
+	if session_id and asset_id:
+		asset = asset_store.get_asset(session_id, asset_id)
+
+		if asset:
+			if request.query_params.get('action') == 'download':
+				asset_path = asset.get('path')
+
+				if os.path.exists(asset_path):
+					return FileResponse(asset_path, filename = asset.get('name'))
+
+			return JSONResponse(
+			{
+				'id': asset.get('id'),
+				'created_at': asset.get('created_at').isoformat(),
+				'expires_at': asset.get('expires_at').isoformat(),
+				'type': asset.get('type'),
+				'media': asset.get('media'),
+				'name': asset.get('name'),
+				'format': asset.get('format'),
+				'size': asset.get('size'),
+				'metadata': asset.get('metadata')
+			}, status_code = HTTP_200_OK)
+
+	return Response(status_code = HTTP_404_NOT_FOUND)
+
+
+async def delete_assets(request : Request) -> Response:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+	body = await request.json()
+	asset_ids = body.get('asset_ids')
+
+	if session_id and asset_ids:
+		asset_set = asset_store.get_assets(session_id)
+
+		if asset_set:
+
+			for asset_id in asset_ids:
+				if asset_id in asset_set:
+					asset = asset_set.get(asset_id)
+
+					if asset:
+						remove_file(asset.get('path'))
+
+			asset_store.delete_assets(session_id, asset_ids)
+			return Response(status_code = HTTP_200_OK)
+
+	return Response(status_code = HTTP_404_NOT_FOUND)
@@ -0,0 +1,20 @@
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.status import HTTP_200_OK
+
+import facefusion.choices
+from facefusion import capability_store
+
+
+async def get_capabilities(request : Request) -> JSONResponse:
+	capabilities =\
+	{
+		'formats':
+		{
+			'audio': facefusion.choices.audio_formats,
+			'image': facefusion.choices.image_formats,
+			'video': facefusion.choices.video_formats
+		},
+		'arguments': capability_store.get_api_capability_group()
+	}
+	return JSONResponse(capabilities, status_code = HTTP_200_OK)
@@ -0,0 +1,32 @@
+import asyncio
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.status import HTTP_404_NOT_FOUND
+from starlette.websockets import WebSocket
+
+from facefusion.apis.api_helper import get_sec_websocket_protocol
+from facefusion.system import get_metrics_set
+
+
+async def get_metrics(request : Request) -> Response:
+	metrics_set = get_metrics_set()
+
+	if metrics_set:
+		return JSONResponse(metrics_set)
+
+	return Response(status_code = HTTP_404_NOT_FOUND)
+
+
+async def websocket_metrics(websocket : WebSocket) -> None:
+	subprotocol = get_sec_websocket_protocol(websocket.scope)
+	await websocket.accept(subprotocol = subprotocol)
+
+	try:
+		while True:
+			metrics_set = get_metrics_set()
+			await websocket.send_json(metrics_set)
+			await asyncio.sleep(2)
+
+	except Exception:
+		pass
@@ -0,0 +1,16 @@
+from starlette.websockets import WebSocket
+
+from facefusion.apis.api_helper import get_sec_websocket_protocol
+
+
+async def websocket_ping(websocket : WebSocket) -> None:
+	subprotocol = get_sec_websocket_protocol(websocket.scope)
+
+	await websocket.accept(subprotocol = subprotocol)
+
+	try:
+		while True:
+			await websocket.receive()
+
+	except Exception:
+		pass
@@ -0,0 +1,75 @@
+import os
+import secrets
+
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.status import HTTP_200_OK, HTTP_201_CREATED, HTTP_401_UNAUTHORIZED
+
+from facefusion import session_context, session_manager, translator
+from facefusion.apis.session_helper import extract_access_token
+
+
+async def create_session(request : Request) -> JSONResponse:
+	body = await request.json()
+
+	if not body.get('api_key') or body.get('api_key') == os.getenv('FACEFUSION_API_KEY'):
+		session_id = secrets.token_urlsafe(16)
+		session = session_manager.create_session()
+		session_context.set_session_id(session_id)
+		session_manager.set_session(session_id, session)
+
+		return JSONResponse(
+		{
+			'access_token': session.get('access_token'),
+			'refresh_token': session.get('refresh_token')
+		}, status_code = HTTP_201_CREATED)
+
+	return JSONResponse(
+	{
+		'message': translator.get('something_went_wrong', 'facefusion.apis')
+	}, status_code = HTTP_401_UNAUTHORIZED)
+
+
+async def get_session(request : Request) -> JSONResponse:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+	session = session_manager.get_session(session_id)
+
+	return JSONResponse(
+	{
+		'access_token': session.get('access_token'),
+		'refresh_token': session.get('refresh_token'),
+		'created_at': session.get('created_at').isoformat(),
+		'expires_at': session.get('expires_at').isoformat()
+	}, status_code = HTTP_200_OK)
+
+
+async def refresh_session(request : Request) -> JSONResponse:
+	body = await request.json()
+
+	for session_id, session in session_manager.SESSIONS.items():
+		if session.get('refresh_token') == body.get('refresh_token') and session_manager.validate_session(session_id):
+			__session__ = session_manager.create_session()
+			session_manager.set_session(session_id, __session__)
+
+			return JSONResponse(
+			{
+				'access_token': __session__.get('access_token'),
+				'refresh_token': __session__.get('refresh_token')
+			}, status_code = HTTP_200_OK)
+
+	return JSONResponse(
+	{
+		'message': translator.get('something_went_wrong', 'facefusion.apis')
+	}, status_code = HTTP_401_UNAUTHORIZED)
+
+
+async def destroy_session(request : Request) -> JSONResponse:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+	session_manager.clear_session(session_id)
+
+	return JSONResponse(
+	{
+		'message': translator.get('ok', 'facefusion.apis')
+	}, status_code = HTTP_200_OK)
@@ -0,0 +1,93 @@
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.status import HTTP_200_OK, HTTP_400_BAD_REQUEST, HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_CONTENT
+
+from facefusion import args_helper, capability_store, session_manager, state_manager, translator
+from facefusion.apis import asset_store
+from facefusion.apis.endpoints.session import extract_access_token
+
+
+async def get_state(request : Request) -> JSONResponse:
+	api_args = args_helper.extract_api_args(state_manager.get_state())
+	return JSONResponse(state_manager.collect_state(api_args), status_code = HTTP_200_OK)
+
+
+async def set_state(request : Request) -> JSONResponse:
+	__api_args__ = {}
+
+	action = request.query_params.get('action')
+	asset_type = request.query_params.get('type')
+
+	if action == 'select' and asset_type == 'source':
+		return await select_source(request)
+
+	if action == 'select' and asset_type == 'target':
+		return await select_target(request)
+
+	body = await request.json()
+	api_args = capability_store.get_api_arguments()
+
+	for key, value in body.items():
+		if key not in api_args:
+			return JSONResponse(
+			{
+				'message': translator.get('invalid_state_key', 'facefusion.apis')
+			}, status_code = HTTP_400_BAD_REQUEST)
+		__api_args__[key] = value
+
+	if __api_args__:
+
+		for key, value in __api_args__.items():
+			state_manager.set_item(key, value)
+
+		__api_args__ = args_helper.extract_api_args(state_manager.get_state())
+		return JSONResponse(state_manager.collect_state(__api_args__), status_code = HTTP_200_OK)
+
+	return JSONResponse({}, status_code = HTTP_422_UNPROCESSABLE_CONTENT)
+
+
+async def select_source(request : Request) -> JSONResponse:
+	body = await request.json()
+	asset_ids = body.get('asset_ids')
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+
+	if isinstance(asset_ids, list) and session_id:
+		source_paths = []
+
+		for asset_id in asset_ids:
+			asset = asset_store.get_asset(session_id, asset_id)
+
+			if asset:
+				source_paths.append(asset.get('path'))
+
+		state_manager.set_item('source_paths', source_paths)
+
+		__api_args__ = args_helper.extract_api_args(state_manager.get_state())
+		return JSONResponse(state_manager.collect_state(__api_args__), status_code = HTTP_200_OK)
+
+	return JSONResponse(
+	{
+		'message': translator.get('source_asset_not_found', 'facefusion.apis')
+	}, status_code = HTTP_404_NOT_FOUND)
+
+
+async def select_target(request : Request) -> JSONResponse:
+	body = await request.json()
+	asset_id = body.get('asset_id')
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+
+	if isinstance(asset_id, str) and session_id:
+		asset = asset_store.get_asset(session_id, asset_id)
+
+		if asset:
+			state_manager.set_item('target_path', asset.get('path'))
+
+			__api_args__ = args_helper.extract_api_args(state_manager.get_state())
+			return JSONResponse(state_manager.collect_state(__api_args__), status_code = HTTP_200_OK)
+
+	return JSONResponse(
+	{
+		'message': translator.get('target_asset_not_found', 'facefusion.apis')
+	}, status_code = HTTP_404_NOT_FOUND)
@@ -0,0 +1,52 @@
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.status import HTTP_200_OK, HTTP_201_CREATED, HTTP_404_NOT_FOUND
+from starlette.websockets import WebSocket, WebSocketState
+
+from facefusion import session_context, session_manager
+from facefusion.apis.api_helper import get_sec_websocket_protocol
+from facefusion.apis.session_helper import extract_access_token
+from facefusion.apis.stream_manager import destroy_stream, process_image, process_video
+
+
+async def websocket_stream(websocket : WebSocket) -> None:
+	subprotocol = get_sec_websocket_protocol(websocket.scope)
+	access_token = extract_access_token(websocket.scope)
+	session_id = session_manager.find_session_id(access_token)
+	session_context.set_session_id(session_id)
+
+	await websocket.accept(subprotocol = subprotocol)
+	await process_image(websocket)
+
+	if websocket.client_state == WebSocketState.CONNECTED:
+		await websocket.close()
+
+
+async def post_stream(request : Request) -> Response:
+	headers =\
+	{
+		'Location': request.url_for('delete_stream').path
+	}
+	content_type = request.headers.get('content-type')
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+	session_context.set_session_id(session_id)
+
+	if session_id and content_type == 'application/sdp':
+		sdp_offer = await request.body()
+		sdp_answer = process_video(session_id, sdp_offer.decode())
+
+		if sdp_answer:
+			return Response(sdp_answer, status_code = HTTP_201_CREATED, media_type = 'application/sdp', headers = headers)
+
+	return Response(status_code = HTTP_404_NOT_FOUND)
+
+
+async def delete_stream(request : Request) -> Response:
+	access_token = extract_access_token(request.scope)
+	session_id = session_manager.find_session_id(access_token)
+
+	if session_id and destroy_stream(session_id):
+		return Response(status_code = HTTP_200_OK)
+
+	return Response(status_code = HTTP_404_NOT_FOUND)
@@ -0,0 +1,15 @@
+from facefusion.types import Locales
+
+LOCALES : Locales =\
+{
+	'en':
+	{
+		'ok': 'ok',
+		'something_went_wrong': 'something went wrong',
+		'invalid_access_token': 'invalid access token',
+		'invalid_refresh_token': 'invalid refresh token',
+		'source_asset_not_found': 'source asset not found',
+		'target_asset_not_found': 'target asset not found',
+		'invalid_state_key': 'invalid state key'
+	}
+}
@@ -0,0 +1,34 @@
+from starlette.responses import JSONResponse
+from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_426_UPGRADE_REQUIRED
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from facefusion import session_manager, translator
+from facefusion.apis.session_helper import extract_access_token
+
+
+def create_session_guard(app : ASGIApp) -> ASGIApp:
+	async def middleware(scope : Scope, receive : Receive, send : Send) -> None:
+		access_token = extract_access_token(scope)
+
+		if access_token:
+			session_id = session_manager.find_session_id(access_token)
+
+			if session_id:
+				if session_manager.validate_session(session_id):
+					return await app(scope, receive, send)
+
+				response = JSONResponse(
+				{
+					'message': translator.get('invalid_access_token', 'facefusion.apis')
+				}, status_code = HTTP_426_UPGRADE_REQUIRED)
+
+				return await response(scope, receive, send)
+
+		response = JSONResponse(
+		{
+			'message': translator.get('invalid_access_token', 'facefusion.apis')
+		}, status_code = HTTP_401_UNAUTHORIZED)
+
+		return await response(scope, receive, send)
+
+	return middleware
@@ -0,0 +1,29 @@
+from typing import Optional
+
+from starlette.datastructures import Headers
+from starlette.types import Scope
+
+from facefusion.apis.api_helper import get_sec_websocket_protocol
+from facefusion.types import Token
+
+
+def extract_access_token(scope : Scope) -> Optional[Token]:
+	if scope.get('type') == 'http':
+		auth_header = Headers(scope = scope).get('Authorization')
+
+		if auth_header:
+			auth_prefix, _, access_token = auth_header.partition(' ')
+
+			if auth_prefix.lower() == 'bearer' and access_token:
+				return access_token
+
+	if scope.get('type') == 'websocket':
+		subprotocol = get_sec_websocket_protocol(scope)
+
+		if subprotocol:
+			protocol_prefix, _, access_token = subprotocol.partition('.')
+
+			if protocol_prefix == 'access_token' and access_token:
+				return access_token
+
+	return None
@@ -0,0 +1,67 @@
+from functools import partial
+from queue import Queue
+from typing import Optional, Tuple
+
+import numpy
+
+from facefusion import rtc
+from facefusion.apis.stream_event import create_receive_event
+from facefusion.codecs import opus_decoder, opus_encoder
+from facefusion.types import AudioCodec, AudioFrame, Buffer, OpusDecoder, RtcPeer, RtcPeerAudio, Time
+
+
+def run_audio_encode_loop(rtc_peer : RtcPeer, audio_queue : Queue[Tuple[Time, AudioFrame]]) -> None:
+	audio_codec = rtc_peer.get('audio').get('codec')
+	temp_audio_time, temp_audio_frame = audio_queue.get()
+	audio_encoder = opus_encoder.create(48000, 2)
+
+	while numpy.any(temp_audio_frame):
+		audio_buffer = opus_encoder.encode(audio_encoder, temp_audio_frame.tobytes(), 2)
+
+		if audio_buffer:
+			audio_timestamp = rtc.convert_time_to_timestamp(audio_codec, temp_audio_time)
+			rtc.send_audio(rtc_peer, audio_buffer, audio_timestamp)
+
+		temp_audio_time, temp_audio_frame = audio_queue.get()
+
+	opus_encoder.destroy(audio_encoder)
+
+
+def receive_audio_frames(rtc_peer_audio : RtcPeerAudio, audio_queue : Queue[Tuple[Time, AudioFrame]]) -> None:
+	audio_track = rtc_peer_audio.get('receiver_track')
+	audio_codec = rtc_peer_audio.get('codec')
+	audio_decoder = create_audio_decoder(audio_codec)
+
+	audio_frame_handler = partial(handle_audio_frame, audio_codec, audio_decoder, audio_queue)
+	receive_event = create_receive_event(audio_track, audio_frame_handler)
+	receive_event.wait()
+
+	empty_audio_frame = numpy.empty(0)
+	audio_queue.put((0.0, empty_audio_frame))
+	destroy_audio_decoder(audio_codec, audio_decoder)
+
+
+def decode_audio_frame(audio_codec : AudioCodec, audio_decoder : OpusDecoder, input_buffer : Buffer) -> Optional[Buffer]:
+	if audio_codec == 'opus':
+		return opus_decoder.decode(audio_decoder, input_buffer, 2)
+	return None
+
+
+def create_audio_decoder(audio_codec : AudioCodec) -> Optional[OpusDecoder]:
+	if audio_codec == 'opus':
+		return opus_decoder.create(48000, 2)
+	return None
+
+
+def destroy_audio_decoder(audio_codec : AudioCodec, audio_decoder : OpusDecoder) -> None:
+	if audio_codec == 'opus':
+		opus_decoder.destroy(audio_decoder)
+
+
+def handle_audio_frame(audio_codec : AudioCodec, audio_decoder : OpusDecoder, audio_queue : Queue[Tuple[Time, AudioFrame]], audio_buffer : Buffer, audio_timestamp : int) -> None:
+	audio_frame = decode_audio_frame(audio_codec, audio_decoder, audio_buffer)
+
+	if audio_frame:
+		audio_frame = numpy.frombuffer(audio_frame, dtype = numpy.float32)
+		audio_time = rtc.convert_timestamp_to_time(audio_codec, audio_timestamp)
+		audio_queue.put((audio_time, audio_frame))
@@ -0,0 +1,30 @@
+import ctypes
+import threading
+from functools import partial
+
+from facefusion.libraries import datachannel as datachannel_module
+from facefusion.types import FrameHandler
+
+
+def create_receive_event(track : int, frame_handler : FrameHandler) -> threading.Event:
+	datachannel_library = datachannel_module.create_static_library()
+	receive_event = threading.Event()
+
+	frame_callback = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)(partial(dispatch_frame, frame_handler))
+	close_callback = ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_void_p)(partial(dispatch_event, receive_event))
+	datachannel_library.rtcSetFrameCallback(track, frame_callback)
+	datachannel_library.rtcSetClosedCallback(track, close_callback)
+	receive_event.frame_callback = frame_callback  # type: ignore[attr-defined]
+	receive_event.close_callback = close_callback  # type: ignore[attr-defined]
+
+	return receive_event
+
+
+def dispatch_frame(frame_handler : FrameHandler, track : int, data : ctypes.c_void_p, size : int, info : ctypes.c_void_p, pointer : ctypes.c_void_p) -> None:
+	frame_buffer = ctypes.string_at(data, size)
+	frame_timestamp = ctypes.cast(info, ctypes.POINTER(ctypes.c_uint32)).contents.value
+	frame_handler(frame_buffer, frame_timestamp)
+
+
+def dispatch_event(event : threading.Event, track : int, pointer : ctypes.c_void_p) -> None:
+	event.set()
@@ -0,0 +1,136 @@
+import ctypes
+import threading
+from collections.abc import AsyncIterator
+from concurrent.futures import Future, ThreadPoolExecutor
+from queue import Queue
+from typing import Optional, Tuple
+
+import cv2
+import numpy
+from starlette.websockets import WebSocket
+
+from facefusion import rtc, rtc_store, state_manager, streamer
+from facefusion.apis.stream_audio import receive_audio_frames, run_audio_encode_loop
+from facefusion.apis.stream_video import receive_video_frames, run_video_encode_loop
+from facefusion.libraries import datachannel as datachannel_module
+from facefusion.types import AudioCodec, AudioFrame, BufferPack, PeerConnection, RtcPeer, RtcPeerAudio, SdpAnswer, SdpOffer, SessionId, Time, VideoCodec, VisionFrame
+
+
+async def process_image(websocket : WebSocket) -> None:
+	capture_vision_frame = await anext(receive_vision_frames(websocket), None)
+
+	if numpy.any(capture_vision_frame):
+		output_vision_frame = streamer.process_stream_frame(capture_vision_frame)
+		is_success, output_frame_buffer = cv2.imencode('.jpg', output_vision_frame)
+
+		if is_success:
+			await websocket.send_bytes(output_frame_buffer.tobytes())
+
+
+async def receive_vision_frames(websocket : WebSocket) -> AsyncIterator[VisionFrame]:
+	websocket_event = await websocket.receive()
+
+	while websocket_event.get('type') == 'websocket.receive':
+		frame_buffer = websocket_event.get('bytes') or bytes()
+		vision_frame = cv2.imdecode(numpy.frombuffer(frame_buffer, numpy.uint8), cv2.IMREAD_COLOR)
+
+		if numpy.any(vision_frame):
+			yield vision_frame
+
+		websocket_event = await websocket.receive()
+
+
+def process_video(session_id : SessionId, sdp_offer : SdpOffer) -> Optional[SdpAnswer]:
+	video_codec : VideoCodec = 'vp8'
+
+	if rtc.get_payload_type(sdp_offer, 'vp9'):
+		video_codec = 'vp9'
+
+	if rtc.get_payload_type(sdp_offer, 'av1'):
+		video_codec = 'av1'
+
+	video_payload_type = rtc.get_payload_type(sdp_offer, video_codec)
+
+	if video_payload_type:
+		peer_connection : PeerConnection = rtc.create_peer_connection()
+		video_receiver_track = rtc.add_video_track(peer_connection, 'recvonly', video_codec, video_payload_type)
+		video_sender_track = rtc.add_video_track(peer_connection, 'sendonly', video_codec, video_payload_type)
+
+		sender_bitrate = ctypes.c_uint(0)
+		receiver_bitrate = ctypes.c_uint(8000)
+		rtc.wire_sender_bitrate(video_sender_track, sender_bitrate)
+
+		audio_codec : AudioCodec = 'opus'
+		audio_payload_type = rtc.get_payload_type(sdp_offer, audio_codec)
+
+		if audio_payload_type:
+			audio_receiver_track = rtc.add_audio_track(peer_connection, 'recvonly', audio_codec, audio_payload_type)
+			audio_sender_track = rtc.add_audio_track(peer_connection, 'sendonly', audio_codec, audio_payload_type)
+
+		rtc.set_remote_description(peer_connection, sdp_offer)
+		sdp_answer = rtc.create_sdp_answer(peer_connection)
+
+		if sdp_answer:
+			rtc_peer : RtcPeer =\
+			{
+				'peer_connection': peer_connection,
+				'video':
+				{
+					'sender_track': video_sender_track,
+					'receiver_track': video_receiver_track,
+					'codec': video_codec
+				},
+				'sender_bitrate': sender_bitrate,
+				'receiver_bitrate': receiver_bitrate
+			}
+
+			if audio_payload_type:
+				rtc_peer['audio'] = RtcPeerAudio(
+					sender_track = audio_sender_track,
+					receiver_track = audio_receiver_track,
+					codec = audio_codec
+				)
+
+			rtc_store.init_peers(session_id)
+			rtc_store.get_peers(session_id).append(rtc_peer)
+
+			threading.Thread(target = run_peer_loop, args = (session_id, rtc_peer), daemon = True).start()
+
+			return sdp_answer
+
+		datachannel_module.create_static_library().rtcDeletePeerConnection(peer_connection)
+
+	return None
+
+
+def run_peer_loop(session_id : SessionId, rtc_peer : RtcPeer) -> None:
+	execution_thread_count = state_manager.get_item('execution_thread_count')
+	video_queue : Queue[Tuple[Time, Future[BufferPack]]] = Queue(maxsize = execution_thread_count)
+	audio_queue : Queue[Tuple[Time, AudioFrame]] = Queue(maxsize = execution_thread_count * 10)
+	video_executor = ThreadPoolExecutor(max_workers = execution_thread_count)
+
+	video_receiver_thread = threading.Thread(target = receive_video_frames, args = (rtc_peer.get('video'), video_queue, video_executor), daemon = True)
+	video_encoder_thread = threading.Thread(target = run_video_encode_loop, args = (rtc_peer, video_queue), daemon = True)
+	video_receiver_thread.start()
+	video_encoder_thread.start()
+
+	if rtc_peer.get('audio'):
+		audio_receiver_thread = threading.Thread(target = receive_audio_frames, args = (rtc_peer.get('audio'), audio_queue), daemon = True)
+		audio_encoder_thread = threading.Thread(target = run_audio_encode_loop, args = (rtc_peer, audio_queue), daemon = True)
+		audio_receiver_thread.start()
+		audio_encoder_thread.start()
+		audio_receiver_thread.join()
+		audio_encoder_thread.join()
+
+	video_receiver_thread.join()
+	video_encoder_thread.join()
+	video_executor.shutdown(wait = True)
+	rtc_store.delete_peers(session_id)
+
+
+def destroy_stream(session_id : SessionId) -> bool:
+	if rtc_store.has_peers(session_id):
+		rtc_store.delete_peers(session_id)
+		return not rtc_store.has_peers(session_id)
+
+	return False
@@ -0,0 +1,174 @@
+from concurrent.futures import Future, ThreadPoolExecutor
+from functools import partial
+from queue import Queue
+from typing import Optional, Tuple
+
+import cv2
+import numpy
+
+from facefusion import rtc, streamer
+from facefusion.apis.stream_event import create_receive_event
+from facefusion.codecs import aom_decoder, aom_encoder, vpx_decoder, vpx_encoder
+from facefusion.types import AomDecoder, AomEncoder, BitRate, Buffer, BufferPack, Resolution, RtcPeer, RtcPeerVideo, Time, VideoCodec, VisionFrame, VpxDecoder, VpxEncoder
+
+
+def run_video_encode_loop(rtc_peer : RtcPeer, video_queue : Queue[Tuple[Time, Future[BufferPack]]]) -> None:
+	video_codec = rtc_peer.get('video').get('codec')
+	video_time, video_future = video_queue.get()
+	video_pack = video_future.result()
+	video_buffer = video_pack.get('buffer')
+	video_resolution = video_pack.get('resolution')
+
+	if video_buffer:
+		temp_resolution : Resolution = video_resolution
+		temp_bitrate : BitRate = 8000
+		video_encoder = create_video_encoder(video_codec, temp_resolution, temp_bitrate)
+		frame_index = 0
+
+		while video_buffer:
+			sender_bitrate = rtc_peer.get('sender_bitrate').value
+
+			if video_resolution[0] - temp_resolution[0] or video_resolution[1] - temp_resolution[1]:
+				temp_resolution = video_resolution
+				update_video_encoder_resolution(video_codec, video_encoder, temp_resolution)
+
+			if sender_bitrate > 0 and sender_bitrate - temp_bitrate:
+				temp_bitrate = sender_bitrate
+				update_video_encoder_bitrate(video_codec, video_encoder, temp_bitrate)
+
+			__video_buffer__ = encode_video_frame(video_codec, video_encoder, video_buffer, temp_resolution, frame_index)
+
+			if __video_buffer__:
+				video_timestamp = rtc.convert_time_to_timestamp(video_codec, video_time)
+				rtc.send_video(rtc_peer, __video_buffer__, video_timestamp)
+
+			receiver_bitrate = rtc_peer.get('receiver_bitrate').value
+			rtc.adapt_receiver_bitrate(rtc_peer, receiver_bitrate)
+			frame_index += 1
+
+			video_time, video_future = video_queue.get()
+			video_pack = video_future.result()
+			video_buffer = video_pack.get('buffer')
+			video_resolution = video_pack.get('resolution')
+
+		destroy_video_encoder(video_codec, video_encoder)
+		rtc.clear_bitrate(rtc_peer)
+
+
+def receive_video_frames(rtc_peer_video : RtcPeerVideo, video_queue : Queue[Tuple[Time, Future[BufferPack]]], video_executor : ThreadPoolExecutor) -> None:
+	video_track = rtc_peer_video.get('receiver_track')
+	video_codec = rtc_peer_video.get('codec')
+	video_decoder = create_video_decoder(video_codec)
+
+	video_frame_handler = partial(handle_video_frame, video_codec, video_decoder, video_queue, video_executor)
+	receive_event = create_receive_event(video_track, video_frame_handler)
+	receive_event.wait()
+
+	empty_future : Future[BufferPack] = Future()
+	empty_future.set_result(BufferPack(buffer = bytes(), resolution = (0, 0)))
+	video_queue.put((0.0, empty_future))
+	destroy_video_decoder(video_codec, video_decoder)
+
+
+def process_video_frame(input_vision_frame : VisionFrame) -> BufferPack:
+	output_vision_frame = streamer.process_stream_frame(input_vision_frame)
+	output_resolution : Resolution = (output_vision_frame.shape[1], output_vision_frame.shape[0])
+	output_buffer = cv2.cvtColor(output_vision_frame, cv2.COLOR_BGR2YUV_I420).tobytes()
+	return BufferPack(buffer = output_buffer, resolution = output_resolution)
+
+
+def decode_video_frame(video_codec : VideoCodec, video_decoder : VpxDecoder | AomDecoder, input_buffer : Buffer) -> Optional[VisionFrame]:
+	if video_codec == 'av1':
+		aom_pointer = aom_decoder.decode(video_decoder, input_buffer)
+
+		if aom_pointer:
+			return normalize_vision_frame(aom_pointer)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		vpx_pointer = vpx_decoder.decode(video_decoder, input_buffer)
+
+		if vpx_pointer:
+			return normalize_vision_frame(vpx_pointer)
+
+	return None
+
+
+def encode_video_frame(video_codec : VideoCodec, video_encoder : VpxEncoder | AomEncoder, input_buffer : Buffer, frame_resolution : Resolution, frame_index : int) -> Buffer:
+	if video_codec == 'av1':
+		return aom_encoder.encode(video_encoder, input_buffer, frame_resolution, frame_index)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		return vpx_encoder.encode(video_encoder, input_buffer, frame_resolution, frame_index)
+
+	return bytes()
+
+
+def normalize_vision_frame(frame_pointer : BufferPack) -> VisionFrame:
+	frame_width, frame_height = frame_pointer.get('resolution')
+	vision_frame = numpy.frombuffer(frame_pointer.get('buffer'), dtype = numpy.uint8).reshape((frame_height * 3 // 2, frame_width))
+	return cv2.cvtColor(vision_frame, cv2.COLOR_YUV2BGR_I420)
+
+
+def create_video_decoder(video_codec : VideoCodec) -> Optional[VpxDecoder | AomDecoder]:
+	if video_codec == 'av1':
+		return aom_decoder.create(8)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		return vpx_decoder.create(video_codec, 8)
+
+	return None
+
+
+def create_video_encoder(video_codec : VideoCodec, frame_resolution : Resolution, bitrate : BitRate) -> Optional[VpxEncoder | AomEncoder]:
+	if video_codec == 'av1':
+		return aom_encoder.create(frame_resolution, bitrate, 8, 10)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		return vpx_encoder.create(video_codec, frame_resolution, bitrate, 8, 10)
+
+	return None
+
+
+def destroy_video_decoder(video_codec : VideoCodec, video_decoder : VpxDecoder | AomDecoder) -> None:
+	if video_codec == 'av1':
+		aom_decoder.destroy(video_decoder)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		vpx_decoder.destroy(video_decoder)
+
+
+def destroy_video_encoder(video_codec : VideoCodec, video_encoder : VpxEncoder | AomEncoder) -> None:
+	if video_codec == 'av1':
+		aom_encoder.destroy(video_encoder)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		vpx_encoder.destroy(video_encoder)
+
+
+def update_video_encoder_resolution(video_codec : VideoCodec, video_encoder : VpxEncoder | AomEncoder, frame_resolution : Resolution) -> bool:
+	if video_codec == 'av1':
+		return aom_encoder.update_resolution(video_encoder, frame_resolution)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		return vpx_encoder.update_resolution(video_encoder, frame_resolution)
+
+	return False
+
+
+def update_video_encoder_bitrate(video_codec : VideoCodec, video_encoder : VpxEncoder | AomEncoder, bitrate : BitRate) -> bool:
+	if video_codec == 'av1':
+		return aom_encoder.update_bitrate(video_encoder, bitrate)
+
+	if video_codec in [ 'vp8', 'vp9' ]:
+		return vpx_encoder.update_bitrate(video_encoder, bitrate)
+
+	return False
+
+
+def handle_video_frame(video_codec : VideoCodec, video_decoder : VpxDecoder | AomDecoder, video_queue : Queue[Tuple[Time, Future[BufferPack]]], video_executor : ThreadPoolExecutor, video_buffer : Buffer, video_timestamp : int) -> None:
+	vision_frame = decode_video_frame(video_codec, video_decoder, video_buffer)
+
+	if numpy.any(vision_frame) and video_queue.qsize() < video_queue.maxsize:
+		video_future = video_executor.submit(process_video_frame, vision_frame)
+		video_time = rtc.convert_timestamp_to_time(video_codec, video_timestamp)
+		video_queue.put((video_time, video_future))
@@ -6,13 +6,13 @@ from facefusion.types import AppContext

 def detect_app_context() -> AppContext:
 	jobs_path = os.path.join('facefusion', 'jobs')
-	uis_path = os.path.join('facefusion', 'uis')
+	apis_path = os.path.join('facefusion', 'apis')
 	frame = sys._getframe(1)

 	while frame:
 		if jobs_path in frame.f_code.co_filename:
 			return 'cli'
-		if uis_path in frame.f_code.co_filename:
-			return 'ui'
+		if apis_path in frame.f_code.co_filename:
+			return 'api'
 		frame = frame.f_back
 	return 'cli'
@@ -1,14 +1,17 @@
-from facefusion import state_manager
+from typing import Union
+
+from facefusion.capability_store import get_api_arguments, get_cli_arguments, get_sys_arguments
 from facefusion.filesystem import get_file_name, is_video, resolve_file_paths
-from facefusion.jobs import job_store
 from facefusion.normalizer import normalize_fps, normalize_space
 from facefusion.processors.core import get_processors_modules
-from facefusion.types import ApplyStateItem, Args
+from facefusion.processors.types import ProcessorState
+from facefusion.types import ApplyStateItem, Args, State
 from facefusion.vision import detect_video_fps


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
 	apply_state_item('command', args.get('command'))
+	apply_state_item('workflow', args.get('workflow'))
 	apply_state_item('temp_path', args.get('temp_path'))
 	apply_state_item('jobs_path', args.get('jobs_path'))
 	apply_state_item('source_paths', args.get('source_paths'))
@@ -45,13 +48,13 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
 	apply_state_item('trim_frame_start', args.get('trim_frame_start'))
 	apply_state_item('trim_frame_end', args.get('trim_frame_end'))
 	apply_state_item('temp_frame_format', args.get('temp_frame_format'))
-	apply_state_item('keep_temp', args.get('keep_temp'))
 	apply_state_item('target_frame_amount', args.get('target_frame_amount'))
 	apply_state_item('output_image_quality', args.get('output_image_quality'))
 	apply_state_item('output_image_scale', args.get('output_image_scale'))
 	apply_state_item('output_audio_encoder', args.get('output_audio_encoder'))
 	apply_state_item('output_audio_quality', args.get('output_audio_quality'))
 	apply_state_item('output_audio_volume', args.get('output_audio_volume'))
+	apply_state_item('output_audio_fps', normalize_fps(args.get('output_audio_fps')))
 	apply_state_item('output_video_encoder', args.get('output_video_encoder'))
 	apply_state_item('output_video_preset', args.get('output_video_preset'))
 	apply_state_item('output_video_quality', args.get('output_video_quality'))
@@ -67,9 +70,6 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
 	for processor_module in get_processors_modules(available_processors):
 		processor_module.apply_args(args, apply_state_item)

-	apply_state_item('open_browser', args.get('open_browser'))
-	apply_state_item('ui_layouts', args.get('ui_layouts'))
-	apply_state_item('ui_workflow', args.get('ui_workflow'))
 	apply_state_item('execution_device_ids', args.get('execution_device_ids'))
 	apply_state_item('execution_providers', args.get('execution_providers'))
 	apply_state_item('execution_thread_count', args.get('execution_thread_count'))
@@ -78,6 +78,9 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
 	apply_state_item('benchmark_mode', args.get('benchmark_mode'))
 	apply_state_item('benchmark_resolutions', args.get('benchmark_resolutions'))
 	apply_state_item('benchmark_cycle_count', args.get('benchmark_cycle_count'))
+	apply_state_item('api_host', args.get('api_host'))
+	apply_state_item('api_port', args.get('api_port'))
+	apply_state_item('api_security_strategy', args.get('api_security_strategy'))
 	apply_state_item('video_memory_strategy', args.get('video_memory_strategy'))
 	apply_state_item('log_level', args.get('log_level'))
 	apply_state_item('halt_on_error', args.get('halt_on_error'))
@@ -86,33 +89,41 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
 	apply_state_item('step_index', args.get('step_index'))


-def reduce_step_args(args : Args) -> Args:
+def extract_api_args(state : Union[State, ProcessorState]) -> Args:
+	api_args =\
+	{
+		key: state.get(key) for key in state if key in get_api_arguments()
+	}
+	return api_args
+
+
+def extract_cli_args(state : Union[State, ProcessorState]) -> Args:
+	cli_args =\
+	{
+		key: state.get(key) for key in state if key in get_cli_arguments()
+	}
+	return cli_args
+
+
+def extract_sys_args(state : Union[State, ProcessorState]) -> Args:
+	sys_args =\
+	{
+		key: state.get(key) for key in state if key in get_sys_arguments()
+	}
+	return sys_args
+
+
+def extract_step_args(state : Union[State, ProcessorState]) -> Args:
 	step_args =\
 	{
-		key: args[key] for key in args if key in job_store.get_step_keys()
+		key: state.get(key) for key in state if key in get_cli_arguments() and key not in get_sys_arguments()
 	}
 	return step_args


-def reduce_job_args(args : Args) -> Args:
-	job_args =\
-	{
-		key: args[key] for key in args if key in job_store.get_job_keys()
-	}
-	return job_args
-
-
-def collect_step_args() -> Args:
+def filter_step_args(args : Args) -> Args:
 	step_args =\
 	{
-		key: state_manager.get_item(key) for key in job_store.get_step_keys() #type:ignore[arg-type]
+		key: args.get(key) for key in args if key in get_cli_arguments() and key not in get_sys_arguments()
 	}
 	return step_args
-
-
-def collect_job_args() -> Args:
-	job_args =\
-	{
-		key: state_manager.get_item(key) for key in job_store.get_job_keys() #type:ignore[arg-type]
-	}
-	return job_args
@@ -1,5 +1,6 @@
+import math
 from functools import lru_cache
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple

 import numpy
 import scipy
@@ -7,7 +8,8 @@ from numpy.typing import NDArray

 from facefusion.ffmpeg import read_audio_buffer
 from facefusion.filesystem import is_audio
-from facefusion.types import Audio, AudioFrame, Fps, Mel, MelFilterBank, Spectrogram
+from facefusion.media_helper import restrict_trim_frame
+from facefusion.types import Audio, AudioFrame, Duration, Fps, Mel, MelFilterBank, Spectrogram
 from facefusion.voice_extractor import batch_extract_voice


@@ -141,3 +143,29 @@ def create_spectrogram(audio : Audio) -> Spectrogram:
 	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 count_audio_frame_total(audio_path : str, fps : Fps) -> int:
+	audio_duration = detect_audio_duration(audio_path)
+	if audio_duration > 0:
+		return math.ceil(audio_duration * fps)
+	return 0
+
+
+def detect_audio_duration(audio_path : str) -> Duration:
+	audio_sample_rate = 48000
+	audio_sample_size = 16
+	audio_channel_total = 2
+
+	if is_audio(audio_path):
+		audio_buffer = read_audio_buffer(audio_path, audio_sample_rate, audio_sample_size, audio_channel_total)
+		if audio_buffer:
+			audio = numpy.frombuffer(audio_buffer, dtype = numpy.int16).reshape(-1, audio_channel_total)
+			audio_duration = len(audio) / audio_sample_rate
+			return audio_duration
+	return 0
+
+
+def restrict_trim_audio_frame(audio_path : str, fps : Fps, trim_frame_start : Optional[int], trim_frame_end : Optional[int]) -> Tuple[int, int]:
+	audio_frame_total = count_audio_frame_total(audio_path, fps)
+	return restrict_trim_frame(audio_frame_total, trim_frame_start, trim_frame_end)
@@ -0,0 +1,65 @@
+from argparse import Action
+from typing import Dict, List
+
+from facefusion.types import CapabilityGroup, CapabilitySet, CapabilityStore, Group, Scope
+
+CAPABILITY_STORE : CapabilityStore =\
+{
+	'api': {},
+	'cli': {},
+	'sys': {}
+}
+
+
+def get_api_capability_group() -> CapabilityGroup:
+	capability_group : CapabilityGroup = {}
+
+	for name, value in CAPABILITY_STORE.get('api').items():
+		for group in value.get('groups'):
+			capability_group.setdefault(group, {})[name] = value
+
+	return capability_group
+
+
+def get_api_capability_set() -> Dict[str, CapabilitySet]:
+	return CAPABILITY_STORE.get('api')
+
+
+def get_cli_capability_set() -> Dict[str, CapabilitySet]:
+	return CAPABILITY_STORE.get('cli')
+
+
+def get_sys_capability_set() -> Dict[str, CapabilitySet]:
+	return CAPABILITY_STORE.get('sys')
+
+
+def get_api_arguments() -> List[str]:
+	return list(get_api_capability_set().keys())
+
+
+def get_cli_arguments() -> List[str]:
+	return list(get_cli_capability_set().keys())
+
+
+def get_sys_arguments() -> List[str]:
+	return list(get_sys_capability_set().keys())
+
+
+def register_capability_set(actions : List[Action], scopes : List[Scope], groups : List[Group]) -> None:
+	for action in actions:
+		value : CapabilitySet =\
+		{
+			'default': action.default,
+			'groups': groups
+		}
+
+		if action.choices:
+			value['choices'] = list(action.choices)
+
+		for scope in scopes:
+			if scope == 'api':
+				CAPABILITY_STORE['api'][action.dest] = value
+			if scope == 'cli':
+				CAPABILITY_STORE['cli'][action.dest] = value
+			if scope == 'sys':
+				CAPABILITY_STORE['sys'][action.dest] = value
@@ -2,7 +2,7 @@ import logging
 from typing import List, Sequence, get_args

 from facefusion.common_helper import create_float_range, create_int_range
-from facefusion.types import Angle, AudioEncoder, AudioFormat, AudioTypeSet, BenchmarkMode, BenchmarkResolution, BenchmarkSet, DownloadProvider, DownloadProviderSet, DownloadScope, EncoderSet, ExecutionProvider, ExecutionProviderSet, FaceDetectorModel, FaceDetectorSet, FaceLandmarkerModel, FaceMaskArea, FaceMaskAreaSet, FaceMaskRegion, FaceMaskRegionSet, FaceMaskType, FaceOccluderModel, FaceParserModel, FaceSelectorGender, FaceSelectorMode, FaceSelectorOrder, FaceSelectorRace, Gender, ImageFormat, ImageTypeSet, JobStatus, LogLevel, LogLevelSet, Race, Score, TempFrameFormat, UiWorkflow, VideoEncoder, VideoFormat, VideoMemoryStrategy, VideoPreset, VideoTypeSet, VoiceExtractorModel
+from facefusion.types import Angle, ApiSecurityStrategy, AudioEncoder, AudioFormat, AudioSet, BenchmarkMode, BenchmarkResolution, BenchmarkSet, DownloadProvider, DownloadProviderSet, DownloadScope, ExecutionProvider, ExecutionProviderSet, FaceDetectorModel, FaceDetectorSet, FaceLandmarkerModel, FaceMaskArea, FaceMaskAreaSet, FaceMaskRegion, FaceMaskRegionSet, FaceMaskType, FaceOccluderModel, FaceParserModel, FaceSelectorGender, FaceSelectorMode, FaceSelectorOrder, FaceSelectorRace, Gender, ImageEncoder, ImageFormat, ImageSet, JobStatus, LogLevel, LogLevelSet, Race, Score, TempFrameFormat, VideoEncoder, VideoFormat, VideoMemoryStrategy, VideoPreset, VideoSet, VoiceExtractorModel, WorkFlow

 face_detector_set : FaceDetectorSet =\
 {
@@ -47,48 +47,46 @@ face_mask_regions : List[FaceMaskRegion] = list(get_args(FaceMaskRegion))

 voice_extractor_models : List[VoiceExtractorModel] = list(get_args(VoiceExtractorModel))

-audio_type_set : AudioTypeSet =\
+workflows : List[WorkFlow] = [ 'auto', 'audio-to-image:frames', 'audio-to-image:video', 'image-to-image', 'image-to-video', 'image-to-video:frames' ]
+
+audio_set : AudioSet =\
 {
-	'flac': 'audio/flac',
-	'm4a': 'audio/mp4',
-	'mp3': 'audio/mpeg',
-	'ogg': 'audio/ogg',
-	'opus': 'audio/opus',
-	'wav': 'audio/x-wav'
+	'flac': 'flac',
+	'm4a': 'aac',
+	'mp3': 'libmp3lame',
+	'ogg': 'flac',
+	'opus': 'libopus',
+	'wav': 'pcm_s16le'
 }
-image_type_set : ImageTypeSet =\
+image_set : ImageSet =\
 {
-	'bmp': 'image/bmp',
-	'jpeg': 'image/jpeg',
-	'png': 'image/png',
-	'tiff': 'image/tiff',
-	'webp': 'image/webp'
+	'bmp': 'bmp',
+	'jpeg': 'mjpeg',
+	'png': 'png',
+	'tiff': 'tiff',
+	'webp': 'libwebp'
 }
-video_type_set : VideoTypeSet =\
+video_set : VideoSet =\
 {
-	'avi': 'video/x-msvideo',
-	'm4v': 'video/mp4',
-	'mkv': 'video/x-matroska',
-	'mp4': 'video/mp4',
-	'mpeg': 'video/mpeg',
-	'mov': 'video/quicktime',
-	'mxf': 'application/mxf',
-	'webm': 'video/webm',
-	'wmv': 'video/x-ms-wmv'
+	'avi': 'mpeg4',
+	'm4v': 'libx264',
+	'mkv': 'libx264',
+	'mov': 'libx264',
+	'mp4': 'libx264',
+	'mpeg': 'mpeg1video',
+	'mxf': 'mpeg2video',
+	'webm': 'libvpx-vp9',
+	'wmv': 'msmpeg4'
 }
 audio_formats : List[AudioFormat] = list(get_args(AudioFormat))
 image_formats : List[ImageFormat] = list(get_args(ImageFormat))
 video_formats : List[VideoFormat] = list(get_args(VideoFormat))
 temp_frame_formats : List[TempFrameFormat] = list(get_args(TempFrameFormat))

-output_audio_encoders : List[AudioEncoder] = list(get_args(AudioEncoder))
-output_video_encoders : List[VideoEncoder] = list(get_args(VideoEncoder))
-output_encoder_set : EncoderSet =\
-{
-	'audio': output_audio_encoders,
-	'video': output_video_encoders
-}
-output_video_presets : List[VideoPreset] = list(get_args(VideoPreset))
+audio_encoders : List[AudioEncoder] = list(get_args(AudioEncoder))
+image_encoders : List[ImageEncoder] = list(get_args(ImageEncoder))
+video_encoders : List[VideoEncoder] = list(get_args(VideoEncoder))
+video_presets : List[VideoPreset] = list(get_args(VideoPreset))

 benchmark_modes : List[BenchmarkMode] = list(get_args(BenchmarkMode))
 benchmark_set : BenchmarkSet =\
@@ -140,6 +138,7 @@ download_providers : List[DownloadProvider] = list(get_args(DownloadProvider))
 download_scopes : List[DownloadScope] = list(get_args(DownloadScope))

 video_memory_strategies : List[VideoMemoryStrategy] = list(get_args(VideoMemoryStrategy))
+api_security_strategies : List[ApiSecurityStrategy] = list(get_args(ApiSecurityStrategy))

 log_level_set : LogLevelSet =\
 {
@@ -150,7 +149,6 @@ log_level_set : LogLevelSet =\
 }
 log_levels : List[LogLevel] = list(get_args(LogLevel))

-ui_workflows : List[UiWorkflow] = list(get_args(UiWorkflow))
 job_statuses : List[JobStatus] = list(get_args(JobStatus))

 benchmark_cycle_count_range : Sequence[int] = create_int_range(1, 10, 1)
@@ -0,0 +1,70 @@
+import ctypes
+import struct
+from typing import Optional
+
+from facefusion.libraries import aom as aom_module
+from facefusion.types import AomDecoder, Buffer, BufferPack
+
+
+def create(thread_count : int) -> Optional[AomDecoder]:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library:
+		aom_decoder = ctypes.create_string_buffer(128)
+		aom_codec = ctypes.c_void_p.in_dll(aom_library, 'aom_codec_av1_dx_algo')
+		config_buffer = ctypes.create_string_buffer(128)
+
+		struct.pack_into('I', config_buffer, 0, thread_count)
+		struct.pack_into('I', config_buffer, 12, 1)
+
+		if aom_library.aom_codec_dec_init_ver(aom_decoder, ctypes.byref(aom_codec), config_buffer, 0, 22) == 0:
+			return aom_decoder
+
+	return None
+
+
+def decode(aom_decoder : AomDecoder, input_buffer : Buffer) -> Optional[BufferPack]:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library and input_buffer:
+		input_total = len(input_buffer)
+		temp_buffer = ctypes.create_string_buffer(input_buffer)
+
+		if aom_library.aom_codec_decode(aom_decoder, temp_buffer, input_total, None) == 0:
+			address = aom_library.aom_codec_get_frame(aom_decoder, ctypes.byref(ctypes.c_void_p(0)))
+
+			if address:
+				frame_width = ctypes.c_uint.from_address(address + 28).value & ~1
+				frame_height = ctypes.c_uint.from_address(address + 32).value & ~1
+
+				return BufferPack(
+					buffer = collect(address, frame_width, frame_height),
+					resolution = (frame_width, frame_height)
+				)
+
+	return None
+
+
+def collect(address : int, frame_width : int, frame_height : int) -> Buffer:
+	output_parts = []
+
+	for index in range(3):
+		plane_pointer = ctypes.c_void_p.from_address(address + 64 + index * 8).value
+		stride = ctypes.c_int.from_address(address + 88 + index * 4).value
+		plane_width = frame_width >> (index > 0)
+		plane_height = frame_height >> (index > 0)
+
+		if stride == plane_width:
+			output_parts.append(ctypes.string_at(plane_pointer, plane_width * plane_height))
+		else:
+			for row in range(plane_height):
+				output_parts.append(ctypes.string_at(plane_pointer + row * stride, plane_width))
+
+	return bytes().join(output_parts)
+
+
+def destroy(aom_decoder : AomDecoder) -> None:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library:
+		aom_library.aom_codec_destroy(aom_decoder)
@@ -0,0 +1,94 @@
+import ctypes
+import struct
+from typing import Optional
+
+from facefusion.libraries import aom as aom_module
+from facefusion.types import AomEncoder, BitRate, Buffer, Resolution
+
+
+def create(frame_resolution : Resolution, bitrate : BitRate, thread_count : int, cpu_count : int) -> Optional[AomEncoder]:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library:
+		aom_encoder = ctypes.create_string_buffer(1152)
+		aom_codec = ctypes.c_void_p.in_dll(aom_library, 'aom_codec_av1_cx_algo')
+
+		config_buffer = ctypes.create_string_buffer(1024)
+
+		if aom_library.aom_codec_enc_config_default(ctypes.byref(aom_codec), config_buffer, 1) == 0:
+			struct.pack_into('I', config_buffer, 4, thread_count)
+			struct.pack_into('I', config_buffer, 12, frame_resolution[0])
+			struct.pack_into('I', config_buffer, 16, frame_resolution[1])
+			struct.pack_into('I', config_buffer, 136, bitrate)
+			struct.pack_into('I', config_buffer, 192, 30)
+
+			if aom_library.aom_codec_enc_init_ver(aom_encoder, ctypes.byref(aom_codec), config_buffer, 0, 25) == 0:
+				aom_library.aom_codec_control(aom_encoder, 13, ctypes.c_int(cpu_count))
+				aom_library.aom_codec_control(aom_encoder, 75, ctypes.c_int(1))
+				aom_library.aom_codec_control(aom_encoder, 106, ctypes.c_int(0))
+				aom_library.aom_codec_control(aom_encoder, 122, ctypes.c_int(0))
+				aom_library.aom_codec_control(aom_encoder, 123, ctypes.c_int(0))
+				ctypes.memmove(ctypes.addressof(aom_encoder) + 128, config_buffer, 1024)
+				return aom_encoder
+
+	return None
+
+
+def encode(aom_encoder : AomEncoder, input_buffer : Buffer, frame_resolution : Resolution, frame_index : int) -> Buffer:
+	aom_library = aom_module.create_static_library()
+	output_buffer = bytes()
+
+	if aom_library:
+		temp_buffer = ctypes.create_string_buffer(256)
+		encode_buffer = ctypes.create_string_buffer(input_buffer)
+
+		if aom_library.aom_img_wrap(temp_buffer, 0x102, frame_resolution[0], frame_resolution[1], 1, encode_buffer) and aom_library.aom_codec_encode(aom_encoder, temp_buffer, frame_index, 1, 0, 1) == 0:
+			output_buffer = collect(aom_encoder)
+
+	return output_buffer
+
+
+def collect(aom_encoder : AomEncoder) -> Buffer:
+	aom_library = aom_module.create_static_library()
+	output_parts = []
+
+	packet_cursor = ctypes.c_void_p(0)
+	packet = aom_library.aom_codec_get_cx_data(aom_encoder, ctypes.byref(packet_cursor))
+
+	while packet:
+		if ctypes.c_int.from_address(packet).value == 0:
+			buffer_pointer = ctypes.c_void_p.from_address(packet + 8).value
+			buffer_size = ctypes.c_size_t.from_address(packet + 16).value
+			output_parts.append(ctypes.string_at(buffer_pointer, buffer_size))
+
+		packet = aom_library.aom_codec_get_cx_data(aom_encoder, ctypes.byref(packet_cursor))
+
+	return bytes().join(output_parts)
+
+
+def update_resolution(aom_encoder : AomEncoder, frame_resolution : Resolution) -> bool:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library:
+		struct.pack_into('I', aom_encoder, 128 + 12, frame_resolution[0])
+		struct.pack_into('I', aom_encoder, 128 + 16, frame_resolution[1])
+		return aom_library.aom_codec_enc_config_set(aom_encoder, ctypes.cast(ctypes.addressof(aom_encoder) + 128, ctypes.c_void_p)) == 0
+
+	return False
+
+
+def update_bitrate(aom_encoder : AomEncoder, bitrate : BitRate) -> bool:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library:
+		struct.pack_into('I', aom_encoder, 128 + 136, bitrate)
+		return aom_library.aom_codec_enc_config_set(aom_encoder, ctypes.cast(ctypes.addressof(aom_encoder) + 128, ctypes.c_void_p)) == 0
+
+	return False
+
+
+def destroy(aom_encoder : AomEncoder) -> None:
+	aom_library = aom_module.create_static_library()
+
+	if aom_library:
+		aom_library.aom_codec_destroy(aom_encoder)
@@ -0,0 +1,38 @@
+import ctypes
+from typing import Optional
+
+from facefusion.libraries import opus as opus_module
+from facefusion.types import Buffer, OpusDecoder
+
+
+def create(sample_rate : int, channel_total : int) -> Optional[OpusDecoder]:
+	opus_library = opus_module.create_static_library()
+
+	if opus_library:
+		return opus_library.opus_decoder_create(sample_rate, channel_total, ctypes.byref(ctypes.c_int(0)))
+
+	return None
+
+
+def decode(opus_decoder : OpusDecoder, input_buffer : Buffer, channel_total : int) -> Buffer:
+	opus_library = opus_module.create_static_library()
+	output_buffer = bytes()
+
+	if opus_library:
+		input_total = len(input_buffer)
+		sample_size = ctypes.sizeof(ctypes.c_float)
+		sample_total = opus_library.opus_decoder_get_nb_samples(opus_decoder, input_buffer, input_total)
+		sample_buffer = (ctypes.c_float * (sample_total * channel_total))()
+		output_total = opus_library.opus_decode_float(opus_decoder, input_buffer, input_total, sample_buffer, sample_total, 0)
+
+		if output_total:
+			output_buffer = ctypes.string_at(ctypes.addressof(sample_buffer), output_total * channel_total * sample_size)
+
+	return output_buffer
+
+
+def destroy(opus_decoder : OpusDecoder) -> None:
+	opus_library = opus_module.create_static_library()
+
+	if opus_library:
+		opus_library.opus_decoder_destroy(opus_decoder)
@@ -0,0 +1,38 @@
+import ctypes
+from typing import Optional
+
+from facefusion.libraries import opus as opus_module
+from facefusion.types import Buffer, OpusEncoder
+
+
+def create(sample_rate : int, channel_total : int) -> Optional[OpusEncoder]:
+	opus_library = opus_module.create_static_library()
+
+	if opus_library:
+		return opus_library.opus_encoder_create(sample_rate, channel_total, 2049, ctypes.byref(ctypes.c_int(0)))
+
+	return None
+
+
+def encode(opus_encoder : OpusEncoder, input_buffer : Buffer, channel_total : int) -> Buffer:
+	opus_library = opus_module.create_static_library()
+	output_buffer = bytes()
+
+	if opus_library:
+		sample_size = ctypes.sizeof(ctypes.c_float)
+		sample_total = len(input_buffer) // (sample_size * channel_total)
+		sample_buffer = (ctypes.c_float * (sample_total * channel_total)).from_buffer_copy(input_buffer)
+		temp_buffer = ctypes.create_string_buffer(2048)
+		output_total = opus_library.opus_encode_float(opus_encoder, sample_buffer, sample_total, temp_buffer, 2048)
+
+		if output_total:
+			output_buffer = temp_buffer.raw[:output_total]
+
+	return output_buffer
+
+
+def destroy(opus_encoder : OpusEncoder) -> None:
+	opus_library = opus_module.create_static_library()
+
+	if opus_library:
+		opus_library.opus_encoder_destroy(opus_encoder)
@@ -0,0 +1,74 @@
+import ctypes
+import struct
+from typing import Optional
+
+from facefusion.libraries import vpx as vpx_module
+from facefusion.types import Buffer, BufferPack, VpxDecoder, VxpVideoCodec
+
+
+def create(video_codec : VxpVideoCodec, thread_count : int) -> Optional[VpxDecoder]:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library:
+		vpx_decoder = ctypes.create_string_buffer(64)
+		vpx_algo = 'vpx_codec_vp8_dx_algo'
+
+		if video_codec == 'vp9':
+			vpx_algo = 'vpx_codec_vp9_dx_algo'
+
+		vpx_codec = ctypes.c_void_p.in_dll(vpx_library, vpx_algo)
+		config_buffer = ctypes.create_string_buffer(128)
+
+		struct.pack_into('I', config_buffer, 0, thread_count)
+
+		if vpx_library.vpx_codec_dec_init_ver(vpx_decoder, ctypes.byref(vpx_codec), config_buffer, 0, 12) == 0:
+			return vpx_decoder
+
+	return None
+
+
+def decode(vpx_decoder : VpxDecoder, input_buffer : Buffer) -> Optional[BufferPack]:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library and input_buffer:
+		input_total = len(input_buffer)
+		temp_buffer = ctypes.create_string_buffer(input_buffer)
+
+		if vpx_library.vpx_codec_decode(vpx_decoder, temp_buffer, input_total, None, 0) == 0:
+			address = vpx_library.vpx_codec_get_frame(vpx_decoder, ctypes.byref(ctypes.c_void_p(0)))
+
+			if address:
+				frame_width = ctypes.c_uint.from_address(address + 24).value & ~1
+				frame_height = ctypes.c_uint.from_address(address + 28).value & ~1
+
+				return BufferPack(
+					buffer = collect(address, frame_width, frame_height),
+					resolution = (frame_width, frame_height)
+				)
+
+	return None
+
+
+def collect(address : int, frame_width : int, frame_height : int) -> Buffer:
+	output_parts = []
+
+	for index in range(3):
+		plane_pointer = ctypes.c_void_p.from_address(address + 48 + index * 8).value
+		stride = ctypes.c_int.from_address(address + 80 + index * 4).value
+		plane_width = frame_width >> (index > 0)
+		plane_height = frame_height >> (index > 0)
+
+		if stride == plane_width:
+			output_parts.append(ctypes.string_at(plane_pointer, plane_width * plane_height))
+		else:
+			for row in range(plane_height):
+				output_parts.append(ctypes.string_at(plane_pointer + row * stride, plane_width))
+
+	return bytes().join(output_parts)
+
+
+def destroy(vpx_decoder : VpxDecoder) -> None:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library:
+		vpx_library.vpx_codec_destroy(vpx_decoder)
@@ -0,0 +1,104 @@
+import ctypes
+import struct
+from typing import Optional
+
+from facefusion.libraries import vpx as vpx_module
+from facefusion.types import BitRate, Buffer, Resolution, VpxEncoder, VxpVideoCodec
+
+
+def create(video_codec : VxpVideoCodec, frame_resolution : Resolution, bitrate : BitRate, thread_count : int, cpu_count : int) -> Optional[VpxEncoder]:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library:
+		vpx_encoder = ctypes.create_string_buffer(640)
+		vpx_algo = 'vpx_codec_vp8_cx_algo'
+
+		if video_codec == 'vp9':
+			vpx_algo = 'vpx_codec_vp9_cx_algo'
+
+		vpx_codec = ctypes.c_void_p.in_dll(vpx_library, vpx_algo)
+
+		config_buffer = ctypes.create_string_buffer(512)
+
+		if vpx_library.vpx_codec_enc_config_default(ctypes.byref(vpx_codec), config_buffer, 0) == 0:
+			struct.pack_into('I', config_buffer, 4, thread_count)
+			struct.pack_into('I', config_buffer, 12, frame_resolution[0])
+			struct.pack_into('I', config_buffer, 16, frame_resolution[1])
+			struct.pack_into('I', config_buffer, 28, 1)
+			struct.pack_into('I', config_buffer, 36, 0)
+			struct.pack_into('I', config_buffer, 44, 0)
+			struct.pack_into('I', config_buffer, 72, 0)
+			struct.pack_into('I', config_buffer, 112, bitrate)
+			struct.pack_into('I', config_buffer, 116, 2)
+			struct.pack_into('I', config_buffer, 120, 50)
+			struct.pack_into('I', config_buffer, 124, 50)
+			struct.pack_into('I', config_buffer, 128, 50)
+
+			if vpx_library.vpx_codec_enc_init_ver(vpx_encoder, ctypes.byref(vpx_codec), config_buffer, 0, 39) == 0:
+				vpx_library.vpx_codec_control_(vpx_encoder, 13, ctypes.c_int(cpu_count))
+				vpx_library.vpx_codec_control_(vpx_encoder, 12, ctypes.c_int(0))
+				vpx_library.vpx_codec_control_(vpx_encoder, 27, ctypes.c_int(10))
+				ctypes.memmove(ctypes.addressof(vpx_encoder) + 64, config_buffer, 512)
+				return vpx_encoder
+
+	return None
+
+
+def encode(vpx_encoder : VpxEncoder, input_buffer : Buffer, frame_resolution : Resolution, frame_index : int) -> Buffer:
+	vpx_library = vpx_module.create_static_library()
+	output_buffer = bytes()
+
+	if vpx_library:
+		temp_buffer = ctypes.create_string_buffer(256)
+		encode_buffer = ctypes.create_string_buffer(input_buffer)
+
+		if vpx_library.vpx_img_wrap(temp_buffer, 0x102, frame_resolution[0], frame_resolution[1], 1, encode_buffer) and vpx_library.vpx_codec_encode(vpx_encoder, temp_buffer, frame_index, 1, 0, 1) == 0:
+			output_buffer = collect(vpx_encoder)
+
+	return output_buffer
+
+
+def collect(vpx_encoder : VpxEncoder) -> Buffer:
+	vpx_library = vpx_module.create_static_library()
+	output_parts = []
+
+	packet_cursor = ctypes.c_void_p(0)
+	packet = vpx_library.vpx_codec_get_cx_data(vpx_encoder, ctypes.byref(packet_cursor))
+
+	while packet:
+		if ctypes.c_int.from_address(packet).value == 0:
+			buffer_pointer = ctypes.c_void_p.from_address(packet + 8).value
+			buffer_size = ctypes.c_size_t.from_address(packet + 16).value
+			output_parts.append(ctypes.string_at(buffer_pointer, buffer_size))
+
+		packet = vpx_library.vpx_codec_get_cx_data(vpx_encoder, ctypes.byref(packet_cursor))
+
+	return bytes().join(output_parts)
+
+
+def update_resolution(vpx_encoder : VpxEncoder, frame_resolution : Resolution) -> bool:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library:
+		struct.pack_into('I', vpx_encoder, 64 + 12, frame_resolution[0])
+		struct.pack_into('I', vpx_encoder, 64 + 16, frame_resolution[1])
+		return vpx_library.vpx_codec_enc_config_set(vpx_encoder, ctypes.cast(ctypes.addressof(vpx_encoder) + 64, ctypes.c_void_p)) == 0
+
+	return False
+
+
+def update_bitrate(vpx_encoder : VpxEncoder, bitrate : BitRate) -> bool:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library:
+		struct.pack_into('I', vpx_encoder, 64 + 112, bitrate)
+		return vpx_library.vpx_codec_enc_config_set(vpx_encoder, ctypes.cast(ctypes.addressof(vpx_encoder) + 64, ctypes.c_void_p)) == 0
+
+	return False
+
+
+def destroy(vpx_encoder : VpxEncoder) -> None:
+	vpx_library = vpx_module.create_static_library()
+
+	if vpx_library:
+		vpx_library.vpx_codec_destroy(vpx_encoder)
@@ -5,18 +5,22 @@ import signal
 import sys
 from time import time

-from facefusion import benchmarker, cli_helper, content_analyser, hash_helper, logger, state_manager, translator
-from facefusion.args import apply_args, collect_job_args, reduce_job_args, reduce_step_args
+import uvicorn
+
+import facefusion.apis.core
+from facefusion import args_helper, benchmarker, cli_helper, content_analyser, hash_helper, logger, state_manager, translator
+from facefusion.args_helper import apply_args
 from facefusion.download import conditional_download_hashes, conditional_download_sources
 from facefusion.exit_helper import hard_exit, signal_exit
-from facefusion.filesystem import get_file_extension, get_file_name, is_image, is_video, resolve_file_paths, resolve_file_pattern
+from facefusion.filesystem import get_file_extension, has_audio, has_image, has_video
+from facefusion.filesystem import get_file_name, resolve_file_paths, resolve_file_pattern
 from facefusion.jobs import job_helper, job_manager, job_runner
 from facefusion.jobs.job_list import compose_job_list
 from facefusion.processors.core import get_processors_modules
 from facefusion.program import create_program
 from facefusion.program_helper import validate_args
-from facefusion.types import Args, ErrorCode
-from facefusion.workflows import image_to_image, image_to_video
+from facefusion.types import Args, ErrorCode, WorkFlow
+from facefusion.workflows import audio_to_image, audio_to_image_as_frames, image_to_image, image_to_video, image_to_video_as_frames


 def cli() -> None:
@@ -49,37 +53,34 @@ def route(args : Args) -> None:
 			hard_exit(2)
 		benchmarker.render()

+	if state_manager.get_item('command') == 'api':
+		if not common_pre_check() or not processors_pre_check() or not facefusion.apis.core.pre_check():
+			hard_exit(2)
+
+		logger.info(translator.get('api_started').format(host = state_manager.get_item('api_host'), port = state_manager.get_item('api_port')), __name__)
+		uvicorn.run(facefusion.apis.core.create_api(), host = state_manager.get_item('api_host'), port = state_manager.get_item('api_port'))
+		hard_exit(1)
+
 	if state_manager.get_item('command') in [ 'job-list', 'job-create', 'job-submit', 'job-submit-all', 'job-delete', 'job-delete-all', 'job-add-step', 'job-remix-step', 'job-insert-step', 'job-remove-step' ]:
-		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		if not job_manager.init_jobs(state_manager.get_jobs_path()):
 			hard_exit(1)
 		error_code = route_job_manager(args)
 		hard_exit(error_code)

 	if state_manager.get_item('command') == 'run':
-		import facefusion.uis.core as ui
-
-		if not common_pre_check() or not processors_pre_check():
-			hard_exit(2)
-		for ui_layout in ui.get_ui_layouts_modules(state_manager.get_item('ui_layouts')):
-			if not ui_layout.pre_check():
-				hard_exit(2)
-		ui.init()
-		ui.launch()
-
-	if state_manager.get_item('command') == 'headless-run':
-		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		if not job_manager.init_jobs(state_manager.get_jobs_path()):
 			hard_exit(1)
 		error_code = process_headless(args)
 		hard_exit(error_code)

 	if state_manager.get_item('command') == 'batch-run':
-		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		if not job_manager.init_jobs(state_manager.get_jobs_path()):
 			hard_exit(1)
 		error_code = process_batch(args)
 		hard_exit(error_code)

 	if state_manager.get_item('command') in [ 'job-run', 'job-run-all', 'job-retry', 'job-retry-all' ]:
-		if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
+		if not job_manager.init_jobs(state_manager.get_jobs_path()):
 			hard_exit(1)
 		error_code = route_job_runner()
 		hard_exit(error_code)
@@ -182,7 +183,7 @@ def route_job_manager(args : Args) -> ErrorCode:
 		return 1

 	if state_manager.get_item('command') == 'job-add-step':
-		step_args = reduce_step_args(args)
+		step_args = args_helper.filter_step_args(args)

 		if job_manager.add_step(state_manager.get_item('job_id'), step_args):
 			logger.info(translator.get('job_step_added').format(job_id = state_manager.get_item('job_id')), __name__)
@@ -191,7 +192,7 @@ def route_job_manager(args : Args) -> ErrorCode:
 		return 1

 	if state_manager.get_item('command') == 'job-remix-step':
-		step_args = reduce_step_args(args)
+		step_args = args_helper.filter_step_args(args)

 		if job_manager.remix_step(state_manager.get_item('job_id'), state_manager.get_item('step_index'), step_args):
 			logger.info(translator.get('job_remix_step_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
@@ -200,7 +201,7 @@ def route_job_manager(args : Args) -> ErrorCode:
 		return 1

 	if state_manager.get_item('command') == 'job-insert-step':
-		step_args = reduce_step_args(args)
+		step_args = args_helper.filter_step_args(args)

 		if job_manager.insert_step(state_manager.get_item('job_id'), state_manager.get_item('step_index'), step_args):
 			logger.info(translator.get('job_step_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
@@ -254,7 +255,7 @@ def route_job_runner() -> ErrorCode:

 def process_headless(args : Args) -> ErrorCode:
 	job_id = job_helper.suggest_job_id('headless')
-	step_args = reduce_step_args(args)
+	step_args = args_helper.filter_step_args(args)

 	if job_manager.create_job(job_id) and job_manager.add_step(job_id, step_args) and job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step):
 		return 0
@@ -263,10 +264,9 @@ def process_headless(args : Args) -> ErrorCode:

 def process_batch(args : Args) -> ErrorCode:
 	job_id = job_helper.suggest_job_id('batch')
-	step_args = reduce_step_args(args)
-	job_args = reduce_job_args(args)
-	source_paths = resolve_file_pattern(job_args.get('source_pattern'))
-	target_paths = resolve_file_pattern(job_args.get('target_pattern'))
+	step_args = args_helper.filter_step_args(args)
+	source_paths = resolve_file_pattern(step_args.get('source_pattern'))
+	target_paths = resolve_file_pattern(step_args.get('target_pattern'))

 	if job_manager.create_job(job_id):
 		if source_paths and target_paths:
@@ -275,7 +275,7 @@ def process_batch(args : Args) -> ErrorCode:
 				step_args['target_path'] = target_path

 				try:
-					step_args['output_path'] = job_args.get('output_pattern').format(index = index, source_name = get_file_name(source_path), target_name = get_file_name(target_path), target_extension = get_file_extension(target_path))
+					step_args['output_path'] = step_args.get('output_pattern').format(index = index, source_name = get_file_name(source_path), target_name = get_file_name(target_path), target_extension = get_file_extension(target_path))
 				except KeyError:
 					return 1

@@ -289,7 +289,7 @@ def process_batch(args : Args) -> ErrorCode:
 				step_args['target_path'] = target_path

 				try:
-					step_args['output_path'] = job_args.get('output_pattern').format(index = index, target_name = get_file_name(target_path), target_extension = get_file_extension(target_path))
+					step_args['output_path'] = step_args.get('output_pattern').format(index = index, target_name = get_file_name(target_path), target_extension = get_file_extension(target_path))
 				except KeyError:
 					return 1

@@ -302,8 +302,10 @@ def process_batch(args : Args) -> ErrorCode:

 def process_step(job_id : str, step_index : int, step_args : Args) -> bool:
 	step_total = job_manager.count_step_total(job_id)
-	step_args.update(collect_job_args())
-	apply_args(step_args, state_manager.set_item)
+	cli_args = args_helper.extract_cli_args(state_manager.get_state())
+	args = cli_args.copy()
+	args.update(step_args)
+	apply_args(args, state_manager.set_item)

 	logger.info(translator.get('processing_step').format(step_current = step_index + 1, step_total = step_total), __name__)
 	if common_pre_check() and processors_pre_check():
@@ -315,15 +317,36 @@ def process_step(job_id : str, step_index : int, step_args : Args) -> bool:
 def conditional_process() -> ErrorCode:
 	start_time = time()

+	if state_manager.get_item('workflow') == 'auto':
+		state_manager.set_item('workflow', detect_workflow())
+
 	for processor_module in get_processors_modules(state_manager.get_item('processors')):
 		if not processor_module.pre_process('output'):
 			return 2

-	if is_image(state_manager.get_item('target_path')):
+	if state_manager.get_item('workflow') == 'audio-to-image:video':
+		return audio_to_image.process(start_time)
+	if state_manager.get_item('workflow') == 'audio-to-image:frames':
+		return audio_to_image_as_frames.process(start_time)
+	if state_manager.get_item('workflow') == 'image-to-image':
 		return image_to_image.process(start_time)
-	if is_video(state_manager.get_item('target_path')):
+	if state_manager.get_item('workflow') == 'image-to-video':
 		return image_to_video.process(start_time)
+	if state_manager.get_item('workflow') == 'image-to-video:frames':
+		return image_to_video_as_frames.process(start_time)

 	return 0


+def detect_workflow() -> WorkFlow:
+	if has_video([ state_manager.get_item('target_path') ]):
+		if get_file_extension(state_manager.get_item('output_path')):
+			return 'image-to-video'
+		return 'image-to-video:frames'
+
+	if has_audio(state_manager.get_item('source_paths')) and has_image([ state_manager.get_item('target_path') ]):
+		if get_file_extension(state_manager.get_item('output_path')):
+			return 'audio-to-image:video'
+		return 'audio-to-image:frames'
+
+	return 'image-to-image'
@@ -10,10 +10,10 @@ import facefusion.choices
 from facefusion import curl_builder, logger, process_manager, state_manager, translator
 from facefusion.filesystem import get_file_name, get_file_size, is_file, remove_file
 from facefusion.hash_helper import validate_hash
-from facefusion.types import Command, DownloadProvider, DownloadSet
+from facefusion.types import Buffer, Command, DownloadProvider, DownloadSet


-def open_curl(commands : List[Command]) -> subprocess.Popen[bytes]:
+def open_curl(commands : List[Command]) -> subprocess.Popen[Buffer]:
 	commands = curl_builder.run(commands)
 	return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)

@@ -1,15 +1,13 @@
 import os
-import shutil
-import subprocess
-import xml.etree.ElementTree as ElementTree
 from functools import lru_cache
-from typing import List, Optional
+from typing import List, Tuple

 import onnxruntime

 import facefusion.choices
 from facefusion.filesystem import create_directory, is_directory
-from facefusion.types import ExecutionDevice, ExecutionProvider, InferenceOptionSet, InferenceProvider, ValueAndUnit
+from facefusion.system import detect_graphic_devices
+from facefusion.types import ExecutionProvider, InferenceOptionSet, InferenceProvider

 onnxruntime.set_default_logger_severity(3)

@@ -39,7 +37,7 @@ def create_inference_providers(execution_device_id : int, execution_providers :
 			inference_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
 			{
 				'device_id': execution_device_id,
-				'cudnn_conv_algo_search': resolve_cudnn_conv_algo_search()
+				'cudnn_conv_algo_search': resolve_static_cudnn_conv_algo_search(tuple(execution_providers))
 			}))

 		if execution_provider == 'tensorrt':
@@ -112,13 +110,19 @@ def resolve_cache_path() -> str:
 	return os.path.join('.caches', onnxruntime.get_version_string())


-def resolve_cudnn_conv_algo_search() -> str:
-	execution_devices = detect_static_execution_devices()
-	product_names = ('GeForce GTX 1630', 'GeForce GTX 1650', 'GeForce GTX 1660')
+@lru_cache()
+def resolve_static_cudnn_conv_algo_search(execution_providers : Tuple[ExecutionProvider, ...]) -> str:
+	return resolve_cudnn_conv_algo_search(list(execution_providers))

-	for execution_device in execution_devices:
-		if execution_device.get('product').get('name').startswith(product_names):
-			return 'DEFAULT'
+
+def resolve_cudnn_conv_algo_search(execution_providers : List[ExecutionProvider]) -> str:
+	if has_execution_provider('cuda') or has_execution_provider('tensorrt'):
+		graphic_devices = detect_graphic_devices(execution_providers)
+		product_names = ('GeForce GTX 1630', 'GeForce GTX 1650', 'GeForce GTX 1660')
+
+		for graphic_device in graphic_devices:
+			if graphic_device.get('product').get('name').startswith(product_names):
+				return 'DEFAULT'

 	return 'EXHAUSTIVE'

@@ -127,68 +131,3 @@ def resolve_openvino_device_type(execution_device_id : int) -> str:
 	if execution_device_id == 0:
 		return 'GPU'
 	return 'GPU.' + str(execution_device_id)
-
-
-def run_nvidia_smi() -> subprocess.Popen[bytes]:
-	commands = [ shutil.which('nvidia-smi'), '--query', '--xml-format' ]
-	return subprocess.Popen(commands, stdout = subprocess.PIPE)
-
-
-@lru_cache()
-def detect_static_execution_devices() -> List[ExecutionDevice]:
-	return detect_execution_devices()
-
-
-def detect_execution_devices() -> List[ExecutionDevice]:
-	execution_devices : List[ExecutionDevice] = []
-
-	try:
-		output, _ = run_nvidia_smi().communicate()
-		root_element = ElementTree.fromstring(output)
-	except Exception:
-		root_element = ElementTree.Element('xml')
-
-	for gpu_element in root_element.findall('gpu'):
-		execution_devices.append(
-		{
-			'driver_version': root_element.findtext('driver_version'),
-			'framework':
-			{
-				'name': 'CUDA',
-				'version': root_element.findtext('cuda_version')
-			},
-			'product':
-			{
-				'vendor': 'NVIDIA',
-				'name': gpu_element.findtext('product_name').replace('NVIDIA', '').strip()
-			},
-			'video_memory':
-			{
-				'total': create_value_and_unit(gpu_element.findtext('fb_memory_usage/total')),
-				'free': create_value_and_unit(gpu_element.findtext('fb_memory_usage/free'))
-			},
-			'temperature':
-			{
-				'gpu': create_value_and_unit(gpu_element.findtext('temperature/gpu_temp')),
-				'memory': create_value_and_unit(gpu_element.findtext('temperature/memory_temp'))
-			},
-			'utilization':
-			{
-				'gpu': create_value_and_unit(gpu_element.findtext('utilization/gpu_util')),
-				'memory': create_value_and_unit(gpu_element.findtext('utilization/memory_util'))
-			}
-		})
-
-	return execution_devices
-
-
-def create_value_and_unit(text : str) -> Optional[ValueAndUnit]:
-	if ' ' in text:
-		value, unit = text.split()
-
-		return\
-		{
-			'value': int(value),
-			'unit': str(unit)
-		}
-	return None
@@ -28,7 +28,7 @@ def graceful_exit(error_code : ErrorCode) -> None:
 	while process_manager.is_processing():
 		sleep(0.5)

-	if state_manager.get_item('target_path'):
-		clear_temp_directory(state_manager.get_item('target_path'))
+	if state_manager.get_item('output_path'):
+		clear_temp_directory(state_manager.get_temp_path(), state_manager.get_item('output_path'))

 	hard_exit(error_code)
@@ -228,7 +228,7 @@ def detect_with_retinaface(vision_frame : VisionFrame, face_detector_size : str)
 		if numpy.any(keep_indices):
 			stride_height = face_detector_height // feature_stride
 			stride_width = face_detector_width // feature_stride
-			anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
+			anchors = create_static_anchors(feature_stride, anchor_total, stride_width, stride_height)
 			bounding_boxes_raw = detection[index + feature_map_channel] * feature_stride
 			face_landmarks_5_raw = detection[index + feature_map_channel * 2] * feature_stride

@@ -273,7 +273,7 @@ def detect_with_scrfd(vision_frame : VisionFrame, face_detector_size : str) -> T
 		if numpy.any(keep_indices):
 			stride_height = face_detector_height // feature_stride
 			stride_width = face_detector_width // feature_stride
-			anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
+			anchors = create_static_anchors(feature_stride, anchor_total, stride_width, stride_height)
 			bounding_boxes_raw = detection[index + feature_map_channel] * feature_stride
 			face_landmarks_5_raw = detection[index + feature_map_channel * 2] * feature_stride

@@ -356,7 +356,7 @@ def detect_with_yunet(vision_frame : VisionFrame, face_detector_size : str) -> T
 		if numpy.any(keep_indices):
 			stride_height = face_detector_height // feature_stride
 			stride_width = face_detector_width // feature_stride
-			anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
+			anchors = create_static_anchors(feature_stride, anchor_total, stride_width, stride_height)
 			bounding_boxes_center = detection[index + feature_map_channel * 2].squeeze(0)[:, :2] * feature_stride + anchors
 			bounding_boxes_size = numpy.exp(detection[index + feature_map_channel * 2].squeeze(0)[:, 2:4]) * feature_stride
 			face_landmarks_5_raw = detection[index + feature_map_channel * 3].squeeze(0)
@@ -131,7 +131,7 @@ def calculate_paste_area(temp_vision_frame : VisionFrame, crop_vision_frame : Vi


@lru_cache()
-def create_static_anchors(feature_stride : int, anchor_total : int, stride_height : int, stride_width : int) -> Anchors:
+def create_static_anchors(feature_stride : int, anchor_total : int, stride_width : int, stride_height : int) -> Anchors:
 	x, y = numpy.mgrid[:stride_width, :stride_height]
 	anchors = numpy.stack((y, x), axis = -1)
 	anchors = (anchors * feature_stride).reshape((-1, 2))
@@ -1,7 +1,7 @@
 import os
 import subprocess
 import tempfile
-from functools import partial
+from functools import lru_cache, partial
 from typing import List, Optional, cast

 from tqdm import tqdm
@@ -9,12 +9,12 @@ from tqdm import tqdm
 import facefusion.choices
 from facefusion import ffmpeg_builder, logger, process_manager, state_manager, translator
 from facefusion.filesystem import get_file_format, remove_file
-from facefusion.temp_helper import get_temp_file_path, get_temp_frame_pattern
-from facefusion.types import AudioBuffer, AudioEncoder, Command, EncoderSet, Fps, Resolution, UpdateProgress, VideoEncoder, VideoFormat
+from facefusion.temp_helper import get_temp_file_path, get_temp_frames_pattern
+from facefusion.types import ApiSecurityStrategy, AudioEncoder, Buffer, Command, EncoderSet, Fps, Resolution, SampleRate, UpdateProgress, VideoEncoder, VideoFormat
 from facefusion.vision import detect_video_duration, detect_video_fps, pack_resolution, predict_video_frame_total


-def run_ffmpeg_with_progress(commands : List[Command], update_progress : UpdateProgress) -> subprocess.Popen[bytes]:
+def run_ffmpeg_with_progress(commands : List[Command], update_progress : UpdateProgress) -> subprocess.Popen[Buffer]:
 	log_level = state_manager.get_item('log_level')
 	commands.extend(ffmpeg_builder.set_progress())
 	commands.extend(ffmpeg_builder.cast_stream())
@@ -45,7 +45,14 @@ def update_progress(progress : tqdm, frame_number : int) -> None:
 	progress.update(frame_number - progress.n)


-def run_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
+def run_ffmpeg_with_pipe(commands : List[Command], file_content : Buffer) -> subprocess.Popen[Buffer]:
+	commands = ffmpeg_builder.run(commands)
+	process = subprocess.Popen(commands, stdin = subprocess.PIPE, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
+	process.communicate(input = file_content)
+	return process
+
+
+def run_ffmpeg(commands : List[Command]) -> subprocess.Popen[Buffer]:
 	log_level = state_manager.get_item('log_level')
 	commands = ffmpeg_builder.run(commands)
 	process = subprocess.Popen(commands, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
@@ -65,14 +72,14 @@ def run_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
 	return process


-def open_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
+def open_ffmpeg(commands : List[Command]) -> subprocess.Popen[Buffer]:
 	commands = ffmpeg_builder.run(commands)
 	return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)


-def log_debug(process : subprocess.Popen[bytes]) -> None:
+def log_debug(process : subprocess.Popen[Buffer]) -> None:
 	_, stderr = process.communicate()
-	errors = stderr.decode().split(os.linesep)
+	errors = stderr.decode().splitlines()

 	for error in errors:
 		if error.strip():
@@ -83,6 +90,7 @@ def get_available_encoder_set() -> EncoderSet:
 	available_encoder_set : EncoderSet =\
 	{
 		'audio': [],
+		'image': [],
 		'video': []
 	}
 	commands = ffmpeg_builder.chain(
@@ -94,22 +102,29 @@ def get_available_encoder_set() -> EncoderSet:
 		if line.startswith(' a'):
 			audio_encoder = line.split()[1]

-			if audio_encoder in facefusion.choices.output_audio_encoders:
-				index = facefusion.choices.output_audio_encoders.index(audio_encoder) #type:ignore[arg-type]
-				available_encoder_set['audio'].insert(index, audio_encoder) #type:ignore[arg-type]
-		if line.startswith(' v'):
-			video_encoder = line.split()[1]
+			if audio_encoder in facefusion.choices.audio_encoders and audio_encoder not in available_encoder_set.get('audio'):
+				available_encoder_set['audio'].append(audio_encoder) #type:ignore[arg-type]

-			if video_encoder in facefusion.choices.output_video_encoders:
-				index = facefusion.choices.output_video_encoders.index(video_encoder) #type:ignore[arg-type]
-				available_encoder_set['video'].insert(index, video_encoder) #type:ignore[arg-type]
+		if line.startswith(' v'):
+			vision_encoder = line.split()[1]
+
+			if vision_encoder in facefusion.choices.image_encoders and vision_encoder not in available_encoder_set.get('image'):
+				available_encoder_set['image'].append(vision_encoder) #type:ignore[arg-type]
+
+			if vision_encoder in facefusion.choices.video_encoders and vision_encoder not in available_encoder_set.get('video'):
+				available_encoder_set['video'].append(vision_encoder) #type:ignore[arg-type]

 	return available_encoder_set


-def extract_frames(target_path : str, temp_video_resolution : Resolution, temp_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
+@lru_cache(maxsize = None)
+def get_static_available_encoder_set() -> EncoderSet:
+	return get_available_encoder_set()
+
+
+def extract_frames(target_path : str, output_path : str, temp_video_resolution : Resolution, temp_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
 	extract_frame_total = predict_video_frame_total(target_path, temp_video_fps, trim_frame_start, trim_frame_end)
-	temp_frame_pattern = get_temp_frame_pattern(target_path, '%08d')
+	temp_frames_pattern = get_temp_frames_pattern(state_manager.get_temp_path(), output_path, state_manager.get_item('temp_frame_format'), '%08d')
 	commands = ffmpeg_builder.chain(
 		ffmpeg_builder.set_input(target_path),
 		ffmpeg_builder.set_media_resolution(pack_resolution(temp_video_resolution)),
@@ -118,7 +133,7 @@ def extract_frames(target_path : str, temp_video_resolution : Resolution, temp_v
 		ffmpeg_builder.select_frame_range(trim_frame_start, trim_frame_end, temp_video_fps),
 		ffmpeg_builder.prevent_frame_drop(),
 		ffmpeg_builder.set_start_number(trim_frame_start),
-		ffmpeg_builder.set_output(temp_frame_pattern)
+		ffmpeg_builder.set_output(temp_frames_pattern)
 	)

 	with tqdm(total = extract_frame_total, desc = translator.get('extracting'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
@@ -126,8 +141,26 @@ def extract_frames(target_path : str, temp_video_resolution : Resolution, temp_v
 		return process.returncode == 0


-def copy_image(target_path : str, temp_image_resolution : Resolution) -> bool:
-	temp_image_path = get_temp_file_path(target_path)
+def spawn_frames(target_path : str, output_path : str, temp_video_resolution : Resolution, temp_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
+	spawn_frame_total = trim_frame_end - trim_frame_start
+	duration = spawn_frame_total / temp_video_fps
+	temp_frames_pattern = get_temp_frames_pattern(state_manager.get_temp_path(), output_path, state_manager.get_item('temp_frame_format'), '%08d')
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_loop(),
+		ffmpeg_builder.set_input(target_path),
+		ffmpeg_builder.set_video_duration(duration),
+		ffmpeg_builder.set_video_fps(temp_video_fps),
+		ffmpeg_builder.set_media_resolution(pack_resolution(temp_video_resolution)),
+		ffmpeg_builder.set_output(temp_frames_pattern)
+	)
+
+	with tqdm(total = spawn_frame_total, desc = translator.get('spawning'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
+		process = run_ffmpeg_with_progress(commands, partial(update_progress, progress))
+		return process.returncode == 0
+
+
+def copy_image(target_path : str, output_path : str, temp_image_resolution : Resolution) -> bool:
+	temp_image_path = get_temp_file_path(state_manager.get_temp_path(), output_path)
 	commands = ffmpeg_builder.chain(
 		ffmpeg_builder.set_input(target_path),
 		ffmpeg_builder.set_media_resolution(pack_resolution(temp_image_resolution)),
@@ -137,19 +170,19 @@ def copy_image(target_path : str, temp_image_resolution : Resolution) -> bool:
 	return run_ffmpeg(commands).returncode == 0


-def finalize_image(target_path : str, output_path : str, output_image_resolution : Resolution) -> bool:
+def finalize_image(output_path : str, output_image_resolution : Resolution) -> bool:
 	output_image_quality = state_manager.get_item('output_image_quality')
-	temp_image_path = get_temp_file_path(target_path)
+	temp_image_path = get_temp_file_path(state_manager.get_temp_path(), output_path)
 	commands = ffmpeg_builder.chain(
 		ffmpeg_builder.set_input(temp_image_path),
 		ffmpeg_builder.set_media_resolution(pack_resolution(output_image_resolution)),
-		ffmpeg_builder.set_image_quality(target_path, output_image_quality),
+		ffmpeg_builder.set_image_quality(output_path, output_image_quality),
 		ffmpeg_builder.force_output(output_path)
 	)
 	return run_ffmpeg(commands).returncode == 0


-def read_audio_buffer(target_path : str, audio_sample_rate : int, audio_sample_size : int, audio_channel_total : int) -> Optional[AudioBuffer]:
+def read_audio_buffer(target_path : str, audio_sample_rate : SampleRate, audio_sample_size : int, audio_channel_total : int) -> Optional[Buffer]:
 	commands = ffmpeg_builder.chain(
 		ffmpeg_builder.set_input(target_path),
 		ffmpeg_builder.ignore_video_stream(),
@@ -161,6 +194,7 @@ def read_audio_buffer(target_path : str, audio_sample_rate : int, audio_sample_s

 	process = open_ffmpeg(commands)
 	audio_buffer, _ = process.communicate()
+
 	if process.returncode == 0:
 		return audio_buffer
 	return None
@@ -171,8 +205,8 @@ def restore_audio(target_path : str, output_path : str, trim_frame_start : int,
 	output_audio_quality = state_manager.get_item('output_audio_quality')
 	output_audio_volume = state_manager.get_item('output_audio_volume')
 	target_video_fps = detect_video_fps(target_path)
-	temp_video_path = get_temp_file_path(target_path)
-	temp_video_format = cast(VideoFormat, get_file_format(temp_video_path))
+	temp_video_path = get_temp_file_path(state_manager.get_temp_path(), output_path)
+	temp_video_format = cast(VideoFormat, get_file_format(output_path))
 	temp_video_duration = detect_video_duration(temp_video_path)
 	output_video_format = cast(VideoFormat, get_file_format(output_path))

@@ -194,12 +228,12 @@ def restore_audio(target_path : str, output_path : str, trim_frame_start : int,
 	return run_ffmpeg(commands).returncode == 0


-def replace_audio(target_path : str, audio_path : str, output_path : str) -> bool:
+def replace_audio(audio_path : str, output_path : str) -> bool:
 	output_audio_encoder = state_manager.get_item('output_audio_encoder')
 	output_audio_quality = state_manager.get_item('output_audio_quality')
 	output_audio_volume = state_manager.get_item('output_audio_volume')
-	temp_video_path = get_temp_file_path(target_path)
-	temp_video_format = cast(VideoFormat, get_file_format(temp_video_path))
+	temp_video_path = get_temp_file_path(state_manager.get_temp_path(), output_path)
+	temp_video_format = cast(VideoFormat, get_file_format(output_path))
 	temp_video_duration = detect_video_duration(temp_video_path)
 	output_video_format = cast(VideoFormat, get_file_format(output_path))

@@ -218,20 +252,20 @@ def replace_audio(target_path : str, audio_path : str, output_path : str) -> boo
 	return run_ffmpeg(commands).returncode == 0


-def merge_video(target_path : str, temp_video_fps : Fps, output_video_resolution : Resolution, output_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
+def merge_video(target_path : str, output_path : str, temp_video_fps : Fps, output_video_fps : Fps, output_video_resolution : Resolution, trim_frame_start : int, trim_frame_end : int) -> bool:
 	output_video_encoder = state_manager.get_item('output_video_encoder')
 	output_video_quality = state_manager.get_item('output_video_quality')
 	output_video_preset = state_manager.get_item('output_video_preset')
 	merge_frame_total = predict_video_frame_total(target_path, output_video_fps, trim_frame_start, trim_frame_end)
-	temp_video_path = get_temp_file_path(target_path)
-	temp_video_format = cast(VideoFormat, get_file_format(temp_video_path))
-	temp_frame_pattern = get_temp_frame_pattern(target_path, '%08d')
+	temp_video_path = get_temp_file_path(state_manager.get_temp_path(), output_path)
+	temp_video_format = cast(VideoFormat, get_file_format(output_path))
+	temp_frames_pattern = get_temp_frames_pattern(state_manager.get_temp_path(), output_path, state_manager.get_item('temp_frame_format'), '%08d')

 	output_video_encoder = fix_video_encoder(temp_video_format, output_video_encoder)
 	commands = ffmpeg_builder.chain(
 		ffmpeg_builder.set_input_fps(temp_video_fps),
 		ffmpeg_builder.set_start_number(trim_frame_start),
-		ffmpeg_builder.set_input(temp_frame_pattern),
+		ffmpeg_builder.set_input(temp_frames_pattern),
 		ffmpeg_builder.set_media_resolution(pack_resolution(output_video_resolution)),
 		ffmpeg_builder.set_video_encoder(output_video_encoder),
 		ffmpeg_builder.set_video_tag(output_video_encoder, temp_video_format),
@@ -276,6 +310,60 @@ def concat_video(output_path : str, temp_output_paths : List[str]) -> bool:
 	return process.returncode == 0


+def sanitize_audio(file_content : Buffer, asset_path : str, security_strategy : ApiSecurityStrategy) -> bool:
+	if security_strategy == 'strict':
+		commands = ffmpeg_builder.chain(
+			ffmpeg_builder.set_input('pipe:0'),
+			ffmpeg_builder.deep_copy_audio(),
+			ffmpeg_builder.strip_metadata(),
+			ffmpeg_builder.force_output(asset_path)
+		)
+		return run_ffmpeg_with_pipe(commands, file_content).returncode == 0
+
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input('pipe:0'),
+		ffmpeg_builder.copy_audio_encoder(),
+		ffmpeg_builder.strip_metadata(),
+		ffmpeg_builder.force_output(asset_path)
+	)
+	return run_ffmpeg_with_pipe(commands, file_content).returncode == 0
+
+
+def sanitize_image(file_content : Buffer, asset_path : str) -> bool:
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input('pipe:0'),
+		ffmpeg_builder.deep_copy_image(),
+		ffmpeg_builder.strip_metadata(),
+		ffmpeg_builder.force_output(asset_path)
+	)
+	return run_ffmpeg_with_pipe(commands, file_content).returncode == 0
+
+
+def sanitize_video(file_content : Buffer, asset_path : str, security_strategy : ApiSecurityStrategy) -> bool:
+	if security_strategy == 'strict':
+		available_video_encoders = get_static_available_encoder_set().get('video')
+		commands = ffmpeg_builder.chain(
+			ffmpeg_builder.set_input('pipe:0'),
+			ffmpeg_builder.set_video_encoder(available_video_encoders[0]),
+			ffmpeg_builder.set_video_preset(available_video_encoders[0], 'ultrafast'),
+			ffmpeg_builder.set_pixel_format(available_video_encoders[0]),
+			ffmpeg_builder.deep_copy_video(),
+			ffmpeg_builder.deep_copy_audio(),
+			ffmpeg_builder.strip_metadata(),
+			ffmpeg_builder.force_output(asset_path)
+		)
+		return run_ffmpeg_with_pipe(commands, file_content).returncode == 0
+
+	commands = ffmpeg_builder.chain(
+		ffmpeg_builder.set_input('pipe:0'),
+		ffmpeg_builder.copy_video_encoder(),
+		ffmpeg_builder.copy_audio_encoder(),
+		ffmpeg_builder.strip_metadata(),
+		ffmpeg_builder.force_output(asset_path)
+	)
+	return run_ffmpeg_with_pipe(commands, file_content).returncode == 0
+
+
 def fix_audio_encoder(video_format : VideoFormat, audio_encoder : AudioEncoder) -> AudioEncoder:
 	if video_format == 'avi' and audio_encoder == 'libopus':
 		return 'aac'
@@ -5,7 +5,7 @@ from typing import List, Optional
 import numpy

 from facefusion.filesystem import get_file_format
-from facefusion.types import AudioEncoder, Command, CommandSet, Duration, Fps, StreamMode, VideoEncoder, VideoFormat, VideoPreset
+from facefusion.types import AudioEncoder, Command, CommandSet, Duration, Fps, SampleRate, StreamMode, VideoEncoder, VideoFormat, VideoPreset


 def run(commands : List[Command]) -> List[Command]:
@@ -63,6 +63,10 @@ def force_output(output_path : str) -> List[Command]:
 	return [ '-y', output_path ]


+def set_loop() -> List[Command]:
+	return [ '-loop', '1' ]
+
+
 def cast_stream() -> List[Command]:
 	return [ '-' ]

@@ -87,6 +91,10 @@ def enforce_pixel_format(pixel_format : str) -> List[Command]:
 	return [ '-pix_fmt', pixel_format ]


+def strip_metadata() -> List[Command]:
+	return [ '-map_metadata', '-1' ]
+
+
 def set_pixel_format(video_encoder : VideoEncoder) -> List[Command]:
 	if video_encoder == 'rawvideo':
 		return [ '-pix_fmt', 'rgb24' ]
@@ -131,12 +139,8 @@ def set_media_resolution(video_resolution : str) -> List[Command]:
 	return [ '-s', video_resolution ]


-def set_image_quality(image_path : str, image_quality : int) -> List[Command]:
-	if get_file_format(image_path) == 'webp':
-		return [ '-q:v', str(image_quality) ]
-
-	image_compression = round(31 - (image_quality * 0.31))
-	return [ '-q:v', str(image_compression) ]
+def deep_copy_audio() -> List[Command]:
+	return [ '-q:a', '0' ]


 def set_audio_encoder(audio_codec : str) -> List[Command]:
@@ -147,7 +151,7 @@ def copy_audio_encoder() -> List[Command]:
 	return set_audio_encoder('copy')


-def set_audio_sample_rate(audio_sample_rate : int) -> List[Command]:
+def set_audio_sample_rate(audio_sample_rate : SampleRate) -> List[Command]:
 	return [ '-ar', str(audio_sample_rate) ]


@@ -183,6 +187,22 @@ def set_audio_volume(audio_volume : int) -> List[Command]:
 	return [ '-filter:a', 'volume=' + str(audio_volume / 100) ]


+def deep_copy_image() -> List[Command]:
+	return [ '-q:v', '0' ]
+
+
+def set_image_quality(image_path : str, image_quality : int) -> List[Command]:
+	if get_file_format(image_path) == 'webp':
+		return [ '-q:v', str(image_quality) ]
+
+	image_compression = round(31 - (image_quality * 0.31))
+	return [ '-q:v', str(image_compression) ]
+
+
+def deep_copy_video() -> List[Command]:
+	return [ '-q:v', '0' ]
+
+
 def set_video_encoder(video_encoder : str) -> List[Command]:
 	return [ '-c:v', video_encoder ]

@@ -285,3 +305,5 @@ def map_qsv_preset(video_preset : VideoPreset) -> Optional[str]:
 	if video_preset in [ 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow' ]:
 		return video_preset
 	return None
+
+
@@ -0,0 +1,84 @@
+import subprocess
+from typing import Dict, List
+
+from facefusion import ffprobe_builder
+from facefusion.types import AudioMetadata, Buffer, Command, Fps, VideoMetadata
+
+
+def run_ffprobe(commands : List[Command]) -> subprocess.Popen[Buffer]:
+	commands = ffprobe_builder.run(commands)
+	return subprocess.Popen(commands, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
+
+
+def probe_entries(media_path : str, entries : List[str]) -> Dict[str, str]:
+	media_entries = {}
+
+	commands = ffprobe_builder.chain(
+		ffprobe_builder.show_entries(entries),
+		ffprobe_builder.format_to_key_value(),
+		ffprobe_builder.set_input(media_path)
+	)
+	output, _ = run_ffprobe(commands).communicate()
+
+	if output:
+		lines = output.decode().strip().splitlines()
+
+		for line in lines:
+			if '=' in line:
+				key, value = line.split('=', 1)
+				media_entries[key] = value
+
+	return media_entries
+
+
+def extract_audio_metadata(audio_path : str) -> AudioMetadata:
+	audio_entries = probe_entries(audio_path, [ 'duration', 'sample_rate', 'channels', 'bit_rate' ])
+
+	duration = float(audio_entries.get('duration'))
+	sample_rate = int(audio_entries.get('sample_rate'))
+	frame_total = int(duration * sample_rate)
+	channel_total = int(audio_entries.get('channels'))
+	bit_rate = int(audio_entries.get('bit_rate'))
+
+	audio_metadata : AudioMetadata =\
+	{
+		'duration' : duration,
+		'frame_total' : frame_total,
+		'channel_total' : channel_total,
+		'sample_rate' : sample_rate,
+		'bit_rate' : bit_rate
+	}
+
+	return audio_metadata
+
+
+def extract_video_metadata(video_path : str) -> VideoMetadata:
+	video_entries = probe_entries(video_path, [ 'duration', 'width', 'height', 'r_frame_rate', 'bit_rate' ])
+
+	duration = float(video_entries.get('duration'))
+	fps = extract_video_fps(video_entries.get('r_frame_rate'))
+	frame_total = int(duration * fps)
+	width = int(video_entries.get('width'))
+	height = int(video_entries.get('height'))
+	bit_rate = int(video_entries.get('bit_rate'))
+
+	video_metadata : VideoMetadata =\
+	{
+		'duration' : duration,
+		'frame_total' : frame_total,
+		'fps' : fps,
+		'resolution' : (width, height),
+		'bit_rate' : bit_rate
+	}
+
+	return video_metadata
+
+
+def extract_video_fps(frame_rate : str) -> Fps:
+	if frame_rate and '/' in frame_rate:
+		numerator, denominator = frame_rate.split('/')
+
+		if int(numerator) and int(denominator):
+			return int(numerator) / int(denominator)
+
+	return 0.0
@@ -0,0 +1,29 @@
+import itertools
+import shutil
+from typing import List
+
+from facefusion.types import Command
+
+
+def run(commands : List[Command]) -> List[Command]:
+	return [ shutil.which('ffprobe'), '-loglevel', 'error' ] + commands
+
+
+def chain(*commands : List[Command]) -> List[Command]:
+	return list(itertools.chain(*commands))
+
+
+def show_entries(entries : List[str]) -> List[Command]:
+	return [ '-show_entries', 'stream=' + ','.join(entries) ]
+
+
+def format_to_value() -> List[Command]:
+	return [ '-of', 'default=noprint_wrappers=1:nokey=1' ]
+
+
+def format_to_key_value() -> List[Command]:
+	return [ '-of', 'default=noprint_wrappers=1' ]
+
+
+def set_input(input_path : str) -> List[Command]:
+	return [ '-i', input_path ]
@@ -42,15 +42,6 @@ def get_file_format(file_path : str) -> Optional[str]:
 	return None


-def same_file_extension(first_file_path : str, second_file_path : str) -> bool:
-	first_file_extension = get_file_extension(first_file_path)
-	second_file_extension = get_file_extension(second_file_path)
-
-	if first_file_extension and second_file_extension:
-		return get_file_extension(first_file_path) == get_file_extension(second_file_path)
-	return False
-
-
 def is_file(file_path : str) -> bool:
 	if file_path:
 		return os.path.isfile(file_path)
@@ -179,6 +170,13 @@ def create_directory(directory_path : str) -> bool:
 	return False


+def move_directory(directory_path : str, move_path : str) -> bool:
+	if is_directory(directory_path):
+		shutil.move(directory_path, move_path)
+		return is_directory(move_path)
+	return False
+
+
 def remove_directory(directory_path : str) -> bool:
 	if is_directory(directory_path):
 		shutil.rmtree(directory_path, ignore_errors = True)
@@ -3,10 +3,11 @@ import zlib
 from typing import Optional

 from facefusion.filesystem import get_file_name, is_file
+from facefusion.types import Buffer


-def create_hash(content : bytes) -> str:
-	return format(zlib.crc32(content), '08x')
+def create_hash(buffer : Buffer) -> str:
+	return format(zlib.crc32(buffer), '08x')


 def validate_hash(validate_path : str) -> bool:
@@ -18,7 +18,7 @@ from facefusion.types import DownloadSet, ExecutionProvider, InferencePool, Infe
 INFERENCE_POOL_SET : InferencePoolSet =\
 {
 	'cli': {},
-	'ui': {}
+	'api': {}
 }


@@ -32,10 +32,10 @@ def get_inference_pool(module_name : str, model_names : List[str], model_source_
 	for execution_device_id in execution_device_ids:
 		inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)

-		if app_context == 'cli' and INFERENCE_POOL_SET.get('ui').get(inference_context):
-			INFERENCE_POOL_SET['cli'][inference_context] = INFERENCE_POOL_SET.get('ui').get(inference_context)
-		if app_context == 'ui' and INFERENCE_POOL_SET.get('cli').get(inference_context):
-			INFERENCE_POOL_SET['ui'][inference_context] = INFERENCE_POOL_SET.get('cli').get(inference_context)
+		if app_context == 'cli' and INFERENCE_POOL_SET.get('api').get(inference_context):
+			INFERENCE_POOL_SET['cli'][inference_context] = INFERENCE_POOL_SET.get('api').get(inference_context)
+		if app_context == 'api' and INFERENCE_POOL_SET.get('cli').get(inference_context):
+			INFERENCE_POOL_SET['api'][inference_context] = INFERENCE_POOL_SET.get('cli').get(inference_context)
 		if not INFERENCE_POOL_SET.get(app_context).get(inference_context):
 			inference_providers = resolve_static_inference_providers(module_name, execution_device_id)
 			INFERENCE_POOL_SET[app_context][inference_context] = create_inference_pool(model_source_set, inference_providers)
@@ -13,6 +13,8 @@ def get_step_output_path(job_id : str, step_index : int, output_path : str) -> O

 		if output_file_name and output_file_extension:
 			return os.path.join(output_directory_path, output_file_name + '-' + job_id + '-' + str(step_index) + output_file_extension)
+		if output_file_path and output_directory_path:
+			return os.path.join(output_directory_path, output_file_path + '-' + job_id + '-' + str(step_index))
 	return None


@@ -1,5 +1,7 @@
+import os
+
 from facefusion.ffmpeg import concat_video
-from facefusion.filesystem import are_images, are_videos, move_file, remove_file
+from facefusion.filesystem import are_images, are_videos, copy_file, create_directory, is_directory, is_file, move_directory, move_file, remove_directory, remove_file, resolve_file_paths
 from facefusion.jobs import job_helper, job_manager
 from facefusion.types import JobOutputSet, JobStep, ProcessStep

@@ -59,6 +61,8 @@ def run_step(job_id : str, step_index : int, step : JobStep, process_step : Proc
 		output_path = step_args.get('output_path')
 		step_output_path = job_helper.get_step_output_path(job_id, step_index, output_path)

+		if is_directory(output_path):
+			return move_directory(output_path, step_output_path) and job_manager.set_step_status(job_id, step_index, 'completed')
 		return move_file(output_path, step_output_path) and job_manager.set_step_status(job_id, step_index, 'completed')
 	job_manager.set_step_status(job_id, step_index, 'failed')
 	return False
@@ -79,13 +83,26 @@ def finalize_steps(job_id : str) -> bool:
 	output_set = collect_output_set(job_id)

 	for output_path, temp_output_paths in output_set.items():
-		if are_videos(temp_output_paths):
+		has_videos = are_videos(temp_output_paths)
+		has_images = are_images(temp_output_paths)
+
+		if has_videos:
 			if not concat_video(output_path, temp_output_paths):
 				return False
-		if are_images(temp_output_paths):
+		if not has_videos and has_images:
 			for temp_output_path in temp_output_paths:
 				if not move_file(temp_output_path, output_path):
 					return False
+		if not has_videos and not has_images:
+			if not create_directory(output_path):
+				return False
+
+			for temp_output_path in temp_output_paths:
+				if is_directory(temp_output_path):
+					temp_frame_paths = resolve_file_paths(temp_output_path)
+					for temp_frame_path in temp_frame_paths:
+						if not copy_file(temp_frame_path, os.path.join(output_path, os.path.basename(temp_frame_path))):
+							return False
 	return True


@@ -94,8 +111,12 @@ def clean_steps(job_id: str) -> bool:

 	for temp_output_paths in output_set.values():
 		for temp_output_path in temp_output_paths:
-			if not remove_file(temp_output_path):
-				return False
+			if is_file(temp_output_path):
+				if not remove_file(temp_output_path):
+					return False
+			if is_directory(temp_output_path):
+				if not remove_directory(temp_output_path):
+					return False
 	return True


@@ -1,27 +0,0 @@
-from typing import List
-
-from facefusion.types import JobStore
-
-JOB_STORE : JobStore =\
-{
-	'job_keys': [],
-	'step_keys': []
-}
-
-
-def get_job_keys() -> List[str]:
-	return JOB_STORE.get('job_keys')
-
-
-def get_step_keys() -> List[str]:
-	return JOB_STORE.get('step_keys')
-
-
-def register_job_keys(job_keys : List[str]) -> None:
-	for job_key in job_keys:
-		JOB_STORE['job_keys'].append(job_key)
-
-
-def register_step_keys(step_keys : List[str]) -> None:
-	for step_key in step_keys:
-		JOB_STORE['step_keys'].append(step_key)
@@ -0,0 +1,115 @@
+import ctypes
+import ctypes.util
+from functools import lru_cache
+from typing import List, Optional
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	library_path = ctypes.util.find_library('amd_smi')
+
+	if library_path:
+		library = ctypes.CDLL(library_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.amdsmi_init.argtypes = [ ctypes.c_uint64 ]
+	library.amdsmi_init.restype = ctypes.c_uint32
+
+	library.amdsmi_shut_down.argtypes = []
+	library.amdsmi_shut_down.restype = ctypes.c_uint32
+
+	library.amdsmi_get_socket_handles.argtypes = [ ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p) ]
+	library.amdsmi_get_socket_handles.restype = ctypes.c_uint32
+
+	library.amdsmi_get_processor_handles.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint32), ctypes.POINTER(ctypes.c_void_p) ]
+	library.amdsmi_get_processor_handles.restype = ctypes.c_uint32
+
+	library.amdsmi_get_gpu_vram_usage.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.amdsmi_get_gpu_vram_usage.restype = ctypes.c_uint32
+
+	library.amdsmi_get_gpu_activity.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.amdsmi_get_gpu_activity.restype = ctypes.c_uint32
+
+	library.amdsmi_get_gpu_asic_info.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.amdsmi_get_gpu_asic_info.restype = ctypes.c_uint32
+
+	library.amdsmi_get_temp_metric.argtypes = [ ctypes.c_void_p, ctypes.c_uint32, ctypes.c_uint32, ctypes.POINTER(ctypes.c_int64) ]
+	library.amdsmi_get_temp_metric.restype = ctypes.c_uint32
+
+	return library
+
+
+def find_device_handles(amd_smi_library : ctypes.CDLL) -> List[ctypes.c_void_p]:
+	device_handles : List[ctypes.c_void_p] = []
+
+	socket_count = ctypes.c_uint32()
+	amd_smi_library.amdsmi_get_socket_handles(ctypes.byref(socket_count), ctypes.POINTER(ctypes.c_void_p)())
+	socket_handles = (ctypes.c_void_p * socket_count.value)()
+	amd_smi_library.amdsmi_get_socket_handles(ctypes.byref(socket_count), socket_handles)
+
+	for socket_index in range(socket_count.value):
+		device_count = ctypes.c_uint32()
+		amd_smi_library.amdsmi_get_processor_handles(socket_handles[socket_index], ctypes.byref(device_count), ctypes.POINTER(ctypes.c_void_p)())
+		processor_handles = (ctypes.c_void_p * device_count.value)()
+		amd_smi_library.amdsmi_get_processor_handles(socket_handles[socket_index], ctypes.byref(device_count), processor_handles)
+
+		for device_index in range(device_count.value):
+			device_handles.append(ctypes.c_void_p(processor_handles[device_index]))
+
+	return device_handles
+
+
+def define_product_info() -> ctypes.Structure:
+	return type('AMDSMI_ASIC_INFO', (ctypes.Structure,),
+	{
+		'_pack_': 1,
+		'_fields_':
+		[
+			('market_name', ctypes.c_char * 256),
+			('vendor_id', ctypes.c_uint32),
+			('vendor_name', ctypes.c_char * 256),
+			('subvendor_id', ctypes.c_uint32),
+			('device_id', ctypes.c_uint64),
+			('rev_id', ctypes.c_uint32),
+			('asic_serial', ctypes.c_char * 256),
+			('oam_id', ctypes.c_uint32),
+			('num_of_compute_units', ctypes.c_uint32),
+			('padding', ctypes.c_ubyte * 4),
+			('target_graphics_version', ctypes.c_uint64),
+			('subsystem_id', ctypes.c_uint32),
+			('reserved', ctypes.c_uint32 * 21)
+		]
+	})()
+
+
+def define_device_memory() -> ctypes.Structure:
+	return type('AMDSMI_VRAM_USAGE', (ctypes.Structure,),
+	{
+		'_pack_': 1,
+		'_fields_':
+		[
+			('vram_total', ctypes.c_uint32),
+			('vram_used', ctypes.c_uint32),
+			('reserved', ctypes.c_uint32 * 2)
+		]
+	})()
+
+
+def define_device_utilization() -> ctypes.Structure:
+	return type('AMDSMI_ENGINE_USAGE', (ctypes.Structure,),
+	{
+		'_pack_': 1,
+		'_fields_':
+		[
+			('gfx_activity', ctypes.c_uint32),
+			('umc_activity', ctypes.c_uint32),
+			('mm_activity', ctypes.c_uint32),
+			('reserved', ctypes.c_uint32 * 13)
+		]
+	})()
@@ -0,0 +1,134 @@
+import ctypes
+from functools import lru_cache
+from typing import Optional
+
+from facefusion.common_helper import is_linux, is_macos, is_windows
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url_by_provider
+from facefusion.filesystem import resolve_relative_path
+from facefusion.types import LibrarySet
+
+
+@lru_cache
+def create_static_library_set() -> Optional[LibrarySet]:
+	if is_linux():
+		return\
+		{
+			'hashes':
+			{
+				'aom':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libaom.hash'),
+					'path': resolve_relative_path('../.libraries/libaom.hash')
+				}
+			},
+			'sources':
+			{
+				'aom':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libaom.so'),
+					'path': resolve_relative_path('../.libraries/libaom.so')
+				}
+			}
+		}
+	if is_macos():
+		return\
+		{
+			'hashes':
+			{
+				'aom':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libaom.hash'),
+					'path': resolve_relative_path('../.libraries/libaom.hash')
+				}
+			},
+			'sources':
+			{
+				'aom':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libaom.dylib'),
+					'path': resolve_relative_path('../.libraries/libaom.dylib')
+				}
+			}
+		}
+	if is_windows():
+		return\
+		{
+			'hashes':
+			{
+				'aom':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/aom.hash'),
+					'path': resolve_relative_path('../.libraries/aom.hash')
+				}
+			},
+			'sources':
+			{
+				'aom':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/aom.dll'),
+					'path': resolve_relative_path('../.libraries/aom.dll')
+				}
+			}
+		}
+
+	return None
+
+
+def pre_check() -> bool:
+	library_hash_set = create_static_library_set().get('hashes')
+	library_source_set = create_static_library_set().get('sources')
+
+	return conditional_download_hashes(library_hash_set) and conditional_download_sources(library_source_set)
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	library_path = create_static_library_set().get('sources').get('aom').get('path')
+
+	if library_path:
+		if is_windows():
+			library = ctypes.CDLL(library_path, winmode = 0)
+		else:
+			library = ctypes.CDLL(library_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.aom_codec_enc_config_default.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint ]
+	library.aom_codec_enc_config_default.restype = ctypes.c_int
+
+	library.aom_codec_enc_init_ver.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_long, ctypes.c_int ]
+	library.aom_codec_enc_init_ver.restype = ctypes.c_int
+
+	library.aom_codec_encode.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int64, ctypes.c_ulong, ctypes.c_long, ctypes.c_ulong ]
+	library.aom_codec_encode.restype = ctypes.c_int
+
+	library.aom_codec_get_cx_data.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p) ]
+	library.aom_codec_get_cx_data.restype = ctypes.c_void_p
+
+	library.aom_codec_enc_config_set.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.aom_codec_enc_config_set.restype = ctypes.c_int
+
+	library.aom_codec_destroy.argtypes = [ ctypes.c_void_p ]
+	library.aom_codec_destroy.restype = ctypes.c_int
+
+	library.aom_img_wrap.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint, ctypes.c_void_p ]
+	library.aom_img_wrap.restype = ctypes.c_void_p
+
+	library.aom_codec_control.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_int ]
+	library.aom_codec_control.restype = ctypes.c_int
+
+	library.aom_codec_dec_init_ver.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_long, ctypes.c_int ]
+	library.aom_codec_dec_init_ver.restype = ctypes.c_int
+
+	library.aom_codec_decode.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_void_p ]
+	library.aom_codec_decode.restype = ctypes.c_int
+
+	library.aom_codec_get_frame.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p) ]
+	library.aom_codec_get_frame.restype = ctypes.c_void_p
+
+	return library
@@ -0,0 +1,294 @@
+import ctypes
+from functools import lru_cache
+from typing import Optional
+
+from facefusion.common_helper import is_linux, is_macos, is_windows
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url_by_provider
+from facefusion.filesystem import resolve_relative_path
+from facefusion.types import LibrarySet
+
+
+@lru_cache
+def create_static_library_set() -> Optional[LibrarySet]:
+	if is_linux():
+		return\
+		{
+			'hashes':
+			{
+				'crypto':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libcrypto.hash'),
+					'path': resolve_relative_path('../.libraries/libcrypto.hash')
+				},
+				'datachannel':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libdatachannel_next.hash'),
+					'path': resolve_relative_path('../.libraries/libdatachannel_next.hash')
+				},
+				'ssl':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libssl.hash'),
+					'path': resolve_relative_path('../.libraries/libssl.hash')
+				}
+			},
+			'sources':
+			{
+				'crypto':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libcrypto.so'),
+					'path': resolve_relative_path('../.libraries/libcrypto.so')
+				},
+				'datachannel':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libdatachannel_next.so'),
+					'path': resolve_relative_path('../.libraries/libdatachannel_next.so')
+				},
+				'ssl':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libssl.so'),
+					'path': resolve_relative_path('../.libraries/libssl.so')
+				}
+			}
+		}
+	if is_macos():
+		return\
+		{
+			'hashes':
+			{
+				'crypto':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libcrypto.hash'),
+					'path': resolve_relative_path('../.libraries/libcrypto.hash')
+				},
+				'datachannel':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libdatachannel_next.hash'),
+					'path': resolve_relative_path('../.libraries/libdatachannel_next.hash')
+				},
+				'ssl':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libssl.hash'),
+					'path': resolve_relative_path('../.libraries/libssl.hash')
+				}
+			},
+			'sources':
+			{
+				'crypto':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libcrypto.dylib'),
+					'path': resolve_relative_path('../.libraries/libcrypto.dylib')
+				},
+				'datachannel':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libdatachannel_next.dylib'),
+					'path': resolve_relative_path('../.libraries/libdatachannel_next.dylib')
+				},
+				'ssl':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libssl.dylib'),
+					'path': resolve_relative_path('../.libraries/libssl.dylib')
+				}
+			}
+		}
+	if is_windows():
+		return\
+		{
+			'hashes':
+			{
+				'crypto':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/crypto.hash'),
+					'path': resolve_relative_path('../.libraries/crypto.hash')
+				},
+				'datachannel':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/datachannel_next.hash'),
+					'path': resolve_relative_path('../.libraries/datachannel_next.hash')
+				},
+				'ssl':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/ssl.hash'),
+					'path': resolve_relative_path('../.libraries/ssl.hash')
+				}
+			},
+			'sources':
+			{
+				'crypto':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/crypto.dll'),
+					'path': resolve_relative_path('../.libraries/crypto.dll')
+				},
+				'datachannel':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/datachannel_next.dll'),
+					'path': resolve_relative_path('../.libraries/datachannel_next.dll')
+				},
+				'ssl':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/ssl.dll'),
+					'path': resolve_relative_path('../.libraries/ssl.dll')
+				}
+			}
+		}
+
+	return None
+
+
+def pre_check() -> bool:
+	library_hash_set = create_static_library_set().get('hashes')
+	library_source_set = create_static_library_set().get('sources')
+
+	return conditional_download_hashes(library_hash_set) and conditional_download_sources(library_source_set)
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	crypto_source_path = create_static_library_set().get('sources').get('crypto').get('path')
+	datachannel_source_path = create_static_library_set().get('sources').get('datachannel').get('path')
+	ssl_source_path = create_static_library_set().get('sources').get('ssl').get('path')
+
+	if crypto_source_path and datachannel_source_path and ssl_source_path:
+		if is_windows():
+			ctypes.CDLL(crypto_source_path, winmode = 0)
+			ctypes.CDLL(ssl_source_path, winmode = 0)
+			library = ctypes.CDLL(datachannel_source_path, winmode = 0)
+		else:
+			ctypes.CDLL(crypto_source_path)
+			ctypes.CDLL(ssl_source_path)
+			library = ctypes.CDLL(datachannel_source_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.rtcInitLogger.argtypes = [ ctypes.c_int, ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p) ]
+	library.rtcInitLogger.restype = None
+	library.rtcInitLogger(2, ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_char_p)(0))
+
+	library.rtcCreatePeerConnection.restype = ctypes.c_int
+
+	library.rtcDeletePeerConnection.argtypes = [ ctypes.c_int ]
+	library.rtcDeletePeerConnection.restype = ctypes.c_int
+
+	library.rtcSetLocalDescription.argtypes = [ ctypes.c_int, ctypes.c_char_p ]
+	library.rtcSetLocalDescription.restype = ctypes.c_int
+
+	library.rtcSetRemoteDescription.argtypes = [ ctypes.c_int, ctypes.c_char_p, ctypes.c_char_p ]
+	library.rtcSetRemoteDescription.restype = ctypes.c_int
+
+	library.rtcAddTrackEx.restype = ctypes.c_int
+
+	library.rtcSendMessage.argtypes = [ ctypes.c_int, ctypes.c_void_p, ctypes.c_int ]
+	library.rtcSendMessage.restype = ctypes.c_int
+
+	library.rtcSetAV1Packetizer.restype = ctypes.c_int
+	library.rtcSetVP8Packetizer.restype = ctypes.c_int
+	library.rtcSetVP9Packetizer.restype = ctypes.c_int
+
+	library.rtcChainRtcpSrReporter.argtypes = [ ctypes.c_int ]
+	library.rtcChainRtcpSrReporter.restype = ctypes.c_int
+
+	library.rtcSetTrackRtpTimestamp.argtypes = [ ctypes.c_int, ctypes.c_uint32 ]
+	library.rtcSetTrackRtpTimestamp.restype = ctypes.c_int
+
+	library.rtcIsOpen.argtypes = [ ctypes.c_int ]
+	library.rtcIsOpen.restype = ctypes.c_bool
+
+	library.rtcChainRtcpNackResponder.argtypes = [ ctypes.c_int, ctypes.c_uint ]
+	library.rtcChainRtcpNackResponder.restype = ctypes.c_int
+
+	library.rtcGetLocalDescription.argtypes = [ ctypes.c_int, ctypes.c_char_p, ctypes.c_int ]
+	library.rtcGetLocalDescription.restype = ctypes.c_int
+
+	library.rtcSetOpusPacketizer.restype = ctypes.c_int
+
+	library.rtcGetPayloadTypesForCodec.argtypes = [ ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_int), ctypes.c_int ]
+	library.rtcGetPayloadTypesForCodec.restype = ctypes.c_int
+
+	library.rtcSetAV1Depacketizer.argtypes = [ ctypes.c_int, ctypes.c_int ]
+	library.rtcSetAV1Depacketizer.restype = ctypes.c_int
+	library.rtcSetVP8Depacketizer.restype = ctypes.c_int
+	library.rtcSetVP9Depacketizer.restype = ctypes.c_int
+	library.rtcSetOpusDepacketizer.restype = ctypes.c_int
+
+	library.rtcChainRtcpReceivingSession.argtypes = [ ctypes.c_int ]
+	library.rtcChainRtcpReceivingSession.restype = ctypes.c_int
+
+	library.rtcSetFrameCallback.argtypes = [ ctypes.c_int, ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_void_p, ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p) ]
+	library.rtcSetFrameCallback.restype = ctypes.c_int
+
+	library.rtcSetUserPointer.argtypes = [ ctypes.c_int, ctypes.c_void_p ]
+	library.rtcSetUserPointer.restype = None
+
+	library.rtcChainRembHandler.argtypes = [ ctypes.c_int, ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_uint, ctypes.c_void_p) ]
+	library.rtcChainRembHandler.restype = ctypes.c_int
+
+	library.rtcRequestBitrate.argtypes = [ ctypes.c_int, ctypes.c_uint ]
+	library.rtcRequestBitrate.restype = ctypes.c_int
+
+	library.rtcSetClosedCallback.argtypes = [ ctypes.c_int, ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_void_p) ]
+	library.rtcSetClosedCallback.restype = ctypes.c_int
+
+	return library
+
+
+def define_rtc_configuration() -> ctypes.Structure:
+	return type('RTC_CONFIGURATION', (ctypes.Structure,),
+	{
+		'_fields_':
+		[
+			('iceServers', ctypes.POINTER(ctypes.c_char_p)),
+			('iceServersCount', ctypes.c_int),
+			('proxyServer', ctypes.c_char_p),
+			('bindAddress', ctypes.c_char_p),
+			('certificateType', ctypes.c_int),
+			('iceTransportPolicy', ctypes.c_int),
+			('enableIceTcp', ctypes.c_bool),
+			('enableIceUdpMux', ctypes.c_bool),
+			('disableAutoNegotiation', ctypes.c_bool),
+			('forceMediaTransport', ctypes.c_bool),
+			('portRangeBegin', ctypes.c_ushort),
+			('portRangeEnd', ctypes.c_ushort),
+			('mtu', ctypes.c_int),
+			('maxMessageSize', ctypes.c_int)
+		]
+	})()
+
+
+def define_rtc_track_init() -> ctypes.Structure:
+	return type('RTC_TRACK_INIT', (ctypes.Structure,),
+	{
+		'_fields_':
+		[
+			('direction', ctypes.c_int),
+			('codec', ctypes.c_int),
+			('payloadType', ctypes.c_int),
+			('ssrc', ctypes.c_uint32),
+			('mid', ctypes.c_char_p),
+			('name', ctypes.c_char_p),
+			('msid', ctypes.c_char_p),
+			('trackId', ctypes.c_char_p),
+			('profile', ctypes.c_char_p)
+		]
+	})()
+
+
+def define_rtc_packetizer_init() -> ctypes.Structure:
+	return type('RTC_PACKETIZER_INIT', (ctypes.Structure,),
+	{
+		'_fields_':
+		[
+			('ssrc', ctypes.c_uint32),
+			('cname', ctypes.c_char_p),
+			('payloadType', ctypes.c_uint8),
+			('clockRate', ctypes.c_uint32),
+			('sequenceNumber', ctypes.c_uint16),
+			('timestamp', ctypes.c_uint32),
+			('maxFragmentSize', ctypes.c_uint16),
+			('nalSeparator', ctypes.c_int),
+			('obuPacketization', ctypes.c_int)
+		]
+	})()
@@ -0,0 +1,88 @@
+import ctypes
+import ctypes.util
+from functools import lru_cache
+from typing import List, Optional
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	library_path = ctypes.util.find_library('nvidia-ml') or ctypes.util.find_library('nvml')
+
+	if library_path:
+		library = ctypes.CDLL(library_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.nvmlInit_v2.argtypes = []
+	library.nvmlInit_v2.restype = ctypes.c_int
+
+	library.nvmlShutdown.argtypes = []
+	library.nvmlShutdown.restype = ctypes.c_int
+
+	library.nvmlDeviceGetCount_v2.argtypes = [ ctypes.POINTER(ctypes.c_uint) ]
+	library.nvmlDeviceGetCount_v2.restype = ctypes.c_int
+
+	library.nvmlSystemGetDriverVersion.argtypes = [ ctypes.c_char_p, ctypes.c_uint ]
+	library.nvmlSystemGetDriverVersion.restype = ctypes.c_int
+
+	library.nvmlSystemGetCudaDriverVersion.argtypes = [ ctypes.POINTER(ctypes.c_int) ]
+	library.nvmlSystemGetCudaDriverVersion.restype = ctypes.c_int
+
+	library.nvmlDeviceGetHandleByIndex_v2.argtypes = [ ctypes.c_uint, ctypes.POINTER(ctypes.c_void_p) ]
+	library.nvmlDeviceGetHandleByIndex_v2.restype = ctypes.c_int
+
+	library.nvmlDeviceGetName.argtypes = [ ctypes.c_void_p, ctypes.c_char_p, ctypes.c_uint ]
+	library.nvmlDeviceGetName.restype = ctypes.c_int
+
+	library.nvmlDeviceGetMemoryInfo.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.nvmlDeviceGetMemoryInfo.restype = ctypes.c_int
+
+	library.nvmlDeviceGetTemperature.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.POINTER(ctypes.c_uint) ]
+	library.nvmlDeviceGetTemperature.restype = ctypes.c_int
+
+	library.nvmlDeviceGetUtilizationRates.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.nvmlDeviceGetUtilizationRates.restype = ctypes.c_int
+
+	return library
+
+
+def find_device_handles(nvidia_ml_library : ctypes.CDLL) -> List[ctypes.c_void_p]:
+	device_handles : List[ctypes.c_void_p] = []
+
+	device_count = ctypes.c_uint()
+	nvidia_ml_library.nvmlDeviceGetCount_v2(ctypes.byref(device_count))
+
+	for device_id in range(device_count.value):
+		device_handle = ctypes.c_void_p()
+		nvidia_ml_library.nvmlDeviceGetHandleByIndex_v2(device_id, ctypes.byref(device_handle))
+		device_handles.append(device_handle)
+
+	return device_handles
+
+
+def define_device_memory() -> ctypes.Structure:
+	return type('NVML_MEMORY', (ctypes.Structure,),
+	{
+		'_fields_':
+		[
+			('total', ctypes.c_ulonglong),
+			('free', ctypes.c_ulonglong),
+			('used', ctypes.c_ulonglong)
+		]
+	})()
+
+
+def define_device_utilization() -> ctypes.Structure:
+	return type('NVML_UTILIZATION', (ctypes.Structure,),
+	{
+		'_fields_':
+		[
+			('gpu', ctypes.c_uint),
+			('memory', ctypes.c_uint)
+		]
+	})()
@@ -0,0 +1,124 @@
+import ctypes
+from functools import lru_cache
+from typing import Optional
+
+from facefusion.common_helper import is_linux, is_macos, is_windows
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url_by_provider
+from facefusion.filesystem import resolve_relative_path
+from facefusion.types import LibrarySet
+
+
+@lru_cache
+def create_static_library_set() -> Optional[LibrarySet]:
+	if is_linux():
+		return\
+		{
+			'hashes':
+			{
+				'opus':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libopus.hash'),
+					'path': resolve_relative_path('../.libraries/libopus.hash')
+				}
+			},
+			'sources':
+			{
+				'opus':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libopus.so'),
+					'path': resolve_relative_path('../.libraries/libopus.so')
+				}
+			}
+		}
+
+	if is_macos():
+		return\
+		{
+			'hashes':
+			{
+				'opus':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libopus.hash'),
+					'path': resolve_relative_path('../.libraries/libopus.hash')
+				}
+			},
+			'sources':
+			{
+				'opus':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libopus.dylib'),
+					'path': resolve_relative_path('../.libraries/libopus.dylib')
+				}
+			}
+		}
+
+	if is_windows():
+		return\
+		{
+			'hashes':
+			{
+				'opus':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/opus.hash'),
+					'path': resolve_relative_path('../.libraries/opus.hash')
+				}
+			},
+			'sources':
+			{
+				'opus':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/opus.dll'),
+					'path': resolve_relative_path('../.libraries/opus.dll')
+				}
+			}
+		}
+
+	return None
+
+
+def pre_check() -> bool:
+	library_hash_set = create_static_library_set().get('hashes')
+	library_source_set = create_static_library_set().get('sources')
+
+	return conditional_download_hashes(library_hash_set) and conditional_download_sources(library_source_set)
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	library_path = create_static_library_set().get('sources').get('opus').get('path')
+
+	if library_path:
+		if is_windows():
+			library = ctypes.CDLL(library_path, winmode = 0)
+		else:
+			library = ctypes.CDLL(library_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.opus_encoder_create.argtypes = [ ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_int) ]
+	library.opus_encoder_create.restype = ctypes.c_void_p
+
+	library.opus_encode_float.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_float), ctypes.c_int, ctypes.c_char_p, ctypes.c_int ]
+	library.opus_encode_float.restype = ctypes.c_int
+
+	library.opus_encoder_destroy.argtypes = [ ctypes.c_void_p ]
+	library.opus_encoder_destroy.restype = None
+
+	library.opus_decoder_create.argtypes = [ ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_int) ]
+	library.opus_decoder_create.restype = ctypes.c_void_p
+
+	library.opus_decode_float.argtypes = [ ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int, ctypes.POINTER(ctypes.c_float), ctypes.c_int, ctypes.c_int ]
+	library.opus_decode_float.restype = ctypes.c_int
+
+	library.opus_decoder_get_nb_samples.argtypes = [ ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int ]
+	library.opus_decoder_get_nb_samples.restype = ctypes.c_int
+
+	library.opus_decoder_destroy.argtypes = [ ctypes.c_void_p ]
+	library.opus_decoder_destroy.restype = None
+
+	return library
@@ -0,0 +1,24 @@
+import ctypes
+import ctypes.util
+from functools import lru_cache
+from typing import Optional
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	library_path = ctypes.util.find_library('rocm-core')
+
+	if library_path:
+		library = ctypes.CDLL(library_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.getROCmVersion.argtypes = [ ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint) ]
+	library.getROCmVersion.restype = ctypes.c_int
+
+	return library
@@ -0,0 +1,134 @@
+import ctypes
+from functools import lru_cache
+from typing import Optional
+
+from facefusion.common_helper import is_linux, is_macos, is_windows
+from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url_by_provider
+from facefusion.filesystem import resolve_relative_path
+from facefusion.types import LibrarySet
+
+
+@lru_cache
+def create_static_library_set() -> Optional[LibrarySet]:
+	if is_linux():
+		return\
+		{
+			'hashes':
+			{
+				'vpx':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libvpx.hash'),
+					'path': resolve_relative_path('../.libraries/libvpx.hash')
+				}
+			},
+			'sources':
+			{
+				'vpx':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'linux/libvpx.so'),
+					'path': resolve_relative_path('../.libraries/libvpx.so')
+				}
+			}
+		}
+	if is_macos():
+		return\
+		{
+			'hashes':
+			{
+				'vpx':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libvpx.hash'),
+					'path': resolve_relative_path('../.libraries/libvpx.hash')
+				}
+			},
+			'sources':
+			{
+				'vpx':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'macos/libvpx.dylib'),
+					'path': resolve_relative_path('../.libraries/libvpx.dylib')
+				}
+			}
+		}
+	if is_windows():
+		return\
+		{
+			'hashes':
+			{
+				'vpx':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/vpx.hash'),
+					'path': resolve_relative_path('../.libraries/vpx.hash')
+				}
+			},
+			'sources':
+			{
+				'vpx':
+				{
+					'url': resolve_download_url_by_provider('huggingface', 'libraries-4.0.0', 'windows/vpx.dll'),
+					'path': resolve_relative_path('../.libraries/vpx.dll')
+				}
+			}
+		}
+
+	return None
+
+
+def pre_check() -> bool:
+	library_hash_set = create_static_library_set().get('hashes')
+	library_source_set = create_static_library_set().get('sources')
+
+	return conditional_download_hashes(library_hash_set) and conditional_download_sources(library_source_set)
+
+
+@lru_cache
+def create_static_library() -> Optional[ctypes.CDLL]:
+	library_path = create_static_library_set().get('sources').get('vpx').get('path')
+
+	if library_path:
+		if is_windows():
+			library = ctypes.CDLL(library_path, winmode = 0)
+		else:
+			library = ctypes.CDLL(library_path)
+
+		if library:
+			return init_ctypes(library)
+
+	return None
+
+
+def init_ctypes(library : ctypes.CDLL) -> ctypes.CDLL:
+	library.vpx_codec_enc_config_default.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint ]
+	library.vpx_codec_enc_config_default.restype = ctypes.c_int
+
+	library.vpx_codec_enc_init_ver.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_long, ctypes.c_int ]
+	library.vpx_codec_enc_init_ver.restype = ctypes.c_int
+
+	library.vpx_codec_encode.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int64, ctypes.c_ulong, ctypes.c_long, ctypes.c_ulong ]
+	library.vpx_codec_encode.restype = ctypes.c_int
+
+	library.vpx_codec_get_cx_data.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p) ]
+	library.vpx_codec_get_cx_data.restype = ctypes.c_void_p
+
+	library.vpx_codec_enc_config_set.argtypes = [ ctypes.c_void_p, ctypes.c_void_p ]
+	library.vpx_codec_enc_config_set.restype = ctypes.c_int
+
+	library.vpx_codec_destroy.argtypes = [ ctypes.c_void_p ]
+	library.vpx_codec_destroy.restype = ctypes.c_int
+
+	library.vpx_img_wrap.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_uint, ctypes.c_uint, ctypes.c_uint, ctypes.c_void_p ]
+	library.vpx_img_wrap.restype = ctypes.c_void_p
+
+	library.vpx_codec_control_.argtypes = [ ctypes.c_void_p, ctypes.c_int, ctypes.c_int ]
+	library.vpx_codec_control_.restype = ctypes.c_int
+
+	library.vpx_codec_dec_init_ver.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_long, ctypes.c_int ]
+	library.vpx_codec_dec_init_ver.restype = ctypes.c_int
+
+	library.vpx_codec_decode.argtypes = [ ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.c_void_p, ctypes.c_long ]
+	library.vpx_codec_decode.restype = ctypes.c_int
+
+	library.vpx_codec_get_frame.argtypes = [ ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p) ]
+	library.vpx_codec_get_frame.restype = ctypes.c_void_p
+
+	return library
@@ -12,8 +12,11 @@ LOCALES : Locales =\
 		'extracting_frames': 'extracting frames with a resolution of {resolution} and {fps} frames per second',
 		'extracting_frames_succeeded': 'extracting frames succeeded',
 		'extracting_frames_failed': 'extracting frames failed',
+		'spawning_frames_succeeded': 'spawning frames succeeded',
+		'spawning_frames_failed': 'spawning frames failed',
 		'analysing': 'analysing',
 		'extracting': 'extracting',
+		'spawning': 'spawning',
 		'streaming': 'streaming',
 		'processing': 'processing',
 		'merging': 'merging',
@@ -37,6 +40,8 @@ LOCALES : Locales =\
 		'processing_stopped': 'processing stopped',
 		'processing_image_succeeded': 'processing to image succeeded in {seconds} seconds',
 		'processing_image_failed': 'processing to image failed',
+		'processing_frames_succeeded': 'processing to frames succeeded in {seconds} seconds',
+		'processing_frames_failed': 'processing to frames failed',
 		'processing_video_succeeded': 'processing to video succeeded in {seconds} seconds',
 		'processing_video_failed': 'processing to video failed',
 		'choose_image_source': 'choose an image for the source',
@@ -48,10 +53,9 @@ LOCALES : Locales =\
 		'no_source_face_detected': 'no source face detected',
 		'processor_not_loaded': 'processor {processor} could not be loaded',
 		'processor_not_implemented': 'processor {processor} not implemented correctly',
-		'ui_layout_not_loaded': 'ui layout {ui_layout} could not be loaded',
-		'ui_layout_not_implemented': 'ui layout {ui_layout} not implemented correctly',
 		'stream_not_loaded': 'stream {stream_mode} could not be loaded',
 		'stream_not_supported': 'stream not supported',
+		'api_started': 'started API on {host}:{port}',
 		'job_created': 'job {job_id} created',
 		'job_not_created': 'job {job_id} not created',
 		'job_submitted': 'job {job_id} submitted',
@@ -99,6 +103,7 @@ LOCALES : Locales =\
 		{
 			'install_dependency': 'choose the variant of {dependency} to install',
 			'skip_conda': 'skip the conda environment check',
+			'workflow': 'choose the workflow',
 			'config_path': 'choose the config file to override defaults',
 			'temp_path': 'specify the directory for the temporary resources',
 			'jobs_path': 'specify the directory to store jobs',
@@ -136,13 +141,13 @@ LOCALES : Locales =\
 			'trim_frame_start': 'specify the starting frame of the target video',
 			'trim_frame_end': 'specify the ending frame of the target video',
 			'temp_frame_format': 'specify the temporary resources format',
-			'keep_temp': 'keep the temporary resources after processing',
 			'target_frame_amount': 'specify the amount of target frames forwarded to the processor',
 			'output_image_quality': 'specify the image quality which translates to the image compression',
 			'output_image_scale': 'specify the image scale based on the target image',
 			'output_audio_encoder': 'specify the encoder used for the audio',
 			'output_audio_quality': 'specify the audio quality which translates to the audio compression',
 			'output_audio_volume': 'specify the audio volume based on the target video',
+			'output_audio_fps': 'specify the fps used when converting audio to video frames',
 			'output_video_encoder': 'specify the encoder used for the video',
 			'output_video_preset': 'balance fast video processing and video file size',
 			'output_video_quality': 'specify the video quality which translates to the video compression',
@@ -151,14 +156,14 @@ LOCALES : Locales =\
 			'processors': 'load a single or multiple processors (choices: {choices}, ...)',
 			'background-remover-model': 'choose the model responsible for removing the background',
 			'background-remover-color': 'apply red, green blue and alpha values of the background',
-			'open_browser': 'open the browser once the program is ready',
-			'ui_layouts': 'launch a single or multiple UI layouts (choices: {choices}, ...)',
-			'ui_workflow': 'choose the ui workflow',
 			'download_providers': 'download using different providers (choices: {choices}, ...)',
 			'download_scope': 'specify the download scope',
 			'benchmark_mode': 'choose the benchmark mode',
 			'benchmark_resolutions': 'choose the resolutions for the benchmarks (choices: {choices}, ...)',
 			'benchmark_cycle_count': 'specify the amount of cycles per benchmark',
+			'api_host': 'specify the API host',
+			'api_port': 'specify the API port',
+			'api_security_strategy': 'specify the API security strategy used for sanitizing uploaded assets',
 			'execution_device_ids': 'specify the devices used for processing',
 			'execution_providers': 'inference using different providers (choices: {choices}, ...)',
 			'execution_thread_count': 'specify the amount of parallel threads while processing',
@@ -166,10 +171,10 @@ LOCALES : Locales =\
 			'log_level': 'adjust the message severity displayed in the terminal',
 			'halt_on_error': 'halt the program once an error occurred',
 			'run': 'run the program',
-			'headless_run': 'run the program in headless mode',
 			'batch_run': 'run the program in batch mode',
 			'force_download': 'force automate downloads and exit',
 			'benchmark': 'benchmark the program',
+			'api': 'start the API server',
 			'job_id': 'specify the job id',
 			'job_status': 'specify the job status',
 			'step_index': 'specify the step index',
@@ -263,7 +268,6 @@ LOCALES : Locales =\
 			'temp_frame_format_dropdown': 'TEMP FRAME FORMAT',
 			'terminal_textbox': 'TERMINAL',
 			'trim_frame_slider': 'TRIM FRAME',
-			'ui_workflow': 'UI WORKFLOW',
 			'video_memory_strategy_dropdown': 'VIDEO MEMORY STRATEGY',
 			'webcam_fps_slider': 'WEBCAM FPS',
 			'webcam_image': 'WEBCAM',
@@ -0,0 +1,17 @@
+from typing import Optional, Tuple
+
+
+def restrict_trim_frame(frame_total : int, trim_frame_start : Optional[int], trim_frame_end : Optional[int]) -> Tuple[int, int]:
+	if isinstance(trim_frame_start, int):
+		trim_frame_start = max(0, min(trim_frame_start, frame_total))
+	if isinstance(trim_frame_end, int):
+		trim_frame_end = max(0, min(trim_frame_end, frame_total))
+
+	if isinstance(trim_frame_start, int) and isinstance(trim_frame_end, int):
+		return trim_frame_start, trim_frame_end
+	if isinstance(trim_frame_start, int):
+		return trim_frame_start, frame_total
+	if isinstance(trim_frame_end, int):
+		return 0, trim_frame_end
+
+	return 0, frame_total
@@ -4,7 +4,7 @@ METADATA =\
 {
 	'name': 'FaceFusion',
 	'description': 'Industry leading face manipulation platform',
-	'version': '3.7.1',
+	'version': 'v4',
 	'license': 'OpenRAIL-AS',
 	'author': 'Henry Ruhs',
 	'url': 'https://facefusion.io'
@@ -6,9 +6,9 @@ from typing import List
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.choices
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_int_metavar, get_middle
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
@@ -16,13 +16,13 @@ from facefusion.face_creator import scale_face
 from facefusion.face_helper import merge_matrix, paste_back, scale_face_landmark_5, warp_face_by_face_landmark_5
 from facefusion.face_masker import create_box_mask, create_occlusion_mask
 from facefusion.face_selector import select_faces
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.processors.modules.age_modifier import choices as age_modifier_choices
 from facefusion.processors.modules.age_modifier.types import AgeModifierDirection, AgeModifierInputs
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import match_frame_color, read_static_image, read_static_video_chunk, read_static_video_frame


@@ -125,9 +125,26 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--age-modifier-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'age_modifier_model', 'fran'), choices = age_modifier_choices.age_modifier_models)
-		group_processors.add_argument('--age-modifier-direction', help = translator.get('help.direction', __package__), type = int, default = config.get_int_value('processors', 'age_modifier_direction', '0'), choices = age_modifier_choices.age_modifier_direction_range, metavar = create_int_metavar(age_modifier_choices.age_modifier_direction_range))
-		facefusion.jobs.job_store.register_step_keys([ 'age_modifier_model', 'age_modifier_direction' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--age-modifier-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'age_modifier_model', 'fran'),
+					choices = age_modifier_choices.age_modifier_models
+				),
+				group_processors.add_argument(
+					'--age-modifier-direction',
+					help = translator.get('help.direction', __package__),
+					type = int,
+					default = config.get_int_value('processors', 'age_modifier_direction', '0'),
+					choices = age_modifier_choices.age_modifier_direction_range,
+					metavar = create_int_metavar(age_modifier_choices.age_modifier_direction_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'age_modifier' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -154,12 +171,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -6,22 +6,22 @@ from typing import List, Tuple
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.choices
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import is_macos, is_windows
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
 from facefusion.execution import has_execution_provider
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.normalizer import normalize_color
 from facefusion.processors.modules.background_remover import choices as background_remover_choices
 from facefusion.processors.modules.background_remover.types import BackgroundRemoverInputs
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.sanitizer import sanitize_int_range
 from facefusion.thread_helper import thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, InferencePool, InferenceProvider, Mask, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, InferencePool, InferenceProvider, Mask, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import read_static_image, read_static_video_chunk, read_static_video_frame


@@ -496,10 +496,32 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--background-remover-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'background_remover_model', 'modnet'), choices = background_remover_choices.background_remover_models)
-		group_processors.add_argument('--background-remover-fill-color', help = translator.get('help.fill_color', __package__), type = partial(sanitize_int_range, int_range = background_remover_choices.background_remover_color_range), default = config.get_int_list('processors', 'background_remover_fill_color', '0 0 0 0'), nargs = '+')
-		group_processors.add_argument('--background-remover-despill-color', help = translator.get('help.despill_color', __package__), type = partial(sanitize_int_range, int_range = background_remover_choices.background_remover_color_range), default = config.get_int_list('processors', 'background_remover_despill_color', '0 0 0 0'), nargs = '+')
-		facefusion.jobs.job_store.register_step_keys([ 'background_remover_model', 'background_remover_fill_color', 'background_remover_despill_color' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--background-remover-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'background_remover_model', 'modnet'),
+					choices = background_remover_choices.background_remover_models
+				),
+				group_processors.add_argument(
+					'--background-remover-fill-color',
+					help = translator.get('help.fill_color', __package__),
+					type = partial(sanitize_int_range, int_range = background_remover_choices.background_remover_color_range),
+					default = config.get_int_list('processors', 'background_remover_fill_color', '0 0 0 0'),
+					nargs = '+'
+				),
+				group_processors.add_argument(
+					'--background-remover-despill-color',
+					help = translator.get('help.despill_color', __package__),
+					type = partial(sanitize_int_range, int_range = background_remover_choices.background_remover_color_range),
+					default = config.get_int_list('processors', 'background_remover_despill_color', '0 0 0 0'),
+					nargs = '+'
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'background_remover' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -527,12 +549,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -7,8 +7,8 @@ import cv2
 import numpy
 from cv2.typing import Size

+import facefusion.capability_store
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_int_metavar, get_middle
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url_by_provider
@@ -16,13 +16,13 @@ from facefusion.face_creator import scale_face
 from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
 from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
 from facefusion.face_selector import select_faces
-from facefusion.filesystem import get_file_name, in_directory, is_image, is_video, resolve_file_paths, resolve_relative_path, same_file_extension
+from facefusion.filesystem import get_file_name, in_directory, is_image, is_video, resolve_file_paths, resolve_relative_path
 from facefusion.processors.modules.deep_swapper import choices as deep_swapper_choices
 from facefusion.processors.modules.deep_swapper.types import DeepSwapperInputs, DeepSwapperMorph
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, Mask, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, Face, InferencePool, Mask, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import conditional_match_frame_color, read_static_image, read_static_video_chunk, read_static_video_frame


@@ -277,9 +277,26 @@ def get_model_size() -> Size:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--deep-swapper-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'deep_swapper_model', 'iperov/elon_musk_224'), choices = deep_swapper_choices.deep_swapper_models)
-		group_processors.add_argument('--deep-swapper-morph', help = translator.get('help.morph', __package__), type = int, default = config.get_int_value('processors', 'deep_swapper_morph', '100'), choices = deep_swapper_choices.deep_swapper_morph_range, metavar = create_int_metavar(deep_swapper_choices.deep_swapper_morph_range))
-		facefusion.jobs.job_store.register_step_keys([ 'deep_swapper_model', 'deep_swapper_morph' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--deep-swapper-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'deep_swapper_model', 'iperov/elon_musk_224'),
+					choices = deep_swapper_choices.deep_swapper_models
+				),
+				group_processors.add_argument(
+					'--deep-swapper-morph',
+					help = translator.get('help.morph', __package__),
+					type = int,
+					default = config.get_int_value('processors', 'deep_swapper_morph', '100'),
+					choices = deep_swapper_choices.deep_swapper_morph_range,
+					metavar = create_int_metavar(deep_swapper_choices.deep_swapper_morph_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'deep_swapper' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -308,12 +325,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -6,8 +6,8 @@ from typing import List, Tuple
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_int_metavar, get_middle
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
@@ -15,14 +15,14 @@ from facefusion.face_creator import scale_face
 from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
 from facefusion.face_masker import create_box_mask, create_occlusion_mask
 from facefusion.face_selector import select_faces
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.processors.live_portrait import create_rotation, limit_expression
 from facefusion.processors.modules.expression_restorer import choices as expression_restorer_choices
 from facefusion.processors.modules.expression_restorer.types import ExpressionRestorerInputs
-from facefusion.processors.types import LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw, ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import conditional_thread_semaphore, thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import read_static_image, read_static_video_chunk, read_static_video_frame


@@ -100,10 +100,34 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--expression-restorer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'expression_restorer_model', 'live_portrait'), choices = expression_restorer_choices.expression_restorer_models)
-		group_processors.add_argument('--expression-restorer-factor', help = translator.get('help.factor', __package__), type = int, default = config.get_int_value('processors', 'expression_restorer_factor', '80'), choices = expression_restorer_choices.expression_restorer_factor_range, metavar = create_int_metavar(expression_restorer_choices.expression_restorer_factor_range))
-		group_processors.add_argument('--expression-restorer-areas', help = translator.get('help.areas', __package__).format(choices = ', '.join(expression_restorer_choices.expression_restorer_areas)), default = config.get_str_list('processors', 'expression_restorer_areas', ' '.join(expression_restorer_choices.expression_restorer_areas)), choices = expression_restorer_choices.expression_restorer_areas, nargs = '+', metavar = 'EXPRESSION_RESTORER_AREAS')
-		facefusion.jobs.job_store.register_step_keys([ 'expression_restorer_model', 'expression_restorer_factor', 'expression_restorer_areas' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--expression-restorer-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'expression_restorer_model', 'live_portrait'),
+					choices = expression_restorer_choices.expression_restorer_models
+				),
+				group_processors.add_argument(
+					'--expression-restorer-factor',
+					help = translator.get('help.factor', __package__),
+					type = int,
+					default = config.get_int_value('processors', 'expression_restorer_factor', '80'),
+					choices = expression_restorer_choices.expression_restorer_factor_range,
+					metavar = create_int_metavar(expression_restorer_choices.expression_restorer_factor_range)
+				),
+				group_processors.add_argument(
+					'--expression-restorer-areas',
+					help = translator.get('help.areas', __package__).format(choices = ', '.join(expression_restorer_choices.expression_restorer_areas)),
+					default = config.get_str_list('processors', 'expression_restorer_areas', ' '.join(expression_restorer_choices.expression_restorer_areas)),
+					choices = expression_restorer_choices.expression_restorer_areas,
+					nargs = '+',
+					metavar = 'EXPRESSION_RESTORER_AREAS'
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'expression_restorer' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -134,12 +158,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -5,20 +5,20 @@ from typing import List
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, logger, state_manager, translator, video_manager
 from facefusion.common_helper import get_middle
 from facefusion.face_creator import scale_face
 from facefusion.face_helper import warp_face_by_face_landmark_5
 from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
 from facefusion.face_selector import select_faces
-from facefusion.filesystem import in_directory, is_image, is_video, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video
 from facefusion.processors.modules.face_debugger import choices as face_debugger_choices
 from facefusion.processors.modules.face_debugger.types import FaceDebuggerInputs
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
-from facefusion.types import ApplyStateItem, Args, Face, InferencePool, ProcessMode, VisionFrame
+from facefusion.types import Args, Face, InferencePool, ProcessMode, VisionFrame
 from facefusion.vision import read_static_image, read_static_video_chunk, read_static_video_frame


@@ -33,8 +33,20 @@ def clear_inference_pool() -> None:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--face-debugger-items', help = translator.get('help.items', __package__).format(choices = ', '.join(face_debugger_choices.face_debugger_items)), default = config.get_str_list('processors', 'face_debugger_items', 'face-landmark-5/68 face-mask'), choices = face_debugger_choices.face_debugger_items, nargs = '+', metavar = 'FACE_DEBUGGER_ITEMS')
-		facefusion.jobs.job_store.register_step_keys([ 'face_debugger_items' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--face-debugger-items',
+					help = translator.get('help.items', __package__).format(choices = ', '.join(face_debugger_choices.face_debugger_items)),
+					default = config.get_str_list('processors', 'face_debugger_items', 'face-landmark-5/68 face-mask'),
+					choices = face_debugger_choices.face_debugger_items,
+					nargs = '+',
+					metavar = 'FACE_DEBUGGER_ITEMS'
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'face_debugger' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -56,12 +68,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -6,8 +6,8 @@ from typing import List, Tuple
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_float_metavar, get_middle
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
@@ -15,14 +15,14 @@ from facefusion.face_creator import scale_face
 from facefusion.face_helper import paste_back, scale_face_landmark_5, warp_face_by_face_landmark_5
 from facefusion.face_masker import create_box_mask
 from facefusion.face_selector import select_faces
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.processors.live_portrait import create_rotation, limit_angle, limit_expression
 from facefusion.processors.modules.face_editor import choices as face_editor_choices
 from facefusion.processors.modules.face_editor.types import FaceEditorInputs
-from facefusion.processors.types import LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitRotation, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw, ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitRotation, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import conditional_thread_semaphore, thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, FaceLandmark68, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, Face, FaceLandmark68, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import read_static_image, read_static_video_chunk, read_static_video_frame


@@ -130,22 +130,130 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--face-editor-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'face_editor_model', 'live_portrait'), choices = face_editor_choices.face_editor_models)
-		group_processors.add_argument('--face-editor-eyebrow-direction', help = translator.get('help.eyebrow_direction', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eyebrow_direction', '0'), choices = face_editor_choices.face_editor_eyebrow_direction_range, metavar = create_float_metavar(face_editor_choices.face_editor_eyebrow_direction_range))
-		group_processors.add_argument('--face-editor-eye-gaze-horizontal', help = translator.get('help.eye_gaze_horizontal', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eye_gaze_horizontal', '0'), choices = face_editor_choices.face_editor_eye_gaze_horizontal_range, metavar = create_float_metavar(face_editor_choices.face_editor_eye_gaze_horizontal_range))
-		group_processors.add_argument('--face-editor-eye-gaze-vertical', help = translator.get('help.eye_gaze_vertical', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eye_gaze_vertical', '0'), choices = face_editor_choices.face_editor_eye_gaze_vertical_range, metavar = create_float_metavar(face_editor_choices.face_editor_eye_gaze_vertical_range))
-		group_processors.add_argument('--face-editor-eye-open-ratio', help = translator.get('help.eye_open_ratio', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eye_open_ratio', '0'), choices = face_editor_choices.face_editor_eye_open_ratio_range, metavar = create_float_metavar(face_editor_choices.face_editor_eye_open_ratio_range))
-		group_processors.add_argument('--face-editor-lip-open-ratio', help = translator.get('help.lip_open_ratio', __package__), type = float, default = config.get_float_value('processors', 'face_editor_lip_open_ratio', '0'), choices = face_editor_choices.face_editor_lip_open_ratio_range, metavar = create_float_metavar(face_editor_choices.face_editor_lip_open_ratio_range))
-		group_processors.add_argument('--face-editor-mouth-grim', help = translator.get('help.mouth_grim', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_grim', '0'), choices = face_editor_choices.face_editor_mouth_grim_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_grim_range))
-		group_processors.add_argument('--face-editor-mouth-pout', help = translator.get('help.mouth_pout', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_pout', '0'), choices = face_editor_choices.face_editor_mouth_pout_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_pout_range))
-		group_processors.add_argument('--face-editor-mouth-purse', help = translator.get('help.mouth_purse', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_purse', '0'), choices = face_editor_choices.face_editor_mouth_purse_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_purse_range))
-		group_processors.add_argument('--face-editor-mouth-smile', help = translator.get('help.mouth_smile', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_smile', '0'), choices = face_editor_choices.face_editor_mouth_smile_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_smile_range))
-		group_processors.add_argument('--face-editor-mouth-position-horizontal', help = translator.get('help.mouth_position_horizontal', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_position_horizontal', '0'), choices = face_editor_choices.face_editor_mouth_position_horizontal_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_position_horizontal_range))
-		group_processors.add_argument('--face-editor-mouth-position-vertical', help = translator.get('help.mouth_position_vertical', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_position_vertical', '0'), choices = face_editor_choices.face_editor_mouth_position_vertical_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_position_vertical_range))
-		group_processors.add_argument('--face-editor-head-pitch', help = translator.get('help.head_pitch', __package__), type = float, default = config.get_float_value('processors', 'face_editor_head_pitch', '0'), choices = face_editor_choices.face_editor_head_pitch_range, metavar = create_float_metavar(face_editor_choices.face_editor_head_pitch_range))
-		group_processors.add_argument('--face-editor-head-yaw', help = translator.get('help.head_yaw', __package__), type = float, default = config.get_float_value('processors', 'face_editor_head_yaw', '0'), choices = face_editor_choices.face_editor_head_yaw_range, metavar = create_float_metavar(face_editor_choices.face_editor_head_yaw_range))
-		group_processors.add_argument('--face-editor-head-roll', help = translator.get('help.head_roll', __package__), type = float, default = config.get_float_value('processors', 'face_editor_head_roll', '0'), choices = face_editor_choices.face_editor_head_roll_range, metavar = create_float_metavar(face_editor_choices.face_editor_head_roll_range))
-		facefusion.jobs.job_store.register_step_keys([ 'face_editor_model', 'face_editor_eyebrow_direction', 'face_editor_eye_gaze_horizontal', 'face_editor_eye_gaze_vertical', 'face_editor_eye_open_ratio', 'face_editor_lip_open_ratio', 'face_editor_mouth_grim', 'face_editor_mouth_pout', 'face_editor_mouth_purse', 'face_editor_mouth_smile', 'face_editor_mouth_position_horizontal', 'face_editor_mouth_position_vertical', 'face_editor_head_pitch', 'face_editor_head_yaw', 'face_editor_head_roll' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--face-editor-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'face_editor_model', 'live_portrait'),
+					choices = face_editor_choices.face_editor_models
+				),
+				group_processors.add_argument(
+					'--face-editor-eyebrow-direction',
+					help = translator.get('help.eyebrow_direction', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_eyebrow_direction', '0'),
+					choices = face_editor_choices.face_editor_eyebrow_direction_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_eyebrow_direction_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-eye-gaze-horizontal',
+					help = translator.get('help.eye_gaze_horizontal', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_eye_gaze_horizontal', '0'),
+					choices = face_editor_choices.face_editor_eye_gaze_horizontal_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_eye_gaze_horizontal_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-eye-gaze-vertical',
+					help = translator.get('help.eye_gaze_vertical', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_eye_gaze_vertical', '0'),
+					choices = face_editor_choices.face_editor_eye_gaze_vertical_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_eye_gaze_vertical_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-eye-open-ratio',
+					help = translator.get('help.eye_open_ratio', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_eye_open_ratio', '0'),
+					choices = face_editor_choices.face_editor_eye_open_ratio_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_eye_open_ratio_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-lip-open-ratio',
+					help = translator.get('help.lip_open_ratio', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_lip_open_ratio', '0'),
+					choices = face_editor_choices.face_editor_lip_open_ratio_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_lip_open_ratio_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-mouth-grim',
+					help = translator.get('help.mouth_grim', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_mouth_grim', '0'),
+					choices = face_editor_choices.face_editor_mouth_grim_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_mouth_grim_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-mouth-pout',
+					help = translator.get('help.mouth_pout', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_mouth_pout', '0'),
+					choices = face_editor_choices.face_editor_mouth_pout_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_mouth_pout_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-mouth-purse',
+					help = translator.get('help.mouth_purse', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_mouth_purse', '0'),
+					choices = face_editor_choices.face_editor_mouth_purse_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_mouth_purse_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-mouth-smile',
+					help = translator.get('help.mouth_smile', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_mouth_smile', '0'),
+					choices = face_editor_choices.face_editor_mouth_smile_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_mouth_smile_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-mouth-position-horizontal',
+					help = translator.get('help.mouth_position_horizontal', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_mouth_position_horizontal', '0'),
+					choices = face_editor_choices.face_editor_mouth_position_horizontal_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_mouth_position_horizontal_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-mouth-position-vertical',
+					help = translator.get('help.mouth_position_vertical', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_mouth_position_vertical', '0'),
+					choices = face_editor_choices.face_editor_mouth_position_vertical_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_mouth_position_vertical_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-head-pitch',
+					help = translator.get('help.head_pitch', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_head_pitch', '0'),
+					choices = face_editor_choices.face_editor_head_pitch_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_head_pitch_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-head-yaw',
+					help = translator.get('help.head_yaw', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_head_yaw', '0'),
+					choices = face_editor_choices.face_editor_head_yaw_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_head_yaw_range)
+				),
+				group_processors.add_argument(
+					'--face-editor-head-roll',
+					help = translator.get('help.head_roll', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_editor_head_roll', '0'),
+					choices = face_editor_choices.face_editor_head_roll_range,
+					metavar = create_float_metavar(face_editor_choices.face_editor_head_roll_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'face_editor' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -185,12 +293,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -5,8 +5,8 @@ from typing import List

 import numpy

+import facefusion.capability_store
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_float_metavar, create_int_metavar, get_middle
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
@@ -14,13 +14,13 @@ from facefusion.face_creator import scale_face
 from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
 from facefusion.face_masker import create_box_mask, create_occlusion_mask
 from facefusion.face_selector import select_faces
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.processors.modules.face_enhancer import choices as face_enhancer_choices
 from facefusion.processors.modules.face_enhancer.types import FaceEnhancerInputs, FaceEnhancerWeight
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import blend_frame, read_static_image, read_static_video_chunk, read_static_video_frame


@@ -294,10 +294,34 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--face-enhancer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'face_enhancer_model', 'gfpgan_1.4'), choices = face_enhancer_choices.face_enhancer_models)
-		group_processors.add_argument('--face-enhancer-blend', help = translator.get('help.blend', __package__), type = int, default = config.get_int_value('processors', 'face_enhancer_blend', '80'), choices = face_enhancer_choices.face_enhancer_blend_range, metavar = create_int_metavar(face_enhancer_choices.face_enhancer_blend_range))
-		group_processors.add_argument('--face-enhancer-weight', help = translator.get('help.weight', __package__), type = float, default = config.get_float_value('processors', 'face_enhancer_weight', '0.5'), choices = face_enhancer_choices.face_enhancer_weight_range, metavar = create_float_metavar(face_enhancer_choices.face_enhancer_weight_range))
-		facefusion.jobs.job_store.register_step_keys([ 'face_enhancer_model', 'face_enhancer_blend', 'face_enhancer_weight' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--face-enhancer-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'face_enhancer_model', 'gfpgan_1.4'),
+					choices = face_enhancer_choices.face_enhancer_models
+				),
+				group_processors.add_argument(
+					'--face-enhancer-blend',
+					help = translator.get('help.blend', __package__),
+					type = int,
+					default = config.get_int_value('processors', 'face_enhancer_blend', '80'),
+					choices = face_enhancer_choices.face_enhancer_blend_range,
+					metavar = create_int_metavar(face_enhancer_choices.face_enhancer_blend_range)
+				),
+				group_processors.add_argument(
+					'--face-enhancer-weight',
+					help = translator.get('help.weight', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_enhancer_weight', '0.5'),
+					choices = face_enhancer_choices.face_enhancer_weight_range,
+					metavar = create_float_metavar(face_enhancer_choices.face_enhancer_weight_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'face_enhancer' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -325,12 +349,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -6,9 +6,9 @@ from typing import List, Optional, Tuple
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.choices
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import get_first, get_middle, is_macos
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
@@ -17,15 +17,15 @@ from facefusion.face_creator import average_face_identity, get_one_face, get_sta
 from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
 from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
 from facefusion.face_selector import select_faces, sort_faces_by_order
-from facefusion.filesystem import filter_image_paths, has_image, in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import filter_image_paths, has_image, in_directory, is_image, is_video, resolve_relative_path
 from facefusion.model_helper import get_static_model_initializer
 from facefusion.processors.modules.face_swapper import choices as face_swapper_choices
 from facefusion.processors.modules.face_swapper.types import FaceSwapperInputs
 from facefusion.processors.pixel_boost import explode_pixel_boost, implode_pixel_boost
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import conditional_thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, Embedding, Face, InferencePool, InferenceProvider, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, Embedding, Face, InferencePool, InferenceProvider, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import read_static_image, read_static_images, read_static_video_chunk, read_static_video_frame, unpack_resolution


@@ -528,12 +528,39 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--face-swapper-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'face_swapper_model', 'hyperswap_1a_256'), choices = face_swapper_choices.face_swapper_models)
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--face-swapper-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'face_swapper_model', 'hyperswap_1a_256'),
+					choices = face_swapper_choices.face_swapper_models
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'face_swapper' ]
+		)
 		known_args, _ = program.parse_known_args()
 		face_swapper_pixel_boost_choices = face_swapper_choices.face_swapper_set.get(known_args.face_swapper_model)
-		group_processors.add_argument('--face-swapper-pixel-boost', help = translator.get('help.pixel_boost', __package__), default = config.get_str_value('processors', 'face_swapper_pixel_boost', get_first(face_swapper_pixel_boost_choices)), choices = face_swapper_pixel_boost_choices)
-		group_processors.add_argument('--face-swapper-weight', help = translator.get('help.weight', __package__), type = float, default = config.get_float_value('processors', 'face_swapper_weight', '0.5'), choices = face_swapper_choices.face_swapper_weight_range)
-		facefusion.jobs.job_store.register_step_keys([ 'face_swapper_model', 'face_swapper_pixel_boost', 'face_swapper_weight' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--face-swapper-pixel-boost',
+					help = translator.get('help.pixel_boost', __package__),
+					default = config.get_str_value('processors', 'face_swapper_pixel_boost', get_first(face_swapper_pixel_boost_choices)),
+					choices = face_swapper_pixel_boost_choices
+				),
+				group_processors.add_argument(
+					'--face-swapper-weight',
+					help = translator.get('help.weight', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'face_swapper_weight', '0.5'),
+					choices = face_swapper_choices.face_swapper_weight_range
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'face_swapper' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -574,13 +601,10 @@ def pre_process(mode : ProcessMode) -> bool:
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False

-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False

 	return True

@@ -6,20 +6,20 @@ from typing import List
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.choices
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_int_metavar, is_macos
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
 from facefusion.execution import has_execution_provider
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.processors.modules.frame_colorizer import choices as frame_colorizer_choices
 from facefusion.processors.modules.frame_colorizer.types import FrameColorizerInputs
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, InferencePool, InferenceProvider, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, InferencePool, InferenceProvider, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import blend_frame, read_static_image, read_static_video_chunk, read_static_video_frame, unpack_resolution


@@ -187,10 +187,33 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--frame-colorizer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'frame_colorizer_model', 'ddcolor'), choices = frame_colorizer_choices.frame_colorizer_models)
-		group_processors.add_argument('--frame-colorizer-size', help = translator.get('help.size', __package__), type = str, default = config.get_str_value('processors', 'frame_colorizer_size', '256x256'), choices = frame_colorizer_choices.frame_colorizer_sizes)
-		group_processors.add_argument('--frame-colorizer-blend', help = translator.get('help.blend', __package__), type = int, default = config.get_int_value('processors', 'frame_colorizer_blend', '100'), choices = frame_colorizer_choices.frame_colorizer_blend_range, metavar = create_int_metavar(frame_colorizer_choices.frame_colorizer_blend_range))
-		facefusion.jobs.job_store.register_step_keys([ 'frame_colorizer_model', 'frame_colorizer_blend', 'frame_colorizer_size' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--frame-colorizer-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'frame_colorizer_model', 'ddcolor'),
+					choices = frame_colorizer_choices.frame_colorizer_models
+				),
+				group_processors.add_argument(
+					'--frame-colorizer-size',
+					help = translator.get('help.size', __package__),
+					type = str,
+					default = config.get_str_value('processors', 'frame_colorizer_size', '256x256'),
+					choices = frame_colorizer_choices.frame_colorizer_sizes
+				),
+				group_processors.add_argument(
+					'--frame-colorizer-blend',
+					help = translator.get('help.blend', __package__),
+					type = int,
+					default = config.get_int_value('processors', 'frame_colorizer_blend', '100'),
+					choices = frame_colorizer_choices.frame_colorizer_blend_range,
+					metavar = create_int_metavar(frame_colorizer_choices.frame_colorizer_blend_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'frame_colorizer' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -218,12 +241,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -6,20 +6,20 @@ from typing import List
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.choices
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, inference_manager, logger, state_manager, translator, video_manager
 from facefusion.common_helper import create_int_metavar, is_macos
 from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
 from facefusion.execution import has_execution_provider
-from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
+from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path
 from facefusion.processors.modules.frame_enhancer import choices as frame_enhancer_choices
 from facefusion.processors.modules.frame_enhancer.types import FrameEnhancerInputs
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import conditional_thread_semaphore
-from facefusion.types import ApplyStateItem, Args, DownloadScope, InferencePool, InferenceProvider, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, DownloadScope, InferencePool, InferenceProvider, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import blend_frame, create_tile_frames, merge_tile_frames, read_static_image, read_static_video_chunk, read_static_video_frame


@@ -582,9 +582,26 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--frame-enhancer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'frame_enhancer_model', 'span_kendata_x4'), choices = frame_enhancer_choices.frame_enhancer_models)
-		group_processors.add_argument('--frame-enhancer-blend', help = translator.get('help.blend', __package__), type = int, default = config.get_int_value('processors', 'frame_enhancer_blend', '80'), choices = frame_enhancer_choices.frame_enhancer_blend_range, metavar = create_int_metavar(frame_enhancer_choices.frame_enhancer_blend_range))
-		facefusion.jobs.job_store.register_step_keys([ 'frame_enhancer_model', 'frame_enhancer_blend' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--frame-enhancer-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'frame_enhancer_model', 'span_kendata_x4'),
+					choices = frame_enhancer_choices.frame_enhancer_models
+				),
+				group_processors.add_argument(
+					'--frame-enhancer-blend',
+					help = translator.get('help.blend', __package__),
+					type = int,
+					default = config.get_int_value('processors', 'frame_enhancer_blend', '80'),
+					choices = frame_enhancer_choices.frame_enhancer_blend_range,
+					metavar = create_int_metavar(frame_enhancer_choices.frame_enhancer_blend_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'frame_enhancer' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -611,12 +628,10 @@ def pre_process(mode : ProcessMode) -> bool:
 	if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
 		logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
 		return False
-	if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
-		logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
-		return False
-	if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
-		logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
-		return False
+	if state_manager.get_item('workflow') in [ 'audio-to-image:video', 'image-to-image', 'image-to-video' ]:
+		if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
+			logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
+			return False
 	return True


@@ -6,8 +6,8 @@ from typing import List
 import cv2
 import numpy

+import facefusion.capability_store
 import facefusion.jobs.job_manager
-import facefusion.jobs.job_store
 from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager, voice_extractor
 from facefusion.audio import read_static_voice
 from facefusion.common_helper import create_float_metavar, get_middle
@@ -19,10 +19,10 @@ from facefusion.face_selector import select_faces
 from facefusion.filesystem import has_audio, resolve_relative_path
 from facefusion.processors.modules.lip_syncer import choices as lip_syncer_choices
 from facefusion.processors.modules.lip_syncer.types import LipSyncerInputs, LipSyncerWeight
-from facefusion.processors.types import ProcessorOutputs
+from facefusion.processors.types import ApplyStateItem, ProcessorOutputs
 from facefusion.program_helper import find_argument_group
 from facefusion.thread_helper import conditional_thread_semaphore
-from facefusion.types import ApplyStateItem, Args, AudioFrame, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
+from facefusion.types import Args, AudioFrame, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
 from facefusion.vision import read_static_image, read_static_video_chunk, read_static_video_frame


@@ -134,9 +134,26 @@ def get_model_options() -> ModelOptions:
 def register_args(program : ArgumentParser) -> None:
 	group_processors = find_argument_group(program, 'processors')
 	if group_processors:
-		group_processors.add_argument('--lip-syncer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'lip_syncer_model', 'wav2lip_gan_96'), choices = lip_syncer_choices.lip_syncer_models)
-		group_processors.add_argument('--lip-syncer-weight', help = translator.get('help.weight', __package__), type = float, default = config.get_float_value('processors', 'lip_syncer_weight', '0.5'), choices = lip_syncer_choices.lip_syncer_weight_range, metavar = create_float_metavar(lip_syncer_choices.lip_syncer_weight_range))
-		facefusion.jobs.job_store.register_step_keys([ 'lip_syncer_model', 'lip_syncer_weight' ])
+		facefusion.capability_store.register_capability_set(
+			[
+				group_processors.add_argument(
+					'--lip-syncer-model',
+					help = translator.get('help.model', __package__),
+					default = config.get_str_value('processors', 'lip_syncer_model', 'wav2lip_gan_96'),
+					choices = lip_syncer_choices.lip_syncer_models
+				),
+				group_processors.add_argument(
+					'--lip-syncer-weight',
+					help = translator.get('help.weight', __package__),
+					type = float,
+					default = config.get_float_value('processors', 'lip_syncer_weight', '0.5'),
+					choices = lip_syncer_choices.lip_syncer_weight_range,
+					metavar = create_float_metavar(lip_syncer_choices.lip_syncer_weight_range)
+				)
+			],
+			scopes = [ 'api', 'cli' ],
+			groups = [ 'lip_syncer' ]
+		)


 def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
@@ -1,4 +1,4 @@
-from typing import Any, Dict, Tuple, TypeAlias
+from typing import Any, Callable, Dict, Tuple, TypeAlias

 from numpy.typing import NDArray

@@ -14,7 +14,11 @@ LivePortraitRotation : TypeAlias = NDArray[Any]
 LivePortraitScale : TypeAlias = NDArray[Any]
 LivePortraitTranslation : TypeAlias = NDArray[Any]

-ProcessorStateKey = str
-ProcessorState : TypeAlias = Dict[ProcessorStateKey, Any]
+ProcessorStateValue : TypeAlias = Any
+ProcessorStateKey : TypeAlias = str
+ProcessorState : TypeAlias = Dict[ProcessorStateKey, ProcessorStateValue]
 ProcessorStateSet : TypeAlias = Dict[AppContext, ProcessorState]
+
+ApplyStateItem : TypeAlias = Callable[[ProcessorStateKey, ProcessorStateValue], None]
+
 ProcessorOutputs : TypeAlias = Tuple[VisionFrame, Mask]
@@ -0,0 +1,275 @@
+import ctypes
+from typing import List, Optional
+
+from facefusion.libraries import datachannel as datachannel_module
+from facefusion.types import AudioCodec, BitRate, Buffer, MediaDirection, PeerConnection, RtcAudioTrack, RtcPeer, RtcTrackInit, RtcVideoTrack, SdpAnswer, SdpOffer, Time, VideoCodec
+
+
+def create_peer_connection() -> PeerConnection:
+	datachannel_library = datachannel_module.create_static_library()
+	rtc_configuration = datachannel_module.define_rtc_configuration()
+
+	rtc_configuration.enableIceUdpMux = True
+	rtc_configuration.forceMediaTransport = True
+	rtc_configuration.disableAutoNegotiation = True
+
+	return datachannel_library.rtcCreatePeerConnection(ctypes.byref(rtc_configuration))
+
+
+def create_sdp_offer(peer_connection : PeerConnection) -> Optional[SdpOffer]:
+	datachannel_library = datachannel_module.create_static_library()
+	datachannel_library.rtcSetLocalDescription(peer_connection, b'offer')
+
+	sdp_buffer = ctypes.create_string_buffer(8192)
+
+	if datachannel_library.rtcGetLocalDescription(peer_connection, sdp_buffer, 8192):
+		return sdp_buffer.value.decode()
+
+	return None
+
+
+def create_sdp_answer(peer_connection : PeerConnection) -> Optional[SdpAnswer]:
+	datachannel_library = datachannel_module.create_static_library()
+	datachannel_library.rtcSetLocalDescription(peer_connection, b'answer')
+
+	sdp_buffer = ctypes.create_string_buffer(8192)
+
+	if datachannel_library.rtcGetLocalDescription(peer_connection, sdp_buffer, 8192):
+		return sdp_buffer.value.decode()
+
+	return None
+
+
+def set_remote_description(peer_connection : PeerConnection, sdp_offer : SdpOffer) -> None:
+	datachannel_library = datachannel_module.create_static_library()
+	datachannel_library.rtcSetRemoteDescription(peer_connection, sdp_offer.encode(), b'offer')
+
+	return None
+
+
+def send_video(rtc_peer : RtcPeer, video_buffer : Buffer, video_timestamp : int) -> None:
+	datachannel_library = datachannel_module.create_static_library()
+
+	if rtc_peer.get('video'):
+		video_track = rtc_peer.get('video').get('sender_track')
+
+		if datachannel_library.rtcIsOpen(video_track):
+			video_total = len(video_buffer)
+			datachannel_library.rtcSetTrackRtpTimestamp(video_track, video_timestamp)
+			datachannel_library.rtcSendMessage(video_track, video_buffer, video_total)
+
+	return None
+
+
+def send_audio(rtc_peer : RtcPeer, audio_buffer : Buffer, audio_timestamp : int) -> None:
+	datachannel_library = datachannel_module.create_static_library()
+
+	if rtc_peer.get('audio'):
+		audio_track = rtc_peer.get('audio').get('sender_track')
+
+		if datachannel_library.rtcIsOpen(audio_track):
+			audio_total = len(audio_buffer)
+			datachannel_library.rtcSetTrackRtpTimestamp(audio_track, audio_timestamp)
+			datachannel_library.rtcSendMessage(audio_track, audio_buffer, audio_total)
+
+	return None
+
+
+def delete_peers(rtc_peers : List[RtcPeer]) -> None:
+	datachannel_library = datachannel_module.create_static_library()
+
+	for rtc_peer in rtc_peers:
+		peer_connection = rtc_peer.get('peer_connection')
+
+		if peer_connection:
+			datachannel_library.rtcDeletePeerConnection(peer_connection)
+
+	return None
+
+
+def add_audio_track(peer_connection : PeerConnection, media_direction : MediaDirection, audio_codec : AudioCodec, payload_type : int) -> RtcAudioTrack:
+	datachannel_library = datachannel_module.create_static_library()
+	audio_track_init = create_audio_track_init(media_direction, audio_codec, payload_type)
+	audio_track = datachannel_library.rtcAddTrackEx(peer_connection, audio_track_init)
+
+	if media_direction == 'sendonly':
+		audio_packetizer = datachannel_module.define_rtc_packetizer_init()
+		audio_packetizer.ssrc = 43
+		audio_packetizer.cname = b'audio'
+		audio_packetizer.payloadType = payload_type
+		audio_packetizer.clockRate = 48000
+
+		if audio_codec == 'opus':
+			datachannel_library.rtcSetOpusPacketizer(audio_track, ctypes.byref(audio_packetizer))
+
+		datachannel_library.rtcChainRtcpSrReporter(audio_track)
+
+	if media_direction == 'recvonly':
+		audio_depacketizer = datachannel_module.define_rtc_packetizer_init()
+		audio_depacketizer.ssrc = 0
+		audio_depacketizer.cname = b'audio'
+		audio_depacketizer.payloadType = payload_type
+		audio_depacketizer.clockRate = 48000
+
+		if audio_codec == 'opus':
+			datachannel_library.rtcSetOpusDepacketizer(audio_track, ctypes.byref(audio_depacketizer))
+
+		datachannel_library.rtcChainRtcpReceivingSession(audio_track)
+
+	return audio_track
+
+
+def add_video_track(peer_connection : PeerConnection, media_direction : MediaDirection, video_codec : VideoCodec, payload_type : int) -> RtcVideoTrack:
+	datachannel_library = datachannel_module.create_static_library()
+	video_track_init = create_video_track_init(media_direction, video_codec, payload_type)
+	video_track = datachannel_library.rtcAddTrackEx(peer_connection, video_track_init)
+
+	if media_direction == 'sendonly':
+		video_packetizer = datachannel_module.define_rtc_packetizer_init()
+		video_packetizer.ssrc = 42
+		video_packetizer.cname = b'video'
+		video_packetizer.payloadType = payload_type
+		video_packetizer.clockRate = 90000
+		video_packetizer.maxFragmentSize = 1200
+
+		if video_codec == 'av1':
+			video_packetizer.obuPacketization = 1
+			datachannel_library.rtcSetAV1Packetizer(video_track, ctypes.byref(video_packetizer))
+
+		if video_codec == 'vp8':
+			datachannel_library.rtcSetVP8Packetizer(video_track, ctypes.byref(video_packetizer))
+
+		if video_codec == 'vp9':
+			datachannel_library.rtcSetVP9Packetizer(video_track, ctypes.byref(video_packetizer))
+
+		datachannel_library.rtcChainRtcpSrReporter(video_track)
+		datachannel_library.rtcChainRtcpNackResponder(video_track, 512)
+
+	if media_direction == 'recvonly':
+		if video_codec == 'av1':
+			datachannel_library.rtcSetAV1Depacketizer(video_track, 1)
+
+		if video_codec == 'vp8':
+			video_depacketizer = datachannel_module.define_rtc_packetizer_init()
+			video_depacketizer.ssrc = 0
+			video_depacketizer.cname = b'video'
+			video_depacketizer.payloadType = payload_type
+			video_depacketizer.clockRate = 90000
+			datachannel_library.rtcSetVP8Depacketizer(video_track, ctypes.byref(video_depacketizer))
+
+		if video_codec == 'vp9':
+			video_depacketizer = datachannel_module.define_rtc_packetizer_init()
+			video_depacketizer.ssrc = 0
+			video_depacketizer.cname = b'video'
+			video_depacketizer.payloadType = payload_type
+			video_depacketizer.clockRate = 90000
+			datachannel_library.rtcSetVP9Depacketizer(video_track, ctypes.byref(video_depacketizer))
+
+		datachannel_library.rtcChainRtcpReceivingSession(video_track)
+
+	return video_track
+
+
+def create_audio_track_init(media_direction : MediaDirection, audio_codec : AudioCodec, payload_type : int) -> RtcTrackInit:
+	track_init = datachannel_module.define_rtc_track_init()
+	track_init.name = b'audio'
+	track_init.payloadType = payload_type
+
+	if media_direction == 'sendonly':
+		track_init.direction = 1
+		track_init.mid = b'3'
+		track_init.ssrc = 43
+
+	if media_direction == 'recvonly':
+		track_init.direction = 2
+		track_init.mid = b'2'
+		track_init.ssrc = 45
+
+	if media_direction == 'sendrecv':
+		track_init.direction = 3
+		track_init.mid = b'1'
+		track_init.ssrc = 43
+
+	if audio_codec == 'opus':
+		track_init.codec = 128
+
+	return ctypes.byref(track_init)
+
+
+def create_video_track_init(media_direction : MediaDirection, video_codec : VideoCodec, payload_type : int) -> RtcTrackInit:
+	track_init = datachannel_module.define_rtc_track_init()
+	track_init.name = b'video'
+	track_init.payloadType = payload_type
+
+	if media_direction == 'sendonly':
+		track_init.direction = 1
+		track_init.mid = b'1'
+		track_init.ssrc = 42
+
+	if media_direction == 'recvonly':
+		track_init.direction = 2
+		track_init.mid = b'0'
+		track_init.ssrc = 44
+
+	if media_direction == 'sendrecv':
+		track_init.direction = 3
+		track_init.mid = b'0'
+		track_init.ssrc = 42
+
+	if video_codec == 'av1':
+		track_init.codec = 4
+
+	if video_codec == 'vp8':
+		track_init.codec = 1
+
+	if video_codec == 'vp9':
+		track_init.codec = 2
+
+	return ctypes.byref(track_init)
+
+
+def get_payload_type(sdp_offer : SdpOffer, codec : AudioCodec | VideoCodec) -> int:
+	datachannel_library = datachannel_module.create_static_library()
+	payload_type_buffer = (ctypes.c_int * 16)()
+	payload_type_total = datachannel_library.rtcGetPayloadTypesForCodec(sdp_offer.encode(), codec.lower().encode(), payload_type_buffer, 16)
+
+	if payload_type_total:
+		return payload_type_buffer[0]
+
+	return 0
+
+
+def convert_time_to_timestamp(codec : AudioCodec | VideoCodec, time : Time) -> int:
+	if codec == 'opus':
+		return int(time * 48000)
+	return int(time * 90000)
+
+
+def convert_timestamp_to_time(codec : AudioCodec | VideoCodec, timestamp : int) -> Time:
+	if codec == 'opus':
+		return timestamp / 48000
+	return timestamp / 90000
+
+
+@ctypes.CFUNCTYPE(None, ctypes.c_int, ctypes.c_uint, ctypes.c_void_p)
+def handle_sender_bitrate(_ : int, bitrate : BitRate, pointer : int) -> None:
+	ctypes.cast(pointer, ctypes.POINTER(ctypes.c_uint)).contents.value = bitrate // 1000
+
+
+def wire_sender_bitrate(video_track : RtcVideoTrack, bitrate : ctypes.c_uint) -> None:
+	datachannel_library = datachannel_module.create_static_library()
+	datachannel_library.rtcSetUserPointer(video_track, ctypes.cast(ctypes.byref(bitrate), ctypes.c_void_p))
+	datachannel_library.rtcChainRembHandler(video_track, handle_sender_bitrate)
+
+
+def adapt_receiver_bitrate(rtc_peer : RtcPeer, bitrate : BitRate) -> None:
+	datachannel_library = datachannel_module.create_static_library()
+	receiver_track = rtc_peer.get('video').get('receiver_track')
+
+	rtc_peer.get('receiver_bitrate').value = bitrate
+	datachannel_library.rtcRequestBitrate(receiver_track, bitrate * 1000)
+
+
+def clear_bitrate(rtc_peer : RtcPeer) -> None:
+	rtc_peer.get('sender_bitrate').value = 0
+	rtc_peer.get('receiver_bitrate').value = 0
@@ -0,0 +1,33 @@
+from typing import List
+
+from facefusion import rtc
+from facefusion.types import RtcPeer, RtcStore, SessionId
+
+RTC_STORE : RtcStore = {}
+
+
+def init_peers(session_id : SessionId) -> None:
+	RTC_STORE[session_id] = []
+
+
+def has_peers(session_id : SessionId) -> bool:
+	return bool(RTC_STORE.get(session_id))
+
+
+def get_peers(session_id : SessionId) -> List[RtcPeer]:
+	return RTC_STORE.get(session_id)
+
+
+def delete_peers(session_id : SessionId) -> None:
+	if session_id in RTC_STORE:
+		rtc_peers = get_peers(session_id)
+
+		if rtc_peers:
+			rtc.delete_peers(rtc_peers)
+			del RTC_STORE[session_id]
+
+	return None
+
+
+def clear() -> None:
+	RTC_STORE.clear()
@@ -0,0 +1,18 @@
+from contextvars import ContextVar
+from typing import Optional
+
+from facefusion.types import SessionId
+
+SESSION_ID : ContextVar[Optional[SessionId]] = ContextVar('SESSION_ID', default = None)
+
+
+def set_session_id(session_id : SessionId) -> None:
+	SESSION_ID.set(session_id)
+
+
+def get_session_id() -> Optional[SessionId]:
+	return SESSION_ID.get()
+
+
+def clear_session_id() -> None:
+	SESSION_ID.set(None)
@@ -0,0 +1,46 @@
+import secrets
+from datetime import datetime, timedelta
+from typing import Dict
+from typing import Optional
+
+from facefusion.types import Session, SessionId
+
+SESSIONS : Dict[SessionId, Session] = {}
+
+
+def create_session() -> Session:
+	session : Session =\
+	{
+		'access_token': secrets.token_urlsafe(64),
+		'refresh_token': secrets.token_urlsafe(64),
+		'created_at': datetime.now(),
+		'expires_at': datetime.now() + timedelta(minutes = 10)
+	}
+
+	return session
+
+
+def get_session(session_id : SessionId) -> Optional[Session]:
+	return SESSIONS.get(session_id)
+
+
+def find_session_id(access_token : str) -> Optional[SessionId]:
+	for session_id, session in SESSIONS.items():
+		if session.get('access_token') == access_token:
+			return session_id
+	return None
+
+
+def set_session(session_id : SessionId, session : Session) -> None:
+	SESSIONS[session_id] = session
+
+
+def validate_session(session_id : SessionId) -> bool:
+	session = get_session(session_id)
+	return session and datetime.now() <= session.get('expires_at')
+
+
+def clear_session(session_id : SessionId) -> None:
+	if session_id in SESSIONS:
+		del SESSIONS[session_id]
+
@@ -1,13 +1,15 @@
-from typing import Any, Union
+import os
+from typing import Union

 from facefusion.app_context import detect_app_context
 from facefusion.processors.types import ProcessorState, ProcessorStateKey, ProcessorStateSet
-from facefusion.types import State, StateKey, StateSet
+from facefusion.session_context import get_session_id
+from facefusion.types import Args, State, StateKey, StateSet, StateValue

 STATE_SET : Union[StateSet, ProcessorStateSet] =\
 {
-	'cli': {}, #type:ignore[assignment]
-	'ui': {} #type:ignore[assignment]
+	'api': {}, #type:ignore[assignment]
+	'cli': {} #type:ignore[assignment]
 }


@@ -16,27 +18,45 @@ def get_state() -> Union[State, ProcessorState]:
 	return STATE_SET.get(app_context)


-def sync_state() -> None:
-	STATE_SET['cli'] = STATE_SET.get('ui') #type:ignore[assignment]
+def collect_state(args : Args) -> Union[State, ProcessorState]:
+	state =\
+	{
+		key: get_item(key) for key in args
+	}
+	return state


-def init_item(key : Union[StateKey, ProcessorStateKey], value : Any) -> None:
+def init_item(key : Union[StateKey, ProcessorStateKey], value : StateValue) -> None:
+	STATE_SET['api'][key] = value #type:ignore[literal-required]
 	STATE_SET['cli'][key] = value #type:ignore[literal-required]
-	STATE_SET['ui'][key] = value #type:ignore[literal-required]


-def get_item(key : Union[StateKey, ProcessorStateKey]) -> Any:
-	return get_state().get(key) #type:ignore[literal-required]
+def get_item(key : Union[StateKey, ProcessorStateKey]) -> StateValue:
+	return get_state().get(key)


-def set_item(key : Union[StateKey, ProcessorStateKey], value : Any) -> None:
+def set_item(key : Union[StateKey, ProcessorStateKey], value : StateValue) -> None:
 	app_context = detect_app_context()
 	STATE_SET[app_context][key] = value #type:ignore[literal-required]


-def sync_item(key : Union[StateKey, ProcessorStateKey]) -> None:
-	STATE_SET['cli'][key] = STATE_SET.get('ui').get(key) #type:ignore[literal-required]
-
-
 def clear_item(key : Union[StateKey, ProcessorStateKey]) -> None:
 	set_item(key, None)
+
+
+def get_jobs_path() -> str:
+	jobs_path = get_item('jobs_path')
+	session_id = get_session_id()
+
+	if session_id:
+		return os.path.join(jobs_path, session_id)
+	return jobs_path
+
+
+def get_temp_path() -> str:
+	temp_path = get_item('temp_path')
+	session_id = get_session_id()
+
+	if session_id:
+		return os.path.join(temp_path, session_id)
+	return temp_path
@@ -2,7 +2,7 @@ import os
 import subprocess
 from collections import deque
 from concurrent.futures import ThreadPoolExecutor
-from typing import Deque, Iterator, List
+from typing import Deque, Iterator

 import cv2
 import numpy
@@ -14,13 +14,12 @@ from facefusion.content_analyser import analyse_stream
 from facefusion.ffmpeg import open_ffmpeg
 from facefusion.filesystem import is_directory
 from facefusion.processors.core import get_processors_modules
-from facefusion.types import Fps, StreamMode, VisionFrame
+from facefusion.types import Buffer, Fps, StreamMode, VisionFrame
 from facefusion.vision import extract_vision_mask, read_static_images


 def multi_process_capture(camera_capture : cv2.VideoCapture, camera_fps : Fps) -> Iterator[VisionFrame]:
 	capture_deque : Deque[VisionFrame] = deque()
-	source_vision_frames = read_static_images(state_manager.get_item('source_paths'))

 	with tqdm(desc = translator.get('streaming'), unit = 'frame', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
 		with ThreadPoolExecutor(max_workers = state_manager.get_item('execution_thread_count')) as executor:
@@ -32,7 +31,7 @@ def multi_process_capture(camera_capture : cv2.VideoCapture, camera_fps : Fps) -
 					camera_capture.release()

 				if numpy.any(capture_vision_frame):
-					future = executor.submit(process_stream_frame, source_vision_frames, capture_vision_frame)
+					future = executor.submit(process_stream_frame, capture_vision_frame)
 					futures.append(future)

 				for future_done in [ future for future in futures if future.done() ]:
@@ -45,7 +44,8 @@ def multi_process_capture(camera_capture : cv2.VideoCapture, camera_fps : Fps) -
 					yield capture_deque.popleft()


-def process_stream_frame(source_vision_frames : List[VisionFrame], target_vision_frame : VisionFrame) -> VisionFrame:
+def process_stream_frame(target_vision_frame : VisionFrame) -> VisionFrame:
+	source_vision_frames = read_static_images(state_manager.get_item('source_paths'))
 	source_audio_frame = create_empty_audio_frame()
 	source_voice_frame = create_empty_audio_frame()
 	temp_vision_frame = target_vision_frame.copy()
@@ -69,7 +69,7 @@ def process_stream_frame(source_vision_frames : List[VisionFrame], target_vision
 	return temp_vision_frame


-def open_stream(stream_mode : StreamMode, stream_resolution : str, stream_fps : Fps) -> subprocess.Popen[bytes]:
+def open_stream(stream_mode : StreamMode, stream_resolution : str, stream_fps : Fps) -> subprocess.Popen[Buffer]:
 	commands = ffmpeg_builder.chain(
 		ffmpeg_builder.capture_video(),
 		ffmpeg_builder.set_media_resolution(stream_resolution),
@@ -0,0 +1,295 @@
+import ctypes
+import shutil
+from pathlib import Path
+from typing import List
+
+import psutil
+
+from facefusion import state_manager
+from facefusion.libraries import amd_smi as amd_smi_module, nvidia_ml as nvidia_ml_module, rocm_core as rocm_core_module
+from facefusion.types import DiskMetrics, ExecutionProvider, GraphicDevice, MemoryMetrics, Metrics, NetworkMetrics, ProcessorMetrics
+
+
+def get_metrics_set() -> Metrics:
+	drive_path = Path(state_manager.get_temp_path()).anchor
+
+	return\
+	{
+		'graphic_devices': detect_graphic_devices(state_manager.get_item('execution_providers')),
+		'disks': detect_disk_metrics([ drive_path ]),
+		'memory': detect_memory_metrics(),
+		'network': detect_network_metrics(),
+		'processor': detect_processor_metrics()
+	}
+
+
+def detect_graphic_devices(execution_providers : List[ExecutionProvider]) -> List[GraphicDevice]:
+	if 'rocm' in execution_providers or 'migraphx' in execution_providers:
+		return detect_amd_graphic_devices()
+	if 'cuda' in execution_providers or 'tensorrt' in execution_providers:
+		return detect_nvidia_graphic_devices()
+	return []
+
+
+def detect_nvidia_graphic_devices() -> List[GraphicDevice]:
+	nvidia_ml_library = nvidia_ml_module.create_static_library()
+	graphic_devices : List[GraphicDevice] = []
+
+	if nvidia_ml_library:
+		nvidia_ml_library.nvmlInit_v2()
+
+		driver_version = ctypes.create_string_buffer(128)
+		nvidia_ml_library.nvmlSystemGetDriverVersion(driver_version, 128)
+
+		cuda_version = ctypes.c_int()
+		nvidia_ml_library.nvmlSystemGetCudaDriverVersion(ctypes.byref(cuda_version))
+
+		for device_handle in nvidia_ml_module.find_device_handles(nvidia_ml_library):
+			device_name = ctypes.create_string_buffer(128)
+			nvidia_ml_library.nvmlDeviceGetName(device_handle, device_name, 128)
+
+			device_memory = nvidia_ml_module.define_device_memory()
+			nvidia_ml_library.nvmlDeviceGetMemoryInfo(device_handle, ctypes.byref(device_memory))
+
+			device_temperature = ctypes.c_uint()
+			nvidia_ml_library.nvmlDeviceGetTemperature(device_handle, 0, ctypes.byref(device_temperature))
+
+			device_utilization = nvidia_ml_module.define_device_utilization()
+			nvidia_ml_library.nvmlDeviceGetUtilizationRates(device_handle, ctypes.byref(device_utilization))
+
+			graphic_devices.append(
+			{
+				'driver_version': driver_version.value.decode(),
+				'framework':
+				{
+					'name': 'CUDA',
+					'version': str(cuda_version.value)
+				},
+				'product':
+				{
+					'vendor': 'NVIDIA',
+					'name': device_name.value.decode()
+				},
+				'memory':
+				{
+					'total':
+					{
+						'value': device_memory.total // (1024 * 1024 * 1024),
+						'unit': 'GB'
+					},
+					'used':
+					{
+						'value': device_memory.used // (1024 * 1024 * 1024),
+						'unit': 'GB'
+					}
+				},
+				'temperature':
+				{
+					'gpu':
+					{
+						'value': device_temperature.value,
+						'unit': 'C'
+					},
+					'memory':
+					{
+						'value': 0,
+						'unit': '%'
+					}
+				},
+				'utilization':
+				{
+					'gpu':
+					{
+						'value': device_utilization.gpu,
+						'unit': '%'
+					},
+					'memory':
+					{
+						'value': device_utilization.memory,
+						'unit': '%'
+					}
+				}
+			})
+
+		nvidia_ml_library.nvmlShutdown()
+
+	return graphic_devices
+
+
+def detect_amd_graphic_devices() -> List[GraphicDevice]:
+	amd_smi_library = amd_smi_module.create_static_library()
+	graphic_devices : List[GraphicDevice] = []
+
+	if amd_smi_library:
+		amd_smi_library.amdsmi_init(ctypes.c_uint64(2))
+
+		rocm_core_library = rocm_core_module.create_static_library()
+		rocm_major_version = ctypes.c_uint()
+		rocm_minor_version = ctypes.c_uint()
+		rocm_patch_version = ctypes.c_uint()
+
+		if rocm_core_library:
+			rocm_core_library.getROCmVersion(ctypes.byref(rocm_major_version), ctypes.byref(rocm_minor_version), ctypes.byref(rocm_patch_version))
+
+		for device_handle in amd_smi_module.find_device_handles(amd_smi_library):
+			product_info = amd_smi_module.define_product_info()
+			amd_smi_library.amdsmi_get_gpu_asic_info(device_handle, ctypes.byref(product_info))
+
+			device_memory = amd_smi_module.define_device_memory()
+			amd_smi_library.amdsmi_get_gpu_vram_usage(device_handle, ctypes.byref(device_memory))
+
+			device_temperature = ctypes.c_int64()
+			amd_smi_library.amdsmi_get_temp_metric(device_handle, 0, 0, ctypes.byref(device_temperature))
+
+			device_utilization = amd_smi_module.define_device_utilization()
+			amd_smi_library.amdsmi_get_gpu_activity(device_handle, ctypes.byref(device_utilization))
+
+			graphic_devices.append(
+			{
+				'driver_version': '0.0.0',
+				'framework':
+				{
+					'name': 'ROCm',
+					'version': str(rocm_major_version.value) + '.' + str(rocm_minor_version.value) + '.' + str(rocm_patch_version.value)
+				},
+				'product':
+				{
+					'vendor': 'AMD',
+					'name': product_info.market_name.decode()
+				},
+				'memory':
+				{
+					'total':
+					{
+						'value': device_memory.vram_total // 1024,
+						'unit': 'GB'
+					},
+					'used':
+					{
+						'value': device_memory.vram_used // 1024,
+						'unit': 'GB'
+					}
+				},
+				'temperature':
+				{
+					'gpu':
+					{
+						'value': device_temperature.value // 1000,
+						'unit': 'C'
+					},
+					'memory':
+					{
+						'value': 0,
+						'unit': '%'
+					}
+				},
+				'utilization':
+				{
+					'gpu':
+					{
+						'value': device_utilization.gfx_activity,
+						'unit': '%'
+					},
+					'memory':
+					{
+						'value': device_utilization.umc_activity,
+						'unit': '%'
+					}
+				}
+			})
+
+		amd_smi_library.amdsmi_shut_down()
+
+	return graphic_devices
+
+
+def detect_disk_metrics(drive_paths : List[str]) -> List[DiskMetrics]:
+	disk_metrics : List[DiskMetrics] = []
+
+	for drive_path in drive_paths:
+		disk_usage = shutil.disk_usage(drive_path)
+
+		disk_metrics.append(
+		{
+			'total':
+			{
+				'value': int(disk_usage.total / (1024 * 1024 * 1024)),
+				'unit': 'GB'
+			},
+			'free':
+			{
+				'value': int(disk_usage.free / (1024 * 1024 * 1024)),
+				'unit': 'GB'
+			},
+			'utilization':
+			{
+				'value': int(disk_usage.used / disk_usage.total * 100),
+				'unit': '%'
+			}
+		})
+
+	return disk_metrics
+
+
+def detect_memory_metrics() -> MemoryMetrics:
+	virtual_memory = psutil.virtual_memory()
+
+	return\
+	{
+		'total':
+		{
+			'value': int(virtual_memory.total / (1024 * 1024 * 1024)),
+			'unit': 'GB'
+		},
+		'free':
+		{
+			'value': int(virtual_memory.available / (1024 * 1024 * 1024)),
+			'unit': 'GB'
+		},
+		'utilization':
+		{
+			'value': int(virtual_memory.percent),
+			'unit': '%'
+		}
+	}
+
+
+def detect_network_metrics() -> NetworkMetrics:
+	network_io = psutil.net_io_counters()
+
+	return\
+	{
+		'sent':
+		{
+			'value': int(network_io.bytes_sent / (1024 * 1024)),
+			'unit': 'MB'
+		},
+		'received':
+		{
+			'value': int(network_io.bytes_recv / (1024 * 1024)),
+			'unit': 'MB'
+		}
+	}
+
+
+def detect_processor_metrics() -> ProcessorMetrics:
+	cpu_frequency = psutil.cpu_freq()
+
+	return\
+	{
+		'cores':
+		{
+			'value': psutil.cpu_count(logical = True),
+			'unit': 'cores'
+		},
+		'frequency':
+		{
+			'value': int(cpu_frequency.current),
+			'unit': 'MHz'
+		},
+		'utilization':
+		{
+			'value': int(psutil.cpu_percent(interval = None)),
+			'unit': '%'
+		}
+	}
@@ -1,49 +1,40 @@
 import os
+from typing import List

-from facefusion import state_manager
 from facefusion.filesystem import create_directory, get_file_extension, get_file_name, move_file, remove_directory, resolve_file_pattern
-from facefusion.types import FrameSet


-def get_temp_file_path(file_path : str) -> str:
-	temp_directory_path = get_temp_directory_path(file_path)
-	temp_file_extension = get_file_extension(file_path)
+def get_temp_file_path(temp_path : str, output_path : str) -> str:
+	temp_directory_path = get_temp_directory_path(temp_path, output_path)
+	temp_file_extension = get_file_extension(output_path)
 	return os.path.join(temp_directory_path, 'temp' + temp_file_extension)


-def move_temp_file(file_path : str, move_path : str) -> bool:
-	temp_file_path = get_temp_file_path(file_path)
-	return move_file(temp_file_path, move_path)
+def move_temp_file(temp_path : str, output_path : str) -> bool:
+	temp_file_path = get_temp_file_path(temp_path, output_path)
+	return move_file(temp_file_path, output_path)


-def resolve_temp_frame_set(target_path : str) -> FrameSet:
-	temp_frame_pattern = get_temp_frame_pattern(target_path, '*')
-	temp_frame_set = {}
-
-	for temp_frame_path in resolve_file_pattern(temp_frame_pattern):
-		frame_number = int(get_file_name(temp_frame_path))
-		temp_frame_set[frame_number] = temp_frame_path
-
-	return temp_frame_set
+def resolve_temp_frame_paths(temp_path : str, output_path : str, temp_frame_format : str) -> List[str]:
+	temp_frames_pattern = get_temp_frames_pattern(temp_path, output_path, temp_frame_format, '*')
+	return resolve_file_pattern(temp_frames_pattern)


-def get_temp_frame_pattern(target_path : str, temp_frame_prefix : str) -> str:
-	temp_directory_path = get_temp_directory_path(target_path)
-	return os.path.join(temp_directory_path, temp_frame_prefix + '.' + state_manager.get_item('temp_frame_format'))
+def get_temp_frames_pattern(temp_path : str, output_path : str, temp_frame_format : str, temp_frame_prefix : str) -> str:
+	temp_directory_path = get_temp_directory_path(temp_path, output_path)
+	return os.path.join(temp_directory_path, temp_frame_prefix + '.' + temp_frame_format)


-def get_temp_directory_path(file_path : str) -> str:
-	temp_file_name = get_file_name(file_path)
-	return os.path.join(state_manager.get_item('temp_path'), 'facefusion', temp_file_name)
+def get_temp_directory_path(temp_path : str, output_path : str) -> str:
+	temp_file_name = get_file_name(output_path)
+	return os.path.join(temp_path, 'facefusion', temp_file_name)


-def create_temp_directory(file_path : str) -> bool:
-	temp_directory_path = get_temp_directory_path(file_path)
+def create_temp_directory(temp_path : str, output_path : str) -> bool:
+	temp_directory_path = get_temp_directory_path(temp_path, output_path)
 	return create_directory(temp_directory_path)


-def clear_temp_directory(file_path : str) -> bool:
-	if not state_manager.get_item('keep_temp'):
-		temp_directory_path = get_temp_directory_path(file_path)
-		return remove_directory(temp_directory_path)
-	return True
+def clear_temp_directory(temp_path : str, output_path : str) -> bool:
+	temp_directory_path = get_temp_directory_path(temp_path, output_path)
+	return remove_directory(temp_directory_path)
@@ -1,6 +1,8 @@
+import ctypes
 from collections import namedtuple
+from datetime import datetime
 from threading import Lock
-from typing import Any, Callable, Dict, List, Literal, NotRequired, Optional, Tuple, TypeAlias, TypedDict
+from typing import Any, Callable, Dict, List, Literal, NotRequired, Optional, Tuple, TypeAlias, TypedDict, Union

 import cv2
 import numpy
@@ -63,6 +65,8 @@ Language = Literal['en']
 Locales : TypeAlias = Dict[Language, Dict[str, Any]]
 LocalePoolSet : TypeAlias = Dict[str, Locales]

+WorkFlow = Literal['auto', 'audio-to-image:frames', 'audio-to-image:video', 'image-to-image', 'image-to-video', 'image-to-video:frames']
+
 VideoCaptureSet : TypeAlias = Dict[str, cv2.VideoCapture]
 VideoWriterSet : TypeAlias = Dict[str, cv2.VideoWriter]
 CameraCaptureSet : TypeAlias = Dict[str, cv2.VideoCapture]
@@ -85,7 +89,6 @@ Matrix : TypeAlias = NDArray[Any]
 Anchors : TypeAlias = NDArray[Any]
 Translation : TypeAlias = NDArray[Any]

-AudioBuffer : TypeAlias = bytes
 Audio : TypeAlias = NDArray[Any]
 AudioChunk : TypeAlias = NDArray[Any]
 AudioFrame : TypeAlias = NDArray[Any]
@@ -95,21 +98,75 @@ MelFilterBank : TypeAlias = NDArray[Any]
 Voice : TypeAlias = NDArray[Any]
 VoiceChunk : TypeAlias = NDArray[Any]

+BitRate : TypeAlias = int
+SampleRate : TypeAlias = int
 Fps : TypeAlias = float
 Duration : TypeAlias = float
+Time : TypeAlias = float
 Color : TypeAlias = Tuple[int, int, int, int]
 Padding : TypeAlias = Tuple[int, int, int, int]
 Margin : TypeAlias = Tuple[int, int, int, int]
 Orientation = Literal['landscape', 'portrait']
 Resolution : TypeAlias = Tuple[int, int]

-ProcessState = Literal['checking', 'processing', 'stopping', 'pending']
+AudioCodec : TypeAlias = Literal['opus']
+VideoCodec : TypeAlias = Literal['av1', 'vp8', 'vp9']
+
+AomVideoCodec : TypeAlias = Literal['av1']
+VxpVideoCodec : TypeAlias = Literal['vp8', 'vp9']
+
+AomEncoder : TypeAlias = ctypes.Array[ctypes.c_char]
+AomDecoder : TypeAlias = ctypes.Array[ctypes.c_char]
+OpusEncoder : TypeAlias = ctypes.c_void_p
+OpusDecoder : TypeAlias = ctypes.c_void_p
+VpxEncoder : TypeAlias = ctypes.Array[ctypes.c_char]
+VpxDecoder : TypeAlias = ctypes.Array[ctypes.c_char]
+
+Buffer : TypeAlias = bytes
+BufferPack = TypedDict('BufferPack',
+{
+	'buffer' : Buffer,
+	'resolution' : Resolution
+})
+
+FrameHandler : TypeAlias = Callable[[Buffer, int], None]
+
 Args : TypeAlias = Dict[str, Any]
+
+Choice : TypeAlias = Union[int | str]
+Scope : TypeAlias = Literal['api', 'cli', 'sys']
+Group : TypeAlias = str
+
+CapabilitySet = TypedDict('CapabilitySet',
+{
+	'default' : Any,
+	'choices' : NotRequired[List[Choice]],
+	'groups' : NotRequired[List[Group]]
+})
+CapabilityStore = TypedDict('CapabilityStore',
+{
+	'api' : Dict[str, CapabilitySet],
+	'cli' : Dict[str, CapabilitySet],
+	'sys' : Dict[str, CapabilitySet]
+})
+CapabilityGroup : TypeAlias = Dict[Group, Dict[str, CapabilitySet]]
+
+ProcessState = Literal['checking', 'processing', 'stopping', 'pending']
 UpdateProgress : TypeAlias = Callable[[int], None]
 ProcessStep : TypeAlias = Callable[[str, int, Args], bool]

 Content : TypeAlias = Dict[str, Any]

+Token : TypeAlias = str
+SessionId : TypeAlias = str
+Session = TypedDict('Session',
+{
+	'access_token' : Token,
+	'refresh_token' : Token,
+	'created_at' : datetime,
+	'expires_at' : datetime
+})
+
 Command : TypeAlias = str
 CommandSet : TypeAlias = Dict[str, List[Command]]

@@ -143,21 +200,90 @@ AudioFormat = Literal['flac', 'm4a', 'mp3', 'ogg', 'opus', 'wav']
 ImageFormat = Literal['bmp', 'jpeg', 'png', 'tiff', 'webp']
 VideoFormat = Literal['avi', 'm4v', 'mkv', 'mov', 'mp4', 'mpeg', 'mxf', 'webm', 'wmv']
 TempFrameFormat = Literal['bmp', 'jpeg', 'png', 'tiff']
-AudioTypeSet : TypeAlias = Dict[AudioFormat, str]
-ImageTypeSet : TypeAlias = Dict[ImageFormat, str]
-VideoTypeSet : TypeAlias = Dict[VideoFormat, str]

 FrameSet : TypeAlias = Dict[int, str]

 AudioEncoder = Literal['flac', 'aac', 'libmp3lame', 'libopus', 'libvorbis', 'pcm_s16le', 'pcm_s32le']
+ImageEncoder = Literal['bmp', 'mjpeg', 'png', 'tiff', 'libwebp']
 VideoEncoder = Literal['libx264', 'libx264rgb', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf', 'h264_qsv', 'hevc_qsv', 'h264_videotoolbox', 'hevc_videotoolbox', 'rawvideo']
+AudioSet : TypeAlias = Dict[AudioFormat, str]
+ImageSet : TypeAlias = Dict[ImageFormat, str]
+VideoSet : TypeAlias = Dict[VideoFormat, str]
 EncoderSet = TypedDict('EncoderSet',
 {
 	'audio' : List[AudioEncoder],
+	'image' : List[ImageEncoder],
 	'video' : List[VideoEncoder]
 })
 VideoPreset = Literal['ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow']

+AssetId : TypeAlias = str
+AssetType = Literal['source', 'target']
+MediaType = Literal['image', 'video', 'audio']
+AudioMetadata = TypedDict('AudioMetadata',
+{
+	'duration' : Duration,
+	'frame_total' : int,
+	'channel_total' : int,
+	'sample_rate' : SampleRate,
+	'bit_rate' : BitRate
+})
+ImageMetadata = TypedDict('ImageMetadata',
+{
+	'resolution' : Resolution
+})
+VideoMetadata = TypedDict('VideoMetadata',
+{
+	'duration' : Duration,
+	'frame_total' : int,
+	'fps' : Fps,
+	'resolution' : Resolution,
+	'bit_rate' : BitRate
+})
+AudioAsset = TypedDict('AudioAsset',
+{
+	'id' : AssetId,
+	'created_at' : datetime,
+	'expires_at' : datetime,
+	'type' : AssetType,
+	'media' : Literal['audio'],
+	'name' : str,
+	'format' : AudioFormat,
+	'size' : int,
+	'path' : str,
+	'metadata' : AudioMetadata
+})
+ImageAsset = TypedDict('ImageAsset',
+{
+	'id' : AssetId,
+	'created_at' : datetime,
+	'expires_at' : datetime,
+	'type' : AssetType,
+	'media' : Literal['image'],
+	'name' : str,
+	'format' : ImageFormat,
+	'size' : int,
+	'path' : str,
+	'metadata' : ImageMetadata
+})
+VideoAsset = TypedDict('VideoAsset',
+{
+	'id' : AssetId,
+	'created_at' : datetime,
+	'expires_at' : datetime,
+	'type' : AssetType,
+	'media' : Literal['video'],
+	'name' : str,
+	'format' : VideoFormat,
+	'size' : int,
+	'path' : str,
+	'metadata' : VideoMetadata
+})
+
+AssetMetadata : TypeAlias = AudioMetadata | ImageMetadata | VideoMetadata
+AssetSet : TypeAlias = Dict[AssetId, AudioAsset | ImageAsset | VideoAsset]
+AssetStore : TypeAlias = Dict[SessionId, AssetSet]
+
 BenchmarkMode = Literal['warm', 'cold']
 BenchmarkResolution = Literal['240p', '360p', '540p', '720p', '1080p', '1440p', '2160p']
 BenchmarkSet : TypeAlias = Dict[BenchmarkResolution, str]
@@ -174,10 +300,65 @@ BenchmarkCycleSet = TypedDict('BenchmarkCycleSet',
 WebcamMode = Literal['inline', 'udp', 'v4l2']
 StreamMode = Literal['udp', 'v4l2']

+PeerConnection : TypeAlias = int
+SdpOffer : TypeAlias = str
+SdpAnswer : TypeAlias = str
+MediaDirection : TypeAlias = Literal['sendonly', 'recvonly', 'sendrecv']
+
+RtcTrackInit : TypeAlias = Any
+
+RtcVideoTrack : TypeAlias = int
+RtcAudioTrack : TypeAlias = int
+
+RtcPeerAudio = TypedDict('RtcPeerAudio',
+{
+	'sender_track': RtcAudioTrack,
+	'receiver_track': RtcAudioTrack,
+	'codec': AudioCodec,
+})
+
+RtcPeerVideo = TypedDict('RtcPeerVideo',
+{
+	'sender_track': RtcVideoTrack,
+	'receiver_track': RtcVideoTrack,
+	'codec': VideoCodec,
+})
+
+RtcPeer = TypedDict('RtcPeer',
+{
+	'peer_connection': PeerConnection,
+	'audio': NotRequired[RtcPeerAudio],
+	'video': RtcPeerVideo,
+	'sender_bitrate': ctypes.c_uint,
+	'receiver_bitrate': ctypes.c_uint
+})
+RtcStore : TypeAlias = Dict[SessionId, List[RtcPeer]]
+
+SdpAudioMedia = TypedDict('SdpAudioMedia',
+{
+	'codec': AudioCodec,
+	'payload_type': int
+})
+
+SdpVideoMedia = TypedDict('SdpVideoMedia',
+{
+	'codec': VideoCodec,
+	'payload_type': int
+})
+
+SdpMedia = TypedDict('SdpMedia',
+{
+	'video': NotRequired[SdpVideoMedia],
+	'audio': NotRequired[SdpAudioMedia]
+})
+
 ModelOptions : TypeAlias = Dict[str, Any]
 ModelSet : TypeAlias = Dict[str, ModelOptions]
 ModelInitializer : TypeAlias = NDArray[Any]

+LibraryOptions : TypeAlias = Dict[str, Any]
+LibrarySet : TypeAlias = Dict[str, LibraryOptions]
+
 ExecutionProvider = Literal['cuda', 'tensorrt', 'rocm', 'migraphx', 'coreml', 'openvino', 'qnn', 'directml', 'cpu']
 ExecutionProviderValue = Literal['CPUExecutionProvider', 'CoreMLExecutionProvider', 'CUDAExecutionProvider', 'DmlExecutionProvider', 'OpenVINOExecutionProvider', 'MIGraphXExecutionProvider', 'QNNExecutionProvider', 'ROCMExecutionProvider', 'TensorrtExecutionProvider']
 ExecutionProviderSet : TypeAlias = Dict[ExecutionProvider, ExecutionProviderValue]
@@ -198,10 +379,10 @@ ExecutionDeviceProduct = TypedDict('ExecutionDeviceProduct',
 	'vendor' : str,
 	'name' : str
 })
-ExecutionDeviceVideoMemory = TypedDict('ExecutionDeviceVideoMemory',
+ExecutionDeviceMemory = TypedDict('ExecutionDeviceMemory',
 {
 	'total' : Optional[ValueAndUnit],
-	'free' : Optional[ValueAndUnit]
+	'used' : Optional[ValueAndUnit]
 })
 ExecutionDeviceTemperature = TypedDict('ExecutionDeviceTemperature',
 {
@@ -213,15 +394,46 @@ ExecutionDeviceUtilization = TypedDict('ExecutionDeviceUtilization',
 	'gpu' : Optional[ValueAndUnit],
 	'memory' : Optional[ValueAndUnit]
 })
-ExecutionDevice = TypedDict('ExecutionDevice',
+GraphicDevice = TypedDict('GraphicDevice',
 {
 	'driver_version' : str,
 	'framework' : ExecutionDeviceFramework,
 	'product' : ExecutionDeviceProduct,
-	'video_memory' : ExecutionDeviceVideoMemory,
+	'memory' : ExecutionDeviceMemory,
 	'temperature' : ExecutionDeviceTemperature,
 	'utilization' : ExecutionDeviceUtilization
 })
+DiskMetrics = TypedDict('DiskMetrics',
+{
+	'total' : ValueAndUnit,
+	'free' : ValueAndUnit,
+	'utilization' : ValueAndUnit
+})
+MemoryMetrics = TypedDict('MemoryMetrics',
+{
+	'total' : ValueAndUnit,
+	'free' : ValueAndUnit,
+	'utilization' : ValueAndUnit
+})
+NetworkMetrics = TypedDict('NetworkMetrics',
+{
+	'sent' : ValueAndUnit,
+	'received' : ValueAndUnit
+})
+ProcessorMetrics = TypedDict('ProcessorMetrics',
+{
+	'cores' : ValueAndUnit,
+	'frequency' : ValueAndUnit,
+	'utilization' : ValueAndUnit
+})
+Metrics = TypedDict('Metrics',
+{
+	'graphic_devices' : List[GraphicDevice],
+	'disks' : List[DiskMetrics],
+	'memory' : MemoryMetrics,
+	'network' : NetworkMetrics,
+	'processor' : ProcessorMetrics
+})

 DownloadProvider = Literal['github', 'huggingface']
 DownloadProviderValue = TypedDict('DownloadProviderValue',
@@ -239,18 +451,12 @@ Download = TypedDict('Download',
 DownloadSet : TypeAlias = Dict[str, Download]

 VideoMemoryStrategy = Literal['strict', 'moderate', 'tolerant']
-AppContext = Literal['cli', 'ui']
+ApiSecurityStrategy = Literal['strict', 'moderate']
+AppContext = Literal['cli', 'api']

 InferencePool : TypeAlias = Dict[str, InferenceSession]
 InferencePoolSet : TypeAlias = Dict[AppContext, Dict[str, InferencePool]]

-UiWorkflow = Literal['instant_runner', 'job_runner', 'job_manager']
-
-JobStore = TypedDict('JobStore',
-{
-	'job_keys' : List[str],
-	'step_keys' : List[str]
-})
 JobOutputSet : TypeAlias = Dict[str, List[str]]
 JobStatus = Literal['drafted', 'queued', 'completed', 'failed']
 JobStepStatus = Literal['drafted', 'queued', 'started', 'completed', 'failed']
@@ -268,9 +474,11 @@ Job = TypedDict('Job',
 })
 JobSet : TypeAlias = Dict[str, Job]

+StateValue : TypeAlias = Any
 StateKey = Literal\
 [
 	'command',
+	'workflow',
 	'config_path',
 	'temp_path',
 	'jobs_path',
@@ -320,21 +528,23 @@ StateKey = Literal\
 	'output_audio_encoder',
 	'output_audio_quality',
 	'output_audio_volume',
+	'output_audio_fps',
 	'output_video_encoder',
 	'output_video_preset',
 	'output_video_quality',
 	'output_video_scale',
 	'output_video_fps',
 	'processors',
-	'open_browser',
-	'ui_layouts',
-	'ui_workflow',
 	'execution_device_ids',
 	'execution_providers',
 	'execution_thread_count',
 	'video_memory_strategy',
 	'log_level',
 	'halt_on_error',
+	'api_host',
+	'api_port',
+	'api_key',
+	'api_security_strategy',
 	'job_id',
 	'job_status',
 	'step_index'
@@ -342,6 +552,7 @@ StateKey = Literal\
 State = TypedDict('State',
 {
 	'command' : str,
+	'workflow' : WorkFlow,
 	'config_path' : str,
 	'temp_path' : str,
 	'jobs_path' : str,
@@ -396,20 +607,22 @@ State = TypedDict('State',
 	'output_video_quality' : int,
 	'output_video_scale' : Scale,
 	'output_video_fps' : float,
+	'output_audio_fps' : float,
 	'processors' : List[str],
-	'open_browser' : bool,
-	'ui_layouts' : List[str],
-	'ui_workflow' : UiWorkflow,
 	'execution_device_ids' : List[int],
 	'execution_providers' : List[ExecutionProvider],
 	'execution_thread_count' : int,
 	'video_memory_strategy' : VideoMemoryStrategy,
 	'log_level' : LogLevel,
 	'halt_on_error' : bool,
+	'api_host' : str,
+	'api_port' : int,
+	'api_key' : str,
+	'api_security_strategy' : ApiSecurityStrategy,
 	'job_id' : str,
 	'job_status' : JobStatus,
 	'step_index' : int
 })
-ApplyStateItem : TypeAlias = Callable[[Any, Any], None]
 StateSet : TypeAlias = Dict[AppContext, State]

+ApplyStateItem : TypeAlias = Callable[[StateKey, StateValue], None]
@@ -1,167 +0,0 @@
-:root:root:root:root .gradio-container
-{
-	overflow: unset;
-}
-
-:root:root:root:root main
-{
-	max-width: 110em;
-}
-
-:root:root:root:root .tab-like-container input[type="number"]
-{
-	border-radius: unset;
-	text-align: center;
-	order: 1;
-	padding: unset
-}
-
-:root:root:root:root input[type="number"]
-{
-	appearance: textfield;
-}
-
-:root:root:root:root input[type="number"]::-webkit-inner-spin-button
-{
-	appearance: none;
-}
-
-:root:root:root:root input[type="number"]:focus
-{
-	outline: unset;
-}
-
-:root:root:root:root .reset-button
-{
-	background: var(--background-fill-secondary);
-	border: unset;
-	font-size: unset;
-	padding: unset;
-}
-
-:root:root:root:root [type="checkbox"],
-:root:root:root:root [type="radio"]
-{
-	border-radius: 50%;
-	height: 1.125rem;
-	width: 1.125rem;
-}
-
-:root:root:root:root input[type="range"]
-{
-	background: transparent;
-}
-
-:root:root:root:root input[type="range"]::-moz-range-thumb,
-:root:root:root:root input[type="range"]::-webkit-slider-thumb
-{
-	background: var(--neutral-300);
-	box-shadow: unset;
-	border-radius: 50%;
-	height: 1.125rem;
-	width: 1.125rem;
-}
-
-:root:root:root:root .gallery-container .thumbnail-item
-{
-	border: unset;
-}
-
-:root:root:root:root .gallery-container .grid-container
-{
-	grid-template-columns: repeat(7, 1fr);
-}
-
-:root:root:root:root .grid-wrap.fixed-height
-{
-	min-height: unset;
-}
-
-:root:root:root:root .box-face-selector .empty,
-:root:root:root:root .box-face-selector .gallery-container
-{
-	min-height: 7.375rem;
-}
-
-:root:root:root:root .tab-wrapper
-{
-	padding: 0 0.625rem;
-}
-
-:root:root:root:root .tab-container
-{
-	gap: 0.5em;
-}
-
-:root:root:root:root .tab-container button
-{
-	background: unset;
-	border-bottom: 0.125rem solid;
-}
-
-:root:root:root:root .tab-container button.selected
-{
-	color: var(--primary-500)
-}
-
-:root:root:root:root .toast-body
-{
-	background: white;
-	color: var(--primary-500);
-	border: unset;
-	border-radius: unset;
-}
-
-:root:root:root:root .dark .toast-body
-{
-	background: var(--neutral-900);
-	color: var(--primary-600);
-}
-
-:root:root:root:root .toast-icon,
-:root:root:root:root .toast-title,
-:root:root:root:root .toast-text,
-:root:root:root:root .toast-close
-{
-	color: unset;
-}
-
-:root:root:root:root .toast-body .timer
-{
-	background: currentColor;
-}
-
-:root:root:root:root .slider_input_container > span,
-:root:root:root:root .feather-upload,
-:root:root:root:root footer
-{
-	display: none;
-}
-
-:root:root:root:root .image-frame
-{
-	background-image: conic-gradient(#fff 90deg, #999 90deg 180deg, #fff 180deg 270deg, #999 270deg);
-	background-size: 1.25rem 1.25rem;
-	background-repeat: repeat;
-	width: 100%;
-}
-
-:root:root:root:root .image-frame > img
-{
-	object-fit: cover;
-}
-
-:root:root:root:root .image-preview.is-landscape
-{
-	position: sticky;
-	top: 0;
-	z-index: 100;
-}
-
-:root:root:root:root .block .error
-{
-	border: 0.125rem solid;
-	padding: 0.375rem 0.75rem;
-	font-size: 0.75rem;
-	text-transform: uppercase;
-}
@@ -1,25 +0,0 @@
-from typing import Dict, List
-
-from facefusion.types import Color, WebcamMode
-from facefusion.uis.types import JobManagerAction, JobRunnerAction, PreviewMode
-
-job_manager_actions : List[JobManagerAction] = [ 'job-create', 'job-submit', 'job-delete', 'job-add-step', 'job-remix-step', 'job-insert-step', 'job-remove-step' ]
-job_runner_actions : List[JobRunnerAction] = [ 'job-run', 'job-run-all', 'job-retry', 'job-retry-all' ]
-
-common_options : List[str] = [ 'keep-temp' ]
-
-preview_modes : List[PreviewMode] = [ 'default', 'frame-by-frame', 'face-by-face' ]
-preview_resolutions : List[str] = [ '512x512', '768x768', '1024x1024' ]
-
-webcam_modes : List[WebcamMode] = [ 'inline', 'udp', 'v4l2' ]
-webcam_resolutions : List[str] = [ '320x240', '640x480', '800x600', '1024x768', '1280x720', '1280x960', '1920x1080' ]
-
-background_remover_fill_colors : Dict[str, Color] =\
-{
-	'red' : (255, 0, 0, 255),
-	'green' : (0, 255, 0, 255),
-	'blue' : (0, 0, 255, 255),
-	'black' : (0, 0, 0, 255),
-	'white' : (255, 255, 255, 255),
-	'alpha' : (0, 0, 0, 0)
-}
@@ -1,41 +0,0 @@
-import random
-from typing import Optional
-
-import gradio
-
-from facefusion import metadata, translator
-
-METADATA_BUTTON : Optional[gradio.Button] = None
-ACTION_BUTTON : Optional[gradio.Button] = None
-
-
-def render() -> None:
-	global METADATA_BUTTON
-	global ACTION_BUTTON
-
-	action = random.choice(
-	[
-		{
-			'translator': translator.get('about.fund'),
-			'url': 'https://fund.facefusion.io'
-		},
-		{
-			'translator': translator.get('about.subscribe'),
-			'url': 'https://subscribe.facefusion.io'
-		},
-		{
-			'translator': translator.get('about.join'),
-			'url': 'https://join.facefusion.io'
-		}
-	])
-
-	METADATA_BUTTON = gradio.Button(
-		value = metadata.get('name') + ' ' + metadata.get('version'),
-		variant = 'primary',
-		link = metadata.get('url')
-	)
-	ACTION_BUTTON = gradio.Button(
-		value = action.get('translator'),
-		link = action.get('url'),
-		size = 'sm'
-	)
@@ -1,64 +0,0 @@
-from typing import List, Optional, Tuple
-
-import gradio
-
-from facefusion import state_manager, translator
-from facefusion.common_helper import calculate_float_step
-from facefusion.processors.core import load_processor_module
-from facefusion.processors.modules.age_modifier import choices as age_modifier_choices
-from facefusion.processors.modules.age_modifier.types import AgeModifierModel
-from facefusion.uis.core import get_ui_component, register_ui_component
-
-AGE_MODIFIER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
-AGE_MODIFIER_DIRECTION_SLIDER : Optional[gradio.Slider] = None
-
-
-def render() -> None:
-	global AGE_MODIFIER_MODEL_DROPDOWN
-	global AGE_MODIFIER_DIRECTION_SLIDER
-
-	has_age_modifier = 'age_modifier' in state_manager.get_item('processors')
-	AGE_MODIFIER_MODEL_DROPDOWN = gradio.Dropdown(
-		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.age_modifier'),
-		choices = age_modifier_choices.age_modifier_models,
-		value = state_manager.get_item('age_modifier_model'),
-		visible = has_age_modifier
-	)
-	AGE_MODIFIER_DIRECTION_SLIDER = gradio.Slider(
-		label = translator.get('uis.direction_slider', 'facefusion.processors.modules.age_modifier'),
-		value = state_manager.get_item('age_modifier_direction'),
-		step = calculate_float_step(age_modifier_choices.age_modifier_direction_range),
-		minimum = age_modifier_choices.age_modifier_direction_range[0],
-		maximum = age_modifier_choices.age_modifier_direction_range[-1],
-		visible = has_age_modifier
-	)
-	register_ui_component('age_modifier_model_dropdown', AGE_MODIFIER_MODEL_DROPDOWN)
-	register_ui_component('age_modifier_direction_slider', AGE_MODIFIER_DIRECTION_SLIDER)
-
-
-def listen() -> None:
-	AGE_MODIFIER_MODEL_DROPDOWN.change(update_age_modifier_model, inputs = AGE_MODIFIER_MODEL_DROPDOWN, outputs = AGE_MODIFIER_MODEL_DROPDOWN)
-	AGE_MODIFIER_DIRECTION_SLIDER.release(update_age_modifier_direction, inputs = AGE_MODIFIER_DIRECTION_SLIDER)
-
-	processors_checkbox_group = get_ui_component('processors_checkbox_group')
-	if processors_checkbox_group:
-		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ AGE_MODIFIER_MODEL_DROPDOWN, AGE_MODIFIER_DIRECTION_SLIDER ])
-
-
-def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider]:
-	has_age_modifier = 'age_modifier' in processors
-	return gradio.Dropdown(visible = has_age_modifier), gradio.Slider(visible = has_age_modifier)
-
-
-def update_age_modifier_model(age_modifier_model : AgeModifierModel) -> gradio.Dropdown:
-	age_modifier_module = load_processor_module('age_modifier')
-	age_modifier_module.clear_inference_pool()
-	state_manager.set_item('age_modifier_model', age_modifier_model)
-
-	if age_modifier_module.pre_check():
-		return gradio.Dropdown(value = state_manager.get_item('age_modifier_model'))
-	return gradio.Dropdown()
-
-
-def update_age_modifier_direction(age_modifier_direction : float) -> None:
-	state_manager.set_item('age_modifier_direction', int(age_modifier_direction))
@@ -1,165 +0,0 @@
-from typing import List, Optional, Tuple
-
-import gradio
-
-from facefusion import state_manager, translator
-from facefusion.common_helper import calculate_int_step
-from facefusion.processors.core import load_processor_module
-from facefusion.processors.modules.background_remover import choices as background_remover_choices
-from facefusion.processors.modules.background_remover.types import BackgroundRemoverModel
-from facefusion.sanitizer import sanitize_int_range
-from facefusion.uis.core import get_ui_component, register_ui_component
-
-BACKGROUND_REMOVER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
-BACKGROUND_REMOVER_FILL_COLOR_WRAPPER : Optional[gradio.Group] = None
-BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER : Optional[gradio.Group] = None
-BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER : Optional[gradio.Number] = None
-BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER : Optional[gradio.Number] = None
-
-
-def render() -> None:
-	global BACKGROUND_REMOVER_MODEL_DROPDOWN
-	global BACKGROUND_REMOVER_FILL_COLOR_WRAPPER
-	global BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER
-	global BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER
-	global BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER
-	global BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER
-	global BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER
-	global BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER
-	global BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER
-	global BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER
-	global BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER
-
-	has_background_remover = 'background_remover' in state_manager.get_item('processors')
-	background_remover_fill_color = state_manager.get_item('background_remover_fill_color')
-	background_remover_despill_color = state_manager.get_item('background_remover_despill_color')
-	BACKGROUND_REMOVER_MODEL_DROPDOWN = gradio.Dropdown(
-		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.background_remover'),
-		choices = background_remover_choices.background_remover_models,
-		value = state_manager.get_item('background_remover_model'),
-		visible = has_background_remover
-	)
-	with gradio.Group(visible = has_background_remover) as BACKGROUND_REMOVER_FILL_COLOR_WRAPPER:
-		with gradio.Row():
-			BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER = gradio.Number(
-				label = translator.get('uis.fill_color_red_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_fill_color[0],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-			BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER = gradio.Number(
-				label = translator.get('uis.fill_color_green_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_fill_color[1],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-		with gradio.Row():
-			BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER = gradio.Number(
-				label = translator.get('uis.fill_color_blue_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_fill_color[2],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-			BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER = gradio.Number(
-				label = translator.get('uis.fill_color_alpha_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_fill_color[3],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-	with gradio.Group(visible = has_background_remover) as BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER:
-		with gradio.Row():
-			BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER = gradio.Number(
-				label = translator.get('uis.despill_color_red_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_despill_color[0],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-			BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER = gradio.Number(
-				label = translator.get('uis.despill_color_green_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_despill_color[1],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-		with gradio.Row():
-			BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER = gradio.Number(
-				label = translator.get('uis.despill_color_blue_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_despill_color[2],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-			BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER = gradio.Number(
-				label = translator.get('uis.despill_color_alpha_number', 'facefusion.processors.modules.background_remover'),
-				value = background_remover_despill_color[3],
-				minimum = background_remover_choices.background_remover_color_range[0],
-				maximum = background_remover_choices.background_remover_color_range[-1],
-				step = calculate_int_step(background_remover_choices.background_remover_color_range)
-			)
-	register_ui_component('background_remover_model_dropdown', BACKGROUND_REMOVER_MODEL_DROPDOWN)
-	register_ui_component('background_remover_fill_color_red_number', BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER)
-	register_ui_component('background_remover_fill_color_green_number', BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER)
-	register_ui_component('background_remover_fill_color_blue_number', BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER)
-	register_ui_component('background_remover_fill_color_alpha_number', BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER)
-	register_ui_component('background_remover_despill_color_red_number', BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER)
-	register_ui_component('background_remover_despill_color_green_number', BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER)
-	register_ui_component('background_remover_despill_color_blue_number', BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER)
-	register_ui_component('background_remover_despill_color_alpha_number', BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER)
-
-
-def listen() -> None:
-	BACKGROUND_REMOVER_MODEL_DROPDOWN.change(update_background_remover_model, inputs = BACKGROUND_REMOVER_MODEL_DROPDOWN, outputs = BACKGROUND_REMOVER_MODEL_DROPDOWN)
-	background_remover_fill_color_inputs = [ BACKGROUND_REMOVER_FILL_COLOR_RED_NUMBER, BACKGROUND_REMOVER_FILL_COLOR_GREEN_NUMBER, BACKGROUND_REMOVER_FILL_COLOR_BLUE_NUMBER, BACKGROUND_REMOVER_FILL_COLOR_ALPHA_NUMBER ]
-	background_remover_despill_color_inputs = [ BACKGROUND_REMOVER_DESPILL_COLOR_RED_NUMBER, BACKGROUND_REMOVER_DESPILL_COLOR_GREEN_NUMBER, BACKGROUND_REMOVER_DESPILL_COLOR_BLUE_NUMBER, BACKGROUND_REMOVER_DESPILL_COLOR_ALPHA_NUMBER ]
-
-	for background_remover_fill_color_input in background_remover_fill_color_inputs:
-		background_remover_fill_color_input.change(update_background_remover_fill_color, inputs = background_remover_fill_color_inputs)
-
-	for background_remover_despill_color_input in background_remover_despill_color_inputs:
-		background_remover_despill_color_input.change(update_background_remover_despill_color, inputs = background_remover_despill_color_inputs)
-
-	processors_checkbox_group = get_ui_component('processors_checkbox_group')
-	if processors_checkbox_group:
-		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ BACKGROUND_REMOVER_MODEL_DROPDOWN, BACKGROUND_REMOVER_FILL_COLOR_WRAPPER, BACKGROUND_REMOVER_DESPILL_COLOR_WRAPPER ])
-
-
-def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Group, gradio.Group]:
-	has_background_remover = 'background_remover' in processors
-	return gradio.Dropdown(visible = has_background_remover), gradio.Group(visible = has_background_remover), gradio.Group(visible = has_background_remover)
-
-
-def update_background_remover_model(background_remover_model : BackgroundRemoverModel) -> gradio.Dropdown:
-	background_remover_module = load_processor_module('background_remover')
-	background_remover_module.clear_inference_pool()
-	state_manager.set_item('background_remover_model', background_remover_model)
-
-	if background_remover_module.pre_check():
-		return gradio.Dropdown(value = state_manager.get_item('background_remover_model'))
-	return gradio.Dropdown()
-
-
-def update_background_remover_fill_color(red : int, green : int, blue : int, alpha : int) -> None:
-	red = sanitize_int_range(red, background_remover_choices.background_remover_color_range)
-	green = sanitize_int_range(green, background_remover_choices.background_remover_color_range)
-	blue = sanitize_int_range(blue, background_remover_choices.background_remover_color_range)
-	alpha = sanitize_int_range(alpha, background_remover_choices.background_remover_color_range)
-	state_manager.set_item('background_remover_fill_color', (red, green, blue, alpha))
-
-
-def update_background_remover_despill_color(red : int, green : int, blue : int, alpha : int) -> None:
-	red = sanitize_int_range(red, background_remover_choices.background_remover_color_range)
-	green = sanitize_int_range(green, background_remover_choices.background_remover_color_range)
-	blue = sanitize_int_range(blue, background_remover_choices.background_remover_color_range)
-	alpha = sanitize_int_range(alpha, background_remover_choices.background_remover_color_range)
-	state_manager.set_item('background_remover_despill_color', (red, green, blue, alpha))
@@ -1,51 +0,0 @@
-from typing import Any, Iterator, List, Optional
-
-import gradio
-
-from facefusion import benchmarker, state_manager, translator
-
-BENCHMARK_BENCHMARKS_DATAFRAME : Optional[gradio.Dataframe] = None
-BENCHMARK_START_BUTTON : Optional[gradio.Button] = None
-
-
-def render() -> None:
-	global BENCHMARK_BENCHMARKS_DATAFRAME
-	global BENCHMARK_START_BUTTON
-
-	BENCHMARK_BENCHMARKS_DATAFRAME = gradio.Dataframe(
-		headers =
-		[
-			'target_path',
-			'cycle_count',
-			'average_run',
-			'fastest_run',
-			'slowest_run',
-			'relative_fps'
-		],
-		datatype =
-		[
-			'str',
-			'number',
-			'number',
-			'number',
-			'number',
-			'number'
-		],
-		show_label = False
-	)
-	BENCHMARK_START_BUTTON = gradio.Button(
-		value = translator.get('uis.start_button'),
-		variant = 'primary',
-		size = 'sm'
-	)
-
-
-def listen() -> None:
-	BENCHMARK_START_BUTTON.click(start, outputs = BENCHMARK_BENCHMARKS_DATAFRAME)
-
-
-def start() -> Iterator[List[Any]]:
-	state_manager.sync_state()
-
-	for benchmark in benchmarker.run():
-		yield [ list(benchmark_set.values()) for benchmark_set in benchmark ]
@@ -1,54 +0,0 @@
-from typing import List, Optional
-
-import gradio
-
-import facefusion.choices
-from facefusion import state_manager, translator
-from facefusion.common_helper import calculate_int_step
-from facefusion.types import BenchmarkMode, BenchmarkResolution
-
-BENCHMARK_MODE_DROPDOWN : Optional[gradio.Dropdown] = None
-BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
-BENCHMARK_CYCLE_COUNT_SLIDER : Optional[gradio.Button] = None
-
-
-def render() -> None:
-	global BENCHMARK_MODE_DROPDOWN
-	global BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP
-	global BENCHMARK_CYCLE_COUNT_SLIDER
-
-	BENCHMARK_MODE_DROPDOWN = gradio.Dropdown(
-		label = translator.get('uis.benchmark_mode_dropdown'),
-		choices = facefusion.choices.benchmark_modes,
-		value = state_manager.get_item('benchmark_mode')
-	)
-	BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP = gradio.CheckboxGroup(
-		label = translator.get('uis.benchmark_resolutions_checkbox_group'),
-		choices = facefusion.choices.benchmark_resolutions,
-		value = state_manager.get_item('benchmark_resolutions')
-	)
-	BENCHMARK_CYCLE_COUNT_SLIDER = gradio.Slider(
-		label = translator.get('uis.benchmark_cycle_count_slider'),
-		value = state_manager.get_item('benchmark_cycle_count'),
-		step = calculate_int_step(facefusion.choices.benchmark_cycle_count_range),
-		minimum = facefusion.choices.benchmark_cycle_count_range[0],
-		maximum = facefusion.choices.benchmark_cycle_count_range[-1]
-	)
-
-
-def listen() -> None:
-	BENCHMARK_MODE_DROPDOWN.change(update_benchmark_mode, inputs = BENCHMARK_MODE_DROPDOWN)
-	BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP.change(update_benchmark_resolutions, inputs = BENCHMARK_RESOLUTIONS_CHECKBOX_GROUP)
-	BENCHMARK_CYCLE_COUNT_SLIDER.release(update_benchmark_cycle_count, inputs = BENCHMARK_CYCLE_COUNT_SLIDER)
-
-
-def update_benchmark_mode(benchmark_mode : BenchmarkMode) -> None:
-	state_manager.set_item('benchmark_mode', benchmark_mode)
-
-
-def update_benchmark_resolutions(benchmark_resolutions : List[BenchmarkResolution]) -> None:
-	state_manager.set_item('benchmark_resolutions', benchmark_resolutions)
-
-
-def update_benchmark_cycle_count(benchmark_cycle_count : int) -> None:
-	state_manager.set_item('benchmark_cycle_count', benchmark_cycle_count)
@@ -1,32 +0,0 @@
-from typing import List, Optional
-
-import gradio
-
-from facefusion import state_manager, translator
-from facefusion.uis import choices as uis_choices
-
-COMMON_OPTIONS_CHECKBOX_GROUP : Optional[gradio.Checkboxgroup] = None
-
-
-def render() -> None:
-	global COMMON_OPTIONS_CHECKBOX_GROUP
-
-	common_options = []
-
-	if state_manager.get_item('keep_temp'):
-		common_options.append('keep-temp')
-
-	COMMON_OPTIONS_CHECKBOX_GROUP = gradio.Checkboxgroup(
-		label = translator.get('uis.common_options_checkbox_group'),
-		choices = uis_choices.common_options,
-		value = common_options
-	)
-
-
-def listen() -> None:
-	COMMON_OPTIONS_CHECKBOX_GROUP.change(update, inputs = COMMON_OPTIONS_CHECKBOX_GROUP)
-
-
-def update(common_options : List[str]) -> None:
-	keep_temp = 'keep-temp' in common_options
-	state_manager.set_item('keep_temp', keep_temp)
@@ -1,64 +0,0 @@
-from typing import List, Optional, Tuple
-
-import gradio
-
-from facefusion import state_manager, translator
-from facefusion.common_helper import calculate_int_step
-from facefusion.processors.core import load_processor_module
-from facefusion.processors.modules.deep_swapper import choices as deep_swapper_choices
-from facefusion.processors.modules.deep_swapper.types import DeepSwapperModel
-from facefusion.uis.core import get_ui_component, register_ui_component
-
-DEEP_SWAPPER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
-DEEP_SWAPPER_MORPH_SLIDER : Optional[gradio.Slider] = None
-
-
-def render() -> None:
-	global DEEP_SWAPPER_MODEL_DROPDOWN
-	global DEEP_SWAPPER_MORPH_SLIDER
-
-	has_deep_swapper = 'deep_swapper' in state_manager.get_item('processors')
-	DEEP_SWAPPER_MODEL_DROPDOWN = gradio.Dropdown(
-		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.deep_swapper'),
-		choices = deep_swapper_choices.deep_swapper_models,
-		value = state_manager.get_item('deep_swapper_model'),
-		visible = has_deep_swapper
-	)
-	DEEP_SWAPPER_MORPH_SLIDER = gradio.Slider(
-		label = translator.get('uis.morph_slider', 'facefusion.processors.modules.deep_swapper'),
-		value = state_manager.get_item('deep_swapper_morph'),
-		step = calculate_int_step(deep_swapper_choices.deep_swapper_morph_range),
-		minimum = deep_swapper_choices.deep_swapper_morph_range[0],
-		maximum = deep_swapper_choices.deep_swapper_morph_range[-1],
-		visible = has_deep_swapper and load_processor_module('deep_swapper').get_inference_pool() and load_processor_module('deep_swapper').has_morph_input()
-	)
-	register_ui_component('deep_swapper_model_dropdown', DEEP_SWAPPER_MODEL_DROPDOWN)
-	register_ui_component('deep_swapper_morph_slider', DEEP_SWAPPER_MORPH_SLIDER)
-
-
-def listen() -> None:
-	DEEP_SWAPPER_MODEL_DROPDOWN.change(update_deep_swapper_model, inputs = DEEP_SWAPPER_MODEL_DROPDOWN, outputs = [ DEEP_SWAPPER_MODEL_DROPDOWN, DEEP_SWAPPER_MORPH_SLIDER ])
-	DEEP_SWAPPER_MORPH_SLIDER.release(update_deep_swapper_morph, inputs = DEEP_SWAPPER_MORPH_SLIDER)
-
-	processors_checkbox_group = get_ui_component('processors_checkbox_group')
-	if processors_checkbox_group:
-		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ DEEP_SWAPPER_MODEL_DROPDOWN, DEEP_SWAPPER_MORPH_SLIDER ])
-
-
-def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider]:
-	has_deep_swapper = 'deep_swapper' in processors
-	return gradio.Dropdown(visible = has_deep_swapper), gradio.Slider(visible = has_deep_swapper and load_processor_module('deep_swapper').get_inference_pool() and load_processor_module('deep_swapper').has_morph_input())
-
-
-def update_deep_swapper_model(deep_swapper_model : DeepSwapperModel) -> Tuple[gradio.Dropdown, gradio.Slider]:
-	deep_swapper_module = load_processor_module('deep_swapper')
-	deep_swapper_module.clear_inference_pool()
-	state_manager.set_item('deep_swapper_model', deep_swapper_model)
-
-	if deep_swapper_module.pre_check():
-		return gradio.Dropdown(value = state_manager.get_item('deep_swapper_model')), gradio.Slider(visible = deep_swapper_module.has_morph_input())
-	return gradio.Dropdown(), gradio.Slider()
-
-
-def update_deep_swapper_morph(deep_swapper_morph : int) -> None:
-	state_manager.set_item('deep_swapper_morph', deep_swapper_morph)
@@ -1,48 +0,0 @@
-from typing import List, Optional
-
-import gradio
-
-import facefusion.choices
-from facefusion import content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, state_manager, translator, voice_extractor
-from facefusion.filesystem import get_file_name, resolve_file_paths
-from facefusion.processors.core import get_processors_modules
-from facefusion.types import DownloadProvider
-
-DOWNLOAD_PROVIDERS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
-
-
-def render() -> None:
-	global DOWNLOAD_PROVIDERS_CHECKBOX_GROUP
-
-	DOWNLOAD_PROVIDERS_CHECKBOX_GROUP = gradio.CheckboxGroup(
-		label = translator.get('uis.download_providers_checkbox_group'),
-		choices = facefusion.choices.download_providers,
-		value = state_manager.get_item('download_providers')
-	)
-
-
-def listen() -> None:
-	DOWNLOAD_PROVIDERS_CHECKBOX_GROUP.change(update_download_providers, inputs = DOWNLOAD_PROVIDERS_CHECKBOX_GROUP, outputs = DOWNLOAD_PROVIDERS_CHECKBOX_GROUP)
-
-
-def update_download_providers(download_providers : List[DownloadProvider]) -> gradio.CheckboxGroup:
-	common_modules =\
-	[
-		content_analyser,
-		face_classifier,
-		face_detector,
-		face_landmarker,
-		face_recognizer,
-		face_masker,
-		voice_extractor
-	]
-	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
-	processor_modules = get_processors_modules(available_processors)
-
-	for module in common_modules + processor_modules:
-		if hasattr(module, 'create_static_model_set'):
-			module.create_static_model_set.cache_clear()
-
-	download_providers = download_providers or facefusion.choices.download_providers
-	state_manager.set_item('download_providers', download_providers)
-	return gradio.CheckboxGroup(value = state_manager.get_item('download_providers'))
@@ -1,48 +0,0 @@
-from typing import List, Optional
-
-import gradio
-
-from facefusion import content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, state_manager, translator, voice_extractor
-from facefusion.execution import get_available_execution_providers
-from facefusion.filesystem import get_file_name, resolve_file_paths
-from facefusion.processors.core import get_processors_modules
-from facefusion.types import ExecutionProvider
-
-EXECUTION_PROVIDERS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
-
-
-def render() -> None:
-	global EXECUTION_PROVIDERS_CHECKBOX_GROUP
-
-	EXECUTION_PROVIDERS_CHECKBOX_GROUP = gradio.CheckboxGroup(
-		label = translator.get('uis.execution_providers_checkbox_group'),
-		choices = get_available_execution_providers(),
-		value = state_manager.get_item('execution_providers')
-	)
-
-
-def listen() -> None:
-	EXECUTION_PROVIDERS_CHECKBOX_GROUP.change(update_execution_providers, inputs = EXECUTION_PROVIDERS_CHECKBOX_GROUP, outputs = EXECUTION_PROVIDERS_CHECKBOX_GROUP)
-
-
-def update_execution_providers(execution_providers : List[ExecutionProvider]) -> gradio.CheckboxGroup:
-	common_modules =\
-	[
-		content_analyser,
-		face_classifier,
-		face_detector,
-		face_landmarker,
-		face_masker,
-		face_recognizer,
-		voice_extractor
-	]
-	available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
-	processor_modules = get_processors_modules(available_processors)
-
-	for module in common_modules + processor_modules:
-		if hasattr(module, 'clear_inference_pool'):
-			module.clear_inference_pool()
-
-	execution_providers = execution_providers or get_available_execution_providers()
-	state_manager.set_item('execution_providers', execution_providers)
-	return gradio.CheckboxGroup(value = state_manager.get_item('execution_providers'))
@@ -1,29 +0,0 @@
-from typing import Optional
-
-import gradio
-
-import facefusion.choices
-from facefusion import state_manager, translator
-from facefusion.common_helper import calculate_int_step
-
-EXECUTION_THREAD_COUNT_SLIDER : Optional[gradio.Slider] = None
-
-
-def render() -> None:
-	global EXECUTION_THREAD_COUNT_SLIDER
-
-	EXECUTION_THREAD_COUNT_SLIDER = gradio.Slider(
-		label = translator.get('uis.execution_thread_count_slider'),
-		value = state_manager.get_item('execution_thread_count'),
-		step = calculate_int_step(facefusion.choices.execution_thread_count_range),
-		minimum = facefusion.choices.execution_thread_count_range[0],
-		maximum = facefusion.choices.execution_thread_count_range[-1]
-	)
-
-
-def listen() -> None:
-	EXECUTION_THREAD_COUNT_SLIDER.release(update_execution_thread_count, inputs = EXECUTION_THREAD_COUNT_SLIDER)
-
-
-def update_execution_thread_count(execution_thread_count : float) -> None:
-	state_manager.set_item('execution_thread_count', int(execution_thread_count))
@@ -1,80 +0,0 @@
-from typing import List, Optional, Tuple
-
-import gradio
-
-from facefusion import state_manager, translator
-from facefusion.common_helper import calculate_float_step
-from facefusion.processors.core import load_processor_module
-from facefusion.processors.modules.expression_restorer import choices as expression_restorer_choices
-from facefusion.processors.modules.expression_restorer.types import ExpressionRestorerArea, ExpressionRestorerModel
-from facefusion.uis.core import get_ui_component, register_ui_component
-
-EXPRESSION_RESTORER_MODEL_DROPDOWN : Optional[gradio.Dropdown] = None
-EXPRESSION_RESTORER_FACTOR_SLIDER : Optional[gradio.Slider] = None
-EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
-
-
-def render() -> None:
-	global EXPRESSION_RESTORER_MODEL_DROPDOWN
-	global EXPRESSION_RESTORER_FACTOR_SLIDER
-	global EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP
-
-	has_expression_restorer = 'expression_restorer' in state_manager.get_item('processors')
-	EXPRESSION_RESTORER_MODEL_DROPDOWN = gradio.Dropdown(
-		label = translator.get('uis.model_dropdown', 'facefusion.processors.modules.expression_restorer'),
-		choices = expression_restorer_choices.expression_restorer_models,
-		value = state_manager.get_item('expression_restorer_model'),
-		visible = has_expression_restorer
-	)
-	EXPRESSION_RESTORER_FACTOR_SLIDER = gradio.Slider(
-		label = translator.get('uis.factor_slider', 'facefusion.processors.modules.expression_restorer'),
-		value = state_manager.get_item('expression_restorer_factor'),
-		step = calculate_float_step(expression_restorer_choices.expression_restorer_factor_range),
-		minimum = expression_restorer_choices.expression_restorer_factor_range[0],
-		maximum = expression_restorer_choices.expression_restorer_factor_range[-1],
-		visible = has_expression_restorer
-	)
-	EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP = gradio.CheckboxGroup(
-		label = translator.get('uis.areas_checkbox_group', 'facefusion.processors.modules.expression_restorer'),
-		choices = expression_restorer_choices.expression_restorer_areas,
-		value = state_manager.get_item('expression_restorer_areas'),
-		visible = has_expression_restorer
-	)
-	register_ui_component('expression_restorer_model_dropdown', EXPRESSION_RESTORER_MODEL_DROPDOWN)
-	register_ui_component('expression_restorer_factor_slider', EXPRESSION_RESTORER_FACTOR_SLIDER)
-	register_ui_component('expression_restorer_areas_checkbox_group', EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP)
-
-
-def listen() -> None:
-	EXPRESSION_RESTORER_MODEL_DROPDOWN.change(update_expression_restorer_model, inputs = EXPRESSION_RESTORER_MODEL_DROPDOWN, outputs = EXPRESSION_RESTORER_MODEL_DROPDOWN)
-	EXPRESSION_RESTORER_FACTOR_SLIDER.release(update_expression_restorer_factor, inputs = EXPRESSION_RESTORER_FACTOR_SLIDER)
-	EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP.change(update_expression_restorer_areas, inputs = EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP, outputs = EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP)
-
-	processors_checkbox_group = get_ui_component('processors_checkbox_group')
-	if processors_checkbox_group:
-		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = [ EXPRESSION_RESTORER_MODEL_DROPDOWN, EXPRESSION_RESTORER_FACTOR_SLIDER, EXPRESSION_RESTORER_AREAS_CHECKBOX_GROUP ])
-
-
-def remote_update(processors : List[str]) -> Tuple[gradio.Dropdown, gradio.Slider, gradio.CheckboxGroup]:
-	has_expression_restorer = 'expression_restorer' in processors
-	return gradio.Dropdown(visible = has_expression_restorer), gradio.Slider(visible = has_expression_restorer), gradio.CheckboxGroup(visible = has_expression_restorer)
-
-
-def update_expression_restorer_model(expression_restorer_model : ExpressionRestorerModel) -> gradio.Dropdown:
-	expression_restorer_module = load_processor_module('expression_restorer')
-	expression_restorer_module.clear_inference_pool()
-	state_manager.set_item('expression_restorer_model', expression_restorer_model)
-
-	if expression_restorer_module.pre_check():
-		return gradio.Dropdown(value = state_manager.get_item('expression_restorer_model'))
-	return gradio.Dropdown()
-
-
-def update_expression_restorer_factor(expression_restorer_factor : float) -> None:
-	state_manager.set_item('expression_restorer_factor', int(expression_restorer_factor))
-
-
-def update_expression_restorer_areas(expression_restorer_areas : List[ExpressionRestorerArea]) -> gradio.CheckboxGroup:
-	expression_restorer_areas = expression_restorer_areas or expression_restorer_choices.expression_restorer_areas
-	state_manager.set_item('expression_restorer_areas', expression_restorer_areas)
-	return gradio.CheckboxGroup(value = state_manager.get_item('expression_restorer_areas'))
@@ -1,40 +0,0 @@
-from typing import List, Optional
-
-import gradio
-
-from facefusion import state_manager, translator
-from facefusion.processors.modules.face_debugger import choices as face_debugger_choices
-from facefusion.processors.modules.face_debugger.types import FaceDebuggerItem
-from facefusion.uis.core import get_ui_component, register_ui_component
-
-FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP : Optional[gradio.CheckboxGroup] = None
-
-
-def render() -> None:
-	global FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP
-
-	has_face_debugger = 'face_debugger' in state_manager.get_item('processors')
-	FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP = gradio.CheckboxGroup(
-		label = translator.get('uis.items_checkbox_group', 'facefusion.processors.modules.face_debugger'),
-		choices = face_debugger_choices.face_debugger_items,
-		value = state_manager.get_item('face_debugger_items'),
-		visible = has_face_debugger
-	)
-	register_ui_component('face_debugger_items_checkbox_group', FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP)
-
-
-def listen() -> None:
-	FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP.change(update_face_debugger_items, inputs = FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP)
-
-	processors_checkbox_group = get_ui_component('processors_checkbox_group')
-	if processors_checkbox_group:
-		processors_checkbox_group.change(remote_update, inputs = processors_checkbox_group, outputs = FACE_DEBUGGER_ITEMS_CHECKBOX_GROUP)
-
-
-def remote_update(processors : List[str]) -> gradio.CheckboxGroup:
-	has_face_debugger = 'face_debugger' in processors
-	return gradio.CheckboxGroup(visible = has_face_debugger)
-
-
-def update_face_debugger_items(face_debugger_items : List[FaceDebuggerItem]) -> None:
-	state_manager.set_item('face_debugger_items', face_debugger_items)
--- a/Show More
+++ b/Show More