> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/video-processing/ffmpeg-nvenc.md).

# 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 वीडियो जनरेशन](/guides/guides_v2-hi/video-generation/ai-video-generation.md)
* [RIFE इंटरपोलेशन](/guides/guides_v2-hi/video-processing/rife-interpolation.md)
* [Real-ESRGAN अपस्केलिंग](/guides/guides_v2-hi/image-processing/real-esrgan-upscaling.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/video-processing/ffmpeg-nvenc.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.