Copy mpashchenkov's changes

Minor refactoring

Partially address review comments

Move DX-related stuff from the sample to a default source

Simplify the default OneVPL config

Address minor review comments

Add class for the default VPL source

WIP: Add initial stub for tests with description

Removing default vpl source and minor refactoring

Refactor default files

Fix build and application crash

Address review comments

Add test on VPL + OCL interaction compared to CPU behavior

Fix test

modules/gapi/src/backends/ocl/goclbackend.cpp

@@ -114,7 +114,8 @@ cv::GArg cv::gimpl::GOCLExecutable::packArg(const GArg &arg)
     GAPI_Assert(   arg.kind != cv::detail::ArgKind::GMAT
               && arg.kind != cv::detail::ArgKind::GSCALAR
               && arg.kind != cv::detail::ArgKind::GARRAY
-              && arg.kind != cv::detail::ArgKind::GOPAQUE);
+              && arg.kind != cv::detail::ArgKind::GOPAQUE
+              && arg.kind != cv::detail::ArgKind::GFRAME);
 
     if (arg.kind != cv::detail::ArgKind::GOBJREF)
     {
@@ -136,6 +137,7 @@ cv::GArg cv::gimpl::GOCLExecutable::packArg(const GArg &arg)
     // Note: .at() is intentional for GOpaque as object MUST be already there
     //   (and constructed by either bindIn/Out or resetInternal)
     case GShape::GOPAQUE:  return GArg(m_res.slot<cv::detail::OpaqueRef>().at(ref.id));
+    case GShape::GFRAME: return GArg(m_res.slot<cv::MediaFrame>().at(ref.id));
     default:
         util::throw_error(std::logic_error("Unsupported GShape type"));
         break;

modules/gapi/src/backends/ocl/goclcore.cpp

@@ -6,11 +6,32 @@
 
 
 #include "precomp.hpp"
+#include "logger.hpp"
 
 #include <opencv2/gapi/core.hpp>
 #include <opencv2/gapi/ocl/core.hpp>
+#include <opencv2/gapi/util/throw.hpp>
+
 #include "backends/ocl/goclcore.hpp"
 
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
+#pragma comment(lib,"d3d11.lib")
+
+// get rid of generate macro max/min/etc from DX side
+#define D3D11_NO_HELPERS
+#define NOMINMAX
+#include <d3d11.h>
+#pragma comment(lib, "dxgi")
+#undef NOMINMAX
+#undef D3D11_NO_HELPERS
+#include <opencv2/core/directx.hpp>
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
+
+#include <opencv2/core/ocl.hpp>
+#include "streaming/onevpl/accelerators/surface/dx11_frame_adapter.hpp"
+
 GAPI_OCL_KERNEL(GOCLAdd, cv::gapi::core::GAdd)
 {
     static void run(const cv::UMat& a, const cv::UMat& b, int dtype, cv::UMat& out)
@@ -523,6 +544,79 @@ GAPI_OCL_KERNEL(GOCLTranspose, cv::gapi::core::GTranspose)
     }
 };
 
+GAPI_OCL_KERNEL(GOCLBGR, cv::gapi::streaming::GBGR)
+{
+    static void run(const cv::MediaFrame& in, cv::UMat& out)
+    {
+        cv::util::suppress_unused_warning(in);
+        cv::util::suppress_unused_warning(out);
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
+#ifdef HAVE_ONEVPL
+        auto d = in.desc();
+        if (d.fmt != cv::MediaFormat::NV12)
+        {
+            GAPI_LOG_FATAL(nullptr, "Unsupported format provided: " << static_cast<int>(d.fmt) <<
+                           ". Expected cv::MediaFormat::NV12.");
+            cv::util::throw_error(std::logic_error("Unsupported MediaFrame format provided"));
+        }
+
+        // FIXME: consider a better solution.
+        // Current approach cannot be easily extended for other adapters (getHandle).
+        auto adapterPtr = in.get<cv::gapi::wip::onevpl::VPLMediaFrameDX11Adapter>();
+        if (adapterPtr == nullptr)
+        {
+            GAPI_LOG_FATAL(nullptr, "Unsupported adapter type. Only VPLMediaFrameDX11Adapter is supported");
+            cv::util::throw_error(std::logic_error("Unsupported adapter type. Only VPLMediaFrameDX11Adapter is supported"));
+        }
+
+        auto params = adapterPtr->getHandle();
+        auto handle = cv::util::any_cast<mfxHDLPair>(params);
+        ID3D11Texture2D* texture = reinterpret_cast<ID3D11Texture2D*>(handle.first);
+        if (texture == nullptr)
+        {
+            GAPI_LOG_FATAL(nullptr, "mfxHDLPair contains ID3D11Texture2D that is nullptr. Handle address" <<
+                           reinterpret_cast<uint64_t>(handle.first));
+            cv::util::throw_error(std::logic_error("mfxHDLPair contains ID3D11Texture2D that is nullptr"));
+        }
+
+        // FIXME: Assuming here that we only have 1 device
+        // TODO: Textures are reusable, so to improve the peroformance here
+        //       consider creating a hash map texture <-> device/ctx
+        static thread_local ID3D11Device* pD3D11Device = nullptr;
+        if (pD3D11Device == nullptr)
+        {
+            texture->GetDevice(&pD3D11Device);
+        }
+        if (pD3D11Device == nullptr)
+        {
+            GAPI_LOG_FATAL(nullptr, "D3D11Texture2D::GetDevice returns pD3D11Device that is nullptr");
+            cv::util::throw_error(std::logic_error("D3D11Texture2D::GetDevice returns pD3D11Device that is nullptr"));
+        }
+
+        // FIXME: assuming here that the context is always the same
+        // TODO: Textures are reusable, so to improve the peroformance here
+        //       consider creating a hash map texture <-> device/ctx
+        static thread_local cv::ocl::Context ctx = cv::directx::ocl::initializeContextFromD3D11Device(pD3D11Device);
+        if (ctx.ptr() == nullptr)
+        {
+            GAPI_LOG_FATAL(nullptr, "initializeContextFromD3D11Device returned null context");
+            cv::util::throw_error(std::logic_error("initializeContextFromD3D11Device returned null context"));
+        }
+
+        cv::directx::convertFromD3D11Texture2D(texture, out);
+#else
+        GAPI_LOG_FATAL(nullptr, "HAVE_ONEVPL is not set. Please, check your cmake flags");
+        cv::util::throw_error(std::logic_error("HAVE_ONEVPL is not set. Please, check your cmake flags"));
+#endif // HAVE_ONEVPL
+#else
+        GAPI_LOG_FATAL(nullptr, "HAVE_D3D11 or HAVE_DIRECTX is not set. Please, check your cmake flags");
+        cv::util::throw_error(std::logic_error("HAVE_D3D11 or HAVE_DIRECTX is not set. Please, check your cmake flags"));
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
+    }
+};
+
 cv::GKernelPackage cv::gapi::core::ocl::kernels()
 {
     static auto pkg = cv::gapi::kernels
@@ -587,6 +681,7 @@ cv::GKernelPackage cv::gapi::core::ocl::kernels()
          , GOCLLUT
          , GOCLConvertTo
          , GOCLTranspose
+         , GOCLBGR
          >();
     return pkg;
 }

modules/gapi/src/streaming/onevpl/accelerators/surface/cpu_frame_adapter.cpp

@@ -65,7 +65,6 @@ MediaFrame::View VPLMediaFrameCPUAdapter::access(MediaFrame::Access) {
 
 cv::util::any VPLMediaFrameCPUAdapter::blobParams() const {
     throw std::runtime_error("VPLMediaFrameCPUAdapter::blobParams() is not implemented");
-    return {};
 }
 
 void VPLMediaFrameCPUAdapter::serialize(cv::gapi::s11n::IOStream&) {

modules/gapi/src/streaming/onevpl/accelerators/surface/dx11_frame_adapter.cpp

@@ -114,17 +114,24 @@ MediaFrame::View VPLMediaFrameDX11Adapter::access(MediaFrame::Access mode) {
     }
 }
 
-cv::util::any VPLMediaFrameDX11Adapter::blobParams() const {
-    /*GAPI_Assert(false && "VPLMediaFrameDX11Adapter::blobParams() is not fully integrated"
-                         "in OpenVINO InferenceEngine and would be temporary disable.");*/
-#ifdef HAVE_INF_ENGINE
+mfxHDLPair VPLMediaFrameDX11Adapter::getHandle() const {
     auto surface_ptr_copy = get_surface();
-    Surface::data_t& data = surface_ptr_copy->get_data();
-    const Surface::info_t& info = surface_ptr_copy->get_info();
+    const Surface::data_t& data = surface_ptr_copy->get_data();
     NativeHandleAdapter* native_handle_getter = reinterpret_cast<NativeHandleAdapter*>(data.MemId);
 
     mfxHDLPair handle{};
     native_handle_getter->get_handle(data.MemId, reinterpret_cast<mfxHDL&>(handle));
+    return handle;
+}
+
+cv::util::any VPLMediaFrameDX11Adapter::blobParams() const {
+    /*GAPI_Assert(false && "VPLMediaFrameDX11Adapter::blobParams() is not fully integrated"
+                         "in OpenVINO InferenceEngine and would be temporary disable.");*/
+#ifdef HAVE_INF_ENGINE
+    mfxHDLPair handle = getHandle();
+
+    auto surface_ptr_copy = get_surface();
+    const Surface::info_t& info = surface_ptr_copy->get_info();
 
     GAPI_Assert(frame_desc.fmt == MediaFormat::NV12 &&
                 "blobParams() for VPLMediaFrameDX11Adapter supports NV12 only");

modules/gapi/src/streaming/onevpl/accelerators/surface/dx11_frame_adapter.hpp

@@ -37,6 +37,11 @@ public:
     GAPI_EXPORTS ~VPLMediaFrameDX11Adapter();
     MediaFrame::View access(MediaFrame::Access) override;
 
+    // FIXME: Consider a better solution since this approach
+    // is not easily extendable for other adapters (oclcore.cpp)
+    // FIXME: Use with caution since the handle might become invalid
+    //        due to reference counting
+    mfxHDLPair getHandle() const;
     // The default implementation does nothing
     cv::util::any blobParams() const override;
     void serialize(cv::gapi::s11n::IOStream&) override;

modules/gapi/src/streaming/onevpl/cfg_param_device_selector.hpp

@@ -20,7 +20,7 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 
-class PlatformSpecificParams;
+struct PlatformSpecificParams;
 std::vector<CfgParam> update_param_with_accel_type(std::vector<CfgParam> &&param_array, AccelType type);
 
 struct GAPI_EXPORTS CfgParamDeviceSelector final: public IDeviceSelector {

modules/gapi/src/streaming/onevpl/default.cpp

@@ -0,0 +1,52 @@
+// 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 http://opencv.org/license.html.
+//
+// Copyright (C) 2022 Intel Corporation
+
+#include <iostream>
+#include <memory>
+
+#include <opencv2/gapi/streaming/onevpl/default.hpp>
+#include <opencv2/gapi/streaming/onevpl/cfg_params.hpp>
+#include <opencv2/gapi/streaming/onevpl/device_selector_interface.hpp>
+
+#include "cfg_param_device_selector.hpp"
+
+#ifdef HAVE_ONEVPL
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+
+std::shared_ptr<IDeviceSelector> getDefaultDeviceSelector(const std::vector<CfgParam>& cfg_params) {
+    std::shared_ptr<CfgParamDeviceSelector> default_accel_contex(new CfgParamDeviceSelector(cfg_params));
+
+    return default_accel_contex;
+}
+
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#else // HAVE_ONEVPL
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+
+std::shared_ptr<IDeviceSelector> getDefaultDeviceSelector(const std::vector<CfgParam>&) {
+    std::cerr << "Cannot utilize getDefaultVPLDeviceAndCtx without HAVE_ONEVPL enabled" << std::endl;
+    util::throw_error(std::logic_error("Cannot utilize getDefaultVPLDeviceAndCtx without HAVE_ONEVPL enabled"));
+    return nullptr;
+}
+
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // HAVE_ONEVPL

modules/gapi/src/streaming/onevpl/engine/decode/decode_engine_legacy.cpp

@@ -251,7 +251,8 @@ VPLLegacyDecodeEngine::SessionParam VPLLegacyDecodeEngine::prepare_session_param
 
     }
 
-    decRequest.Type |= MFX_MEMTYPE_EXTERNAL_FRAME | MFX_MEMTYPE_FROM_DECODE | MFX_MEMTYPE_FROM_VPPIN;
+    decRequest.Type |= MFX_MEMTYPE_EXTERNAL_FRAME | MFX_MEMTYPE_FROM_DECODE |
+                       MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_SHARED_RESOURCE;
     VPLAccelerationPolicy::pool_key_t decode_pool_key =
                 acceleration_policy->create_surface_pool(decRequest, mfxDecParams.mfx.FrameInfo);
 

modules/gapi/src/streaming/onevpl/engine/preproc/preproc_engine.cpp

@@ -281,7 +281,7 @@ pp_session VPPPreprocEngine::initialize_preproc(const pp_params& initial_frame_p
             vppRequests[1].AllocId = std::numeric_limits<uint16_t>::max() - request_id++;
             GAPI_Assert(request_id != std::numeric_limits<uint16_t>::max() && "Something wrong");
 
-            vppRequests[1].Type |= MFX_MEMTYPE_FROM_VPPIN;
+            vppRequests[1].Type |= MFX_MEMTYPE_FROM_VPPIN | MFX_MEMTYPE_SHARED_RESOURCE;
             vpp_out_pool_key = acceleration_policy->create_surface_pool(vppRequests[1],
                                                                         mfxVPPParams.vpp.Out);
 

modules/gapi/src/streaming/onevpl/utils.cpp

@@ -429,4 +429,5 @@ std::string ext_mem_frame_type_to_cstr(int type) {
 } // namespace wip
 } // namespace gapi
 } // namespace cv
+
 #endif // HAVE_ONEVPL