opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+15-13Lines changed: 15 additions & 13 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+15-13Lines changed: 15 additions & 13 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/accel_types.hpp
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/accel_types.hpp
Copy file name to clipboard
+3Lines changed: 3 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions
diff --git a/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+239-43Lines changed: 239 additions & 43 deletions b/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+239-43Lines changed: 239 additions & 43 deletions
diff --git a/‎modules/gapi/src/backends/ie/giebackend.cpp
Copy file name to clipboard
+33-44Lines changed: 33 additions & 44 deletions b/‎modules/gapi/src/backends/ie/giebackend.cpp
Copy file name to clipboard
+33-44Lines changed: 33 additions & 44 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_va_api.cpp
Copy file name to clipboard
+10-24Lines changed: 10 additions & 24 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_va_api.cpp
Copy file name to clipboard
+10-24Lines changed: 10 additions & 24 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_va_api.hpp
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_va_api.hpp
Copy file name to clipboard
-1Lines changed: 0 additions & 1 deletion
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/dx11_alloc_resource.cpp
Copy file name to clipboard
+13-8Lines changed: 13 additions & 8 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/dx11_alloc_resource.cpp
Copy file name to clipboard
+13-8Lines changed: 13 additions & 8 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/surface/cpu_frame_adapter.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/gapi/src/streaming/onevpl/accelerators/surface/cpu_frame_adapter.cpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
@@ -320,20 +320,17 @@ if(HAVE_GAPI_ONEVPL)
   endif()
 
   if(UNIX)
-    find_package(PkgConfig)
-    if(PkgConfig_FOUND)
-      pkg_check_modules(PKG_LIBVA libva>=1.2 libva-drm>=1.2)
-      if(PKG_LIBVA_FOUND)
-        set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-        set(THREADS_PREFER_PTHREAD_FLAG TRUE)
-        find_package(Threads REQUIRED)
-      else()
-        message(FATAL_ERROR "libva not found: building HAVE_GAPI_ONEVPL without libVA support is impossible on UNIX systems")
+    if(WITH_VA)
+      include("${OpenCV_SOURCE_DIR}/cmake/OpenCVFindVA.cmake")
+      if(VA_INCLUDE_DIR)
+        ocv_target_include_directories(${the_module} SYSTEM PRIVATE ${VA_INCLUDE_DIR})
+        ocv_target_include_directories(opencv_test_gapi SYSTEM PRIVATE ${VA_INCLUDE_DIR})
+        ocv_target_link_libraries(${the_module} PRIVATE ${VA_LIBRARIES})
+        ocv_target_link_libraries(opencv_test_gapi PRIVATE ${VA_LIBRARIES})
       endif()
-    else()
-      message(FATAL_ERROR "PkgConfig not found: building HAVE_GAPI_ONEVPL without libVA support is impossible on UNIX systems")
-    endif()
-    ocv_target_link_libraries(${the_module} PRIVATE ${PKG_LIBVA_LIBRARIES} ${PKG_THREAD_LIBRARIES})
+    else(WITH_VA)
+      message(FATAL_ERROR "libva not found: building HAVE_GAPI_ONEVPL without libVA support is impossible on UNIX systems")
+    endif(WITH_VA)
   endif()
 endif()
 
@@ -373,6 +370,11 @@ if(TARGET example_gapi_onevpl_infer_single_roi)
   if(HAVE_D3D11 AND HAVE_OPENCL)
     ocv_target_include_directories(example_gapi_onevpl_infer_single_roi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS})
   endif()
+  if(WITH_VA AND UNIX)
+    message ("GAPI VPL samples with VAAPI")
+    ocv_target_include_directories(example_gapi_onevpl_infer_single_roi SYSTEM PRIVATE ${VA_INCLUDE_DIR})
+    ocv_target_link_libraries(example_gapi_onevpl_infer_single_roi PRIVATE ${VA_LIBRARIES})
+  endif()
 endif()
 
 if(TARGET example_gapi_pipeline_modeling_tool)
 
@@ -65,6 +65,9 @@ GAPI_EXPORTS Device create_dx11_device(Device::Ptr device_ptr,
                                        const std::string& device_name);
 GAPI_EXPORTS Context create_dx11_context(Context::Ptr ctx_ptr);
 
+GAPI_EXPORTS Device create_vaapi_device(Device::Ptr device_ptr,
+                                        const std::string& device_name);
+GAPI_EXPORTS Context create_vaapi_context(Context::Ptr ctx_ptr);
 } // namespace onevpl
 } // namespace wip
 } // namespace gapi
 
@@ -185,6 +185,8 @@ struct GAPI_EXPORTS CfgParam {
     const name_t& get_name() const;
     const value_t& get_value() const;
     bool is_major() const;
+    std::string to_string() const;
+
     bool operator==(const CfgParam& rhs) const;
     bool operator< (const CfgParam& rhs) const;
     bool operator!=(const CfgParam& rhs) const;
 
@@ -300,6 +300,7 @@ struct IEUnit {
                             cv::util::any_cast<InferenceEngine::ParamMap>(&params.context_config);
         if (ctx_params != nullptr) {
             auto ie_core = cv::gimpl::ie::wrap::getCore();
+            GAPI_LOG_DEBUG(nullptr, "create IE remote ctx for device id: " << params.device_id);
             rctx = ie_core.CreateContext(params.device_id, *ctx_params);
         }
 
@@ -703,57 +704,13 @@ cv::MediaFrame preprocess_frame_impl(cv::MediaFrame &&in_frame, const std::strin
     return std::move(in_frame);
 }
 
-inline IE::Blob::Ptr extractRemoteBlob(IECallContext& ctx, std::size_t i,
-                                       const std::string &layer_name,
-                                       const cv::util::optional<cv::Rect> &opt_roi,
-                                       cv::MediaFrame* out_keep_alive_frame,
-                                       bool* out_is_preprocessed) {
-    GAPI_Assert(ctx.inShape(i) == cv::GShape::GFRAME &&
-                "Remote blob is supported for MediaFrame only");
-    cv::MediaFrame frame = ctx.inFrame(i);
-    if (ctx.uu.preproc_engine_impl) {
-        GAPI_LOG_DEBUG(nullptr, "Try to use preprocessing for decoded remote frame in remote ctx");
-        frame = preprocess_frame_impl(std::move(frame), layer_name, ctx, opt_roi,
-                                      out_keep_alive_frame, out_is_preprocessed);
-    }
-
-    // Request params for result frame whatever it got preprocessed or not
-    cv::util::any any_blob_params = frame.blobParams();
-
-    using ParamType = std::pair<InferenceEngine::TensorDesc, InferenceEngine::ParamMap>;
-    using NV12ParamType = std::pair<ParamType, ParamType>;
-
-    NV12ParamType* blob_params = cv::util::any_cast<NV12ParamType>(&any_blob_params);
-    if (blob_params == nullptr) {
-        GAPI_Assert(false && "Incorrect type of blobParams:"
-                             "expected std::pair<ParamType, ParamType>,"
-                             "with ParamType std::pair<InferenceEngine::TensorDesc,"
-                                                      "InferenceEngine::ParamMap >>");
-    }
-
-    //The parameters are TensorDesc and ParamMap for both y and uv blobs
-    auto y_blob = ctx.uu.rctx->CreateBlob(blob_params->first.first, blob_params->first.second);
-    auto uv_blob = ctx.uu.rctx->CreateBlob(blob_params->second.first, blob_params->second.second);
-
-#if INF_ENGINE_RELEASE >= 2021010000
-    return IE::make_shared_blob<IE::NV12Blob>(y_blob, uv_blob);
-#else
-    return IE::make_shared_blob<InferenceEngine::NV12Blob>(y_blob, uv_blob);
-#endif
-}
-
 inline IE::Blob::Ptr extractBlob(IECallContext& ctx,
                                  std::size_t i,
                                  cv::gapi::ie::TraitAs hint,
                                  const std::string& layer_name,
                                  const cv::util::optional<cv::Rect> &opt_roi,
                                  cv::MediaFrame* out_keep_alive_frame = nullptr,
                                  bool* out_is_preprocessed = nullptr) {
-    if (ctx.uu.rctx != nullptr) {
-        return extractRemoteBlob(ctx, i, layer_name, opt_roi,
-                                 out_keep_alive_frame, out_is_preprocessed);
-    }
-
     switch (ctx.inShape(i)) {
         case cv::GShape::GFRAME: {
             auto frame = ctx.inFrame(i);
@@ -762,6 +719,37 @@ inline IE::Blob::Ptr extractBlob(IECallContext& ctx,
                 frame = preprocess_frame_impl(std::move(frame), layer_name, ctx, opt_roi,
                                               out_keep_alive_frame, out_is_preprocessed);
             }
+
+            // NB: check OV remote device context availability.
+            // if it exist and MediaFrame shares the same device context
+            // then we create a remote blob without memory copy
+            if (ctx.uu.rctx != nullptr) {
+                // Request params for result frame whatever it got preprocessed or not
+                cv::util::any any_blob_params = frame.blobParams();
+                using ParamType = std::pair<InferenceEngine::TensorDesc, InferenceEngine::ParamMap>;
+                using NV12ParamType = std::pair<ParamType, ParamType>;
+
+                NV12ParamType* blob_params = cv::util::any_cast<NV12ParamType>(&any_blob_params);
+                if (blob_params == nullptr) {
+                    GAPI_Assert(false && "Incorrect type of blobParams:"
+                                         "expected std::pair<ParamType, ParamType>,"
+                                         "with ParamType std::pair<InferenceEngine::TensorDesc,"
+                                         "InferenceEngine::ParamMap >>");
+                }
+
+                //The parameters are TensorDesc and ParamMap for both y and uv blobs
+                auto y_blob = ctx.uu.rctx->CreateBlob(blob_params->first.first, blob_params->first.second);
+                auto uv_blob = ctx.uu.rctx->CreateBlob(blob_params->second.first, blob_params->second.second);
+
+#if INF_ENGINE_RELEASE >= 2021010000
+                return IE::make_shared_blob<IE::NV12Blob>(y_blob, uv_blob);
+#else
+                return IE::make_shared_blob<InferenceEngine::NV12Blob>(y_blob, uv_blob);
+#endif
+            }
+
+            // NB: If no OV remote context created then use default MediaFrame accessor approach:
+            // it invokes memory copying operation If GPU MediaFrame come
             ctx.views.emplace_back(new cv::MediaFrame::View(frame.access(cv::MediaFrame::Access::R)));
             return wrapIE(*(ctx.views.back()), frame.desc());
         }
@@ -1158,6 +1146,7 @@ static void PostOutputs(InferenceEngine::InferRequest &request,
         ctx->out.post(std::move(output), ctx->eptr);
     }
 
+    ctx->views.clear();
     ctx->releaseKeepAliveFrame(&request);
 }
 
 
@@ -178,8 +178,8 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
         GAPI_LOG_INFO(nullptr, "Released workspace memory: " << ptr);
         ptr = nullptr;
 #else
+        GAPI_LOG_INFO(nullptr, "Workspace memory to release: " << ptr);
         free(ptr);
-        GAPI_LOG_INFO(nullptr, "Released workspace memory: " << ptr);
         ptr = nullptr;
 #endif
 
 
@@ -27,38 +27,24 @@ namespace onevpl {
 VPLVAAPIAccelerationPolicy::VPLVAAPIAccelerationPolicy(device_selector_ptr_t selector) :
     VPLAccelerationPolicy(selector),
     cpu_dispatcher(new VPLCPUAccelerationPolicy(selector)),
-    va_handle(),
-    device_fd(-1) {
+    va_handle() {
+    GAPI_LOG_INFO(nullptr, "created - TODO dispatchered on CPU acceleration");
 #if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
-    // TODO Move it out in device selector
-    device_fd = open("/dev/dri/renderD128", O_RDWR);
-    if (device_fd < 0) {
-        GAPI_LOG_WARNING(nullptr, "VAAPI device descriptor \"/dev/dri/renderD128\" has not found");
-        throw std::runtime_error("cannot open VAAPI device");
-    }
-    va_handle = vaGetDisplayDRM(device_fd);
-    if (!va_handle) {
-        GAPI_LOG_WARNING(nullptr, "VAAPI device vaGetDisplayDRM failed, error: " << strerror(errno));
-        close(device_fd);
-        throw std::runtime_error("vaGetDisplayDRM failed");
-    }
-    int major_version = 0, minor_version = 0;
-    VAStatus status {};
-    status = vaInitialize(va_handle, &major_version, &minor_version);
-    if (VA_STATUS_SUCCESS != status) {
-        GAPI_LOG_WARNING(nullptr, "Cannot initialize VAAPI device, error: " << vaErrorStr(status));
-        close(device_fd);
-        throw std::runtime_error("vaInitialize failed");
-    }
-    GAPI_LOG_INFO(nullptr, "created");
+    // setup VAAPI device
+    IDeviceSelector::DeviceScoreTable devices = get_device_selector()->select_devices();
+    GAPI_Assert(devices.size() == 1 && "Multiple(or zero) acceleration  VAAPI devices are not unsupported");
+    AccelType accel_type = devices.begin()->second.get_type();
+    GAPI_Assert(accel_type == AccelType::VAAPI &&
+                "Unexpected device AccelType while is waiting AccelType::VAAPI");
+
+    va_handle = reinterpret_cast<VADisplay>(devices.begin()->second.get_ptr());
 #else  // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
     GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
 #endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
 }
 
 VPLVAAPIAccelerationPolicy::~VPLVAAPIAccelerationPolicy() {
     vaTerminate(va_handle);
-    close(device_fd);
     GAPI_LOG_INFO(nullptr, "destroyed");
 }
 
 
@@ -50,7 +50,6 @@ struct GAPI_EXPORTS VPLVAAPIAccelerationPolicy final : public VPLAccelerationPol
     std::unique_ptr<VPLAccelerationPolicy> cpu_dispatcher;
 #ifdef __linux__
     VADisplay va_handle;
-    int device_fd;  // TODO Move it out in device selector
 #endif // __linux__
 };
 } // namespace onevpl
 
@@ -96,6 +96,8 @@ void LockAdapter::unlock_write(mfxMemId mid, mfxFrameData &data) {
 
 SharedLock* LockAdapter::set_adaptee(SharedLock* new_impl) {
     SharedLock* old_impl = impl;
+    GAPI_LOG_DEBUG(nullptr, "this: " << this <<
+                            ", old: " << old_impl << ", new: " << new_impl);
     GAPI_DbgAssert(old_impl == nullptr || new_impl == nullptr && "Must not be previous impl");
     impl = new_impl;
     return old_impl;
@@ -184,6 +186,8 @@ void DX11AllocationItem::on_first_in_impl(mfxFrameData *ptr) {
     D3D11_MAP mapType = D3D11_MAP_READ;
     UINT mapFlags = D3D11_MAP_FLAG_DO_NOT_WAIT;
 
+    GAPI_LOG_DEBUG(nullptr, "texture: " << get_texture_ptr() <<
+                            ", subresorce: " << get_subresource());
     shared_device_context->CopySubresourceRegion(get_staging_texture_ptr(), 0,
                                                  0, 0, 0,
                                                  get_texture_ptr(),
@@ -245,8 +249,8 @@ mfxStatus DX11AllocationItem::release_access(mfxFrameData *ptr) {
 }
 
 mfxStatus DX11AllocationItem::shared_access_acquire_unsafe(mfxFrameData *ptr) {
-    GAPI_LOG_DEBUG(nullptr, "acquire READ lock: " << this);
-    GAPI_LOG_DEBUG(nullptr, "texture: " << get_texture_ptr() <<
+    GAPI_LOG_DEBUG(nullptr, "acquire READ lock: " << this <<
+                            ", texture: " << get_texture_ptr() <<
                             ", sub id: " << get_subresource());
     // shared access requires elastic barrier
     // first-in visited thread uses resource mapping on host memory
@@ -257,15 +261,16 @@ mfxStatus DX11AllocationItem::shared_access_acquire_unsafe(mfxFrameData *ptr) {
 
     if (!(ptr->Y && (ptr->UV || (ptr->U && ptr->V)))) {
         GAPI_LOG_WARNING(nullptr, "No any data obtained: " << this);
+        GAPI_DbgAssert(false && "shared access must provide data");
         return MFX_ERR_LOCK_MEMORY;
     }
     GAPI_LOG_DEBUG(nullptr, "READ access granted: " << this);
     return MFX_ERR_NONE;
 }
 
 mfxStatus DX11AllocationItem::shared_access_release_unsafe(mfxFrameData *ptr) {
-    GAPI_LOG_DEBUG(nullptr, "releasing READ lock: " << this);
-    GAPI_LOG_DEBUG(nullptr, "texture: " << get_texture_ptr() <<
+    GAPI_LOG_DEBUG(nullptr, "releasing READ lock: " << this <<
+                            ", texture: " << get_texture_ptr() <<
                             ", sub id: " << get_subresource());
     // releasing shared access requires elastic barrier
     // last-out thread must make memory unmapping then and only then no more
@@ -278,8 +283,8 @@ mfxStatus DX11AllocationItem::shared_access_release_unsafe(mfxFrameData *ptr) {
 }
 
 mfxStatus DX11AllocationItem::exclusive_access_acquire_unsafe(mfxFrameData *ptr) {
-    GAPI_LOG_DEBUG(nullptr, "acquire WRITE lock: " << this);
-    GAPI_LOG_DEBUG(nullptr, "texture: " << get_texture_ptr() <<
+    GAPI_LOG_DEBUG(nullptr, "acquire WRITE lock: " << this <<
+                            ", texture: " << get_texture_ptr() <<
                             ", sub id: " << get_subresource());
     D3D11_MAP mapType = D3D11_MAP_WRITE;
     UINT mapFlags = D3D11_MAP_FLAG_DO_NOT_WAIT;
@@ -321,8 +326,8 @@ mfxStatus DX11AllocationItem::exclusive_access_acquire_unsafe(mfxFrameData *ptr)
 }
 
 mfxStatus DX11AllocationItem::exclusive_access_release_unsafe(mfxFrameData *ptr) {
-    GAPI_LOG_DEBUG(nullptr, "releasing WRITE lock: " << this);
-    GAPI_LOG_DEBUG(nullptr, "texture: " << get_texture_ptr() <<
+    GAPI_LOG_DEBUG(nullptr, "releasing WRITE lock: " << this <<
+                            ", texture: " << get_texture_ptr() <<
                             ", sub id: " << get_subresource());
 
     get_device_ctx_ptr()->Unmap(get_staging_texture_ptr(), 0);
 
@@ -64,7 +64,7 @@ MediaFrame::View VPLMediaFrameCPUAdapter::access(MediaFrame::Access) {
 }
 
 cv::util::any VPLMediaFrameCPUAdapter::blobParams() const {
-    GAPI_Assert("VPLMediaFrameCPUAdapter::blobParams() is not implemented");
+    throw std::runtime_error("VPLMediaFrameCPUAdapter::blobParams() is not implemented");
     return {};
 }
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ MediaFrame::View VPLMediaFrameCPUAdapter::access(MediaFrame::Access) {`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`cv::util::any VPLMediaFrameCPUAdapter::blobParams() const {`
`67`		`- GAPI_Assert("VPLMediaFrameCPUAdapter::blobParams() is not implemented");`
	`67`	`+ throw std::runtime_error("VPLMediaFrameCPUAdapter::blobParams() is not implemented");`
`68`	`68`	`return {};`
`69`	`69`	`}`
`70`	`70`