opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+12Lines changed: 12 additions & 0 deletions
diff --git a/‎modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp
Copy file name to clipboard
+83Lines changed: 83 additions & 0 deletions b/‎modules/gapi/perf/streaming/gapi_streaming_source_perf_tests.cpp
Copy file name to clipboard
+83Lines changed: 83 additions & 0 deletions
diff --git a/‎modules/gapi/samples/infer_single_roi.cpp
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions b/‎modules/gapi/samples/infer_single_roi.cpp
Copy file name to clipboard
+8Lines changed: 8 additions & 0 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
Copy file name to clipboard
+8-64Lines changed: 8 additions & 64 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
Copy file name to clipboard
+8-64Lines changed: 8 additions & 64 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.hpp
Copy file name to clipboard
+1-6Lines changed: 1 addition & 6 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.hpp
Copy file name to clipboard
+1-6Lines changed: 1 addition & 6 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/surface/surface_pool.cpp
Copy file name to clipboard
+17-3Lines changed: 17 additions & 3 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/surface/surface_pool.cpp
Copy file name to clipboard
+17-3Lines changed: 17 additions & 3 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/surface/surface_pool.hpp
Copy file name to clipboard
+7-2Lines changed: 7 additions & 2 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/surface/surface_pool.hpp
Copy file name to clipboard
+7-2Lines changed: 7 additions & 2 deletions
@@ -297,3 +297,15 @@ if (TARGET example_gapi_onevpl_infer_single_roi)
     ocv_target_include_directories(example_gapi_onevpl_infer_single_roi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS})
   endif()
 endif()
+
+# perf test dependencies postprocessing
+if(HAVE_GAPI_ONEVPL)
+  # NB: TARGET opencv_perf_gapi doesn't exist before `ocv_add_perf_tests`
+  if(TARGET opencv_perf_gapi)
+    ocv_target_compile_definitions(opencv_perf_gapi PRIVATE -DHAVE_ONEVPL)
+    ocv_target_link_libraries(opencv_perf_gapi PRIVATE ${VPL_IMPORTED_TARGETS})
+    if(HAVE_D3D11 AND HAVE_OPENCL)
+        ocv_target_include_directories(opencv_perf_gapi SYSTEM PRIVATE ${OPENCL_INCLUDE_DIRS})
+    endif()
+  endif()
+endif()
@@ -0,0 +1,83 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://opencv.org/license.html.
+//
+// Copyright (C) 2021 Intel Corporation
+
+#ifdef HAVE_ONEVPL
+
+#include "../perf_precomp.hpp"
+#include "../../test/common/gapi_tests_common.hpp"
+#include <opencv2/gapi/streaming/onevpl/source.hpp>
+#include <opencv2/gapi/streaming/cap.hpp>
+
+namespace opencv_test
+{
+using namespace perf;
+
+const std::string files[] = {
+    "highgui/video/big_buck_bunny.h265",
+    "highgui/video/big_buck_bunny.h264",
+};
+
+const std::string codec[] = {
+    "MFX_CODEC_HEVC",
+    "MFX_CODEC_AVC"
+};
+
+using source_t = std::string;
+using codec_t = std::string;
+using source_description_t = std::tuple<source_t, codec_t>;
+
+class OneVPLSourcePerfTest : public TestPerfParams<source_description_t> {};
+class VideoCapSourcePerfTest : public TestPerfParams<source_t> {};
+
+PERF_TEST_P_(OneVPLSourcePerfTest, TestPerformance)
+{
+    using namespace cv::gapi::wip::onevpl;
+
+    const auto params = GetParam();
+    source_t src = findDataFile(get<0>(params));
+    codec_t type = get<1>(params);
+
+    std::vector<CfgParam> cfg_params {
+        CfgParam::create<std::string>("mfxImplDescription.Impl", "MFX_IMPL_TYPE_HARDWARE"),
+        CfgParam::create("mfxImplDescription.mfxDecoderDescription.decoder.CodecID", type),
+    };
+
+    auto source_ptr = cv::gapi::wip::make_onevpl_src(src, cfg_params);
+
+    cv::gapi::wip::Data out;
+    TEST_CYCLE()
+    {
+        source_ptr->pull(out);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+PERF_TEST_P_(VideoCapSourcePerfTest, TestPerformance)
+{
+    using namespace cv::gapi::wip;
+
+    source_t src = findDataFile(GetParam());
+    auto source_ptr = make_src<GCaptureSource>(src);
+    Data out;
+    TEST_CYCLE()
+    {
+        source_ptr->pull(out);
+    }
+
+    SANITY_CHECK_NOTHING();
+}
+
+INSTANTIATE_TEST_CASE_P(Streaming, OneVPLSourcePerfTest,
+                        Values(source_description_t(files[0], codec[0]),
+                               source_description_t(files[1], codec[1])));
+
+INSTANTIATE_TEST_CASE_P(Streaming, VideoCapSourcePerfTest,
+                        Values(files[0],
+                               files[1]));
+} // namespace opencv_test
+
+#endif // HAVE_ONEVPL
@@ -256,9 +256,17 @@ int main(int argc, char *argv[])
     pipeline.start();
 
     cv::Mat out;
+    int framesCount = 0;
+    cv::TickMeter t;
+    t.start();
     while (pipeline.pull(cv::gout(out))) {
         cv::imshow("Out", out);
         cv::waitKey(1);
+        framesCount++;
     }
+    t.stop();
+    std::cout << "Elapsed time: " << t.getTimeSec() << std::endl;
+    std::cout << "FPS: " << framesCount / (t.getTimeSec() ? t.getTimeSec() : 1) << std::endl;
+    std::cout << "framesCount: " << framesCount << std::endl;
     return 0;
 }
@@ -47,9 +47,8 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
                                               surface_ptr_ctr_t creator) {
     GAPI_LOG_DEBUG(nullptr, "pool size: " << pool_size << ", surface size bytes: " << surface_size_bytes);
 
-    // create empty pool
-    pool_t pool;
-    pool.reserve(pool_size);
+    // NB: create empty pool with reservation
+    pool_t pool(pool_size);
 
     // allocate workplace memory area
     size_t preallocated_raw_bytes = pool_size * surface_size_bytes;
@@ -107,7 +106,7 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
 
     // remember pool by key
     GAPI_LOG_INFO(nullptr, "New pool allocated, key: " << preallocated_pool_memory_ptr <<
-                           ", surface count: " << pool.size() <<
+                           ", surface count: " << pool.total_size() <<
                            ", surface size bytes: " << surface_size_bytes);
     if (!pool_table.emplace(preallocated_pool_memory_ptr, std::move(pool)).second) {
         GAPI_LOG_WARNING(nullptr, "Cannot insert pool, table size: " + std::to_string(pool_table.size()) <<
@@ -121,33 +120,13 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
 VPLCPUAccelerationPolicy::surface_weak_ptr_t VPLCPUAccelerationPolicy::get_free_surface(pool_key_t key) {
     auto pool_it = pool_table.find(key);
     if (pool_it == pool_table.end()) {
-        throw std::runtime_error("VPLCPUAccelerationPolicy::get_free_surface - "
-                                 "key is not found, table size: " +
-                                 std::to_string(pool_table.size()));
+        GAPI_LOG_WARNING(nullptr, "key is not found, table size: " <<
+                                  pool_table.size());
+        GAPI_Assert(false && "Invalid surface key requested in VPLCPUAccelerationPolicy");
     }
 
     pool_t& requested_pool = pool_it->second;
-#ifdef TEST_PERF
     return requested_pool.find_free();
-#else // TEST_PERF
-    auto it =
-        std::find_if(requested_pool.begin(), requested_pool.end(),
-                     [](const surface_ptr_t& val) {
-            GAPI_DbgAssert(val && "Pool contains empty surface");
-            return !val->get_locks_count();
-        });
-
-    // Limitation realloc pool might be a future extension
-    if (it == requested_pool.end()) {
-        std::stringstream ss;
-        ss << "cannot get free surface from pool, key: " << key << ", size: " << requested_pool.size();
-        const std::string& str = ss.str();
-        GAPI_LOG_WARNING(nullptr, str);
-        throw std::runtime_error(std::string(__FUNCTION__) + " - " + str);
-    }
-
-    return *it;
-#endif // TEST_PERF
 }
 
 size_t VPLCPUAccelerationPolicy::get_free_surface_count(pool_key_t key) const {
@@ -157,18 +136,8 @@ size_t VPLCPUAccelerationPolicy::get_free_surface_count(pool_key_t key) const {
                                   ", table size: " << pool_table.size());
         return 0;
     }
-#ifdef TEST_PERF
-    return 0;
-#else // TEST_PERF
     const pool_t& requested_pool = pool_it->second;
-    size_t free_surf_count =
-        std::count_if(requested_pool.begin(), requested_pool.end(),
-                     [](const surface_ptr_t& val) {
-            GAPI_Assert(val && "Pool contains empty surface");
-            return !val->get_locks_count();
-        });
-    return free_surf_count;
-#endif // TEST_PERF
+    return requested_pool.available_size();
 }
 
 size_t VPLCPUAccelerationPolicy::get_surface_count(pool_key_t key) const {
@@ -178,11 +147,7 @@ size_t VPLCPUAccelerationPolicy::get_surface_count(pool_key_t key) const {
                                 ", table size: " << pool_table.size());
         return 0;
     }
-#ifdef TEST_PERF
-    return 0;
-#else // TEST_PERF
-    return pool_it->second.size();
-#endif // TEST_PERF
+    return pool_it->second.total_size();
 }
 
 cv::MediaFrame::AdapterPtr VPLCPUAccelerationPolicy::create_frame_adapter(pool_key_t key,
@@ -197,28 +162,7 @@ cv::MediaFrame::AdapterPtr VPLCPUAccelerationPolicy::create_frame_adapter(pool_k
     }
 
     pool_t& requested_pool = pool_it->second;
-#ifdef TEST_PERF
     return cv::MediaFrame::AdapterPtr{new VPLMediaFrameCPUAdapter(requested_pool.find_by_handle(surface))};
-#else // TEST_PERF
-    auto it =
-        std::find_if(requested_pool.begin(), requested_pool.end(),
-                     [surface](const surface_ptr_t& val) {
-            GAPI_DbgAssert(val && "Pool contains empty surface");
-            return val->get_handle() == surface;
-        });
-
-    // Limitation realloc pool might be a future extension
-    if (it == requested_pool.end()) {
-        std::stringstream ss;
-        ss << "cannot get requested surface from pool, key: " << key << ", surf: "
-           << surface << ", pool size: " << requested_pool.size();
-        const std::string& str = ss.str();
-        GAPI_LOG_WARNING(nullptr, str);
-        throw std::runtime_error(std::string(__FUNCTION__) + " - " + str);
-    }
-
-    return cv::MediaFrame::AdapterPtr{new VPLMediaFrameCPUAdapter(*it)};
-#endif // TEST_PERF
 }
 } // namespace onevpl
 } // namespace wip
 
@@ -15,9 +15,7 @@
 #ifdef HAVE_ONEVPL
 #include <vpl/mfxvideo.h>
 #include "streaming/onevpl/accelerators/accel_policy_interface.hpp"
-#ifdef TEST_PERF
 #include "streaming/onevpl/accelerators/surface/surface_pool.hpp"
-#endif // TEST_PERF
 
 namespace cv {
 namespace gapi {
@@ -29,11 +27,8 @@ struct GAPI_EXPORTS VPLCPUAccelerationPolicy final : public VPLAccelerationPolic
 {
     VPLCPUAccelerationPolicy();
     ~VPLCPUAccelerationPolicy();
-#ifdef TEST_PERF
+
     using pool_t = CachedPool;
-#else  // TEST_PERF
-    using pool_t = std::vector<surface_ptr_t>;
-#endif // TEST_PERF
 
     void init(session_t session) override;
     void deinit(session_t session) override;
 
@@ -9,11 +9,15 @@ namespace gapi {
 namespace wip {
 namespace onevpl {
 
+CachedPool::CachedPool(size_t reserved_size/* = 0 */) {
+    reserve(reserved_size);
+}
+
 void CachedPool::reserve(size_t size) {
     surfaces.reserve(size);
 }
 
-size_t CachedPool::size() const {
+size_t CachedPool::total_size() const {
     return surfaces.size();
 }
 
@@ -29,20 +33,30 @@ void CachedPool::push_back(surface_ptr_t &&surf) {
     next_free_it = surfaces.begin();
 }
 
+size_t CachedPool::available_size() const {
+    size_t free_surf_count =
+        std::count_if(surfaces.begin(), surfaces.end(),
+                     [](const surface_ptr_t& val) {
+            GAPI_DbgAssert(val && "Pool contains empty surface");
+            return (val->get_locks_count() == 0);
+        });
+    return free_surf_count;
+}
+
 CachedPool::surface_ptr_t CachedPool::find_free() {
     auto it =
         std::find_if(next_free_it, surfaces.end(),
                      [](const surface_ptr_t& val) {
             GAPI_DbgAssert(val && "Pool contains empty surface");
-            return !val->get_locks_count();
+            return (val->get_locks_count() == 0);
         });
 
     // Limitation realloc pool might be a future extension
     if (it == surfaces.end()) {
         it = std::find_if(surfaces.begin(), next_free_it,
                           [](const surface_ptr_t& val) {
                 GAPI_DbgAssert(val && "Pool contains empty surface");
-                return !val->get_locks_count();
+                return (val->get_locks_count() == 0);
             });
         if (it == next_free_it) {
             std::stringstream ss;
 
@@ -28,13 +28,18 @@ class GAPI_EXPORTS CachedPool {
     using free_surface_iterator_t = typename surface_container_t::iterator;
     using cached_surface_container_t = std::map<mfxFrameSurface1*, surface_ptr_t>;
 
+    explicit CachedPool(size_t reserved_size = 0);
+
     void push_back(surface_ptr_t &&surf);
-    void reserve(size_t size);
-    size_t size() const;
+    size_t total_size() const;
+    size_t available_size() const;
     void clear();
+
     surface_ptr_t find_free();
     surface_ptr_t find_by_handle(mfxFrameSurface1* handle);
 private:
+    void reserve(size_t size);
+
     surface_container_t surfaces;
     free_surface_iterator_t next_free_it;
     cached_surface_container_t cache;