Ir al contenido principal
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 Intel

Este tutorial te guía para configurar la aceleración por hardware completa en GPUs integradas Intel y GPUs discretas ARC mediante QSV y VA-API. Si estás en macOS, usa mejor VideoToolbox.

Métodos de aceleración​

La transcodificación acelerada por hardware es compatible con la mayoría de GPUs Intel.

En Windows, QSV es el único método disponible.

En Linux hay dos métodos:

  • QSV - Preferible en GPUs estándar, para mejor rendimiento

  • VA-API - Requerido por GPUs heredadas anteriores a Broadwell, para compatibilidad

nota

VA-API en Linux soporta casi todas las GPUs Intel.

Las plataformas compatibles con QSV en Linux se limitan a Broadwell (5ª generación Core) y posteriores.

La interfaz QSV proporcionada por Intel OneVPL / MediaSDK es una implementación de alto nivel basada en VA-API para Linux y DXVA/D3D11VA para Windows, que ofrece mejor rendimiento y más opciones de ajuste en plataformas compatibles.

QSV puede usarse junto con VA-API y DXVA/D3D11VA para una canalización de transcodificación híbrida más flexible.

precaución

Las generaciones ICL (Ice Lake), JSL (Jasper Lake), EHL (Elkhart Lake) y anteriores están perdiendo soporte para QSV en Linux, ya que el entorno de ejecución MediaSDK ha sido descontinuado por Intel, y podría dejar de funcionar en unos años, momento en el que deberás cambiar a VA-API. Usa hardware más nuevo si estás adquiriendo equipos.

Consulta el aviso de descontinuación y el soporte para plataformas heredadas para más información.

nota

  • A diferencia de NVIDIA NVENC, no hay límite de sesiones de codificación simultáneas en iGPU Intel ni dGPU ARC.

  • QSV y VA-API admiten 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 tono acelerado por hardware de HDR/DV a SDR es compatible con todas las GPUs Intel que tengan decodificación HEVC 10-bit.

Hay dos métodos diferentes que pueden usarse en Windows y/o Linux. Pros y contras se listan a continuación:

  1. OpenCL

    • Pros - Soporta Dolby Vision P5, opciones detalladas de ajuste, hardware ampliamente compatible.

    • Contras - El entorno de ejecución OpenCL a veces requiere instalación manual en Linux.

  2. QSV VPP

    • Pros - Menor consumo energético, realizado mediante hardware LUT de función fija de Intel.

    • Contras - Opciones limitadas de ajuste, modelos de GPU compatibles restringidos, actualmente solo disponible en Linux.

nota

La opción Prefer OS native DXVA or VA-API hardware decoders alterna entre los decodificadores nativos y los QSV. El soporte para Dolby Vision requiere que esta opción esté marcada.

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

No uses modelos de procesadores Intel que terminen en "F" - esos no tienen GPU integrada.

El soporte para Quick Sync Video puede verificarse en el sitio ark de Intel antes de comprar una nueva GPU adecuada para aceleración por hardware.

Transcodificar H.264​

AVC / H.264 8-bit sigue siendo ampliamente usado por su excelente compatibilidad. Todas las GPUs Intel que soportan QSV pueden decodificarlo y codificarlo.

  • Decodificación & Codificación H.264 8-bit - Cualquier GPU Intel que soporte Quick Sync Video (QSV)

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 de Intel no son la excepción:

  • Decodificación y codificación HEVC 8-bit - Gen 9 Skylake (6ª Gen Core) y posteriores

  • Decodificación y codificación HEVC 10-bit - Gen 9.5 Kaby Lake (7ª Gen Core), Apollo Lake, Gemini Lake (Pentium y Celeron) y posteriores

nota

Ten en cuenta que la 6ª Gen Core con iGPU HD 5xx carece de soporte para 10-bit. Se recomienda elegir procesadores de 7ª generación y posteriores, que generalmente incluyen iGPU de la serie HD / UHD 6xx.

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.

Intel incorporó soporte para aceleración AV1 en sus GPU más recientes:

  • Decodificación AV1 8/10-bit - Gen 12 Tiger Lake (11ª Gen Core) y posteriores

  • Codificación AV1 8/10-bit - Gen 12.5 DG2 / ARC A-series, Gen 12.7 Meteor Lake (14ª Gen Core Mobile / 1ª Gen Core Ultra) y posteriores

nota

Ten en cuenta que los procesadores Jasper Lake y Elkhart Lake son Pentium/Celeron/Atom de 10ª generación que no incluyen aceleración AV1.

Transcodificar otros códecs​

Consulte estos enlaces:

Velocidad y calidad​

Intel mejora la velocidad y calidad de video de sus codificadores de función fija en cada generación de arquitecturas gráficas.

Pueden clasificarse en 4 niveles según su rendimiento:

  • Entry-Level - HD / UHD 600, 605 y 61x

    consejo

    Estas iGPU suelen encontrarse en mini PC o NAS. Pueden transcodificar HEVC 10-bit y aplicar filtros de mapeo de tono. Aunque tienen limitaciones de rendimiento y potencia, son adecuadas para uso personal.

  • Mainstream - HD / UHD 620, 630, Iris 640, 655 y gráficos Gen 11

    consejo

    Estas iGPU ofrecen mayor potencia de cálculo que las de nivel básico, permitiendo múltiples transcodificaciones simultáneas de 4K HDR HEVC 10-bit. Nota: los gráficos Gen 11 tienen calidad de codificador ligeramente mejorada respecto a Gen 9.

  • Alto Rendimiento - Serie UHD 7xx e Iris Xe graphics

    consejo

    Estas GPU utilizan la arquitectura Gen 12 XeLP con decodificación hardware AV1, mejorando significativamente la calidad de video y velocidad. Modelos como la UHD 770 e Iris Xe cuentan con un segundo motor de video MFX, lo que mejora sus capacidades de transcodificación concurrente.

  • Hardcore - GPU discretos e integrados ARC serie A y B

    consejo

    Las GPU de la serie ARC A utilizan la arquitectura Gen 12.5 XeHPG, que continúa mejorando sobre la base de XeLP, y admite codificación hardware AV1 y mejoras en codificación H.264 y HEVC. Esto las hace competitivas con el preset medio de los codificadores software x264 y x265. Todos los modelos de GPU ARC serie A vienen con dos motores de video MFX. La calidad de codificación en la serie ARC B es similar a su predecesora, pero con velocidades de codificación ligeramente mejoradas.

OneVPL y MediaSDK​

OneVPL es una nueva implementación de QSV para reemplazar MediaSDK. Ambos proporcionan el entorno de ejecución Quick Sync Video (QSV).

Intel admite OneVPL en gráficos Gen 12+ (procesadores de 11ª generación Core y posteriores, es decir, Tiger Lake y Rocket Lake).

nota

  • La diferencia más notable es que OneVPL admite el nuevo codificador hardware AV1 en GPU ARC.

  • FFmpeg 6.0 habilita OneVPL. Este proceso es transparente para los usuarios finales.

Soporte para GPU ARC​

El servidor Jellyfin admite GPU discretos Intel ARC Alchemist/serie A en Windows y Linux 6.2+. Para usar GPU discretos ARC Battlemage/serie B en Linux, se requiere la versión de kernel 6.12+. Windows también es compatible, solo instala el controlador de la GPU.

Solo necesitas seguir las Configuraciones de Windows y Configuraciones de Linux para configurarlo y verificarlo.

consejo

  • Resizable-BAR es obligatorio únicamente para la aceleración hardware en tarjetas ARC serie B, o el controlador multimedia hará fallar el transcodificador. Para tarjetas ARC serie A, el controlador multimedia puede tolerar no tenerlo habilitado, pero también se recomienda habilitar Resizable-BAR si el procesador, la placa base y la BIOS lo admiten, para lograr el mejor rendimiento.

  • ASPM debe habilitarse en la BIOS si es compatible. Esto reduce considerablemente el consumo de energía en reposo de la GPU ARC.

  • La codificación de bajo consumo se utiliza por defecto en GPU ARC. El firmware GuC y HuC puede faltar en distribuciones antiguas, es posible que necesites descargarlo manualmente del repositorio de firmware del kernel.

  • Las configuraciones antiguas de compilación del kernel podrían no tener habilitados los módulos MEI, que son necesarios para usar GPU ARC en Linux.

  • A partir de las GPU discretas ARC Battlemage/serie B, Intel ha habilitado el controlador del kernel xe por defecto en las nuevas GPU (arquitecturas Xe-2 y posteriores) para reemplazar al antiguo controlador del kernel i915. La codificación de bajo consumo y los firmware GuC y HuC se habilitan automáticamente, y los usuarios no deben referirse a configuraciones como i915.enable_guc=xxx, que ya no son relevantes.

Configuraciones en Windows​

Se recomienda Windows 10 64-bit o superior. QSV no está disponible en Docker para Windows ni WSL/WSL2.

Problemas y limitaciones conocidos en Windows​

Consulta esta sección para ver problemas y limitaciones conocidos

Configurar en host Windows​

  1. Elimina el controlador antiguo con DDU si actualizaste desde un procesador Intel anterior a la 6ª generación sin reinstalación limpia.

  2. Instala limpio el último controlador EXE o INF del centro de descargas de Intel.

  3. Evita que la GPU sea ocupada por sesiones de Escritorio remoto de Windows.

    • Escribe gpedit.msc en el cuadro de diálogo de teclas rápidas Win+R y ejecútalo para abrir el "Editor de directivas de grupo local".

    • Navega en el árbol izquierdo [Configuración del equipo > Plantillas administrativas > Componentes de Windows]

    • Busca aquí [Servicios de Escritorio remoto > Host de sesión de Escritorio remoto > Entorno de sesión remota]

    • En el lado derecho, haz doble clic en [Usar adaptadores de gráficos de hardware para todas las sesiones de Servicios de Escritorio remoto]

    • Establece [Deshabilitado] en la ventana emergente y haz clic en [Aceptar], luego reinicia el sistema.

    Configuración de GPU para escritorio remoto

  4. Activa QSV en Jellyfin y desmarca los códecs no compatibles.

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 como se muestra:

    nota

    Los nombres duplicados de motores indican que la GPU puede tener múltiples motores de video MFX.

    • 3D - Motor 2D/3D, carga de trabajo QSV VPP o GPGPU

    • Copy - Carga de trabajo del motor Blitter/Copia

    • Video Decode - Carga de trabajo del decodificador o codificador QSV

    • Video Processing - Carga de trabajo del procesador QSV VPP

    • Compute - Carga de trabajo GPGPU o QSV VPP (solo disponible en ARC / DG2+)

    Verificar Intel en Windows

Configuraciones para Linux​

Se requiere una distribución Linux de 64 bits. La GPU compatible varía según versiones del kernel y firmware.

Problemas conocidos y limitaciones en Linux​

Consulta esta sección para ver problemas y limitaciones conocidos

Configurar en host Linux​

Debian y Ubuntu Linux​

El paquete deb jellyfin-ffmpeg* incluye todos los controladores de medios Intel necesarios excepto OpenCL (ver más abajo).

nota

Se requieren permisos de root.

  1. Si ya agregaste el repositorio jellyfin a tus fuentes apt e instalaste jellyfin-server y jellyfin-web, y prefieres usar ffmpeg vanilla en lugar de jellyfin-ffmpeg, instala estos paquetes Intel.

    nota

    En Debian, deberás agregar "non-free" a tu configuración apt.

  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. Asegúrate de que exista al menos un dispositivo renderD* en /dev/dri. De lo contrario, actualiza tu kernel o habilita la iGPU en la BIOS.

    nota

    Observa los permisos y el grupo que tiene acceso de escritura, en este caso es render:

    $ ls -l /dev/dri

    total 0
    drwxr-xr-x  2 root root        120 Mar  5 05:15 by-path
    crw-rw----+ 1 root video  226,   0 Mar  5 05:15 card0
    crw-rw----+ 1 root video  226,   1 Mar  5 05:15 card1
    crw-rw----+ 1 root render 226, 128 Mar  5 05:15 renderD128
    crw-rw----+ 1 root render 226, 129 Mar  5 05:15 renderD129

  4. Agrega el usuario jellyfin al grupo render, luego reinicia el servicio de jellyfin:

    nota

    En algunas versiones, el grupo podría ser video o input en lugar de render.

    sudo usermod -aG render jellyfin
    sudo systemctl restart jellyfin

  5. Verifica la versión de intel-opencl-icd que ofrece tu distribución Linux:

    nota

    Este paquete podría no estar disponible en distribuciones recientes debido a que actualmente depende de LLVM 14, que puede faltar en versiones como Debian Trixie. En tal caso, puedes usar una versión del repositorio Intel compute-runtime.

    $ apt policy intel-opencl-icd

    intel-opencl-icd:
      Installed: (none)
      Candidate: 22.14.22890-1
    ...

  6. Si la versión es más reciente que 22.xx.xxxxx, simplemente instálala. Para los productos más recientes como N95/N100 y Arc A380, el soporte se proporciona en 23.xx.xxxxx y versiones posteriores. De lo contrario, instala desde el repositorio Intel compute-runtime.

    sudo apt install -y intel-opencl-icd

  7. Comprueba los códecs QSV/VA-API compatibles:

    nota

    • iHD driver indica soporte para interfaces QSV y VA-API.

    • i965 driver indica solo soporte para interfaz VA-API, que debe usarse solo en plataformas anteriores a Broadwell.

    sudo /usr/lib/jellyfin-ffmpeg/vainfo --display drm --device /dev/dri/renderD128

    libva info: VA-API version 1.17.0
    libva info: Trying to open /usr/lib/jellyfin-ffmpeg/lib/dri/iHD_drv_video.so
    libva info: Found init function __vaDriverInit_1_17
    libva info: va_openDriver() returns 0
    Trying display: drm
    vainfo: VA-API version: 1.17 (libva 2.17.0)
    vainfo: Driver version: Intel iHD driver for Intel(R) Gen Graphics - 23.1.2 (xxxxxxx)
    vainfo: Supported profile and entrypoints
    ...

  8. Comprueba el estado del entorno de ejecución de OpenCL:

    sudo /usr/lib/jellyfin-ffmpeg/ffmpeg -v verbose -init_hw_device vaapi=va:/dev/dri/renderD128 -init_hw_device opencl@va

    [AVHWDeviceContext @ 0x55cc8ac21a80] 0.0: Intel(R) OpenCL HD Graphics / Intel(R) Iris(R) Xe Graphics [0x9a49]
    [AVHWDeviceContext @ 0x55cc8ac21a80] Intel QSV to OpenCL mapping function found (clCreateFromVA_APIMediaSurfaceINTEL).
    [AVHWDeviceContext @ 0x55cc8ac21a80] Intel QSV in OpenCL acquire function found (clEnqueueAcquireVA_APIMediaSurfacesINTEL).
    [AVHWDeviceContext @ 0x55cc8ac21a80] Intel QSV in OpenCL release function found (clEnqueueReleaseVA_APIMediaSurfacesINTEL).
    ...

  9. Si deseas usar la segunda GPU, cambia renderD128 por renderD129 en el panel de control de Jellyfin.

  10. Activa QSV o VA-API 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 de Jellyfin Server. Asegúrate también de elegir el nombre en clave correcto consultando 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. Los controladores Intel de modo usuario y el entorno de ejecución OpenCL requieren instalación manual para habilitar QSV/VA-API:

  3. Verifica los códecs QSV/VA-API y el estado del entorno OpenCL:

    sudo pacman -Syu libva-utils
    sudo vainfo --display drm --device /dev/dri/renderD128
    sudo /usr/lib/jellyfin-ffmpeg/ffmpeg -v verbose -init_hw_device vaapi=va:/dev/dri/renderD128 -init_hw_device opencl@va

  4. Consulta las secciones restantes de Debian y Ubuntu Linux.

Otras distribuciones​

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

Pueden descargarse desde estos enlaces:

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 otros paquetes necesarios de controladores Intel y sus dependencias que contengan estas palabras clave:

  • Controlador Intel media - iHD

  • Controlador Intel vaapi - i965

  • Intel media SDK - MFX

  • Intel oneVPL-intel-gpu - VPL

  • Entorno de ejecución Intel compute - OpenCL

Configurar con virtualización en Linux​

Docker oficial​

La imagen oficial de Docker incluye todos los controladores Intel media en modo usuario y el entorno de ejecución OpenCL necesarios.

Solo debe pasar el ID del grupo render del host a Docker y ajustar las configuraciones según sus necesidades.

  1. Consulta el ID del grupo render en el sistema anfitrión y úsalo en la CLI de Docker o archivo docker-compose:

    En algunas versiones, el grupo podría ser video o input en lugar de render.

    getent group render | cut -d: -f3

  2. Usa 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 \
       --group-add="122" \ # Change this to match your "render" host group id and remove this comment
       --net=host \
       --restart=unless-stopped \
       --device /dev/dri/renderD128:/dev/dri/renderD128 \
       jellyfin/jellyfin

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

      services:
        jellyfin:
          image: jellyfin/jellyfin
          user: 1000:1000
          group_add:
            - '122' # Change this to match your "render" host group id and remove this comment
          network_mode: 'host'
          volumes:
            - /path/to/config:/config
            - /path/to/cache:/cache
            - /path/to/media:/media
          devices:
            - /dev/dri/renderD128:/dev/dri/renderD128

  3. Si desea usar la segunda GPU del sistema, cambie renderD128 por renderD129.

  4. Para probar compilaciones inestables, cambie jellyfin/jellyfin por jellyfin/jellyfin:unstable bajo su propio riesgo.

  5. Verifica los códecs QSV y VA-API:

    docker exec -it jellyfin /usr/lib/jellyfin-ffmpeg/vainfo

  6. Comprueba el estado del runtime OpenCL:

    docker exec -it jellyfin /usr/lib/jellyfin-ffmpeg/ffmpeg -v verbose -init_hw_device vaapi=va -init_hw_device opencl@va

  7. Habilita QSV o VA-API en Jellyfin y desmarca los códecs no compatibles.

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.

Kubernetes​

Sigue los mismos principios que para Docker, con un pequeño cambio: tu contenedor dentro del pod debe ejecutarse como privilegiado.

Los dispositivos en Kubernetes se añaden como montajes de ruta de host, no se separan en volúmenes independientes como en el ejemplo de Docker.

  1. Ejemplo de archivo de configuración de Kubernetes (versión API 1) en YAML:

    # Example of an incomplete deployment spec
    apiVersion: apps/v1
    kind: Deployment
    metadata: ...
    spec:
      template:
        metadata: ...
        spec:
          securityContext:
            runAsUser: 1000 # Similar to "user: 1000:1000" on Docker
            runAsGroup: 1000
            supplementalGroups:
              - 122 # Change this to match your "render" host group id and remove this comment
          containers:
            - name: 'jellyfin'
              image: ...
              ports: ...
              env: ...
              securityContext:
                privileged: true # Container must run as privileged inside of the pod
              volumeMounts:
                - name: 'render-device'
                  mountPath: '/dev/dri/renderD128'
          volumes:
            - name: 'render-device'
              hostPath:
                path: '/dev/dri/renderD128'

  2. Cuando el pod se inicie, puedes verificar los códecs QSV y VA-API.

    Si aparece error: failed to initialize display, verifica que los supplementalGroups sean correctos.

    kubectl exec <JELLYFIN_POD_NAME> -- /usr/lib/jellyfin-ffmpeg/vainfo

  3. Activa QSV o VA-API en Jellyfin y desmarca los códecs no compatibles.

Contenedores LXC y LXD​

precaución

Esto se ha probado con LXC 3.0 y puede o no funcionar con versiones anteriores.

  1. Consulta el ID del grupo render en el sistema anfitrión.

    nota

    En algunas distribuciones, el grupo podría ser video o input en lugar de render.

    getent group render | cut -d: -f3

  2. Instala los controladores necesarios en el sistema anfitrión.

  3. Añade tu GPU al contenedor:

    lxc config device add <CONTAINER_NAME> gpu gpu gid=<GID_OF_HOST_RENDER_GROUP>

  4. Verifica que tengas los dispositivos requeridos dentro del contenedor:

    $ lxc exec jellyfin -- ls -l /dev/dri

    total 0
    crw-rw---- 1 root video 226,   0 Jun  4 02:13 card0
    crw-rw---- 1 root video 226,   0 Jun  4 02:13 controlD64
    crw-rw---- 1 root video 226, 128 Jun  4 02:13 renderD128

  5. Configura Jellyfin para usar aceleración QSV o VA-API y cambia la GPU predeterminada renderD128 si es necesario.

LXC en Proxmox​

  1. Asegúrate de que tu GPU esté disponible como dispositivo de renderizado DRI en el host Proxmox, p. ej. /dev/dri/renderD128. Si no, instala los controladores necesarios en el host.

  2. Proxmox VE 8 o más reciente:

    Configura un Device Passthrough para el dispositivo de renderizado en la sección Resources de la interfaz web. Asegúrate de establecer el GID correcto en las opciones avanzadas del diálogo, ej. 989 para el grupo render. Los GIDs pueden consultarse en /etc/group dentro del LXC.

    nota

    Debes iniciar sesión como root. Otras cuentas de administrador no pueden realizar esta acción.

    Proxmox VE 7 o anteriores:

    nota

    • Jellyfin debe ejecutarse en un contenedor LXC privilegiado.

    • Un contenedor no privilegiado existente puede convertirse en privilegiado haciendo un backup y restaurándolo como privilegiado.

    Añade tu GPU al contenedor editando /etc/pve/lxc/<CONTAINER_ID>.conf.

    Es posible que necesites cambiar los GIDs en los ejemplos siguientes para que coincidan con los de tu host.

    precaución

    Esto se ha probado en Proxmox VE 7.1 - en versiones anteriores quizá debas cambiar cgroup2 por cgroup.

    lxc.cgroup2.devices.allow: c 226:0 rwm
    lxc.cgroup2.devices.allow: c 226:128 rwm
    lxc.mount.entry: /dev/dri/renderD128 dev/dri/renderD128 none bind,optional,create=file

  3. Reinicia tu contenedor e instala los controladores necesarios en tu contenedor.

  4. Agrega el usuario jellyfin al grupo que elegiste en el Paso 2, es decir, el grupo que posee el dispositivo de renderizado DRI dentro del LXC.

  5. Configura Jellyfin para usar aceleración QSV o VA-API y cambia la GPU predeterminada renderD128 si es necesario.

Verificar en Linux​

nota

Se requieren permisos de root.

  1. Instala el paquete intel-gpu-tools en el sistema anfitrión, utilizado para depurar el controlador gráfico Intel en Linux. El nombre varía según la distribución:

    • En Debian y Ubuntu:

      sudo apt update && sudo apt install -y intel-gpu-tools

    • En Arch Linux:

      sudo pacman -Syu intel-gpu-tools

  2. Reproduce un video en el cliente web de Jellyfin y activa la transcodificación configurando una resolución o bitrate más bajos.

  3. Usa el comando intel_gpu_top para verificar la ocupación de los motores como sigue:

    nota

    Nombres duplicados de motores indican que la GPU podría tener múltiples motores de video MFX.

    • Render/3D - Motor 2D/3D, carga de trabajo QSV VPP o GPGPU
    • Blitter - Carga de motor Blitter/Copy
    • Video - Carga de trabajo de decodificador o codificador QSV
    • VideoEnhance - Carga de procesador QSV VPP
    • Compute - Carga GPGPU o QSV VPP (solo disponible en ARC / DG2+)
    sudo intel_gpu_top

    intel-gpu-top: Intel Tigerlake (Gen12) @ /dev/dri/card0 -   86/ 349 MHz;  54% RC6
            441 irqs/s

             ENGINES     BUSY                                                MI_SEMA MI_WAIT
           Render/3D   19.86% |████████▊                                   |      0%      0%
             Blitter    0.00% |                                            |      0%      0%
               Video    2.17% |█                                           |      0%      0%
        VideoEnhance    3.52% |█▋                                          |      0%      0%

       PID              NAME    Render/3D        Blitter          Video        VideoEnhance
    ...

Codificación de Bajo Consumo​

Los codificadores de video Intel en gráficos Gen 9+ admiten dos modos:

  • Codificación de bajo consumo / LP (VDEnc + HuC)

  • Codificación no de bajo consumo / LP (PAK + kernel multimedia + VME)

La codificación de bajo consumo puede reducir el uso de la GPU con ayuda del firmware HuC.

Esto puede ser útil para acelerar el mapeo de tono HDR/DV basado en OpenCL.

consejo

Más detalles técnicos sobre hardware de video Intel están disponibles en el repositorio del controlador multimedia.

Soporte de Hardware para Modo LP​

nota

Gen X se refiere a la arquitectura gráfica de Intel y no a la generación del procesador. (ej. gráficos Gen 9 ≠ procesadores de 9ª generación)

  • Gráficos Gen 9.x SKL+ - Admiten codificación no-LP y LP (solo H.264)

  • Gráficos Gen 11 ICL - Admiten ambos modos

  • Gráficos Gen 11 JSL/EHL - Solo admiten modo LP

  • Gráficos Gen 12 TGL/DG1+ - Admiten ambos modos

  • DG2/ARC A-Series (Gen 12.5) - Solo admiten modo LP

  • MTL/ARL (Gen 12.7), LNL/BMG (Gen 13 o 20?) y posteriores - Solo admiten modo LP

Soporte de Sistema para Modo LP​

  • Windows admite ambos modos por defecto. No requiere configuración adicional.

  • Linux admite ambos modos solo en Gen 12 ADL+ por defecto.

    En plataformas anteriores, el modo LP puede configurarse manualmente pasando un parámetro al controlador de kernel i915.

Configurar y verificar el modo LP en Linux​

:::precaución

Esta configuración solo es necesaria si estás usando un procesador Intel Jasper Lake o Elkhart Lake, o deseas mayor velocidad en el mapeo de tonos OpenCL en Linux.

:::

nota

Se requieren permisos de root.

  1. Instala los últimos paquetes de firmware de Linux en el sistema anfitrión. El nombre varía según la distribución:

    • En Debian:

      sudo apt update && sudo apt install -y firmware-linux-nonfree

    • En Ubuntu:

      sudo apt update && sudo apt install -y linux-firmware

    • En Arch Linux:

      sudo pacman -Syu linux-firmware

    • Descarga firmwares directamente del repositorio Linux:

      cd ~/
      git clone --depth=1 https://git.kernel.org/pub/scm/linux/kernel/git/firmware/linux-firmware.git
      sudo mkdir -p /usr/lib/firmware
      sudo cp -r linux-firmware/i915 linux-firmware/xe /usr/lib/firmware

  2. Añade el parámetro de kernel i915 requerido en el sistema anfitrión para habilitar la carga de firmware GuC y HuC:

    • Verifica el módulo de kernel en uso; pasa al paso 3 si el controlador xe está activo.
    nota

    ARC Battlemage/B-series, Core Ultra 200V-series (Lunar Lake) y GPUs más nuevas (arquitecturas Xe-2 y posteriores) usan el controlador xe en lugar de i915. Este paso no aplica.

    lspci -knn | grep -E "i915|xe|VGA|Display"

    00:02.0 Display controller [0380]: Intel Corporation Alder Lake-P GT2 [Iris Xe Graphics] [8086:46a6] (rev 0c)
            Kernel driver in use: i915
            Kernel modules: i915, xe
    03:00.0 VGA compatible controller [0300]: Intel Corporation DG1 [Iris Xe MAX Graphics] [8086:4905] (rev 01)
            Kernel driver in use: i915
            Kernel modules: i915, xe
    • Habilita carga de firmware HuC por GuC en el controlador i915:
    nota

    DG1, 12ª (ADL-P), 13ª, 14ª generación y GPUs ARC Alchemist/A-series tienen enable_guc=3 habilitado por defecto. Omite este paso en estas GPUs, de lo contrario desactivarás funciones habilitadas por defecto.

    sudo mkdir -p /etc/modprobe.d
    sudo sh -c "echo 'options i915 enable_guc=2' >> /etc/modprobe.d/i915.conf"

  3. Actualiza el initramfs y grub. Los comandos varían según la distribución.

    • En Debian y Ubuntu:

      sudo update-initramfs -u && sudo update-grub

    • En Arch Linux:

      sudo mkinitcpio -P && sudo update-grub

  4. Reinicia el sistema y verifica el estado de GuC y HuC con los siguientes comandos. Asegúrate de que no haya FAIL o ERROR en las salidas.

    sudo reboot
    sudo dmesg | grep -E "i915|xe"
    sudo sh -c "cat /sys/kernel/debug/dri/0/gt*/uc/guc_info"
    sudo sh -c "cat /sys/kernel/debug/dri/0/gt*/uc/huc_info"

    • Si obtienes un error No such file or directory al ejecutar los últimos dos comandos, intenta consultar un dispositivo dri con un número diferente, por ejemplo 1:

      sudo sh -c "cat /sys/kernel/debug/dri/1/gt*/uc/guc_info"
      sudo sh -c "cat /sys/kernel/debug/dri/1/gt*/uc/huc_info"

    • En kernels muy antiguos (4.16-) los últimos dos comandos pueden ser así:

      sudo cat /sys/kernel/debug/dri/0/i915_guc_load_status
      sudo cat /sys/kernel/debug/dri/0/i915_huc_load_status

  5. Ahora puedes habilitar de forma segura el codificador de bajo consumo de Intel en el panel de Jellyfin.

consejo

Lecturas extendidas para más distribuciones: