opencv
diff --git a/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions b/‎modules/gapi/CMakeLists.txt
Copy file name to clipboard
+2Lines changed: 2 additions & 0 deletions
diff --git a/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp
Copy file name to clipboard
+56Lines changed: 56 additions & 0 deletions b/‎modules/gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp
Copy file name to clipboard
+56Lines changed: 56 additions & 0 deletions
diff --git a/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+70-25Lines changed: 70 additions & 25 deletions b/‎modules/gapi/samples/onevpl_infer_single_roi.cpp
Copy file name to clipboard
+70-25Lines changed: 70 additions & 25 deletions
diff --git a/‎modules/gapi/src/backends/ie/giebackend.cpp
Copy file name to clipboard
+16-6Lines changed: 16 additions & 6 deletions b/‎modules/gapi/src/backends/ie/giebackend.cpp
Copy file name to clipboard
+16-6Lines changed: 16 additions & 6 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
Copy file name to clipboard
+11-12Lines changed: 11 additions & 12 deletions b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.cpp
Copy file name to clipboard
+11-12Lines changed: 11 additions & 12 deletions
diff --git a/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.hpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion b/‎modules/gapi/src/streaming/onevpl/accelerators/accel_policy_cpu.hpp
Copy file name to clipboard
+1-1Lines changed: 1 addition & 1 deletion
@@ -191,6 +191,8 @@ set(gapi_srcs
     src/streaming/onevpl/engine/processing_engine_base.cpp
     src/streaming/onevpl/engine/decode/decode_engine_legacy.cpp
     src/streaming/onevpl/engine/decode/decode_session.cpp
+    src/streaming/onevpl/engine/transcode/transcode_engine_legacy.cpp
+    src/streaming/onevpl/engine/transcode/transcode_session.cpp
     src/streaming/onevpl/demux/async_mfp_demux_data_provider.cpp
     src/streaming/onevpl/data_provider_dispatcher.cpp
 
 
@@ -110,6 +110,62 @@ struct GAPI_EXPORTS CfgParam {
     static CfgParam create_implementation(uint32_t value);
     static CfgParam create_implementation(const char* value);
 
+
+    static constexpr const char *vpp_frames_pool_size_name() { return "vpp_frames_pool_size"; }
+    static CfgParam create_vpp_frames_pool_size(size_t value);
+
+    static constexpr const char *vpp_in_width_name() { return "vpp.In.Width"; }
+    static CfgParam create_vpp_in_width(uint16_t value);
+
+    static constexpr const char *vpp_in_height_name() { return "vpp.In.Height"; }
+    static CfgParam create_vpp_in_height(uint16_t value);
+
+    static constexpr const char *vpp_in_crop_x_name() { return "vpp.In.CropX"; }
+    static CfgParam create_vpp_in_crop_x(uint16_t value);
+
+    static constexpr const char *vpp_in_crop_y_name() { return "vpp.In.CropY"; }
+    static CfgParam create_vpp_in_crop_y(uint16_t value);
+
+    static constexpr const char *vpp_in_crop_w_name() { return "vpp.In.CropW"; }
+    static CfgParam create_vpp_in_crop_w(uint16_t value);
+
+    static constexpr const char *vpp_in_crop_h_name() { return "vpp.In.CropH"; }
+    static CfgParam create_vpp_in_crop_h(uint16_t value);
+
+
+    static constexpr const char *vpp_out_fourcc_name() { return "vpp.Out.FourCC"; }
+    static CfgParam create_vpp_out_fourcc(uint32_t value);
+
+    static constexpr const char *vpp_out_chroma_format_name() { return "vpp.Out.ChromaFormat"; }
+    static CfgParam create_vpp_out_chroma_format(uint16_t value);
+
+    static constexpr const char *vpp_out_width_name() { return "vpp.Out.Width"; }
+    static CfgParam create_vpp_out_width(uint16_t value);
+
+    static constexpr const char *vpp_out_height_name() { return "vpp.Out.Height"; }
+    static CfgParam create_vpp_out_height(uint16_t value);
+
+    static constexpr const char *vpp_out_crop_x_name() { return "vpp.Out.CropX"; }
+    static CfgParam create_vpp_out_crop_x(uint16_t value);
+
+    static constexpr const char *vpp_out_crop_y_name() { return "vpp.Out.CropY"; }
+    static CfgParam create_vpp_out_crop_y(uint16_t value);
+
+    static constexpr const char *vpp_out_crop_w_name() { return "vpp.Out.CropW"; }
+    static CfgParam create_vpp_out_crop_w(uint16_t value);
+
+    static constexpr const char *vpp_out_crop_h_name() { return "vpp.Out.CropH"; }
+    static CfgParam create_vpp_out_crop_h(uint16_t value);
+
+    static constexpr const char *vpp_out_pic_struct_name() { return "vpp.Out.PicStruct"; }
+    static CfgParam create_vpp_out_pic_struct(uint16_t value);
+
+    static constexpr const char *vpp_out_framerate_n_name() { return "vpp.Out.FrameRateExtN"; }
+    static CfgParam create_vpp_out_framerate_n(uint32_t value);
+
+    static constexpr const char *vpp_out_framerate_d_name() { return "vpp.Out.FrameRateExtD"; }
+    static CfgParam create_vpp_out_framerate_d(uint32_t value);
+
     /**
      * Create generic onevp::GSource configuration parameter.
      *
 
@@ -45,10 +45,15 @@ const std::string keys =
     "{ faced                        | AUTO                                      | Target device for face detection model (e.g. AUTO, GPU, VPU, ...) }"
     "{ cfg_params                   | <prop name>:<value>;<prop name>:<value>   | Semicolon separated list of oneVPL mfxVariants which is used for configuring source (see `MFXSetConfigFilterProperty` by https://spec.oneapi.io/versions/latest/elements/oneVPL/source/index.html) }"
     "{ streaming_queue_capacity     | 1                                         | Streaming executor queue capacity. Calculated automaticaly if 0 }"
-    "{ frames_pool_size             | 0                                         | OneVPL source applies this parameter as preallocated frames pool size}";
-
+    "{ frames_pool_size             | 0                                         | OneVPL source applies this parameter as preallocated frames pool size}"
+    "{ vpp_frames_pool_size         | 0                                         | OneVPL source applies this parameter as preallocated frames pool size for VPP preprocessing results}"
+    "{ source_preproc_enable        | 0                                         | Turn on OneVPL source frame preprocessing using network input description instead of IE plugin preprocessing}";
 
 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();
@@ -123,8 +128,9 @@ using GRect       = cv::GOpaque<cv::Rect>;
 using GSize       = cv::GOpaque<cv::Size>;
 using GPrims      = cv::GArray<cv::gapi::wip::draw::Prim>;
 
-G_API_OP(LocateROI, <GRect(GSize)>, "sample.custom.locate-roi") {
-    static cv::GOpaqueDesc outMeta(const cv::GOpaqueDesc &) {
+G_API_OP(LocateROI, <GRect(GSize, std::reference_wrapper<const std::string>)>, "sample.custom.locate-roi") {
+    static cv::GOpaqueDesc outMeta(const cv::GOpaqueDesc &,
+                                   std::reference_wrapper<const std::string>) {
         return cv::empty_gopaque_desc();
     }
 };
@@ -145,18 +151,30 @@ GAPI_OCV_KERNEL(OCVLocateROI, LocateROI) {
     // but only crops the input image to square (this is
     // the most convenient aspect ratio for detectors to use)
 
-    static void run(const cv::Size& in_size, cv::Rect &out_rect) {
+    static void run(const cv::Size& in_size,
+                    std::reference_wrapper<const std::string> device_id_ref,
+                    cv::Rect &out_rect) {
 
         // Identify the central point & square size (- some padding)
-        const auto center = cv::Point{in_size.width/2, in_size.height/2};
-        auto sqside = std::min(in_size.width, in_size.height);
-
-        // Now build the central square ROI
-        out_rect = cv::Rect{ center.x - sqside/2
-                           , center.y - sqside/2
-                           , sqside
-                           , sqside
-                           };
+        // NB: GPU plugin in InferenceEngine doesn't support ROI at now
+        if (!is_gpu(device_id_ref.get())) {
+            const auto center = cv::Point{in_size.width/2, in_size.height/2};
+            auto sqside = std::min(in_size.width, in_size.height);
+
+            // Now build the central square ROI
+            out_rect = cv::Rect{ center.x - sqside/2
+                                , center.y - sqside/2
+                                , sqside
+                                , sqside
+                                };
+        } else {
+            // use whole frame for GPU device
+            out_rect = cv::Rect{ 0
+                                , 0
+                                , in_size.width
+                                , in_size.height
+                                };
+        }
     }
 };
 
@@ -193,11 +211,14 @@ int main(int argc, char *argv[]) {
     }
 
     // get file name
-    std::string file_path = cmd.get<std::string>("input");
-    const std::string output = cmd.get<std::string>("output");
+    const auto file_path = cmd.get<std::string>("input");
+    const auto output = cmd.get<std::string>("output");
     const auto face_model_path = cmd.get<std::string>("facem");
     const auto streaming_queue_capacity = cmd.get<uint32_t>("streaming_queue_capacity");
-    const auto source_queue_capacity = cmd.get<uint32_t>("frames_pool_size");
+    const auto source_decode_queue_capacity = cmd.get<uint32_t>("frames_pool_size");
+    const auto source_vpp_queue_capacity = cmd.get<uint32_t>("vpp_frames_pool_size");
+    const auto vpl_source_preproc_enable = cmd.get<uint32_t>("source_preproc_enable");
+    const auto device_id = cmd.get<std::string>("faced");
 
     // check ouput file extension
     if (!output.empty()) {
@@ -214,18 +235,26 @@ int main(int argc, char *argv[]) {
     try {
         std::string line;
         while (std::getline(params_list, line, ';')) {
+            if (vpl_source_preproc_enable == 0) {
+                if (line.find("vpp.") != std::string::npos) {
+                    // skip VPP preprocessing primitives if not requested
+                    continue;
+                }
+            }
             source_cfgs.push_back(cfg::create_from_string(line));
         }
     } catch (const std::exception& ex) {
         std::cerr << "Invalid cfg parameter: " << ex.what() << std::endl;
         return -1;
     }
 
-    if (source_queue_capacity != 0) {
-        source_cfgs.push_back(cv::gapi::wip::onevpl::CfgParam::create_frames_pool_size(source_queue_capacity));
+    if (source_decode_queue_capacity != 0) {
+        source_cfgs.push_back(cv::gapi::wip::onevpl::CfgParam::create_frames_pool_size(source_decode_queue_capacity));
+    }
+    if (source_vpp_queue_capacity != 0) {
+        source_cfgs.push_back(cv::gapi::wip::onevpl::CfgParam::create_vpp_frames_pool_size(source_vpp_queue_capacity));
     }
 
-    const std::string& device_id = cmd.get<std::string>("faced");
     auto face_net = cv::gapi::ie::Params<custom::FaceDetector> {
         face_model_path,                 // path to topology IR
         get_weights_path(face_model_path),   // path to weights
@@ -247,7 +276,7 @@ int main(int argc, char *argv[]) {
     auto dx11_dev = createCOMPtrGuard<ID3D11Device>();
     auto dx11_ctx = createCOMPtrGuard<ID3D11DeviceContext>();
 
-    if (device_id.find("GPU") != std::string::npos) {
+    if (is_gpu(device_id)) {
         auto adapter_factory = createCOMPtrGuard<IDXGIFactory>();
         {
             IDXGIFactory* out_factory = nullptr;
@@ -294,11 +323,25 @@ int main(int argc, char *argv[]) {
 #endif // HAVE_D3D11
 #endif // HAVE_DIRECTX
     // set ctx_config for GPU device only - no need in case of CPU device type
-    if (device_id.find("GPU") != std::string::npos) {
+    if (is_gpu(device_id)) {
         InferenceEngine::ParamMap ctx_config({{"CONTEXT_TYPE", "VA_SHARED"},
                                             {"VA_DEVICE", accel_device_ptr} });
 
         face_net.cfgContextParams(ctx_config);
+        face_net.pluginConfig({{"GPU_NV12_TWO_INPUTS", "YES" }});
+
+        std::cout <<"/*******************************************************/\n"
+                    "ATTENTION: GPU Inference Engine preprocessing is not vital as expected!"
+                     " Please consider param \"source_preproc_enable=1\" and specify "
+                     " appropriated media frame transformation using oneVPL::VPP primitives"
+                     " which force onevpl::GSource to produce tranformed media frames."
+                     " For exploring list of supported transformations please find out "
+                     " vpp_* related stuff in"
+                     " gapi/include/opencv2/gapi/streaming/onevpl/cfg_params.hpp"
+                     " Pay attention that to obtain expected result In this case VPP "
+                     " transformation must match network input params."
+                     " Please vote/create issue about exporting network params using GAPI\n"
+                     "/******************************************************/" << std::endl;
     }
 #endif // HAVE_INF_ENGINE
 
@@ -314,7 +357,7 @@ int main(int argc, char *argv[]) {
     // Create source
     cv::Ptr<cv::gapi::wip::IStreamSource> cap;
     try {
-        if (device_id.find("GPU") != std::string::npos) {
+        if (is_gpu(device_id)) {
             cap = cv::gapi::wip::make_onevpl_src(file_path, source_cfgs,
                                                  device_id,
                                                  accel_device_ptr,
@@ -334,7 +377,7 @@ int main(int argc, char *argv[]) {
     // Now build the graph
     cv::GFrame in;
     auto size = cv::gapi::streaming::size(in);
-    auto roi = custom::LocateROI::on(size);
+    auto roi = custom::LocateROI::on(size, std::cref(device_id));
     auto blob = cv::gapi::infer<custom::FaceDetector>(roi, in);
     cv::GArray<cv::Rect> rcs = cv::gapi::parseSSD(blob, size, 0.5f, true, true);
     auto out_frame = cv::gapi::wip::draw::renderFrame(in, custom::BBoxes::on(rcs, roi));
@@ -397,6 +440,8 @@ typename cv::gapi::wip::onevpl::CfgParam create_from_string(const std::string &l
     std::string name = line.substr(0, name_endline_pos);
     std::string value = line.substr(name_endline_pos + 1);
 
-    return cv::gapi::wip::onevpl::CfgParam::create(name, value);
+    return cv::gapi::wip::onevpl::CfgParam::create(name, value,
+                                                   /* vpp params strongly optional */
+                                                   name.find("vpp.") == std::string::npos);
 }
 }
@@ -507,7 +507,6 @@ inline IE::Blob::Ptr extractRemoteBlob(IECallContext& ctx, std::size_t i) {
                 "Remote blob is supported for MediaFrame only");
 
     cv::util::any any_blob_params = ctx.inFrame(i).blobParams();
-    auto ie_core = cv::gimpl::ie::wrap::getCore();
 
     using ParamType = std::pair<InferenceEngine::TensorDesc, InferenceEngine::ParamMap>;
     using NV12ParamType = std::pair<ParamType, ParamType>;
@@ -529,7 +528,6 @@ inline IE::Blob::Ptr extractRemoteBlob(IECallContext& ctx, std::size_t i) {
 #else
     return IE::make_shared_blob<InferenceEngine::NV12Blob>(y_blob, uv_blob);
 #endif
-
 }
 
 inline IE::Blob::Ptr extractBlob(IECallContext& ctx,
@@ -571,6 +569,19 @@ static void setBlob(InferenceEngine::InferRequest& req,
     }
 }
 
+static void setROIBlob(InferenceEngine::InferRequest& req,
+                       const std::string&             layer_name,
+                       const IE::Blob::Ptr&           blob,
+                       const cv::Rect &roi,
+                       const IECallContext&           ctx) {
+    if (ctx.uu.params.device_id.find("GPU") != std::string::npos) {
+        GAPI_LOG_DEBUG(nullptr, "Skip ROI blob creation for device_id: " <<
+                       ctx.uu.params.device_id << ", layer: " << layer_name);
+        setBlob(req, layer_name, blob, ctx);
+    } else {
+        setBlob(req, layer_name, IE::make_shared_blob(blob, toIE(roi)), ctx);
+    }
+}
 } // anonymous namespace
 
 std::vector<InferenceEngine::InferRequest> cv::gimpl::ie::IECompiled::createInferRequests() {
@@ -1125,10 +1136,9 @@ struct InferROI: public cv::detail::KernelTag {
                         // it should be treated as image
                         IE::Blob::Ptr this_blob =
                             extractBlob(*ctx, 1, cv::gapi::ie::TraitAs::IMAGE);
-                        setBlob(req,
-                                *(ctx->uu.params.input_names.begin()),
-                                IE::make_shared_blob(this_blob, toIE(this_roi)),
-                                *ctx);
+                        setROIBlob(req,
+                                   *(ctx->uu.params.input_names.begin()),
+                                   this_blob, this_roi, *ctx);
                         // FIXME: Should it be done by kernel ?
                         // What about to do that in RequestPool ?
                         req.StartAsync();
 
@@ -210,30 +210,29 @@ VPLCPUAccelerationPolicy::create_surface_pool(size_t pool_size, size_t surface_s
 }
 
 VPLCPUAccelerationPolicy::pool_key_t
-VPLCPUAccelerationPolicy::create_surface_pool(const mfxFrameAllocRequest& alloc_request, mfxVideoParam& param) {
+VPLCPUAccelerationPolicy::create_surface_pool(const mfxFrameAllocRequest& alloc_request, mfxFrameInfo& info) {
 
     // External (application) allocation of decode surfaces
     GAPI_LOG_DEBUG(nullptr, "Query mfxFrameAllocRequest.NumFrameSuggested: " << alloc_request.NumFrameSuggested <<
                             ", mfxFrameAllocRequest.Type: " << alloc_request.Type);
 
-    mfxU32 singleSurfaceSize = utils::GetSurfaceSize_(param.mfx.FrameInfo.FourCC,
-                                                      param.mfx.FrameInfo.Width,
-                                                      param.mfx.FrameInfo.Height);
+    mfxU32 singleSurfaceSize = utils::GetSurfaceSize_(info.FourCC,
+                                                      info.Width,
+                                                      info.Height);
     if (!singleSurfaceSize) {
         throw std::runtime_error("Cannot determine surface size for: fourCC: " +
-                                 std::to_string(param.mfx.FrameInfo.FourCC) +
-                                 ", width: " + std::to_string(param.mfx.FrameInfo.Width) +
-                                 ", height: " + std::to_string(param.mfx.FrameInfo.Height));
+                                 std::to_string(info.FourCC) +
+                                 ", width: " + std::to_string(info.Width) +
+                                 ", height: " + std::to_string(info.Height));
     }
 
-    const auto &frameInfo = param.mfx.FrameInfo;
     auto surface_creator =
-            [&frameInfo] (std::shared_ptr<void> out_buf_ptr, size_t out_buf_ptr_offset,
+            [&info] (std::shared_ptr<void> out_buf_ptr, size_t out_buf_ptr_offset,
                           size_t out_buf_size) -> surface_ptr_t {
-                return (frameInfo.FourCC == MFX_FOURCC_RGB4) ?
-                        utils::create_surface_RGB4_(frameInfo, out_buf_ptr, out_buf_ptr_offset,
+                return (info.FourCC == MFX_FOURCC_RGB4) ?
+                        utils::create_surface_RGB4_(info, out_buf_ptr, out_buf_ptr_offset,
                                                     out_buf_size) :
-                        utils::create_surface_other_(frameInfo, out_buf_ptr, out_buf_ptr_offset,
+                        utils::create_surface_other_(info, out_buf_ptr, out_buf_ptr_offset,
                                                      out_buf_size);};
 
     return create_surface_pool(alloc_request.NumFrameSuggested,
 
@@ -32,7 +32,7 @@ struct GAPI_EXPORTS VPLCPUAccelerationPolicy final : public VPLAccelerationPolic
     void init(session_t session) override;
     void deinit(session_t session) override;
     pool_key_t create_surface_pool(size_t pool_size, size_t surface_size_bytes, surface_ptr_ctr_t creator);
-    pool_key_t create_surface_pool(const mfxFrameAllocRequest& alloc_request, mfxVideoParam& param) 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;