Merge branch 4.x

modules/gapi/CMakeLists.txt

@@ -133,7 +133,7 @@ set(gapi_srcs
     src/backends/fluid/gfluidimgproc.cpp
     src/backends/fluid/gfluidimgproc_func.dispatch.cpp
     src/backends/fluid/gfluidcore.cpp
-	  src/backends/fluid/gfluidcore_func.dispatch.cpp
+    src/backends/fluid/gfluidcore_func.dispatch.cpp
 
     # OAK Backend (optional)
     src/backends/oak/goak.cpp
@@ -194,6 +194,7 @@ set(gapi_srcs
     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/accel_policy_va_api.cpp
     src/streaming/onevpl/accelerators/dx11_alloc_resource.cpp
     src/streaming/onevpl/engine/engine_session.cpp
     src/streaming/onevpl/engine/processing_engine_base.cpp
@@ -310,12 +311,27 @@ if(HAVE_GAPI_ONEVPL)
         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()
+
+  if(UNIX)
+    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(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()
 
 ocv_option(OPENCV_GAPI_GSTREAMER "Build G-API with GStreamer support" HAVE_GSTREAMER)
@@ -354,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)

modules/gapi/cmake/DownloadADE.cmake

@@ -1,7 +1,7 @@
 set(ade_src_dir "${OpenCV_BINARY_DIR}/3rdparty/ade")
-set(ade_filename "v0.1.1f.zip")
-set(ade_subdir "ade-0.1.1f")
-set(ade_md5 "b624b995ec9c439cbc2e9e6ee940d3a2")
+set(ade_filename "v0.1.2.zip")
+set(ade_subdir "ade-0.1.2")
+set(ade_md5 "561c1e28ccf27ad0557a18e251c22226")
 ocv_download(FILENAME ${ade_filename}
              HASH ${ade_md5}
              URL

modules/gapi/include/opencv2/gapi/fluid/gfluidkernel.hpp

@@ -181,7 +181,7 @@ template<> struct fluid_get_in<cv::GMat>
 template<> struct fluid_get_in<cv::GScalar>
 {
     // FIXME: change to return by reference when moved to own::Scalar
-    static const cv::Scalar get(const cv::GArgs &in_args, int idx)
+    static cv::Scalar get(const cv::GArgs &in_args, int idx)
     {
         return in_args[idx].unsafe_get<cv::Scalar>();
     }

modules/gapi/include/opencv2/gapi/own/types.hpp

@@ -89,7 +89,7 @@ inline Rect& operator&=(Rect& lhs, const Rect& rhs)
     return lhs;
 }
 
-inline const Rect operator&(const Rect& lhs, const Rect& rhs)
+inline Rect operator&(const Rect& lhs, const Rect& rhs)
 {
     Rect result = lhs;
     return result &= rhs;

modules/gapi/include/opencv2/gapi/streaming/cap.hpp

@@ -119,6 +119,12 @@ GAPI_EXPORTS_W cv::Ptr<IStreamSource> inline make_capture_src(const std::string&
     return make_src<GCaptureSource>(path);
 }
 
+// NB: Overload for using from python
+GAPI_EXPORTS_W cv::Ptr<IStreamSource> inline make_capture_src(const int id)
+{
+    return make_src<GCaptureSource>(id);
+}
+
 } // namespace wip
 } // namespace gapi
 } // namespace cv

modules/gapi/include/opencv2/gapi/streaming/onevpl/accel_types.hpp

@@ -20,6 +20,7 @@ namespace onevpl {
 enum class AccelType: uint8_t {
     HOST,
     DX11,
+    VAAPI,
 
     LAST_VALUE = std::numeric_limits<uint8_t>::max()
 };
@@ -64,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

modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp

@@ -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;

modules/gapi/misc/python/samples/gaze_estimation.py

@@ -27,7 +27,7 @@ def build_argparser():
     parser = argparse.ArgumentParser(description='This is an OpenCV-based version of Gaze Estimation example')
 
     parser.add_argument('--input',
-                        help='Path to the input video file')
+                        help='Path to the input video file or camera device number')
     parser.add_argument('--out',
                         help='Path to the output video file')
     parser.add_argument('--facem',
@@ -323,7 +323,11 @@ if __name__ == '__main__':
 
     # ------------------------Execution part------------------------
     ccomp = comp.compileStreaming(args=cv.gapi.compile_args(kernels, nets))
-    source = cv.gapi.wip.make_capture_src(ARGUMENTS.input)
+    if ARGUMENTS.input.isdigit():
+        source = cv.gapi.wip.make_capture_src(int(ARGUMENTS.input))
+    else:
+        source = cv.gapi.wip.make_capture_src(ARGUMENTS.input)
+
     ccomp.setSource(cv.gin(source))
     ccomp.start()
 

modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp

@@ -17,6 +17,7 @@
 #include "streaming/onevpl/cfg_param_device_selector.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_dx11.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_va_api.hpp"
 
 namespace opencv_test
 {
@@ -89,6 +90,7 @@ PERF_TEST_P_(VideoCapSourcePerf_Test, TestPerformance)
     SANITY_CHECK_NOTHING();
 }
 
+#ifdef __WIN32__
 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"),
@@ -96,6 +98,11 @@ INSTANTIATE_TEST_CASE_P(Streaming, OneVPLSourcePerf_Test,
                                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")));
+#elif __linux__
+INSTANTIATE_TEST_CASE_P(Streaming, OneVPLSourcePerf_Test,
+                        Values(source_description_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_VAAPI"),
+                               source_description_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_VAAPI")));
+#endif
 
 INSTANTIATE_TEST_CASE_P(Streaming, VideoCapSourcePerf_Test,
                         Values(files[0],
@@ -152,6 +159,8 @@ static pp_out_param_t full_hd = pp_out_param_t {cv::MediaFormat::NV12,
 static pp_out_param_t cif = pp_out_param_t {cv::MediaFormat::NV12,
                                             {352, 288}};
 
+
+#ifdef __WIN32__
 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),
@@ -165,6 +174,13 @@ INSTANTIATE_TEST_CASE_P(Streaming_Source_PP, OneVPLSourcePerf_PP_Test,
                                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)));
+#elif __linux__
+INSTANTIATE_TEST_CASE_P(Streaming_Source_PP, OneVPLSourcePerf_PP_Test,
+                        Values(source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_VAAPI", full_hd),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_VAAPI", cif),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_VAAPI",full_hd),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_VAAPI",cif)));
+#endif
 
 class OneVPLSourcePerf_PP_Engine_Test : public TestPerfParams<source_description_preproc_t> {};
 
@@ -198,6 +214,8 @@ PERF_TEST_P_(OneVPLSourcePerf_PP_Engine_Test, TestPerformance)
     std::unique_ptr<VPLAccelerationPolicy> policy;
     if (mode == "MFX_ACCEL_MODE_VIA_D3D11") {
         policy.reset(new VPLDX11AccelerationPolicy(device_selector));
+    } else if (mode == "MFX_ACCEL_MODE_VIA_VAAPI") {
+        policy.reset(new VPLVAAPIAccelerationPolicy(device_selector));
     } else if (mode.empty()){
         policy.reset(new VPLCPUAccelerationPolicy(device_selector));
     } else {
@@ -219,6 +237,7 @@ PERF_TEST_P_(OneVPLSourcePerf_PP_Engine_Test, TestPerformance)
     SANITY_CHECK_NOTHING();
 }
 
+#ifdef __WIN32__
 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),
@@ -232,6 +251,13 @@ INSTANTIATE_TEST_CASE_P(Streaming_Engine_PP, OneVPLSourcePerf_PP_Engine_Test,
                                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)));
+#elif __linux__
+INSTANTIATE_TEST_CASE_P(Streaming_Engine_PP, OneVPLSourcePerf_PP_Engine_Test,
+                        Values(source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_VAAPI", full_hd),
+                               source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_VAAPI", cif),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_VAAPI",full_hd),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_VAAPI",cif)));
+#endif
 
 class OneVPLSourcePerf_PP_Engine_Bypass_Test : public TestPerfParams<source_description_preproc_t> {};
 
@@ -265,8 +291,12 @@ PERF_TEST_P_(OneVPLSourcePerf_PP_Engine_Bypass_Test, TestPerformance)
     std::unique_ptr<VPLAccelerationPolicy> policy;
     if (mode == "MFX_ACCEL_MODE_VIA_D3D11") {
         policy.reset(new VPLDX11AccelerationPolicy(device_selector));
-    } else {
+    } else if (mode == "MFX_ACCEL_MODE_VIA_VAAPI") {
+        policy.reset(new VPLVAAPIAccelerationPolicy(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;
@@ -288,6 +318,8 @@ 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}};
+
+#ifdef __WIN32__
 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),
@@ -295,6 +327,11 @@ INSTANTIATE_TEST_CASE_P(Streaming_Engine_PP_Bypass, OneVPLSourcePerf_PP_Engine_B
                                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)));
+#elif __linux__
+INSTANTIATE_TEST_CASE_P(Streaming_Engine_PP_Bypass, OneVPLSourcePerf_PP_Engine_Bypass_Test,
+                        Values(source_description_preproc_t(files[0], codec[0], "MFX_ACCEL_MODE_VIA_VAAPI", res_672x384),
+                               source_description_preproc_t(files[1], codec[1], "MFX_ACCEL_MODE_VIA_VAAPI", res_672x384)));
+#endif
 } // namespace opencv_test
 
 #endif // HAVE_ONEVPL

modules/gapi/samples/onevpl_infer_single_roi.cpp

@@ -16,6 +16,7 @@
 
 #ifdef HAVE_INF_ENGINE
 #include <inference_engine.hpp> // ParamMap
+#endif // HAVE_INF_ENGINE
 
 #ifdef HAVE_DIRECTX
 #ifdef HAVE_D3D11
@@ -24,15 +25,23 @@
 // get rid of generate macro max/min/etc from DX side
 #define D3D11_NO_HELPERS
 #define NOMINMAX
-#include <cldnn/cldnn_config.hpp>
 #include <d3d11.h>
 #pragma comment(lib, "dxgi")
 #undef NOMINMAX
 #undef D3D11_NO_HELPERS
-
 #endif // HAVE_D3D11
 #endif // HAVE_DIRECTX
-#endif // HAVE_INF_ENGINE
+
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#include "va/va.h"
+#include "va/va_drm.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // __linux__
+
 
 const std::string about =
     "This is an OpenCV-based version of oneVPLSource decoder example";
@@ -41,14 +50,21 @@ const std::string keys =
     "{ 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) }"
+    "{ faced                        | GPU                                       | Target device for face detection model (e.g. AUTO, GPU, VPU, ...) }"
+    "{ cfg_params                   |                                           | 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 automatically 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}"
-    "{ roi                          | -1,-1,-1,-1                               | Region of interest (ROI) to use for inference. Identified automatically when not set }";
+    "{ roi                          | -1,-1,-1,-1                               | Region of interest (ROI) to use for inference. Identified automatically when not set }"
+    "{ source_device                | CPU                                       | choose device for decoding }"
+    "{ preproc_device               |                                           | choose device for preprocessing }";
+
 
 namespace {
+bool is_gpu(const std::string &device_name) {
+    return device_name.find("GPU") != std::string::npos;
+}
+
 std::string get_weights_path(const std::string &model_path) {
     const auto EXT_LEN = 4u;
     const auto sz = model_path.size();
@@ -84,7 +100,6 @@ cv::util::optional<cv::Rect> parse_roi(const std::string &rc) {
     return cv::util::make_optional(std::move(rv));
 }
 
-#ifdef HAVE_INF_ENGINE
 #ifdef HAVE_DIRECTX
 #ifdef HAVE_D3D11
 
@@ -134,7 +149,6 @@ AccelParamsType create_device_with_ctx(IDXGIAdapter* adapter) {
 }
 #endif // HAVE_D3D11
 #endif // HAVE_DIRECTX
-#endif // HAVE_INF_ENGINE
 } // anonymous namespace
 
 namespace custom {
@@ -260,6 +274,79 @@ GAPI_OCV_KERNEL(OCVParseSSD, ParseSSD) {
 
 namespace cfg {
 typename cv::gapi::wip::onevpl::CfgParam create_from_string(const std::string &line);
+
+struct flow {
+    flow(bool preproc, bool rctx) :
+        vpl_preproc_enable(preproc),
+        ie_remote_ctx_enable(rctx) {
+    }
+    bool vpl_preproc_enable = false;
+    bool ie_remote_ctx_enable = false;
+};
+
+using support_matrix =
+        std::map <std::string/*source_dev_id*/,
+                  std::map<std::string/*preproc_device_id*/,
+                           std::map <std::string/*rctx device_id*/, std::shared_ptr<flow>>>>;
+support_matrix resolved_conf{{
+                            {"GPU", {{
+                                        {"",    {{ "CPU", std::make_shared<flow>(false, false)},
+                                                 { "GPU", {/* unsupported:
+                                                           * ie GPU preproc isn't available */}}
+                                                }},
+
+                                        {"CPU", {{ "CPU", {/* unsupported: preproc mix */}},
+                                                 { "GPU", {/* unsupported: preproc mix */}}
+                                                }},
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
+                                        {"GPU", {{ "CPU", std::make_shared<flow>(true, false)},
+                                                 { "GPU", std::make_shared<flow>(true, true)}}}
+#else   // TODO VAAPI under linux doesn't support GPU IE remote context
+                                        {"GPU", {{ "CPU", std::make_shared<flow>(true, false)},
+                                                 { "GPU", std::make_shared<flow>(true, false)}}}
+#endif
+                                    }}
+                            },
+                            {"CPU", {{
+                                        {"",    {{ "CPU", std::make_shared<flow>(false, false)},
+                                                 { "GPU", std::make_shared<flow>(false, false)}
+                                                }},
+
+                                        {"CPU", {{ "CPU", std::make_shared<flow>(true, false)},
+                                                 { "GPU", std::make_shared<flow>(true, false)}
+                                                }},
+
+                                        {"GPU", {{ "CPU", {/* unsupported: preproc mix */}},
+                                                 { "GPU", {/* unsupported: preproc mix */}}}}
+                                    }}
+                            }
+                        }};
+
+static void print_available_cfg(std::ostream &out,
+                                const std::string &source_device,
+                                const std::string &preproc_device,
+                                const std::string &ie_device_id) {
+    const std::string source_device_cfg_name("--source_device=");
+    const std::string preproc_device_cfg_name("--preproc_device=");
+    const std::string ie_cfg_name("--faced=");
+    out << "unsupported acceleration param combinations:\n"
+                     << source_device_cfg_name << source_device << " "
+                     << preproc_device_cfg_name << preproc_device << " "
+                     << ie_cfg_name << ie_device_id <<
+                     "\n\nSupported matrix:\n\n" << std::endl;
+    for (const auto &s_d : cfg::resolved_conf) {
+        std::string prefix = source_device_cfg_name + s_d.first;
+        for (const auto &p_d : s_d.second) {
+            std::string mid_prefix = prefix + +"\t" + preproc_device_cfg_name +
+                                    (p_d.first.empty() ? "" : p_d.first);
+            for (const auto &i_d : p_d.second) {
+                if (i_d.second) {
+                    std::cerr << mid_prefix << "\t" << ie_cfg_name <<i_d.first << std::endl;
+                }
+            }
+        }
+    }
+}
 }
 
 int main(int argc, char *argv[]) {
@@ -280,6 +367,15 @@ int main(int argc, char *argv[]) {
     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 device_id = cmd.get<std::string>("faced");
+    const auto source_device = cmd.get<std::string>("source_device");
+    const auto preproc_device = cmd.get<std::string>("preproc_device");
+
+    // validate support matrix
+    std::shared_ptr<cfg::flow> flow_settings = cfg::resolved_conf[source_device][preproc_device][device_id];
+    if (!flow_settings) {
+        cfg::print_available_cfg(std::cerr, source_device, preproc_device, device_id);
+        return -1;
+    }
 
     // check output file extension
     if (!output.empty()) {
@@ -303,6 +399,7 @@ int main(int argc, char *argv[]) {
         return -1;
     }
 
+    // apply VPL source optimization params
     if (source_decode_queue_capacity != 0) {
         source_cfgs.push_back(cv::gapi::wip::onevpl::CfgParam::create_frames_pool_size(source_decode_queue_capacity));
     }
@@ -316,22 +413,57 @@ int main(int argc, char *argv[]) {
         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
-    cv::util::optional<cv::gapi::wip::onevpl::Device> accel_device;
-    cv::util::optional<cv::gapi::wip::onevpl::Context> accel_ctx;
+    // It is allowed (and highly recommended) to reuse predefined device_ptr & context_ptr objects
+    // received from user application. Current sample demonstrate how to deal with this situation.
+    //
+    // But if you do not need this fine-grained acceleration devices configuration then
+    // just use default constructors for onevpl::GSource, IE and preprocessing module.
+    // But please pay attention that default pipeline construction in this case will be
+    // very inefficient and carries out multiple CPU-GPU memory copies
+    //
+    // If you want to reach max performance and seize copy-free approach for specific
+    // device & context selection then follow the steps below.
+    // The situation is complicated a little bit in comparison with default configuration, thus
+    // let's focusing this:
+    //
+    // - all component-participants (Source, Preprocessing, Inference)
+    // must share the same device & context instances
+    //
+    // - you must wrapping your available device & context instancs into thin
+    // `cv::gapi::wip::Device` & `cv::gapi::wip::Context`.
+    // !!! Please pay attention that both objects are weak wrapper so you must ensure
+    // that device & context would be alived before full pipeline created !!!
+    //
+    // - you should pass such wrappers as constructor arguments for each component in pipeline:
+    //      a) use extended constructor for `onevpl::GSource` for activating predefined device & context
+    //      b) use `cfgContextParams` method of `cv::gapi::ie::Params` to enable `PreprocesingEngine`
+    // for predefined device & context
+    //      c) use `InferenceEngine::ParamMap` to activate remote ctx in Inference Engine for given
+    // device & context
+    //
+    //
+    //// P.S. the current sample supports heterogenous pipeline construction also.
+    //// It is possible to make up mixed device approach.
+    //// Please feel free to explore different configurations!
 
-#ifdef HAVE_INF_ENGINE
+    cv::util::optional<cv::gapi::wip::onevpl::Device> gpu_accel_device;
+    cv::util::optional<cv::gapi::wip::onevpl::Context> gpu_accel_ctx;
+    cv::gapi::wip::onevpl::Device cpu_accel_device = cv::gapi::wip::onevpl::create_host_device();
+    cv::gapi::wip::onevpl::Context cpu_accel_ctx = cv::gapi::wip::onevpl::create_host_context();
+    // create GPU device if requested
+    if (is_gpu(device_id)
+        || is_gpu(source_device)
+        || is_gpu(preproc_device)) {
 #ifdef HAVE_DIRECTX
 #ifdef HAVE_D3D11
-    auto dx11_dev = createCOMPtrGuard<ID3D11Device>();
-    auto dx11_ctx = createCOMPtrGuard<ID3D11DeviceContext>();
+        // create DX11 device & context owning handles.
+        // wip::Device & wip::Context provide non-owning semantic of resources and act
+        // as weak references API wrappers in order to carry type-erased resources type
+        // into appropriate modules: onevpl::GSource, PreprocEngine and InferenceEngine
+        // Until modules are not created owner handles must stay alive
+        auto dx11_dev = createCOMPtrGuard<ID3D11Device>();
+        auto dx11_ctx = createCOMPtrGuard<ID3D11DeviceContext>();
 
-    if (device_id.find("GPU") != std::string::npos) {
         auto adapter_factory = createCOMPtrGuard<IDXGIFactory>();
         {
             IDXGIFactory* out_factory = nullptr;
@@ -365,40 +497,102 @@ int main(int argc, char *argv[]) {
         }
 
         std::tie(dx11_dev, dx11_ctx) = create_device_with_ctx(intel_adapter.get());
-        accel_device = cv::util::make_optional(
+        gpu_accel_device = cv::util::make_optional(
                             cv::gapi::wip::onevpl::create_dx11_device(
                                                         reinterpret_cast<void*>(dx11_dev.get()),
-                                                        device_id));
-        accel_ctx = cv::util::make_optional(
+                                                        "GPU"));
+        gpu_accel_ctx = cv::util::make_optional(
                             cv::gapi::wip::onevpl::create_dx11_context(
                                                         reinterpret_cast<void*>(dx11_ctx.get())));
-
-        // 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 (accel_device.has_value() &&
-        accel_device.value().get_name().find("GPU") != std::string::npos) {
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+        static const char *predefined_vaapi_devices_list[] {"/dev/dri/renderD128",
+                                                            "/dev/dri/renderD129",
+                                                            "/dev/dri/card0",
+                                                            "/dev/dri/card1",
+                                                            nullptr};
+        std::stringstream ss;
+        int device_fd = -1;
+        VADisplay va_handle = nullptr;
+        for (const char **device_path = predefined_vaapi_devices_list;
+            *device_path != nullptr; device_path++) {
+            device_fd = open(*device_path, O_RDWR);
+            if (device_fd < 0) {
+                std::string info("Cannot open GPU file: \"");
+                info = info + *device_path + "\", error: " + strerror(errno);
+                ss << info << std::endl;
+                continue;
+            }
+            va_handle = vaGetDisplayDRM(device_fd);
+            if (!va_handle) {
+                close(device_fd);
+                std::string info("VAAPI device vaGetDisplayDRM failed, error: ");
+                info += strerror(errno);
+                ss << info << std::endl;
+                continue;
+            }
+            int major_version = 0, minor_version = 0;
+            VAStatus status {};
+            status = vaInitialize(va_handle, &major_version, &minor_version);
+            if (VA_STATUS_SUCCESS != status) {
+                close(device_fd);
+                va_handle = nullptr;
+
+                std::string info("Cannot initialize VAAPI device, error: ");
+                info += vaErrorStr(status);
+                ss << info << std::endl;
+                continue;
+            }
+            std::cout << "VAAPI created for device: " << *device_path << ", version: "
+                      << major_version << "." << minor_version << std::endl;
+            break;
+        }
+
+        // check device creation
+        if (!va_handle) {
+            std::cerr << "Cannot create VAAPI device. Log:\n" << ss.str() << std::endl;
+            return -1;
+        }
+        gpu_accel_device = cv::util::make_optional(
+                            cv::gapi::wip::onevpl::create_vaapi_device(reinterpret_cast<void*>(va_handle),
+                                                                       "GPU"));
+        gpu_accel_ctx = cv::util::make_optional(
+                            cv::gapi::wip::onevpl::create_vaapi_context(nullptr));
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // #ifdef __linux__
+    }
+
+#ifdef HAVE_INF_ENGINE
+    // activate remote ctx in Inference Engine for GPU device
+    // when other pipeline component use the GPU device too
+    if (flow_settings->ie_remote_ctx_enable) {
         InferenceEngine::ParamMap ctx_config({{"CONTEXT_TYPE", "VA_SHARED"},
-                                              {"VA_DEVICE", accel_device.value().get_ptr()} });
+                                              {"VA_DEVICE", gpu_accel_device.value().get_ptr()} });
         face_net.cfgContextParams(ctx_config);
+        std::cout << "enforce InferenceEngine remote context on device: " << device_id << std::endl;
 
         // NB: consider NV12 surface because it's one of native GPU image format
         face_net.pluginConfig({{"GPU_NV12_TWO_INPUTS", "YES" }});
+        std::cout << "enforce InferenceEngine NV12 blob" << std::endl;
     }
 #endif // HAVE_INF_ENGINE
 
-    // turn on preproc
-    if (accel_device.has_value() && accel_ctx.has_value()) {
-        face_net.cfgPreprocessingParams(accel_device.value(),
-                                        accel_ctx.value());
-        std::cout << "enforce VPP preprocessing on " << device_id << std::endl;
+    // turn on VPP PreprocesingEngine if available & requested
+    if (flow_settings->vpl_preproc_enable) {
+        if (is_gpu(preproc_device)) {
+            // activate VPP PreprocesingEngine on GPU
+            face_net.cfgPreprocessingParams(gpu_accel_device.value(),
+                                            gpu_accel_ctx.value());
+        } else {
+            // activate VPP PreprocesingEngine on CPU
+            face_net.cfgPreprocessingParams(cpu_accel_device,
+                                            cpu_accel_ctx);
+        }
+        std::cout << "enforce VPP preprocessing on device: " << preproc_device << std::endl;
+    } else {
+        std::cout << "use InferenceEngine default preprocessing" << std::endl;
     }
 
     auto kernels = cv::gapi::kernels
@@ -414,10 +608,12 @@ int main(int argc, char *argv[]) {
     // Create source
     cv::gapi::wip::IStreamSource::Ptr cap;
     try {
-        if (accel_device.has_value() && accel_ctx.has_value()) {
+        if (is_gpu(source_device)) {
+            std::cout << "enforce VPL Source deconding on device: " << source_device << std::endl;
+            // use special 'Device' constructor for `onevpl::GSource`
             cap = cv::gapi::wip::make_onevpl_src(file_path, source_cfgs,
-                                                 accel_device.value(),
-                                                 accel_ctx.value());
+                                                 gpu_accel_device.value(),
+                                                 gpu_accel_ctx.value());
         } else {
             cap = cv::gapi::wip::make_onevpl_src(file_path, source_cfgs);
         }

modules/gapi/src/backends/fluid/gfluidcore_func.dispatch.cpp

@@ -6,6 +6,8 @@
 
 #if !defined(GAPI_STANDALONE)
 
+#include <opencv2/core/hal/intrin.hpp>
+#if CV_SIMD
 #include "gfluidcore_func.hpp"
 #include "gfluidcore_func.simd.hpp"
 
@@ -14,7 +16,6 @@
 #include "gfluidutils.hpp"
 
 #include <opencv2/core/cvdef.h>
-#include <opencv2/core/hal/intrin.hpp>
 
 #include <cmath>
 #include <cstdlib>
@@ -394,5 +395,5 @@ CONVERTTO_SCALED_SIMD(float, float)
 } // namespace fluid
 } // namespace gapi
 } // namespace cv
-
+#endif // CV_SIMD
 #endif // !defined(GAPI_STANDALONE)

modules/gapi/src/backends/fluid/gfluidcore_func.hpp

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#if !defined(GAPI_STANDALONE)
+#if !defined(GAPI_STANDALONE) && CV_SIMD
 
 #include <opencv2/core.hpp>
 

modules/gapi/src/backends/ie/giebackend.cpp

@@ -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,45 +704,6 @@ 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,
@@ -749,11 +711,6 @@ inline IE::Blob::Ptr extractBlob(IECallContext& ctx,
                                  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);
 }
 

modules/gapi/src/compiler/passes/exec.cpp

@@ -606,7 +606,9 @@ namespace
         MergeContext mc;
 
         bool there_was_a_merge = false;
+#ifdef DEBUG_MERGE
         std::size_t iteration = 0u;
+#endif
         do
         {
             there_was_a_merge = false;
@@ -615,8 +617,8 @@ namespace
 #ifdef DEBUG_MERGE
             GAPI_LOG_INFO(NULL, "Before next merge attempt " << iteration << "...");
             merge_debug(g, iteration);
-#endif
             iteration++;
+#endif
             auto sorted = pass_helpers::topoSort(im);
             for (auto nh : sorted)
             {

modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp

@@ -11,6 +11,7 @@
 #include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
 #include "streaming/onevpl/accelerators/surface/cpu_frame_adapter.hpp"
 #include "streaming/onevpl/accelerators/surface/surface.hpp"
+#include "streaming/onevpl/utils.hpp"
 #include "logger.hpp"
 
 #ifdef _WIN32
@@ -22,7 +23,7 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 namespace utils {
-mfxU32 GetSurfaceSize_(mfxU32 FourCC, mfxU32 width, mfxU32 height) {
+static mfxU32 GetSurfaceSize_(mfxU32 FourCC, mfxU32 width, mfxU32 height) {
     mfxU32 nbytes = 0;
 
     mfxU32 half_width = width / 2;
@@ -47,10 +48,10 @@ mfxU32 GetSurfaceSize_(mfxU32 FourCC, mfxU32 width, mfxU32 height) {
     return nbytes;
 }
 
-surface_ptr_t create_surface_RGB4_(mfxFrameInfo frameInfo,
-                                   std::shared_ptr<void> out_buf_ptr,
-                                   size_t out_buf_ptr_offset,
-                                   size_t out_buf_size)
+static surface_ptr_t create_surface_RGB4_(mfxFrameInfo frameInfo,
+                                          std::shared_ptr<void> out_buf_ptr,
+                                          size_t out_buf_ptr_offset,
+                                          size_t out_buf_size)
 {
     mfxU8* buf = reinterpret_cast<mfxU8*>(out_buf_ptr.get());
     mfxU16 surfW = frameInfo.Width * 4;
@@ -80,10 +81,10 @@ surface_ptr_t create_surface_RGB4_(mfxFrameInfo frameInfo,
     return Surface::create_surface(std::move(handle), out_buf_ptr);
 }
 
-surface_ptr_t create_surface_other_(mfxFrameInfo frameInfo,
-                                    std::shared_ptr<void> out_buf_ptr,
-                                    size_t out_buf_ptr_offset,
-                                    size_t out_buf_size)
+static surface_ptr_t create_surface_other_(mfxFrameInfo frameInfo,
+                                           std::shared_ptr<void> out_buf_ptr,
+                                           size_t out_buf_ptr_offset,
+                                           size_t out_buf_size)
 {
     mfxU8* buf = reinterpret_cast<mfxU8*>(out_buf_ptr.get());
     mfxU16 surfH = frameInfo.Height;
@@ -155,8 +156,12 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
     GAPI_LOG_DEBUG(nullptr, "page size: " << page_size_bytes << ", preallocated_raw_bytes: " << preallocated_raw_bytes);
     preallocated_pool_memory_ptr = _aligned_malloc(preallocated_raw_bytes, page_size_bytes);
 #else
-    GAPI_Assert(false && "Compatibility is not tested for systems differ than \"_WIN32\". "
-                         "Please feel free to set it up under OPENCV contribution policy");
+    int err = posix_memalign(&preallocated_pool_memory_ptr, page_size_bytes, preallocated_raw_bytes);
+    if (err) {
+        GAPI_LOG_WARNING(nullptr, "Cannot allocate aligned memory, size: " << preallocated_raw_bytes <<
+                                  ", alignment: " << page_size_bytes << ", error: " <<
+                                  strerror(err));
+    }
 #endif
 
     if (!preallocated_pool_memory_ptr) {
@@ -173,8 +178,9 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
         GAPI_LOG_INFO(nullptr, "Released workspace memory: " << ptr);
         ptr = nullptr;
 #else
-        GAPI_Assert(false && "Not implemented for systems differ than \"_WIN32\". "
-                             "Please feel free to set it up under OPENCV contribution policy");
+        GAPI_LOG_INFO(nullptr, "Workspace memory to release: " << ptr);
+        free(ptr);
+        ptr = nullptr;
 #endif
 
         });
@@ -220,10 +226,8 @@ VPLCPUAccelerationPolicy::create_surface_pool(const mfxFrameAllocRequest& alloc_
                                                       info.Width,
                                                       info.Height);
     if (!singleSurfaceSize) {
-        throw std::runtime_error("Cannot determine surface size for: fourCC: " +
-                                 std::to_string(info.FourCC) +
-                                 ", width: " + std::to_string(info.Width) +
-                                 ", height: " + std::to_string(info.Height));
+        throw std::runtime_error("Cannot determine surface size from frame: " +
+                                 mfx_frame_info_to_string(info));
     }
 
     auto surface_creator =

modules/gapi/src/streaming/onevpl/accelerators/accel_policy_dx11.cpp

@@ -13,8 +13,7 @@
 #include "streaming/onevpl/utils.hpp"
 #include "logger.hpp"
 
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
 #pragma comment(lib,"d3d11.lib")
 
 #define D3D11_NO_HELPERS
@@ -441,6 +440,52 @@ mfxStatus VPLDX11AccelerationPolicy::on_free(mfxFrameAllocResponse *response) {
 } // namespace wip
 } // namespace gapi
 } // namespace cv
-#endif // HAVE_D3D11
-#endif // HAVE_DIRECTX
+
+#else // #if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+VPLDX11AccelerationPolicy::VPLDX11AccelerationPolicy(device_selector_ptr_t selector) :
+    VPLAccelerationPolicy(selector) {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+VPLDX11AccelerationPolicy::~VPLDX11AccelerationPolicy() = default;
+
+void VPLDX11AccelerationPolicy::init(session_t ) {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+void VPLDX11AccelerationPolicy::deinit(session_t) {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+VPLDX11AccelerationPolicy::pool_key_t VPLDX11AccelerationPolicy::create_surface_pool(const mfxFrameAllocRequest&,
+                                                                                     mfxFrameInfo&) {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+VPLDX11AccelerationPolicy::surface_weak_ptr_t VPLDX11AccelerationPolicy::get_free_surface(pool_key_t) {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+size_t VPLDX11AccelerationPolicy::get_free_surface_count(pool_key_t) const {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+size_t VPLDX11AccelerationPolicy::get_surface_count(pool_key_t) const {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+
+cv::MediaFrame::AdapterPtr VPLDX11AccelerationPolicy::create_frame_adapter(pool_key_t,
+                                                                          const FrameConstructorArgs &) {
+    GAPI_Assert(false && "VPLDX11AccelerationPolicy unavailable in current configuration");
+}
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+#endif // #if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
 #endif // HAVE_ONEVPL

modules/gapi/src/streaming/onevpl/accelerators/accel_policy_dx11.hpp

@@ -15,8 +15,7 @@
 #include "streaming/onevpl/accelerators/surface/surface_pool.hpp"
 #include "streaming/onevpl/accelerators/dx11_alloc_resource.hpp"
 
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
 #define D3D11_NO_HELPERS
 #define NOMINMAX
 #include <d3d11.h>
@@ -24,7 +23,9 @@
 #include "opencv2/core/directx.hpp"
 #ifdef HAVE_OPENCL
 #include <CL/cl_d3d11.h>
-#endif
+#endif // HAVE_OPENCL
+#undef NOMINMAX
+#endif // HAVE_DIRECTX && HAVE_D3D11
 
 namespace cv {
 namespace gapi {
@@ -51,6 +52,8 @@ struct GAPI_EXPORTS VPLDX11AccelerationPolicy final: public VPLAccelerationPolic
     cv::MediaFrame::AdapterPtr create_frame_adapter(pool_key_t key,
                                                     const FrameConstructorArgs &params) override;
 private:
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
     ID3D11Device *hw_handle;
     ID3D11DeviceContext* device_context;
 
@@ -75,14 +78,13 @@ private:
     std::map<alloc_id_t, allocation_t> allocation_table;
 
     std::map<pool_key_t, pool_t> pool_table;
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
 };
 } // namespace onevpl
 } // namespace wip
 } // namespace gapi
 } // namespace cv
-#undef NOMINMAX
-#endif // HAVE_D3D11
-#endif // HAVE_DIRECTX
 
 #endif // HAVE_ONEVPL
 #endif // GAPI_STREAMING_ONEVPL_ACCELERATORS_ACCEL_POLICY_DX11_HPP

modules/gapi/src/streaming/onevpl/accelerators/accel_policy_va_api.cpp

@@ -0,0 +1,136 @@
+// 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.
+
+#ifdef HAVE_ONEVPL
+#include <cstdlib>
+#include <exception>
+#include <stdint.h>
+
+#ifdef __linux__
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#endif // __linux__
+
+#include "streaming/onevpl/accelerators/accel_policy_va_api.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
+#include "streaming/onevpl/utils.hpp"
+#include "logger.hpp"
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+#ifdef __linux__
+VPLVAAPIAccelerationPolicy::VPLVAAPIAccelerationPolicy(device_selector_ptr_t selector) :
+    VPLAccelerationPolicy(selector),
+    cpu_dispatcher(new VPLCPUAccelerationPolicy(selector)),
+    va_handle() {
+    GAPI_LOG_INFO(nullptr, "created - TODO dispatchered on CPU acceleration");
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+    // 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);
+    GAPI_LOG_INFO(nullptr, "destroyed");
+}
+
+void VPLVAAPIAccelerationPolicy::init(session_t session) {
+    GAPI_LOG_INFO(nullptr, "session: " << session);
+
+    cpu_dispatcher->init(session);
+    mfxStatus sts = MFXVideoCORE_SetHandle(session,
+                                           static_cast<mfxHandleType>(MFX_HANDLE_VA_DISPLAY),
+                                           va_handle);
+    if (sts != MFX_ERR_NONE)
+    {
+        throw std::logic_error("Cannot create VPLVAAPIAccelerationPolicy, MFXVideoCORE_SetHandle error: " +
+                               mfxstatus_to_string(sts));
+    }
+    GAPI_LOG_INFO(nullptr, "finished successfully, session: " << session);
+}
+
+void VPLVAAPIAccelerationPolicy::deinit(session_t session) {
+    GAPI_LOG_INFO(nullptr, "session: " << session);
+}
+
+VPLVAAPIAccelerationPolicy::pool_key_t
+VPLVAAPIAccelerationPolicy::create_surface_pool(const mfxFrameAllocRequest& alloc_request, mfxFrameInfo& info) {
+
+    return cpu_dispatcher->create_surface_pool(alloc_request, info);
+}
+
+VPLVAAPIAccelerationPolicy::surface_weak_ptr_t VPLVAAPIAccelerationPolicy::get_free_surface(pool_key_t key) {
+    return cpu_dispatcher->get_free_surface(key);
+}
+
+size_t VPLVAAPIAccelerationPolicy::get_free_surface_count(pool_key_t key) const {
+    return cpu_dispatcher->get_free_surface_count(key);
+}
+
+size_t VPLVAAPIAccelerationPolicy::get_surface_count(pool_key_t key) const {
+    return cpu_dispatcher->get_surface_count(key);
+}
+
+cv::MediaFrame::AdapterPtr VPLVAAPIAccelerationPolicy::create_frame_adapter(pool_key_t key,
+                                                                          const FrameConstructorArgs &params) {
+    return cpu_dispatcher->create_frame_adapter(key, params);
+}
+
+#else // __linux__
+
+VPLVAAPIAccelerationPolicy::VPLVAAPIAccelerationPolicy(device_selector_ptr_t selector) :
+    VPLAccelerationPolicy(selector) {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+VPLVAAPIAccelerationPolicy::~VPLVAAPIAccelerationPolicy() = default;
+
+void VPLVAAPIAccelerationPolicy::init(session_t ) {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+void VPLVAAPIAccelerationPolicy::deinit(session_t) {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+VPLVAAPIAccelerationPolicy::pool_key_t VPLVAAPIAccelerationPolicy::create_surface_pool(const mfxFrameAllocRequest&,
+                                                                                     mfxFrameInfo&) {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+VPLVAAPIAccelerationPolicy::surface_weak_ptr_t VPLVAAPIAccelerationPolicy::get_free_surface(pool_key_t) {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+size_t VPLVAAPIAccelerationPolicy::get_free_surface_count(pool_key_t) const {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+size_t VPLVAAPIAccelerationPolicy::get_surface_count(pool_key_t) const {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+
+cv::MediaFrame::AdapterPtr VPLVAAPIAccelerationPolicy::create_frame_adapter(pool_key_t,
+                                                                          const FrameConstructorArgs &) {
+    GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current configuration");
+}
+#endif // __linux__
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+#endif // HAVE_ONEVPL

modules/gapi/src/streaming/onevpl/accelerators/accel_policy_va_api.hpp

@@ -0,0 +1,61 @@
+// 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.
+
+#ifndef GAPI_STREAMING_ONEVPL_ACCELERATORS_ACCEL_POLICY_VA_API_HPP
+#define GAPI_STREAMING_ONEVPL_ACCELERATORS_ACCEL_POLICY_VA_API_HPP
+
+#include <map>
+#include <vector>
+
+#include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS
+
+#ifdef HAVE_ONEVPL
+#include "streaming/onevpl/accelerators/accel_policy_interface.hpp"
+#include "streaming/onevpl/accelerators/surface/surface_pool.hpp"
+
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#include "va/va.h"
+#include "va/va_drm.h"
+#else
+    typedef void* VADisplay;
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // __linux__
+
+namespace cv {
+namespace gapi {
+namespace wip {
+namespace onevpl {
+
+// GAPI_EXPORTS for tests
+struct GAPI_EXPORTS VPLVAAPIAccelerationPolicy final : public VPLAccelerationPolicy
+{
+    VPLVAAPIAccelerationPolicy(device_selector_ptr_t selector);
+    ~VPLVAAPIAccelerationPolicy();
+
+    using pool_t = CachedPool;
+
+    void init(session_t session) override;
+    void deinit(session_t session) override;
+    pool_key_t create_surface_pool(const mfxFrameAllocRequest& alloc_request, mfxFrameInfo& info) override;
+    surface_weak_ptr_t get_free_surface(pool_key_t key) override;
+    size_t get_free_surface_count(pool_key_t key) const override;
+    size_t get_surface_count(pool_key_t key) const override;
+
+    cv::MediaFrame::AdapterPtr create_frame_adapter(pool_key_t key,
+                                                    const FrameConstructorArgs& args) override;
+
+private:
+    std::unique_ptr<VPLAccelerationPolicy> cpu_dispatcher;
+#ifdef __linux__
+    VADisplay va_handle;
+#endif // __linux__
+};
+} // namespace onevpl
+} // namespace wip
+} // namespace gapi
+} // namespace cv
+
+#endif // HAVE_ONEVPL
+#endif // GAPI_STREAMING_ONEVPL_ACCELERATORS_ACCEL_POLICY_VA_API_HPP

modules/gapi/src/streaming/onevpl/accelerators/dx11_alloc_resource.cpp

@@ -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,6 +261,7 @@ 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);
@@ -264,8 +269,8 @@ mfxStatus DX11AllocationItem::shared_access_acquire_unsafe(mfxFrameData *ptr) {
 }
 
 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);

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

@@ -59,7 +59,7 @@ std::shared_ptr<Surface> BaseFrameAdapter::surface() {
     return parent_surface_ptr;
 }
 
-const BaseFrameAdapter::SessionHandle BaseFrameAdapter::get_session_handle() const {
+BaseFrameAdapter::SessionHandle BaseFrameAdapter::get_session_handle() const {
     return parent_handle;
 }
 

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

@@ -23,7 +23,7 @@ public:
     using SessionHandle = mfxSession;
 
     const std::shared_ptr<Surface>& get_surface() const;
-    const SessionHandle get_session_handle() const;
+    SessionHandle get_session_handle() const;
 
     cv::GFrameDesc meta() const override;
     AccelType accel_type() const;

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

@@ -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 {};
 }
 

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

@@ -12,6 +12,8 @@
 #ifdef HAVE_ONEVPL
 #include "streaming/onevpl/onevpl_export.hpp"
 
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
 #ifdef HAVE_INF_ENGINE
 // For IE classes (ParamMap, etc)
 #include <inference_engine.hpp>
@@ -202,4 +204,6 @@ DXGI_FORMAT VPLMediaFrameDX11Adapter::get_dx11_color_format(uint32_t mfx_fourcc)
 } // namespace wip
 } // namespace gapi
 } // namespace cv
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
 #endif // HAVE_ONEVPL

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

@@ -4,6 +4,7 @@
 //
 // Copyright (C) 2021 Intel Corporation
 
+#include <opencv2/gapi/own/assert.hpp>
 #include "streaming/onevpl/accelerators/surface/surface.hpp"
 #include "logger.hpp"
 
@@ -20,12 +21,12 @@ Surface::Surface(std::unique_ptr<handle_t>&& surf, std::shared_ptr<void> associa
     mirrored_locked_count() {
 
     GAPI_Assert(mfx_surface && "Surface is nullptr");
-    GAPI_LOG_DEBUG(nullptr, "create surface: " << mfx_surface <<
+    GAPI_LOG_DEBUG(nullptr, "create surface: " << get_handle() <<
                             ", locked count: " << mfx_surface->Data.Locked);
 }
 
 Surface::~Surface() {
-    GAPI_LOG_DEBUG(nullptr, "destroy surface: " << mfx_surface <<
+    GAPI_LOG_DEBUG(nullptr, "destroy surface: " << get_handle() <<
                             ", worspace memory counter: " <<
                             workspace_memory_ptr.use_count());
 }
@@ -60,7 +61,7 @@ size_t Surface::get_locks_count() const {
 
 size_t Surface::obtain_lock() {
     size_t locked_count = mirrored_locked_count.fetch_add(1);
-    GAPI_LOG_DEBUG(nullptr, "surface: " << mfx_surface.get() <<
+    GAPI_LOG_DEBUG(nullptr, "surface: " << get_handle() <<
                             ", locked times: " << locked_count + 1);
     return locked_count; // return preceding value
 }
@@ -68,7 +69,7 @@ size_t Surface::obtain_lock() {
 size_t Surface::release_lock() {
     size_t locked_count = mirrored_locked_count.fetch_sub(1);
     GAPI_Assert(locked_count && "Surface lock counter is invalid");
-    GAPI_LOG_DEBUG(nullptr, "surface: " << mfx_surface.get() <<
+    GAPI_LOG_DEBUG(nullptr, "surface: " << get_handle() <<
                             ", locked times: " << locked_count - 1);
     return locked_count; // return preceding value
 }

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

@@ -1,3 +1,4 @@
+#include <opencv2/gapi/own/assert.hpp>
 #include "streaming/onevpl/accelerators/surface/surface_pool.hpp"
 #include "streaming/onevpl/accelerators/surface/surface.hpp"
 #include "logger.hpp"

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

@@ -9,6 +9,7 @@
 #include <opencv2/gapi/own/assert.hpp>
 #include <opencv2/gapi/util/variant.hpp>
 
+#include <opencv2/gapi/streaming/onevpl/device_selector_interface.hpp>
 #include "streaming/onevpl/cfg_param_device_selector.hpp"
 #include "streaming/onevpl/cfg_params_parser.hpp"
 #include "streaming/onevpl/utils.hpp"
@@ -26,25 +27,54 @@
 #pragma comment(lib, "dxgi")
 #undef D3D11_NO_HELPERS
 #undef NOMINMAX
+#endif // HAVE_D3D11
+#endif // HAVE_DIRECTX
+
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#include "va/va.h"
+#include "va/va_drm.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // __linux__
 
 #include <codecvt>
 #include "opencv2/core/directx.hpp"
-#ifdef HAVE_OPENCL
-#include <CL/cl_d3d11.h>
-#endif
 
 namespace cv {
 namespace gapi {
 namespace wip {
 namespace onevpl {
+#ifdef __linux__
+struct PlatformSpecificParams {
+    ~PlatformSpecificParams() {
+        for (int fd : fds) {
+            close(fd);
+        }
+    }
 
-std::vector<CfgParam> insertCfgparam(std::vector<CfgParam> &&param_array, AccelType type) {
+    void track_fd(int fd) {
+        fds.insert(fd);
+    }
+private:
+    std::set<int> fds;
+};
+#else
+struct PlatformSpecificParams {};
+#endif
+
+std::vector<CfgParam> update_param_with_accel_type(std::vector<CfgParam> &&param_array, AccelType type) {
     switch (type) {
         case AccelType::HOST:
             break;
         case AccelType::DX11:
             param_array.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_D3D11));
             break;
+        case AccelType::VAAPI:
+            param_array.push_back(CfgParam::create_acceleration_mode(MFX_IMPL_VIA_VAAPI));
+            break;
         default:
             GAPI_DbgAssert(false && "Unexpected AccelType");
             break;
@@ -71,8 +101,7 @@ CfgParamDeviceSelector::CfgParamDeviceSelector(const CfgParams& cfg_params) :
 
     switch(accel_mode.Data.U32) {
         case MFX_ACCEL_MODE_VIA_D3D11: {
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             ID3D11Device *hw_handle = nullptr;
             ID3D11DeviceContext* device_context = nullptr;
 
@@ -141,14 +170,88 @@ CfgParamDeviceSelector::CfgParamDeviceSelector(const CfgParams& cfg_params) :
 
             suggested_device = IDeviceSelector::create<Device>(hw_handle, "GPU", AccelType::DX11);
             suggested_context = IDeviceSelector::create<Context>(device_context, AccelType::DX11);
-#else
+#else  // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             GAPI_LOG_WARNING(nullptr, "Unavailable \"" <<  CfgParam::acceleration_mode_name() << ": MFX_ACCEL_MODE_VIA_D3D11\""
                                       "was chosen for current project configuration");
             throw std::logic_error(std::string("Unsupported \"") +
                                    CfgParam::acceleration_mode_name() +
                                    ": MFX_ACCEL_MODE_VIA_D3D11\"");
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
+#endif // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
+            break;
+        }
+        case MFX_IMPL_VIA_VAAPI : {
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+            static const char *predefined_vaapi_devices_list[] {"/dev/dri/renderD128",
+                                                                "/dev/dri/renderD129",
+                                                                "/dev/dri/card0",
+                                                                "/dev/dri/card1",
+                                                                nullptr};
+            std::stringstream ss;
+            int device_fd = -1;
+            VADisplay va_handle;va_handle = nullptr;
+            for (const char **device_path = predefined_vaapi_devices_list;
+                *device_path != nullptr; device_path++) {
+                device_fd = open(*device_path, O_RDWR);
+                if (device_fd < 0) {
+                    std::string info("Cannot open GPU file: \"");
+                    info = info + *device_path + "\", error: " + strerror(errno);
+                    GAPI_LOG_DEBUG(nullptr, info);
+                    ss << info << std::endl;
+                    continue;
+                }
+                va_handle = vaGetDisplayDRM(device_fd);
+                if (!va_handle) {
+                    close(device_fd);
+
+                    std::string info("VAAPI device vaGetDisplayDRM failed, error: ");
+                    info += strerror(errno);
+                    GAPI_LOG_DEBUG(nullptr, info);
+                    ss << info << std::endl;
+                    continue;
+                }
+                int major_version = 0, minor_version = 0;
+                VAStatus status {};
+                status = vaInitialize(va_handle, &major_version, &minor_version);
+                if (VA_STATUS_SUCCESS != status) {
+                    close(device_fd);
+                    va_handle = nullptr;
+
+                    std::string info("Cannot initialize VAAPI device, error: ");
+                    info += vaErrorStr(status);
+                    GAPI_LOG_DEBUG(nullptr, info);
+                    ss << info << std::endl;
+                    continue;
+                }
+                GAPI_LOG_INFO(nullptr, "VAAPI created for device: " << *device_path);
+                break;
+            }
+
+            // check device creation
+            if (!va_handle) {
+                GAPI_LOG_WARNING(nullptr, "Cannot create VAAPI device. Log:\n" << ss.str());
+                throw std::logic_error(std::string("Cannot create device for \"") +
+                                   CfgParam::acceleration_mode_name() +
+                                   ": MFX_IMPL_VIA_VAAPI\"");
+            }
+
+            // Unfortunately VAAPI doesn't provide API for extracting initial FD value from VADisplay, which
+            // value is stored as VADisplay fields, by the way. But, because we here are only one creator
+            // of VAAPI device then we will need make cleanup for all allocated resources by ourselfs
+            //and FD is definitely must be utilized. So, let's use complementary struct `PlatformSpecificParams` which
+            // represent some kind of 'platform specific data' and which will store opened FD for
+            // future utilization
+            platform_specific_data.reset (new PlatformSpecificParams);
+            platform_specific_data->track_fd(device_fd);
+
+            suggested_device = IDeviceSelector::create<Device>(va_handle, "GPU", AccelType::VAAPI);
+            suggested_context = IDeviceSelector::create<Context>(nullptr, AccelType::VAAPI);
+#else  // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+            GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current linux configuration");
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#else // #ifdef __linux__
+            GAPI_Assert(false && "MFX_IMPL_VIA_VAAPI is supported on linux only");
+#endif // #ifdef __linux__
             break;
         }
         case MFX_ACCEL_MODE_NA: {
@@ -198,10 +301,10 @@ CfgParamDeviceSelector::CfgParamDeviceSelector(Device::Ptr device_ptr,
     }
     mfxVariant accel_mode = cfg_param_to_mfx_variant(*accel_mode_it);
 
+    cv::util::suppress_unused_warning(device_id);
     switch(accel_mode.Data.U32) {
         case MFX_ACCEL_MODE_VIA_D3D11: {
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             suggested_device = IDeviceSelector::create<Device>(device_ptr, device_id, AccelType::DX11);
             ID3D11Device* dx_device_ptr =
                 reinterpret_cast<ID3D11Device*>(suggested_device.get_ptr());
@@ -220,14 +323,26 @@ CfgParamDeviceSelector::CfgParamDeviceSelector(Device::Ptr device_ptr,
             }
 
             dx_ctx_ptr->AddRef();
-#else
+#else  // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             GAPI_LOG_WARNING(nullptr, "Unavailable \"" <<  CfgParam::acceleration_mode_name() <<
                                       ": MFX_ACCEL_MODE_VIA_D3D11\""
                                       "was chosen for current project configuration");
             throw std::logic_error(std::string("Unsupported \"") +
                                    CfgParam::acceleration_mode_name() + ": MFX_ACCEL_MODE_VIA_D3D11\"");
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
+#endif // #if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
+            break;
+        }
+        case MFX_IMPL_VIA_VAAPI : {
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+            suggested_device = IDeviceSelector::create<Device>(device_ptr, device_id, AccelType::VAAPI);
+            suggested_context = IDeviceSelector::create<Context>(nullptr, AccelType::VAAPI);
+#else  // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+            GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current linux configuration");
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#else // #ifdef __linux__
+            GAPI_Assert(false && "MFX_IMPL_VIA_VAAPI is supported on linux only");
+#endif // #ifdef __linux__
             break;
         }
         case MFX_ACCEL_MODE_NA: {
@@ -253,8 +368,7 @@ CfgParamDeviceSelector::CfgParamDeviceSelector(const Device &device,
 
     switch(device.get_type()) {
         case AccelType::DX11: {
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             ID3D11Device* dx_device_ptr =
                 reinterpret_cast<ID3D11Device*>(suggested_device.get_ptr());
             dx_device_ptr->AddRef();
@@ -272,15 +386,23 @@ CfgParamDeviceSelector::CfgParamDeviceSelector(const Device &device,
 
             dx_ctx_ptr->AddRef();
             break;
-#else
+#else // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             GAPI_LOG_WARNING(nullptr, "Unavailable \"" <<  CfgParam::acceleration_mode_name() <<
                                       ": MFX_ACCEL_MODE_VIA_D3D11\""
                                       "was chosen for current project configuration");
             throw std::logic_error(std::string("Unsupported \"") +
                                    CfgParam::acceleration_mode_name() + ": MFX_ACCEL_MODE_VIA_D3D11\"");
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
+#endif // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
         }
+        case AccelType::VAAPI:
+#ifdef __linux__
+#if !defined(HAVE_VA) || !defined(HAVE_VA_INTEL)
+            GAPI_Assert(false && "VPLVAAPIAccelerationPolicy unavailable in current linux configuration");
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#else // #ifdef __linux__
+            GAPI_Assert(false && "MFX_IMPL_VIA_VAAPI is supported on linux only");
+#endif // #ifdef __linux__
+            break;
         case AccelType::HOST:
             break;
         default:
@@ -299,14 +421,12 @@ CfgParamDeviceSelector::~CfgParamDeviceSelector() {
             //nothing to do
             break;
         case AccelType::DX11: {
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             ID3D11DeviceContext* device_ctx_ptr =
                 reinterpret_cast<ID3D11DeviceContext*>(suggested_context.get_ptr());
             device_ctx_ptr->Release();
             device_ctx_ptr = nullptr;
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
+#endif // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             break;
         }
         default:
@@ -322,22 +442,29 @@ CfgParamDeviceSelector::~CfgParamDeviceSelector() {
             //nothing to do
             break;
         case AccelType::DX11: {
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             ID3D11Device* device_ptr = reinterpret_cast<ID3D11Device*>(suggested_device.get_ptr());
             device_ptr->Release();
             device_ptr = nullptr;
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
+#endif // defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
             break;
         }
+        case AccelType::VAAPI: {
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+            VADisplay va_handle = reinterpret_cast<VADisplay>(suggested_device.get_ptr());
+            vaTerminate(va_handle);
+            platform_specific_data.reset();
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // #ifdef __linux__
+        }
         default:
             break;
     }
 }
 
 CfgParamDeviceSelector::DeviceScoreTable CfgParamDeviceSelector::select_devices() const {
-    return {std::make_pair(Score::MaxActivePriority, suggested_device)};
+    return {std::make_pair(Score::Type(Score::MaxActivePriority), suggested_device)};
 }
 
 CfgParamDeviceSelector::DeviceContexts CfgParamDeviceSelector::select_context() {
@@ -348,6 +475,4 @@ CfgParamDeviceSelector::DeviceContexts CfgParamDeviceSelector::select_context()
 } // namespace wip
 } // namespace gapi
 } // namespace cv
-#endif // HAVE_D3D11
-#endif // HAVE_DIRECTX
 #endif // HAVE_ONEVPL

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

@@ -20,6 +20,9 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 
+class PlatformSpecificParams;
+std::vector<CfgParam> update_param_with_accel_type(std::vector<CfgParam> &&param_array, AccelType type);
+
 struct GAPI_EXPORTS CfgParamDeviceSelector final: public IDeviceSelector {
     CfgParamDeviceSelector(const CfgParams& params = {});
     CfgParamDeviceSelector(Device::Ptr device_ptr,
@@ -37,6 +40,7 @@ struct GAPI_EXPORTS CfgParamDeviceSelector final: public IDeviceSelector {
 private:
     Device suggested_device;
     Context suggested_context;
+    std::unique_ptr<PlatformSpecificParams> platform_specific_data;
 };
 } // namespace onevpl
 } // namespace wip

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

@@ -4,6 +4,7 @@
 //
 // Copyright (C) 2021 Intel Corporation
 
+#include <sstream>
 #include <opencv2/gapi/util/throw.hpp>
 
 #include <opencv2/gapi/streaming/onevpl/cfg_params.hpp>
@@ -25,6 +26,15 @@ struct variant_comparator : cv::util::static_visitor<bool, variant_comparator> {
 private:
     const CfgParam::value_t& rhs;
 };
+
+struct variant_stringifier : cv::util::static_visitor<std::string, variant_stringifier> {
+    template<typename ValueType>
+    std::string visit(const ValueType& lhs) const {
+        std::stringstream ss;
+        ss << lhs;
+        return ss.str();
+    }
+};
 } // namespace util
 
 struct CfgParam::Priv {
@@ -228,6 +238,11 @@ bool CfgParam::is_major() const {
     return m_priv->is_major_impl();
 }
 
+std::string CfgParam::to_string() const {
+    return get_name() + ":" + cv::util::visit(util::variant_stringifier{},
+                                              get_value());
+}
+
 bool CfgParam::operator< (const CfgParam& rhs) const {
     return *m_priv < *rhs.m_priv;
 }

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

@@ -87,15 +87,15 @@ std::vector<ValueType> get_params_from_string(const std::string& str) {
 
         ParamCreator<ValueType> creator;
         if (name == CfgParam::implementation_name()) {
-            ret.push_back(creator.create<mfxU32>(name, cstr_to_mfx_impl(value.c_str())));
+            ret.push_back(creator.template create<mfxU32>(name, cstr_to_mfx_impl(value.c_str())));
         } else if (name == CfgParam::decoder_id_name()) {
-            ret.push_back(creator.create<mfxU32>(name, cstr_to_mfx_codec_id(value.c_str())));
+            ret.push_back(creator.template create<mfxU32>(name, cstr_to_mfx_codec_id(value.c_str())));
         } else if (name == CfgParam::acceleration_mode_name()) {
-            ret.push_back(creator.create<mfxU32>(name, cstr_to_mfx_accel_mode(value.c_str())));
+            ret.push_back(creator.template create<mfxU32>(name, cstr_to_mfx_accel_mode(value.c_str())));
         } else if (name == "mfxImplDescription.ApiVersion.Version") {
-            ret.push_back(creator.create<mfxU32>(name, cstr_to_mfx_version(value.c_str())));
+            ret.push_back(creator.template create<mfxU32>(name, cstr_to_mfx_version(value.c_str())));
         } else if ((name == CfgParam::frames_pool_size_name()) || (name == CfgParam::vpp_frames_pool_size_name())) {
-            ret.push_back(creator.create(name, strtoull_or_throw(value.c_str()), false));
+            ret.push_back(creator.create(name, static_cast<mfxU32>(strtoull_or_throw(value.c_str()), false)));
         } else if ((name == CfgParam::vpp_in_width_name()) || (name == CfgParam::vpp_in_height_name()) ||
                    (name == CfgParam::vpp_in_crop_w_name()) || (name == CfgParam::vpp_in_crop_h_name()) ||
                    (name == CfgParam::vpp_in_crop_x_name()) || (name == CfgParam::vpp_in_crop_y_name()) ||
@@ -186,7 +186,7 @@ unsigned long strtoul_or_throw(const char* str) {
     errno = 0;
     unsigned long ret = strtoul(str, &end_ptr, 10);
     if ((end_ptr == str) ||
-        ((ret == ULONG_MAX || ret == LONG_MIN) && errno == ERANGE)) {
+        ((ret == ULONG_MAX) && errno == ERANGE)) {
             // nothing parsed from the string, handle errors or exit
         GAPI_LOG_WARNING(nullptr, "strtoul failed for: " << str);
         GAPI_Assert(false && "strtoul_or_throw");
@@ -199,7 +199,7 @@ size_t strtoull_or_throw(const char* str) {
     errno = 0;
     size_t ret = strtoull(str, &end_ptr, 10);
     if ((end_ptr == str) ||
-        ((ret == LONG_MAX || ret == LONG_MIN) && errno == ERANGE)) {
+        ((ret == ULLONG_MAX) && errno == ERANGE)) {
             // nothing parsed from the string, handle errors or exit
         GAPI_LOG_WARNING(nullptr, "strtoull failed for: " << str);
         GAPI_Assert(false && "strtoull_or_throw");

modules/gapi/src/streaming/onevpl/demux/async_mfp_demux_data_provider.cpp

@@ -14,6 +14,7 @@
 #pragma comment(lib, "mfreadwrite.lib")
 #endif // _WIN32
 
+#include <opencv2/gapi/own/assert.hpp>
 #include "streaming/onevpl/demux/async_mfp_demux_data_provider.hpp"
 #include "logger.hpp"
 
@@ -807,7 +808,7 @@ bool MFPAsyncDemuxDataProvider::fetch_bitstream_data(std::shared_ptr<mfx_bitstre
     return false;
 }
 
-bool MFPAsyncDemuxDataProvider::empty() const override {
+bool MFPAsyncDemuxDataProvider::empty() const {
     GAPI_Assert(false && "Unsupported: Microsoft Media Foundation is not available");
     return true;
 }

modules/gapi/src/streaming/onevpl/demux/async_mfp_demux_data_provider.hpp

@@ -14,6 +14,7 @@
 
 #ifdef HAVE_ONEVPL
 #include "streaming/onevpl/onevpl_export.hpp"
+#include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
 
 #ifdef _WIN32
 #define NOMINMAX
@@ -28,7 +29,6 @@
 #include <wmcodecdsp.h>
 #undef NOMINMAX
 
-#include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
 #include "streaming/onevpl/data_provider_defines.hpp"
 #include "streaming/onevpl/utils.hpp"
 

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

@@ -20,6 +20,8 @@ const char* to_cstring(AccelType type) {
             return "HOST";
         case AccelType::DX11:
             return "DX11";
+        case AccelType::VAAPI:
+            return "VAAPI";
         default:
             GAPI_DbgAssert(false && "Unexpected AccelType");
             break;
@@ -117,6 +119,18 @@ Context create_dx11_context(Context::Ptr ctx_ptr) {
                                                                 AccelType::DX11);
 }
 
+Device create_vaapi_device(Device::Ptr device_ptr,
+                           const std::string& device_name) {
+    return detail::DeviceContextCreator::create_entity<Device>(device_ptr,
+                                                               device_name,
+                                                               AccelType::VAAPI);
+}
+
+Context create_vaapi_context(Context::Ptr ctx_ptr) {
+    return detail::DeviceContextCreator::create_entity<Context>(ctx_ptr,
+                                                                AccelType::VAAPI);
+}
+
 } // namespace onevpl
 } // namespace wip
 } // namespace gapi

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

@@ -175,6 +175,7 @@ VPLLegacyDecodeEngine::SessionParam VPLLegacyDecodeEngine::prepare_session_param
 
     // Prepare video param
     mfxVideoParam mfxDecParams {};
+    memset(&mfxDecParams, 0, sizeof(mfxDecParams));
     mfxDecParams.mfx.CodecId = decoder_id_name;
 
     // set memory stream direction according to acceleration policy device type
@@ -185,6 +186,9 @@ VPLLegacyDecodeEngine::SessionParam VPLLegacyDecodeEngine::prepare_session_param
         mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
     } else if (accel_type == AccelType::HOST) {
         mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
+    } else if (accel_type == AccelType::VAAPI) {
+        // TODO make proper direction
+        mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
     } else {
         GAPI_Assert(false && "unsupported AccelType from device selector");
     }
@@ -253,7 +257,8 @@ VPLLegacyDecodeEngine::SessionParam VPLLegacyDecodeEngine::prepare_session_param
 
     // Input parameters finished, now initialize decode
     // create decoder for session according to header recovered from source file
-
+    GAPI_LOG_INFO(nullptr, "Initialize decoder for session: " << mfx_session <<
+                           ", frame info: " << mfx_frame_info_to_string(mfxDecParams.mfx.FrameInfo));
     sts = MFXVideoDECODE_Init(mfx_session, &mfxDecParams);
     if (MFX_ERR_NONE != sts) {
         throw std::runtime_error("Error initializing Decode, error: " +

modules/gapi/src/streaming/onevpl/engine/decode/decode_session.hpp

@@ -21,6 +21,9 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 class Surface;
+struct VPLAccelerationPolicy;
+class VPLLegacyDecodeEngine;
+
 class GAPI_EXPORTS LegacyDecodeSession : public EngineSession {
 public:
     friend class VPLLegacyDecodeEngine;

modules/gapi/src/streaming/onevpl/engine/engine_session.hpp

@@ -14,6 +14,7 @@
 #include <utility>
 #include <vector>
 
+#include "opencv2/gapi/util/optional.hpp"
 #include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS
 #include <opencv2/gapi/streaming/onevpl/data_provider_interface.hpp>
 #include "streaming/onevpl/data_provider_defines.hpp"
@@ -31,7 +32,7 @@ namespace onevpl {
 struct GAPI_EXPORTS DecoderParams {
     std::shared_ptr<IDataProvider::mfx_bitstream> stream;
     mfxVideoParam param;
-    cv::optional<size_t> preallocated_frames_count;
+    cv::util::optional<size_t> preallocated_frames_count;
 };
 
 struct GAPI_EXPORTS TranscoderParams {

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

@@ -34,8 +34,8 @@ bool FrameInfoComparator::equal_to(const mfxFrameInfo& lhs, const mfxFrameInfo&
     return lhs == rhs;
 }
 
-void apply_roi(mfxFrameSurface1* surface_handle,
-               const cv::util::optional<cv::Rect> &opt_roi) {
+static void apply_roi(mfxFrameSurface1* surface_handle,
+                      const cv::util::optional<cv::Rect> &opt_roi) {
     if (opt_roi.has_value()) {
         const cv::Rect &roi = opt_roi.value();
         surface_handle->Info.CropX = static_cast<mfxU16>(roi.x);
@@ -176,7 +176,8 @@ pp_session VPPPreprocEngine::initialize_preproc(const pp_params& initial_frame_p
     const vpp_pp_params &params = initial_frame_param.get<vpp_pp_params>();
 
     // adjust preprocessing settings
-    mfxVideoParam mfxVPPParams{0};
+    mfxVideoParam mfxVPPParams{};
+    memset(&mfxVPPParams, 0, sizeof(mfxVideoParam));
     // NB: IN params for VPP session must be equal to decoded surface params
     mfxVPPParams.vpp.In = params.info;
 

modules/gapi/src/streaming/onevpl/engine/preproc/vpp_preproc_defines.hpp

@@ -16,12 +16,18 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 struct vpp_pp_params {
+    vpp_pp_params() : handle(), info(), reserved() {}
+    vpp_pp_params(mfxSession s, mfxFrameInfo i, void *r = nullptr) :
+        handle(s), info(i), reserved(r) {}
     mfxSession handle;
     mfxFrameInfo info;
     void *reserved = nullptr;
 };
 
 struct vpp_pp_session {
+    vpp_pp_session() : handle(), reserved() {}
+    vpp_pp_session(std::shared_ptr<EngineSession> h, void *r = nullptr) :
+        handle(h), reserved(r) {}
     std::shared_ptr<EngineSession> handle;
     void *reserved = nullptr;
 };

modules/gapi/src/streaming/onevpl/engine/preproc_engine_interface.cpp

@@ -14,6 +14,7 @@
 
 #include "streaming/onevpl/accelerators/accel_policy_dx11.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_va_api.hpp"
 #include "streaming/onevpl/accelerators/surface/surface.hpp"
 #include "streaming/onevpl/cfg_param_device_selector.hpp"
 #include "streaming/onevpl/cfg_params_parser.hpp"
@@ -41,30 +42,56 @@ IPreprocEngine::create_preproc_engine_impl(const onevpl::Device &device,
     cv::util::suppress_unused_warning(context);
     std::unique_ptr<VPPPreprocDispatcher> dispatcher(new VPPPreprocDispatcher);
 #ifdef HAVE_ONEVPL
-    if (device.get_type() == onevpl::AccelType::DX11) {
-        bool gpu_pp_is_created = false;
+    bool pp_is_created = false;
+    switch (device.get_type()) {
+        case onevpl::AccelType::DX11: {
+            GAPI_LOG_INFO(nullptr, "Creating DX11 VPP preprocessing engine");
 #ifdef HAVE_DIRECTX
 #ifdef HAVE_D3D11
-        GAPI_LOG_INFO(nullptr, "Creating DX11 VPP preprocessing engine");
-        // create GPU VPP preproc engine
-        dispatcher->insert_worker<VPPPreprocEngine>(
+            // create GPU VPP preproc engine
+            dispatcher->insert_worker<VPPPreprocEngine>(
                                 std::unique_ptr<VPLAccelerationPolicy>{
                                         new VPLDX11AccelerationPolicy(
                                             std::make_shared<CfgParamDeviceSelector>(
                                                     device, context, CfgParams{}))
                                 });
-        GAPI_LOG_INFO(nullptr, "DX11 VPP preprocessing engine created");
-        gpu_pp_is_created = true;
+            GAPI_LOG_INFO(nullptr, "DX11 VPP preprocessing engine created");
+            pp_is_created = true;
 #endif
 #endif
-        GAPI_Assert(gpu_pp_is_created && "VPP preproc for GPU is requested, but it is avaiable only for DX11 at now");
-    } else {
-        GAPI_LOG_INFO(nullptr, "Creating CPU VPP preprocessing engine");
-        dispatcher->insert_worker<VPPPreprocEngine>(
+            break;
+        }
+        case onevpl::AccelType::VAAPI: {
+            GAPI_LOG_INFO(nullptr, "Creating VAAPI VPP preprocessing engine");
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+            // create GPU VPP preproc engine
+            dispatcher->insert_worker<VPPPreprocEngine>(
+                                std::unique_ptr<VPLAccelerationPolicy>{
+                                        new VPLVAAPIAccelerationPolicy(
+                                            std::make_shared<CfgParamDeviceSelector>(
+                                                    device, context, CfgParams{}))
+                                });
+            GAPI_LOG_INFO(nullptr, "VAAPI VPP preprocessing engine created");
+            pp_is_created = true;
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // #ifdef __linux__
+            break;
+        }
+        default: {
+            GAPI_LOG_INFO(nullptr, "Creating CPU VPP preprocessing engine");
+            dispatcher->insert_worker<VPPPreprocEngine>(
                         std::unique_ptr<VPLAccelerationPolicy>{
                                 new VPLCPUAccelerationPolicy(
                                     std::make_shared<CfgParamDeviceSelector>(CfgParams{}))});
-        GAPI_LOG_INFO(nullptr, "CPU VPP preprocessing engine created");
+            GAPI_LOG_INFO(nullptr, "CPU VPP preprocessing engine created");
+            pp_is_created = true;
+            break;
+        }
+    }
+    if (!pp_is_created) {
+        GAPI_LOG_WARNING(nullptr, "Cannot create VPP preprocessing engine: configuration unsupported");
+        GAPI_Assert(false && "VPP preproc unsupported");
     }
 #endif // HAVE_ONEVPL
     return dispatcher;

modules/gapi/src/streaming/onevpl/engine/processing_engine_base.hpp

@@ -9,6 +9,7 @@
 
 #include <queue>
 #include <opencv2/gapi/streaming/onevpl/cfg_params.hpp>
+#include <opencv2/gapi/garg.hpp>
 #include "streaming/onevpl/engine/engine_session.hpp"
 #include "opencv2/gapi/own/exports.hpp" // GAPI_EXPORTS
 

modules/gapi/src/streaming/onevpl/engine/transcode/transcode_engine_legacy.cpp

@@ -269,7 +269,8 @@ VPLLegacyTranscodeEngine::initialize_session(mfxSession mfx_session,
     const auto& mfxDecParams = decode_params.decoder_params.param;
 
     // NB: create transcode params: Out = In by default, In = initially decoded
-    mfxVideoParam mfxVPPParams{0};
+    mfxVideoParam mfxVPPParams{};
+    memset(&mfxVPPParams, 0, sizeof(mfxVPPParams));
     mfxVPPParams.vpp.In = mfxDecParams.mfx.FrameInfo;
     mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
 
@@ -366,6 +367,8 @@ VPLLegacyTranscodeEngine::initialize_session(mfxSession mfx_session,
     VPLAccelerationPolicy::pool_key_t vpp_out_pool_key =
                 acceleration_policy->create_surface_pool(vppRequests[1], mfxVPPParams.vpp.Out);
 
+    GAPI_LOG_INFO(nullptr, "Initialize VPP for session: " << mfx_session <<
+                           ", out frame info: " << mfx_frame_info_to_string(mfxVPPParams.vpp.Out));
     sts = MFXVideoVPP_Init(mfx_session, &mfxVPPParams);
     if (MFX_ERR_NONE != sts) {
         GAPI_LOG_WARNING(nullptr, "cannot Init VPP");

modules/gapi/src/streaming/onevpl/engine/transcode/transcode_session.hpp

@@ -15,7 +15,7 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 class Surface;
-
+class VPLLegacyTranscodeEngine;
 class GAPI_EXPORTS LegacyTranscodeSession : public LegacyDecodeSession {
 public:
     friend class VPLLegacyTranscodeEngine;

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

@@ -10,9 +10,11 @@
 #endif // defined(_MSC_VER)
 
 #ifdef HAVE_ONEVPL
+#if defined(MFX_VERSION)
 #if (MFX_VERSION >= 2000)
 #include <vpl/mfxdispatcher.h>
 #endif // MFX_VERSION
+#endif // defined(MFX_VERSION)
 
 #include <vpl/mfx.h>
 #include <vpl/mfxvideo.h>

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

@@ -36,7 +36,7 @@ GSource::GSource(const std::string& filePath,
 GSource::GSource(const std::string& filePath,
                  const CfgParams& cfg_params,
                  const Device &device, const Context &ctx) :
-    GSource(filePath, cfg_params,
+    GSource(filePath, update_param_with_accel_type(CfgParams{cfg_params}, device.get_type()),
             std::make_shared<CfgParamDeviceSelector>(device, ctx, cfg_params)) {
 }
 

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

@@ -11,6 +11,7 @@
 #include "streaming/onevpl/engine/transcode/transcode_engine_legacy.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_dx11.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_va_api.hpp"
 #include "streaming/onevpl/utils.hpp"
 #include "streaming/onevpl/cfg_params_parser.hpp"
 #include "streaming/onevpl/data_provider_defines.hpp"
@@ -93,12 +94,12 @@ GSource::Priv::Priv(std::shared_ptr<IDataProvider> provider,
          GAPI_Assert(cfg_inst && "MFXCreateConfig failed");
 
         if (!cfg_param_it->is_major()) {
-            GAPI_LOG_DEBUG(nullptr, "Skip not major param: " << cfg_param_it->get_name());
+            GAPI_LOG_DEBUG(nullptr, "Skip not major param: " << cfg_param_it->to_string());
             ++cfg_param_it;
             continue;
         }
 
-        GAPI_LOG_DEBUG(nullptr, "Apply major param: " << cfg_param_it->get_name());
+        GAPI_LOG_DEBUG(nullptr, "Apply major param: " << cfg_param_it->to_string());
         mfxVariant mfx_param = cfg_param_to_mfx_variant(*cfg_param_it);
         mfxStatus sts = MFXSetConfigFilterProperty(cfg_inst,
                                                    (mfxU8 *)cfg_param_it->get_name().c_str(),
@@ -188,8 +189,14 @@ GSource::Priv::Priv(std::shared_ptr<IDataProvider> provider,
 
     // Extract the most suitable VPL implementation by max score
     auto max_match_it = matches_count.rbegin();
-    GAPI_Assert(max_match_it != matches_count.rend() &&
-                "Cannot find matched MFX implementation for requested configuration");
+    if (max_match_it == matches_count.rend()) {
+        std::stringstream ss;
+        for (const auto &p : cfg_params) {
+            ss << p.to_string() << std::endl;
+        }
+        GAPI_LOG_WARNING(nullptr, "No one suitable MFX implementation is found, requested params:\n" << ss.str());
+        throw std::runtime_error("Cannot find any suitable MFX implementation for requested configuration");
+    }
 
     // TODO impl_number is global for now
     impl_number = max_match_it->second;
@@ -294,6 +301,12 @@ std::unique_ptr<VPLAccelerationPolicy> GSource::Priv::initializeHWAccel(std::sha
             ret = std::move(cand);
             break;
         }
+        case MFX_ACCEL_MODE_VIA_VAAPI:
+        {
+            std::unique_ptr<VPLVAAPIAccelerationPolicy> cand(new VPLVAAPIAccelerationPolicy(selector));
+            ret = std::move(cand);
+            break;
+        }
         case MFX_ACCEL_MODE_NA:
         {
             std::unique_ptr<VPLCPUAccelerationPolicy> cand(new VPLCPUAccelerationPolicy(selector));
@@ -314,11 +327,16 @@ std::unique_ptr<VPLAccelerationPolicy> GSource::Priv::initializeHWAccel(std::sha
 
 const std::vector<CfgParam>& GSource::Priv::getDefaultCfgParams()
 {
+#ifdef __WIN32__
     static const std::vector<CfgParam> def_params =
         get_params_from_string<CfgParam>(
                     "mfxImplDescription.Impl: MFX_IMPL_TYPE_HARDWARE\n"
                     "mfxImplDescription.AccelerationMode: MFX_ACCEL_MODE_VIA_D3D11\n");
-
+#else
+    static const std::vector<CfgParam> def_params =
+        get_params_from_string<CfgParam>(
+                    "mfxImplDescription.Impl: MFX_IMPL_TYPE_HARDWARE\n");
+#endif
     return def_params;
 }
 

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

@@ -357,7 +357,7 @@ std::string mfxstatus_to_string(mfxStatus err) {
     }
 
     std::string ret("<unknown ");
-    ret += std::to_string(err) + ">";
+    ret += std::to_string(static_cast<size_t>(err)) + ">";
     return ret;
 }
 
@@ -384,7 +384,7 @@ std::string mfx_frame_info_to_string(const mfxFrameInfo &info) {
     return ss.str();
 }
 
-int compare(const mfxFrameInfo &lhs, const mfxFrameInfo &rhs) {
+static int compare(const mfxFrameInfo &lhs, const mfxFrameInfo &rhs) {
     //NB: mfxFrameInfo is a `packed` struct declared in VPL
     return memcmp(&lhs, &rhs, sizeof(mfxFrameInfo));
 }

modules/gapi/test/cpu/gapi_core_tests_cpu.cpp

@@ -12,6 +12,7 @@
 namespace
 {
 #define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -20,9 +21,7 @@ namespace opencv_test
 // FIXME: Wut? See MulTestCPU/MathOpTest below (duplicate?)
 INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU),
                                 Values(ADD, MUL),
@@ -32,9 +31,7 @@ INSTANTIATE_TEST_CASE_P(AddTestCPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU),
                                 Values(MUL),
@@ -44,9 +41,7 @@ INSTANTIATE_TEST_CASE_P(MulTestCPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU),
                                 Values(SUB),
@@ -56,9 +51,7 @@ INSTANTIATE_TEST_CASE_P(SubTestCPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU),
                                 Values(DIV),
@@ -68,90 +61,68 @@ INSTANTIATE_TEST_CASE_P(DivTestCPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(MulTestCPU, MulDoubleTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(DivTestCPU, DivTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(DivCTestCPU, DivCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MeanTestCPU, MeanTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MaskTestCPU, MaskTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(SelectTestCPU, SelectTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Polar2CartCPU, Polar2CartTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_32FC1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Cart2PolarCPU, Cart2PolarTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_32FC1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(PhaseCPU, PhaseTest,
                         Combine(Values(CV_32F, CV_32FC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
          /* angle_in_degrees */ testing::Bool()));
 
 INSTANTIATE_TEST_CASE_P(SqrtCPU, SqrtTest,
                         Combine(Values(CV_32F, CV_32FC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U),
                                 Values(CORE_CPU),
                                 Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@@ -160,9 +131,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestCPU, CmpTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AND, OR, XOR),
@@ -170,33 +139,25 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestCPU, BitwiseTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotTestCPU, NotTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MinTestCPU, MinTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(MaxTestCPU, MaxTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 //Values(1e-5),
                                 Values(CORE_CPU),
@@ -204,43 +165,33 @@ INSTANTIATE_TEST_CASE_P(SumTestCPU, SumTest,
 
 INSTANTIATE_TEST_CASE_P(CountNonZeroTestCPU, CountNonZeroTest,
                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffTestCPU, AbsDiffTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffCTestCPU, AbsDiffCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(AddWeightedTestCPU, AddWeightedTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_CPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsToleranceScalar(1e-5).to_compare_obj()),
@@ -248,17 +199,13 @@ INSTANTIATE_TEST_CASE_P(NormTestCPU, NormTest,
 
 INSTANTIATE_TEST_CASE_P(IntegralTestCPU, IntegralTest,
                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
@@ -269,9 +216,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdTest,
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
@@ -279,99 +224,75 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestCPU, ThresholdOTTest,
 
 INSTANTIATE_TEST_CASE_P(InRangeTestCPU, InRangeTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Split3TestCPU, Split3Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Split4TestCPU, Split4Test,
                         Combine(Values(CV_8UC4),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Merge3TestCPU, Merge3Test,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC3),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(Merge4TestCPU, Merge4Test,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC4),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(RemapTestCPU, RemapTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(FlipTestCPU, FlipTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(0,1,-1)));
 
 INSTANTIATE_TEST_CASE_P(CropTestCPU, CropTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 
 INSTANTIATE_TEST_CASE_P(CopyTestCPU, CopyTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCPU, LUTTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCustomCPU, LUTTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC3),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -380,40 +301,31 @@ INSTANTIATE_TEST_CASE_P(ConvertToCPU, ConvertToTest,
 
 INSTANTIATE_TEST_CASE_P(ConcatHorTestCPU, ConcatHorTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatVertTestCPU, ConcatVertTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatVertVecTestCPU, ConcatVertVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatHorVecTestCPU, ConcatHorVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 
 INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -425,8 +337,7 @@ INSTANTIATE_TEST_CASE_P(WarpPerspectiveTestCPU, WarpPerspectiveTest,
 
 INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -438,8 +349,7 @@ INSTANTIATE_TEST_CASE_P(WarpAffineTestCPU, WarpAffineTest,
 
 INSTANTIATE_TEST_CASE_P(NormalizeTestCPU, NormalizeTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -519,9 +429,7 @@ INSTANTIATE_TEST_CASE_P(TransposeTestCPU, TransposeTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1,
                                        CV_8UC2, CV_16UC2, CV_16SC2, CV_32FC2,
                                        CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj())));

modules/gapi/test/cpu/gapi_core_tests_fluid.cpp

@@ -11,6 +11,7 @@
 namespace
 {
 #define CORE_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::fluid::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -18,10 +19,7 @@ namespace opencv_test
 // FIXME: Windows accuracy problems after recent update!
 INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1, CV_8U, CV_32F),
                                 Values(CORE_FLUID),
                                 Values(DIV, MUL),
@@ -37,10 +35,7 @@ INSTANTIATE_TEST_CASE_P(MathOpTestFluid, MathOpTest,
 //        Github ticket: https://github.com/opencv/opencv/issues/18373.
 INSTANTIATE_TEST_CASE_P(DISABLED_MathOpTestFluid, MathOpTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1, CV_8U, CV_32F),
                                 Values(CORE_FLUID),
                                 Values(ADD, SUB),
@@ -54,9 +49,7 @@ INSTANTIATE_TEST_CASE_P(DISABLED_MathOpTestFluid, MathOpTest,
 //        Github ticket: https://github.com/opencv/opencv/issues/18373.
 INSTANTIATE_TEST_CASE_P(DISABLED_SubTestFluid, MathOpTest,
                         Combine(Values(CV_8UC1, CV_16SC1 , CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1, CV_8U, CV_32F),
                                 Values(CORE_FLUID),
                                 Values(SUB),
@@ -66,41 +59,31 @@ INSTANTIATE_TEST_CASE_P(DISABLED_SubTestFluid, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(MulSTestFluid, MulDoubleTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1), // FIXME: extend with more types
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DivCTestFluid, DivCTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U, CV_32F),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_MeanTestFluid, MeanTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(MaskTestFluid, MaskTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffTestFluid, AbsDiffTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
@@ -108,18 +91,13 @@ INSTANTIATE_TEST_CASE_P(AbsDiffCTestFluid, AbsDiffCTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_8UC2,
                                        CV_16UC2, CV_16SC2, CV_8UC3, CV_16UC3,
                                        CV_16SC3, CV_8UC4, CV_16UC4, CV_16SC4),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AND, OR, XOR),
@@ -127,46 +105,32 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestFluid, BitwiseTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotTestFluid, NotTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(MinTestFluid, MinTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(MaxTestFluid, MaxTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_SumTestFluid, SumTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U),
                                 Values(CORE_FLUID),
                                 Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@@ -176,10 +140,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestFluid, CmpTest,
 // FIXME: solve comparison error to unite with the test above
 INSTANTIATE_TEST_CASE_P(CompareTestFluidScalar, CmpTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U),
                                 Values(CORE_FLUID),
                                 Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@@ -188,18 +149,14 @@ INSTANTIATE_TEST_CASE_P(CompareTestFluidScalar, CmpTest,
 
 INSTANTIATE_TEST_CASE_P(AddWeightedTestFluid, AddWeightedTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1, CV_8U, CV_32F),
                                 Values(CORE_FLUID),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_NormTestFluid, NormTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsToleranceScalar(1e-5).to_compare_obj()),
@@ -207,26 +164,19 @@ INSTANTIATE_TEST_CASE_P(DISABLED_NormTestFluid, NormTest,
 
 INSTANTIATE_TEST_CASE_P(DISABLED_IntegralTestFluid, IntegralTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestFluid, LUTTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
                                 Values(CORE_FLUID),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@@ -235,128 +185,94 @@ INSTANTIATE_TEST_CASE_P(ConvertToFluid, ConvertToTest,
 
 INSTANTIATE_TEST_CASE_P(DISABLED_ConcatHorTestFluid, ConcatHorTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_ConcatVertTestFluid, ConcatVertTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Split3TestFluid, Split3Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Split4TestFluid, Split4Test,
                         Combine(Values(CV_8UC4),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Merge3TestFluid, Merge3Test,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC3),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Merge4TestFluid, Merge4Test,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC4),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_RemapTestFluid, RemapTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_FlipTestFluid, FlipTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(0,1,-1)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_CropTestFluid, CropTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 
 INSTANTIATE_TEST_CASE_P(SelectTestFluid, SelectTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Polar2CartFluid, Polar2CartTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_32FC1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(Cart2PolarFluid, Cart2PolarTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_32FC1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(PhaseFluid, PhaseTest,
                         Combine(Values(CV_32F, CV_32FC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
          /* angle_in_degrees */ testing::Bool()));
 
 INSTANTIATE_TEST_CASE_P(SqrtFluid, SqrtTest,
                         Combine(Values(CV_32F, CV_32FC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV,
@@ -368,19 +284,14 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestFluid, ThresholdTest,
 
 INSTANTIATE_TEST_CASE_P(DISABLED_ThresholdTestFluid, ThresholdOTTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
 
 INSTANTIATE_TEST_CASE_P(InRangeTestFluid, InRangeTest,
                         Combine(Values(CV_8UC3, CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1920, 1080),
-                                       cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID)));
 

modules/gapi/test/cpu/gapi_imgproc_tests_cpu.cpp

@@ -13,6 +13,7 @@
 namespace
 {
 #define IMGPROC_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::imgproc::cpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -20,9 +21,7 @@ namespace opencv_test
 
 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@@ -32,9 +31,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTest,
 
 INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@@ -44,9 +41,7 @@ INSTANTIATE_TEST_CASE_P(ResizePTestCPU, ResizePTest,
 
 INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@@ -56,9 +51,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestCPU, ResizeTestFxFy,
 
 INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                        cv::Size(640, 480),
-                                        cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -70,8 +63,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestCPU, Filter2DTest,
 
 INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsTolerance(0).to_compare_obj()),
@@ -80,8 +72,7 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestCPU, BoxFilterTest,
 
 INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                        cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -89,8 +80,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_8U, SepFilterTest,
 
 INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
                         Combine(Values(CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -98,8 +88,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestCPU_other, SepFilterTest,
 
 INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsTolerance(0.0).to_compare_obj()),
@@ -108,8 +97,7 @@ INSTANTIATE_TEST_CASE_P(BlurTestCPU, BlurTest,
 
 INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -117,8 +105,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestCPU, GaussianBlurTest,
 
 INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -126,8 +113,7 @@ INSTANTIATE_TEST_CASE_P(MedianBlurTestCPU, MedianBlurTest,
 
 INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -138,8 +124,7 @@ INSTANTIATE_TEST_CASE_P(ErodeTestCPU, ErodeTest,
 
 INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -147,8 +132,7 @@ INSTANTIATE_TEST_CASE_P(Erode3x3TestCPU, Erode3x3Test,
 
 INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -159,8 +143,7 @@ INSTANTIATE_TEST_CASE_P(DilateTestCPU, DilateTest,
 
 INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -168,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3TestCPU, Dilate3x3Test,
 
 INSTANTIATE_TEST_CASE_P(MorphologyExTestCPU, MorphologyExTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -183,8 +165,7 @@ INSTANTIATE_TEST_CASE_P(MorphologyExTestCPU, MorphologyExTest,
 
 INSTANTIATE_TEST_CASE_P(MorphologyExHitMissTestCPU, MorphologyExTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -192,8 +173,7 @@ INSTANTIATE_TEST_CASE_P(MorphologyExHitMissTestCPU, MorphologyExTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -203,8 +183,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestCPU, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -214,8 +193,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestCPU32F, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -226,8 +204,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestCPU, SobelXYTest,
 
 INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -238,8 +215,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestCPU32F, SobelXYTest,
 
 INSTANTIATE_TEST_CASE_P(LaplacianTestCPU, LaplacianTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -249,8 +225,7 @@ INSTANTIATE_TEST_CASE_P(LaplacianTestCPU, LaplacianTest,
 
 INSTANTIATE_TEST_CASE_P(BilateralFilterTestCPU, BilateralFilterTest,
                         Combine(Values(CV_32FC1, CV_32FC3, CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -261,16 +236,14 @@ INSTANTIATE_TEST_CASE_P(BilateralFilterTestCPU, BilateralFilterTest,
 
 INSTANTIATE_TEST_CASE_P(EqHistTestCPU, EqHistTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(CannyTestCPU, CannyTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsSimilarPoints(0, 0.05).to_compare_obj()),
@@ -314,8 +287,7 @@ INSTANTIATE_TEST_CASE_P(FindContoursOffsetTestCPU, FindContoursOffsetTest,
 
 INSTANTIATE_TEST_CASE_P(FindContoursHNoOffsetTestCPU, FindContoursHNoOffsetTest,
                         Combine(Values(IMGPROC_CPU),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE),
                                 Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
@@ -324,8 +296,7 @@ INSTANTIATE_TEST_CASE_P(FindContoursHNoOffsetTestCPU, FindContoursHNoOffsetTest,
 
 INSTANTIATE_TEST_CASE_P(FindContoursHNoOffset32STestCPU, FindContoursHNoOffsetTest,
                         Combine(Values(IMGPROC_CPU),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32SC1),
                                 Values(RETR_CCOMP, RETR_FLOODFILL),
                                 Values(CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE,
@@ -337,9 +308,7 @@ INSTANTIATE_TEST_CASE_P(FindContoursHOffsetTestCPU, FindContoursHOffsetTest,
 
 INSTANTIATE_TEST_CASE_P(BoundingRectMatTestCPU, BoundingRectMatTest,
                         Combine(Values( CV_8UC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(IMGPROC_CPU),
                                 Values(IoUToleranceRect(0).to_compare_obj()),
@@ -440,176 +409,154 @@ INSTANTIATE_TEST_CASE_P(FitLine3DVector64FTestCPU, FitLine3DVector64FTest,
 
 INSTANTIATE_TEST_CASE_P(BGR2RGBTestCPU, BGR2RGBTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2GrayTestCPU, RGB2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2GrayTestCPU, BGR2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUVTestCPU, RGB2YUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(YUV2RGBTestCPU, YUV2RGBTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2I420TestCPU, BGR2I420Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2I420TestCPU, RGB2I420Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(I4202BGRTestCPU, I4202BGRTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(I4202RGBTestCPU, I4202RGBTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NV12toRGBTestCPU, NV12toRGBTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NV12toBGRTestCPU, NV12toBGRTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NV12toGrayTestCPU, NV12toGrayTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NV12toRGBpTestCPU, NV12toRGBpTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NV12toBGRpTestCPU, NV12toBGRpTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2LabTestCPU, RGB2LabTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2LUVTestCPU, BGR2LUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(LUV2BGRTestCPU, LUV2BGRTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2YUVTestCPU, BGR2YUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(YUV2BGRTestCPU, YUV2BGRTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2HSVTestCPU, RGB2HSVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestCPU, BayerGR2RGBTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_CPU),
                                 Values(AbsExact().to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUV422TestCPU, RGB2YUV422Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC2),
                                 Values(IMGPROC_CPU),
                                 Values(AbsTolerance(1).to_compare_obj())));

modules/gapi/test/cpu/gapi_imgproc_tests_fluid.cpp

@@ -19,26 +19,17 @@ namespace opencv_test
 INSTANTIATE_TEST_CASE_P(ResizeTestFluid, ResizeTest,
                         Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128),
-                                       cv::Size(64, 64),
                                        cv::Size(30, 30)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 1).to_compare_obj()),
                                 Values(/*cv::INTER_NEAREST,*/ cv::INTER_LINEAR/*, cv::INTER_AREA*/),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128),
-                                       cv::Size(64, 64),
                                        cv::Size(30, 30))));
 
 INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
                         Combine(Values(CV_8UC3/*CV_8UC1, CV_16UC1, CV_16SC1*/),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128),
-                                       cv::Size(64, 64),
                                        cv::Size(30, 30)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
@@ -49,40 +40,35 @@ INSTANTIATE_TEST_CASE_P(ResizeTestFxFyFluid, ResizeTestFxFy,
 
 INSTANTIATE_TEST_CASE_P(RGB2GrayTestFluid, RGB2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2GrayTestFluid, BGR2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUVTestFluid, RGB2YUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(YUV2RGBTestFluid, YUV2RGBTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
@@ -90,40 +76,35 @@ INSTANTIATE_TEST_CASE_P(RGB2LabTestFluid, RGB2LabTest,
 // FIXME: Not supported by Fluid yet (no kernel implemented)
 INSTANTIATE_TEST_CASE_P(BGR2LUVTestFluid, BGR2LUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(5e-3, 6).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2HSVTestFluid, RGB2HSVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BayerGR2RGBTestFluid, BayerGR2RGBTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUV422TestFluid, RGB2YUV422Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC2),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsTolerance(1).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -132,8 +113,7 @@ INSTANTIATE_TEST_CASE_P(blurTestFluid, BlurTest,
 
 INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-3f, 0.01).to_compare_obj()),
@@ -141,8 +121,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestFluid, GaussianBlurTest,
 
 INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -150,8 +129,7 @@ INSTANTIATE_TEST_CASE_P(medianBlurTestFluid, MedianBlurTest,
 
 INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -162,8 +140,7 @@ INSTANTIATE_TEST_CASE_P(erodeTestFluid, ErodeTest,
 
 INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -174,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(dilateTestFluid, DilateTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -185,8 +161,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -196,8 +171,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestFluid32F, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -208,8 +182,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid, SobelXYTest,
 
 INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -220,8 +193,7 @@ INSTANTIATE_TEST_CASE_P(SobelXYTestFluid32F, SobelXYTest,
 
 INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -230,8 +202,7 @@ INSTANTIATE_TEST_CASE_P(boxFilterTestFluid32, BoxFilterTest,
 
 INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_FLUID),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -240,7 +211,6 @@ INSTANTIATE_TEST_CASE_P(sepFilterTestFluid, SepFilterTest,
 INSTANTIATE_TEST_CASE_P(filter2DTestFluid, Filter2DTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
                                 Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
                                        cv::Size(128, 128)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_FLUID),

modules/gapi/test/cpu/gapi_operators_tests_cpu.cpp

@@ -12,6 +12,7 @@
 namespace
 {
 #define CORE_CPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::cpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -19,21 +20,17 @@ namespace opencv_test
 
 // FIXME: CPU test runs are disabled since Fluid is an exclusive plugin now!
 INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatMatTest,
-                    Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                            Values(cv::Size(1280, 720),
-                                   cv::Size(640, 480),
-                                   cv::Size(128, 128)),
-                            Values(-1),
-                            Values(CORE_CPU),
-                            Values(AbsExact().to_compare_obj()),
-                            Values( ADD, SUB, DIV,
+                        Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
+                                ValuesIn(in_sizes),
+                                Values(-1),
+                                Values(CORE_CPU),
+                                Values(AbsExact().to_compare_obj()),
+                                Values( ADD, SUB, DIV,
                                     GT, LT, GE, LE, EQ, NE)));
 
 INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -44,9 +41,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestCPU, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -54,9 +49,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatMatTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -65,9 +58,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestCPU, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestCPU, NotOperatorTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_CPU)));
 }

modules/gapi/test/cpu/gapi_operators_tests_fluid.cpp

@@ -11,6 +11,7 @@
 namespace
 {
 #define CORE_FLUID [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::fluid::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -18,9 +19,7 @@ namespace opencv_test
 
 INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -29,9 +28,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestFluid, MathOperatorMatMatTest,
 
 INSTANTIATE_TEST_CASE_P(MathOperatorArithmeticTestFluid, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -41,9 +38,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorArithmeticTestFluid, MathOperatorMatScalarTe
   // FIXME: solve comparison error
 INSTANTIATE_TEST_CASE_P(MathOperatorCompareTestFluid, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsSimilarPoints(1, 0.01).to_compare_obj()),
@@ -52,9 +47,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorCompareTestFluid, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -62,9 +55,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatMatTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_FLUID),
                                 Values(AbsExact().to_compare_obj()),
@@ -72,10 +63,8 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestFluid, MathOperatorMatScalarTest,
                                         ANDR, ORR, XORR )));
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestFluid, NotOperatorTest,
-                    Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                            Values(cv::Size(1280, 720),
-                                   cv::Size(640, 480),
-                                   cv::Size(128, 128)),
-                            Values(-1),
-                            Values(CORE_FLUID)));
+                        Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
+                                ValuesIn(in_sizes),
+                                Values(-1),
+                                Values(CORE_FLUID)));
 }

modules/gapi/test/gpu/gapi_core_tests_gpu.cpp

@@ -11,6 +11,7 @@
 namespace
 {
 #define CORE_GPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::gpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -19,9 +20,7 @@ namespace opencv_test
 // FIXME: Wut? See MulTestGPU/MathOpTest below (duplicate?)
 INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU),
                                 Values(ADD, MUL),
@@ -31,9 +30,7 @@ INSTANTIATE_TEST_CASE_P(AddTestGPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU),
                                 Values(MUL),
@@ -43,9 +40,7 @@ INSTANTIATE_TEST_CASE_P(MulTestGPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU),
                                 Values(SUB),
@@ -65,9 +60,7 @@ INSTANTIATE_TEST_CASE_P(SubTestGPU, MathOpTest,
 //        Github ticket: https://github.com/opencv/opencv/issues/18373.
 INSTANTIATE_TEST_CASE_P(DISABLED_DivTestGPU, MathOpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU),
                                 Values(DIV),
@@ -77,74 +70,56 @@ INSTANTIATE_TEST_CASE_P(DISABLED_DivTestGPU, MathOpTest,
 
 INSTANTIATE_TEST_CASE_P(MulTestGPU, MulDoubleTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DivTestGPU, DivTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DivCTestGPU, DivCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(MeanTestGPU, MeanTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 //TODO: mask test doesn't work
 INSTANTIATE_TEST_CASE_P(DISABLED_MaskTestGPU, MaskTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(SelectTestGPU, SelectTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Polar2CartGPU, Polar2CartTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_32FC1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Cart2PolarGPU, Cart2PolarTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_32FC1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U),
                                 Values(CORE_GPU),
                                 Values(CMP_EQ, CMP_GE, CMP_NE, CMP_GT, CMP_LT, CMP_LE),
@@ -153,9 +128,7 @@ INSTANTIATE_TEST_CASE_P(CompareTestGPU, CmpTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AND, OR, XOR),
@@ -163,76 +136,58 @@ INSTANTIATE_TEST_CASE_P(BitwiseTestGPU, BitwiseTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotTestGPU, NotTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_MinTestGPU, MinTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_MaxTestGPU, MaxTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(SumTestGPU, SumTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(CountNonZeroTestGPU, CountNonZeroTest,
                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AbsToleranceScalar(1e-5).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffTestGPU, AbsDiffTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(AbsDiffCTestGPU, AbsDiffCTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(AddWeightedTestGPU, AddWeightedTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values( -1, CV_8U, CV_16U, CV_32F ),
                                 Values(CORE_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-6, 1).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AbsToleranceScalar(1e-3).to_compare_obj()), //TODO: too relaxed?
@@ -240,17 +195,13 @@ INSTANTIATE_TEST_CASE_P(NormTestGPU, NormTest,
 
 INSTANTIATE_TEST_CASE_P(IntegralTestGPU, IntegralTest,
                         Combine(Values( CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(cv::THRESH_BINARY, cv::THRESH_BINARY_INV, cv::THRESH_TRUNC,
@@ -261,9 +212,7 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdTest,
 
 INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(cv::THRESH_OTSU, cv::THRESH_TRIANGLE)));
@@ -271,91 +220,69 @@ INSTANTIATE_TEST_CASE_P(ThresholdTestGPU, ThresholdOTTest,
 
 INSTANTIATE_TEST_CASE_P(InRangeTestGPU, InRangeTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Split3TestGPU, Split3Test,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Split4TestGPU, Split4Test,
                         Combine(Values(CV_8UC4),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Merge3TestGPU, Merge3Test,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC3),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(Merge4TestGPU, Merge4Test,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC4),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(RemapTestGPU, RemapTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(FlipTestGPU, FlipTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(0,1,-1)));
 
 INSTANTIATE_TEST_CASE_P(CropTestGPU, CropTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(cv::Rect(10, 8, 20, 35), cv::Rect(4, 10, 37, 50))));
 
 INSTANTIATE_TEST_CASE_P(LUTTestGPU, LUTTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(LUTTestCustomGPU, LUTTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8UC3),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(CV_8U, CV_16U, CV_16S, CV_32F),
                                 Values(CORE_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -364,17 +291,13 @@ INSTANTIATE_TEST_CASE_P(ConvertToGPU, ConvertToTest,
 
 INSTANTIATE_TEST_CASE_P(ConcatHorTestGPU, ConcatHorTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(ConcatVertTestGPU, ConcatVertTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
@@ -382,9 +305,7 @@ INSTANTIATE_TEST_CASE_P(TransposeTestGPU, TransposeTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1, CV_32FC1,
                                        CV_8UC2, CV_16UC2, CV_16SC2, CV_32FC2,
                                        CV_8UC3, CV_16UC3, CV_16SC3, CV_32FC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AbsExact().to_compare_obj())));
@@ -415,17 +336,13 @@ INSTANTIATE_TEST_CASE_P(ReInitOutTestGPU, ReInitOutTest,
 //TODO: fix this backend to allow ConcatVertVec ConcatHorVec
 INSTANTIATE_TEST_CASE_P(DISABLED_ConcatVertVecTestGPU, ConcatVertVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 
 INSTANTIATE_TEST_CASE_P(DISABLED_ConcatHorVecTestGPU, ConcatHorVecTest,
                         Combine(Values( CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1 ),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 }

modules/gapi/test/gpu/gapi_imgproc_tests_gpu.cpp

@@ -12,6 +12,7 @@
 namespace
 {
 #define IMGPROC_GPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::imgproc::gpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -19,9 +20,7 @@ namespace opencv_test
 
 INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@@ -31,9 +30,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTest,
 
 INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsSimilarPoints(2, 0.05).to_compare_obj()),
@@ -43,9 +40,7 @@ INSTANTIATE_TEST_CASE_P(ResizeTestGPU, ResizeTestFxFy,
 
 INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@@ -57,8 +52,7 @@ INSTANTIATE_TEST_CASE_P(Filter2DTestGPU, Filter2DTest,
 
 INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest,
                         Combine(Values(/*CV_8UC1,*/ CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@@ -68,8 +62,7 @@ INSTANTIATE_TEST_CASE_P(BoxFilterTestGPU, BoxFilterTest,
 
 INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -77,8 +70,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_8U, SepFilterTest,
 
 INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest,
                         Combine(Values(CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_32F),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceFilter(1e-4f, 0.01).to_compare_obj()),
@@ -86,8 +78,7 @@ INSTANTIATE_TEST_CASE_P(SepFilterTestGPU_other, SepFilterTest,
 
 INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@@ -96,8 +87,7 @@ INSTANTIATE_TEST_CASE_P(BlurTestGPU, BlurTest,
 
 INSTANTIATE_TEST_CASE_P(gaussBlurTestGPU, GaussianBlurTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceFilter(1e-5f, 0.01).to_compare_obj()),
@@ -105,8 +95,7 @@ INSTANTIATE_TEST_CASE_P(gaussBlurTestGPU, GaussianBlurTest,
 
 INSTANTIATE_TEST_CASE_P(MedianBlurTestGPU, MedianBlurTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -114,8 +103,7 @@ INSTANTIATE_TEST_CASE_P(MedianBlurTestGPU, MedianBlurTest,
 
 INSTANTIATE_TEST_CASE_P(ErodeTestGPU, ErodeTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -126,8 +114,7 @@ INSTANTIATE_TEST_CASE_P(ErodeTestGPU, ErodeTest,
 
 INSTANTIATE_TEST_CASE_P(Erode3x3TestGPU, Erode3x3Test,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -135,8 +122,7 @@ INSTANTIATE_TEST_CASE_P(Erode3x3TestGPU, Erode3x3Test,
 
 INSTANTIATE_TEST_CASE_P(DilateTestGPU, DilateTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -147,8 +133,7 @@ INSTANTIATE_TEST_CASE_P(DilateTestGPU, DilateTest,
 
 INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -156,8 +141,7 @@ INSTANTIATE_TEST_CASE_P(Dilate3x3TestGPU, Dilate3x3Test,
 
 INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1, CV_16S, CV_32F),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@@ -167,8 +151,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(SobelTestGPU32F, SobelTest,
                         Combine(Values(CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_32F),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@@ -178,8 +161,7 @@ INSTANTIATE_TEST_CASE_P(SobelTestGPU32F, SobelTest,
 
 INSTANTIATE_TEST_CASE_P(LaplacianTestGPU, LaplacianTest,
                         Combine(Values(CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@@ -189,8 +171,7 @@ INSTANTIATE_TEST_CASE_P(LaplacianTestGPU, LaplacianTest,
 
 INSTANTIATE_TEST_CASE_P(BilateralFilterTestGPU, BilateralFilterTest,
                         Combine(Values(CV_32FC1, CV_32FC3, CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@@ -201,16 +182,14 @@ INSTANTIATE_TEST_CASE_P(BilateralFilterTestGPU, BilateralFilterTest,
 
 INSTANTIATE_TEST_CASE_P(EqHistTestGPU, EqHistTest,
                         Combine(Values(CV_8UC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(-1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsExact().to_compare_obj())));  // FIXIT Non reliable check
 
 INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest,
                         Combine(Values(CV_8UC1, CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_GPU),
                                 Values(AbsSimilarPoints(0, 0.05).to_compare_obj()),
@@ -221,72 +200,63 @@ INSTANTIATE_TEST_CASE_P(CannyTestGPU, CannyTest,
 
 INSTANTIATE_TEST_CASE_P(RGB2GrayTestGPU, RGB2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2GrayTestGPU, BGR2GrayTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC1),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2YUVTestGPU, RGB2YUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(YUV2RGBTestGPU, YUV2RGBTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(RGB2LabTestGPU, RGB2LabTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(AbsSimilarPoints(1, 0.05).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2LUVTestGPU, BGR2LUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(5e-3, 6).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(LUV2BGRTestGPU, LUV2BGRTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(BGR2YUVTestGPU, BGR2YUVTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));
 
 INSTANTIATE_TEST_CASE_P(YUV2BGRTestGPU, YUV2BGRTest,
                         Combine(Values(CV_8UC3),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480)),
+                                Values(cv::Size(1280, 720)),
                                 Values(CV_8UC3),
                                 Values(IMGPROC_GPU),
                                 Values(ToleranceColor(1e-3).to_compare_obj())));

modules/gapi/test/gpu/gapi_operators_tests_gpu.cpp

@@ -11,6 +11,7 @@
 namespace
 {
 #define CORE_GPU [] () { return cv::compile_args(cv::gapi::use_only{cv::gapi::core::gpu::kernels()}); }
+    const std::vector <cv::Size> in_sizes{ cv::Size(1280, 720), cv::Size(128, 128) };
 }  // anonymous namespace
 
 namespace opencv_test
@@ -18,9 +19,7 @@ namespace opencv_test
 
 INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
                     Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                            Values(cv::Size(1280, 720),
-                                   cv::Size(640, 480),
-                                   cv::Size(128, 128)),
+                            ValuesIn(in_sizes),
                             Values(-1),
                             Values(CORE_GPU),
                             Values(Tolerance_FloatRel_IntAbs(1e-5, 2).to_compare_obj()),
@@ -29,9 +28,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatMatTest,
 
 INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16SC1, CV_32FC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(Tolerance_FloatRel_IntAbs(1e-4, 2).to_compare_obj()),
@@ -42,9 +39,7 @@ INSTANTIATE_TEST_CASE_P(MathOperatorTestGPU, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -52,9 +47,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatMatTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU),
                                 Values(AbsExact().to_compare_obj()),
@@ -63,9 +56,7 @@ INSTANTIATE_TEST_CASE_P(BitwiseOperatorTestGPU, MathOperatorMatScalarTest,
 
 INSTANTIATE_TEST_CASE_P(BitwiseNotOperatorTestGPU, NotOperatorTest,
                         Combine(Values(CV_8UC1, CV_16UC1, CV_16SC1),
-                                Values(cv::Size(1280, 720),
-                                       cv::Size(640, 480),
-                                       cv::Size(128, 128)),
+                                ValuesIn(in_sizes),
                                 Values(-1),
                                 Values(CORE_GPU)));
 }

modules/gapi/test/rmat/rmat_view_tests.cpp

@@ -132,7 +132,7 @@ TEST_P(RMatViewNDTest, StepFromView) {
 
 INSTANTIATE_TEST_CASE_P(Test, RMatViewNDTest,
                         Combine(Values(CV_8U, CV_32F), // depth
-                                Values(1,2,3,4,7)));   // ndims
+                                Values(1,2,3,4,5)));   // ndims
 
 struct RMatViewNDTestNegative : public TestWithParam<
     std::tuple<int /*depth*/, int /*chan*/, int /*ndims*/>>{};
@@ -153,7 +153,7 @@ TEST_P(RMatViewNDTestNegative, DefaultStep) {
 INSTANTIATE_TEST_CASE_P(Test, RMatViewNDTestNegative,
                         Combine(Values(CV_8U, CV_32F), // depth
                                 Values(1,2,3,4),       // chan
-                                Values(2,4,7)));       // ndims
+                                Values(2,4,5)));       // ndims
 
 TEST_P(RMatViewTest, NonDefaultStepInput) {
     auto type = GetParam();

modules/gapi/test/s11n/gapi_s11n_tests.cpp

@@ -569,7 +569,6 @@ TEST_F(S11N_Basic, Test_Bind_RunArgs_MatScalar) {
     v[0] = cv::GRunArg{ mat };
     v[1] = cv::GRunArg{ scalar };
     GRunArgsP output = cv::gapi::bind(v);
-    unsigned int i = 0;
     for (auto it : output)
     {
         using T = cv::GRunArgP;
@@ -591,7 +590,6 @@ TEST_F(S11N_Basic, Test_Bind_RunArgs_MatScalar) {
             GAPI_Assert(false && "This value type is not supported!"); // ...maybe because of STANDALONE mode.
             break;
         }
-        i++;
     }
 }
 

modules/gapi/test/streaming/gapi_streaming_tests.cpp

@@ -2440,7 +2440,11 @@ TEST(OneVPL_Source, Init)
 
     std::vector<CfgParam> src_params;
     src_params.push_back(CfgParam::create_implementation(MFX_IMPL_TYPE_HARDWARE));
+#ifdef _WIN32
     src_params.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_D3D11));
+#elif defined(__linux__)
+    src_params.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_VAAPI));
+#endif
     src_params.push_back(CfgParam::create_decoder_id(MFX_CODEC_HEVC));
     std::stringstream stream(std::ios_base::in | std::ios_base::out | std::ios_base::binary);
 

modules/gapi/test/streaming/gapi_streaming_vpl_core_test.cpp

@@ -36,6 +36,7 @@
 #include "streaming/onevpl/accelerators/surface/cpu_frame_adapter.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_dx11.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_va_api.hpp"
 #include "streaming/onevpl/accelerators/dx11_alloc_resource.hpp"
 #include "streaming/onevpl/accelerators/utils/shared_lock.hpp"
 #define private public
@@ -79,7 +80,7 @@ struct TestProcessingSession : public cv::gapi::wip::onevpl::EngineSession {
 
 struct TestProcessingEngine: public cv::gapi::wip::onevpl::ProcessingEngineBase {
 
-    size_t pipeline_stage_num = 0;
+    int pipeline_stage_num = 0;
 
     TestProcessingEngine(std::unique_ptr<cv::gapi::wip::onevpl::VPLAccelerationPolicy>&& accel) :
         cv::gapi::wip::onevpl::ProcessingEngineBase(std::move(accel)) {
@@ -154,7 +155,7 @@ private:
     mfxFrameAllocator m_allocator;
 };
 template <class LockProcessor, class UnlockProcessor>
-std::map<mfxMemId, UnlockProcessor> TestLockableAllocator<LockProcessor, UnlockProcessor>::lock_processor_table {};
+std::map<mfxMemId, LockProcessor> TestLockableAllocator<LockProcessor, UnlockProcessor>::lock_processor_table {};
 
 template <class LockProcessor, class UnlockProcessor>
 std::map<mfxMemId, UnlockProcessor> TestLockableAllocator<LockProcessor, UnlockProcessor>::unlock_processor_table {};
@@ -194,11 +195,11 @@ TEST(OneVPL_Source_Surface, InitSurface)
     // check self consistency
     EXPECT_EQ(reinterpret_cast<void*>(surf->get_handle()),
               reinterpret_cast<void*>(mfx_core_handle));
-    EXPECT_EQ(0, surf->get_locks_count());
-    EXPECT_EQ(0, surf->obtain_lock());
-    EXPECT_EQ(1, surf->get_locks_count());
-    EXPECT_EQ(1, surf->release_lock());
-    EXPECT_EQ(0, surf->get_locks_count());
+    EXPECT_TRUE(0 == surf->get_locks_count());
+    EXPECT_TRUE(0 == surf->obtain_lock());
+    EXPECT_TRUE(1 == surf->get_locks_count());
+    EXPECT_TRUE(1 == surf->release_lock());
+    EXPECT_TRUE(0 == surf->get_locks_count());
 }
 
 TEST(OneVPL_Source_Surface, ConcurrentLock)
@@ -213,7 +214,7 @@ TEST(OneVPL_Source_Surface, ConcurrentLock)
     auto surf = Surface::create_surface(std::move(handle), associated_memory);
 
     // check self consistency
-    EXPECT_EQ(0, surf->get_locks_count());
+    EXPECT_TRUE(0 == surf->get_locks_count());
 
     // MFX internal limitation: do not exceede U16 range
     // so I16 is using here
@@ -238,7 +239,7 @@ TEST(OneVPL_Source_Surface, ConcurrentLock)
     }
 
     worker_thread.join();
-    EXPECT_EQ(lock_counter * 2, surf->get_locks_count());
+    EXPECT_TRUE(static_cast<size_t>(lock_counter * 2) == surf->get_locks_count());
 }
 
 TEST(OneVPL_Source_Surface, MemoryLifeTime)
@@ -271,7 +272,7 @@ TEST(OneVPL_Source_Surface, MemoryLifeTime)
     }
 
     // workspace memory must be alive
-    EXPECT_EQ(0, surfaces.size());
+    EXPECT_TRUE(0 == surfaces.size());
     EXPECT_TRUE(associated_memory != nullptr);
     EXPECT_TRUE(preallocated_memory_ptr.get() != nullptr);
 
@@ -293,7 +294,7 @@ TEST(OneVPL_Source_Surface, MemoryLifeTime)
     associated_memory.reset();
 
     // workspace memory must be still alive
-    EXPECT_EQ(0, surfaces.size());
+    EXPECT_TRUE(0 == surfaces.size());
     EXPECT_TRUE(associated_memory == nullptr);
     EXPECT_TRUE(preallocated_memory_ptr.get() != nullptr);
 
@@ -316,14 +317,14 @@ TEST(OneVPL_Source_CPU_FrameAdapter, InitFrameAdapter)
     auto surf = Surface::create_surface(std::move(handle), associated_memory);
 
     // check consistency
-    EXPECT_EQ(0, surf->get_locks_count());
+    EXPECT_TRUE(0 == surf->get_locks_count());
 
     {
         mfxSession stub_session = reinterpret_cast<mfxSession>(0x1);
         VPLMediaFrameCPUAdapter adapter(surf, stub_session);
-        EXPECT_EQ(1, surf->get_locks_count());
+        EXPECT_TRUE(1 == surf->get_locks_count());
     }
-    EXPECT_EQ(0, surf->get_locks_count());
+    EXPECT_TRUE(0 == surf->get_locks_count());
 }
 
 TEST(OneVPL_Source_CPU_Accelerator, InitDestroy)
@@ -385,13 +386,13 @@ TEST(OneVPL_Source_CPU_Accelerator, PoolProduceConsume)
     for (size_t i = 0; i < surface_count; i++) {
         std::shared_ptr<Surface> surf = acceleration_policy->get_free_surface(key).lock();
         EXPECT_TRUE(surf.get() != nullptr);
-        EXPECT_EQ(0, surf->obtain_lock());
+        EXPECT_TRUE(0 == surf->obtain_lock());
         surfaces.push_back(std::move(surf));
     }
 
     // check consistency (no free surfaces)
     EXPECT_EQ(acceleration_policy->get_surface_count(key), surface_count);
-    EXPECT_EQ(0, acceleration_policy->get_free_surface_count(key));
+    EXPECT_TRUE(0 == acceleration_policy->get_free_surface_count(key));
 
     // fail consume non-free surfaces
     for (size_t i = 0; i < surface_count; i++) {
@@ -400,7 +401,7 @@ TEST(OneVPL_Source_CPU_Accelerator, PoolProduceConsume)
 
     // release surfaces
     for (auto& surf : surfaces) {
-        EXPECT_EQ(1, surf->release_lock());
+        EXPECT_TRUE(1 == surf->release_lock());
     }
     surfaces.clear();
 
@@ -412,7 +413,7 @@ TEST(OneVPL_Source_CPU_Accelerator, PoolProduceConsume)
     for (size_t i = 0; i < surface_count; i++) {
         std::shared_ptr<Surface> surf = acceleration_policy->get_free_surface(key).lock();
         EXPECT_TRUE(surf.get() != nullptr);
-        EXPECT_EQ(0, surf->obtain_lock());
+        EXPECT_TRUE(0 == surf->obtain_lock());
     }
 }
 
@@ -444,7 +445,7 @@ TEST(OneVPL_Source_CPU_Accelerator, PoolProduceConcurrentConsume)
     for (size_t i = 0; i < surface_count; i++) {
         std::shared_ptr<Surface> surf = acceleration_policy->get_free_surface(key).lock();
         EXPECT_TRUE(surf.get() != nullptr);
-        EXPECT_EQ(0, surf->obtain_lock());
+        EXPECT_TRUE(0 == surf->obtain_lock());
         surfaces.push_back(std::move(surf));
     }
 
@@ -458,7 +459,7 @@ TEST(OneVPL_Source_CPU_Accelerator, PoolProduceConcurrentConsume)
         // concurrent release surfaces
         size_t surfaces_count = surfaces.size();
         for (auto& surf : surfaces) {
-            EXPECT_EQ(1, surf->release_lock());
+            EXPECT_TRUE(1 == surf->release_lock());
             std::this_thread::sleep_for(std::chrono::seconds(1));
         }
         surfaces.clear();
@@ -492,7 +493,7 @@ TEST(OneVPL_Source_ProcessingEngine, Init)
     mfxSession mfx_session{};
     engine.initialize_session(mfx_session, {}, std::shared_ptr<IDataProvider>{});
 
-    EXPECT_EQ(0, engine.get_ready_frames_count());
+    EXPECT_TRUE(0 == engine.get_ready_frames_count());
     ProcessingEngineBase::ExecutionStatus ret = engine.process(mfx_session);
     EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::Continue);
     EXPECT_EQ(0, engine.pipeline_stage_num);
@@ -508,12 +509,12 @@ TEST(OneVPL_Source_ProcessingEngine, Init)
     ret = engine.process(mfx_session);
     EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::Processed);
     EXPECT_EQ(3, engine.pipeline_stage_num);
-    EXPECT_EQ(1, engine.get_ready_frames_count());
+    EXPECT_TRUE(1 == engine.get_ready_frames_count());
 
     ret = engine.process(mfx_session);
     EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::SessionNotFound);
     EXPECT_EQ(3, engine.pipeline_stage_num);
-    EXPECT_EQ(1, engine.get_ready_frames_count());
+    EXPECT_TRUE(1 == engine.get_ready_frames_count());
 
     cv::gapi::wip::Data frame;
     engine.get_frame(frame);
@@ -603,7 +604,98 @@ TEST(OneVPL_Source_DX11_Accel, Init)
     MFXClose(mfx_session);
     MFXUnload(test_mfx_handle);
 }
+#endif // HAVE_DIRECTX
+#endif // HAVE_D3D11
 
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+TEST(OneVPL_Source_VAAPI_Accel, Init)
+{
+    using namespace cv::gapi::wip::onevpl;
+
+    std::vector<CfgParam> cfg_params_w_vaapi;
+    cfg_params_w_vaapi.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_VAAPI));
+    VPLVAAPIAccelerationPolicy accel(std::make_shared<CfgParamDeviceSelector>(cfg_params_w_vaapi));
+
+    mfxLoader test_mfx_handle = MFXLoad();
+
+    mfxConfig cfg_inst_0 = MFXCreateConfig(test_mfx_handle);
+    EXPECT_TRUE(cfg_inst_0);
+    mfxVariant mfx_param_0;
+    mfx_param_0.Type = MFX_VARIANT_TYPE_U32;
+    mfx_param_0.Data.U32 = MFX_IMPL_TYPE_HARDWARE;
+    EXPECT_EQ(MFXSetConfigFilterProperty(cfg_inst_0,(mfxU8 *)CfgParam::implementation_name(),
+                                                    mfx_param_0), MFX_ERR_NONE);
+
+    mfxConfig cfg_inst_1 = MFXCreateConfig(test_mfx_handle);
+    EXPECT_TRUE(cfg_inst_1);
+    mfxVariant mfx_param_1;
+    mfx_param_1.Type = MFX_VARIANT_TYPE_U32;
+    mfx_param_1.Data.U32 = MFX_ACCEL_MODE_VIA_VAAPI;
+    EXPECT_EQ(MFXSetConfigFilterProperty(cfg_inst_1,(mfxU8 *)CfgParam::acceleration_mode_name(),
+                                                    mfx_param_1), MFX_ERR_NONE);
+
+    mfxConfig cfg_inst_2 = MFXCreateConfig(test_mfx_handle);
+    EXPECT_TRUE(cfg_inst_2);
+    mfxVariant mfx_param_2;
+    mfx_param_2.Type = MFX_VARIANT_TYPE_U32;
+    mfx_param_2.Data.U32 = MFX_CODEC_HEVC;
+    EXPECT_EQ(MFXSetConfigFilterProperty(cfg_inst_2,(mfxU8 *)CfgParam::decoder_id_name(),
+                                                    mfx_param_2), MFX_ERR_NONE);
+
+    // create session
+    mfxSession mfx_session{};
+    mfxStatus sts = MFXCreateSession(test_mfx_handle, 0, &mfx_session);
+    EXPECT_EQ(MFX_ERR_NONE, sts);
+
+    // assign acceleration
+    EXPECT_NO_THROW(accel.init(mfx_session));
+
+    // create proper bitstream
+    mfxBitstream bitstream{};
+    const int BITSTREAM_BUFFER_SIZE = 2000000;
+    bitstream.MaxLength = BITSTREAM_BUFFER_SIZE;
+    bitstream.Data = (mfxU8 *)calloc(bitstream.MaxLength, sizeof(mfxU8));
+    EXPECT_TRUE(bitstream.Data);
+
+    // simulate read stream
+    bitstream.DataOffset = 0;
+    bitstream.DataLength = sizeof(streaming::onevpl::hevc_header) * sizeof(streaming::onevpl::hevc_header[0]);
+    memcpy(bitstream.Data, streaming::onevpl::hevc_header, bitstream.DataLength);
+    bitstream.CodecId = MFX_CODEC_HEVC;
+
+    // prepare dec params
+    mfxVideoParam mfxDecParams {};
+    mfxDecParams.mfx.CodecId = bitstream.CodecId;
+    mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
+    sts = MFXVideoDECODE_DecodeHeader(mfx_session, &bitstream, &mfxDecParams);
+    EXPECT_EQ(MFX_ERR_NONE, sts);
+
+    mfxFrameAllocRequest request{};
+    memset(&request, 0, sizeof(request));
+    sts = MFXVideoDECODE_QueryIOSurf(mfx_session, &mfxDecParams, &request);
+    EXPECT_EQ(MFX_ERR_NONE, sts);
+
+    // Allocate surfaces for decoder
+    VPLAccelerationPolicy::pool_key_t key = accel.create_surface_pool(request,
+                                                                      mfxDecParams.mfx.FrameInfo);
+    auto cand_surface = accel.get_free_surface(key).lock();
+
+    sts = MFXVideoDECODE_Init(mfx_session, &mfxDecParams);
+    EXPECT_EQ(MFX_ERR_NONE, sts);
+
+    MFXVideoDECODE_Close(mfx_session);
+    EXPECT_EQ(MFX_ERR_NONE, sts);
+
+    EXPECT_NO_THROW(accel.deinit(mfx_session));
+    MFXClose(mfx_session);
+    MFXUnload(test_mfx_handle);
+}
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // __linux__
+
+#ifdef HAVE_DIRECTX
+#ifdef HAVE_D3D11
 TEST(OneVPL_Source_DX11_Accel_VPL, Init)
 {
     using namespace cv::gapi::wip::onevpl;
@@ -1024,8 +1116,6 @@ TEST(OneVPL_Source_DX11_Accel_VPL, preproc)
         }
     } while(frame_num < min_available_frames_count);
 }
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
 
 TEST(OneVPL_Source_DX11_FrameLockable, LockUnlock_without_Adaptee)
 {
@@ -1114,6 +1204,8 @@ TEST(OneVPL_Source_DX11_FrameLockable, LockUnlock_with_Adaptee)
     EXPECT_EQ(w_lock_counter, exec_count);
     EXPECT_EQ(w_unlock_counter, exec_count);
 }
+#endif // HAVE_DIRECTX
+#endif // HAVE_D3D11
 }
 } // namespace opencv_test
 #endif // HAVE_ONEVPL

modules/gapi/test/streaming/gapi_streaming_vpl_data_provider.cpp

@@ -16,6 +16,7 @@
 #include "streaming/onevpl/demux/async_mfp_demux_data_provider.hpp"
 #include "streaming/onevpl/source_priv.hpp"
 
+#ifdef _WIN32
 namespace opencv_test
 {
 namespace
@@ -299,4 +300,5 @@ TEST(OneVPL_Source_MFPAsyncDemux, produce_consume) {
 }
 } // namespace opencv_test
 
+#endif // _WIN32
 #endif // HAVE_ONEVPL

modules/gapi/test/streaming/gapi_streaming_vpl_device_selector.cpp

@@ -29,6 +29,16 @@
 #endif // HAVE_D3D11
 #endif // HAVE_DIRECTX
 
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#include "va/va.h"
+#include "va/va_drm.h"
+
+#include <fcntl.h>
+#include <unistd.h>
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // __linux__
+
 #ifdef HAVE_ONEVPL
 #include "streaming/onevpl/onevpl_export.hpp"
 #include "streaming/onevpl/cfg_param_device_selector.hpp"
@@ -69,11 +79,11 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDevice)
     using namespace cv::gapi::wip::onevpl;
     CfgParamDeviceSelector selector;
     IDeviceSelector::DeviceScoreTable devs = selector.select_devices();
-    EXPECT_EQ(devs.size(), 1);
+    EXPECT_TRUE(devs.size() == 1);
     test_host_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority);
 
     IDeviceSelector::DeviceContexts ctxs = selector.select_context();
-    EXPECT_EQ(ctxs.size(), 1);
+    EXPECT_TRUE(ctxs.size() == 1);
     test_host_ctx_eq(*ctxs.begin());
 }
 
@@ -83,10 +93,10 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDeviceWithEmptyCfgParam)
     std::vector<CfgParam> empty_params;
     CfgParamDeviceSelector selector(empty_params);
     IDeviceSelector::DeviceScoreTable devs = selector.select_devices();
-    EXPECT_EQ(devs.size(), 1);
+    EXPECT_TRUE(devs.size() == 1);
     test_host_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority);
     IDeviceSelector::DeviceContexts ctxs = selector.select_context();
-    EXPECT_EQ(ctxs.size(), 1);
+    EXPECT_TRUE(ctxs.size() == 1);
     test_host_ctx_eq(*ctxs.begin());
 }
 
@@ -97,11 +107,11 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDeviceWithAccelNACfgParam)
     cfg_params_w_no_accel.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_NA));
     CfgParamDeviceSelector selector(cfg_params_w_no_accel);
     IDeviceSelector::DeviceScoreTable devs = selector.select_devices();
-    EXPECT_EQ(devs.size(), 1);
+    EXPECT_TRUE(devs.size() == 1);
     test_host_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority);
 
     IDeviceSelector::DeviceContexts ctxs = selector.select_context();
-    EXPECT_EQ(ctxs.size(), 1);
+    EXPECT_TRUE(ctxs.size() == 1);
     test_host_ctx_eq(*ctxs.begin());
 }
 
@@ -113,11 +123,11 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDeviceWithEmptyCfgParam_DX11
     std::vector<CfgParam> empty_params;
     CfgParamDeviceSelector selector(empty_params);
     IDeviceSelector::DeviceScoreTable devs = selector.select_devices();
-    EXPECT_EQ(devs.size(), 1);
+    EXPECT_TRUE(devs.size() == 1);
     test_host_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority);
 
     IDeviceSelector::DeviceContexts ctxs = selector.select_context();
-    EXPECT_EQ(ctxs.size(), 1);
+    EXPECT_TRUE(ctxs.size() == 1);
     test_host_ctx_eq(*ctxs.begin());
 }
 
@@ -130,13 +140,13 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDeviceWithDX11AccelCfgParam_
     EXPECT_NO_THROW(selector_ptr.reset(new CfgParamDeviceSelector(cfg_params_w_dx11)));
     IDeviceSelector::DeviceScoreTable devs = selector_ptr->select_devices();
 
-    EXPECT_EQ(devs.size(), 1);
+    EXPECT_TRUE(devs.size() == 1);
     test_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority,
                 AccelType::DX11,
                 std::get<1>(*devs.begin()).get_ptr() /* compare just type */);
 
     IDeviceSelector::DeviceContexts ctxs = selector_ptr->select_context();
-    EXPECT_EQ(ctxs.size(), 1);
+    EXPECT_TRUE(ctxs.size() == 1);
     EXPECT_TRUE(ctxs.begin()->get_ptr());
 }
 
@@ -182,12 +192,12 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, ExternalDeviceWithDX11AccelCfgParam
                                                                   cfg_params_w_dx11)));
     IDeviceSelector::DeviceScoreTable devs = selector_ptr->select_devices();
 
-    EXPECT_EQ(devs.size(), 1);
+    EXPECT_TRUE(devs.size() == 1);
     test_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority,
                 AccelType::DX11, device);
 
     IDeviceSelector::DeviceContexts ctxs = selector_ptr->select_context();
-    EXPECT_EQ(ctxs.size(), 1);
+    EXPECT_TRUE(ctxs.size() == 1);
     EXPECT_EQ(reinterpret_cast<ID3D11DeviceContext*>(ctxs.begin()->get_ptr()),
               device_context);
 }
@@ -201,13 +211,138 @@ TEST(OneVPL_Source_Device_Selector_CfgParam, DX11DeviceFromCfgParamWithDX11Disab
 {
     using namespace cv::gapi::wip::onevpl;
     std::vector<CfgParam> cfg_params_w_non_existed_dx11;
-    cfg_params_w_not_existed_dx11.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_D3D11));
+    cfg_params_w_non_existed_dx11.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_D3D11));
     EXPECT_THROW(CfgParamDeviceSelector{cfg_params_w_non_existed_dx11},
                  std::logic_error);
 }
 #endif // HAVE_D3D11
 #endif // HAVE_DIRECTX
 
+#ifdef __linux__
+#if defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDeviceWithEmptyCfgParam_VAAPI_ENABLED)
+{
+    using namespace cv::gapi::wip::onevpl;
+    std::vector<CfgParam> empty_params;
+    CfgParamDeviceSelector selector(empty_params);
+    IDeviceSelector::DeviceScoreTable devs = selector.select_devices();
+    EXPECT_TRUE(devs.size() == 1);
+    test_host_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority);
+
+    IDeviceSelector::DeviceContexts ctxs = selector.select_context();
+    EXPECT_TRUE(ctxs.size() == 1);
+    test_host_ctx_eq(*ctxs.begin());
+}
+
+TEST(OneVPL_Source_Device_Selector_CfgParam, DefaultDeviceWithVAAPIAccelCfgParam_VAAPI_ENABLED)
+{
+    using namespace cv::gapi::wip::onevpl;
+    std::vector<CfgParam> cfg_params_w_vaapi;
+    cfg_params_w_vaapi.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_VAAPI));
+    std::unique_ptr<CfgParamDeviceSelector> selector_ptr;
+    EXPECT_NO_THROW(selector_ptr.reset(new CfgParamDeviceSelector(cfg_params_w_vaapi)));
+    IDeviceSelector::DeviceScoreTable devs = selector_ptr->select_devices();
+
+    EXPECT_TRUE(devs.size() == 1);
+    test_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority,
+                AccelType::VAAPI,
+                std::get<1>(*devs.begin()).get_ptr() /* compare just type */);
+
+    IDeviceSelector::DeviceContexts ctxs = selector_ptr->select_context();
+    EXPECT_TRUE(ctxs.size() == 1);
+    EXPECT_FALSE(ctxs.begin()->get_ptr());
+}
+
+TEST(OneVPL_Source_Device_Selector_CfgParam, NULLDeviceWithVAAPIAccelCfgParam_VAAPI_ENABLED)
+{
+    using namespace cv::gapi::wip::onevpl;
+    std::vector<CfgParam> cfg_params_w_vaapi;
+    cfg_params_w_vaapi.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_VAAPI));
+    Device::Ptr empty_device_ptr = nullptr;
+    Context::Ptr empty_ctx_ptr = nullptr;
+    EXPECT_THROW(CfgParamDeviceSelector sel(empty_device_ptr, "GPU",
+                                            empty_ctx_ptr,
+                                            cfg_params_w_vaapi),
+                 std::logic_error); // empty_device_ptr must be invalid
+}
+
+
+TEST(OneVPL_Source_Device_Selector_CfgParam, ExternalDeviceWithVAAPIAccelCfgParam_VAAPI_ENABLED)
+{
+    using namespace cv::gapi::wip::onevpl;
+    VADisplay va_handle = nullptr;
+    struct FileDescriptorRAII {
+        FileDescriptorRAII() :fd (-1) {}
+        ~FileDescriptorRAII() { reset(-1); }
+        void reset(int d) {
+            if (fd != -1) {
+                close(fd);
+            }
+            fd = d;
+        }
+        operator int() { return fd; }
+    private:
+        FileDescriptorRAII(FileDescriptorRAII& src) = delete;
+        FileDescriptorRAII& operator=(FileDescriptorRAII& src) = delete;
+        FileDescriptorRAII(FileDescriptorRAII&& src) = delete;
+        FileDescriptorRAII& operator=(FileDescriptorRAII&& src) = delete;
+        int fd = -1;
+    };
+    static const char *predefined_vaapi_devices_list[] {"/dev/dri/renderD128",
+                                                        "/dev/dri/renderD129",
+                                                        "/dev/dri/card0",
+                                                        "/dev/dri/card1",
+                                                        nullptr};
+
+    FileDescriptorRAII device_fd;
+    for (const char **device_path = predefined_vaapi_devices_list;
+        *device_path != nullptr; device_path++) {
+        device_fd.reset(open(*device_path, O_RDWR));
+        if (device_fd < 0) {
+            continue;
+        }
+        va_handle = vaGetDisplayDRM(device_fd);
+        if (!va_handle) {
+            continue;
+        }
+        int major_version = 0, minor_version = 0;
+        VAStatus status {};
+        status = vaInitialize(va_handle, &major_version, &minor_version);
+        if (VA_STATUS_SUCCESS != status) {
+            close(device_fd);
+            va_handle = nullptr;
+            continue;
+        }
+        break;
+    }
+    EXPECT_TRUE(device_fd != -1);
+    EXPECT_TRUE(va_handle);
+    auto device = cv::util::make_optional(
+                            cv::gapi::wip::onevpl::create_vaapi_device(reinterpret_cast<void*>(va_handle),
+                                                                       "GPU", device_fd));
+    auto device_context = cv::util::make_optional(
+                            cv::gapi::wip::onevpl::create_vaapi_context(nullptr));
+
+    std::unique_ptr<CfgParamDeviceSelector> selector_ptr;
+    std::vector<CfgParam> cfg_params_w_vaapi;
+    cfg_params_w_vaapi.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_VAAPI));
+    EXPECT_NO_THROW(selector_ptr.reset(new CfgParamDeviceSelector(device.value(),
+                                                                  device_context.value(),
+                                                                  cfg_params_w_vaapi)));
+    IDeviceSelector::DeviceScoreTable devs = selector_ptr->select_devices();
+
+    EXPECT_TRUE(devs.size() == 1);
+    test_dev_eq(*devs.begin(), IDeviceSelector::Score::MaxActivePriority,
+                AccelType::VAAPI, device.value().get_ptr());
+
+    IDeviceSelector::DeviceContexts ctxs = selector_ptr->select_context();
+    EXPECT_TRUE(ctxs.size() == 1);
+    EXPECT_EQ(reinterpret_cast<void*>(ctxs.begin()->get_ptr()),
+              device_context.value().get_ptr());
+}
+#endif // defined(HAVE_VA) || defined(HAVE_VA_INTEL)
+#endif // #ifdef __linux__
+
 TEST(OneVPL_Source_Device_Selector_CfgParam, UnknownPtrDeviceFromCfgParam)
 {
     using namespace cv::gapi::wip::onevpl;

modules/gapi/test/streaming/gapi_streaming_vpp_preproc_test.cpp

@@ -40,6 +40,7 @@
 #include "streaming/onevpl/accelerators/surface/dx11_frame_adapter.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_cpu.hpp"
 #include "streaming/onevpl/accelerators/accel_policy_dx11.hpp"
+#include "streaming/onevpl/accelerators/accel_policy_va_api.hpp"
 #include "streaming/onevpl/accelerators/dx11_alloc_resource.hpp"
 #include "streaming/onevpl/accelerators/utils/shared_lock.hpp"
 #define private public
@@ -120,6 +121,28 @@ std::tuple<mfxLoader, mfxConfig> prepare_mfx(int mfx_codec, int mfx_accel_mode)
     return std::make_tuple(mfx, cfg_inst_3);
 }
 
+static std::unique_ptr<cv::gapi::wip::onevpl::VPLAccelerationPolicy>
+create_accel_policy_from_int(int accel,
+                             std::shared_ptr<cv::gapi::wip::onevpl::IDeviceSelector> selector) {
+    using namespace cv::gapi::wip::onevpl;
+    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy;
+    if (accel == MFX_ACCEL_MODE_VIA_D3D11) {
+        decode_accel_policy.reset (new VPLDX11AccelerationPolicy(selector));
+    } else if (accel == MFX_ACCEL_MODE_VIA_VAAPI) {
+        decode_accel_policy.reset (new VPLVAAPIAccelerationPolicy(selector));
+    }
+    EXPECT_TRUE(decode_accel_policy.get());
+    return decode_accel_policy;
+}
+
+static std::unique_ptr<cv::gapi::wip::onevpl::VPLAccelerationPolicy>
+create_accel_policy_from_int(int &accel,
+                             std::vector<cv::gapi::wip::onevpl::CfgParam> &out_cfg_params) {
+    using namespace cv::gapi::wip::onevpl;
+    out_cfg_params.push_back(CfgParam::create_acceleration_mode(accel));
+    return create_accel_policy_from_int(accel, std::make_shared<CfgParamDeviceSelector>(out_cfg_params));
+}
+
 class SafeQueue {
 public:
     void push(cv::MediaFrame&& f) {
@@ -186,26 +209,32 @@ static cv::util::optional<cv::Rect> empty_roi;
 
 class VPPPreprocParams : public ::testing::TestWithParam<preproc_args_t> {};
 
+#if defined(HAVE_DIRECTX) && defined(HAVE_D3D11)
+    #define UT_ACCEL_TYPE MFX_ACCEL_MODE_VIA_D3D11
+#elif __linux__
+    #define UT_ACCEL_TYPE MFX_ACCEL_MODE_VIA_VAAPI
+#else
+    #define UT_ACCEL_TYPE -1
+#endif
+
 preproc_args_t files[] = {
     preproc_args_t {"highgui/video/big_buck_bunny.h264",
-                    MFX_CODEC_AVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_AVC,     UT_ACCEL_TYPE,
                     cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1080}}},
     preproc_args_t {"highgui/video/big_buck_bunny.h265",
-                    MFX_CODEC_HEVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_HEVC,     UT_ACCEL_TYPE,
                     cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1280}}}
 };
 
-#ifdef HAVE_DIRECTX
-#ifdef HAVE_D3D11
-TEST(OneVPL_Source_PreprocEngine, functional_single_thread)
+class OneVPL_PreproEngineTest : public ::testing::TestWithParam<acceleration_t> {};
+TEST_P(OneVPL_PreproEngineTest, functional_single_thread)
 {
     using namespace cv::gapi::wip::onevpl;
     using namespace cv::gapi::wip;
 
-    std::vector<CfgParam> cfg_params_w_dx11;
-    cfg_params_w_dx11.push_back(CfgParam::create_acceleration_mode(MFX_ACCEL_MODE_VIA_D3D11));
-    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy (
-                    new VPLDX11AccelerationPolicy(std::make_shared<CfgParamDeviceSelector>(cfg_params_w_dx11)));
+    int accel_type = GetParam();
+    std::vector<CfgParam> cfg_params_w_accel;
+    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy = create_accel_policy_from_int(accel_type, cfg_params_w_accel);
 
     // create file data provider
     std::string file_path = findDataFile("highgui/video/big_buck_bunny.h265");
@@ -214,7 +243,7 @@ TEST(OneVPL_Source_PreprocEngine, functional_single_thread)
 
     mfxLoader mfx{};
     mfxConfig mfx_cfg{};
-    std::tie(mfx, mfx_cfg) = prepare_mfx(MFX_CODEC_HEVC, MFX_ACCEL_MODE_VIA_D3D11);
+    std::tie(mfx, mfx_cfg) = prepare_mfx(MFX_CODEC_HEVC, accel_type);
 
     // create decode session
     mfxSession mfx_decode_session{};
@@ -225,7 +254,7 @@ TEST(OneVPL_Source_PreprocEngine, functional_single_thread)
     auto device_selector = decode_accel_policy->get_device_selector();
     VPLLegacyDecodeEngine decode_engine(std::move(decode_accel_policy));
     auto sess_ptr = decode_engine.initialize_session(mfx_decode_session,
-                                                     cfg_params_w_dx11,
+                                                     cfg_params_w_accel,
                                                      data_provider);
 
     // simulate net info
@@ -233,8 +262,7 @@ TEST(OneVPL_Source_PreprocEngine, functional_single_thread)
                                          {1920, 1080}};
 
     // create VPP preproc engine
-    VPPPreprocEngine preproc_engine(std::unique_ptr<VPLAccelerationPolicy>{
-                                                new VPLDX11AccelerationPolicy(device_selector)});
+    VPPPreprocEngine preproc_engine(create_accel_policy_from_int(accel_type, device_selector));
 
     // launch pipeline
     // 1) decode frame
@@ -261,7 +289,7 @@ TEST(OneVPL_Source_PreprocEngine, functional_single_thread)
 
     // make test in loop
     bool in_progress = false;
-    size_t frames_processed_count = 1;
+    int frames_processed_count = 1;
     const auto &first_pp_param_value_impl =
         cv::util::get<cv::gapi::wip::onevpl::vpp_pp_params>(first_pp_params.value().value);
     try {
@@ -298,9 +326,12 @@ TEST(OneVPL_Source_PreprocEngine, functional_single_thread)
     ASSERT_NE(frames_processed_count, 1);
 }
 
-void decode_function(cv::gapi::wip::onevpl::VPLLegacyDecodeEngine &decode_engine,
-                     cv::gapi::wip::onevpl::ProcessingEngineBase::session_ptr sess_ptr,
-                     SafeQueue &queue, size_t &decoded_number) {
+INSTANTIATE_TEST_CASE_P(OneVPL_Source_PreprocEngine, OneVPL_PreproEngineTest,
+                        testing::Values(UT_ACCEL_TYPE));
+
+static void decode_function(cv::gapi::wip::onevpl::VPLLegacyDecodeEngine &decode_engine,
+                            cv::gapi::wip::onevpl::ProcessingEngineBase::session_ptr sess_ptr,
+                            SafeQueue &queue, int &decoded_number) {
     // decode first frame
     {
         cv::MediaFrame decoded_frame;
@@ -320,9 +351,9 @@ void decode_function(cv::gapi::wip::onevpl::VPLLegacyDecodeEngine &decode_engine
     queue.push_stop();
 }
 
-void preproc_function(cv::gapi::wip::IPreprocEngine &preproc_engine, SafeQueue&queue,
-                      size_t &preproc_number, const out_frame_info_t &required_frame_param,
-                      const cv::util::optional<cv::Rect> &roi_rect = {}) {
+static void preproc_function(cv::gapi::wip::IPreprocEngine &preproc_engine, SafeQueue&queue,
+                             int &preproc_number, const out_frame_info_t &required_frame_param,
+                             const cv::util::optional<cv::Rect> &roi_rect = {}) {
     using namespace cv::gapi::wip;
     using namespace cv::gapi::wip::onevpl;
     // create preproc session based on frame description & network info
@@ -385,10 +416,11 @@ void preproc_function(cv::gapi::wip::IPreprocEngine &preproc_engine, SafeQueue&q
     ASSERT_NE(preproc_number, 1);
 }
 
-void multi_source_preproc_function(size_t source_num,
-                                   cv::gapi::wip::IPreprocEngine &preproc_engine, SafeQueue&queue,
-                                   size_t &preproc_number, const out_frame_info_t &required_frame_param,
-                                   const cv::util::optional<cv::Rect> &roi_rect = {}) {
+#ifdef __WIN32__
+static void multi_source_preproc_function(size_t source_num,
+                                          cv::gapi::wip::IPreprocEngine &preproc_engine, SafeQueue&queue,
+                                          int &preproc_number, const out_frame_info_t &required_frame_param,
+                                          const cv::util::optional<cv::Rect> &roi_rect = {}) {
     using namespace cv::gapi::wip;
     using namespace cv::gapi::wip::onevpl;
     // create preproc session based on frame description & network info
@@ -450,6 +482,8 @@ void multi_source_preproc_function(size_t source_num,
     ASSERT_FALSE(in_progress);
     ASSERT_NE(preproc_number, 1);
 }
+#endif // __WIN32__
+
 using roi_t = cv::util::optional<cv::Rect>;
 using preproc_roi_args_t = decltype(std::tuple_cat(std::declval<preproc_args_t>(),
                                                    std::declval<std::tuple<roi_t>>()));
@@ -467,10 +501,8 @@ TEST_P(VPPPreprocROIParams, functional_roi_different_threads)
 
     file_path = findDataFile(file_path);
 
-    std::vector<CfgParam> cfg_params_w_dx11;
-    cfg_params_w_dx11.push_back(CfgParam::create_acceleration_mode(accel));
-    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy (
-                    new VPLDX11AccelerationPolicy(std::make_shared<CfgParamDeviceSelector>(cfg_params_w_dx11)));
+    std::vector<CfgParam> cfg_params_w_accel;
+    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy = create_accel_policy_from_int(accel, cfg_params_w_accel);
 
     // create file data provider
     std::shared_ptr<IDataProvider> data_provider(new FileDataProvider(file_path,
@@ -489,17 +521,16 @@ TEST_P(VPPPreprocROIParams, functional_roi_different_threads)
     auto device_selector = decode_accel_policy->get_device_selector();
     VPLLegacyDecodeEngine decode_engine(std::move(decode_accel_policy));
     auto sess_ptr = decode_engine.initialize_session(mfx_decode_session,
-                                                     cfg_params_w_dx11,
+                                                     cfg_params_w_accel,
                                                      data_provider);
 
     // create VPP preproc engine
-    VPPPreprocEngine preproc_engine(std::unique_ptr<VPLAccelerationPolicy>{
-                                                new VPLDX11AccelerationPolicy(device_selector)});
+    VPPPreprocEngine preproc_engine(create_accel_policy_from_int(accel, device_selector));
 
     // launch threads
     SafeQueue queue;
-    size_t decoded_number = 1;
-    size_t preproc_number = 0;
+    int decoded_number = 1;
+    int preproc_number = 0;
 
     std::thread decode_thread(decode_function, std::ref(decode_engine), sess_ptr,
                               std::ref(queue), std::ref(decoded_number));
@@ -515,31 +546,31 @@ TEST_P(VPPPreprocROIParams, functional_roi_different_threads)
 
 preproc_roi_args_t files_w_roi[] = {
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h264",
-                    MFX_CODEC_AVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_AVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1080}}},
                     roi_t{cv::Rect{0,0,50,50}}},
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h264",
-                    MFX_CODEC_AVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_AVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1080}}},
                     roi_t{}},
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h264",
-                    MFX_CODEC_AVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_AVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1080}}},
                     roi_t{cv::Rect{0,0,100,100}}},
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h264",
-                    MFX_CODEC_AVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_AVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1080}}},
                     roi_t{cv::Rect{100,100,200,200}}},
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h265",
-                    MFX_CODEC_HEVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_HEVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1280}}},
                     roi_t{cv::Rect{0,0,100,100}}},
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h265",
-                    MFX_CODEC_HEVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_HEVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1280}}},
                     roi_t{}},
     preproc_roi_args_t {"highgui/video/big_buck_bunny.h265",
-                    MFX_CODEC_HEVC,     MFX_ACCEL_MODE_VIA_D3D11,
+                    MFX_CODEC_HEVC,     UT_ACCEL_TYPE,
                     out_frame_info_t{cv::GFrameDesc {cv::MediaFormat::NV12, {1920, 1280}}},
                     roi_t{cv::Rect{100,100,200,200}}}
 };
@@ -561,12 +592,10 @@ TEST_P(VPPInnerPreprocParams, functional_inner_preproc_size)
 
     file_path = findDataFile(file_path);
 
-    std::vector<CfgParam> cfg_params_w_dx11_vpp;
+    std::vector<CfgParam> cfg_params_w_accel_vpp;
 
     // create accel policy
-    cfg_params_w_dx11_vpp.push_back(CfgParam::create_acceleration_mode(accel));
-    std::unique_ptr<VPLAccelerationPolicy> accel_policy (
-                    new VPLDX11AccelerationPolicy(std::make_shared<CfgParamDeviceSelector>(cfg_params_w_dx11_vpp)));
+    std::unique_ptr<VPLAccelerationPolicy> accel_policy = create_accel_policy_from_int(accel, cfg_params_w_accel_vpp);
 
     // create file data provider
     std::shared_ptr<IDataProvider> data_provider(new FileDataProvider(file_path,
@@ -582,20 +611,20 @@ TEST_P(VPPInnerPreprocParams, functional_inner_preproc_size)
     EXPECT_EQ(MFX_ERR_NONE, sts);
 
     // fill vpp params beforehand: resolution
-    cfg_params_w_dx11_vpp.push_back(CfgParam::create_vpp_out_width(
+    cfg_params_w_accel_vpp.push_back(CfgParam::create_vpp_out_width(
                                         static_cast<uint16_t>(required_frame_param.size.width)));
-    cfg_params_w_dx11_vpp.push_back(CfgParam::create_vpp_out_height(
+    cfg_params_w_accel_vpp.push_back(CfgParam::create_vpp_out_height(
                                         static_cast<uint16_t>(required_frame_param.size.height)));
 
     // create transcode engine
     auto device_selector = accel_policy->get_device_selector();
     VPLLegacyTranscodeEngine engine(std::move(accel_policy));
     auto sess_ptr = engine.initialize_session(mfx_decode_session,
-                                              cfg_params_w_dx11_vpp,
+                                              cfg_params_w_accel_vpp,
                                               data_provider);
    // make test in loop
     bool in_progress = false;
-    size_t frames_processed_count = 1;
+    int frames_processed_count = 1;
     try {
         while(true) {
             cv::MediaFrame decoded_frame = extract_decoded_frame(sess_ptr->session, engine);
@@ -618,7 +647,8 @@ TEST_P(VPPInnerPreprocParams, functional_inner_preproc_size)
 INSTANTIATE_TEST_CASE_P(OneVPL_Source_PreprocInner, VPPInnerPreprocParams,
                         testing::ValuesIn(files));
 
-// Dispatcher test suite
+// enable only for WIN32 because there are not CPU processing on Linux by default
+#ifdef __WIN32__
 class VPPPreprocDispatcherROIParams : public ::testing::TestWithParam<preproc_roi_args_t> {};
 TEST_P(VPPPreprocDispatcherROIParams, functional_roi_different_threads)
 {
@@ -626,17 +656,15 @@ TEST_P(VPPPreprocDispatcherROIParams, functional_roi_different_threads)
     using namespace cv::gapi::wip::onevpl;
     source_t file_path;
     decoder_t decoder_id;
-    acceleration_t accel = MFX_ACCEL_MODE_VIA_D3D11;
+    acceleration_t accel = 0;
     out_frame_info_t required_frame_param;
     roi_t opt_roi;
-    std::tie(file_path, decoder_id, std::ignore, required_frame_param, opt_roi) = GetParam();
+    std::tie(file_path, decoder_id, accel, required_frame_param, opt_roi) = GetParam();
 
     file_path = findDataFile(file_path);
 
-    std::vector<CfgParam> cfg_params_w_dx11;
-    cfg_params_w_dx11.push_back(CfgParam::create_acceleration_mode(accel));
-    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy (
-                    new VPLDX11AccelerationPolicy(std::make_shared<CfgParamDeviceSelector>(cfg_params_w_dx11)));
+    std::vector<CfgParam> cfg_params_w_accel;
+    std::unique_ptr<VPLAccelerationPolicy> decode_accel_policy = create_accel_policy_from_int(accel, cfg_params_w_accel);
 
     // create file data provider
     std::shared_ptr<IDataProvider> data_provider(new FileDataProvider(file_path,
@@ -661,7 +689,7 @@ TEST_P(VPPPreprocDispatcherROIParams, functional_roi_different_threads)
     auto device_selector = decode_accel_policy->get_device_selector();
     VPLLegacyDecodeEngine decode_engine(std::move(decode_accel_policy));
     auto sess_ptr = decode_engine.initialize_session(mfx_decode_session,
-                                                     cfg_params_w_dx11,
+                                                     cfg_params_w_accel,
                                                      data_provider);
     std::vector<CfgParam> cfg_params_cpu;
     auto cpu_device_selector = std::make_shared<CfgParamDeviceSelector>(cfg_params_cpu);
@@ -673,16 +701,15 @@ TEST_P(VPPPreprocDispatcherROIParams, functional_roi_different_threads)
 
     // create VPP preproc engines
     VPPPreprocDispatcher preproc_dispatcher;
-    preproc_dispatcher.insert_worker<VPPPreprocEngine>(std::unique_ptr<VPLAccelerationPolicy>{
-                                                            new VPLDX11AccelerationPolicy(device_selector)});
+    preproc_dispatcher.insert_worker<VPPPreprocEngine>(create_accel_policy_from_int(accel, device_selector));
     preproc_dispatcher.insert_worker<VPPPreprocEngine>(std::unique_ptr<VPLAccelerationPolicy>{
                                                             new VPLCPUAccelerationPolicy(cpu_device_selector)});
 
     // launch threads
     SafeQueue queue;
-    size_t decoded_number = 1;
-    size_t cpu_decoded_number = 1;
-    size_t preproc_number = 0;
+    int decoded_number = 1;
+    int cpu_decoded_number = 1;
+    int preproc_number = 0;
 
     std::thread decode_thread(decode_function, std::ref(decode_engine), sess_ptr,
                               std::ref(queue), std::ref(decoded_number));
@@ -704,7 +731,6 @@ TEST_P(VPPPreprocDispatcherROIParams, functional_roi_different_threads)
 INSTANTIATE_TEST_CASE_P(OneVPL_Source_PreprocDispatcherROI, VPPPreprocDispatcherROIParams,
                         testing::ValuesIn(files_w_roi));
 
-#endif // HAVE_DIRECTX
-#endif // HAVE_D3D11
+#endif // __WIN32__
 } // namespace opencv_test
 #endif // HAVE_ONEVPL