FFmpeg NVENC

GPU-beschleunigte Videokodierung mit FFmpeg NVENC auf Clore.ai

Hardwarebeschleunigte Videokodierung mit NVIDIA-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist NVENC?

NVENC (NVIDIA Video Encoder) bietet:

• 5-10-mal schnellere Kodierung als die CPU

• Unterstützung für H.264, H.265/HEVC, AV1

• Echtzeit-Kodierung in 4K/8K

• Geringe GPU-Compute-Auslastung

Anforderungen

Codec	Min. GPU	Empfohlen
H.264	GTX 600+	RTX 3060+
HEVC	GTX 900+	RTX 3070+
AV1	RTX 4000+	RTX 4090

Schnell bereitstellen

Docker-Image:

nvidia/cuda:12.8.1-devel-ubuntu22.04

Ports:

22/tcp

Befehl:

apt-get update && \\
apt-get install -y ffmpeg && \\
echo "FFmpeg mit NVENC bereit"

NVENC-Unterstützung prüfen

# Verfügbare Encoder prüfen
ffmpeg -encoders | grep nvenc

# Sollte anzeigen:

# V....D h264_nvenc

# V....D hevc_nvenc

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

Grundlegende Kodierung

H.264-Kodierung

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

HEVC/H.265-Kodierung

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

AV1-Kodierung (RTX 4000+)

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

Presets

Preset	Qualität	Geschwindigkeit
p1	Niedrigste	Am schnellsten
p2-p3	Niedrig	Schnell
p4-p5	Mittel	Ausgewogen
p6-p7	Hoch	Langsam

# Schnellste Kodierung
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p1 output.mp4

# Beste Qualität
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 output.mp4

Qualitätskontrolle

Konstante Qualität (CQ)

# Niedriger = bessere Qualität, größere Datei
ffmpeg -i input.mp4 -c:v h264_nvenc -cq 18 output.mp4

# Empfohlene Werte: 18-28

Konstante Bitrate (CBR)

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

Variable Bitrate (VBR)

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

Auflösung & Skalierung

Video skalieren

# Auf 1080p skalieren
ffmpeg -i input.mp4 -vf "scale=1920:1080" -c:v h264_nvenc output.mp4

# Auf 4K skalieren
ffmpeg -i input.mp4 -vf "scale=3840:2160" -c:v hevc_nvenc output.mp4

# Seitenverhältnis beibehalten
ffmpeg -i input.mp4 -vf "scale=-1:1080" -c:v h264_nvenc output.mp4

GPU-Skalierung (schneller)

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

Hardware-Dekodierung + Kodierung

Vollständige GPU-Pipeline:

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

Stapelkonvertierung

Shell-Skript

#!/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 "Konvertiert: $filename"
    fi
done

Python-Stapelverarbeitung

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'))]

# Parallel verarbeiten (wenn Multi-GPU oder genügend Ressourcen)
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"Konvertiert: {f}")

Häufige Aufgaben

In weboptimiertes MP4 konvertieren

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

Audio extrahieren

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

Untertitel hinzufügen

# Untertitel ins Video einbrennen
ffmpeg -i input.mp4 -vf "subtitles=subs.srt" -c:v h264_nvenc output.mp4

# Als Soft-Untertitel einbetten
ffmpeg -i input.mp4 -i subs.srt -c:v copy -c:a copy -c:s mov_text output.mp4

Video trimmen

# Ab 00:01:00 für 30 Sekunden
ffmpeg -ss 00:01:00 -i input.mp4 -t 30 -c:v h264_nvenc output.mp4

# Vom Start- bis zum Endzeitstempel
ffmpeg -i input.mp4 -ss 00:00:30 -to 00:02:00 -c:v h264_nvenc output.mp4

Videos zusammenfügen

# Dateiliste erstellen
echo "file 'video1.mp4'" > list.txt
echo "file 'video2.mp4'" >> list.txt
echo "file 'video3.mp4'" >> list.txt

# Zusammenfügen
ffmpeg -f concat -safe 0 -i list.txt -c:v h264_nvenc output.mp4

GIF erstellen

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

Frames extrahieren

# Jedes Einzelbild
ffmpeg -i input.mp4 frames/frame_%04d.png

# Jede Sekunde
ffmpeg -i input.mp4 -vf "fps=1" frames/frame_%04d.png

Frames zu Video

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

Streaming

RTMP-Stream

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

HLS-Ausgabe

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

Leistungsvergleich

Kodierungsgeschwindigkeit (4K-Video)

Encoder	GPU/CPU	Geschwindigkeit
libx264	CPU (8 Kerne)	~30 fps
h264_nvenc	RTX 3090	~300 fps
h264_nvenc	RTX 4090	~450 fps
hevc_nvenc	RTX 3090	~200 fps
hevc_nvenc	RTX 4090	~350 fps

Erweiterte Optionen

Zweipass-Kodierung

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

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

B-Frames & GOP

ffmpeg -i input.mp4 \\
    -c:v h264_nvenc \\
    -bf 2 \\           # B-Frames
    -g 60 \\           # GOP-Größe
    -keyint_min 30 \\  # Minimales Keyframe-Intervall
    output.mp4

HDR-Unterstützung (HEVC)

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

Multi-GPU

# Bestimmte GPU verwenden
ffmpeg -hwaccel cuda -hwaccel_device 0 -i input.mp4 -c:v h264_nvenc output.mp4

# Parallele Kodierung auf verschiedenen GPUs
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

Fehlerbehebung

NVENC nicht gefunden

# NVIDIA-Treiber prüfen
nvidia-smi

# FFmpeg-Build prüfen
ffmpeg -encoders | grep nvenc

Kodierung fehlgeschlagen

# Gleichzeitige Sitzungen reduzieren (NVENC-Limit)

# Consumer-GPUs: 3-5 Sitzungen

# Professionelle GPUs: unbegrenzt

Schlechte Qualität

• Höheres Preset verwenden (p6, p7)

• Niedrigeren CQ-Wert verwenden (18-20)

• Bitrate erhöhen

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• KI-Videogenerierung

• RIFE-Interpolation

• Real-ESRGAN-Hochskalierung