Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Tutorial de aceleración por hardware en GPU NVIDIA

Este tutorial te guía en la configuración de la aceleración por hardware completa para video en GPU NVIDIA mediante NVENC.

Métodos de aceleración

La transcodificación acelerada por hardware es compatible con las GPU NVIDIA desde la arquitectura Maxwell.

En Windows y Linux, NVENC es el único método disponible.

NVENC/NVDEC son las API de códecs de video propietarias de las GPU NVIDIA, que pueden usarse con CUDA para lograr una aceleración por hardware completa.

Consulta esta sección para conocer los problemas y limitaciones conocidos.

nota

NVENC admite servidores sin monitor en Windows y Linux, lo que significa que no se requiere un monitor conectado.

Métodos de mapeo de tono

El mapeo de tonos HDR/DV a SDR acelerado por hardware es compatible con todas las GPU NVIDIA que tengan decodificación HEVC de 10 bits.

En Windows y Linux, CUDA es el único método de mapeo de tonos disponible. También admite Dolby Vision P5 y zero-copy.

nota

La función Enable enhanced NVDEC decoder alterna entre los procesos de decodificación más nuevos de NVDEC y los más antiguos de CUVID. El soporte para Dolby Vision requiere que esta opción esté marcada para habilitar NVDEC.

Seleccionar hardware GPU

Para principiantes, consulta la Guía de selección de hardware para consejos de selección. Usuarios avanzados, continúen leyendo esta sección.

precaución

La mayoría de las GPU NVIDIA incluyen soporte para NVENC/NVDEC, pero algunos modelos de gama baja y móviles (ej. GT1030 y MX450) son excepciones.

El soporte de códecs de video puede verificarse mediante la Matriz de soporte de códecs de GPU NVIDIA antes de adquirir una GPU adecuada para aceleración por hardware.

Transcodificar H.264

AVC / H.264 de 8 bits sigue siendo ampliamente utilizado debido a su excelente compatibilidad. Todas las GPU NVIDIA que admiten NVENC/NVDEC pueden decodificarlo y/o codificarlo.

• Decodificación y codificación de H.264 de 8 bits - Cualquier GPU NVIDIA que admita NVENC/NVDEC

Transcodificar HEVC

HEVC / H.265 sigue siendo la primera opción para almacenar video en 4K a 10 bits, HDR y Dolby Vision. Cuenta con soporte de codificación por software maduro gracias a x265, además de amplia implementación de codificación por hardware en la mayoría de GPUs lanzadas después de 2016.

Las GPU Maxwell+ brindan soporte para HEVC:

• Decodificación y codificación de HEVC de 8 bits - Maxwell 2da Gen (GM206) y más recientes

• Decodificación de HEVC de 10 bits - Maxwell 2da Gen (GM206) y más recientes

• Codificación de HEVC de 10 bits - Pascal y más recientes

nota

Ten en cuenta que en la serie Maxwell 2da Gen, solo las variantes GM206 ofrecen soporte para decodificación HEVC de 10 bits. Su sucesor Pascal tiene soporte completo para HEVC de 10 bits y mejoras en velocidad y calidad.

Transcodificación AV1

AV1 es un códec de video libre de regalías y preparado para el futuro. Ahorra considerable espacio de almacenamiento y ancho de banda de red gracias a su menor tamaño de archivo. La desventaja es que la decodificación y codificación son muy exigentes para la CPU. La aceleración por hardware permite transcodificar flujos AV1 en tiempo real. La codificación AV1 es compatible en Jellyfin 10.9 y versiones posteriores.

NVIDIA agregó soporte para aceleración AV1 en sus GPU más recientes:

• Decodificación de AV1 de 8/10 bits - Ampere y más recientes

• Codificación de AV1 de 8/10 bits - Ada Lovelace y más recientes

Transcodificar otros códecs

Consulte estos enlaces:

• Matriz de soporte de códecs de GPU NVIDIA

• Calculadora de transcodificación por hardware de NVIDIA

Velocidad y calidad

Calidad de codificación:

• H.264 y HEVC - Blackwell/Ada/Ampere/Turing > Turing TU117/Volta/Pascal > Maxwell

• AV1 - Solo Ada Lovelace y Blackwell

Velocidad de decodificación y codificación dentro de la misma generación:

• Modelos con múltiples NVENC/NVDEC > Modelos con un solo NVENC/NVDEC

• Modelos con alta frecuencia de reloj GPU > Modelos con baja frecuencia de reloj GPU

• Modelos con alto ancho de banda de memoria > Modelos con bajo ancho de banda de memoria

Tablas de rendimiento NVENC/NVDEC:

• Rendimiento NVENC - Documentación NVIDIA

• Rendimiento NVDEC - Documentación NVIDIA

Configuraciones en Windows

Se recomienda Windows 10 de 64 bits o superior. En Jellyfin 10.10, la versión mínima requerida del controlador NVIDIA es 522.25.

Configurar en host Windows

1. Elimina el controlador antiguo con DDU si actualizaste desde una GPU NVIDIA anterior a Maxwell sin hacer una instalación limpia.

2. Instala limpiamente el último controlador desde Descargas de controladores NVIDIA.

3. Activa NVENC en Jellyfin y desmarca los códecs no compatibles.

Configurar con virtualización en Windows

El controlador NVIDIA para Windows proporciona acceso a NVENC/NVDEC y CUDA en WSL2 y Docker para Windows.

Consulta Configurar en host Linux y Configurar con virtualización Linux.

Verificar en Windows

1. Reproduce un video en el cliente web de Jellyfin y fuerza la transcodificación reduciendo la resolución o tasa de bits.

2. Abre el "Administrador de tareas" y navega a la pestaña de GPU.

3. Verifica la ocupación de los motores de la siguiente manera:

   • 3D - Motor 2D/3D o carga de trabajo CUDA/GPGPU

   • Copy - Carga de trabajo del motor Blitter/Copia

   • Video Decode - Carga de trabajo del decodificador de video

   • Video Encode - Carga de trabajo del codificador de video

   • Cuda - Carga de trabajo CUDA/GPGPU

   

Configuraciones para Linux

Se requiere una distribución Linux de 64 bits. En Jellyfin 10.10, la versión mínima requerida del controlador NVIDIA es 520.56.06.

Configurar en host Linux

Debian y Ubuntu Linux

El paquete deb jellyfin-ffmpeg* requerido por Jellyfin no incluye ningún controlador propietario de NVIDIA.

Debes instalar el controlador NVIDIA desde la distribución y configurar los permisos del usuario jellyfin.

nota

Se requieren permisos de root.

1. Suponiendo que has agregado el repositorio de Jellyfin a tus fuentes apt e instalado jellyfin-server y jellyfin-web.

2. Instala el paquete jellyfin-ffmpeg7. Elimina el paquete meta jellyfin obsoleto si causa conflictos:

   sudo apt update && sudo apt install -y jellyfin-ffmpeg7

3. Instala el controlador propietario de NVIDIA siguiendo estos enlaces. Luego instala dos paquetes adicionales para soporte NVENC y NVDEC:

   • En Debian: https://wiki.debian.org/NvidiaGraphicsDrivers

     sudo apt update && sudo apt install -y libnvcuvid1 libnvidia-encode1

   • En Ubuntu: https://ubuntu.com/server/docs/nvidia-drivers-installation

     nota

     Es posible que necesites agregar la versión del controlador como sufijo del nombre del paquete.

     sudo apt update && sudo apt install -y libnvidia-decode libnvidia-encode

4. Verifica el estado de la GPU NVIDIA usando nvidia-smi:

   $ nvidia-smi
   
   +-----------------------------------------------------------------------------+
   | NVIDIA-SMI 520.56.06    Driver Version: 520.56.06    CUDA Version: 11.8     |
   |-------------------------------+----------------------+----------------------+
   | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
   | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
   |                               |                      |               MIG M. |
   |===============================+======================+======================|
   |   0  NVIDIA GeForce ...  Off  | 00000000:1C:00.0 Off |                  N/A |
   |  0%   44C    P0    N/A /  75W |      0MiB /  1998MiB |      0%      Default |
   |                               |                      |                  N/A |
   +-------------------------------+----------------------+----------------------+
   ...

5. Habilita NVENC en Jellyfin y desmarca los códecs no compatibles.

Linux Mint

Linux Mint utiliza Ubuntu como base para sus paquetes.

Puedes seguir los pasos de configuración de Debian y Ubuntu Linux pero instala manualmente todos los paquetes de Jellyfin jellyfin-server, jellyfin-web y jellyfin-ffmpeg7 desde la página de lanzamientos del servidor Jellyfin. Asegúrate también de elegir el nombre de código correcto siguiendo los mapas de versiones oficiales.

Arch Linux

nota

Se requieren permisos de root.

1. Instala el paquete jellyfin-ffmpeg de Archlinux/extra:

   sudo pacman -Syu jellyfin-ffmpeg

2. Instala el controlador propietario de NVIDIA siguiendo el enlace. Luego instala un paquete adicional para soporte NVENC y NVDEC:

   • https://wiki.archlinux.org/title/NVIDIA#Installation

   sudo pacman -Syu nvidia-utils

3. Verifica el estado de la GPU NVIDIA usando nvidia-smi:

   nvidia-smi

4. Habilita NVENC en Jellyfin y desmarca los códecs no compatibles.

Otras distribuciones

Proporcionamos binarios portables de jellyfin-ffmpeg para distribuciones sin mantenedor regular.

Pueden descargarse desde estos enlaces:

• Repositorio de Jellyfin

• Lanzamientos · jellyfin/jellyfin-ffmpeg · GitHub

nota

Requisitos mínimos de versiones para glibc y Linux:

• x86_64 / amd64 - glibc >= 2.28, Linux >= 4.18 (mayoría de distros lanzadas en 2018 o posteriores)

Extraiga e instálelo en la ruta correcta, luego ajuste la ruta de FFmpeg en el panel de Jellyfin para que coincida:

nota

Se requieren permisos de root.

cd ~/
mkdir -p jellyfin-ffmpeg
wget https://repo.jellyfin.org/releases/ffmpeg/<VERSION>/jellyfin-ffmpeg_<VERSION>_portable_linux64-gpl.tar.xz
tar -xvf jellyfin-ffmpeg_<VERSION>_portable_linux64-gpl.tar.xz -C jellyfin-ffmpeg
sudo mv jellyfin-ffmpeg /usr/lib
sudo ldd -v /usr/lib/jellyfin-ffmpeg/ffmpeg

Instala los paquetes de controladores propietarios de NVIDIA y sus dependencias que contengan estas palabras clave:

• NVIDIA NVDEC CUVID - DECODIFICACIÓN

• NVIDIA NVENC - CODIFICACIÓN

Configurar con virtualización en Linux

Docker oficial

La imagen oficial de Docker no incluye controladores propietarios de NVIDIA.

Debes instalar el controlador de NVIDIA y el NVIDIA Container Toolkit en el sistema anfitrión para permitir que Docker acceda a tu GPU.

nota

Se requieren permisos de root.

1. Instala el controlador propietario de NVIDIA en el sistema anfitrión. Consulta las instrucciones anteriores.

2. Instala NVIDIA Container Toolkit en el sistema host siguiendo este enlace:

   • https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html#installation-guide

3. Usa la línea de comandos de Docker o docker-compose:

   • Ejemplo de línea de comandos:

     docker run -d \
      --name=jellyfin \
      --volume /path/to/config:/config \
      --volume /path/to/cache:/cache \
      --volume /path/to/media:/media \
      --user 1000:1000 \
      --net=host \
      --restart=unless-stopped \
      --runtime=nvidia \
      --gpus all \
      jellyfin/jellyfin

   • Ejemplo de archivo de configuración docker-compose en YAML:

     services:
       jellyfin:
         image: jellyfin/jellyfin
         user: 1000:1000
         network_mode: 'host'
         volumes:
           - /path/to/config:/config
           - /path/to/cache:/cache
           - /path/to/media:/media
         runtime: nvidia
         deploy:
           resources:
             reservations:
               devices:
                 - driver: nvidia
                   count: all
                   capabilities: [gpu]

   nota

   Si encuentras el error de upstream CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected, pasa estos dispositivos adicionales a Docker:

   /dev/nvidia-caps:/dev/nvidia-caps
   /dev/nvidia0:/dev/nvidia0
   /dev/nvidiactl:/dev/nvidiactl
   /dev/nvidia-modeset:/dev/nvidia-modeset
   /dev/nvidia-uvm:/dev/nvidia-uvm
   /dev/nvidia-uvm-tools:/dev/nvidia-uvm-tools

4. Agrega tu usuario al grupo de video:

   sudo usermod -aG video $USER

5. Actualiza enlaces dinámicos y reinicia el servicio Docker:

   docker exec -it jellyfin ldconfig
   sudo systemctl restart docker

6. Verifica el estado de la GPU NVIDIA con nvidia-smi:

   docker exec -it jellyfin nvidia-smi

7. Para probar compilaciones inestables, cambia jellyfin/jellyfin por jellyfin/jellyfin:unstable bajo tu propio riesgo.

8. Habilita NVENC en Jellyfin y desmarca los códecs no admitidos.

nota

La imagen oficial de Docker de Jellyfin ya configura las variables de entorno necesarias para GPUs NVIDIA. Si creas tu propia imagen, añade estas variables adicionales en la configuración de Docker:

• NVIDIA_DRIVER_CAPABILITIES=all

• NVIDIA_VISIBLE_DEVICES=all

Docker de Linuxserver.io

Las imágenes Docker de LSIO son mantenidas por linuxserver.io. Consulta su documentación en GitHub - linuxserver/docker-jellyfin.

nota

Las rutas de las carpetas de configuración y datos de Jellyfin difieren entre las imágenes Docker oficiales y las de LSIO. Por lo tanto, no pueden intercambiarse fácilmente.

Podman

1. Agrega el repositorio CUDA a tu gestor de paquetes.

   Busca en el siguiente directorio el archivo de repositorio adecuado para tu distribución: Repositorios CUDA

   Instala el archivo de repositorio adecuado en tu gestor de paquetes. El método depende de tu gestor de paquetes y versión del SO. Reemplaza la URL del repositorio en los ejemplos siguientes con la adecuada para tu distribución.

   a. Fedora, RHEL, CentOS:

   sudo dnf config-manager addrepo --from-repofile=https://developer.download.nvidia.com/compute/cuda/repos/fedora42/$(uname -m)/cuda-fedora42.repo

   b. Debian, Ubuntu:

   echo "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin stable main" | sudo tee /etc/apt/sources.list.d/cuda-ubuntu2404.list

   sudo apt-get update

2. Instala los paquetes cuda-toolkit y nvidia-container-toolkit-base

   a. Fedora, RHEL, CentOS:

   sudo dnf install cuda-toolkit nvidia-container-toolkit-base

   b. Debian, Ubuntu:

   sudo apt-get install -y cuda-toolkit nvidia-container-toolkit-base

3. Genera un archivo de especificación CDI.

   sudo nvidia-ctk cdi generate --output=/etc/cdi/nvidia.yaml

   Consulta: Soporte para Container Device Interface — NVIDIA Container Toolkit

4. Adapta tu línea de comandos de podman o el archivo de contenedor systemd para usar el dispositivo: nvidia.com/gpu=0

   Por ejemplo, tu línea de comandos de podman debería verse ahora así:

   podman run \
    --detach \
    --label "io.containers.autoupdate=registry" \
    --name myjellyfin \
    --publish 8096:8096/tcp \
    --device nvidia.com/gpu=0 \
    # --security-opt label=disable # Only needed for older versions of container-selinux < 2.226
    --rm \
    --user $(id -u):$(id -g) \
    --userns keep-id \
    --environment=JELLYFIN_DATA_DIR=/var/lib/jellyfin
    --environment=JELLYFIN_CONFIG_DIR=/etc/jellyfin
    --environment=JELLYFIN_LOG_DIR=/var/log/jellyfin
    --environment=JELLYFIN_CACHE_DIR=/var/cache/jellyfin
    --volume=/your/path/to/data:/var/lib/jellyfin      # Replace paths with actual paths on your host's filesystem
    --volume=/your/path/to/config:/etc/jellyfin
    --volume=/your/path/to/logs:/var/log/jellyfin
    --volume=/your/path/to/cache:/var/cache/jellyfin
    --mount type=bind,source=/path/to/media,destination=/media,ro=true,relabel=private \
    docker.io/jellyfin/jellyfin:latest

   Systemd:

   [Unit]
   Description=jellyfin
   
   [Container]
   Image=docker.io/jellyfin/jellyfin:latest
   AutoUpdate=registry
   PublishPort=8096:8096/tcp
   UserNS=keep-id
   #SecurityLabelDisable=true # Only needed for older versions of container-selinux < 2.226
   AddDevice=nvidia.com/gpu=0
   Environment=JELLYFIN_DATA_DIR=/var/lib/jellyfin
   Environment=JELLYFIN_CONFIG_DIR=/etc/jellyfin
   Environment=JELLYFIN_LOG_DIR=/var/log/jellyfin
   Environment=JELLYFIN_CACHE_DIR=/var/cache/jellyfin
   Volume=/your/path/to/data:/var/lib/jellyfin      # Replace paths with actual paths on your host's filesystem
   Volume=/your/path/to/config:/etc/jellyfin
   Volume=/your/path/to/logs:/var/log/jellyfin
   Volume=/your/path/to/cache:/var/cache/jellyfin
   
   [Service]
   # Inform systemd of additional exit status
   SuccessExitStatus=0 143
   
   [Install]
   # Start by default on boot
   WantedBy=default.target

5. Crea la siguiente regla udev para asegurar que los dispositivos GPU se inicialicen antes de iniciar el contenedor.

   Guarda el siguiente archivo como /etc/udev/rules.d/nvidia.rules:

   ACTION=="add|bind", ATTR{vendor}=="0x10de", ATTR{class}=="0x03[0-9]*", \
       DRIVER=="nvidia", TEST!="/dev/nvidia-uvm", \
       RUN+="/usr/bin/nvidia-modprobe", \
       RUN+="/usr/bin/nvidia-modprobe -c0 -u", \
       RUN+="/usr/bin/nvidia-modprobe -m"

Otras Virtualizaciones

Otras virtualizaciones no están verificadas y pueden o no funcionar con GPU NVIDIA.

Consulta el Tutorial de HWA para GPU Intel - Configuración con Virtualización Linux para más información.

Verificar en Linux

1. Reproduce un video en el cliente web de Jellyfin y fuerza la transcodificación reduciendo la resolución o tasa de bits.

2. Utiliza el comando nvidia-smi para verificar la ocupación de la GPU NVIDIA y el uso de VRAM de cada proceso jellyfin-ffmpeg:

   $ nvidia-smi
   
   +-----------------------------------------------------------------------------+
   | NVIDIA-SMI 520.56.06    Driver Version: 520.56.06    CUDA Version: 11.8     |
   |-------------------------------+----------------------+----------------------+
   | GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
   | Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
   |                               |                      |               MIG M. |
   |===============================+======================+======================|
   |   0  NVIDIA GeForce ...  Off  | 00000000:1C:00.0 Off |                  N/A |
   | 43%   44C    P2    36W /  75W |    274MiB /  1998MiB |     68%      Default |
   |                               |                      |                  N/A |
   +-------------------------------+----------------------+----------------------+
   +-----------------------------------------------------------------------------+
   | Processes:                                                                  |
   |  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
   |        ID   ID                                                   Usage      |
   |=============================================================================|
   |    0   N/A  N/A      4024      G   /usr/lib/xorg/Xorg                 63MiB |
   |    0   N/A  N/A      5837      C   /usr/lib/jellyfin-ffmpeg/ffmpeg   195MiB |
   +-----------------------------------------------------------------------------+