Upload 5 files

Extras/ffff_assets/core.py

@@ -0,0 +1,189 @@
+import importlib
+import os
+import warnings
+from types import ModuleType
+from typing import Any, Dict, List, Optional
+
+import gradio
+from gradio.themes import Size
+
+from ffff import logger, metadata, state_manager, wording
+from ffff.exit_helper import hard_exit
+from ffff.filesystem import resolve_relative_path
+from ffff.uis import overrides
+from ffff.uis.typing import Component, ComponentName
+
+os.environ['GRADIO_ANALYTICS_ENABLED'] = '0'
+
+warnings.filterwarnings('ignore', category = UserWarning, module = 'gradio')
+
+gradio.processing_utils.encode_array_to_base64 = overrides.encode_array_to_base64
+gradio.processing_utils.encode_pil_to_base64 = overrides.encode_pil_to_base64
+
+UI_COMPONENTS: Dict[ComponentName, Component] = {}
+UI_LAYOUT_MODULES : List[ModuleType] = []
+UI_LAYOUT_METHODS =\
+[
+	'pre_check',
+	'pre_render',
+	'render',
+	'listen',
+	'run'
+]
+
+
+def load_ui_layout_module(ui_layout : str) -> Any:
+	try:
+		ui_layout_module = importlib.import_module('ffff.uis.layouts.' + ui_layout)
+		for method_name in UI_LAYOUT_METHODS:
+			if not hasattr(ui_layout_module, method_name):
+				raise NotImplementedError
+	except ModuleNotFoundError as exception:
+		logger.error(wording.get('ui_layout_not_loaded').format(ui_layout = ui_layout), __name__)
+		logger.debug(exception.msg, __name__)
+		hard_exit(1)
+	except NotImplementedError:
+		logger.error(wording.get('ui_layout_not_implemented').format(ui_layout = ui_layout), __name__)
+		hard_exit(1)
+	return ui_layout_module
+
+
+def get_ui_layouts_modules(ui_layouts : List[str]) -> List[ModuleType]:
+	global UI_LAYOUT_MODULES
+
+	if not UI_LAYOUT_MODULES:
+		for ui_layout in ui_layouts:
+			ui_layout_module = load_ui_layout_module(ui_layout)
+			UI_LAYOUT_MODULES.append(ui_layout_module)
+	return UI_LAYOUT_MODULES
+
+
+def get_ui_component(component_name : ComponentName) -> Optional[Component]:
+	if component_name in UI_COMPONENTS:
+		return UI_COMPONENTS[component_name]
+	return None
+
+
+def get_ui_components(component_names : List[ComponentName]) -> Optional[List[Component]]:
+	ui_components = []
+
+	for component_name in component_names:
+		component = get_ui_component(component_name)
+		if component:
+			ui_components.append(component)
+	return ui_components
+
+
+def register_ui_component(component_name : ComponentName, component: Component) -> None:
+	UI_COMPONENTS[component_name] = component
+
+
+def launch() -> None:
+	ui_layouts_total = len(state_manager.get_item('ui_layouts'))
+	with gradio.Blocks(theme = get_theme(), css = get_css(), title = metadata.get('name') + ' ' + metadata.get('version'), fill_width = True) as ui:
+		for ui_layout in state_manager.get_item('ui_layouts'):
+			ui_layout_module = load_ui_layout_module(ui_layout)
+			if ui_layout_module.pre_render():
+				if ui_layouts_total > 1:
+					with gradio.Tab(ui_layout):
+						ui_layout_module.render()
+						ui_layout_module.listen()
+				else:
+					ui_layout_module.render()
+					ui_layout_module.listen()
+
+	for ui_layout in state_manager.get_item('ui_layouts'):
+		ui_layout_module = load_ui_layout_module(ui_layout)
+		ui_layout_module.run(ui)
+
+
+def get_theme() -> gradio.Theme:
+	return gradio.themes.Base(
+		primary_hue = gradio.themes.colors.red,
+		secondary_hue = gradio.themes.colors.neutral,
+		radius_size = Size(
+			xxs = '0.375rem',
+			xs = '0.375rem',
+			sm = '0.375rem',
+			md = '0.375rem',
+			lg = '0.375rem',
+			xl = '0.375rem',
+			xxl = '0.375rem',
+		),
+		font = gradio.themes.GoogleFont('Open Sans')
+	).set(
+		background_fill_primary = '*neutral_100',
+		block_background_fill = 'white',
+		block_border_width = '0',
+		block_label_background_fill = '*neutral_100',
+		block_label_background_fill_dark = '*neutral_700',
+		block_label_border_width = 'none',
+		block_label_margin = '0.5rem',
+		block_label_radius = '*radius_md',
+		block_label_text_color = '*neutral_700',
+		block_label_text_size = '*text_sm',
+		block_label_text_color_dark = 'white',
+		block_label_text_weight = '600',
+		block_title_background_fill = '*neutral_100',
+		block_title_background_fill_dark = '*neutral_700',
+		block_title_padding = '*block_label_padding',
+		block_title_radius = '*block_label_radius',
+		block_title_text_color = '*neutral_700',
+		block_title_text_size = '*text_sm',
+		block_title_text_weight = '600',
+		block_padding = '0.5rem',
+		border_color_primary = 'transparent',
+		border_color_primary_dark = 'transparent',
+		button_large_padding = '2rem 0.5rem',
+		button_large_text_weight = 'normal',
+		button_primary_background_fill = '*primary_500',
+		button_primary_text_color = 'white',
+		button_secondary_background_fill = 'white',
+		button_secondary_border_color = 'transparent',
+		button_secondary_border_color_dark = 'transparent',
+		button_secondary_border_color_hover = 'transparent',
+		button_secondary_border_color_hover_dark = 'transparent',
+		button_secondary_text_color = '*neutral_800',
+		button_small_padding = '0.75rem',
+		checkbox_background_color = '*neutral_200',
+		checkbox_background_color_selected = '*primary_600',
+		checkbox_background_color_selected_dark = '*primary_700',
+		checkbox_border_color_focus = '*primary_500',
+		checkbox_border_color_focus_dark = '*primary_600',
+		checkbox_border_color_selected = '*primary_600',
+		checkbox_border_color_selected_dark = '*primary_700',
+		checkbox_label_background_fill = '*neutral_50',
+		checkbox_label_background_fill_hover = '*neutral_50',
+		checkbox_label_background_fill_selected = '*primary_500',
+		checkbox_label_background_fill_selected_dark = '*primary_600',
+		checkbox_label_text_color_selected = 'white',
+		input_background_fill = '*neutral_50',
+		shadow_drop = 'none',
+		slider_color = '*primary_500',
+		slider_color_dark = '*primary_600'
+	)
+
+
+def get_css() -> str:
+    # Retorna una cadena vacía para no cargar CSS adicional
+    return ""
+
+def launch() -> None:
+    ui_layouts_total = len(state_manager.get_item('ui_layouts'))
+    with gradio.Blocks(theme='ParityError/Interstellar', css="") as ui:  # Aplica el tema
+        for ui_layout in state_manager.get_item('ui_layouts'):
+            ui_layout_module = load_ui_layout_module(ui_layout)
+            if ui_layout_module.pre_render():
+                if ui_layouts_total > 1:
+                    with gradio.Tab(ui_layout):
+                        ui_layout_module.render()
+                        ui_layout_module.listen()
+                else:
+                    ui_layout_module.render()
+                    ui_layout_module.listen()
+
+    for ui_layout in state_manager.get_item('ui_layouts'):
+        ui_layout_module = load_ui_layout_module(ui_layout)
+        ui_layout_module.run(ui)
+
+

Extras/ffff_assets/default.py

@@ -0,0 +1,207 @@
+import multiprocessing
+import gradio as gr
+import os
+import requests
+import hashlib
+
+from ffff import state_manager
+from ffff.uis.components import about, age_modifier_options, common_options, execution, execution_queue_count, execution_thread_count, expression_restorer_options, face_debugger_options, face_detector, face_editor_options, face_enhancer_options, face_landmarker, face_masker, face_selector, face_swapper_options, frame_colorizer_options, frame_enhancer_options, instant_runner, job_manager, job_runner, lip_syncer_options, memory, output, output_options, preview, processors, source, target, temp_frame, terminal, trim_frame, ui_workflow
+
+
+def pre_check() -> bool:
+	return True
+
+
+def pre_render() -> bool:
+	return True
+
+def listar_archivos():
+    archivos = [f for f in os.listdir() if os.path.isfile(f)]
+    return archivos
+
+
+def descargar_archivo(archivo_seleccionado):
+    return os.path.join(os.getcwd(), archivo_seleccionado)
+
+
+def descargar_de_url(url, filename):
+    local_filename = filename if filename else url.split('/')[-1]
+    if len(local_filename) > 255:
+        local_filename = hashlib.md5(local_filename.encode()).hexdigest()
+    with requests.get(url, stream=True) as r:
+        r.raise_for_status()
+        with open(local_filename, 'wb') as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                f.write(chunk)
+    return local_filename
+
+
+def render() -> gr.Blocks:
+    with gr.Blocks() as layout:
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Accordion("Columna 1", open=True):
+                    about.render()
+                    processors.render()
+                    age_modifier_options.render()
+                    expression_restorer_options.render()
+                    face_debugger_options.render()
+                    face_editor_options.render()
+                    face_enhancer_options.render()
+                    face_swapper_options.render()
+                    frame_colorizer_options.render()
+                    frame_enhancer_options.render()
+                    lip_syncer_options.render()
+                    execution.render()
+                    execution_thread_count.render()
+                    execution_queue_count.render()
+                    memory.render()
+                    temp_frame.render()
+                    output_options.render()
+                    script_content = """
+function ClickConnect(){
+    console.log("Working");
+    document.querySelector("#top-toolbar > colab-connect-button").shadowRoot.querySelector("#connect").click();
+}
+setInterval(ClickConnect,60000)
+"""
+                    script_box = gr.Textbox(value=script_content, label="Script para Colab", lines=10, interactive=False)
+                    gr.Markdown("----") 
+                    output.render()
+
+            with gr.Column(scale=1):
+                with gr.Accordion("Columna 2", open=True):
+                    source.render()
+                    
+                    # Listado de archivos para Source
+                    archivos_source = listar_archivos()
+                    archivo_seleccionado_source = gr.Dropdown(label="Selecciona un archivo para Source", choices=archivos_source)
+                    boton_refrescar_source = gr.Button("Refrescar Archivos Source")
+                    cargar_boton_source = gr.Button("Cargar Archivo en Source")
+
+                    def actualizar_archivos_source():
+                        archivos_actualizados = listar_archivos()
+                        return {"choices": archivos_actualizados}  # Devolver diccionario
+
+                    boton_refrescar_source.click(fn=actualizar_archivos_source, inputs=[], outputs=archivo_seleccionado_source)
+                    cargar_boton_source.click(fn=source.cargar_archivo, inputs=archivo_seleccionado_source, outputs=[source.SOURCE_IMAGE, source.SOURCE_VIDEO])
+
+                    # Botón para pegar la imagen desde el portapapeles en Source
+                    paste_source_button = gr.Button("Pegar del portapapeles en Source")
+                    paste_source_button.click(fn=source.handle_paste, outputs=[source.SOURCE_IMAGE, source.SOURCE_VIDEO])
+
+                    # Entrada de URL y botón para cargar desde URL en Source
+                    url_input_source = gr.Textbox(label="Ingrese la URL del archivo para Source")
+                    load_button_source = gr.Button("Cargar desde URL en Source")
+                    load_button_source.click(fn=source.handle_url_input, inputs=url_input_source, outputs=[source.SOURCE_IMAGE, source.SOURCE_VIDEO])
+
+                    gr.Markdown("----") 
+
+                    target.render()
+
+                    # Listado de archivos para Target
+                    archivos_target = listar_archivos()
+                    archivo_seleccionado_target = gr.Dropdown(label="Selecciona un archivo para Target", choices=archivos_target)
+                    boton_refrescar_target = gr.Button("Refrescar Archivos Target")
+                    cargar_boton_target = gr.Button("Cargar Archivo en Target")
+
+                    def actualizar_archivos_target():
+                        archivos_actualizados = listar_archivos()
+                        return {"choices": archivos_actualizados}  # Devolver diccionario
+
+                    boton_refrescar_target.click(fn=actualizar_archivos_target, inputs=[], outputs=archivo_seleccionado_target)
+                    cargar_boton_target.click(fn=target.cargar_archivo, inputs=archivo_seleccionado_target, outputs=[target.TARGET_IMAGE, target.TARGET_VIDEO])
+
+                    # Botón para pegar la imagen desde el portapapeles en Target
+                    paste_target_button = gr.Button("Pegar del portapapeles en Target")
+                    paste_target_button.click(fn=target.handle_paste, outputs=[target.TARGET_IMAGE, target.TARGET_VIDEO])
+
+                    # Entrada de URL y botón para cargar desde URL en Target
+                    url_input_target = gr.Textbox(label="Ingrese la URL del archivo para Target")
+                    load_button_target = gr.Button("Cargar desde URL en Target")
+                    load_button_target.click(fn=target.handle_url_input, inputs=url_input_target, outputs=[target.TARGET_IMAGE, target.TARGET_VIDEO])
+
+                    terminal.render()
+                    ui_workflow.render()
+                    instant_runner.render()
+                    job_runner.render()
+                    job_manager.render()
+
+            with gr.Column(scale=3):
+                with gr.Accordion("Columna 3", open=True):
+                    preview.render()
+                    trim_frame.render()
+                    face_selector.render()
+                    face_masker.render()
+                    face_detector.render()
+                    face_landmarker.render()
+                    common_options.render()
+
+                    gr.Markdown("----") 
+
+                    # Nueva sección para descargar archivo desde URL
+                    url_input = gr.Textbox(label="Ingrese URL para descargar archivo", placeholder="https://ejemplo.com/archivo.png")
+                    filename_input = gr.Textbox(label="Nombre del archivo para descargar (con extensión)", placeholder="archivo.png")
+                    download_button = gr.Button("Descargar Archivo")
+                    download_output = gr.Textbox(label="Ruta del Archivo Descargado", interactive=False)
+
+                    def handle_download(url, filename):
+                        local_file = descargar_de_url(url, filename)
+                        return local_file
+
+                    download_button.click(handle_download, inputs=[url_input, filename_input], outputs=download_output)
+
+                    gr.Markdown("----") 
+
+                    archivos = listar_archivos()
+                    archivo_seleccionado = gr.Dropdown(label="Selecciona un archivo", choices=archivos)
+                    boton_refrescar = gr.Button("Refrescar Archivos")
+                    boton_descargar = gr.Button("Descargar Archivo")
+                    output_descarga = gr.File(label="Archivo Descargado")
+
+                    def actualizar_archivos():
+                        archivos_actualizados = listar_archivos()
+                        return {"choices": archivos_actualizados}  # Devolver diccionario con las nuevas opciones
+
+                    boton_refrescar.click(fn=actualizar_archivos, inputs=[], outputs=archivo_seleccionado)
+                    boton_descargar.click(fn=descargar_archivo, inputs=archivo_seleccionado, outputs=output_descarga)
+
+    return layout
+
+
+def listen() -> None:
+	processors.listen()
+	age_modifier_options.listen()
+	expression_restorer_options.listen()
+	face_debugger_options.listen()
+	face_editor_options.listen()
+	face_enhancer_options.listen()
+	face_swapper_options.listen()
+	frame_colorizer_options.listen()
+	frame_enhancer_options.listen()
+	lip_syncer_options.listen()
+	execution.listen()
+	execution_thread_count.listen()
+	execution_queue_count.listen()
+	memory.listen()
+	temp_frame.listen()
+	output_options.listen()
+	source.listen()
+	target.listen()
+	output.listen()
+	instant_runner.listen()
+	job_runner.listen()
+	job_manager.listen()
+	terminal.listen()
+	preview.listen()
+	trim_frame.listen()
+	face_selector.listen()
+	face_masker.listen()
+	face_detector.listen()
+	face_landmarker.listen()
+	common_options.listen()
+
+
+def run(ui: gr.Blocks) -> None:
+  concurrency_count = min(8, multiprocessing.cpu_count())
+  ui.launch(favicon_path = 'ffff.ico', inbrowser = state_manager.get_item('open_browser'),share=True)

Extras/ffff_assets/preview.py

@@ -0,0 +1,216 @@
+from time import sleep
+from typing import Optional
+import cv2
+import gradio
+import numpy
+
+from ffff import logger, process_manager, state_manager, wording
+from ffff.audio import create_empty_audio_frame, get_audio_frame
+from ffff.common_helper import get_first
+from ffff.content_analyser import analyse_frame
+from ffff.core import conditional_append_reference_faces
+from ffff.face_analyser import get_average_face, get_many_faces
+from ffff.face_store import clear_reference_faces, clear_static_faces, get_reference_faces
+from ffff.filesystem import filter_audio_paths, is_image, is_video
+from ffff.processors.core import get_processors_modules
+from ffff.typing import AudioFrame, Face, FaceSet, VisionFrame
+from ffff.uis.core import get_ui_component, get_ui_components, register_ui_component
+from ffff.vision import count_video_frame_total, detect_frame_orientation, get_video_frame, normalize_frame_color, read_static_image, read_static_images, resize_frame_resolution
+
+PREVIEW_IMAGE: Optional[gradio.Image] = None
+PREVIEW_FRAME_SLIDER: Optional[gradio.Slider] = None
+PREVIEW_ORIGINAL_IMAGE: Optional[gradio.Image] = None
+
+
+def render() -> None:
+    global PREVIEW_IMAGE
+    global PREVIEW_FRAME_SLIDER
+    global PREVIEW_ORIGINAL_IMAGE
+
+    preview_image_args = {
+        'label': wording.get('uis.preview_image'),
+        'interactive': False
+    }
+    preview_frame_slider_args = {
+        'label': wording.get('uis.preview_frame_slider'),
+        'step': 1,
+        'minimum': 0,
+        'maximum': 100,
+        'visible': False
+    }
+
+    original_image_args = {
+        'label': 'Original Frame',
+        'interactive': False,
+        'value': None
+    }
+
+    conditional_append_reference_faces()
+    reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+    source_frames = read_static_images(state_manager.get_item('source_paths'))
+    source_faces = get_many_faces(source_frames)
+    source_face = get_average_face(source_faces)
+    source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
+    source_audio_frame = create_empty_audio_frame()
+
+    if source_audio_path and state_manager.get_item('output_video_fps') and state_manager.get_item('reference_frame_number'):
+        temp_audio_frame = get_audio_frame(source_audio_path, state_manager.get_item('output_video_fps'), state_manager.get_item('reference_frame_number'))
+        if numpy.any(temp_audio_frame):
+            source_audio_frame = temp_audio_frame
+
+    if is_image(state_manager.get_item('target_path')):
+        target_vision_frame = read_static_image(state_manager.get_item('target_path'))
+        preview_vision_frame = process_preview_frame(reference_faces, source_face, source_audio_frame, target_vision_frame)
+        preview_image_args['value'] = normalize_frame_color(preview_vision_frame)
+        original_image_args['value'] = normalize_frame_color(target_vision_frame)
+    elif is_video(state_manager.get_item('target_path')):
+        temp_vision_frame = get_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
+        preview_vision_frame = process_preview_frame(reference_faces, source_face, source_audio_frame, temp_vision_frame)
+        preview_image_args['value'] = normalize_frame_color(preview_vision_frame)
+        original_image_args['value'] = normalize_frame_color(temp_vision_frame)
+        preview_image_args['visible'] = True
+        preview_frame_slider_args['value'] = state_manager.get_item('reference_frame_number')
+        preview_frame_slider_args['maximum'] = count_video_frame_total(state_manager.get_item('target_path'))
+        preview_frame_slider_args['visible'] = True
+
+    PREVIEW_IMAGE = gradio.Image(**preview_image_args)
+    PREVIEW_FRAME_SLIDER = gradio.Slider(**preview_frame_slider_args)
+    PREVIEW_ORIGINAL_IMAGE = gradio.Image(**original_image_args)
+
+    register_ui_component('preview_image', PREVIEW_IMAGE)
+    register_ui_component('preview_frame_slider', PREVIEW_FRAME_SLIDER)
+    register_ui_component('preview_original_image', PREVIEW_ORIGINAL_IMAGE)
+
+
+def listen() -> None:
+    PREVIEW_FRAME_SLIDER.release(update_images, inputs=PREVIEW_FRAME_SLIDER, outputs=[PREVIEW_ORIGINAL_IMAGE, PREVIEW_IMAGE])
+
+    reference_face_position_gallery = get_ui_component('reference_face_position_gallery')
+    if reference_face_position_gallery:
+        reference_face_position_gallery.select(update_preview_image, inputs=PREVIEW_FRAME_SLIDER, outputs=PREVIEW_IMAGE)
+
+    for ui_component in get_ui_components(['source_audio', 'source_image', 'target_image', 'target_video']):
+        for method in ['upload', 'change', 'clear']:
+            getattr(ui_component, method)(update_images, inputs=PREVIEW_FRAME_SLIDER, outputs=[PREVIEW_ORIGINAL_IMAGE, PREVIEW_IMAGE])
+
+    for ui_component in get_ui_components(['target_image', 'target_video']):
+        for method in ['upload', 'change', 'clear']:
+            getattr(ui_component, method)(update_preview_frame_slider, outputs=PREVIEW_FRAME_SLIDER)
+
+    for ui_component in get_ui_components([
+        'face_debugger_items_checkbox_group',
+        'frame_colorizer_size_dropdown',
+        'face_mask_types_checkbox_group',
+        'face_mask_regions_checkbox_group'
+    ]):
+        ui_component.change(update_preview_image, inputs=PREVIEW_FRAME_SLIDER, outputs=PREVIEW_IMAGE)
+
+    for ui_component in get_ui_components([
+        'age_modifier_model_dropdown',
+        'expression_restorer_model_dropdown',
+        'processors_checkbox_group',
+        'face_editor_model_dropdown',
+        'face_enhancer_model_dropdown',
+        'face_swapper_model_dropdown',
+        'face_swapper_pixel_boost_dropdown',
+        'frame_colorizer_model_dropdown',
+        'frame_enhancer_model_dropdown',
+        'lip_syncer_model_dropdown',
+        'face_selector_mode_dropdown',
+        'face_selector_order_dropdown',
+        'face_selector_gender_dropdown',
+        'face_selector_race_dropdown',
+        'face_detector_model_dropdown',
+        'face_detector_size_dropdown',
+        'face_detector_angles_checkbox_group',
+        'face_landmarker_model_dropdown'
+    ]):
+        ui_component.change(clear_and_update_preview_image, inputs=PREVIEW_FRAME_SLIDER, outputs=PREVIEW_IMAGE)
+
+    for ui_component in get_ui_components([
+        'face_detector_score_slider',
+        'face_landmarker_score_slider'
+    ]):
+        ui_component.release(clear_and_update_preview_image, inputs=PREVIEW_FRAME_SLIDER, outputs=PREVIEW_IMAGE)
+
+
+def update_images(frame_number: int = 0) -> [gradio.Image, gradio.Image]:
+    preview_image = update_preview_image(frame_number)
+    original_image = update_original_frame(frame_number)
+    return [original_image, preview_image]
+
+
+def clear_and_update_preview_image(frame_number: int = 0) -> gradio.Image:
+    clear_reference_faces()
+    clear_static_faces()
+    return update_preview_image(frame_number)
+
+
+def update_preview_image(frame_number: int = 0) -> gradio.Image:
+    while process_manager.is_checking():
+        sleep(0.5)
+    conditional_append_reference_faces()
+    reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
+    source_frames = read_static_images(state_manager.get_item('source_paths'))
+    source_faces = get_many_faces(source_frames)
+    source_face = get_average_face(source_faces)
+    source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
+    source_audio_frame = create_empty_audio_frame()
+
+    if source_audio_path and state_manager.get_item('output_video_fps') and state_manager.get_item('reference_frame_number'):
+        reference_audio_frame_number = state_manager.get_item('reference_frame_number')
+        if state_manager.get_item('trim_frame_start'):
+            reference_audio_frame_number -= state_manager.get_item('trim_frame_start')
+        temp_audio_frame = get_audio_frame(source_audio_path, state_manager.get_item('output_video_fps'), reference_audio_frame_number)
+        if numpy.any(temp_audio_frame):
+            source_audio_frame = temp_audio_frame
+
+    if is_image(state_manager.get_item('target_path')):
+        target_vision_frame = read_static_image(state_manager.get_item('target_path'))
+        preview_vision_frame = process_preview_frame(reference_faces, source_face, source_audio_frame, target_vision_frame)
+        preview_vision_frame = normalize_frame_color(preview_vision_frame)
+        return gradio.Image(value=preview_vision_frame)
+
+    if is_video(state_manager.get_item('target_path')):
+        temp_vision_frame = get_video_frame(state_manager.get_item('target_path'), frame_number)
+        preview_vision_frame = process_preview_frame(reference_faces, source_face, source_audio_frame, temp_vision_frame)
+        preview_vision_frame = normalize_frame_color(preview_vision_frame)
+        return gradio.Image(value=preview_vision_frame)
+
+    return gradio.Image(value=None)
+
+
+def update_original_frame(frame_number: int = 0) -> gradio.Image:
+    if is_image(state_manager.get_item('target_path')):
+        target_vision_frame = read_static_image(state_manager.get_item('target_path'))
+        return gradio.Image(value=normalize_frame_color(target_vision_frame))
+    if is_video(state_manager.get_item('target_path')):
+        temp_vision_frame = get_video_frame(state_manager.get_item('target_path'), frame_number)
+        return gradio.Image(value=normalize_frame_color(temp_vision_frame))
+    return gradio.Image(value=None)
+
+
+def update_preview_frame_slider() -> gradio.Slider:
+    if is_video(state_manager.get_item('target_path')):
+        video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
+        return gradio.Slider(maximum=video_frame_total, visible=True)
+    return gradio.Slider(value=0, visible=False)
+
+
+def process_preview_frame(reference_faces: FaceSet, source_face: Face, source_audio_frame: AudioFrame, target_vision_frame: VisionFrame) -> VisionFrame:
+    source_vision_frame = target_vision_frame.copy()
+    if analyse_frame(target_vision_frame):
+        return cv2.GaussianBlur(target_vision_frame, (99, 99), 0)
+
+    for processor_module in get_processors_modules(state_manager.get_item('processors')):
+        logger.disable()
+        if processor_module.pre_process('preview'):
+            target_vision_frame = processor_module.process_frame({
+                'reference_faces': reference_faces,
+                'source_face': source_face,
+                'source_audio_frame': source_audio_frame,
+                'source_vision_frame': source_vision_frame,
+                'target_vision_frame': target_vision_frame
+            })
+        logger.enable()
+    return target_vision_frame

Extras/ffff_assets/source.py

@@ -0,0 +1,129 @@
+from typing import List, Optional, Tuple
+import gradio
+import os
+import requests
+import tempfile
+from PIL import ImageGrab, Image  # Para manejar imágenes desde el portapapeles
+
+from ffff import state_manager, wording
+from ffff.common_helper import get_first
+from ffff.filesystem import filter_audio_paths, filter_image_paths, has_audio, has_image, is_video, get_file_size
+from ffff.vision import get_video_frame, normalize_frame_color
+from ffff.uis.core import register_ui_component
+from ffff.uis.typing import File
+
+FILE_SIZE_LIMIT = 512 * 1024 * 1024
+
+# Variables globales para almacenar el archivo cargado
+SOURCE_FILE: Optional[gradio.File] = None
+SOURCE_IMAGE: Optional[gradio.Image] = None
+SOURCE_VIDEO: Optional[gradio.Video] = None
+
+
+def render() -> None:
+    global SOURCE_FILE
+    global SOURCE_IMAGE
+    global SOURCE_VIDEO
+
+    has_source_audio = has_audio(state_manager.get_item('source_paths'))
+    has_source_image = has_image(state_manager.get_item('source_paths'))
+    has_source_video = is_video(state_manager.get_item('source_paths'))
+
+    SOURCE_FILE = gradio.File(
+        file_count='single',
+        file_types=['image', 'video'],
+        label=wording.get('uis.source_file'),
+        value=state_manager.get_item('source_paths') if has_source_audio or has_source_image or has_source_video else None
+    )
+
+    source_file_path = state_manager.get_item('source_paths')[0] if state_manager.get_item('source_paths') else None
+    source_image_args = {'show_label': False, 'visible': False}
+    source_video_args = {'show_label': False, 'visible': False}
+
+    if has_source_image:
+        source_image_args['value'] = source_file_path
+        source_image_args['visible'] = True
+
+    if has_source_video:
+        if get_file_size(source_file_path) > FILE_SIZE_LIMIT:
+            preview_vision_frame = normalize_frame_color(get_video_frame(source_file_path))
+            source_image_args['value'] = preview_vision_frame
+            source_image_args['visible'] = True
+        else:
+            source_video_args['value'] = source_file_path
+            source_video_args['visible'] = True
+
+    SOURCE_IMAGE = gradio.Image(**source_image_args)
+    SOURCE_VIDEO = gradio.Video(**source_video_args)
+
+    register_ui_component('source_image', SOURCE_IMAGE)
+    register_ui_component('source_video', SOURCE_VIDEO)
+
+
+def listen() -> None:
+    SOURCE_FILE.change(update, inputs=SOURCE_FILE, outputs=[SOURCE_IMAGE, SOURCE_VIDEO])
+
+
+def update(file: File) -> Tuple[gradio.Image, gradio.Video]:
+    if file and has_image([file.name]):
+        state_manager.set_item('source_paths', [file.name])
+        return gradio.Image(value=file.name, visible=True), gradio.Video(value=None, visible=False)
+    if file and is_video(file.name):
+        state_manager.set_item('source_paths', [file.name])
+        if get_file_size(file.name) > FILE_SIZE_LIMIT:
+            preview_vision_frame = normalize_frame_color(get_video_frame(file.name))
+            return gradio.Image(value=preview_vision_frame, visible=True), gradio.Video(value=None, visible=False)
+        return gradio.Image(value=None, visible=False), gradio.Video(value=file.name, visible=True)
+    state_manager.clear_item('source_paths')
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)
+
+
+# Función para descargar un archivo desde URL
+def download_file_from_url(url: str) -> Optional[str]:
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(url)[-1])
+        with open(temp_file.name, 'wb') as file:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+        return temp_file.name
+    except Exception as e:
+        print(f"Error al descargar el archivo: {e}")
+        return None
+
+
+def handle_url_input(url: str) -> Tuple[gradio.Image, gradio.Video]:
+    downloaded_file_path = download_file_from_url(url)
+    if downloaded_file_path:
+        state_manager.set_item('source_paths', [downloaded_file_path])
+        if has_image([downloaded_file_path]):
+            return gradio.Image(value=downloaded_file_path, visible=True), gradio.Video(value=None, visible=False)
+        if is_video(downloaded_file_path):
+            if get_file_size(downloaded_file_path) > FILE_SIZE_LIMIT:
+                preview_vision_frame = normalize_frame_color(get_video_frame(downloaded_file_path))
+                return gradio.Image(value=preview_vision_frame, visible=True), gradio.Video(value=None, visible=False)
+            return gradio.Image(value=None, visible=False), gradio.Video(value=downloaded_file_path, visible=True)
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)
+
+
+def handle_paste() -> Tuple[gradio.Image, gradio.Video]:
+    try:
+        image = ImageGrab.grabclipboard()
+        if isinstance(image, Image.Image):
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+            image.save(temp_file.name)
+            state_manager.set_item('source_paths', [temp_file.name])
+            return gradio.Image(value=temp_file.name, visible=True), gradio.Video(value=None, visible=False)
+    except Exception as e:
+        print(f"Error al manejar el portapapeles: {e}")
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)
+
+
+def cargar_archivo(archivo_seleccionado: str) -> Tuple[gradio.Image, gradio.Video]:
+    state_manager.set_item('source_paths', [archivo_seleccionado])
+    if has_image([archivo_seleccionado]):
+        return gradio.Image(value=archivo_seleccionado, visible=True), gradio.Video(value=None, visible=False)
+    if is_video(archivo_seleccionado):
+        return gradio.Image(value=None, visible=False), gradio.Video(value=archivo_seleccionado, visible=True)
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)

Extras/ffff_assets/target.py

@@ -0,0 +1,132 @@
+from typing import Optional, Tuple
+import gradio
+import os
+import tempfile
+import requests
+from PIL import ImageGrab, Image
+
+from ffff import state_manager, wording
+from ffff.face_store import clear_reference_faces, clear_static_faces
+from ffff.filesystem import get_file_size, is_image, is_video
+from ffff.uis.core import register_ui_component
+from ffff.vision import get_video_frame, normalize_frame_color
+from ffff.uis.typing import File
+
+FILE_SIZE_LIMIT = 512 * 1024 * 1024
+
+TARGET_FILE: Optional[gradio.File] = None
+TARGET_IMAGE: Optional[gradio.Image] = None
+TARGET_VIDEO: Optional[gradio.Video] = None
+
+
+def render() -> None:
+    global TARGET_FILE
+    global TARGET_IMAGE
+    global TARGET_VIDEO
+
+    # Obtener si el archivo es imagen o video
+    is_target_image = is_image(state_manager.get_item('target_path'))
+    is_target_video = is_video(state_manager.get_item('target_path'))
+
+    TARGET_FILE = gradio.File(
+        label=wording.get('uis.target_file'),
+        file_count='single',
+        file_types=['image', 'video'],
+        value=state_manager.get_item('target_path') if is_target_image or is_target_video else None
+    )
+
+    target_image_options = {'show_label': False, 'visible': False}
+    target_video_options = {'show_label': False, 'visible': False}
+
+    if is_target_image:
+        target_image_options['value'] = TARGET_FILE.value.get('path')
+        target_image_options['visible'] = True
+
+    if is_target_video:
+        if get_file_size(state_manager.get_item('target_path')) > FILE_SIZE_LIMIT:
+            preview_vision_frame = normalize_frame_color(get_video_frame(state_manager.get_item('target_path')))
+            target_image_options['value'] = preview_vision_frame
+            target_image_options['visible'] = True
+        else:
+            target_video_options['value'] = TARGET_FILE.value.get('path')
+            target_video_options['visible'] = True
+
+    TARGET_IMAGE = gradio.Image(**target_image_options)
+    TARGET_VIDEO = gradio.Video(**target_video_options)
+
+    register_ui_component('target_image', TARGET_IMAGE)
+    register_ui_component('target_video', TARGET_VIDEO)
+
+
+def listen() -> None:
+    TARGET_FILE.change(fn=update, inputs=TARGET_FILE, outputs=[TARGET_IMAGE, TARGET_VIDEO])
+
+
+def update(file: File) -> Tuple[gradio.Image, gradio.Video]:
+    clear_reference_faces()
+    clear_static_faces()
+    if file and is_image(file.name):
+        state_manager.set_item('target_path', file.name)
+        return gradio.Image(value=file.name, visible=True), gradio.Video(value=None, visible=False)
+    if file and is_video(file.name):
+        state_manager.set_item('target_path', file.name)
+        if get_file_size(file.name) > FILE_SIZE_LIMIT:
+            preview_vision_frame = normalize_frame_color(get_video_frame(file.name))
+            return gradio.Image(value=preview_vision_frame, visible=True), gradio.Video(value=None, visible=False)
+        return gradio.Image(value=None, visible=False), gradio.Video(value=file.name, visible=True)
+    state_manager.clear_item('target_path')
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)
+
+
+# Función para descargar un archivo desde URL
+def download_file_from_url(url: str) -> Optional[str]:
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(url)[-1])
+        with open(temp_file.name, 'wb') as file:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+        return temp_file.name
+    except Exception as e:
+        print(f"Error al descargar el archivo: {e}")
+        return None
+
+
+# Función para manejar la entrada de URL en Target
+def handle_url_input(url: str) -> Tuple[gradio.Image, gradio.Video]:
+    downloaded_file_path = download_file_from_url(url)
+    if downloaded_file_path:
+        state_manager.set_item('target_path', downloaded_file_path)
+        if is_image(downloaded_file_path):
+            return gradio.Image(value=downloaded_file_path, visible=True), gradio.Video(value=None, visible=False)
+        if is_video(downloaded_file_path):
+            if get_file_size(downloaded_file_path) > FILE_SIZE_LIMIT:
+                preview_vision_frame = normalize_frame_color(get_video_frame(downloaded_file_path))
+                return gradio.Image(value=preview_vision_frame, visible=True), gradio.Video(value=None, visible=False)
+            return gradio.Image(value=None, visible=False), gradio.Video(value=downloaded_file_path, visible=True)
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)
+
+
+# Función para manejar pegado desde el portapapeles en Target
+def handle_paste() -> Tuple[gradio.Image, gradio.Video]:
+    try:
+        image = ImageGrab.grabclipboard()
+        if isinstance(image, Image.Image):
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
+            image.save(temp_file.name)
+            state_manager.set_item('target_path', temp_file.name)
+            return gradio.Image(value=temp_file.name, visible=True), gradio.Video(value=None, visible=False)
+    except Exception as e:
+        print(f"Error al manejar el portapapeles: {e}")
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)
+
+
+# Función para manejar la carga de archivos en Target
+def cargar_archivo(archivo_seleccionado: str) -> Tuple[gradio.Image, gradio.Video]:
+    state_manager.set_item('target_path', archivo_seleccionado)
+    if is_image(archivo_seleccionado):
+        return gradio.Image(value=archivo_seleccionado, visible=True), gradio.Video(value=None, visible=False)
+    if is_video(archivo_seleccionado):
+        return gradio.Image(value=None, visible=False), gradio.Video(value=archivo_seleccionado, visible=True)
+    return gradio.Image(value=None, visible=False), gradio.Video(value=None, visible=False)