Merge pull request #16031 from aDanPin:dm/streaming_auto_meta

G-API-NG/Streaming: don't require explicit metadata in compileStreaming()

* First probably working version
Hardcode gose to setSource() :)

* Pre final version of move metadata declaration from compileStreaming() to setSource().

* G-API-NG/Streaming: recovered the existing Streaming functionality

- The auto-meta test is disabling since it crashes.
- Restored .gitignore

* G-API-NG/Streaming: Made the meta-less compileStreaming() work

- Works fine even with OpenCV backend;
- Fluid doesn't support such kind of compilation so far - to be fixed

* G-API-NG/Streaming: Fix Fluid to support meta-less compilation

- Introduced a notion of metadata-sensitive passes and slightly
  refactored GCompiler and GFluidBackend to support that
- Fixed a TwoVideoSourcesFail test on streaming

* Add three smoke streaming tests to gapi_streaming_tests.
All three teste run pipeline with two different input sets
1) SmokeTest_Two_Const_Mats test run pipeline with two const Mats
2) SmokeTest_One_Video_One_Const_Scalar test run pipleline with Mat(video source) and const Scalar
3) SmokeTest_One_Video_One_Const_Vector test run pipeline with Mat(video source) and const Vector
 # Please enter the commit message for your changes. Lines starting

* style fix

* Some review stuff

* Some review stuff

modules/gapi/include/opencv2/gapi/gcomputation.hpp

@@ -410,11 +410,12 @@ public:
      *
      * @param in_metas vector of input metadata configuration. Grab
      * metadata from real data objects (like cv::Mat or cv::Scalar)
-     * using cv::descr_of(), or create it on your own.  @param args
-     * compilation arguments for this compilation process. Compilation
-     * arguments directly affect what kind of executable object would
-     * be produced, e.g. which kernels (and thus, devices) would be
-     * used to execute computation.
+     * using cv::descr_of(), or create it on your own.
+     *
+     * @param args compilation arguments for this compilation
+     * process. Compilation arguments directly affect what kind of
+     * executable object would be produced, e.g. which kernels (and
+     * thus, devices) would be used to execute computation.
      *
      * @return GStreamingCompiled, a streaming-oriented executable
      * computation compiled specifically for the given input
@@ -424,6 +425,27 @@ public:
      */
     GStreamingCompiled compileStreaming(GMetaArgs &&in_metas, GCompileArgs &&args = {});
 
+    /**
+     * @brief Compile the computation for streaming mode.
+     *
+     * This method triggers compilation process and produces a new
+     * GStreamingCompiled object which then can process video stream
+     * data in any format. Underlying mechanisms will be adjusted to
+     * every new input video stream automatically, but please note that
+     * _not all_ existing backends support this (see reshape()).
+     *
+     * @param args compilation arguments for this compilation
+     * process. Compilation arguments directly affect what kind of
+     * executable object would be produced, e.g. which kernels (and
+     * thus, devices) would be used to execute computation.
+     *
+     * @return GStreamingCompiled, a streaming-oriented executable
+     * computation compiled for any input image format.
+     *
+     * @sa @ref gapi_compile_args
+     */
+    GStreamingCompiled compileStreaming(GCompileArgs &&args = {});
+
     // 2. Direct metadata version
     /**
      * @overload

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

@@ -45,31 +45,62 @@ namespace wip {
 class GCaptureSource: public IStreamSource
 {
 public:
-    explicit GCaptureSource(int id) : cap(id) {}
-    explicit GCaptureSource(const std::string &path) : cap(path) {}
+    explicit GCaptureSource(int id) : cap(id) { prep(); }
+    explicit GCaptureSource(const std::string &path) : cap(path) { prep(); }
 
     // TODO: Add more constructor overloads to make it
     // fully compatible with VideoCapture's interface.
 
 protected:
     cv::VideoCapture cap;
+    cv::Mat first;
+    bool first_pulled = false;
+
+    void prep()
+    {
+        // Prepare first frame to report its meta to engine
+        // when needed
+        GAPI_Assert(first.empty());
+        cv::Mat tmp;
+        if (!cap.read(tmp))
+        {
+            GAPI_Assert(false && "Couldn't grab the very first frame");
+        }
+        // NOTE: Some decode/media VideoCapture backends continue
+        // owning the video buffer under cv::Mat so in order to
+        // process it safely in a highly concurrent pipeline, clone()
+        // is the only right way.
+        first = tmp.clone();
+    }
+
     virtual bool pull(cv::gapi::wip::Data &data) override
     {
+        if (!first_pulled)
+        {
+            GAPI_Assert(!first.empty());
+            first_pulled = true;
+            data = first; // no need to clone here since it was cloned already
+            return true;
+        }
+
         if (!cap.isOpened()) return false;
+
         cv::Mat frame;
         if (!cap.read(frame))
         {
             // end-of-stream happened
             return false;
         }
-
-        // NOTE: Some decode/media VideoCapture backends continue
-        // owning the video buffer under cv::Mat so in order to
-        // process it safely in a highly concurrent pipeline, clone()
-        // is the only right way.
+        // Same reason to clone as in prep()
         data = frame.clone();
         return true;
     }
+
+    virtual GMetaArg descr_of() const override
+    {
+        GAPI_Assert(!first.empty());
+        return cv::GMetaArg{cv::descr_of(first)};
+    }
 };
 
 } // namespace wip

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

@@ -7,8 +7,11 @@
 #ifndef OPENCV_GAPI_STREAMING_SOURCE_HPP
 #define OPENCV_GAPI_STREAMING_SOURCE_HPP
 
-#include <memory> // shared_ptr
-#include <type_traits> // is_base_of
+#include <memory>                      // shared_ptr
+#include <type_traits>                 // is_base_of
+
+#include <opencv2/gapi/gmetaarg.hpp>   // GMetaArg
+
 
 namespace cv {
 namespace gapi {
@@ -38,6 +41,7 @@ public:
     using Ptr = std::shared_ptr<IStreamSource>;
     Ptr ptr() { return shared_from_this(); }
     virtual bool pull(Data &data) = 0;
+    virtual GMetaArg descr_of() const = 0;
     virtual ~IStreamSource() = default;
 };