modules/gapi/test/gapi_frame_tests.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4 //
   5 // Copyright (C) 2020 Intel Corporation
   6
   7 #include "test_precomp.hpp"
   8
   9 #include <opencv2/gapi/media.hpp>
  10
  11 ////////////////////////////////////////////////////////////////////////////////
  12 // cv::GFrame tests
  13
  14 namespace opencv_test {
  15
  16 G_API_OP(GBlurFrame, <GMat(GFrame)>, "test.blur_frame") {
  17     static GMatDesc outMeta(GFrameDesc in) {
  18         return cv::GMatDesc(CV_8U,3,in.size);
  19     }
  20 };
  21
  22 GAPI_OCV_KERNEL(OCVBlurFrame, GBlurFrame) {
  23     static void run(const cv::MediaFrame &in, cv::Mat& out) {
  24         GAPI_Assert(in.desc().fmt == cv::MediaFormat::BGR);
  25         cv::MediaFrame::View view = in.access(cv::MediaFrame::Access::R);
  26         cv::blur(cv::Mat(in.desc().size, CV_8UC3, view.ptr[0], view.stride[0]),
  27                  out,
  28                  cv::Size{3,3});
  29     }
  30 };
  31
  32 ////////////////////////////////////////////////////////////////////////////////
  33 // cv::MediaFrame tests
  34 namespace {
  35 class TestMediaBGR final: public cv::MediaFrame::IAdapter {
  36     cv::Mat m_mat;
  37     using Cb = cv::MediaFrame::View::Callback;
  38     Cb m_cb;
  39
  40 public:
  41     explicit TestMediaBGR(cv::Mat m, Cb cb = [](){})
  42         : m_mat(m), m_cb(cb) {
  43     }
  44     cv::GFrameDesc meta() const override {
  45         return cv::GFrameDesc{cv::MediaFormat::BGR, cv::Size(m_mat.cols, m_mat.rows)};
  46     }
  47     cv::MediaFrame::View access(cv::MediaFrame::Access) override {
  48         cv::MediaFrame::View::Ptrs pp = { m_mat.ptr(), nullptr, nullptr, nullptr };
  49         cv::MediaFrame::View::Strides ss = { m_mat.step, 0u, 0u, 0u };
  50         return cv::MediaFrame::View(std::move(pp), std::move(ss), Cb{m_cb});
  51     }
  52 };
  53
  54 class TestMediaNV12 final: public cv::MediaFrame::IAdapter {
  55     cv::Mat m_y;
  56     cv::Mat m_uv;
  57 public:
  58     TestMediaNV12(cv::Mat y, cv::Mat uv) : m_y(y), m_uv(uv) {
  59     }
  60     cv::GFrameDesc meta() const override {
  61         return cv::GFrameDesc{cv::MediaFormat::NV12, cv::Size(m_y.cols, m_y.rows)};
  62     }
  63     cv::MediaFrame::View access(cv::MediaFrame::Access) override {
  64         cv::MediaFrame::View::Ptrs pp = {
  65             m_y.ptr(), m_uv.ptr(), nullptr, nullptr
  66         };
  67         cv::MediaFrame::View::Strides ss = {
  68             m_y.step, m_uv.step, 0u, 0u
  69         };
  70         return cv::MediaFrame::View(std::move(pp), std::move(ss));
  71     }
  72 };
  73 } // anonymous namespace
  74
  75 struct MediaFrame_Test: public ::testing::Test {
  76     using M = cv::Mat;
  77     using MF = cv::MediaFrame;
  78     MF frame;
  79 };
  80
  81 struct MediaFrame_BGR: public MediaFrame_Test {
  82     M bgr;
  83     MediaFrame_BGR()
  84         : bgr(M::eye(240, 320, CV_8UC3)) {
  85         cv::randn(bgr, cv::Scalar::all(127.0f), cv::Scalar::all(40.f));
  86         frame = MF::Create<TestMediaBGR>(bgr);
  87     }
  88 };
  89
  90 TEST_F(MediaFrame_BGR, Meta) {
  91     auto meta = frame.desc();
  92     EXPECT_EQ(cv::MediaFormat::BGR, meta.fmt);
  93     EXPECT_EQ(cv::Size(320,240),    meta.size);
  94 }
  95
  96 TEST_F(MediaFrame_BGR, Access) {
  97     cv::MediaFrame::View view1 = frame.access(cv::MediaFrame::Access::R);
  98     EXPECT_EQ(bgr.ptr(), view1.ptr[0]);
  99     EXPECT_EQ(bgr.step,  view1.stride[0]);
 100
 101     cv::MediaFrame::View view2 = frame.access(cv::MediaFrame::Access::R);
 102     EXPECT_EQ(bgr.ptr(), view2.ptr[0]);
 103     EXPECT_EQ(bgr.step,  view2.stride[0]);
 104 }
 105
 106 TEST_F(MediaFrame_BGR, Input) {
 107     // Run the OpenCV code
 108     cv::Mat out_mat_ocv, out_mat_gapi;
 109     cv::blur(bgr, out_mat_ocv, cv::Size{3,3});
 110
 111     // Run the G-API code
 112     cv::GFrame in;
 113     cv::GMat out = GBlurFrame::on(in);
 114     cv::GComputation(cv::GIn(in), cv::GOut(out))
 115         .apply(cv::gin(frame),
 116                cv::gout(out_mat_gapi),
 117                cv::compile_args(cv::gapi::kernels<OCVBlurFrame>()));
 118
 119     // Compare
 120     EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
 121 }
 122
 123 struct MediaFrame_NV12: public MediaFrame_Test {
 124     cv::Size sz;
 125     cv::Mat buf, y, uv;
 126     MediaFrame_NV12()
 127         : sz {320, 240}
 128         , buf(M::eye(sz.height*3/2, sz.width, CV_8UC1))
 129         , y  (buf.rowRange(0, sz.height))
 130         , uv (buf.rowRange(sz.height, sz.height*3/2)) {
 131         frame = MF::Create<TestMediaNV12>(y, uv);
 132     }
 133 };
 134
 135 TEST_F(MediaFrame_NV12, Meta) {
 136     auto meta = frame.desc();
 137     EXPECT_EQ(cv::MediaFormat::NV12, meta.fmt);
 138     EXPECT_EQ(cv::Size(320,240),     meta.size);
 139 }
 140
 141 TEST_F(MediaFrame_NV12, Access) {
 142     cv::MediaFrame::View view1 = frame.access(cv::MediaFrame::Access::R);
 143     EXPECT_EQ(y. ptr(), view1.ptr   [0]);
 144     EXPECT_EQ(y. step,  view1.stride[0]);
 145     EXPECT_EQ(uv.ptr(), view1.ptr   [1]);
 146     EXPECT_EQ(uv.step,  view1.stride[1]);
 147
 148     cv::MediaFrame::View view2 = frame.access(cv::MediaFrame::Access::R);
 149     EXPECT_EQ(y. ptr(), view2.ptr   [0]);
 150     EXPECT_EQ(y. step,  view2.stride[0]);
 151     EXPECT_EQ(uv.ptr(), view2.ptr   [1]);
 152     EXPECT_EQ(uv.step,  view2.stride[1]);
 153 }
 154
 155 TEST(MediaFrame, Callback) {
 156     int counter = 0;
 157     cv::Mat bgr = cv::Mat::eye(240, 320, CV_8UC3);
 158     cv::MediaFrame frame = cv::MediaFrame::Create<TestMediaBGR>(bgr, [&counter](){counter++;});
 159
 160     // Test that the callback (in this case, incrementing the counter)
 161     // is called only on View destruction.
 162     EXPECT_EQ(0, counter);
 163     {
 164         cv::MediaFrame::View v1 = frame.access(cv::MediaFrame::Access::R);
 165         EXPECT_EQ(0, counter);
 166     }
 167     EXPECT_EQ(1, counter);
 168     {
 169         cv::MediaFrame::View v1 = frame.access(cv::MediaFrame::Access::R);
 170         EXPECT_EQ(1, counter);
 171         cv::MediaFrame::View v2 = frame.access(cv::MediaFrame::Access::W);
 172         EXPECT_EQ(1, counter);
 173     }
 174     EXPECT_EQ(3, counter);
 175 }
 176
 177 } // namespace opencv_test