# FFmpeg NVENC

Hardware-accelerated video encoding with NVIDIA GPUs.

{% hint style="success" %}
All examples can be run on GPU servers rented through [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Renting on CLORE.AI

1. Visit [CLORE.AI Marketplace](https://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:**

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

## Check NVENC Support

```bash

# 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

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

### HEVC/H.265 Encoding

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

### AV1 Encoding (RTX 4000+)

```bash
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     |

```bash

# 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)

```bash

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

# Recommended values: 18-28
```

### Constant Bitrate (CBR)

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

### Variable Bitrate (VBR)

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

## Resolution & Scaling

### Resize Video

```bash

# 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)

```bash
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:

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

## Batch Conversion

### Shell Script

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

### Python Batch

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

# 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

```bash
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

```bash
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

```bash

# 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

```bash

# 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

```bash

# 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

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

### Extract Frames

```bash

# 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

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

## Streaming

### RTMP Stream

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

### HLS Output

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

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

```bash

# 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

```bash
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)

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

## Multi-GPU

```bash

# 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

```bash

# Check NVIDIA driver
nvidia-smi

# Check FFmpeg build
ffmpeg -encoders | grep nvenc
```

### Encoding Failed

```bash

# 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*](https://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](https://docs.clore.ai/guides/video-generation/ai-video-generation)
* [RIFE Interpolation](https://docs.clore.ai/guides/video-processing/rife-interpolation)
* [Real-ESRGAN Upscaling](https://docs.clore.ai/guides/image-processing/real-esrgan-upscaling)