FFmpeg एक ग्रैंड ओपन सोर्स प्रोजेक्ट है, जो एक तरह का मल्टीमीडिया इनसाइक्लोपीडिया है। FFmpeg से आप बड़ी संख्या में कंप्यूटर मल्टीमीडिया कार्यों को हल कर सकते हैं। लेकिन फिर भी, कभी-कभी FFmpeg का विस्तार करने की आवश्यकता होती है। मानक तरीका प्रोजेक्ट कोड में परिवर्तन करना और फिर नया संस्करण संकलित करना है। लेख एक नए कोडेक को जोड़ने का विवरण देता है। बाहरी कार्यों को FFmpeg से जोड़ने के लिए कुछ विशेषताओं पर भी विचार किया जाता है। यदि कोई कोडेक जोड़ने की आवश्यकता नहीं है, तो FFmpeg कोडेक की वास्तुकला और उनकी सेटिंग्स की बेहतर समझ के लिए लेख उपयोगी हो सकता है। यह माना जाता है कि पाठक FFmpeg की वास्तुकला, FFmpeg की संकलन प्रक्रिया से परिचित है, और FFmpeg API का उपयोग करके प्रोग्रामिंग अनुभव भी है। विवरण FFmpeg 4.2 "Ada", अगस्त 2019 के लिए मान्य है।

सामग्री की तालिका

परिचय

कोडेक (कोडेक, शब्द कॉडर और डीकोडर के संयोजन से आता है) एक बहुत ही सामान्य शब्द है और, जैसा कि अक्सर ऐसे मामलों में होता है, इसका अर्थ संदर्भ के आधार पर कुछ भिन्न होता है। मीडिया डेटा को संपीड़ित / विघटित करने के लिए प्राथमिक अर्थ सॉफ्टवेयर या हार्डवेयर है। संपीड़न / विघटन की शर्तों के बजाय, अक्सर एन्कोडिंग / डिकोडिंग शब्द का उपयोग किया जाता है। लेकिन कुछ मामलों में, एक कोडेक आमतौर पर केवल एक संपीड़न प्रारूप का मतलब समझा जाता है (वे भी कोडेक प्रारूप कहते हैं), संपीड़न / अपघटन के लिए उपयोग किए जाने वाले साधनों की परवाह किए बिना। आइए देखें कि FFmpeg में कोडेक शब्द का उपयोग कैसे किया जाता है।

1. कोडेक पहचान

FFmpeg कोडेक्स को libavcodec लाइब्रेरी में संकलित किया गया है।

1.1। कोडेक आईडी

enum AVCodecID libavcodec/avcodec.h enum AVCodecID में परिभाषित किया गया है। इस गणना का प्रत्येक तत्व संपीड़न प्रारूप की पहचान करता है। इस गणना के तत्व AV_CODEC_ID_XXX के रूप में होने चाहिए, जहां XXX ऊपरी मामले में अद्वितीय कोडेक पहचानकर्ता नाम है। यहाँ कोडेक पहचानकर्ताओं के उदाहरण हैं: AV_CODEC_ID_H264 , AV_CODEC_ID_AAC । कोडेक पहचानकर्ता के अधिक विस्तृत विवरण के लिए, AVCodecDescriptor संरचना ( libavcodec/avcodec.h में घोषित करें, संक्षिप्त रूप में दिए गए) का उपयोग करें:

 typedef struct AVCodecDescriptor { enum AVCodecID id; enum AVMediaType type; const char *name; const char *long_name; // ... } AVCodecDescriptor; 

इस संरचना का प्रमुख सदस्य id , बाकी सदस्य कोडेक पहचानकर्ता के बारे में अतिरिक्त जानकारी प्रदान करते हैं। प्रत्येक कोडेक पहचानकर्ता विशिष्ट रूप से एक मीडिया प्रकार ( type सदस्य) से जुड़ा होता है और इसमें एक अद्वितीय नाम ( name सदस्य) होता है, जिसे निचले मामले में लिखा जाता है। AVCodecDescriptor एक प्रकार फ़ाइल libavcodec/codec_desc.c AVCodecDescriptor में परिभाषित किया गया है। प्रत्येक कोडेक पहचानकर्ता के लिए, एक संबंधित सरणी तत्व होता है। इस सरणी के तत्वों को id मान द्वारा आदेश दिया जाना चाहिए, क्योंकि बाइनरी खोज का उपयोग तत्वों की खोज के लिए किया जाता है। कोडेक पहचानकर्ता के बारे में जानकारी प्राप्त करने के लिए, आप कार्यों का उपयोग कर सकते हैं:

 const AVCodecDescriptor* avcodec_descriptor_get(enum AVCodecID id); const AVCodecDescriptor* avcodec_descriptor_get_by_name(const char *name); enum AVMediaType avcodec_get_type(enum AVCodecID codec_id); const char* avcodec_get_name(enum AVCodecID id); 

1.2। कोडेक

कोडेक स्वयं - मीडिया डेटा के एन्कोडिंग / डिकोडिंग करने के लिए आवश्यक उपकरणों का एक सेट, AVCodec संरचना ( libavcodec/avcodec.h में घोषित) को जोड़ती है। यहां इसका संक्षिप्त संस्करण है, नीचे पूर्ण चर्चा की जाएगी।

 typedef struct AVCodec { const char *name; const char *long_name; enum AVMediaType type; enum AVCodecID id; // ... } AVCodec; 

इस संरचना का सबसे महत्वपूर्ण सदस्य id , कोडेक पहचानकर्ता है, मीडिया के type ( type ) को परिभाषित करने वाला एक सदस्य भी है, लेकिन इसका मूल्य AVCodecDescriptor से उसी सदस्य के मूल्य से मेल खाना चाहिए। कोडेक्स को दो श्रेणियों में विभाजित किया गया है: एन्कोडर्स, जो मीडिया को संपीड़ित या एन्कोड करते हैं, और डिकोडर्स, जो विपरीत ऑपरेशन करते हैं - डिकम्प्रेस या डिकोड। (कभी-कभी रूसी ग्रंथों में, शब्द के बजाय, एन्कोडर अंग्रेजी से ट्रेसिंग पेपर का उपयोग करता है - एनकोडर।) AVCodec में कोई विशेष सदस्य नहीं है जो कोडेक श्रेणी को परिभाषित करता है (हालांकि श्रेणी को परोक्ष रूप से फ़ंक्शन av_codec_is_encoder() और av_codec_is_decoder() का उपयोग करके निर्धारित किया जाता है; इस श्रेणी के दौरान यह निर्धारित किया जाता है। यह कैसे किया जाएगा यह नीचे दिखाया जाएगा: कई कोडेक्स में एक ही कोडेक पहचानकर्ता हो सकता है। यदि उनके पास एक ही श्रेणी है, तो उन्हें नाम (सदस्य name ) से भिन्न होना चाहिए। एक एन्कोडर और डिकोडर में एक ही कोडेक पहचानकर्ता हो सकता है। एक होना एक ही नाम, जो कोडेक पहचानकर्ता के नाम के साथ मेल खाता हो सकता है (लेकिन ये मिलान वैकल्पिक हैं)। ऐसी स्थिति से कुछ भ्रम हो सकता है, लेकिन कुछ भी नहीं किया जाना चाहिए, आपको स्पष्ट रूप से समझना चाहिए कि नाम किस इकाई से संबंधित है। आपकी श्रेणी के भीतर, नाम। कोडेक अद्वितीय होना चाहिए। पंजीकृत कोडेक्स की खोज करने के लिए, कार्य हैं:

 AVCodec* avcodec_find_encoder_by_name(const char *name); AVCodec* avcodec_find_decoder_by_name(const char *name); AVCodec* avcodec_find_encoder(enum AVCodecID id); AVCodec* avcodec_find_decoder(enum AVCodecID id); 

चूंकि कई कोडक समान पहचानकर्ता हो सकते हैं, अंतिम दो फ़ंक्शन उनमें से एक को वापस करते हैं, जिसे किसी दिए गए कोडेक पहचानकर्ता के लिए डिफ़ॉल्ट कोडेक माना जा सकता है।

आदेश के साथ सभी पंजीकृत कोडेक्स की एक सूची का अनुरोध किया जा सकता है

ffmpeg -codecs >codecs.txt

कमांड निष्पादित करने के बाद, codecs.txt फ़ाइल में यह सूची होगी। प्रत्येक कोडेक पहचानकर्ता को एक अलग रिकॉर्ड (लाइन) द्वारा दर्शाया जाएगा। उदाहरण के लिए, कोडेक पहचानकर्ता के लिए प्रविष्टि AV_CODEC_ID_H264 :

DEV.LS
h264
H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10
(decoders: h264 h264_qsv h264_cuvid)
(encoders: libx264 libx264rgb h264_amf h264_nvenc h264_qsv nvenc nvenc_h264)


रिकॉर्डिंग की शुरुआत में, विशेष वर्ण हैं जो इस कोडेक पहचानकर्ता के लिए उपलब्ध सामान्य सुविधाओं का निर्धारण करते हैं: D - डिकोडर पंजीकृत हैं, E - एन्कोडर पंजीकृत हैं, V - वीडियो के लिए उपयोग किया जाता है, L - दोषपूर्ण संपीड़न की संभावना है, S - दोषरहित संपीड़न की संभावना है। इसके बाद कोडेक पहचानकर्ता का नाम ( h264 ) आता है, उसके बाद एक लंबा कोडेक पहचानकर्ता नाम ( H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 ) आता है, और फिर पंजीकृत डिकोडर्स और एनकोडर के नामों की एक सूची होती है।

2. FFmpeg में एक नया कोडेक जोड़ना

हम एक ऑडियो कोडेक के उदाहरण का उपयोग करके FFmpeg में एक नया कोडेक जोड़ने की प्रक्रिया पर विचार करेंगे, जिसे हम FROX ।

चरण 1. enum AVCodecID एक नया तत्व जोड़ें।

यह सूची libavcodec/avcodec.h । जोड़ते समय, आपको नियमों का पालन करना चाहिए:

1. एक तत्व का मूल्य मौजूदा गणना तत्वों के मूल्यों के साथ मेल नहीं खाना चाहिए;
2. मौजूदा गणना तत्वों के मूल्यों को न बदलें;
3. इसी तरह के कोडेक्स के समूह में एक नया मान पोस्ट करें।

टेम्पलेट के अनुसार, इस तत्व का पहचानकर्ता AV_CODEC_ID_FROX होना चाहिए। AV_CODEC_ID_PCM_S64LE से पहले इसे रखें और 0x10700 मान 0x10700 ।

चरण 2। आइटम को codec_descriptors सरणी (फ़ाइल libavcodec/codec_desc.c ) में जोड़ें।

 static const AVCodecDescriptor codec_descriptors[] = { // ... { .id = AV_CODEC_ID_FROX, .type = AVMEDIA_TYPE_AUDIO, .name = "frox", .long_name = NULL_IF_CONFIG_SMALL("FROX audio"), .props = AV_CODEC_PROP_LOSSLESS, }, // ... }; 

आपको तत्व को "सही" स्थान पर जोड़ने की आवश्यकता है, id मूल्य द्वारा सरणी तत्वों की एकरूपता का उल्लंघन नहीं किया जाना चाहिए।

चरण 3. एन्कोडर और डिकोडर के लिए AVCodec अलग-अलग उदाहरणों को परिभाषित करें।

ऐसा करने के लिए, आपको पहले कोडेक और कई फ़ंक्शन के संदर्भ के लिए संरचना निर्धारित करने की आवश्यकता है जो वास्तविक एन्कोडिंग / डिकोडिंग और कुछ अन्य आवश्यक संचालन करेंगे। इस खंड में, इन परिभाषाओं को अत्यंत योजनाबद्ध रूप से बनाया जाएगा; एक अधिक विस्तृत विवरण बाद में बनाया जाएगा। हम कोड को फाइल libavcodec/frox.c

 #include "avcodec.h" // context typedef struct FroxContext { // ... } FroxContext; // decoder static int frox_decode_init(AVCodecContext *codec_ctx) { return -1; } static int frox_decode_close(AVCodecContext *codec_ctx) { return -1; } static int frox_decode(AVCodecContext *codec_ctx, void* outdata, int *outdata_size, AVPacket *pkt) { return -1; } AVCodec ff_frox_decoder = { .name = "frox_dec", .long_name = NULL_IF_CONFIG_SMALL("FROX audio decoder"), .type = AVMEDIA_TYPE_AUDIO, .id = AV_CODEC_ID_FROX, .priv_data_size = sizeof(FroxContext), .init = frox_decode_init, .close = frox_decode_close, .decode = frox_decode, .capabilities = AV_CODEC_CAP_LOSSLESS, .sample_fmts = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE}, .channel_layouts = (const int64_t[]) {AV_CH_LAYOUT_MONO, 0 }, }; // encoder static int frox_encode_init(AVCodecContext *codec_ctx) { return -1; } static int frox_encode_close(AVCodecContext *codec_ctx) { return -1; } static int frox_encode(AVCodecContext *codec_ctx, AVPacket *pkt, const AVFrame *frame, int *got_pkt_ptr) { return -1; } AVCodec ff_frox_encoder = { .name = "frox_enc", .long_name = NULL_IF_CONFIG_SMALL("FROX audio encoder"), .type = AVMEDIA_TYPE_AUDIO, .id = AV_CODEC_ID_FROX, .priv_data_size = sizeof(FroxContext), .init = frox_encode_init, .close = frox_encode_close, .encode2 = frox_encode, .sample_fmts = (const enum AVSampleFormat[]) {AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE}, .channel_layouts = (const int64_t[]) {AV_CH_LAYOUT_MONO, 0 }, }; 

सादगी के लिए, इस उदाहरण में, एनकोडर और डिकोडर का एक ही संदर्भ है - FroxContext , लेकिन अक्सर एनकोडर और डिकोडर में अलग-अलग संदर्भ होते हैं। यह भी ध्यान दें कि AVCodec उदाहरण के AVCodec को एक विशेष पैटर्न का पालन करना चाहिए।

चरण 4. पंजीकरण सूची में AVCodec उदाहरण जोड़ें।

फ़ाइल libavcodec/allcodecs.c । इस फ़ाइल की शुरुआत में सभी पंजीकृत कोडेक्स की घोषणाओं की एक सूची है। इस सूची में हमारे कोडेक्स जोड़ें:

 extern AVCodec ff_frox_decoder; extern AVCodec ff_frox_encoder; 

निष्पादन के दौरान, configure स्क्रिप्ट ऐसी सभी घोषणाओं को ढूंढती है और libavcodec/codec_list.c उत्पन्न करती है, जिसमें libavcodec/allcodecs.c में घोषित libavcodec/allcodecs.c लिए एक सरणी libavcodec/allcodecs.c । फ़ाइल libavcodec/codec_list.c में स्क्रिप्ट निष्पादित करने के बाद हम देखेंगे:

 static const AVCodec * const codec_list[] = { // ... &ff_frox_encoder, // ... &ff_frox_decoder, // ... NULL }; 

इसके अलावा, configure स्क्रिप्ट के निष्पादन के दौरान, config.h फ़ाइल config.h , जिसमें हम घोषणाओं को पाते हैं

 #define CONFIG_FROX_DECODER 1 #define CONFIG_FROX_ENCODER 1 

चरण 5. libavcodec/Makefile संपादित करें

libavcodec/Makefile । हम अनुभाग # decoders/encoders पाते हैं, और वहां जोड़ते हैं

 OBJS-$(CONFIG_FROX_DECODER) += frox.o OBJS-$(CONFIG_FROX_ENCODER) += frox.o 

चरण 6. मल्टीप्लेक्स और डिम्टिप्लेक्सर के कोड को संपादित करें।

मल्टीप्लेक्स (muxer) और demultiplexer (demuxer) को नए कोडक को "जानना" चाहिए। रिकॉर्डिंग करते समय, इस कोडेक के लिए पहचान करने वाली जानकारी को रिकॉर्ड करना आवश्यक है, पढ़ते समय, पहचान करने वाली जानकारी से कोडेक के पहचानकर्ता को निर्धारित करें। यहां आपको matroska प्रारूप ( *.mkv ) के लिए क्या करने की आवश्यकता है।

1. फ़ाइल libavformat/matroska.c , नए कोडेक के लिए एक तत्व को libavformat/matroska.c सरणी में जोड़ें:

 const CodecTags ff_mkv_codec_tags[] = { // ... {"A_FROX", AV_CODEC_ID_FROX}, // ... }; 

स्ट्रिंग "A_FROX" और सूचना की पहचान के रूप में मल्टीप्लेक्सर द्वारा फाइल में लिखा जाएगा। इस सरणी में, यह कोडेक पहचानकर्ता के साथ जुड़ा हुआ है, इसलिए, जब पढ़ा जाता है, तो डीमुल्टिप्लेक्सर आसानी से इसे निर्धारित कर सकता है। Demultiplexer codec_id संरचना के codec_id सदस्य को कोडेक पहचानकर्ता लिखता है। इस संरचना का एक सूचक AVStream संरचना का सदस्य है।

2. फ़ाइल में libavformat/matroskaenc.c , additional_audio_tags libavformat/matroskaenc.c सरणी में तत्व जोड़ें:

 static const AVCodecTag additional_audio_tags[] = { // ... { AV_CODEC_ID_FROX, 0XFFFFFFFF }, // ... }; 

तो सब कुछ तैयार है। सबसे पहले, configure स्क्रिप्ट चलाएँ। उसके बाद, आपको यह सुनिश्चित करने की आवश्यकता है कि ऊपर वर्णित फ़ाइलें libavcodec/codec_list.c और config.h में बने हैं। फिर आप संकलन चला सकते हैं:

make clean
make


यदि संकलन ffmpeg.exe चला ffmpeg.exe , तो ffmpeg निष्पादन योग्य (या ffmpeg.exe , यदि लक्ष्य OS Windows है) प्रकट होता है। आदेश निष्पादित करें

./ffmpeg -codecs >codecs.txt


और सुनिश्चित करें कि FFmpeg हमारे नए कोडेक्स "देखता है", हम codecs.txt फ़ाइल में प्रविष्टि पाते हैं

DEA..S frox FROX audio (decoders: frox_dec) (encoders: frox_enc)


3. संदर्भ और आवश्यक कार्यों का विस्तृत विवरण

इस खंड में, हम अधिक विस्तार से वर्णन करते हैं कि कोडेक संदर्भ की संरचना और आवश्यक कार्य क्या दिख सकते हैं।

3.1। कोडेक संदर्भ

कोडेक संदर्भ विकल्पों की स्थापना का समर्थन कर सकता है। एनकोडर के लिए, यह समर्थन अक्सर पर्याप्त रूप से उपयोग किया जाता है, डिकोडर्स के लिए कम बार। विकल्पों की स्थापना का समर्थन करने वाली संरचना में पहले सदस्य के रूप में AVClass संरचना के लिए एक संकेतक होना चाहिए और फिर स्वयं विकल्प होंगे।

 #include "libavutil/opt.h" typedef struct FroxContext { const AVClass *av_class; int frox_int; char *frox_str; uint8_t *frox_bin; int bin_size; } FroxContext; 

अगला, आपको AVOption प्रकार की एक सरणी को परिभाषित करने की आवश्यकता है, जिसमें से प्रत्येक तत्व एक विशिष्ट विकल्प का वर्णन करता है।

 static const AVOption frox_options[] = { { "frox_int", "This is a demo option of int type.", offsetof(FroxContext, frox_int), AV_OPT_TYPE_INT, { .i64 = -1 }, 1, SHRT_MAX }, { "frox_str", "This is a demo option of string type.", offsetof(FroxContext, frox_str), AV_OPT_TYPE_STRING }, { "frox_bin", "This is a demo option of binary type.", offsetof(FroxContext, frox_bin), AV_OPT_TYPE_BINARY }, { NULL }, }; 

प्रत्येक विकल्प के लिए, आपको एक नाम, विवरण, संरचना में ऑफसेट, प्रकार को परिभाषित करना होगा। आप डिफ़ॉल्ट मान को भी परिभाषित कर सकते हैं और पूर्णांक विकल्पों के लिए मान्य मानों की एक श्रृंखला चुन सकते हैं।

अगला, आपको AVClass के प्रकार को परिभाषित करने की आवश्यकता है।

 static const AVClass frox_class = { .class_name = "FroxContext", .item_name = av_default_item_name, .option = frox_options, .version = LIBAVUTIL_VERSION_INT, }; 

इस उदाहरण के लिए एक पॉइंटर का उपयोग संबंधित AVCodec सदस्य को शुरू करने के लिए किया जाना चाहिए।

 AVCodec ff_frox_decoder = { // ... .priv_data_size = sizeof(FroxContext), .priv_class = &frox_class, // ... }; AVCodec ff_frox_encoder = { // ... .priv_data_size = sizeof(FroxContext), .priv_class = &frox_class, // ... }; 

अब फ़ंक्शन निष्पादित करते समय

 AVCodecContext *avcodec_alloc_context3(const AVCodec *codec); 

AVCodecContext संरचना का एक उदाहरण AVCodecContext और codec सदस्य को आरंभीकृत किया गया है। अगला, codec->priv_data_size आधार पर, आवश्यक मेमोरी को codec->priv_class का उपयोग करते हुए FroxContext उदाहरण के लिए आवंटित किया जाएगा codec->priv_class इस उदाहरण codec->priv_class पहले सदस्य को आरंभीकृत किया जाएगा और फिर av_opt_set_defaults() फ़ंक्शन को बुलाया जाएगा, जो विकल्पों के लिए डिफ़ॉल्ट मान सेट करेगा। FroxContext उदाहरण के लिए एक संकेतक priv_data संरचना के priv_data सदस्य के माध्यम से उपलब्ध होगा।

एफएफएमपीई एपीआई के साथ काम करते समय, विकल्पों के मूल्यों को सीधे सेट किया जा सकता है।

 const AVCodec *codec; // ... AVCodecContext *codec_ctx = avcodec_alloc_context3(codec); // ... av_opt_set(codec_ctx->priv_data, "frox_str", "meow", 0); av_opt_set_int(codec_ctx->priv_data, "frox_int", 42, 0); 

एक अन्य तरीका विकल्प शब्दकोश का उपयोग करना है, जो तीसरे तर्क के रूप में पारित किया जाएगा जब avcodec_open2() देखें (नीचे देखें)।

फ़ंक्शन का उपयोग करना

 const AVOption* av_opt_next(const void* ctx, const AVOption* prev); 

आप कोडेक संदर्भ द्वारा समर्थित सभी विकल्पों की एक सूची प्राप्त कर सकते हैं। यह एक कोडेक की जांच करते समय उपयोगी है। लेकिन इससे पहले, आपको यह सुनिश्चित करना होगा कि codec_ctx->codec->priv_class एक गैर-शून्य मान पर सेट है, अन्यथा संदर्भ विकल्पों का समर्थन नहीं करता है और विकल्पों के साथ कोई भी ऑपरेशन प्रोग्राम को क्रैश करेगा।

3.2। कार्यों

आइए अब हम अधिक विस्तार से जांचते हैं कि कोडक के प्रारंभ में उपयोग किए जाने वाले कार्य और वास्तविक एन्कोडिंग / डिकोडिंग की व्यवस्था कैसे की जाती है। वे आमतौर पर हमेशा एक FroxContext को पॉइंटर प्राप्त करने की आवश्यकता FroxContext ।

 AVCodecContext *codec_ctx; // ... FroxContext* frox_ctx = codec_ctx->priv_data; 

फ़ंक्शन निष्पादित होने पर frox_decode_init() और frox_encode_init() फ़ंक्शन को कॉल किया जाएगा

 int avcodec_open2( AVCodecContext *codec_ctx, const AVCodec *codec, AVDictionary **options); 

उन्हें काम करने के लिए कोडेक के लिए आवश्यक संसाधन आवंटित करने की आवश्यकता होती है, और यदि आवश्यक हो, तो AVCodecContext संरचना के कुछ सदस्यों को प्रारंभ करें, उदाहरण के लिए, एक ऑडियो frame_size लिए frame_size ।

frox_decode_close() और frox_encode_close() फ़ंक्शन को कॉल किया जाएगा

 int avcodec_close(AVCodecContext *codec_ctx); 

उन्हें आवंटित संसाधनों को मुक्त करने की आवश्यकता है।

डिकोडिंग लागू करने के लिए एक फ़ंक्शन पर विचार करें

 int frox_decode( AVCodecContext *codec_ctx, void *outdata, int *outdata_size, AVPacket *pkt); 

उसे निम्नलिखित कार्यों को लागू करना चाहिए:

1. वास्तविक डिकोडिंग;
2. आउटपुट फ्रेम के लिए आवश्यक बफर का आवंटन;
3. बफर डीकोड करने के लिए डेटा डिकोड किया गया।

विचार करें कि आउटपुट फ्रेम के लिए आवश्यक बफर कैसे आवंटित करें। AVFrame पैरामीटर वास्तव में AVFrame को AVFrame , इसलिए आपको पहले एक प्रकार का रूपांतरण करना होगा:

 AVFrame* frm = outdata; 

अगला, आपको फ्रेम डेटा संग्रहीत करने के लिए एक बफर आवंटित करने की आवश्यकता है। ऐसा करने के लिए, AVFrame सदस्यों को आरम्भ करें जो फ्रेम बफर आकार का निर्धारण करते हैं। ऑडियो के लिए, यह nb_samples , channel_layout , format (वीडियो की width , height , format ) है।

उसके बाद, आपको फ़ंक्शन को कॉल करने की आवश्यकता है

 int av_frame_get_buffer(AVFrame* frm, int alignment); 

फ़्रेम का पॉइंटर, जो परिवर्तित outdata पैरामीटर है, पहले तर्क के रूप में उपयोग किया जाता है, इसे दूसरे तर्क के रूप में शून्य पास करने की सिफारिश की जाती है। फ्रेम का उपयोग करने के बाद (यह पहले से ही कोडेक के बाहर होता है), इस फ़ंक्शन द्वारा आवंटित बफर को फ़ंक्शन द्वारा मुक्त किया जाता है

 void av_frame_unref(AVFrame* frm); 

frox_decode() फ़ंक्शन को frox_decode() द्वारा इंगित किए गए पैकेट से डिकोडिंग के लिए उपयोग किए जाने वाले बाइट्स की संख्या को वापस करना चाहिए। यदि फ़्रेम का निर्माण पूरा हो गया है, तो outdata_size द्वारा इंगित किया गया चर outdata_size मान निर्दिष्ट किया जाता है, अन्यथा इस चर का मान 0 हो जाता है।

कोडिंग को लागू करने के लिए एक फ़ंक्शन पर विचार करें

 int frox_encode( AVCodecContext *codec_ctx, AVPacket *pkt, const AVFrame *frame, int *got_pkt_ptr); 

उसे निम्नलिखित कार्यों को लागू करना चाहिए:

1. वास्तविक कोडिंग;
2. आउटपुट पैकेट के लिए आवश्यक बफर का आवंटन;
3. पैकेट बफर को एन्कोडेड डेटा कॉपी करें।

आवश्यक बफर का चयन करने के लिए, फ़ंक्शन का उपयोग करें

 int av_new_packet(AVPacket *pkt, int pack_size); 

पैरामीटर pkt उपयोग पहले तर्क के रूप में किया जाता है, और एन्कोडेड डेटा का आकार दूसरा है। पैकेज का उपयोग करने के बाद (यह पहले से ही कोडेक के बाहर होता है), इस फ़ंक्शन द्वारा आवंटित बफ़र्स को फ़ंक्शन द्वारा मुक्त किया जाता है

 void av_packet_unref(AVPacket *pkt); 

यदि पैकेज पूरा हो गया है, तो got_pkt_ptr द्वारा इंगित चर को गैर-शून्य मान असाइन किया जाता है, अन्यथा इस चर का मान 0 हो जाता है। यदि कोई त्रुटि नहीं है, तो फ़ंक्शन शून्य हो जाता है, अन्यथा एक त्रुटि कोड।

कोडेक को लागू करते समय, लॉगिंग का आमतौर पर उपयोग किया जाता है (त्रुटियों के लिए यह एक अनिवार्य आवश्यकता माना जा सकता है)। यहाँ एक उदाहरण है:

 static int frox_decode_close(AVCodecContext *codec_ctx) { av_log(codec_ctx, AV_LOG_INFO, "FROX decode close\n"); // ... } 

इस स्थिति में, लॉग में आउटपुट करते समय, कोडेक नाम को संदर्भ नाम के रूप में उपयोग किया जाएगा।

3.3। समय टिकट

FFmpeg में समय निर्धारित करने के लिए, एक समय आधार का उपयोग किया जाता है, AVRational प्रकार द्वारा दर्शाए गए परिमेय संख्या का उपयोग करके सेकंड में निर्दिष्ट किया जाता है। (C ++ 11 में एक समान दृष्टिकोण का उपयोग किया जाता है। उदाहरण के लिए, 1/1000 मिलीसेकंड सेट करता है।) फ़्रेम और पैकेट में टाइप int64_t टाइमस्टैम्प्स होते हैं, उनके मानों में संबंधित समय इकाइयों में समय होता है। एक फ्रेम, जो कि एक AVFrame संरचना है, में एक सदस्य pts (प्रस्तुति टाइमस्टैम्प) है, जिसका मान फ्रेम में कैप्चर किए गए दृश्य के सापेक्ष समय को निर्धारित करता है। एक पैकेज, जो कि एक AVPacket संरचना है, में सदस्य pts (प्रेजेंटेशन टाइमस्टैम्प) और dts (डीकंप्रेसन टाइमस्टैम्प) हैं। मूल्य dts डिकोडिंग के लिए पैकेट के प्रसारण के सापेक्ष समय को निर्धारित करता है। सरल कोडेक्स के लिए, यह pts के समान है, लेकिन जटिल कोडेक्स के लिए यह भिन्न हो सकता है (उदाहरण के लिए, बी-फ्रेम का उपयोग करते समय h264 लिए), अर्थात, पैकेट को गलत क्रम में डिकोड किया जा सकता है जिसमें फ्रेम का उपयोग किया जाना चाहिए।

टाइम यूनिट को स्ट्रीम और कोडेक के लिए परिभाषित किया गया है, AVStream संरचना में एक ही सदस्य है - time_base , उसी सदस्य के पास AVCodecContext संरचना है।

av_read_frame() का उपयोग करके स्ट्रीम से निकाले गए पैकेट का टाइमस्टैम्प इस स्ट्रीम के समय की इकाइयों में निर्दिष्ट किया जाएगा। डिकोडिंग करते समय, कोडेक की टाइम यूनिट का उपयोग नहीं किया जाता है। वीडियो डिकोडर के लिए, यह आमतौर पर सेट नहीं किया जाता है, ऑडियो डिकोडर के लिए इसका एक मानक मूल्य है - नमूना आवृत्ति का उलटा। डिकोडर को पैकेट के टाइम स्टैम्प के आधार पर आउटपुट फ्रेम के लिए एक टाइम स्टैम्प सेट करना चाहिए। FFmpeg स्वतंत्र रूप से इस तरह के एक लेबल को परिभाषित करता है और इसे best_effort_timestamp संरचना के best_effort_timestamp सदस्य को best_effort_timestamp है। ये सभी टाइमस्टैम्प उस धारा के समय की इकाई का उपयोग करेंगे जहां से पैकेट निकाला जाता है।

एनकोडर के लिए, आपको समय की इकाई को निर्दिष्ट करना होगा। डिकोडिंग को व्यवस्थित करने वाले क्लाइंट कोड में, आपको avcodec_open2() कॉल करने से पहले time_base संरचना के time_base सदस्य के लिए मान सेट करना होगा। आमतौर पर इनकोडिंग फ्रेम के समय टिकटों के लिए उपयोग की जाने वाली समय की इकाई लें। यदि ऐसा नहीं किया जाता है, तो वीडियो एनकोडर आमतौर पर एक त्रुटि देते हैं, ऑडियो एनकोडर डिफ़ॉल्ट मान सेट करते हैं - नमूना आवृत्ति का व्युत्क्रम। क्या कोई कोडेक किसी दिए गए यूनिट को बदल सकता है या नहीं यह पूरी तरह स्पष्ट नहीं है बस मामले में, avcodec_open2() को कॉल करने के बाद हमेशा time_base मान की जांच करना बेहतर होता है, और अगर यह बदल गया है, तो कोडेक के टाइम यूनिट के लिए इनपुट फ्रेम के टाइमस्टैम्प को पुनर्गणना करें। एन्कोडिंग प्रक्रिया में, आपको पैकेज के dts और dts को स्थापित करना होगा। एन्कोडिंग के बाद, आउटपुट स्ट्रीम पर एक पैकेट लिखने से पहले, कोडेक टाइम यूनिट से स्ट्रीम टाइम यूनिट के लिए पैकेट टाइमस्टैम्प को पुनर्गणना करना आवश्यक है। ऐसा करने के लिए, फ़ंक्शन का उपयोग करें

 void av_packet_rescale_ts( AVPacket *pkt, AVRational tb_src, AVRational tb_dst); 

पैकेट को स्ट्रीम में लिखते समय, यह सुनिश्चित करना आवश्यक है कि dts मूल्यों में सख्ती से वृद्धि हो, अन्यथा मल्टीप्लेक्स एक त्रुटि फेंक देगा। (अधिक जानकारी के लिए, av_interleaved_write_frame() फ़ंक्शन के लिए दस्तावेज़ देखें।)

3.4। कोडेक द्वारा उपयोग किए जाने वाले अन्य कार्य

जब आप किसी AVCodec उदाहरण को प्रारंभ करते हैं, तो दो और फ़ंक्शन पंजीकृत किए जा सकते हैं। यहाँ AVCodec के संबंधित सदस्य हैं:

 typedef struct AVCodec { // ... void (*init_static_data)(AVCodec *codec); void (*flush)(AVCodecContext *codec_ctx); // ... } AVCodec; 

उनमें से पहले को कोडेक के पंजीकरण के बाद एक बार बुलाया जाता है।

दूसरा कोडेक की आंतरिक स्थिति को रीसेट करता है, इसे फ़ंक्शन के निष्पादन के दौरान कहा जाएगा

 void avcodec_flush_buffers(AVCodecContext *codec_ctx); 

यह कॉल आवश्यक है, उदाहरण के लिए, जब वर्तमान प्लेबैक स्थिति को जबरन बदलना।

4. कोडेक के बाहरी कार्यान्वयन

4.1। बाहरी फ़ंक्शन कनेक्शन

कोडेक के निम्नलिखित संगठन पर विचार करें: FFmpeg में पंजीकृत कोडेक एक फ्रेमवर्क की भूमिका निभाता है, और FFmpeg के बाहर कार्यान्वित बाहरी कार्यों (एक तरह के प्लगइन्स) के लिए वास्तविक एन्कोडिंग / डिकोडिंग प्रक्रिया को दर्शाता है।

. यहाँ उनमें से कुछ हैं:

1. , FFmpeg ;
2. C, , C++;
3. framework, FFmpeg.

, FFmpeg «», FFmpeg API. «» FFmpeg ( , ), . — . .

 typedef int(*dec_extern_t)(const void*, int, void*); static int frox_decode( AVCodecContext* codec_ctx, void* outdata, int *outdata_size, AVPacket* pkt) { int ret = -1; void* out_buff; //      out_buff FroxContext *fc = codec_ctx->priv_data; if (fc->bin_size > 0) { if (fc->bin_size == sizeof(dec_extern_t)) { dec_extern_t edec; memcpy(&edec, fc->frox_bin, fc->bin_size); ret = (*edec)(pkt->data, pkt->size, out_buff); if (ret >= 0) { //     out_buff   } } else { /*  */ } } else { /*    */ } // ... return ret; } 

FFmpeg API ( C++) .

 extern "C" { int DecodeFroxData(const void* buff, int size, void* outBuff); typedef int(*dec_extern_t)(const void*, int, void*); #include <libavcodec/avcodec.h> #include <libavutil/opt.h> } // ... AVCodecContext* ctx; // ... dec_extern_t dec = DecodeFroxData; void* pv = &dec; auto pb = static_cast<const uint8_t*>(pv); auto sz = sizeof(dec); av_opt_set_bin(ctx->priv_data, "frox_bin", pb, sz, 0); 

4.2.

— . , . , . , , FFmpeg , «» , . . , . FFmpeg API - , , . . , . PC (Windows) DirectShow AVI . PC - DirectShow. 32- FourCC. ( biCompression BITMAPINFOHEADER .) , DirectShow , PC -. FFmpeg , , , codec_tag AVCodecParameters FourCC, . FFmpeg API , . FFmpeg FFmpeg API.

, *.mkv FFmpeg ( ENCODER ).

निष्कर्ष

, , FFmpeg: , changelog, .. «» FFmpeg, , .

साधन

FFmpeg

[1] FFmpeg —
[2] FFmpeg —
[3] FFmpeg —
[4] FFmpeg — Ubuntu

[5] FFmpeg Compilation Guide
[6] Compilation of FFmpeg 4.0 in Windows 10

FFmpeg API

[7] ffmpeg

[8] FFmpeg codec HOWTO
[9] FFmpeg video codec tutorial