Blame view

3rdparty/opencv-4.5.4/modules/videoio/perf/perf_camera.impl.hpp 2.49 KB
f4334277   Hu Chunming   提交3rdparty
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
  // 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 http://opencv.org/license.html
  
  // Not a standalone header.
  
  #include <opencv2/core/utils/configuration.private.hpp>
  
  namespace opencv_test {
  using namespace perf;
  
  static
  utils::Paths getTestCameras()
  {
      static utils::Paths cameras = utils::getConfigurationParameterPaths("OPENCV_TEST_PERF_CAMERA_LIST");
      return cameras;
  }
  
  PERF_TEST(VideoCapture_Camera, waitAny_V4L)
  {
      auto cameraNames = getTestCameras();
      if (cameraNames.empty())
         throw SkipTestException("No list of tested cameras. Use OPENCV_TEST_PERF_CAMERA_LIST parameter");
  
      const int totalFrames = 50; // number of expected frames (summary for all cameras)
      const int64 timeoutNS = 100 * 1000000;
  
      const Size frameSize(640, 480);
      const int fpsDefaultEven = 30;
      const int fpsDefaultOdd = 15;
  
      std::vector<VideoCapture> cameras;
      for (size_t i = 0; i < cameraNames.size(); ++i)
      {
          const auto& name = cameraNames[i];
          int fps = (int)utils::getConfigurationParameterSizeT(cv::format("OPENCV_TEST_CAMERA%d_FPS", (int)i).c_str(), (i & 1) ? fpsDefaultOdd : fpsDefaultEven);
          std::cout << "Camera[" << i << "] = '" << name << "', fps=" << fps << std::endl;
          VideoCapture cap(name, CAP_V4L);
          ASSERT_TRUE(cap.isOpened()) << name;
          EXPECT_TRUE(cap.set(CAP_PROP_FRAME_WIDTH, frameSize.width)) << name;
          EXPECT_TRUE(cap.set(CAP_PROP_FRAME_HEIGHT, frameSize.height)) << name;
          EXPECT_TRUE(cap.set(CAP_PROP_FPS, fps)) << name;
          //launch cameras
          Mat firstFrame;
          EXPECT_TRUE(cap.read(firstFrame));
          EXPECT_EQ(frameSize.width, firstFrame.cols);
          EXPECT_EQ(frameSize.height, firstFrame.rows);
          cameras.push_back(cap);
      }
  
      TEST_CYCLE()
      {
          int counter = 0;
          std::vector<int> cameraReady;
          do
          {
              EXPECT_TRUE(VideoCapture::waitAny(cameras, cameraReady, timeoutNS));
              EXPECT_FALSE(cameraReady.empty());
              for (int idx : cameraReady)
              {
                  VideoCapture& c = cameras[idx];
                  Mat frame;
                  ASSERT_TRUE(c.retrieve(frame));
                  EXPECT_EQ(frameSize.width, frame.cols);
                  EXPECT_EQ(frameSize.height, frame.rows);
  
                  ++counter;
              }
          }
          while(counter < totalFrames);
      }
  
      SANITY_CHECK_NOTHING();
  }
  
  } // namespace