opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp
Copy file name to clipboard
+102Lines changed: 102 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/device_selector_interface.hpp
Copy file name to clipboard
+102Lines changed: 102 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/source.hpp
Copy file name to clipboard
+24Lines changed: 24 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/source.hpp
Copy file name to clipboard
+24Lines changed: 24 additions & 0 deletions
diff --git a/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+136-2Lines changed: 136 additions & 2 deletions b/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+136-2Lines changed: 136 additions & 2 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_dx11.hpp
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_dx11.hpp
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
@@ -181,6 +181,9 @@ set(gapi_srcs
     src/streaming/onevpl/engine/decode/decode_engine_legacy.cpp
     src/streaming/onevpl/engine/decode/decode_session.cpp
 
+    src/streaming/onevpl/cfg_param_device_selector.cpp
+    src/streaming/onevpl/device_selector_interface.cpp
+
     # Utils (ITT tracing)
     src/utils/itt.cpp
     )
@@ -283,3 +286,15 @@ endif()
 
 ocv_add_perf_tests()
 ocv_add_samples()
+
+
+# Required for sample with inference on host
+if (TARGET example_gapi_onevpl_infer_single_roi)
+  if(OPENCV_GAPI_INF_ENGINE)
+    ocv_target_link_libraries(example_gapi_onevpl_infer_single_roi PRIVATE ${INF_ENGINE_TARGET})
+    ocv_target_compile_definitions(example_gapi_onevpl_infer_single_roi PRIVATE -DHAVE_INF_ENGINE)
+  endif()
+  if(HAVE_D3D11 AND HAVE_OPENCL)
+    ocv_target_include_directories(example_gapi_onevpl_infer_single_roi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS})
+  endif()
+endif()
@@ -0,0 +1,102 @@
+// 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 GAPI_STREAMING_ONEVPL_DEVICE_SELECTOR_INTERFACE_HPP
+#define GAPI_STREAMING_ONEVPL_DEVICE_SELECTOR_INTERFACE_HPP
+
+#include <limits>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+
+enum class AccelType : uint8_t {
+    HOST,
+    DX11,
+
+    LAST_VALUE = std::numeric_limits<uint8_t>::max()
+};
+
+GAPI_EXPORTS const char* to_cstring(AccelType type);
+
+struct IDeviceSelector;
+struct GAPI_EXPORTS Device {
+    friend struct IDeviceSelector;
+    using Ptr = void*;
+
+    ~Device();
+    const std::string& get_name() const;
+    Ptr get_ptr() const;
+    AccelType get_type() const;
+private:
+    Device(Ptr device_ptr, const std::string& device_name,
+           AccelType device_type);
+
+    std::string name;
+    Ptr ptr;
+    AccelType type;
+};
+
+struct GAPI_EXPORTS Context {
+    friend struct IDeviceSelector;
+    using Ptr = void*;
+
+    ~Context();
+    Ptr get_ptr() const;
+    AccelType get_type() const;
+private:
+    Context(Ptr ctx_ptr, AccelType ctx_type);
+    Ptr ptr;
+    AccelType type;
+};
+
+struct GAPI_EXPORTS IDeviceSelector {
+    using Ptr = std::shared_ptr<IDeviceSelector>;
+
+    struct GAPI_EXPORTS Score {
+        friend struct IDeviceSelector;
+        using Type = int16_t;
+        static constexpr Type MaxActivePriority = std::numeric_limits<Type>::max();
+        static constexpr Type MinActivePriority = 0;
+        static constexpr Type MaxPassivePriority = MinActivePriority - 1;
+        static constexpr Type MinPassivePriority = std::numeric_limits<Type>::min();
+
+        Score(Type val);
+        ~Score();
+
+        operator Type () const;
+        Type get() const;
+        friend bool operator< (Score lhs, Score rhs) {
+            return lhs.get() < rhs.get();
+        }
+    private:
+        Type value;
+    };
+
+    using DeviceScoreTable = std::map<Score, Device>;
+    using DeviceContexts = std::vector<Context>;
+
+    virtual ~IDeviceSelector();
+    virtual DeviceScoreTable select_devices() const = 0;
+    virtual DeviceContexts select_context() = 0;
+protected:
+    template<typename Entity, typename ...Args>
+    static Entity create(Args &&...args) {
+        return Entity(std::forward<Args>(args)...);
+    }
+};
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // GAPI_STREAMING_ONEVPL_DEVICE_SELECTOR_INTERFACE_HPP
@@ -12,6 +12,7 @@
 #include <opencv2/gapi/streaming/source.hpp>
 #include <opencv2/gapi/streaming/onevpl/cfg_params.hpp>
 #include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
+#include <opencv2/gapi/streaming/onevpl/device_selector_interface.hpp>
 
 namespace cv {
 namespace gapi {
@@ -38,8 +39,31 @@ class GAPI_EXPORTS GSource : public IStreamSource
 
     GSource(const std::string& filePath,
             const CfgParams& cfg_params = CfgParams{});
+
+    GSource(const std::string& filePath,
+            const CfgParams& cfg_params,
+            const std::string& device_id,
+            void* accel_device_ptr,
+            void* accel_ctx_ptr);
+
+    GSource(const std::string& filePath,
+            const CfgParams& cfg_params,
+            std::shared_ptr<IDeviceSelector> selector);
+
+
     GSource(std::shared_ptr<IDataProvider> source,
             const CfgParams& cfg_params = CfgParams{});
+
+    GSource(std::shared_ptr<IDataProvider> source,
+            const CfgParams& cfg_params,
+            const std::string& device_id,
+            void* accel_device_ptr,
+            void* accel_ctx_ptr);
+
+    GSource(std::shared_ptr<IDataProvider> source,
+            const CfgParams& cfg_params,
+            std::shared_ptr<IDeviceSelector> selector);
+
     ~GSource() override;
 
     bool pull(cv::gapi::wip::Data& data) override;
 
@@ -2,6 +2,7 @@
 #include <fstream>
 #include <iostream>
 #include <cctype>
+#include <tuple>
 
 #include <opencv2/imgproc.hpp>
 #include <opencv2/gapi.hpp>
@@ -10,8 +11,30 @@
 #include <opencv2/gapi/infer/ie.hpp>
 #include <opencv2/gapi/render.hpp>
 #include <opencv2/gapi/streaming/onevpl/source.hpp>
+#include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
 #include <opencv2/highgui.hpp> // CommandLineParser
 
+#ifdef HAVE_INF_ENGINE
+#include <inference_engine.hpp> // ParamMap
+
+#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 <cldnn/cldnn_config.hpp>
+#include <atlbase.h>
+#include <d3d11.h>
+#pragma comment(lib, "dxgi")
+#undef NOMINMAX
+#undef D3D11_NO_HELPERS
+
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
+#endif // HAVE_INF_ENGINE
+
 const std::string about =
     "This is an OpenCV-based version of oneVPLSource decoder example";
 const std::string keys =
@@ -36,6 +59,37 @@ std::string get_weights_path(const std::string &model_path) {
     CV_Assert(ext == ".xml");
     return model_path.substr(0u, sz - EXT_LEN) + ".bin";
 }
+
+#ifdef HAVE_INF_ENGINE
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
+
+using AccelParamsType = std::tuple<CComPtr<ID3D11Device>, CComPtr<ID3D11DeviceContext>>;
+
+AccelParamsType create_device_with_ctx(CComPtr<IDXGIAdapter> adapter) {
+    UINT flags = 0;
+    D3D_FEATURE_LEVEL feature_levels[] = { D3D_FEATURE_LEVEL_11_1,
+                                           D3D_FEATURE_LEVEL_11_0,
+                                         };
+    D3D_FEATURE_LEVEL featureLevel;
+    ID3D11Device* ret_device_ptr = nullptr;
+    ID3D11DeviceContext* ret_ctx_ptr = nullptr;
+    HRESULT err = D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN,
+                                    nullptr, flags,
+                                    feature_levels,
+                                    ARRAYSIZE(feature_levels),
+                                    D3D11_SDK_VERSION, &ret_device_ptr,
+                                    &featureLevel, &ret_ctx_ptr);
+    if (FAILED(err)) {
+        throw std::runtime_error("Cannot create D3D11CreateDevice, error: " +
+                                 std::to_string(HRESULT_CODE(err)));
+    }
+
+    return std::make_tuple(ret_device_ptr, ret_ctx_ptr);
+}
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
+#endif // HAVE_INF_ENGINE
 } // anonymous namespace
 
 namespace custom {
@@ -197,11 +251,84 @@ int main(int argc, char *argv[]) {
         return -1;
     }
 
+    const std::string& device_id = cmd.get<std::string>("faced");
     auto face_net = cv::gapi::ie::Params<custom::FaceDetector> {
         face_model_path,                 // path to topology IR
         get_weights_path(face_model_path),   // path to weights
-        cmd.get<std::string>("faced"),   // device specifier
+        device_id
     };
+
+    // Create device_ptr & context_ptr using graphic API
+    // InferenceEngine requires such device & context to create its own
+    // remote shared context through InferenceEngine::ParamMap in
+    // GAPI InferenceEngine backend to provide interoperability with onevpl::GSource
+    // So GAPI InferenceEngine backend and onevpl::GSource MUST share the same
+    // device and context
+    void* accel_device_ptr = nullptr;
+    void* accel_ctx_ptr = nullptr;
+
+#ifdef HAVE_INF_ENGINE
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
+    CComPtr<ID3D11Device> dx11_dev;
+    CComPtr<ID3D11DeviceContext> dx11_ctx;
+
+    if (device_id.find("GPU") != std::string::npos) {
+        CComPtr<IDXGIFactory> adapter_factory;
+        CComPtr<IDXGIAdapter> intel_adapters;
+        {
+            IDXGIFactory* out_factory = nullptr;
+            HRESULT err = CreateDXGIFactory(__uuidof(IDXGIFactory),
+                                        reinterpret_cast<void**>(&out_factory));
+            if (FAILED(err)) {
+                std::cerr << "Cannot create CreateDXGIFactory, error: " << HRESULT_CODE(err) << std::endl;
+                return -1;
+            }
+            adapter_factory.Attach(out_factory);
+        }
+
+        CComPtr<IDXGIAdapter> intel_adapter;
+        UINT adapter_index = 0;
+        const unsigned int refIntelVendorID = 0x8086;
+        IDXGIAdapter* out_adapter = nullptr;
+
+        while (adapter_factory->EnumAdapters(adapter_index, &out_adapter) != DXGI_ERROR_NOT_FOUND) {
+            DXGI_ADAPTER_DESC desc{};
+            out_adapter->GetDesc(&desc);
+            if (desc.VendorId == refIntelVendorID) {
+                intel_adapter.Attach(out_adapter);
+                break;
+            }
+            ++adapter_index;
+        }
+
+        if (!intel_adapter) {
+            std::cerr << "No Intel GPU adapter on aboard. Exit" << std::endl;
+            return -1;
+        }
+
+        std::tie(dx11_dev, dx11_ctx) = create_device_with_ctx(intel_adapter);
+        accel_device_ptr = reinterpret_cast<void*>(dx11_dev.p);
+        accel_ctx_ptr = reinterpret_cast<void*>(dx11_ctx.p);
+
+        // put accel type description for VPL source
+        source_cfgs.push_back(cfg::create_from_string(
+                                        "mfxImplDescription.AccelerationMode"
+                                        ":"
+                                        "MFX_ACCEL_MODE_VIA_D3D11"));
+    }
+
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
+    // set ctx_config for GPU device only - no need in case of CPU device type
+    if (device_id.find("GPU") != std::string::npos) {
+        InferenceEngine::ParamMap ctx_config({{"CONTEXT_TYPE", "VA_SHARED"},
+                                            {"VA_DEVICE", accel_device_ptr} });
+
+        face_net.cfgContextParams(ctx_config);
+    }
+#endif // HAVE_INF_ENGINE
+
     auto kernels = cv::gapi::kernels
         < custom::OCVLocateROI
         , custom::OCVParseSSD
@@ -211,7 +338,14 @@ int main(int argc, char *argv[]) {
     // Create source
     cv::Ptr<cv::gapi::wip::IStreamSource> cap;
     try {
-        cap = cv::gapi::wip::make_onevpl_src(file_path, source_cfgs);
+        if (device_id.find("GPU") != std::string::npos) {
+            cap = cv::gapi::wip::make_onevpl_src(file_path, source_cfgs,
+                                                 device_id,
+                                                 accel_device_ptr,
+                                                 accel_ctx_ptr);
+        } else {
+            cap = cv::gapi::wip::make_onevpl_src(file_path, source_cfgs);
+        }
         std::cout << "oneVPL source desription: " << cap->descr_of() << std::endl;
     } catch (const std::exception& ex) {
         std::cerr << "Cannot create source: " << ex.what() << std::endl;
 
@@ -22,6 +22,7 @@
 #ifdef HAVE_DIRECTX
 #ifdef HAVE_D3D11
 #define D3D11_NO_HELPERS
+#define NOMINMAX
 #include <d3d11.h>
 #include <codecvt>
 #include "opencv2/core/directx.hpp"