Ffmpeg वीडियो प्लेयर को अंतिम रूप देना

पिछले लेख में, ffmpeg के मुख्य घटकों पर विचार किया गया था और उनके आधार पर एक सरल खिलाड़ी को डिकोडिंग गति के साथ वीडियो को सिंक्रनाइज़ किए बिना बनाया गया था।
इस लेख में, हम ध्वनि प्रजनन को जोड़ने और सिंक्रनाइज़ेशन से निपटने के तरीके को देखेंगे।

परिचय

मल्टीमीडिया के साथ काम करने के लिए अधिकांश एप्लिकेशन और मल्टीमीडिया फ्रेमवर्क एक ग्राफ पर आधारित होते हैं। ग्राफ़ नोड्स वे ऑब्जेक्ट हैं जो एक विशिष्ट कार्य करते हैं। उदाहरण के लिए, वीडियो प्लेयर के ऐसे ग्राफ पर विचार करें।

कार्य डेटा रीडिंग ब्लॉक से शुरू होता है, जिसमें हमारे मामले में फ़ाइल पढ़ी जाती है। अधिक सामान्य स्थिति में, यह एक नेटवर्क पर या एक हार्डवेयर स्रोत से डेटा प्राप्त कर रहा है।
Demultiplexing आने वाली धारा को कई आउटगोइंग वाले (उदाहरण के लिए, ऑडियो और वीडियो) में विभाजित करता है। Demultiplexing डेटा कंटेनर के स्तर पर काम करता है, अर्थात्, इस स्तर पर यह पूरी तरह से उदासीन है कि यह या उस धारा को कूटबद्ध किया गया है। कंटेनरों के उदाहरण: AVI, MPEG-TS, MP4, FLV।
डिम्टिप्लेक्सिंग के बाद, ब्लॉक में प्राप्त धाराओं का डिकोडिंग वीडियो डिकोडिंग और ऑडियो डिकोडिंग किया जाता है। डिकोडर मानक प्रारूपों में डेटा आउटपुट करेगा - वीडियो के लिए YUV या RGB फ्रेम और ऑडियो के लिए PCM डेटा। डिकोडिंग आमतौर पर अलग-अलग धाराओं में किया जाता है। वीडियो को प्रदर्शित करना वीडियो को स्क्रीन पर प्रदर्शित करता है, और बजाना ऑडियो परिणामी ऑडियो स्ट्रीम निभाता है।

कार्यान्वयन

हम अपने खिलाड़ी के लिए समान कार्यान्वयन का उपयोग करेंगे। एक अलग स्ट्रीम में हम फाइल को पढ़ेंगे और इसे दूसरी स्ट्रीम में वीडियो और ऑडियो को डीकोड कर सकते हैं। फिर स्क्रीन पर छवि प्रदर्शित करने और ऑडियो चलाने के लिए एसडीएल का उपयोग करें। आवेदन के मुख्य धागे में, हम एसडीएल घटनाओं की प्रक्रिया करेंगे।

इस उदाहरण के लिए कोड काफी बड़ा हो गया, मैंने इसे पूरी तरह से यहां नहीं देने का फैसला किया। मैं केवल मौलिक बिंदु दिखाऊंगा। सभी कोड को लेख के अंत में लिंक पर देखा जा सकता है।

सबसे पहले, हम सभी मुख्य चर को एक समान संदर्भ में जोड़ते हैं:

typedef struct MainContext { AVFormatContext *format_context; // Streams Stream video_stream; Stream audio_stream; // Queues PacketQueue videoq; PacketQueue audioq; /* ... */ } MainContext; 

यह संदर्भ सभी थ्रेड्स को दिया जाएगा। वीडियो_स्ट्रीम और ऑडियो_स्ट्रीम में क्रमशः सूचना और वीडियो और ऑडियो स्ट्रीम शामिल हैं। वीडियोक और ऑडियोक एक कतार हैं, जिसमें डेमल्टिप्लेक्सिंग स्ट्रीम रीड पैकेट को जोड़ देगा। इन परिवर्तनों को देखते हुए, डिमक्स कोड ( demux_thread ) पूरी तरह से सरल होगा और निम्नलिखित रूप लेगा:

 AVPacket packet; while (av_read_frame(main_context->format_context, &packet) >= 0) { if (packet.stream_index == video_stream_index) { // Video packet packet_queue_put(&main_context->videoq, &packet); } else if (packet.stream_index == audio_stream_index) { // Audio packet packet_queue_put(&main_context->audioq, &packet); } else { av_free_packet(&packet); } } 

यहां हमने फ़ाइल से अगला पैकेट पढ़ा, और, धारा के प्रकार पर निर्भर करते हुए, इसे डिकोडिंग के लिए उपयुक्त कतार में रखा। यह डीमुल्टिप्लेक्सिंग स्ट्रीम का मुख्य कार्य है; इसमें कोई अधिक क्रिया नहीं की जाती है।
अब अधिक जटिल वीडियो और ऑडियो डिकोडिंग धाराओं पर विचार करें।

वीडियो चलाएं

वीडियो को डिकोड करने और प्रदर्शित करने की प्रक्रिया पर पिछले लेख में चर्चा की गई थी। मुख्य कोड अपरिवर्तित रहा, लेकिन दो भागों में विभाजित किया गया - वीडियो डिकोडिंग, एक अलग थ्रेड ( video_decode_thread ) और विंडो डिस्प्ले ( video_refresh_timer ) में प्रदर्शन, टाइमर द्वारा मुख्य थ्रेड में निष्पादित। यह पृथक्करण सिंक्रनाइज़ेशन के कार्यान्वयन को सुविधाजनक बनाने के लिए आवश्यक है, जिसे हम लेख के दूसरे भाग में विचार करेंगे।

छवि को अपडेट करना टाइमर द्वारा किया जाता है, और एक अलग थ्रेड में नहीं, क्योंकि एसडीएल को यह आवश्यक है कि वीडियो के साथ संचालन एप्लिकेशन के मुख्य धागे में किया जाए। इसी तरह, आप एक मनमाना स्ट्रीम से ओवरले नहीं बना सकते। उदाहरण के लिए, एसडीएल घटनाओं और एक स्थिति चर का उपयोग करके इस सीमा को दरकिनार किया जा सकता है। लेकिन हम ऐसा नहीं करेंगे। हम खुद को एक ओवरले तक सीमित रखते हैं, जिसे हम डिकोडिंग शुरू होने से पहले बनाएंगे।

ऑडियो चलाएं

कंप्यूटर पर ध्वनि नमूनों की एक सतत धारा है। प्रत्येक नमूना एक तरंग मूल्य है। ध्वनियाँ एक विशिष्ट नमूने दर पर दर्ज की जाती हैं, और उन्हें समान आवृत्ति पर पुन: प्रस्तुत किया जाना चाहिए। नमूनाकरण दर प्रति सेकंड नमूनों की संख्या है। उदाहरण के लिए, प्रति सेकंड 44,100 नमूने एक ऑडियो सीडी का नमूना आवृत्ति है। इसके अलावा, ऑडियो में कई चैनल हो सकते हैं। उदाहरण के लिए, स्टीरियो नमूने के लिए एक बार में दो आएँगे। किसी फ़ाइल से डेटा प्राप्त करते समय, यह ज्ञात नहीं होता है कि कितने नमूने प्राप्त होंगे, लेकिन FFmpeg अपूर्ण नमूने नहीं देगा। इसका मतलब यह भी है कि एफएफएमपी स्टीरियो नमूनों को विभाजित नहीं करेगा।

पहला कदम ऑडियो आउटपुट के लिए एसडीएल को कॉन्फ़िगर करना है। आरंभिक फ़ंक्शन में आपको ध्वज SDL_INIT_AUDIO जोड़ना होगा। फिर SDL_AudioSpec संरचना भरें और इसे SDL_OpenAudio फ़ंक्शन में पास करें:

 SDL_AudioSpec wanted_spec, spec; // Set audio settings from codec info wanted_spec.freq = codec_context->sample_rate; wanted_spec.format = AUDIO_S16SYS; wanted_spec.channels = codec_context->channels; wanted_spec.silence = 0; wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE; wanted_spec.callback = audio_callback; wanted_spec.userdata = main_context; if (SDL_OpenAudio(&wanted_spec, &spec) < 0) { fprintf(stderr, "SDL: %s\n", SDL_GetError()); return -1; } SDL_PauseAudio(0); 

SDL ऑडियो को आउटपुट करने के लिए कॉलबैक फ़ंक्शन कॉल का उपयोग करता है।
संरचना में निम्नलिखित पैरामीटर हैं:

• freq : नमूनाकरण दर।
• प्रारूप : संचरित डेटा का प्रारूप। "AUDIO_S16SYS" में "S" प्रतीक का अर्थ है कि डेटा पर हस्ताक्षर किए जाएंगे, 16 - नमूना आकार 16 बिट्स, "SYS" है - सिस्टम बाइट ऑर्डर का उपयोग किया जाता है। यह इस प्रारूप में है कि एफएफएमपीपी डिकोड किए गए डेटा को लौटाता है।
• चैनल : ऑडियो चैनलों की संख्या।
• मौन : मौन का अर्थ है। हस्ताक्षरित डेटा के लिए, आमतौर पर 0 का उपयोग किया जाता है।
• नमूने : एसडीएल ऑडियो बफर का आकार। सामान्य मान 512 और 8192 बाइट्स के बीच होते हैं। हम 1024 का उपयोग करेंगे।
• कॉलबैक : डेटा के साथ बफर को भरने के लिए कॉलबैक फ़ंक्शन।
• userdata : उपयोगकर्ता डेटा कॉलबैक फ़ंक्शन में पास हुआ। हम यहां अपने मुख्य संदर्भ का उपयोग करते हैं।

SDL_PauseAudio (0) के लिए कॉल ध्वनि प्लेबैक शुरू करता है। यदि बफर में कोई डेटा नहीं है, तो "मौन" खेला जाएगा।

ऑडियो डिकोडिंग

जैसा कि आप शायद याद करते हैं, जब डीमोल्टिप्लेक्सिंग, हम पढ़े गए पैकेट को एक अलग ऑडियो क्यू में डालते हैं । ऑडियो_डॉस्कोप_थ्रेड डिकोडिंग फ़ंक्शन का मुख्य उद्देश्य पैकेट को कतार से प्राप्त करना है, इसे डीकोड करना और इसे दूसरे बफर में डालना है, जिसे तब फ़ंक्शन में पढ़ा जाएगा जिसे हमने SDL_OpenAudio में निर्दिष्ट किया था ।

हम इस तरह के बफर के रूप में एक परिपत्र बफर का उपयोग करेंगे। मुख्य कार्यों के प्रोटोटाइप:

 int ring_buffer_write(RingBuffer* rb, void* buffer, int len, int block); int ring_buffer_read(RingBuffer* rb, void* buffer, int len, int block); 

तर्कों का उद्देश्य नाम से स्पष्ट होना चाहिए। ब्लॉक तर्क इंगित करता है कि क्या फ़ंक्शन को अवरुद्ध किया जाना चाहिए यदि पर्याप्त बफर स्थान नहीं है या पढ़ने के लिए कोई डेटा नहीं है।

तो, पूरे डिकोडिंग फ़ंक्शन निम्नानुसार है:

 static int audio_decode_thread(void *arg) { assert(arg != NULL); MainContext* main_context = (MainContext*)arg; Stream* audio_stream = &main_context->audio_stream; AVFrame frame; while (1) { avcodec_get_frame_defaults(&frame); // Get packet from queue AVPacket pkt; packet_queue_get(&main_context->audioq, &pkt, 1); // The audio packet can contain several frames int got_frame; int len = avcodec_decode_audio4(audio_stream->codec_context, &frame, &got_frame, &pkt); if (len < 0) { av_free_packet(&pkt); fprintf(stderr, "Failed to decode audio frame\n"); break; } if (got_frame) { // Store frame // Get decoded buffer size int data_size = av_samples_get_buffer_size(NULL, audio_stream->codec_context->channels, frame.nb_samples, audio_stream->codec_context->sample_fmt, 1); ring_buffer_write(&main_context->audio_buf, frame.data[0], data_size, 1); } av_free_packet(&pkt); } return 0; } 

ऑडियो पैकेट avcodec_decode_audio4 फ़ंक्शन द्वारा डिकोड किया गया है । यदि संपूर्ण फ़्रेम डिकोड किया गया है ( got_frame ध्वज), तो बाइट्स में बफ़र का आकार av_samples_get_buber_size फ़ंक्शन का उपयोग करके निर्धारित करें और इसे हमारी रिंग बफर पर लिखें।

ऑडियो चलाएं

यह केवल एक छोटा सा रहता है, अर्थात् डिकोड किए गए नमूनों को खेलने के लिए। यह कॉलबैक फ़ंक्शन ऑडियो_ कॉलबैक में किया जाता है:

 static void audio_callback(void* userdata, uint8_t* stream, int len) { assert(userdata != NULL); MainContext* main_context = (MainContext*)userdata; ring_buffer_read(&main_context->audio_buf, stream, len, 1); } 

यहां सब कुछ प्राथमिक है। हम लेन बफर से बाइट्स प्राप्त करते हैं और उन्हें प्रदान किए गए एसडीएल बफर में बचाते हैं।

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

तुल्यकालन

किसी फ़ाइल में वीडियो और ऑडियो स्ट्रीम के बारे में जानकारी होती है कि किस क्षण और किस गति से उन्हें चलाने की आवश्यकता है। ऑडियो स्ट्रीम के लिए, यह नमूना दर है जो हम पिछले भाग में मिले थे, और वीडियो स्ट्रीम के लिए, यह फ्रेम प्रति सेकंड ( FPS ) की संख्या है। हालाँकि, आप केवल इन मानों के आधार पर सिंक्रनाइज़ नहीं कर सकते, क्योंकि कंप्यूटर एक आदर्श उपकरण नहीं है, और अधिकांश वीडियो फ़ाइलों में इन मापदंडों के लिए गलत मान हैं। इसके बजाय, धारा के प्रत्येक पैकेट में दो मान होते हैं - एक डिकोडिंग टाइमस्टैम्प (DTS) और एक प्रस्तुति टाइमस्टैम्प ( PTS )। दो अलग-अलग मूल्यों का अस्तित्व इस तथ्य के कारण है कि फ़ाइल में फ़्रेम ऑर्डर से बाहर जा सकता है। यह संभव है अगर वीडियो में बी-फ़्रेम हैं ( द्वि-पूर्वानुमान चित्र , एक फ्रेम जो पिछले और अगले दोनों फ़्रेमों पर निर्भर करता है)। वीडियो पर बार-बार फ्रेम भी हो सकते हैं।

तीन तुल्यकालन विकल्प हैं:

• ऑडियो के लिए वीडियो का सिंक्रनाइज़ेशन;
• ऑडियो से वीडियो सिंक्रनाइज़ेशन;
• बाहरी जनरेटर के साथ वीडियो और ऑडियो का सिंक्रनाइज़ेशन;

इन विकल्पों में से सबसे सरल पर विचार करें, अर्थात् ऑडियो के लिए वीडियो का सिंक्रनाइज़ेशन । वर्तमान फ्रेम को प्रदर्शित करने के बाद, हम पीटीएस पर आधारित अगले एक के प्रदर्शन समय की गणना करेंगे। हम छवि को अपडेट करने के लिए एसडीएल टाइमर का उपयोग करेंगे।

हमारे मुख्य संदर्भ में, निम्नलिखित फ़ील्ड जोड़ें:

 typedef struct MainContext { /* ... */ double video_clock; double audio_clock; double frame_timer; double frame_last_pts; double frame_last_delay; /* ... */ } MainContext; 

• video_clock : वीडियो प्रदर्शन आवृत्ति;
• Audio_clock : ऑडियो प्लेबैक आवृत्ति;
• फ्रेम_मीटर : वर्तमान प्रदर्शन समय मूल्य;
• फ्रेम_ब्लेस्ट_इप्स : दिखाए गए अंतिम फ्रेम का पीटीएस मान;
• फ्रेम_ब्लास्ट_डेले : दिखाए गए अंतिम फ्रेम का विलंब मूल्य;

आरंभीकरण के दौरान, फ़्रेम_टाइमर को प्रारंभिक मान असाइन करें:

 main_context->frame_timer = (double)av_gettime() / 1000000.0; 

वीडियो डिकोडिंग स्ट्रीम में, हम निम्नलिखित फ्रेम के प्रदर्शन समय की गणना करेंगे:

 double pts = frame.pkt_dts; if (pts == AV_NOPTS_VALUE) { pts = frame.pkt_pts; } if (pts == AV_NOPTS_VALUE) { pts = 0; } pts *= av_q2d(main_context->video_stream->time_base); pts = synchronize_video(main_context, &frame, pts); 

आप देख सकते हैं कि pts मान तीन में से एक मान ले सकता है:

• Frame.pkt_dts : FFmpeg डिकोडिंग के दौरान फ्रेम को रीक्रिएट करता है, ताकि DTS मूल्य डीकोड किए गए फ्रेम के PTS मूल्य से मेल खाता हो। इस मामले में, हम DTS का उपयोग करते हैं।
• फ़्रेम। pkt_pts : यदि कोई DTS मान नहीं है, तो PTS का उपयोग करके देखें।
• 0 : यदि दोनों मान गायब हैं, तो हम अंतिम सहेजे गए वीडियो आवृत्ति मान का उपयोग करेंगे।

फ़ंक्शन कोड सिंक्रोनाइज़_विडियो :

 double synchronize_video(MainContext* main_context, AVFrame *src_frame, double pts) { assert(main_context != NULL); assert(src_frame != NULL); AVCodecContext* video_codec_context = main_context->video_stream->codec; if(pts != 0) { /* if we have pts, set video clock to it */ main_context->video_clock = pts; } else { /* if we aren't given a pts, set it to the clock */ pts = main_context->video_clock; } /* update the video clock */ double frame_delay = av_q2d(video_codec_context->time_base); /* if we are repeating a frame, adjust clock accordingly */ frame_delay += src_frame->repeat_pict * (frame_delay * 0.5); main_context->video_clock += frame_delay; return pts; } 

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

ऑडियो डिकोडिंग स्ट्रीम में, हम ऑडियो फ़्रीक्वेंसी को सहेजेंगे, ताकि बाद में इसे इसके लिए सिंक्रोनाइज़ किया जा सके:

 if (pkt.pts != AV_NOPTS_VALUE) { main_context->audio_clock = av_q2d(main_context->audio_stream->time_base) * pkt.pts; } else { /* if no pts, then compute it */ main_context->audio_clock += (double)data_size / (audio_codec_context->channels * audio_codec_context->sample_rate * av_get_bytes_per_sample(audio_codec_context->sample_fmt)); } 

वीडियो प्रदर्शन समारोह में, हम निम्नलिखित फ्रेम को प्रदर्शित करने से पहले देरी की गणना करेंगे:

 double delay = compute_delay(main_context); schedule_refresh(main_context, (int)(delay * 1000 + 0.5)); 

खैर, हमारे तुल्यकालन का "दिल" कंप्यूट_डेल है:

 static double compute_delay(MainContext* main_context) { double delay = main_context->pict.pts - main_context->frame_last_pts; if (delay <= 0.0 || delay >= 1.0) { // Delay incorrect - use previous one delay = main_context->frame_last_delay; } // Save for next time main_context->frame_last_pts = main_context->pict.pts; main_context->frame_last_delay = delay; // Update delay to sync to audio double ref_clock = get_audio_clock(main_context); double diff = main_context->pict.pts - ref_clock; double sync_threshold = FFMAX(AV_SYNC_THRESHOLD, delay); if (fabs(diff) < AV_NOSYNC_THRESHOLD) { if (diff <= -sync_threshold) { delay = 0; } else if (diff >= sync_threshold) { delay = 2 * delay; } } main_context->frame_timer += delay; double actual_delay = main_context->frame_timer - (av_gettime() / 1000000.0); if(actual_delay < 0.010) { /* Really it should skip the picture instead */ actual_delay = 0.010; } return actual_delay; } 

सबसे पहले, हम पिछले और वर्तमान फ्रेम के बीच देरी की गणना करते हैं और वर्तमान मूल्यों को बचाते हैं। उसके बाद, हम ऑडियो के साथ संभावित desync को ध्यान में रखते हैं और अगले फ्रेम तक आवश्यक देरी की अवधि की गणना करते हैं।

वह सब है! हम खिलाड़ी को लॉन्च करते हैं और देखने का आनंद लेते हैं!

निष्कर्ष

इस भाग में, हमने सबसे सरल खिलाड़ी के विकास को पूरा किया, कार्यक्रम की संरचना में सुधार किया, ऑडियो प्लेबैक और सिंक्रनाइज़ेशन जोड़ा।
बिना पढ़े हुए विषय बने रहे: रिवाइंड, तेज / धीमी प्लेबैक, अन्य सिंक्रनाइज़ेशन विकल्प।
अभी भी कोडिंग और मल्टीप्लेक्सिंग का एक बिल्कुल अलग विषय है। शायद मैं अगले लेख में इस पर विचार करने की कोशिश करूंगा।

खिलाड़ी का स्रोत कोड ।

आपका ध्यान देने के लिए आप सभी का धन्यवाद!