🔘 ➗ 👡 DMABUF के माध्यम से OpenGLESv2 बनावट को पुनः लोड करना 👩🏽‍✈️ 🖖🏿 ❣️

इस लेख में मैं बात करना चाहता हूं कि DMABUF के माध्यम से OpenGLES बनावट को अपडेट करना कितना आसान है। मैंने हैबर में देखा और मेरे आश्चर्य को, इस विषय पर एक भी लेख नहीं मिला। हब्र Q & A में भी इसका कुछ पता नहीं चला। और यह मेरे लिए थोड़ा अजीब है। तकनीक काफी समय पहले दिखाई दी थी, हालांकि वास्तव में नेटवर्क पर इसके बारे में बहुत अधिक जानकारी नहीं है, यह सब अस्पष्ट और विरोधाभासी है।

इससे पहले कि मैं इस तरह के वीडियो प्लेयर को ऊपर के डेमो पर लिख पाऊं, मैंने यह सारी जानकारी अलग-अलग स्रोतों से थोड़ी-थोड़ी करके एकत्र की। यहाँ, डेमो पर, मेरे स्व-निर्मित वीडियो प्लेयर, जो कि gstreamer लाइब्रेरी पर आधारित है, रेंडर करने से पहले हर बार OpenGLESv2 टेक्सचर में वीडियो फ्रेम लोड करता है। रास्पबेरी Pi4 द्वारा संचालित। फ़्रेम को केवल एक विशेष रूप से आवंटित मेमोरी में कॉपी किया जाता है - और डीएमए उन्हें जीपीयू मेमोरी में टेक्सचर में स्थानांतरित करता है। आगे, मैं आपको बताऊंगा कि मैंने यह कैसे किया।

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

SoC सिंगल-बोर्ड वाले सहित कई आधुनिक कंप्यूटरों की वास्तुकला ऐसी है कि प्रोसेसर मेमोरी GPU मेमोरी से अलग है। आमतौर पर, उपयोगकर्ता प्रोग्रामों की GPU मेमोरी तक सीधी पहुंच नहीं होती है और आपको एक ही glTexSubImage2D () जैसे विभिन्न एपीआई कार्यों का उपयोग करने की आवश्यकता होती है। इसके अलावा, मैंने कहीं पढ़ा है कि बनावट का आंतरिक प्रतिनिधित्व पिक्सल्स के अनुक्रम के रूप में चित्रों के पारंपरिक प्रतिनिधित्व से भिन्न हो सकता है। मुझे नहीं पता कि यह कितना सच है। हो सकता है कि।

तो DMABUF तकनीक मुझे क्या देती है? मेमोरी को विशेष रूप से आवंटित किया गया है और किसी भी थ्रेड से एक प्रक्रिया केवल पिक्सेल लिख सकती है जब भी वह चाहे। डीएमए स्वयं जीपीयू की स्मृति में बनावट में सभी परिवर्तनों को स्थानांतरित करेगा। सुंदर है कि नहीं?

मुझे तुरंत यह कहना होगा कि मुझे PBO के बारे में पता है - Pixel Buffer Object, आमतौर पर PBO की मदद से डायनेमिक टेक्सचर अपडेट किया जाता है, DMA का उपयोग वहाँ भी किया जाने लगता है, लेकिन PBO केवल OpenGLESv3 में दिखाई दिया और सभी कार्यान्वयनों में नहीं। तो नहीं - अफसोस, यह मेरा तरीका नहीं है।

लेख रास्पबेरी प्रोग्रामर और गेम डेवलपर और शायद एंड्रॉइड प्रोग्रामर दोनों के लिए रुचि का हो सकता है, क्योंकि ओपनजीएलईएस का भी उपयोग किया जाता है और मुझे यकीन है कि यह डीएमएबीयूएफ तकनीक भी वहां मौजूद है (कम से कम मुझे यकीन है कि आप इसे एंड्रॉइड से उपयोग कर सकते हैं। NDK)।

मैं एक रास्पबेरी Pi4 पर DMABUF का उपयोग करके एक कार्यक्रम लिखूंगा। कार्यक्रम को ubuntu के तहत साधारण इंटेल x86 / x86_64 कंप्यूटर पर भी काम करना चाहिए (और होगा)।

इस लेख में, मैं मानता हूं कि आप पहले से ही OpenGLESv2 API के साथ ग्राफिक्स प्रोग्राम करना जानते हैं। हालांकि, इनमें से कई चुनौतियां नहीं होंगी। अधिकतर हमारे पास ioctl का जादू होगा।

इसलिए, पहली बात यह सुनिश्चित करना है कि प्लेटफॉर्म पर उपलब्ध एपीआई DMABUF का समर्थन करना चाहिए। ऐसा करने के लिए, ईजीएल एक्सटेंशन की सूची देखें:

char* EglExtString = (char*)eglQueryString( esContext->eglDisplay, EGL_EXTENSIONS ); if( strstr( EglExtString, "EGL_EXT_image_dma_buf_import") ) { cout << "DMA_BUF feature must be supported!!!\n"; }

इसलिए हम तुरंत समझ जाएंगे कि क्या DMABUF का उपयोग करने की उम्मीद है या कोई उम्मीद नहीं है। उदाहरण के लिए, रास्पबेरी Pi3 और सभी पिछले बोर्डों पर कोई उम्मीद नहीं है। बीआरसीएम ब्रोच के साथ विशेष पुस्तकालयों के माध्यम से, सामान्य तौर पर, यहां तक कि ओपनजीएलईएस 2 भी किसी तरह से नीचे छीन लिया गया है। और अब रास्पबेरी Pi4 पर एक वास्तविक OpenGLES है, विस्तार EGL_EXT_image_dma_buf_import है, हुर्रे।

मैं इस बात पर ध्यान देना चाहूंगा कि मेरे पास एकल-बोर्ड Pi4 पर मौजूद OS क्या है, अन्यथा इससे समस्याएं भी हो सकती हैं:

 pi@raspberrypi:~ $ lsb_release -a No LSB modules are available. Distributor ID: Raspbian Description: Raspbian GNU/Linux 10 (buster) Release: 10 Codename: buster pi@raspberrypi:~ $ uname -a Linux raspberrypi 4.19.75-v7l+ #1270 SMP Tue Sep 24 18:51:41 BST 2019 armv7l GNU/Linux

मैं यह भी नोट करता हूं कि EGL_EXT_image_dma_buf_import एक्सटेंशन ऑरेंज पाई पीसी (माली -400) / पीसी 2 (माली -450) पर है, जब तक कि आप इन बोर्डों पर माली जीपीयू नहीं चला सकते (आधिकारिक असेंबली में यह नहीं है, मैंने इसे आर्मबियन पर स्थापित किया है, साथ ही मैंने खुद इसे स्थापित किया है) कर्नेल ड्राइवर असेंबली)। यानी DMABUF लगभग हर जगह है। यह केवल लेने और उपयोग करने के लिए आवश्यक है।

इसके बाद, आपको फ़ाइल / dev / dri / card0 या / dev / dri / card1 खोलने की आवश्यकता है - उनमें से एक, यह प्लेटफ़ॉर्म पर निर्भर करता है, यह अलग तरह से होता है, आपको DRM_CAP_DUMB_BFFFF का समर्थन करने वाली फ़ाइल देखने की आवश्यकता है:

 int OpenDrm() { int fd = open("/dev/dri/card0", O_RDWR | O_CLOEXEC); if( fd < 0 ) { cout << "cannot open /dev/dri/card0\n"; return -1; } uint64_t hasDumb = 0; if( drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &hasDumb) < 0 ) { close( fd ); cout << "/dev/dri/card0 has no support for DUMB_BUFFER\n"; //maybe Raspberry Pi4 or other platform fd = open("/dev/dri/card1", O_RDWR | O_CLOEXEC); if( fd < 0 ) { cout << "cannot open /dev/dri/card1\n"; return -1; } hasDumb = 0; if( drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &hasDumb) < 0 ) { close( fd ); cout << "/dev/dri/card1 has no support for DUMB_BUFFER\n"; return -1; } } if( !hasDumb ) { close( fd ); cout << "no support for DUMB_BUFFER\n"; return -1; } //Get DRM authorization drm_magic_t magic; if( drmGetMagic(fd, &magic) ) { cout << "no DRM magic\n"; close( fd ); return -1; } Window root = DefaultRootWindow( x_display ); if( !DRI2Authenticate( x_display, root, magic ) ) { close( fd ); cout << "Failed DRI2Authenticate\n"; return -1; } cout << "DRM fd "<< fd <<"\n"; return fd; }

यहाँ वैसे मेरे लिए एक अकथनीय सूक्ष्मता है। कुछ प्लेटफार्मों में पुस्तकालय नहीं हैं जो DRI2Authenticate () फ़ंक्शन प्रदान करते हैं। उदाहरण के लिए, यह दरार में नहीं है और ऑरेंज पाई पीसी के लिए 32-बिट संस्करण में है। यह सब कुछ अजीब है। लेकिन मुझे GITHUB: github.com/robclark/libdri2 पर ऐसी रिपॉजिटरी मिली, इसे लिया, इकट्ठा और इंस्टॉल किया जा सकता है, फिर सब कुछ ठीक है। यह अजीब है कि लैपटॉप पर मेरे उबंटू 18 (64 बिट) में कोई समस्या नहीं है।

यदि आप पा सकते हैं और खोल सकते हैं / dev / dri / cardX खोल सकते हैं। आपको KHR (ख्रोनों) के तीन बहुत ही आवश्यक कार्यों तक पहुँचने की आवश्यकता है:

 PFNEGLCREATEIMAGEKHRPROC funcEglCreateImageKHR = nullptr; PFNEGLDESTROYIMAGEKHRPROC funcEglDestroyImageKHR = nullptr; PFNGLEGLIMAGETARGETTEXTURE2DOESPROC funcGlEGLImageTargetTexture2DOES = nullptr; ... funcEglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC) eglGetProcAddress("eglCreateImageKHR"); funcEglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC) eglGetProcAddress("eglDestroyImageKHR"); funcGlEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)eglGetProcAddress("glEGLImageTargetTexture2DOES"); if( funcEglCreateImageKHR && funcEglDestroyImageKHR && funcGlEGLImageTargetTexture2DOES ) { cout << "DMA_BUF feature supported!!!\n"; } else { CloseDrm(); }

अब हमें एक फ़ंक्शन की आवश्यकता है जो DMABUF के लिए एक मेमोरी क्षेत्र बनाता है। फ़ंक्शन पैरामीटर को बिटमैप चौड़ाई, ऊँचाई के साथ-साथ इंगित करता है, जिसमें DmaFd फ़ाइल डिस्क्रिप्टर हैंडलर और प्लेन बिटमैप मेमोरी के लिए एक पॉइंटर लौटाया जाएगा।

 nt CreateDmaBuf( int Width, int Height, int* DmaFd, void** Plane ) { int dmaFd = *DmaFd = 0; void* pplane = *Plane = nullptr; // Create dumb buffer drm_mode_create_dumb buffer = { 0 }; buffer.width = Width; buffer.height = Height; buffer.handle = 0; buffer.bpp = 32; //Bits per pixel buffer.flags = 0; int ret = drmIoctl( DriCardFd, DRM_IOCTL_MODE_CREATE_DUMB, &buffer); cout << "DRM_IOCTL_MODE_CREATE_DUMB " << buffer.handle << " " << ret << "\n"; if (ret < 0) { cout << "Error cannot DRM_IOCTL_MODE_CREATE_DUMB\n"; return -1; } // Get the dmabuf for the buffer drm_prime_handle prime; memset(&prime, 0, sizeof prime); prime.handle = buffer.handle; prime.flags = /*DRM_CLOEXEC |*/ DRM_RDWR; ret = drmIoctl( DriCardFd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &prime); if (ret < 0) { cout << "Error cannot DRM_IOCTL_PRIME_HANDLE_TO_FD " << errno << " " << ret <<"\n"; return -1; } dmaFd = prime.fd; // Map the buffer to userspace int Bpp = 32; pplane = mmap(NULL, Width*Height*Bpp/8, PROT_READ | PROT_WRITE, MAP_SHARED, dmaFd, 0); if( pplane == MAP_FAILED ) { cout << "Error cannot mmap\n"; return -1; } //return valid values *DmaFd = dmaFd; *Plane = pplane; cout << "DMABUF created "<< dmaFd << " " << (void*)Plane <<"\n"; return 0; }

अब हमें DmaFd हैंडलर से जुड़ी एक EGL छवि बनाने की आवश्यकता है:

 int CreateDmaBufferImage( ESContext* esContext, int Width, int Height, int* DmaFd, void** Plane, EGLImageKHR* Image ) { int dmaFd = 0; void* planePtr = nullptr; int Bpp = 32; int ret0 = CreateDmaBuf( Width, Height, &dmaFd, &planePtr ); if( ret0<0 ) return -1; EGLint img_attrs[] = { EGL_WIDTH, Width, EGL_HEIGHT, Height, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_ABGR8888, EGL_DMA_BUF_PLANE0_FD_EXT, dmaFd, EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0, EGL_DMA_BUF_PLANE0_PITCH_EXT, Width * Bpp / 8, EGL_NONE }; EGLImageKHR image = funcEglCreateImageKHR( esContext->eglDisplay, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, 0, &img_attrs[0] ); *Plane = planePtr; *DmaFd = dmaFd; *Image = image; cout << "DMA_BUF pointer " << (void*)planePtr << "\n"; cout << "DMA_BUF fd " << (int)dmaFd << "\n"; cout << "EGLImageKHR " << image << "\n"; return 0; }

और अंत में, हमारे परिणाम लगभग समाप्त हो गए हैं, और हमें ईजीएल छवि और ओपनजीएलईएस 2 छवि को जोड़ना होगा। फ़ंक्शन प्रक्रिया के पता स्थान में मेमोरी के लिए एक पॉइंटर लौटाता है। वहां आप बस किसी भी प्रोसेसर थ्रेड से लिख सकते हैं और समय के साथ सभी परिवर्तन स्वचालित रूप से डीएमएबीयूएफ के माध्यम से जीपीयू बनावट में दिखाई देते हैं।

 void* CreateVideoTexture( ESContext* esContext, int Width, int Height ) { CreateDmaBufferImage( esContext, Width, Height, &esContext->DmaFd, &esContext->Plane, &esContext->ImageKHR ); GLuint texId; glGenTextures ( 1, &texId ); glBindTexture ( GL_TEXTURE_2D, texId ); glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); funcGlEGLImageTargetTexture2DOES(GL_TEXTURE_2D, esContext->ImageKHR ); checkGlError( __LINE__ ); UserData *userData = (UserData*)esContext->userData; userData->textureV = texId; userData->textureV_ready = true; return esContext->Plane; }

GlEGLImageTargetTexture2DOES (..) फ़ंक्शन केवल यह बाध्यकारी करता है। यह सामान्य बनावट आईडी निर्माण glGenTextures (..) का उपयोग करता है और इसे पहले बनाए गए esContext-> ImageKHR EGL छवि के साथ जोड़ता है। उसके बाद, बनावट userData-> बनावट V का उपयोग नियमित शेड में किया जा सकता है। और सूचक esContext-> विमान स्मृति में उस क्षेत्र का एक संकेतक है जहां आपको बनावट को अपडेट करने के लिए लिखने की आवश्यकता होती है।

यहाँ एक कोड स्निपेट है जो एक वीडियो फ्रेम को कॉपी करता है:

 GstFlowReturn on_new_sample( GstAppSink *pAppsink, gpointer pParam ) { GstFlowReturn ret = GST_FLOW_OK; GstSample *Sample = gst_app_sink_pull_sample(pAppsink); if( Sample ) { if( VideoWidth==0 || VideoHeight==0 ) { GstCaps* caps = gst_sample_get_caps( Sample ); GstStructure* structure = gst_caps_get_structure (caps, 0); gst_structure_get_int (structure, "width", &VideoWidth); gst_structure_get_int (structure, "height", &VideoHeight); cout << "Stream Resolution " << VideoWidth << " " << VideoHeight << "\n"; } GstBuffer *Buffer = gst_sample_get_buffer( Sample ); if( Buffer ) { GstMapInfo MapInfo; memset(&MapInfo, 0, sizeof(MapInfo)); gboolean Mapped = gst_buffer_map( Buffer, &MapInfo, GST_MAP_READ ); if( Mapped ) { if( dmabuf_ptr ) memcpy( dmabuf_ptr, MapInfo.data, MapInfo.size ); gst_buffer_unmap( Buffer, &MapInfo); frame_ready = true; update_cv.notify_one(); } } gst_sample_unref( Sample ); } return ret; }

हर बार एक नया वीडियो फ़्रेम दिखाई देने पर यह फ़ंक्शन gstreamer द्वारा ही बुलाया जाता है। हम इसे gst_app_sink_pull_sample () का उपयोग करके पुनः प्राप्त करते हैं। इस फ़ंक्शन में मेमसीपी () है, जो फ्रेम को DMABUF मेमोरी में कॉपी करता है। फिर फ़्रेम_रेड ध्वज सेट किया गया है और std के माध्यम से :: condition_variable update_cv.notify_one (), जो स्ट्रीम रेंडर करता है वह जाग गया है।

शायद यही सब है ...

हालाँकि नहीं, मैं झूठ बोल रहा हूँ। अभी भी सिंक्रनाइज़ेशन के मुद्दे हैं।

पहला यह है कि प्रोसेसर मेमोरी को लिखता है, लेकिन ये रिकॉर्ड प्रोसेसर के कैश में समाप्त हो सकते हैं और वहां आयोजित होने के बाद, आपको रिकॉर्डिंग के बाद कैश कैश बनाने की आवश्यकता होती है। दूसरा - यह जानना बिल्कुल बुरा नहीं होगा कि डीएमए पहले ही काम कर चुका है और आप रेंडर करना शुरू कर सकते हैं। ईमानदारी से, अगर पहले मैं अभी भी कल्पना करता हूं कि कैसे करना है, तो दूसरा - नहीं। यदि आपके पास विचार हैं, तो टिप्पणियों में लिखें।

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

शायद आखिरी बिंदु: मेरी परियोजना में मैं 32-बिट बिटमैप का उपयोग करता हूं, जो मेरे मामले में अच्छा नहीं है। यह बहुत उचित होगा कि Ystreamer से YUV लिया जाए, तब वीडियो फ्रेम का आकार बहुत छोटा होता है, लेकिन तर्क जटिल है - मुझे अलग-अलग Y, U, V. खैर, तीन शेयर्स के लिए 3 DMABUF करना होगा। शैडर भी जटिल है, आपको YUV को ARGB में बदलने की आवश्यकता है सही में shader

आप पूरा प्रोजेक्ट गिथब पर देख सकते हैं। हालाँकि, मैं स्वच्छ और सही कोड / शैली के प्रेमियों के लिए पहले से माफी माँगता हूँ। मैं मानता हूं कि यह Google-खान-पेस्ट की मदद से लापरवाही से लिखा गया था।

DMABUF के माध्यम से OpenGLESv2 बनावट को पुनः लोड करना

More articles: