# GPU AMD (VAAPI) pour Plex & Jellyfin en LXC Proxmox

Ce document décrit la configuration de la RX 6700 XT pour **Plex** (CT `20232400`) et **Jellyfin** (CT `20308096`) sous **Proxmox VE 8**, en conteneurs LXC **unprivileged**, avec transcodage matériel **VAAPI**.

---

## 1. Contexte

- **Host Proxmox**

  - Kernel : `6.8.12-16-pve`
  - GPU : **AMD Radeon RX 6700 XT (Navi 22)**, driver `amdgpu`
  - Devices exposés sur le host :
    ```bash
    ls -l /dev/dri
    # card0      -> GPU AMD
    # renderD128 -> node de rendu (VAAPI, ROCm, etc.)
    ```
- **Conteneurs concernés**

  - Plex : CT **`20232400`**, hostname `plex`
  - Jellyfin : CT **`20308096`**, hostname `jellyfin`
  - Les deux sont des LXC **unprivileged** créés via les **community-scripts** (Helper-Scripts).

Objectif :

> Donner accès au GPU via **/dev/dri** dans les deux LXC et activer le transcodage matériel VAAPI dans Plex & Jellyfin.

---

## 2. Configuration LXC côté Proxmox

### 2.1 Plex (CT 20232400) – `/etc/pve/lxc/20232400.conf`

Configuration **finale** (partie importante) :

```ini
# Plex LXC (Helper-Scripts)
arch: amd64
cmode: shell
cores: 12
features: keyctl=1,nesting=1
hostname: plex
memory: 4096
mp0: /mnt/pve/movie,mp=/movie
mp1: /mnt/pve/music,mp=/music
mp2: /mnt/pve/anime,mp=/anime
mp3: /mnt/pve/serie,mp=/serie
nameserver: 192.168.1.3
net0: name=eth0,bridge=vmbr0,gw=192.168.1.1,hwaddr=BC:24:11:2C:BF:A3,ip=192.168.1.202/24,type=veth
onboot: 1
ostype: ubuntu
rootfs: vm-docker:vm-20232400-disk-0,size=300G
searchdomain: z-server.me
startup: order=4
swap: 2048
tags: community-script;linux;lxc;marechal;media;server;share;ssh;webserver

# 🔹 Accès au GPU via /dev/dri
lxc.cgroup2.devices.allow: c 226:* rwm
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir
```

> ⚠️ Important :
> **AUCUNE** ligne `dev0:` ou `dev1:` ne doit être présente.
> Le **bind-mount complet de `/dev/dri`** via `lxc.mount.entry` + la règle `c 226:*` suffisent.

Après modification :

```bash
pct stop 20232400
pct start 20232400
```

---

### 2.2 Jellyfin (CT 20308096) – `/etc/pve/lxc/20308096.conf`

Configuration **finale** (partie importante) :

```ini
# Jellyfin LXC (Helper-Scripts)
arch: amd64
cmode: shell
cores: 12
features: keyctl=1,nesting=1
hostname: jellyfin
memory: 6144
mp0: /mnt/pve/movie,mp=/movie
mp1: /mnt/pve/music,mp=/music
mp2: /mnt/pve/anime,mp=/anime
mp3: /mnt/pve/serie,mp=/serie
nameserver: 192.168.1.3
net0: name=eth0,bridge=vmbr0,gw=192.168.1.1,hwaddr=BC:24:11:E7:9C:CC,ip=192.168.1.203/24,type=veth
onboot: 1
ostype: ubuntu
rootfs: vm-docker:vm-20308096-disk-0,size=100G
searchdomain: z-server.me
startup: order=5
swap: 2048
tags: community-script;linux;lxc;marechal;media;server;share;ssh;webserver

# 🔹 Accès au GPU via /dev/dri
lxc.cgroup2.devices.allow: c 226:* rwm
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir
```

Redémarrer :

```bash
pct stop 20308096
pct start 20308096
```

---

## 3. Vérifications dans les conteneurs

### 3.1 Plex – devices GPU visibles dans le LXC

Sur le **host** :

```bash
pct stop 20232400
pct start 20232400
pct console 20232400
# (Ctrl+a q pour quitter la console)
```

Dans le conteneur Plex :

```bash
ls -l /dev/dri
```

On doit voir quelque chose comme :

```text
crw-rw---- 1 root video  226,   0 ... card0
crw-rw---- 1 root render 226, 128 ... renderD128
```

### 3.2 Jellyfin – devices GPU visibles

Sur le host :

```bash
pct stop 20308096
pct start 20308096
pct console 20308096
```

Dans le conteneur Jellyfin :

```bash
ls -l /dev/dri
```

Sortie attendue similaire avec `card0` et `renderD128`.

---

## 4. Groupes `video` / `render` pour Plex & Jellyfin

Les applications doivent tourner avec un utilisateur membre des groupes `video` et `render`.

### 4.1 Plex

Dans le conteneur Plex :

```bash
grep -w 'video\|render' /etc/group
```

Tu avais :

```text
video:x:44:plex
render:x:118:
```

On ajoute donc `plex` dans `render` :

```bash
usermod -aG video,render plex
id plex
```

Vérifier que la sortie contient bien `video` et `render`.

Redémarrer Plex :

```bash
systemctl restart plexmediaserver 2>/dev/null || systemctl restart plex 2>/dev/null
```

---

### 4.2 Jellyfin

Dans le conteneur Jellyfin :

```bash
grep -w 'video\|render' /etc/group
```

Tu avais :

```text
video:x:44:jellyfin
render:x:104:jellyfin
```

Donc `jellyfin` est déjà dans les bons groupes.
Au besoin :

```bash
usermod -aG video,render jellyfin
id jellyfin
systemctl restart jellyfin
```

---

## 5. Validation VAAPI avec `vainfo`

Tu peux tester rapidement le support VAAPI dans un des conteneurs (Plex ou Jellyfin).

Installation (exemple Plex, Ubuntu 22.04) :

```bash
apt update
apt install -y vainfo mesa-va-drivers
vainfo
```

Exemple de sortie (résumé) :

```text
libva info: VA-API version 1.14.0
libva info: Trying to open /usr/lib/x86_64-linux-gnu/dri/radeonsi_drv_video.so
libva info: va_openDriver() returns 0
vainfo: VA-API version: 1.14 (libva 2.12.0)
vainfo: Driver version: Mesa Gallium driver ... for AMD Radeon RX 6700 XT
...
VAProfileH264Main               : VAEntrypointVLD
VAProfileH264Main               : VAEntrypointEncSlice
VAProfileHEVCMain               : VAEntrypointVLD
VAProfileHEVCMain10             : VAEntrypointVLD
VAProfileHEVCMain10             : VAEntrypointEncSlice
...
```

Les lignes `VAProfile...` / `VAEntrypointEncSlice` confirment que l’encodage matériel est disponible.

---

## 6. Configuration dans Plex

Dans l’interface web Plex :

1. Aller dans :**Settings → Server → Transcoder**
2. Activer :
   - ✅ **Use hardware acceleration when available**
3. Garder le mode **automatique / VAAPI** (Plex utilisera `/dev/dri`).

Pour forcer un transcodage :

- Lire un film 4K (ou au moins 1080p)
- Sur le client, réduire la qualité (ex. 720p 4 Mbps) pour obliger le transcodage.

Optionnel : vérifier dans les stats de lecture Plex que le codec porte la mention “(hw)” ou que le transcode utilise VAAPI.

---

## 7. Configuration dans Jellyfin

Dans l’interface Jellyfin :

1. Aller dans :**Dashboard → Playback → Transcoding**
2. Section **Hardware acceleration** :
   - Choisir **VAAPI**
   - Device : `/dev/dri/renderD128` (ou laisser Automatic si Jellyfin le détecte)
3. Cocher :
   - Hardware decoding
   - Hardware encoding (si proposé)
4. Sauvegarder.

Pour tester :

- Lire une vidéo 4K ou 1080p haute qualité.
- Baisser la résolution / le bitrate côté client pour forcer le transcodage.
- Vérifier dans **Dashboard → Active sessions** que le codec utilise VAAPI.

---

## 8. Stress-test GPU 4K avec `ffmpeg`

Pour mettre **la RX 6700 XT dans le rouge**, on peut utiliser un fichier 4K de test dans le LXC Plex (ou Jellyfin) et transcoder via VAAPI.

### 8.1 Exemple de fichier 4K de test (dans Plex)

Dans le conteneur Plex :

```bash
cd /movie
mkdir -p test4k
cd test4k

# Exemple : fichier 4K téléchargé manuellement (démo 4K, film de test, etc.)
# wget "https://.../mon_fichier_4k.mp4" -O 4k-test.mp4
```

> Remplacer l’URL par un fichier 4K réel (film de test, démo 4K, etc.)
> L’important : résolution 3840x2160 et bitrate élevé pour bien charger le GPU.

### 8.2 Transcodage 4K → H.264 via VAAPI

Toujours dans Plex LXC, dans `/movie/test4k` :

```bash
ffmpeg -hwaccel vaapi -vaapi_device /dev/dri/renderD128 \
  -i 4k-test.mp4 \
  -vf 'format=nv12,hwupload' \
  -c:v h264_vaapi -b:v 20M \
  -f null -
```

Explications :

- `-hwaccel vaapi -vaapi_device /dev/dri/renderD128` : décodage matériel via VAAPI.
- `format=nv12,hwupload` : format adapté au pipeline VAAPI.
- `-c:v h264_vaapi` : encodage H.264 sur le GPU.
- `-f null -` : la sortie vidéo n’est pas écrite sur disque (pure charge GPU).

Tu peux lancer **plusieurs ffmpeg en parallèle** (deux shells) pour encore plus de charge.

---

## 9. Supervision de la charge GPU sur le host

Sur le **host Proxmox**, pendant un transcodage (Plex, Jellyfin ou ffmpeg), tu peux surveiller la charge de la RX 6700 XT.

Installation de `radeontop` (si pas déjà fait) :

```bash
apt update
apt install -y radeontop
radeontop
```

Sinon, méthode texte simple (selon ce que le noyau expose) :

```bash
watch -n1 "cat /sys/kernel/debug/dri/0/amdgpu_pm_info | egrep 'GPU load|GPU freq|Memory freq' || echo 'no debug info'"
```

Tu devrais voir la charge GPU augmenter dès que :

- un transcodage Plex est en cours,
- un transcodage Jellyfin est en cours,
- ou un `ffmpeg` VAAPI tourne dans un LXC.

---

## 10. Résumé rapide

- Le **GPU AMD** est exposé dans les LXC via :
  - `lxc.cgroup2.devices.allow: c 226:* rwm`
  - `lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir`
- Aucun `dev0:` / `dev1:` dans les confs LXC : pas besoin, et ça casse `autodev`.
- Les utilisateurs `plex` et `jellyfin` sont dans les groupes :
  - `video`
  - `render`
- Plex & Jellyfin sont configurés en **VAAPI**.
- Les tests 4K + `ffmpeg` permettent de confirmer que la RX 6700 XT est bien utilisée.

Ce README est la référence pour la configuration GPU/VAAPI de Plex & Jellyfin sur ce cluster Proxmox.