FFmpeg NVENC

GPU-beschleunigte Video-Encoding mit FFmpeg NVENC auf Clore.ai

Hardware-beschleunigte Video-Codierung mit NVIDIA-GPUs.

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

Mieten auf CLORE.AI

1. Besuchen Sie CLORE.AI Marketplace

2. Nach GPU-Typ, VRAM und Preis filtern

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

4. Konfigurieren Sie Ihre Bestellung:

   • Docker-Image auswählen

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

   • Umgebungsvariablen bei Bedarf hinzufügen

   • Startbefehl eingeben

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

6. Bestellung erstellen und auf Bereitstellung warten

Zugriff auf Ihren Server

• Verbindungsdetails finden Sie in Meine Bestellungen

• Webschnittstellen: Verwenden Sie die HTTP-Port-URL

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

Was ist NVENC?

NVENC (NVIDIA Video Encoder) bietet:

• 5–10× schnellere Codierung als die CPU

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

• Echtzeit-Codierung in 4K/8K

• Geringe GPU-Rechenutzung

Anforderungen

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

Schnelle Bereitstellung

Docker-Image:

nvidia/cuda:12.1.0-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 Codierung

H.264-Codierung

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

HEVC/H.265-Codierung

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

AV1-Codierung (RTX 4000+)

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

Voreinstellungen

Voreinstellung	Qualität	Geschwindigkeit
p1	Am niedrigsten	Am schnellsten
p2-p3	Gering	Schnell
p4-p5	Mittel	Ausgeglichen
p6-p7	Hoch	Langsam

# Schnellste Codierung
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ätssteuerung

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 + Codierung

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-Stapel

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 (bei Multi-GPU oder ausreichenden 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 web-optimiertes 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 in Video einbrennen
ffmpeg -i input.mp4 -vf "subtitles=subs.srt" -c:v h264_nvenc output.mp4

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

Video beschneiden

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

# Von Start bis 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

# Jeden Frame
ffmpeg -i input.mp4 frames/frame_%04d.png

# Jede 1 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

Codiergeschwindigkeit (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

Zwei-Pass-Codierung

# 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

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

# Parallele Codierung 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

Codierung 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 (18–20)

• Bitrate erhöhen

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (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

Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

• Verwenden Sie Spot Markt für flexible Workloads (oft 30–50% günstiger)

• Bezahlen mit CLORE Token

• Preise bei verschiedenen Anbietern vergleichen

Nächste Schritte

• KI-Videogenerierung

• RIFE-Interpolation

• Real-ESRGAN-Upscaling