# FFmpeg NVENC

NVIDIA GPU के साथ हार्डवेयर-त्वरित वीडियो एन्कोडिंग।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

## CLORE.AI पर किराये पर लेना

1. पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)
2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें
3. चुनें **ऑन-डिमांड** (निश्चित दर) या **स्पॉट** (बिड प्राइस)
4. अपना ऑर्डर कॉन्फ़िगर करें:
   * Docker इमेज चुनें
   * पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
   * यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें
   * स्टार्टअप कमांड दर्ज करें
5. भुगतान चुनें: **CLORE**, **BTC**, या **USDT/USDC**
6. ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

### अपने सर्वर तक पहुँचें

* कनेक्शन विवरण में खोजें **मेरे ऑर्डर**
* वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें
* SSH: `ssh -p <port> root@<proxy-address>`

## NVENC क्या है?

NVENC (NVIDIA वीडियो एन्कोडर) प्रदान करता है:

* CPU की तुलना में 5-10x तेज़ एन्कोडिंग
* H.264, H.265/HEVC, AV1 समर्थन
* रीयल-टाइम 4K/8K एन्कोडिंग
* कम GPU कंप्यूट उपयोग

## आवश्यकताएँ

| कोडेक | न्यूनतम GPU | अनुशंसित  |
| ----- | ----------- | --------- |
| H.264 | GTX 600+    | RTX 3060+ |
| HEVC  | GTX 900+    | RTX 3070+ |
| AV1   | RTX 4000+   | RTX 4090  |

## त्वरित तैनाती

**Docker इमेज:**

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

**पोर्ट:**

```
22/tcp
```

**कमांड:**

```bash
apt-get update && \
apt-get install -y ffmpeg && \
echo "NVENC के साथ FFmpeg तैयार है"
```

## NVENC समर्थन जाँचें

```bash

# उपलब्ध एन्कोडरों की जाँच करें
ffmpeg -encoders | grep nvenc

# दिखाना चाहिए:

# V....D h264_nvenc

# V....D hevc_nvenc

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

## बुनियादी एन्कोडिंग

### H.264 एन्कोडिंग

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

### HEVC/H.265 एन्कोडिंग

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

### AV1 एन्कोडिंग (RTX 4000+)

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

## प्रीसेट्स

| प्रीसेट | गुणवत्ता | स्पीड    |
| ------- | -------- | -------- |
| p1      | सबसे कम  | सबसे तेज |
| p2-p3   | कम       | तेज़     |
| p4-p5   | मध्यम    | संतुलित  |
| p6-p7   | उच्च     | धीमा     |

```bash

# सबसे तेज़ एन्कोडिंग
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p1 output.mp4

# सर्वश्रेष्ठ गुणवत्ता
ffmpeg -i input.mp4 -c:v h264_nvenc -preset p7 output.mp4
```

## गुणवत्ता नियंत्रण

### निरंतर गुणवत्ता (CQ)

```bash

# कम = बेहतर गुणवत्ता, बड़ा फ़ाइल आकार
ffmpeg -i input.mp4 -c:v h264_nvenc -cq 18 output.mp4

# अनुशंसित मान: 18-28
```

### निरंतर बिटरेट (CBR)

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

### चर बिटरेट (VBR)

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

## रिज़ॉल्यूशन और स्केलिंग

### वीडियो का आकार बदलें

```bash

# 1080p पर स्केल करें
ffmpeg -i input.mp4 -vf "scale=1920:1080" -c:v h264_nvenc output.mp4

# 4K पर स्केल करें
ffmpeg -i input.mp4 -vf "scale=3840:2160" -c:v hevc_nvenc output.mp4

# आस्पेक्ट रेशियो बनाए रखें
ffmpeg -i input.mp4 -vf "scale=-1:1080" -c:v h264_nvenc output.mp4
```

### GPU स्केलिंग (तेज़)

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

## हार्डवेयर डीकॉडिंग + एन्कोडिंग

पूर्ण GPU पाइपलाइन:

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

## बैच रूपांतरण

### शेल स्क्रिप्ट

```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 "रूपांतरित: $filename"
    fi
done
```

### पायथन बैच

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

# समानांतर में प्रोसेस करें (यदि मल्टी-GPU या पर्याप्त संसाधन हों)
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"रूपांतरित: {f}")
```

## सामान्य कार्य

### वेब-अनुकूल 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
```

### ऑडियो निकालें

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

### सबटाइटल जोड़ें

```bash

# सबटाइटल्स को वीडियो में बर्न करें
ffmpeg -i input.mp4 -vf "subtitles=subs.srt" -c:v h264_nvenc output.mp4

# सॉफ्ट सबटाइटल के रूप में एम्बेड करें
ffmpeg -i input.mp4 -i subs.srt -c:v copy -c:a copy -c:s mov_text output.mp4
```

### वीडियो ट्रिम करें

```bash

# 00:01:00 से 30 सेकंड के लिए
ffmpeg -ss 00:01:00 -i input.mp4 -t 30 -c:v h264_nvenc output.mp4

# प्रारंभ से समाप्त टाइमस्टैम्प तक
ffmpeg -i input.mp4 -ss 00:00:30 -to 00:02:00 -c:v h264_nvenc output.mp4
```

### वीडियो जोड़ें (Concatenate)

```bash

# फ़ाइल सूची बनाएं
echo "file 'video1.mp4'" > list.txt
echo "file 'video2.mp4'" >> list.txt
echo "file 'video3.mp4'" >> list.txt

# जोड़ें
ffmpeg -f concat -safe 0 -i list.txt -c:v h264_nvenc output.mp4
```

### GIF बनाएं

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

### फ़्रेम निकालें

```bash

# हर फ्रेम
ffmpeg -i input.mp4 frames/frame_%04d.png

# हर 1 सेकंड
ffmpeg -i input.mp4 -vf "fps=1" frames/frame_%04d.png
```

### फ़्रेम्स को वीडियो में बदलें

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

## स्ट्रीमिंग

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

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

## प्रदर्शन तुलना

### एन्कोडिंग गति (4K वीडियो)

| एन्कोडर     | GPU/CPU     | स्पीड     |
| ----------- | ----------- | --------- |
| libx264     | CPU (8 कोर) | \~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 |

## उन्नत विकल्प

### टू-पास एन्कोडिंग

```bash

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

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

### B-फ़्रेम और GOP

```bash
ffmpeg -i input.mp4 \
    -c:v h264_nvenc \
    -bf 2 \           # B-फ़्रेम
    -g 60 \           # GOP आकार
    -keyint_min 30 \  # न्यूनतम की-फ्रेम अंतराल
    output.mp4
```

### HDR समर्थन (HEVC)

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

## मल्टी-GPU

```bash

# विशिष्ट GPU का उपयोग करें
ffmpeg -hwaccel cuda -hwaccel_device 0 -i input.mp4 -c:v h264_nvenc output.mp4

# विभिन्न 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
```

## समस्याओं का निवारण

### NVENC नहीं मिला

```bash

# NVIDIA ड्राइवर की जाँच करें
nvidia-smi

# FFmpeg बिल्ड की जाँच करें
ffmpeg -encoders | grep nvenc
```

### एन्कोडिंग विफल हुई

```bash

# समवर्ती सत्रों को कम करें (NVENC सीमा)

# कंज्यूमर GPUs: 3-5 सत्र

# प्रोफेशनल GPUs: असीमित
```

### खराब गुणवत्ता

* उच्च प्रीसेट का उपयोग करें (p6, p7)
* CQ मान कम करें (18-20)
* बिटरेट बढ़ाएँ

## लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

| GPU       | घंटात्मक दर | दैनिक दर | 4-घंटे सत्र |
| --------- | ----------- | -------- | ----------- |
| 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     |

*कीमतें प्रदाता और मांग के अनुसार बदलती हैं। जाँच करें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

**पैसे बचाएँ:**

* उपयोग करें **स्पॉट** लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
* भुगतान करें **CLORE** टोकन के साथ
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## अगले कदम

* [AI वीडियो जनरेशन](https://docs.clore.ai/guides/guides_v2-hi/video-generation/ai-video-generation)
* [RIFE इंटरपोलेशन](https://docs.clore.ai/guides/guides_v2-hi/video-processing/rife-interpolation)
* [Real-ESRGAN अपस्केलिंग](https://docs.clore.ai/guides/guides_v2-hi/image-processing/real-esrgan-upscaling)