opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+22-3Lines changed: 22 additions & 3 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+22-3Lines changed: 22 additions & 3 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamerpipeline.hpp
Copy file name to clipboard
+47Lines changed: 47 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamerpipeline.hpp
Copy file name to clipboard
+47Lines changed: 47 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamersource.hpp
Copy file name to clipboard
+89Lines changed: 89 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/gstreamer/gstreamersource.hpp
Copy file name to clipboard
+89Lines changed: 89 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎modules/gapi/src/streaming/gstreamer/gstreamer_buffer_utils.cpp
Copy file name to clipboard
+27Lines changed: 27 additions & 0 deletions b/‎modules/gapi/src/streaming/gstreamer/gstreamer_buffer_utils.cpp
Copy file name to clipboard
+27Lines changed: 27 additions & 0 deletions
diff --git a/‎modules/gapi/src/streaming/gstreamer/gstreamer_buffer_utils.hpp
Copy file name to clipboard
+27Lines changed: 27 additions & 0 deletions b/‎modules/gapi/src/streaming/gstreamer/gstreamer_buffer_utils.hpp
Copy file name to clipboard
+27Lines changed: 27 additions & 0 deletions
diff --git a/‎modules/gapi/src/streaming/gstreamer/gstreamer_media_adapter.cpp
Copy file name to clipboard
+122Lines changed: 122 additions & 0 deletions b/‎modules/gapi/src/streaming/gstreamer/gstreamer_media_adapter.cpp
Copy file name to clipboard
+122Lines changed: 122 additions & 0 deletions
@@ -47,12 +47,14 @@ file(GLOB gapi_ext_hdrs
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/infer/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/ocl/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/own/*.hpp"
+    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/plaidml/*.hpp"
+    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/python/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/render/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/s11n/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/*.hpp"
-    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/plaidml/*.hpp"
+    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/gstreamer/*.hpp"
+    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/streaming/onevpl/*.hpp"
     "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/util/*.hpp"
-    "${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/python/*.hpp"
     )
 
 set(gapi_srcs
@@ -163,7 +165,7 @@ set(gapi_srcs
     src/backends/ie/bindings_ie.cpp
     src/backends/python/gpythonbackend.cpp
 
-    # Streaming source
+    # OpenVPL Streaming source
     src/streaming/onevpl/source.cpp
     src/streaming/onevpl/source_priv.cpp
     src/streaming/onevpl/file_data_provider.cpp
@@ -186,6 +188,14 @@ set(gapi_srcs
     src/streaming/onevpl/cfg_param_device_selector.cpp
     src/streaming/onevpl/device_selector_interface.cpp
 
+    # GStreamer Streaming source
+    src/streaming/gstreamer/gstreamer_pipeline_facade.cpp
+    src/streaming/gstreamer/gstreamerpipeline.cpp
+    src/streaming/gstreamer/gstreamersource.cpp
+    src/streaming/gstreamer/gstreamer_buffer_utils.cpp
+    src/streaming/gstreamer/gstreamer_media_adapter.cpp
+    src/streaming/gstreamer/gstreamerenv.cpp
+
     # Utils (ITT tracing)
     src/utils/itt.cpp
     )
@@ -283,6 +293,15 @@ if(HAVE_GAPI_ONEVPL)
   endif()
 endif()
 
+if(HAVE_GSTREAMER)
+  if(TARGET opencv_test_gapi)
+    ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_GSTREAMER)
+    ocv_target_link_libraries(opencv_test_gapi PRIVATE ocv.3rdparty.gstreamer)
+  endif()
+  ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_GSTREAMER)
+  ocv_target_link_libraries(${the_module} PRIVATE ocv.3rdparty.gstreamer)
+endif()
+
 if(WIN32)
   # Required for htonl/ntohl on Windows
   ocv_target_link_libraries(${the_module} PRIVATE wsock32 ws2_32)
 
@@ -0,0 +1,47 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERPIPELINE_HPP
+#define OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERPIPELINE_HPP
+
+#include <opencv2/gapi/streaming/gstreamer/gstreamersource.hpp>
+#include <opencv2/gapi/own/exports.hpp>
+
+#include <string>
+#include <unordered_map>
+#include <memory>
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace gst {
+
+class GAPI_EXPORTS GStreamerPipeline
+{
+public:
+    class Priv;
+
+    explicit GStreamerPipeline(const std::string& pipeline);
+    IStreamSource::Ptr getStreamingSource(const std::string& appsinkName,
+                                          const GStreamerSource::OutputType outputType =
+                                              GStreamerSource::OutputType::MAT);
+    virtual ~GStreamerPipeline();
+
+protected:
+    explicit GStreamerPipeline(std::unique_ptr<Priv> priv);
+
+    std::unique_ptr<Priv> m_priv;
+};
+
+} // namespace gst
+
+using GStreamerPipeline = gst::GStreamerPipeline;
+
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERPIPELINE_HPP
@@ -0,0 +1,89 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERSOURCE_HPP
+#define OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERSOURCE_HPP
+
+#include <opencv2/gapi/streaming/source.hpp>
+#include <opencv2/gapi/garg.hpp>
+
+#include <memory>
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace gst {
+
+/**
+ * @brief OpenCV's GStreamer streaming source.
+ *        Streams cv::Mat-s/cv::MediaFrame from passed GStreamer pipeline.
+ *
+ * This class implements IStreamSource interface.
+ *
+ * To create GStreamerSource instance you need to pass 'pipeline' and, optionally, 'outputType'
+ * arguments into constructor.
+ * 'pipeline' should represent GStreamer pipeline in form of textual description.
+ * Almost any custom pipeline is supported which can be successfully ran via gst-launch.
+ * The only two limitations are:
+ *      - there should be __one__ appsink element in the pipeline to pass data to OpenCV app.
+ *        Pipeline can actually contain many sink elements, but it must have one and only one
+ *        appsink among them.
+ *
+ *      - data passed to appsink should be video-frame in NV12 format.
+ *
+ * 'outputType' is used to select type of output data to produce: 'cv::MediaFrame' or 'cv::Mat'.
+ * To produce 'cv::MediaFrame'-s you need to pass 'GStreamerSource::OutputType::FRAME' and,
+ * correspondingly, 'GStreamerSource::OutputType::MAT' to produce 'cv::Mat'-s.
+ * Please note, that in the last case, output 'cv::Mat' will be of BGR format, internal conversion
+ * from NV12 GStreamer data will happen.
+ * Default value for 'outputType' is 'GStreamerSource::OutputType::MAT'.
+ *
+ * @note Stream sources are passed to G-API via shared pointers, so please use gapi::make_src<>
+ *       to create objects and ptr() to pass a GStreamerSource to cv::gin().
+ *
+ * @note You need to build OpenCV with GStreamer support to use this class.
+ */
+
+class GStreamerPipelineFacade;
+
+class GAPI_EXPORTS GStreamerSource : public IStreamSource
+{
+public:
+    class Priv;
+
+    // Indicates what type of data should be produced by GStreamerSource: cv::MediaFrame or cv::Mat
+    enum class OutputType {
+        FRAME,
+        MAT
+    };
+
+    GStreamerSource(const std::string& pipeline,
+                    const GStreamerSource::OutputType outputType =
+                        GStreamerSource::OutputType::MAT);
+    GStreamerSource(std::shared_ptr<GStreamerPipelineFacade> pipeline,
+                    const std::string& appsinkName,
+                    const GStreamerSource::OutputType outputType =
+                        GStreamerSource::OutputType::MAT);
+
+    bool pull(cv::gapi::wip::Data& data) override;
+    GMetaArg descr_of() const override;
+    ~GStreamerSource() override;
+
+protected:
+    explicit GStreamerSource(std::unique_ptr<Priv> priv);
+
+    std::unique_ptr<Priv> m_priv;
+};
+
+} // namespace gst
+
+using GStreamerSource = gst::GStreamerSource;
+
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMERSOURCE_HPP
@@ -19,7 +19,7 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 
-enum class AccelType : uint8_t {
+enum class AccelType: uint8_t {
     HOST,
     DX11,
 
 
@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#include "gstreamer_buffer_utils.hpp"
+#include "gstreamerptr.hpp"
+#include <opencv2/gapi/own/assert.hpp>
+
+#ifdef HAVE_GSTREAMER
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace gstreamer_utils {
+
+void mapBufferToFrame(GstBuffer& buffer, GstVideoInfo& info, GstVideoFrame& frame,
+                      GstMapFlags mapFlags) {
+    bool mapped = gst_video_frame_map(&frame, &info, &buffer, mapFlags);
+    GAPI_Assert(mapped && "Failed to map GStreamer buffer to system memory as video-frame!");
+}
+
+} // namespace gstreamer_utils
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+#endif // HAVE_GSTREAMER
@@ -0,0 +1,27 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#ifndef OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMER_BUFFER_UTILS_HPP
+#define OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMER_BUFFER_UTILS_HPP
+
+#ifdef HAVE_GSTREAMER
+#include <gst/gstbuffer.h>
+#include <gst/video/video-frame.h>
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace gstreamer_utils {
+
+void mapBufferToFrame(GstBuffer& buffer, GstVideoInfo& info, GstVideoFrame& frame,
+                      GstMapFlags map_flags);
+
+} // namespace gstreamer_utils
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+#endif // HAVE_GSTREAMER
+#endif // OPENCV_GAPI_STREAMING_GSTREAMER_GSTREAMER_BUFFER_UTILS_HPP
@@ -0,0 +1,122 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#include "gstreamer_media_adapter.hpp"
+#include "gstreamer_buffer_utils.hpp"
+
+#ifdef HAVE_GSTREAMER
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace gst {
+
+GStreamerMediaAdapter::GStreamerMediaAdapter(const cv::GFrameDesc& frameDesc,
+                                             GstVideoInfo* videoInfo,
+                                             GstBuffer* buffer) :
+    m_frameDesc(frameDesc),
+    m_videoInfo(gst_video_info_copy(videoInfo)),
+    m_buffer(gst_buffer_ref(buffer)),
+    m_isMapped(false)
+{
+#if GST_VERSION_MINOR >= 10
+    // Check that GstBuffer has mono-view, so we can retrieve only one video-meta
+    GAPI_Assert((gst_buffer_get_flags(m_buffer) & GST_VIDEO_BUFFER_FLAG_MULTIPLE_VIEW) == 0);
+#endif // GST_VERSION_MINOR >= 10
+
+    GstVideoMeta* videoMeta = gst_buffer_get_video_meta(m_buffer);
+    if (videoMeta != nullptr) {
+        m_strides = { videoMeta->stride[0], videoMeta->stride[1] };
+        m_offsets = { videoMeta->offset[0], videoMeta->offset[1] };
+    } else {
+        m_strides = { GST_VIDEO_INFO_PLANE_STRIDE(m_videoInfo.get(), 0),
+                      GST_VIDEO_INFO_PLANE_STRIDE(m_videoInfo.get(), 1) };
+        m_offsets = { GST_VIDEO_INFO_PLANE_OFFSET(m_videoInfo.get(), 0),
+                      GST_VIDEO_INFO_PLANE_OFFSET(m_videoInfo.get(), 1) };
+    }
+}
+
+GStreamerMediaAdapter::~GStreamerMediaAdapter() {
+    if (m_isMapped.load(std::memory_order_acquire)) {
+        gst_video_frame_unmap(&m_videoFrame);
+        m_isMapped.store(false, std::memory_order_release);
+        m_mappedForWrite.store(false);
+    }
+}
+
+cv::GFrameDesc GStreamerMediaAdapter::meta() const {
+    return m_frameDesc;
+}
+
+cv::MediaFrame::View GStreamerMediaAdapter::access(cv::MediaFrame::Access access) {
+    GAPI_Assert(access == cv::MediaFrame::Access::R ||
+                access == cv::MediaFrame::Access::W);
+    static std::atomic<size_t> thread_counters { };
+    ++thread_counters;
+
+    // NOTE: Framework guarantees that there should be no parallel accesses to the frame
+    //       memory if is accessing for write.
+    if (access == cv::MediaFrame::Access::W && !m_mappedForWrite.load(std::memory_order_acquire)) {
+        GAPI_Assert(thread_counters > 1 &&
+                    "Multiple access to view during mapping for write detected!");
+        gst_video_frame_unmap(&m_videoFrame);
+        m_isMapped.store(false);
+    }
+
+    if (!m_isMapped.load(std::memory_order_acquire)) {
+
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        if(!m_isMapped.load(std::memory_order_relaxed)) {
+
+            GAPI_Assert(GST_VIDEO_INFO_N_PLANES(m_videoInfo.get()) == 2);
+            GAPI_Assert(GST_VIDEO_INFO_FORMAT(m_videoInfo.get()) == GST_VIDEO_FORMAT_NV12);
+
+            // TODO: Use RAII for map/unmap
+            if (access == cv::MediaFrame::Access::W) {
+                gstreamer_utils::mapBufferToFrame(*m_buffer, *m_videoInfo, m_videoFrame,
+                                                  GST_MAP_WRITE);
+                m_mappedForWrite.store(true, std::memory_order_release);
+            } else {
+                gstreamer_utils::mapBufferToFrame(*m_buffer, *m_videoInfo, m_videoFrame,
+                                                  GST_MAP_READ);
+            }
+
+            GAPI_Assert(GST_VIDEO_FRAME_PLANE_STRIDE(&m_videoFrame, 0) == m_strides[0]);
+            GAPI_Assert(GST_VIDEO_FRAME_PLANE_STRIDE(&m_videoFrame, 1) == m_strides[1]);
+            GAPI_Assert(GST_VIDEO_FRAME_PLANE_OFFSET(&m_videoFrame, 0) == m_offsets[0]);
+            GAPI_Assert(GST_VIDEO_FRAME_PLANE_OFFSET(&m_videoFrame, 1) == m_offsets[1]);
+
+            m_isMapped.store(true, std::memory_order_release);
+        }
+    }
+
+    cv::MediaFrame::View::Ptrs ps {
+        static_cast<uint8_t*>(GST_VIDEO_FRAME_PLANE_DATA(&m_videoFrame, 0)) + m_offsets[0], // Y-plane
+        static_cast<uint8_t*>(GST_VIDEO_FRAME_PLANE_DATA(&m_videoFrame, 0)) + m_offsets[1], // UV-plane
+        nullptr,
+        nullptr
+    };
+
+    cv::MediaFrame::View::Strides ss = {
+        static_cast<std::size_t>(m_strides[0]), // Y-plane stride
+        static_cast<std::size_t>(m_strides[1]), // UV-plane stride
+        0u,
+        0u
+    };
+
+    --thread_counters;
+    return cv::MediaFrame::View(std::move(ps), std::move(ss));
+}
+
+cv::util::any GStreamerMediaAdapter::blobParams() const {
+    GAPI_Assert(false && "No implementation for GStreamerMediaAdapter::blobParams()");
+}
+
+} // namespace gst
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+#endif // HAVE_GSTREAMER