# FFmpeg NVENC

Encodage vidéo accéléré par le matériel avec les GPU NVIDIA.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que NVENC ?

NVENC (NVIDIA Video Encoder) fournit :

* Encodage 5 à 10x plus rapide que le CPU
* Prise en charge de H.264, H.265/HEVC, AV1
* Encodage 4K/8K en temps réel
* Faible utilisation du calcul GPU

## Exigences

| Codec | GPU min   | Recommandé |
| ----- | --------- | ---------- |
| H.264 | GTX 600+  | RTX 3060+  |
| HEVC  | GTX 900+  | RTX 3070+  |
| AV1   | RTX 4000+ | RTX 4090   |

## Déploiement rapide

**Image Docker :**

```
nvidia/cuda:12.1.0-devel-ubuntu22.04
```

**Ports :**

```
22/tcp
```

**Commande :**

```bash
apt-get update && \
apt-get install -y ffmpeg && \
echo "FFmpeg with NVENC ready"
```

## Vérifier la prise en charge de NVENC

```bash

# Vérifier les encodeurs disponibles
ffmpeg -encoders | grep nvenc

# Devrait afficher :

# V....D h264_nvenc

# V....D hevc_nvenc

# V....D av1_nvenc (RTX 4000+)
```

## Encodage de base

### Encodage H.264

```bash
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 -cq 23 output.mp4
```

### Encodage HEVC/H.265

```bash
ffmpeg -i input.mp4 -c:v hevc_nvenc -preset p7 -cq 23 output.mp4
```

### Encodage AV1 (RTX 4000+)

```bash
ffmpeg -i input.mp4 -c:v av1_nvenc -preset p7 -cq 23 output.mp4
```

## Préréglages

| Préréglage | Qualité     | Vitesse        |
| ---------- | ----------- | -------------- |
| p1         | Le plus bas | Le plus rapide |
| p2-p3      | Faible      | Rapide         |
| p4-p5      | Moyen       | Équilibré      |
| p6-p7      | Élevé       | Lent           |

```bash

# Encodage le plus rapide
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p1 output.mp4

# Meilleure qualité
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 output.mp4
```

## Contrôle de la qualité

### Qualité constante (CQ)

```bash

# Plus bas = meilleure qualité, fichier plus volumineux
ffmpeg -i input.mp4 -c:v h264_nvenc -cq 18 output.mp4

# Valeurs recommandées : 18-28
```

### Débit binaire constant (CBR)

```bash
ffmpeg -i input.mp4 -c:v h264_nvenc -b:v 10M output.mp4
```

### Débit binaire variable (VBR)

```bash
ffmpeg -i input.mp4 -c:v h264_nvenc -b:v 10M -maxrate 15M -bufsize 20M output.mp4
```

## Résolution et mise à l'échelle

### Redimensionner la vidéo

```bash

# Mise à l'échelle vers 1080p
ffmpeg -i input.mp4 -vf "scale=1920:1080" -c:v h264_nvenc output.mp4

# Mise à l'échelle vers 4K
ffmpeg -i input.mp4 -vf "scale=3840:2160" -c:v hevc_nvenc output.mp4

# Conserver le rapport d'aspect
ffmpeg -i input.mp4 -vf "scale=-1:1080" -c:v h264_nvenc output.mp4
```

### Mise à l'échelle GPU (plus rapide)

```bash
ffmpeg -hwaccel cuda -hwaccel_output_format cuda \
    -i input.mp4 \
    -vf "scale_cuda=1920:1080" \
    -c:v h264_nvenc output.mp4
```

## Décodage matériel + encodage

Pipeline GPU complet :

```bash
ffmpeg \
    -hwaccel cuda \
    -hwaccel_output_format cuda \
    -i input.mp4 \
    -c:v h264_nvenc \
    -preset p4 \
    output.mp4
```

## Conversion par lot

### Script Shell

```bash
#!/bin/bash
INPUT_DIR=$1
OUTPUT_DIR=$2

mkdir -p "$OUTPUT_DIR"

for file in "$INPUT_DIR"/*.{mp4,mkv,avi,mov}; do
    if [ -f "$file" ]; then
        filename=$(basename "$file")
        name="${filename%.*}"

        ffmpeg -hwaccel cuda -i "$file" \
            -c:v h264_nvenc -preset p5 -cq 23 \
            -c:a aac -b:a 192k \
            "$OUTPUT_DIR/${name}.mp4"

        echo "Converted: $filename"
    fi
done
```

### Batch Python

```python
import subprocess
import os
from concurrent.futures import ThreadPoolExecutor

def convert_video(input_path, output_path):
    cmd = [
        'ffmpeg', '-y',
        '-hwaccel', 'cuda',
        '-i', input_path,
        '-c:v', 'h264_nvenc',
        '-preset', 'p5',
        '-cq', '23',
        '-c:a', 'aac',
        '-b:a', '192k',
        output_path
    ]
    subprocess.run(cmd, check=True)

input_dir = './videos'
output_dir = './converted'
os.makedirs(output_dir, exist_ok=True)

files = [f for f in os.listdir(input_dir) if f.endswith(('.mp4', '.mkv', '.avi'))]

# Traiter en parallèle (si multi-GPU ou ressources suffisantes)
for f in files:
    input_path = os.path.join(input_dir, f)
    output_path = os.path.join(output_dir, f.rsplit('.', 1)[0] + '.mp4')
    convert_video(input_path, output_path)
    print(f"Converted: {f}")
```

## Tâches courantes

### Convertir en MP4 optimisé pour le web

```bash
ffmpeg -i input.mp4 \
    -c:v h264_nvenc -preset p5 -cq 23 \
    -c:a aac -b:a 128k \
    -movflags +faststart \
    web_video.mp4
```

### Extraire l'audio

```bash
ffmpeg -i video.mp4 -vn -c:a copy audio.aac
ffmpeg -i video.mp4 -vn -c:a libmp3lame -b:a 320k audio.mp3
```

### Ajouter des sous-titres

```bash

# Graver les sous-titres dans la vidéo
ffmpeg -i input.mp4 -vf "subtitles=subs.srt" -c:v h264_nvenc output.mp4

# Intégrer comme sous-titres souples
ffmpeg -i input.mp4 -i subs.srt -c:v copy -c:a copy -c:s mov_text output.mp4
```

### Couper la vidéo

```bash

# Depuis 00:01:00 pendant 30 secondes
ffmpeg -ss 00:01:00 -i input.mp4 -t 30 -c:v h264_nvenc output.mp4

# Du début à l'horodatage de fin
ffmpeg -i input.mp4 -ss 00:00:30 -to 00:02:00 -c:v h264_nvenc output.mp4
```

### Concaténer des vidéos

```bash

# Créer la liste de fichiers
echo "file 'video1.mp4'" > list.txt
echo "file 'video2.mp4'" >> list.txt
echo "file 'video3.mp4'" >> list.txt

# Concaténer
ffmpeg -f concat -safe 0 -i list.txt -c:v h264_nvenc output.mp4
```

### Créer un GIF

```bash
ffmpeg -i input.mp4 -vf "fps=10,scale=480:-1:flags=lanczos" output.gif
```

### Extraire des images

```bash

# Chaque image
ffmpeg -i input.mp4 frames/frame_%04d.png

# Toutes les 1 seconde
ffmpeg -i input.mp4 -vf "fps=1" frames/frame_%04d.png
```

### Images vers vidéo

```bash
ffmpeg -framerate 30 -i frames/frame_%04d.png -c:v h264_nvenc output.mp4
```

## Streaming

### Flux RTMP

```bash
ffmpeg -re -i input.mp4 \
    -c:v h264_nvenc -preset p4 -b:v 4M \
    -c:a aac -b:a 128k \
    -f flv rtmp://server/live/stream
```

### Sortie HLS

```bash
ffmpeg -i input.mp4 \
    -c:v h264_nvenc -preset p5 \
    -c:a aac \
    -f hls -hls_time 10 -hls_list_size 0 \
    output.m3u8
```

## Comparaison des performances

### Vitesse d'encodage (vidéo 4K)

| Encodeur    | GPU/CPU       | Vitesse   |
| ----------- | ------------- | --------- |
| libx264     | CPU (8 cœurs) | \~30 ips  |
| h264\_nvenc | RTX 3090      | \~300 ips |
| h264\_nvenc | RTX 4090      | \~450 ips |
| hevc\_nvenc | RTX 3090      | \~200 ips |
| hevc\_nvenc | RTX 4090      | \~350 ips |

## Options avancées

### Encodage en deux passes

```bash

# Passe 1
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 -b:v 10M -pass 1 -f null /dev/null

# Passe 2
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 -b:v 10M -pass 2 output.mp4
```

### B-Frames et GOP

```bash
ffmpeg -i input.mp4 \
    -c:v h264_nvenc \
    -bf 2 \           # B-frames
    -g 60 \           # Taille du GOP
    -keyint_min 30 \  # Intervalle minimum entre images clés
    output.mp4
```

### Prise en charge HDR (HEVC)

```bash
ffmpeg -i hdr_input.mp4 \
    -c:v hevc_nvenc \
    -preset p5 \
    -profile:v main10 \
    -pix_fmt p010le \
    hdr_output.mp4
```

## Multi-GPU

```bash

# Utiliser un GPU spécifique
ffmpeg -hwaccel cuda -hwaccel_device 0 -i input.mp4 -c:v h264_nvenc output.mp4

# Encodage parallèle sur différents GPU
ffmpeg -hwaccel cuda -hwaccel_device 0 -i video1.mp4 -c:v h264_nvenc out1.mp4 &
ffmpeg -hwaccel cuda -hwaccel_device 1 -i video2.mp4 -c:v h264_nvenc out2.mp4 &
wait
```

## Dépannage

### NVENC introuvable

```bash

# Vérifier le pilote NVIDIA
nvidia-smi

# Vérifier la compilation de FFmpeg
ffmpeg -encoders | grep nvenc
```

### Échec de l'encodage

```bash

# Réduire les sessions simultanées (limite NVENC)

# GPU grand public : 3-5 sessions

# GPU professionnels : illimité
```

### Mauvaise qualité

* Utiliser un preset plus élevé (p6, p7)
* Valeur CQ plus basse (18-20)
* Augmenter le débit binaire

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| RTX 3060  | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090  | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090  | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [Génération vidéo IA](https://docs.clore.ai/guides/guides_v2-fr/generation-video/ai-video-generation)
* [Interpolation RIFE](https://docs.clore.ai/guides/guides_v2-fr/traitement-video/rife-interpolation)
* [Upscaling Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling)