Deep Live Cam es es una herramienta basada en inteligencia artificial que permite realizar transformaciones de cara en tiempo real desde el vídeo capturado mediante una webcam. Con esta herramienta, además de ponerte la cara de tu personaje favorito, se puede aplicar a un video previamente grabado. Vamos a añadir además la redirección a una cámara web virtual para ser utilizada en un videochat.

En nuestro caso utilizaremos un Linux Mint y aunque no es necesario, es ideal que tengamos una tarjeta gráfica relativamente potente. En mi caso uso una tarjeta Nvidia GeForce RTX 2060 Super. Si no usamos una tarjeta gráfica para que la aplicación haga uso de sus núcleos CUDA, funcionará pero a bastante ralentizado y a trompicones.

Paso 1. Instalando las herramientas necesarias

Abre una terminal y ejecuta lo siguiente:

sudo apt install ffmpeg git python3-pip python3-tk python3-venv

• ffmpeg: Herramienta para manipulación de archivos multimedia.
• git: Sistema de control de versiones para gestionar el código fuente.
• python3-pip: Gestor de paquetes para instalar bibliotecas y herramientas de Python 3.
• python3-tk: Bibliotecas de herramientas de interfaz gráfica para Python 3, útiles para proyectos con elementos visuales.
• python3-venv: Es la herramienta para crear entornos virtuales de Python.

Paso 2. Clonando el repositorio de Deep-Live-Cam y configurando el entorno virtual

git clone https://github.com/hacksider/Deep-Live-Cam
cd Deep-Live-Cam/
python3 -m venv venv

Activamos el entorno virtual:

source venv/bin/activate

Instalamos las librerías con los requerimientos de la herramienta, suele tardar un buen rato no desesperes:

pip install -r requirements.txt

Paso 3. Descargando modelos preentrenados.

mkdir models
cd models
wget https://huggingface.co/hacksider/deep-live-cam/resolve/main/inswapper_128_fp16.onnx
wget https://huggingface.co/hacksider/deep-live-cam/resolve/main/GFPGANv1.4.pth
cd ..

• inswapper_128_fp16.onnx: Es un potente modelo de intercambio facial.
• GFPGANv1.4.pth: Modelo para mejorar visualmente las caras.

Paso 4. Lo ejecutamos.

Nos aseguramos que estamos dentro del directorio Deep-Live-Cam y lo ejecutamos así:

python3 run.py

Uso de tarjeta gráfica con núcleos CUDA.

Para acelerar el proceso y que la imagen se vea más fluidamente haremos lo que nos dice las instrucciones del desarrollador, haremos lo siguiente:

1.- Instalamos en nuestro sistema CUDA Toolkit 11.8.

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.0-1_all.deb
sudo dpkg -i cuda-keyring_1.0-1_all.deb
sudo apt-get update
sudo apt-get -y install cuda

2.- Realizamos algunos cambios y añadidos.

pip uninstall onnxruntime onnxruntime-gpu
pip install onnxruntime-gpu==1.15.1

3. Ejecución de la aplicación con uso de núcleos CUDA

python run.py --execution-provider cuda

Redireccionando la salida a una cámara virtual

Para poder utilizar la fake webcam como una cámara virtual para ser usada en Video chats tenemos que tocar ciertas partes del código y añadir la posibilidad de usar virtual cameras a nuestro linux.

1. Creamos las cámaras virtuales.

sudo apt update
sudo apt-get install v4l2loopback-dkms

Aunque solo necesitemos uno, amos a crear tres dispositivos virtuales. Para ello, añadimos a las tres cámaras al fichero de configuración en /etc/modprobe.d/virtualcams.conf. Nos creará los dispositivos /dev/video10, /dev/video11 y /dev/video12. Le asignaremos también un nombre a cada cámara que serán virtual10, virtual11 y virtual12: (copia y pega en la línea de comandos las 4 líneas siguientes a la vez)

echo options v4l2loopback devices=3 video_nr=10,11,12 
card_label="Virtual10","Virtual11","Virtual12" exclusive_caps=1,1,1 | sudo tee -a 
/etc/modprobe.d/virtualcams.conf

Hacemos que se creen al iniciar el ordenador:

echo v4l2loopback | sudo tee -a /etc/modules-load.d/virtualcams.conf

Recargamos el módulo del kernel que hace funcionar las cámaras virtuales:

sudo modprobe -r v4l2loopback
sudo modprobe v4l2loopback

En este punto conviene reiniciar el ordenador

Retocando el código y haciéndolo funcionar.

Además de hacer que funcione la cámara virtual, arreglaremos el código para poder cerrar la ventana y cambiar de cara sin tener que cerrar todo el programa.

Asegúrate primero que estas en el directorio donde se encuentra la aplicación (Deep-Live-Cam) y que tienes el entorno virtual activado (en la línea de comandos debe aparecer (venv) al inicio).

Instalamos dependencias necesarias:

pip install pyfakewebcam

Hacemos una copia de seguridad de lo que vamos a tocar y editamos el código:

cp ./modules/ui.py ./modules/ui-seguridad.py
nano ./modules/ui.py

Al principio añadimos el código que he resaltado para que el programa utilice la librería pyfakewebcam:

import os
import webbrowser
import customtkinter as ctk
from typing import Callable, Tuple
import cv2
import pyfakewebcam

from PIL import Image, ImageOps

Unas líneas más abajo añade lo resaltado para permitir que la webcam real utilice desde el inicio la cámara y crear la cámara virtual. En nuestro caso usaremos las cámaras del sistema /dev/video0 como cámara real y /dev/video10 como cámara fake. Si tu webcam real fuera /dev/video1 has de cambiar cap = cv2.VideoCapture(0) por cap = cv2.VideoCapture(1). La primera línea está puesta ahí sólo para arreglar el fallo de no poder cambiar de cara porque dice que la webcam está ocupada.

preview_label = None
preview_slider = None
source_label = None
target_label = None
status_label = None

cap = cv2.VideoCapture(0)  # Use index for the webcam (adjust the index 
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # Set the width of the resolution
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 360)  # Set the height of the resolution
cap.set(cv2.CAP_PROP_FPS, 60)  # Set the frame rate of the webcam

width = int(cap.get(3))  # Código 3 corresponde al ancho
height = int(cap.get(4))  # Código 4 corresponde al alto
print(f"Ancho: {width}, Alto: {height}")
camera = pyfakewebcam.FakeWebcam('/dev/video10', width, height)
img_ft, vid_ft = modules.globals.file_types


def init(start: Callable[[], None], destroy: Callable[[], None]) -> ctk.CTk:
    global ROOT, PREVIEW

Nos vamos abajo del todo y comentamos la línea marcada en rojo

def webcam_preview():
    if modules.globals.source_path is None:
        # No image selected
        return
    
    global preview_label, PREVIEW

#   cap = cv2.VideoCapture(0)  # Use index for the webcam (adjust the index accordingly if necessary)    
#    cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # Set the width of the resolution
#    cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 360)  # Set the height of the resolution
#    cap.set(cv2.CAP_PROP_FPS, 60)  # Set the frame rate of the webcam
#    PREVIEW_MAX_WIDTH = 1280
#    PREVIEW_MAX_HEIGHT = 720
    #PREVIEW_MAX_WIDTH = 640
    #PREVIEW_MAX_HEIGHT = 360

Finalizamos haciéndo la redirección hacia la cámara virtual añadiendo lo siguiente. RESPETA LOS ESPACIOS INICIALES:

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        # Select and save face image only once
        if source_image is None and modules.globals.source_path:
            source_image = get_one_face(cv2.imread(modules.globals.source_path))

        temp_frame = frame.copy()  #Create a copy of the frame

        for frame_processor in frame_processors:
            temp_frame = frame_processor.process_frame(source_image, temp_frame)

        image = cv2.cvtColor(temp_frame, cv2.COLOR_BGR2RGB)  # Convert the image to RGB format to display it with Tkinter
        camera.schedule_frame(image)
        image = Image.fromarray(image)
        image = ImageOps.contain(image, (PREVIEW_MAX_WIDTH, PREVIEW_MAX_HEIGHT), Image.LANCZOS)

Recomendaciones y testeos:

• Para saber mientras se ejecuta, las salidas de las cámaras virtuales puedes hacer: ffplay /dev/video0 o ffplay /dev/video10 o ffplay /dev/video11 dependiendo cual es la cámara que uses.
• Asegúrate que la webcam que vas a usar es /dev/video0. Con un ls /dev/video* verás todas las que tienes en tu sistema, reales o virtuales. Si tu cámara de entrrada al programa fuera por ejemplo /dev/video1, debes cambiar la línea de código cap = cv2.VideoCapture(0) por cap = cv2.VideoCapture(1)
• Si vas a usar micrófono ten en cuenta que la webcam real la está utilizando la aplicación para deep fakes. Si le dices al navegador que use el micrófono integrado en esa webcam probablemente no te deje ya que está siendo usado. Usa un micrófono externo como alternativa.
• Para saber las cámaras virtuales creadas en tu equipo y cuales son físicas un comando te lo dirá: v4l2-ctl --list-devices pero para ello tienes que instalar el paquete v4l-utils con sudo apt install v4l-utils.
• Si vas a usar un dispositivo móvil para webcam como Iriun Webcam, debes saber que esta crea también cámaras virtuales por lo que deberás hacer lo siguiente para que esta cámara funcione:
  
  Una vez instalado el paquete Iriun Webcam, debes editar el archivo de configuración de cámaras virtuales con sudo nano /etc/modprobe.d/iriunwebcam-options.conf
  A continuación comenta todo lo que hay dentro con #.
  
  Modifica el archivo de configuración que creamos anteriormente con sudo nano /etc/modprobe.d/virtualcams.conf para que quede de la siguiente manera:
  options v4l2loopback devices=4 video_nr=0,10,11,12 card_label="Iriun Webcam",Virtual10,Virtual11,Virtual12 exclusive_caps=1,1,1,1