Merge pull request #19107 from TolyaTalamanov:at/hotfix-gstreamingbackend

[G-API] GStreamingBackend hotfix

* GStreamingBackend hotfix

* Fix comments to review

* Add strides

* Removew while loop inside actor

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

@@ -13,8 +13,7 @@ namespace cv {
 namespace gapi {
 namespace streaming {
 
-cv::gapi::GKernelPackage kernels();
+GAPI_EXPORTS cv::gapi::GKernelPackage kernels();
-cv::gapi::GBackend backend();
 
 // FIXME: Make a generic kernel
 G_API_OP(GCopy, <GFrame(GFrame)>, "org.opencv.streaming.copy")

modules/gapi/src/backends/common/gbackend.hpp

@@ -58,6 +58,35 @@ namespace gimpl {
     struct Data;
     struct RcDesc;
 
+    struct GAPI_EXPORTS RMatMediaAdapterBGR final: public cv::RMat::Adapter
+    {
+        explicit RMatMediaAdapterBGR(const cv::MediaFrame& frame) : m_frame(frame) { };
+
+        virtual cv::RMat::View access(cv::RMat::Access a) override
+        {
+            auto view = m_frame.access(a == cv::RMat::Access::W ? cv::MediaFrame::Access::W
+                                                                : cv::MediaFrame::Access::R);
+            auto ptr = reinterpret_cast<uchar*>(view.ptr[0]);
+            auto stride = view.stride[0];
+
+            std::shared_ptr<cv::MediaFrame::View> view_ptr =
+                std::make_shared<cv::MediaFrame::View>(std::move(view));
+            auto callback = [view_ptr]() mutable { view_ptr.reset(); };
+
+            return cv::RMat::View(desc(), ptr, stride, callback);
+        }
+
+        virtual cv::GMatDesc desc() const override
+        {
+            const auto& desc = m_frame.desc();
+            GAPI_Assert(desc.fmt == cv::MediaFormat::BGR);
+            return cv::GMatDesc{CV_8U, 3, desc.size};
+        }
+
+        cv::MediaFrame m_frame;
+    };
+
+
 namespace magazine {
     template<typename... Ts> struct Class
     {

modules/gapi/src/backends/streaming/gstreamingbackend.cpp

@@ -55,6 +55,7 @@ class GStreamingIntrinExecutable final: public cv::gimpl::GIslandExecutable
 
 public:
     GStreamingIntrinExecutable(const ade::Graph                   &,
+                               const cv::GCompileArgs             &,
                                const std::vector<ade::NodeHandle> &);
 
     const ade::Graph& m_g;
@@ -80,10 +81,10 @@ class GStreamingBackendImpl final: public cv::gapi::GBackend::Priv
     }
 
     virtual EPtr compile(const ade::Graph &graph,
-                         const cv::GCompileArgs &,
+                         const cv::GCompileArgs &args,
                          const std::vector<ade::NodeHandle> &nodes) const override
     {
-        return EPtr{new GStreamingIntrinExecutable(graph, nodes)};
+        return EPtr{new GStreamingIntrinExecutable(graph, args, nodes)};
     }
 
     virtual bool controlsMerge() const override
@@ -101,6 +102,7 @@ class GStreamingBackendImpl final: public cv::gapi::GBackend::Priv
 };
 
 GStreamingIntrinExecutable::GStreamingIntrinExecutable(const ade::Graph& g,
+                                                       const cv::GCompileArgs& args,
                                                        const std::vector<ade::NodeHandle>& nodes)
     : m_g(g), m_gm(m_g)
 {
@@ -114,7 +116,7 @@ GStreamingIntrinExecutable::GStreamingIntrinExecutable(const ade::Graph& g,
     GAPI_Assert(it != nodes.end() && "No operators found for this island?!");
 
     ConstStreamingGraph cag(m_g);
-    m_actor = cag.metadata(*it).get<StreamingCreateFunction>().createActorFunction();
+    m_actor = cag.metadata(*it).get<StreamingCreateFunction>().createActorFunction(args);
 
     // Ensure this the only op in the graph
     if (std::any_of(it+1, nodes.end(), is_op))
@@ -141,63 +143,57 @@ cv::gapi::GKernelPackage cv::gapi::streaming::kernels()
 void cv::gimpl::Copy::Actor::run(cv::gimpl::GIslandExecutable::IInput  &in,
                                  cv::gimpl::GIslandExecutable::IOutput &out)
 {
-    while (true)
+    const auto in_msg = in.get();
+    if (cv::util::holds_alternative<cv::gimpl::EndOfStream>(in_msg))
     {
-        const auto in_msg = in.get();
+        out.post(cv::gimpl::EndOfStream{});
-        if (cv::util::holds_alternative<cv::gimpl::EndOfStream>(in_msg))
+        return;
-        {
-            out.post(cv::gimpl::EndOfStream{});
-            return;
-        }
-
-        const cv::GRunArgs &in_args = cv::util::get<cv::GRunArgs>(in_msg);
-        GAPI_Assert(in_args.size() == 1u);
-
-        cv::GRunArgP out_arg = out.get(0);
-        *cv::util::get<cv::MediaFrame*>(out_arg) = cv::util::get<cv::MediaFrame>(in_args[0]);
-        out.post(std::move(out_arg));
     }
+
+    const cv::GRunArgs &in_args = cv::util::get<cv::GRunArgs>(in_msg);
+    GAPI_Assert(in_args.size() == 1u);
+
+    cv::GRunArgP out_arg = out.get(0);
+    *cv::util::get<cv::MediaFrame*>(out_arg) = cv::util::get<cv::MediaFrame>(in_args[0]);
+    out.post(std::move(out_arg));
 }
 
 void cv::gimpl::BGR::Actor::run(cv::gimpl::GIslandExecutable::IInput  &in,
                                 cv::gimpl::GIslandExecutable::IOutput &out)
 {
-    while (true)
+    const auto in_msg = in.get();
+    if (cv::util::holds_alternative<cv::gimpl::EndOfStream>(in_msg))
     {
-        const auto in_msg = in.get();
+        out.post(cv::gimpl::EndOfStream{});
-        if (cv::util::holds_alternative<cv::gimpl::EndOfStream>(in_msg))
+        return;
-        {
+    }
-            out.post(cv::gimpl::EndOfStream{});
+
-            return;
+    const cv::GRunArgs &in_args = cv::util::get<cv::GRunArgs>(in_msg);
-        }
+    GAPI_Assert(in_args.size() == 1u);
-
+
-        const cv::GRunArgs &in_args = cv::util::get<cv::GRunArgs>(in_msg);
+    cv::GRunArgP out_arg = out.get(0);
-        GAPI_Assert(in_args.size() == 1u);
+    auto frame = cv::util::get<cv::MediaFrame>(in_args[0]);
-
+    const auto& desc = frame.desc();
-        cv::GRunArgP out_arg = out.get(0);
+
-        auto frame = cv::util::get<cv::MediaFrame>(in_args[0]);
+    auto& rmat = *cv::util::get<cv::RMat*>(out_arg);
-        const auto& desc = frame.desc();
+    switch (desc.fmt)
-
+    {
-        auto& rmat = *cv::util::get<cv::RMat*>(out_arg);
+        case cv::MediaFormat::BGR:
-        switch (desc.fmt)
+            rmat = cv::make_rmat<cv::gimpl::RMatMediaAdapterBGR>(frame);
-        {
+            break;
-            case cv::MediaFormat::BGR:
+        case cv::MediaFormat::NV12:
-                rmat = cv::make_rmat<cv::gimpl::RMatMediaBGRAdapter>(frame);
-                break;
-            case cv::MediaFormat::NV12:
             {
                 cv::Mat bgr;
                 auto view = frame.access(cv::MediaFrame::Access::R);
-                cv::Mat y_plane (desc.size,     CV_8UC1, view.ptr[0]);
+                cv::Mat y_plane (desc.size,     CV_8UC1, view.ptr[0], view.stride[0]);
-                cv::Mat uv_plane(desc.size / 2, CV_8UC2, view.ptr[1]);
+                cv::Mat uv_plane(desc.size / 2, CV_8UC2, view.ptr[1], view.stride[1]);
                 cv::cvtColorTwoPlane(y_plane, uv_plane, bgr, cv::COLOR_YUV2BGR_NV12);
                 rmat = cv::make_rmat<cv::gimpl::RMatAdapter>(bgr);
                 break;
             }
-            default:
+        default:
-                cv::util::throw_error(
+            cv::util::throw_error(
-                        std::logic_error("Unsupported MediaFormat for cv::gapi::streaming::BGR"));
+                    std::logic_error("Unsupported MediaFormat for cv::gapi::streaming::BGR"));
-        }
-        out.post(std::move(out_arg));
     }
+    out.post(std::move(out_arg));
 }

modules/gapi/src/backends/streaming/gstreamingbackend.hpp

@@ -14,34 +14,6 @@
 namespace cv {
 namespace gimpl {
 
-struct RMatMediaBGRAdapter final: public cv::RMat::Adapter
-{
-    RMatMediaBGRAdapter(cv::MediaFrame frame) : m_frame(frame) { };
-
-    virtual cv::RMat::View access(cv::RMat::Access a) override
-    {
-        auto view = m_frame.access(a == cv::RMat::Access::W ? cv::MediaFrame::Access::W
-                                                            : cv::MediaFrame::Access::R);
-        auto ptr = reinterpret_cast<uchar*>(view.ptr[0]);
-        auto stride = view.stride[0];
-
-        std::shared_ptr<cv::MediaFrame::View> view_ptr =
-            std::make_shared<cv::MediaFrame::View>(std::move(view));
-        auto callback = [view_ptr]() mutable { view_ptr.reset(); };
-
-        return cv::RMat::View(desc(), ptr, stride, callback);
-    }
-
-    virtual cv::GMatDesc desc() const override
-    {
-        const auto& desc = m_frame.desc();
-        GAPI_Assert(desc.fmt == cv::MediaFormat::BGR);
-        return cv::GMatDesc{CV_8U, 3, desc.size};
-    }
-
-    cv::MediaFrame m_frame;
-};
-
 struct Copy: public cv::detail::KernelTag
 {
     using API = cv::gapi::streaming::GCopy;
@@ -51,14 +23,14 @@ struct Copy: public cv::detail::KernelTag
     class Actor final: public cv::gapi::streaming::IActor
     {
         public:
-            explicit Actor() {}
+            explicit Actor(const cv::GCompileArgs&) {}
             virtual void run(cv::gimpl::GIslandExecutable::IInput  &in,
                              cv::gimpl::GIslandExecutable::IOutput &out) override;
     };
 
-    static cv::gapi::streaming::IActor::Ptr create()
+    static cv::gapi::streaming::IActor::Ptr create(const cv::GCompileArgs& args)
     {
-        return cv::gapi::streaming::IActor::Ptr(new Actor());
+        return cv::gapi::streaming::IActor::Ptr(new Actor(args));
     }
 
     static cv::gapi::streaming::GStreamingKernel kernel() { return {&create}; };
@@ -71,14 +43,14 @@ struct BGR: public cv::detail::KernelTag
 
     class Actor final: public cv::gapi::streaming::IActor {
         public:
-            explicit Actor() {}
+            explicit Actor(const cv::GCompileArgs&) {}
             virtual void run(cv::gimpl::GIslandExecutable::IInput &in,
                              cv::gimpl::GIslandExecutable::IOutput&out) override;
     };
 
-    static cv::gapi::streaming::IActor::Ptr create()
+    static cv::gapi::streaming::IActor::Ptr create(const cv::GCompileArgs& args)
     {
-        return cv::gapi::streaming::IActor::Ptr(new Actor());
+        return cv::gapi::streaming::IActor::Ptr(new Actor(args));
     }
     static cv::gapi::streaming::GStreamingKernel kernel() { return {&create}; };
 };

modules/gapi/src/backends/streaming/gstreamingkernel.hpp

@@ -14,6 +14,8 @@ namespace cv {
 namespace gapi {
 namespace streaming {
 
+GAPI_EXPORTS cv::gapi::GBackend backend();
+
 class IActor {
 public:
     using Ptr = std::shared_ptr<IActor>;
@@ -24,7 +26,7 @@ public:
     virtual ~IActor() = default;
 };
 
-using CreateActorFunction = std::function<IActor::Ptr()>;
+using CreateActorFunction = std::function<IActor::Ptr(const cv::GCompileArgs&)>;
 struct GStreamingKernel
 {
     CreateActorFunction createActorFunction;