FFmpeg NVENC

GPU-accelerated video encoding with FFmpeg NVENC on Clore.ai

Hardware-accelerated video encoding with NVIDIA GPUs.

All examples can be run on GPU servers rented through CLORE.AI Marketplace.

Renting on CLORE.AI

1. Visit CLORE.AI Marketplace

2. Filter by GPU type, VRAM, and price

3. Choose On-Demand (fixed rate) or Spot (bid price)

4. Configure your order:

   • Select Docker image

   • Set ports (TCP for SSH, HTTP for web UIs)

   • Add environment variables if needed

   • Enter startup command

5. Select payment: CLORE, BTC, or USDT/USDC

6. Create order and wait for deployment

Access Your Server

• Find connection details in My Orders

• Web interfaces: Use the HTTP port URL

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

What is NVENC?

NVENC (NVIDIA Video Encoder) provides:

• 5-10x faster encoding than CPU

• H.264, H.265/HEVC, AV1 support

• Real-time 4K/8K encoding

• Low GPU compute usage

Requirements

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

Quick Deploy

Docker Image:

nvidia/cuda:12.1.0-devel-ubuntu22.04

Ports:

22/tcp

Command:

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

Check NVENC Support

# Check available encoders
ffmpeg -encoders | grep nvenc

# Should show:

# V....D h264_nvenc

# V....D hevc_nvenc

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

Basic Encoding

H.264 Encoding

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

HEVC/H.265 Encoding

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

AV1 Encoding (RTX 4000+)

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

Presets

Preset	Quality	Speed
p1	Lowest	Fastest
p2-p3	Low	Fast
p4-p5	Medium	Balanced
p6-p7	High	Slow

# Fastest encoding
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p1 output.mp4

# Best quality
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 output.mp4

Quality Control

Constant Quality (CQ)

# Lower = better quality, larger file
ffmpeg -i input.mp4 -c:v h264_nvenc -cq 18 output.mp4

# Recommended values: 18-28

Constant 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

Resolution & Scaling

Resize Video

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

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

# Maintain aspect ratio
ffmpeg -i input.mp4 -vf "scale=-1:1080" -c:v h264_nvenc output.mp4

GPU Scaling (Faster)

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

Hardware Decoding + Encoding

Full GPU pipeline:

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

Batch Conversion

Shell Script

#!/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

Python Batch

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

# Process in parallel (if multi-GPU or enough resources)
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}")

Common Tasks

Convert to Web-Optimized MP4

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

Extract Audio

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

Add Subtitles

# Burn subtitles into video
ffmpeg -i input.mp4 -vf "subtitles=subs.srt" -c:v h264_nvenc output.mp4

# Embed as soft subtitles
ffmpeg -i input.mp4 -i subs.srt -c:v copy -c:a copy -c:s mov_text output.mp4

Trim Video

# From 00:01:00 for 30 seconds
ffmpeg -ss 00:01:00 -i input.mp4 -t 30 -c:v h264_nvenc output.mp4

# From start to end timestamp
ffmpeg -i input.mp4 -ss 00:00:30 -to 00:02:00 -c:v h264_nvenc output.mp4

Concatenate Videos

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

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

Create GIF

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

Extract Frames

# Every frame
ffmpeg -i input.mp4 frames/frame_%04d.png

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

Frames to 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 Output

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

Performance Comparison

Encoding Speed (4K Video)

Encoder	GPU/CPU	Speed
libx264	CPU (8 core)	~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

Advanced Options

Two-Pass Encoding

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

# Pass 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 size
    -keyint_min 30 \  # Min keyframe interval
    output.mp4

HDR Support (HEVC)

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

Multi-GPU

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

# Parallel encoding on different 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

Troubleshooting

NVENC Not Found

# Check NVIDIA driver
nvidia-smi

# Check FFmpeg build
ffmpeg -encoders | grep nvenc

Encoding Failed

# Reduce concurrent sessions (NVENC limit)

# Consumer GPUs: 3-5 sessions

# Professional GPUs: unlimited

Poor Quality

• Use higher preset (p6, p7)

• Lower CQ value (18-20)

• Increase bitrate

Cost Estimate

Typical CLORE.AI marketplace rates (as of 2024):

GPU	Hourly Rate	Daily Rate	4-Hour Session
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

Prices vary by provider and demand. Check CLORE.AI Marketplace for current rates.

Save money:

• Use Spot market for flexible workloads (often 30-50% cheaper)

• Pay with CLORE tokens

• Compare prices across different providers

Next Steps

• AI Video Generation

• RIFE Interpolation

• Real-ESRGAN Upscaling