opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+5Lines changed: 5 additions & 0 deletions
diff --git a/‎modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp
Copy file name to clipboard
+205-6Lines changed: 205 additions & 6 deletions b/‎modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp
Copy file name to clipboard
+205-6Lines changed: 205 additions & 6 deletions
diff --git a/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+5-25Lines changed: 5 additions & 25 deletions b/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+5-25Lines changed: 5 additions & 25 deletions
@@ -186,6 +186,7 @@ set(gapi_srcs
     src/streaming/onevpl/cfg_params_parser.cpp
     src/streaming/onevpl/utils.cpp
     src/streaming/onevpl/data_provider_interface_exception.cpp
+    src/streaming/onevpl/accelerators/surface/base_frame_adapter.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
@@ -200,6 +201,8 @@ set(gapi_srcs
     src/streaming/onevpl/engine/decode/decode_session.cpp
     src/streaming/onevpl/engine/transcode/transcode_engine_legacy.cpp
     src/streaming/onevpl/engine/transcode/transcode_session.cpp
+    src/streaming/onevpl/engine/preproc/preproc_engine.cpp
+    src/streaming/onevpl/engine/preproc/preproc_session.cpp
     src/streaming/onevpl/demux/async_mfp_demux_data_provider.cpp
     src/streaming/onevpl/data_provider_dispatcher.cpp
 
@@ -360,7 +363,9 @@ endif()
 # perf test dependencies postprocessing
 if(HAVE_GAPI_ONEVPL)
   # NB: TARGET opencv_perf_gapi doesn't exist before `ocv_add_perf_tests`
+  # src/ is specified to include dirs for INTERNAL tests only.
   if(TARGET opencv_perf_gapi)
+    target_include_directories(opencv_perf_gapi PRIVATE "${CMAKE_CURRENT_LIST_DIR}/src")
     ocv_target_compile_definitions(opencv_perf_gapi PRIVATE -DHAVE_ONEVPL)
     ocv_target_link_libraries(opencv_perf_gapi PRIVATE ${VPL_IMPORTED_TARGETS})
     if(HAVE_D3D11 AND HAVE_OPENCL)
 
@@ -11,6 +11,13 @@
 #include <opencv2/gapi/streaming/onevpl/source.hpp>
 #include <opencv2/gapi/streaming/cap.hpp>
 
+#include "streaming/onevpl/engine/preproc/preproc_engine.hpp"
+#include "streaming/onevpl/engine/preproc/preproc_session.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_interface.hpp"
+#include "streaming/onevpl/cfg_param_device_selector.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_dx11.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
+
 namespace opencv_test
 {
 using namespace perf;
@@ -32,10 +39,10 @@ using codec_t = std::string;
 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> {};
+class OneVPLSourcePerf_Test : public TestPerfParams<source_description_t> {};
+class VideoCapSourcePerf_Test : public TestPerfParams<source_t> {};
 
-PERF_TEST_P_(OneVPLSourcePerfTest, TestPerformance)
+PERF_TEST_P_(OneVPLSourcePerf_Test, TestPerformance)
 {
     using namespace cv::gapi::wip::onevpl;
 
@@ -67,7 +74,7 @@ PERF_TEST_P_(OneVPLSourcePerfTest, TestPerformance)
     SANITY_CHECK_NOTHING();
 }
 
-PERF_TEST_P_(VideoCapSourcePerfTest, TestPerformance)
+PERF_TEST_P_(VideoCapSourcePerf_Test, TestPerformance)
 {
     using namespace cv::gapi::wip;
 
@@ -82,18 +89,210 @@ PERF_TEST_P_(VideoCapSourcePerfTest, TestPerformance)
     SANITY_CHECK_NOTHING();
 }
 
-INSTANTIATE_TEST_CASE_P(Streaming, OneVPLSourcePerfTest,
+INSTANTIATE_TEST_CASE_P(Streaming, OneVPLSourcePerf_Test,
                         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,
+INSTANTIATE_TEST_CASE_P(Streaming, VideoCapSourcePerf_Test,
                         Values(files[0],
                                files[1],
                                files[2]));
+
+using pp_out_param_t = cv::GFrameDesc;
+using source_description_preproc_t = decltype(std::tuple_cat(std::declval<source_description_t>(),
+                                                             std::declval<std::tuple<pp_out_param_t>>()));
+class OneVPLSourcePerf_PP_Test : public TestPerfParams<source_description_preproc_t> {};
+
+PERF_TEST_P_(OneVPLSourcePerf_PP_Test, TestPerformance)
+{
+    using namespace cv::gapi::wip::onevpl;
+
+    const auto params = GetParam();
+    source_t src = findDataFile(get<0>(params));
+    codec_t type = get<1>(params);
+    accel_mode_t mode = get<2>(params);
+    pp_out_param_t res = get<3>(params);
+
+    std::vector<CfgParam> cfg_params {
+        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()));
+    }
+
+    cfg_params.push_back(CfgParam::create_vpp_out_width(static_cast<uint16_t>(res.size.width)));
+    cfg_params.push_back(CfgParam::create_vpp_out_height(static_cast<uint16_t>(res.size.height)));
+    cfg_params.push_back(CfgParam::create_vpp_out_crop_x(0));
+    cfg_params.push_back(CfgParam::create_vpp_out_crop_y(0));
+    cfg_params.push_back(CfgParam::create_vpp_out_crop_w(static_cast<uint16_t>(res.size.width)));
+    cfg_params.push_back(CfgParam::create_vpp_out_crop_h(static_cast<uint16_t>(res.size.height)));
+
+    auto source_ptr = cv::gapi::wip::make_onevpl_src(src, cfg_params);
+
+    cv::gapi::wip::Data out;
+    TEST_CYCLE()
+    {
+        source_ptr->pull(out);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+static pp_out_param_t full_hd = pp_out_param_t {cv::MediaFormat::NV12,
+                                                {1920, 1080}};
+
+static pp_out_param_t cif = pp_out_param_t {cv::MediaFormat::NV12,
+                                            {352, 288}};
+
+INSTANTIATE_TEST_CASE_P(Streaming_Source_PP, OneVPLSourcePerf_PP_Test,
+                        Values(source_description_preproc_t(files[0], codec[0], "", full_hd),
+                               source_description_preproc_t(files[0], codec[0], "", cif),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_D3D11", full_hd),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_D3D11", cif),
+                               source_description_preproc_t(files[1], codec[1], "", full_hd),
+                               source_description_preproc_t(files[1], codec[1], "", cif),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_D3D11",full_hd),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_D3D11",cif),
+                               source_description_preproc_t(files[2], codec[2], "", full_hd),
+                               source_description_preproc_t(files[2], codec[2], "", cif),
+                               source_description_preproc_t(files[2], codec[2], "MFX_ACCEL_MODE_VIA_D3D11", full_hd),
+                               source_description_preproc_t(files[2], codec[2], "MFX_ACCEL_MODE_VIA_D3D11", cif)));
+
+class OneVPLSourcePerf_PP_Engine_Test : public TestPerfParams<source_description_preproc_t> {};
+
+PERF_TEST_P_(OneVPLSourcePerf_PP_Engine_Test, TestPerformance)
+{
+    using namespace cv::gapi::wip;
+    using namespace cv::gapi::wip::onevpl;
+
+    const auto params = GetParam();
+    source_t src = findDataFile(get<0>(params));
+    codec_t type = get<1>(params);
+    accel_mode_t mode = get<2>(params);
+    const pp_out_param_t &required_frame_param = get<3>(params);
+
+    std::vector<CfgParam> cfg_params {
+        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 device_selector = std::make_shared<CfgParamDeviceSelector>(cfg_params);
+    auto source_ptr = cv::gapi::wip::make_onevpl_src(src, cfg_params, device_selector);
+
+    // create VPP preproc engine
+    std::unique_ptr<VPLAccelerationPolicy> policy;
+    if (mode == "MFX_ACCEL_MODE_VIA_D3D11") {
+        policy.reset(new VPLDX11AccelerationPolicy(device_selector));
+    } else if (mode.empty()){
+        policy.reset(new VPLCPUAccelerationPolicy(device_selector));
+    } else {
+        ASSERT_TRUE(false && "Unsupported acceleration policy type");
+    }
+    VPPPreprocEngine preproc_engine(std::move(policy));
+    cv::gapi::wip::Data out;
+    TEST_CYCLE()
+    {
+        source_ptr->pull(out);
+        cv::MediaFrame frame = cv::util::get<cv::MediaFrame>(out);
+        cv::util::optional<pp_params> param = preproc_engine.is_applicable(frame);
+        pp_session sess = preproc_engine.initialize_preproc(param.value(),
+                                                            required_frame_param);
+        (void)preproc_engine.run_sync(sess, frame);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+INSTANTIATE_TEST_CASE_P(Streaming_Engine_PP, OneVPLSourcePerf_PP_Engine_Test,
+                        Values(source_description_preproc_t(files[0], codec[0], "", full_hd),
+                               source_description_preproc_t(files[0], codec[0], "", cif),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_D3D11", full_hd),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_D3D11", cif),
+                               source_description_preproc_t(files[1], codec[1], "", full_hd),
+                               source_description_preproc_t(files[1], codec[1], "", cif),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_D3D11",full_hd),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_D3D11",cif),
+                               source_description_preproc_t(files[2], codec[2], "", full_hd),
+                               source_description_preproc_t(files[2], codec[2], "", cif),
+                               source_description_preproc_t(files[2], codec[2], "MFX_ACCEL_MODE_VIA_D3D11", full_hd),
+                               source_description_preproc_t(files[2], codec[2], "MFX_ACCEL_MODE_VIA_D3D11", cif)));
+
+class OneVPLSourcePerf_PP_Engine_Bypass_Test : public TestPerfParams<source_description_preproc_t> {};
+
+PERF_TEST_P_(OneVPLSourcePerf_PP_Engine_Bypass_Test, TestPerformance)
+{
+    using namespace cv::gapi::wip;
+    using namespace cv::gapi::wip::onevpl;
+
+    const auto params = GetParam();
+    source_t src = findDataFile(get<0>(params));
+    codec_t type = get<1>(params);
+    accel_mode_t mode = get<2>(params);
+    const pp_out_param_t &required_frame_param = get<3>(params);
+
+    std::vector<CfgParam> cfg_params {
+        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 device_selector = std::make_shared<CfgParamDeviceSelector>(cfg_params);
+    auto source_ptr = cv::gapi::wip::make_onevpl_src(src, cfg_params, device_selector);
+
+    // create VPP preproc engine
+    std::unique_ptr<VPLAccelerationPolicy> policy;
+    if (mode == "MFX_ACCEL_MODE_VIA_D3D11") {
+        policy.reset(new VPLDX11AccelerationPolicy(device_selector));
+    } else {
+        policy.reset(new VPLCPUAccelerationPolicy(device_selector));
+    }
+    VPPPreprocEngine preproc_engine(std::move(policy));
+    cv::gapi::wip::Data out;
+    TEST_CYCLE()
+    {
+        source_ptr->pull(out);
+        cv::MediaFrame frame = cv::util::get<cv::MediaFrame>(out);
+        cv::util::optional<pp_params> param = preproc_engine.is_applicable(frame);
+        pp_session sess = preproc_engine.initialize_preproc(param.value(),
+                                                            required_frame_param);
+        (void)preproc_engine.run_sync(sess, frame);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+static pp_out_param_t res_672x384 = pp_out_param_t {cv::MediaFormat::NV12,
+                                                    {672, 384}};
+static pp_out_param_t res_336x256 = pp_out_param_t {cv::MediaFormat::NV12,
+                                                    {336, 256}};
+INSTANTIATE_TEST_CASE_P(Streaming_Engine_PP_Bypass, OneVPLSourcePerf_PP_Engine_Bypass_Test,
+                        Values(source_description_preproc_t(files[0], codec[0], "", res_672x384),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_D3D11", res_672x384),
+                               source_description_preproc_t(files[1], codec[1], "", res_672x384),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_D3D11", res_672x384),
+                               source_description_preproc_t(files[2], codec[2], "", res_336x256),
+                               source_description_preproc_t(files[2], codec[2], "MFX_ACCEL_MODE_VIA_D3D11", res_336x256)));
 } // namespace opencv_test
 
 #endif // HAVE_ONEVPL
@@ -46,8 +46,7 @@ const std::string keys =
     "{ 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}"
-    "{ vpp_frames_pool_size         | 0                                         | OneVPL source applies this parameter as preallocated frames pool size for VPP preprocessing results}"
-    "{ source_preproc_enable        | 0                                         | Turn on OneVPL source frame preprocessing using network input description instead of IE plugin preprocessing}";
+    "{ vpp_frames_pool_size         | 0                                         | OneVPL source applies this parameter as preallocated frames pool size for VPP preprocessing results}";
 
 namespace {
 bool is_gpu(const std::string &device_name) {
@@ -217,7 +216,6 @@ int main(int argc, char *argv[]) {
     const auto streaming_queue_capacity = cmd.get<uint32_t>("streaming_queue_capacity");
     const auto source_decode_queue_capacity = cmd.get<uint32_t>("frames_pool_size");
     const auto source_vpp_queue_capacity = cmd.get<uint32_t>("vpp_frames_pool_size");
-    const auto vpl_source_preproc_enable = cmd.get<uint32_t>("source_preproc_enable");
     const auto device_id = cmd.get<std::string>("faced");
 
     // check ouput file extension
@@ -235,12 +233,6 @@ int main(int argc, char *argv[]) {
     try {
         std::string line;
         while (std::getline(params_list, line, ';')) {
-            if (vpl_source_preproc_enable == 0) {
-                if (line.find("vpp.") != std::string::npos) {
-                    // skip VPP preprocessing primitives if not requested
-                    continue;
-                }
-            }
             source_cfgs.push_back(cfg::create_from_string(line));
         }
     } catch (const std::exception& ex) {
@@ -325,23 +317,11 @@ int main(int argc, char *argv[]) {
     // set ctx_config for GPU device only - no need in case of CPU device type
     if (is_gpu(device_id)) {
         InferenceEngine::ParamMap ctx_config({{"CONTEXT_TYPE", "VA_SHARED"},
-                                            {"VA_DEVICE", accel_device_ptr} });
-
+                                              {"VA_DEVICE", accel_device_ptr} });
         face_net.cfgContextParams(ctx_config);
-        face_net.pluginConfig({{"GPU_NV12_TWO_INPUTS", "YES" }});
 
-        std::cout <<"/*******************************************************/\n"
-                    "ATTENTION: GPU Inference Engine preprocessing is not vital as expected!"
-                     " Please consider param \"source_preproc_enable=1\" and specify "
-                     " appropriated media frame transformation using oneVPL::VPP primitives"
-                     " which force onevpl::GSource to produce tranformed media frames."
-                     " For exploring list of supported transformations please find out "
-                     " vpp_* related stuff in"
-                     " gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp"
-                     " Pay attention that to obtain expected result In this case VPP "
-                     " transformation must match network input params."
-                     " Please vote/create issue about exporting network params using GAPI\n"
-                     "/******************************************************/" << std::endl;
+        // NB: consider NV12 surface because it's one of native GPU image format
+        face_net.pluginConfig({{"GPU_NV12_TWO_INPUTS", "YES" }});
     }
 #endif // HAVE_INF_ENGINE
 
@@ -378,7 +358,7 @@ int main(int argc, char *argv[]) {
     cv::GFrame in;
     auto size = cv::gapi::streaming::size(in);
     auto roi = custom::LocateROI::on(size, std::cref(device_id));
-    auto blob = cv::gapi::infer<custom::FaceDetector>(roi, in);
+    auto blob = cv::gapi::infer<custom::FaceDetector>(in);
     cv::GArray<cv::Rect> rcs = cv::gapi::parseSSD(blob, size, 0.5f, true, true);
     auto out_frame = cv::gapi::wip::draw::renderFrame(in, custom::BBoxes::on(rcs, roi));
     auto out = cv::gapi::streaming::BGR(out_frame);