FFmpeg NVENC

Clore.ai पर FFmpeg NVENC के साथ GPU-त्वरित वीडियो एन्कोडिंग

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

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

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

1. पर जाएँ CLORE.AI मार्केटप्लेस

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

कमांड:

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

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

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

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

# V....D h264_nvenc

# V....D hevc_nvenc

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

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

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

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

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

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

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

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

प्रीसेट्स

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

# सबसे तेज़ एन्कोडिंग
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)

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

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

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

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

चर बिटरेट (VBR)

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

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

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

# 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 स्केलिंग (तेज़)

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

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

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

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

बैच रूपांतरण

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

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

पायथन बैच

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 में रूपांतरण

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

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

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

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

# सबटाइटल्स को वीडियो में बर्न करें
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

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

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

# फ़ाइल सूची बनाएं
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 बनाएं

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

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

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

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

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

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

स्ट्रीमिंग

RTMP स्ट्रीम

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 आउटपुट

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

उन्नत विकल्प

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

# पास 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

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

HDR समर्थन (HEVC)

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

मल्टी-GPU

# विशिष्ट 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 नहीं मिला

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

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

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

# समवर्ती सत्रों को कम करें (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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

• भुगतान करें CLORE टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले कदम

• AI वीडियो जनरेशन

• RIFE इंटरपोलेशन

• Real-ESRGAN अपस्केलिंग