👄 👩🏻‍✈️ 👙 क्यूएमएल में हार्डवेयर त्वरित वीडियो की सरल शून्य-कॉपी रेंडरिंग 🤶🏻 👨🏾‍🏫 🏂🏼

परिचय

इस लेख का उद्देश्य यह प्रदर्शित करना है कि आप तृतीय-पक्ष वीडियो बफ़र और QML के साथ मित्र कैसे बना सकते हैं। मुख्य विचार VideoOutput के मानक QML घटक का उपयोग करना है। यह आपको तृतीय-पक्ष स्रोतों से दूर करने की अनुमति देता है, यह अच्छी तरह से प्रलेखित है और इसमें GL_OES_EGL_image_external का समर्थन करने वाला बैकएंड है।

जब मैं क्यूटी में कैमरे के साथ काम करने के उदाहरणों को चलाने की कोशिश कर रहा था, और एम्बेडेड प्लेटफ़ॉर्म पर वे 3-5 फ्रेम प्रति सेकंड की गति से काम करने की कोशिश करने के बाद यह विचार अचानक उत्पन्न हो सकता है। यह स्पष्ट हो गया कि बॉक्स से बाहर किसी भी शून्य-कॉपी का कोई सवाल ही नहीं था, हालाँकि प्लेटफ़ॉर्म यह सब पूरी तरह से समर्थन करता है। निष्पक्षता में, डेस्कटॉप पर, VideoOutput और कैमरा काम करते हैं, जैसा कि अपेक्षित था, जल्दी और अनावश्यक नकल के बिना। लेकिन मेरे कार्य में, वीडियो को कैप्चर करने के लिए मौजूदा कक्षाओं के साथ करना असंभव था, और मैं एक तृतीय-पक्ष स्रोत से वीडियो प्राप्त करना चाहता था, जो डिकोडिंग वीडियो के लिए एक मनमाने ढंग से Greareamer पाइपलाइन हो सकता है, उदाहरण के लिए, एक फ़ाइल या RTSP स्ट्रीम, या एक तृतीय-पक्ष API से जिसे आधार में एकीकृत किया जा सकता है। क्यूटी की कक्षाएं कुछ संदिग्ध हैं। आप निश्चित रूप से, एक बार फिर से पहिया को फिर से मजबूत कर सकते हैं और अपने घटक को ओपनजीएल के माध्यम से ड्राइंग के साथ लिख सकते हैं, लेकिन यह तुरंत एक जानबूझकर मृत अंत और कठिन तरीका लग रहा था।

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

सिद्धांत

VideoOutput कस्टम स्रोत का समर्थन करता है, बशर्ते कि

पारित वस्तु सीधे VideoSurface संपत्ति के माध्यम से QAbstractVideoSurface को स्वीकार कर सकती है
या QVideoRendererControl [लिंक] के साथ MediaObject के माध्यम से।

सूत्रों और प्रलेखन में एक खोज से पता चला है कि QtMultimedia में एक QAbstractVideoBuffer वर्ग है जो QPixmap से GLTexture और EGLImage तक विभिन्न प्रकार के हैंडल का समर्थन करता है। आगे की खोजों ने वीडोनोडे_ग्लग प्लगइन का नेतृत्व किया, जो उस फ्रेम को प्रस्तुत करता है जो नमूना के साथ shaplerExternalOES का उपयोग करके आया था। इसका मतलब यह है कि जब मैं EGLImage के साथ एक QAbstractVideoBuffer बनाने का प्रबंधन करता हूं, तो यह इस बफर को videnode_egl को पास करने का एक तरीका खोजने के लिए रहता है।
और अगर EGLImage प्लेटफ़ॉर्म समर्थित नहीं है, तो आप मेमोरी को रैप कर सकते हैं और रेंडरिंग के लिए भेज सकते हैं, क्योंकि अधिकांश पिक्सेल फॉर्मेट के लिए शेड पहले से ही लागू हैं।

कार्यान्वयन

उदाहरण लगभग पूरी तरह से वीडियो अवलोकन ट्यूटोरियल पर आधारित है।

Qt को डेस्कटॉप पर OpenGL ES के साथ काम करने के लिए, आपको Qt को संबंधित ध्वज के साथ पुनर्निर्माण करने की आवश्यकता है। डिफ़ॉल्ट रूप से, यह डेस्कटॉप के लिए सक्षम नहीं है।

सादगी के लिए, हम पहली विधि का उपयोग करेंगे, और वीडियो स्रोत के रूप में सरल GStreamer पाइपलाइन लें:

v4l2src ! appsink

एक V4L2Source वर्ग बनाएं जो इसके द्वारा निर्दिष्ट QAbstractVideoSurface को फ़्रेम वितरित करेगा।

 class V4L2Source : public QQuickItem { Q_OBJECT Q_PROPERTY(QAbstractVideoSurface* videoSurface READ videoSurface WRITE setVideoSurface) Q_PROPERTY(QString device MEMBER m_device READ device WRITE setDevice) Q_PROPERTY(QString caps MEMBER m_caps) public: V4L2Source(QQuickItem* parent = nullptr); virtual ~V4L2Source(); void setVideoSurface(QAbstractVideoSurface* surface); void setDevice(QString device); public slots: void start(); void stop(); private slots: void setWindow(QQuickWindow* win); void sync(); signals: void frameReady(); ... }

सब कुछ काफी तुच्छ है, सेटवॉइन () स्लॉट को छोड़कर - इसे QQuickItem :: windowChanged () सिग्नल को इंटरसेप्ट करने के लिए और कॉल करने के लिए QQuickWindow :: setSynchronizing () को सेट करना आवश्यक है।

चूंकि VideoOutput बैकएंड हमेशा नहीं जानता कि ईगलैमेज के साथ कैसे काम करना है, इसलिए आपको QAbstractVideoSurface से पूछना होगा कि दिए गए QAbstractVideoBuffer के लिए कौन से प्रारूप :: HandleType समर्थन का समर्थन करते हैं:

 void V4L2Source::setVideoSurface(QAbstractVideoSurface* surface) { if (m_surface != surface && m_surface && m_surface->isActive()) { m_surface->stop(); } m_surface = surface; if (surface ->supportedPixelFormats( QAbstractVideoBuffer::HandleType::EGLImageHandle) .size() > 0) { EGLImageSupported = true; } else { EGLImageSupported = false; } if (m_surface && m_device.length() > 0) { start(); } }

आइए हमारी पाइपलाइन बनाएं और आवश्यक कॉलबैक सेट करें:

 GstAppSinkCallbacks V4L2Source::callbacks = {.eos = nullptr, .new_preroll = nullptr, .new_sample = &V4L2Source::on_new_sample}; V4L2Source::V4L2Source(QQuickItem* parent) : QQuickItem(parent) { m_surface = nullptr; connect(this, &QQuickItem::windowChanged, this, &V4L2Source::setWindow); pipeline = gst_pipeline_new("V4L2Source::pipeline"); v4l2src = gst_element_factory_make("v4l2src", nullptr); appsink = gst_element_factory_make("appsink", nullptr); GstPad* pad = gst_element_get_static_pad(appsink, "sink"); gst_pad_add_probe(pad, GST_PAD_PROBE_TYPE_QUERY_BOTH, appsink_pad_probe, nullptr, nullptr); gst_object_unref(pad); gst_app_sink_set_callbacks(GST_APP_SINK(appsink), &callbacks, this, nullptr); gst_bin_add_many(GST_BIN(pipeline), v4l2src, appsink, nullptr); gst_element_link(v4l2src, appsink); context = g_main_context_new(); loop = g_main_loop_new(context, FALSE); } void V4L2Source::setWindow(QQuickWindow* win) { if (win) { connect(win, &QQuickWindow::beforeSynchronizing, this, &V4L2Source::sync, Qt::DirectConnection); } } GstFlowReturn V4L2Source::on_new_sample(GstAppSink* sink, gpointer data) { Q_UNUSED(sink) V4L2Source* self = (V4L2Source*)data; QMutexLocker locker(&self->mutex); self->ready = true; self->frameReady(); return GST_FLOW_OK; } // Request v4l2src allocator to add GstVideoMeta to buffers static GstPadProbeReturn appsink_pad_probe(GstPad* pad, GstPadProbeInfo* info, gpointer user_data) { if (info->type & GST_PAD_PROBE_TYPE_QUERY_BOTH) { GstQuery* query = gst_pad_probe_info_get_query(info); if (GST_QUERY_TYPE(query) == GST_QUERY_ALLOCATION) { gst_query_add_allocation_meta(query, GST_VIDEO_META_API_TYPE, NULL); } } return GST_PAD_PROBE_OK; }

कंस्ट्रक्टर में, आपकी पाइपलाइन लॉन्च करने के लिए मानक कोड GMainContext और GMainLoop द्वारा एक अलग स्ट्रीम में पाइपलाइन बनाने के लिए बनाया गया है।

यह Qt पर ध्यान देने योग्य है :: SetWindow () में DirectConnection ध्वज - यह गारंटी देता है कि कॉलबैक को सिग्नल के समान थ्रेड में बुलाया जाएगा, जो हमें वर्तमान OpenGL संदर्भ तक पहुंच प्रदान करता है।

V4L2Source :: on_new_sample () जिसे v4l2src से नया फ़्रेम आने पर कहा जाता है, बस तैयार ध्वज को सेट करता है और वीडियोऑटपुट को सूचित करने के लिए संबंधित सिग्नल को ट्रिगर करता है कि सामग्री को फिर से बनाना आवश्यक है।

एप्सिंक सिंक जांच की जरूरत है ताकि v4l2src एलोकेटर को प्रत्येक बफर पर वीडियो प्रारूप के बारे में मेटा जानकारी जोड़ने के लिए कहा जा सके। यह उन स्थितियों को ध्यान में रखना आवश्यक है जब चालक मानक के अलावा हड़ताल / ऑफसेट के साथ वीडियो बफर जारी करता है।

VideoOutput के लिए वीडियो फ्रेम अपडेट सिंक () स्लॉट में होता है:

 // Make sure this callback is invoked from rendering thread void V4L2Source::sync() { { QMutexLocker locker(&mutex); if (!ready) { return; } // reset ready flag ready = false; } // pull available sample and convert GstBuffer into a QAbstractVideoBuffer GstSample* sample = gst_app_sink_pull_sample(GST_APP_SINK(appsink)); GstBuffer* buffer = gst_sample_get_buffer(sample); GstVideoMeta* videoMeta = gst_buffer_get_video_meta(buffer); // if memory is DMABUF and EGLImage is supported by the backend, // create video buffer with EGLImage handle videoFrame.reset(); if (EGLImageSupported && buffer_is_dmabuf(buffer)) { videoBuffer.reset(new GstDmaVideoBuffer(buffer, videoMeta)); } else { // TODO: support other memory types, probably GL textures? // just map memory videoBuffer.reset(new GstVideoBuffer(buffer, videoMeta)); } QSize size = QSize(videoMeta->width, videoMeta->height); QVideoFrame::PixelFormat format = gst_video_format_to_qvideoformat(videoMeta->format); videoFrame.reset(new QVideoFrame( static_cast<QAbstractVideoBuffer*>(videoBuffer.get()), size, format)); if (!m_surface->isActive()) { m_format = QVideoSurfaceFormat(size, format); Q_ASSERT(m_surface->start(m_format) == true); } m_surface->present(*videoFrame); gst_sample_unref(sample); }

इस फ़ंक्शन में, हम ऐप्पिंक से हमारे पास उपलब्ध अंतिम बफर को लेते हैं, GstVideoMeta को प्रत्येक प्लेलिस्ट के लिए ऑफ़सेट्स और स्ट्राइड्स के बारे में जानकारी प्राप्त करने के लिए कहें (अच्छी तरह से, सादगी के लिए, किसी कारण के लिए कोई मेटा नहीं है) और वांछित सिर प्रकार के साथ एक QAbstractVideoBuffer बनाएं: EGLImage (GstDmaVideoBuffer) या कोई नहीं (GstVideoBuffer)। फिर इसे QVideoFrame में लपेटें और रेंडरिंग कतार में रखें।

GstDmaVideoBuffer और GstVideoBuffer का कार्यान्वयन अपने आप में काफी तुच्छ है:

 #define GST_BUFFER_GET_DMAFD(buffer, plane) \ (((plane) < gst_buffer_n_memory((buffer))) ? \ gst_dmabuf_memory_get_fd(gst_buffer_peek_memory((buffer), (plane))) : \ gst_dmabuf_memory_get_fd(gst_buffer_peek_memory((buffer), 0))) class GstDmaVideoBuffer : public QAbstractVideoBuffer { public: // This should be called from renderer thread GstDmaVideoBuffer(GstBuffer* buffer, GstVideoMeta* videoMeta) : QAbstractVideoBuffer(HandleType::EGLImageHandle), buffer(gst_buffer_ref(buffer)), m_videoMeta(videoMeta) { static PFNEGLCREATEIMAGEKHRPROC eglCreateImageKHR = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>( eglGetProcAddress("eglCreateImageKHR")); int idx = 0; EGLint attribs[MAX_ATTRIBUTES_COUNT]; attribs[idx++] = EGL_WIDTH; attribs[idx++] = m_videoMeta->width; attribs[idx++] = EGL_HEIGHT; attribs[idx++] = m_videoMeta->height; attribs[idx++] = EGL_LINUX_DRM_FOURCC_EXT; attribs[idx++] = gst_video_format_to_drm_code(m_videoMeta->format); attribs[idx++] = EGL_DMA_BUF_PLANE0_FD_EXT; attribs[idx++] = GST_BUFFER_GET_DMAFD(buffer, 0); attribs[idx++] = EGL_DMA_BUF_PLANE0_OFFSET_EXT; attribs[idx++] = m_videoMeta->offset[0]; attribs[idx++] = EGL_DMA_BUF_PLANE0_PITCH_EXT; attribs[idx++] = m_videoMeta->stride[0]; if (m_videoMeta->n_planes > 1) { attribs[idx++] = EGL_DMA_BUF_PLANE1_FD_EXT; attribs[idx++] = GST_BUFFER_GET_DMAFD(buffer, 1); attribs[idx++] = EGL_DMA_BUF_PLANE1_OFFSET_EXT; attribs[idx++] = m_videoMeta->offset[1]; attribs[idx++] = EGL_DMA_BUF_PLANE1_PITCH_EXT; attribs[idx++] = m_videoMeta->stride[1]; } if (m_videoMeta->n_planes > 2) { attribs[idx++] = EGL_DMA_BUF_PLANE2_FD_EXT; attribs[idx++] = GST_BUFFER_GET_DMAFD(buffer, 2); attribs[idx++] = EGL_DMA_BUF_PLANE2_OFFSET_EXT; attribs[idx++] = m_videoMeta->offset[2]; attribs[idx++] = EGL_DMA_BUF_PLANE2_PITCH_EXT; attribs[idx++] = m_videoMeta->stride[2]; } attribs[idx++] = EGL_NONE; auto m_qOpenGLContext = QOpenGLContext::currentContext(); QEGLNativeContext qEglContext = qvariant_cast<QEGLNativeContext>(m_qOpenGLContext->nativeHandle()); EGLDisplay dpy = qEglContext.display(); Q_ASSERT(dpy != EGL_NO_DISPLAY); image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, (EGLClientBuffer) nullptr, attribs); Q_ASSERT(image != EGL_NO_IMAGE_KHR); } ... // This should be called from renderer thread ~GstDmaVideoBuffer() override { static PFNEGLDESTROYIMAGEKHRPROC eglDestroyImageKHR = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>( eglGetProcAddress("eglDestroyImageKHR")); auto m_qOpenGLContext = QOpenGLContext::currentContext(); QEGLNativeContext qEglContext = qvariant_cast<QEGLNativeContext>(m_qOpenGLContext->nativeHandle()); EGLDisplay dpy = qEglContext.display(); Q_ASSERT(dpy != EGL_NO_DISPLAY); eglDestroyImageKHR(dpy, image); gst_buffer_unref(buffer); } private: EGLImage image; GstBuffer* buffer; GstVideoMeta* m_videoMeta; }; class GstVideoBuffer : public QAbstractPlanarVideoBuffer { public: GstVideoBuffer(GstBuffer* buffer, GstVideoMeta* videoMeta) : QAbstractPlanarVideoBuffer(HandleType::NoHandle), m_buffer(gst_buffer_ref(buffer)), m_videoMeta(videoMeta), m_mode(QAbstractVideoBuffer::MapMode::NotMapped) { } QVariant handle() const override { return QVariant(); } void release() override { } int map(MapMode mode, int* numBytes, int bytesPerLine[4], uchar* data[4]) override { int size = 0; const GstMapFlags flags = GstMapFlags(((mode & ReadOnly) ? GST_MAP_READ : 0) | ((mode & WriteOnly) ? GST_MAP_WRITE : 0)); if (mode == NotMapped || m_mode != NotMapped) { return 0; } else { for (int i = 0; i < m_videoMeta->n_planes; i++) { gst_video_meta_map(m_videoMeta, i, &m_mapInfo[i], (gpointer*)&data[i], &bytesPerLine[i], flags); size += m_mapInfo[i].size; } } m_mode = mode; *numBytes = size; return m_videoMeta->n_planes; } MapMode mapMode() const override { return m_mode; } void unmap() override { if (m_mode != NotMapped) { for (int i = 0; i < m_videoMeta->n_planes; i++) { gst_video_meta_unmap(m_videoMeta, i, &m_mapInfo[i]); } } m_mode = NotMapped; } ~GstVideoBuffer() override { unmap(); gst_buffer_unref(m_buffer); } private: GstBuffer* m_buffer; MapMode m_mode; GstVideoMeta* m_videoMeta; GstMapInfo m_mapInfo[4]; };

इस सब के बाद, हम निम्नलिखित फॉर्म का QML पेज बना सकते हैं:

 import QtQuick 2.10 import QtQuick.Window 2.10 import QtQuick.Layouts 1.10 import QtQuick.Controls 2.0 import QtMultimedia 5.10 import v4l2source 1.0 Window { visible: true width: 640 height: 480 title: qsTr("qml zero copy rendering") color: "black" CameraSource { id: camera device: "/dev/video0" onFrameReady: videoOutput.update() } VideoOutput { id: videoOutput source: camera anchors.fill: parent } onClosing: camera.stop() }

निष्कर्ष

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

कोड लिंक

क्यूएमएल में हार्डवेयर त्वरित वीडियो की सरल शून्य-कॉपी रेंडरिंग

परिचय

सिद्धांत

कार्यान्वयन

निष्कर्ष

संदर्भ

More articles: