opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+7Lines changed: 7 additions & 0 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+7Lines changed: 7 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp
Copy file name to clipboard
+64-1Lines changed: 64 additions & 1 deletion b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp
Copy file name to clipboard
+64-1Lines changed: 64 additions & 1 deletion
diff --git a/‎modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp
Copy file name to clipboard
+23-7Lines changed: 23 additions & 7 deletions b/‎modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp
Copy file name to clipboard
+23-7Lines changed: 23 additions & 7 deletions
diff --git a/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+19-7Lines changed: 19 additions & 7 deletions b/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+19-7Lines changed: 19 additions & 7 deletions
diff --git a/‎modules/gapi/src/backends/render/grenderocv.cpp
Copy file name to clipboard
+21-17Lines changed: 21 additions & 17 deletions b/‎modules/gapi/src/backends/render/grenderocv.cpp
Copy file name to clipboard
+21-17Lines changed: 21 additions & 17 deletions
@@ -174,10 +174,13 @@ set(gapi_srcs
     src/streaming/onevpl/utils.cpp
     src/streaming/onevpl/data_provider_interface_exception.cpp
     src/streaming/onevpl/accelerators/surface/cpu_frame_adapter.cpp
+    src/streaming/onevpl/accelerators/surface/dx11_frame_adapter.cpp
     src/streaming/onevpl/accelerators/surface/surface.cpp
     src/streaming/onevpl/accelerators/surface/surface_pool.cpp
+    src/streaming/onevpl/accelerators/utils/shared_lock.cpp
     src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
     src/streaming/onevpl/accelerators/accel_policy_dx11.cpp
+    src/streaming/onevpl/accelerators/dx11_alloc_resource.cpp
     src/streaming/onevpl/engine/engine_session.cpp
     src/streaming/onevpl/engine/processing_engine_base.cpp
     src/streaming/onevpl/engine/decode/decode_engine_legacy.cpp
@@ -282,12 +285,16 @@ if(HAVE_GAPI_ONEVPL)
   if(TARGET opencv_test_gapi)
     ocv_target_compile_definitions(opencv_test_gapi PRIVATE -DHAVE_ONEVPL)
     ocv_target_link_libraries(opencv_test_gapi PRIVATE ${VPL_IMPORTED_TARGETS})
+    if(MSVC)
+        target_compile_options(opencv_test_gapi PUBLIC "/wd4201")
+    endif()
     if(HAVE_D3D11 AND HAVE_OPENCL)
         ocv_target_include_directories(opencv_test_gapi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS})
     endif()
   endif()
   ocv_target_compile_definitions(${the_module} PRIVATE -DHAVE_ONEVPL)
   ocv_target_link_libraries(${the_module} PRIVATE ${VPL_IMPORTED_TARGETS})
+
   if(HAVE_D3D11 AND HAVE_OPENCL)
     ocv_target_include_directories(${the_module} SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS})
   endif()
 
@@ -46,9 +46,72 @@ struct GAPI_EXPORTS CfgParam {
                                       double_t,
                                       void*,
                                       std::string>;
+    /**
+     * @brief frames_pool_size_name
+     *
+     * Special configuration parameter name for onevp::GSource:
+     *
+     * @note frames_pool_size_name allows to allocate surfaces pool appropriate size to keep
+     * decoded frames in accelerator memory ready before
+     * they would be consumed by onevp::GSource::pull operation. If you see
+     * a lot of WARNING about lack of free surface then it's time to increase
+     * frames_pool_size_name but be aware of accelerator free memory volume.
+     * If not set then MFX implementation use
+     * mfxFrameAllocRequest::NumFrameSuggested behavior
+     *
+     */
+    static constexpr const char *frames_pool_size_name() { return "frames_pool_size"; }
+    static CfgParam create_frames_pool_size(uint64_t value);
+
+    /**
+     * @brief acceleration_mode_name
+     *
+     * Special configuration parameter names for onevp::GSource:
+     *
+     * @note acceleration_mode_name allows to activate hardware acceleration &
+     * device memory management.
+     * Supported values:
+     * - MFX_ACCEL_MODE_VIA_D3D11   Will activate DX11 acceleration and will produces
+     * MediaFrames with data allocated in DX11 device memory
+     *
+     * If not set then MFX implementation will use default acceleration behavior:
+     * all decoding operation uses default GPU resources but MediaFrame produces
+     * data allocated by using host RAM
+     *
+     */
+    static constexpr const char *acceleration_mode_name() { return "mfxImplDescription.AccelerationMode"; }
+    static CfgParam create_acceleration_mode(uint32_t value);
+    static CfgParam create_acceleration_mode(const char* value);
+
+    /**
+     * @brief decoder_id_name
+     *
+     * Special configuration parameter names for onevp::GSource:
+     *
+     * @note decoder_id_name allows to specify VPL decoder type which MUST present
+     * in case of RAW video input data and MUST NOT present as CfgParam if video
+     * stream incapsulated into container(*.mp4, *.mkv and so on). In latter case
+     * onevp::GSource will determine it automatically
+     * Supported values:
+     * - MFX_CODEC_AVC
+     * - MFX_CODEC_HEVC
+     * - MFX_CODEC_MPEG2
+     * - MFX_CODEC_VC1
+     * - MFX_CODEC_CAPTURE
+     * - MFX_CODEC_VP9
+     * - MFX_CODEC_AV1
+     *
+     */
+    static constexpr const char *decoder_id_name() { return "mfxImplDescription.mfxDecoderDescription.decoder.CodecID"; }
+    static CfgParam create_decoder_id(uint32_t value);
+    static CfgParam create_decoder_id(const char* value);
+
+    static constexpr const char *implementation_name() { return "mfxImplDescription.Impl"; }
+    static CfgParam create_implementation(uint32_t value);
+    static CfgParam create_implementation(const char* value);
 
     /**
-     * Create onevp::GSource configuration parameter.
+     * Create generic onevp::GSource configuration parameter.
      *
      *@param name           name of parameter.
      *@param value          value of parameter.
 
@@ -18,16 +18,19 @@ using namespace perf;
 const std::string files[] = {
     "highgui/video/big_buck_bunny.h265",
     "highgui/video/big_buck_bunny.h264",
+    "highgui/video/sample_322x242_15frames.yuv420p.libx265.mp4",
 };
 
 const std::string codec[] = {
     "MFX_CODEC_HEVC",
-    "MFX_CODEC_AVC"
+    "MFX_CODEC_AVC",
+    "",
 };
 
 using source_t = std::string;
 using codec_t = std::string;
-using source_description_t = std::tuple<source_t, codec_t>;
+using accel_mode_t = std::string;
+using source_description_t = std::tuple<source_t, codec_t, accel_mode_t>;
 
 class OneVPLSourcePerfTest : public TestPerfParams<source_description_t> {};
 class VideoCapSourcePerfTest : public TestPerfParams<source_t> {};
@@ -39,12 +42,20 @@ PERF_TEST_P_(OneVPLSourcePerfTest, TestPerformance)
     const auto params = GetParam();
     source_t src = findDataFile(get<0>(params));
     codec_t type = get<1>(params);
+    accel_mode_t mode = get<2>(params);
 
     std::vector<CfgParam> cfg_params {
-        CfgParam::create<std::string>("mfxImplDescription.Impl", "MFX_IMPL_TYPE_HARDWARE"),
-        CfgParam::create("mfxImplDescription.mfxDecoderDescription.decoder.CodecID", type),
+        CfgParam::create_implementation("MFX_IMPL_TYPE_HARDWARE"),
     };
 
+    if (!type.empty()) {
+        cfg_params.push_back(CfgParam::create_decoder_id(type.c_str()));
+    }
+
+    if (!mode.empty()) {
+        cfg_params.push_back(CfgParam::create_acceleration_mode(mode.c_str()));
+    }
+
     auto source_ptr = cv::gapi::wip::make_onevpl_src(src, cfg_params);
 
     cv::gapi::wip::Data out;
@@ -72,12 +83,17 @@ PERF_TEST_P_(VideoCapSourcePerfTest, TestPerformance)
 }
 
 INSTANTIATE_TEST_CASE_P(Streaming, OneVPLSourcePerfTest,
-                        Values(source_description_t(files[0], codec[0]),
-                               source_description_t(files[1], codec[1])));
+                        Values(source_description_t(files[0], codec[0], ""),
+                               source_description_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_D3D11"),
+                               source_description_t(files[1], codec[1], ""),
+                               source_description_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_D3D11"),
+                               source_description_t(files[2], codec[2], ""),
+                               source_description_t(files[2], codec[2], "MFX_ACCEL_MODE_VIA_D3D11")));
 
 INSTANTIATE_TEST_CASE_P(Streaming, VideoCapSourcePerfTest,
                         Values(files[0],
-                               files[1]));
+                               files[1],
+                               files[2]));
 } // namespace opencv_test
 
 #endif // HAVE_ONEVPL
@@ -38,12 +38,14 @@
 const std::string about =
     "This is an OpenCV-based version of oneVPLSource decoder example";
 const std::string keys =
-    "{ h help       |                                           | Print this help message }"
-    "{ input        |                                           | Path to the input demultiplexed video file }"
-    "{ output       |                                           | Path to the output RAW video file. Use .avi extension }"
-    "{ facem        | face-detection-adas-0001.xml              | Path to OpenVINO IE face detection model (.xml) }"
-    "{ faced        | CPU                                       | Target device for face detection model (e.g. CPU, GPU, VPU, ...) }"
-    "{ cfg_params   | <prop name>:<value>;<prop name>:<value>   | Semicolon separated list of oneVPL mfxVariants which is used for configuring source (see `MFXSetConfigFilterProperty` by https://spec.oneapi.io/versions/latest/elements/oneVPL/source/index.html) }";
+    "{ h help                       |                                           | Print this help message }"
+    "{ input                        |                                           | Path to the input demultiplexed video file }"
+    "{ output                       |                                           | Path to the output RAW video file. Use .avi extension }"
+    "{ facem                        | face-detection-adas-0001.xml              | Path to OpenVINO IE face detection model (.xml) }"
+    "{ faced                        | AUTO                                      | Target device for face detection model (e.g. AUTO, GPU, VPU, ...) }"
+    "{ cfg_params                   | <prop name>:<value>;<prop name>:<value>   | Semicolon separated list of oneVPL mfxVariants which is used for configuring source (see `MFXSetConfigFilterProperty` by https://spec.oneapi.io/versions/latest/elements/oneVPL/source/index.html) }"
+    "{ streaming_queue_capacity     | 1                                         | Streaming executor queue capacity. Calculated automaticaly if 0 }"
+    "{ frames_pool_size             | 0                                         | OneVPL source applies this parameter as preallocated frames pool size}";
 
 
 namespace {
@@ -194,6 +196,8 @@ int main(int argc, char *argv[]) {
     std::string file_path = cmd.get<std::string>("input");
     const std::string output = cmd.get<std::string>("output");
     const auto face_model_path = cmd.get<std::string>("facem");
+    const auto streaming_queue_capacity = cmd.get<uint64_t>("streaming_queue_capacity");
+    const auto source_queue_capacity = cmd.get<uint64_t>("frames_pool_size");
 
     // check ouput file extension
     if (!output.empty()) {
@@ -217,6 +221,10 @@ int main(int argc, char *argv[]) {
         return -1;
     }
 
+    if (source_queue_capacity != 0) {
+        source_cfgs.push_back(cv::gapi::wip::onevpl::CfgParam::create_frames_pool_size(source_queue_capacity));
+    }
+
     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
@@ -298,6 +306,10 @@ int main(int argc, char *argv[]) {
         < custom::OCVLocateROI
         , custom::OCVBBoxes>();
     auto networks = cv::gapi::networks(face_net);
+    auto face_detection_args = cv::compile_args(networks, kernels);
+    if (streaming_queue_capacity != 0) {
+        face_detection_args += cv::compile_args(cv::gapi::streaming::queue_capacity{ streaming_queue_capacity });
+    }
 
     // Create source
     cv::Ptr<cv::gapi::wip::IStreamSource> cap;
@@ -331,7 +343,7 @@ int main(int argc, char *argv[]) {
     cv::GStreamingCompiled pipeline;
     try {
         pipeline = cv::GComputation(cv::GIn(in), cv::GOut(out))
-                .compileStreaming(cv::compile_args(kernels, networks));
+                .compileStreaming(std::move(face_detection_args));
     } catch (const std::exception& ex) {
         std::cerr << "Exception occured during pipeline construction: " << ex.what() << std::endl;
         return -1;
 
@@ -128,15 +128,12 @@ GAPI_OCV_KERNEL_ST(RenderFrameOCVImpl, cv::gapi::wip::draw::GRenderFrame, Render
         out = in;
 
         auto desc = out.desc();
-        auto w_out = out.access(cv::MediaFrame::Access::W);
-
-        auto out_y = cv::Mat(desc.size, CV_8UC1, w_out.ptr[0], w_out.stride[0]);
-        auto out_uv = cv::Mat(desc.size / 2, CV_8UC2, w_out.ptr[1], w_out.stride[1]);
-
-        auto r_in = in.access(cv::MediaFrame::Access::R);
+        cv::Mat upsample_uv, yuv;
+        {
+            auto r_in = in.access(cv::MediaFrame::Access::R);
 
-        auto in_y = cv::Mat(desc.size, CV_8UC1, r_in.ptr[0], r_in.stride[0]);
-        auto in_uv = cv::Mat(desc.size / 2, CV_8UC2, r_in.ptr[1], r_in.stride[1]);
+            auto in_y = cv::Mat(desc.size, CV_8UC1, r_in.ptr[0], r_in.stride[0]);
+            auto in_uv = cv::Mat(desc.size / 2, CV_8UC2, r_in.ptr[1], r_in.stride[1]);
 
         /* FIXME How to render correctly on NV12 format ?
          *
@@ -157,19 +154,26 @@ GAPI_OCV_KERNEL_ST(RenderFrameOCVImpl, cv::gapi::wip::draw::GRenderFrame, Render
          *
          */
 
-         // NV12 -> YUV
-        cv::Mat upsample_uv, yuv;
-        cv::resize(in_uv, upsample_uv, in_uv.size() * 2, cv::INTER_LINEAR);
-        cv::merge(std::vector<cv::Mat>{in_y, upsample_uv}, yuv);
+            // NV12 -> YUV
+            cv::resize(in_uv, upsample_uv, in_uv.size() * 2, cv::INTER_LINEAR);
+            cv::merge(std::vector<cv::Mat>{in_y, upsample_uv}, yuv);
+        }
 
         cv::gapi::wip::draw::drawPrimitivesOCVYUV(yuv, prims, state.ftpr);
 
         // YUV -> NV12
-        cv::Mat out_u, out_v, uv_plane;
-        std::vector<cv::Mat> chs = { out_y, out_u, out_v };
-        cv::split(yuv, chs);
-        cv::merge(std::vector<cv::Mat>{chs[1], chs[2]}, uv_plane);
-        cv::resize(uv_plane, out_uv, uv_plane.size() / 2, cv::INTER_LINEAR);
+        {
+            auto w_out = out.access(cv::MediaFrame::Access::W);
+
+            auto out_y = cv::Mat(desc.size, CV_8UC1, w_out.ptr[0], w_out.stride[0]);
+            auto out_uv = cv::Mat(desc.size / 2, CV_8UC2, w_out.ptr[1], w_out.stride[1]);
+
+            cv::Mat out_u, out_v, uv_plane;
+            std::vector<cv::Mat> chs = { out_y, out_u, out_v };
+            cv::split(yuv, chs);
+            cv::merge(std::vector<cv::Mat>{chs[1], chs[2]}, uv_plane);
+            cv::resize(uv_plane, out_uv, uv_plane.size() / 2, cv::INTER_LINEAR);
+        }
     }
 
     static void setup(const cv::GFrameDesc&   /* in_nv12  */,