Merge remote-tracking branch 'upstream/3.4' into merge-3.4

[platform/upstream/opencv.git] / modules / videoio / test / test_camera.cpp

diff --git a/modules/videoio/test/test_camera.cpp b/modules/videoio/test/test_camera.cpp
index e82285a..884390e 100644 (file)
--- a/modules/videoio/test/test_camera.cpp
+++ b/modules/videoio/test/test_camera.cpp
@@ -5,9 +5,10 @@
 // Note: all tests here are DISABLED by default due specific requirements.
 // Don't use #if 0 - these tests should be tested for compilation at least.
 //
-// Usage: opencv_test_videoio --gtest_also_run_disabled_tests --gtest_filter=*VideoIO_Camera*<tested case>*
+// Usage: opencv_test_videoio --gtest_also_run_disabled_tests --gtest_filter=*videoio_camera*<tested case>*
 
 #include "test_precomp.hpp"
+#include <opencv2/core/utils/configuration.private.hpp>
 
 namespace opencv_test { namespace {
 
@@ -59,7 +60,7 @@ static void test_readFrames(/*const*/ VideoCapture& capture, const int N = 100,
     if (lastFrame) *lastFrame = frame.clone();
 }
 
-TEST(DISABLED_VideoIO_Camera, basic)
+TEST(DISABLED_videoio_camera, basic)
 {
     VideoCapture capture(0);
     ASSERT_TRUE(capture.isOpened());
@@ -71,7 +72,7 @@ TEST(DISABLED_VideoIO_Camera, basic)
     capture.release();
 }
 
-TEST(DISABLED_VideoIO_Camera, validate_V4L2_MJPEG)
+TEST(DISABLED_videoio_camera, v4l_read_mjpg)
 {
     VideoCapture capture(CAP_V4L2);
     ASSERT_TRUE(capture.isOpened());
@@ -86,7 +87,21 @@ TEST(DISABLED_VideoIO_Camera, validate_V4L2_MJPEG)
     capture.release();
 }
 
-TEST(DISABLED_VideoIO_Camera, validate_V4L2_FrameSize)
+//Following test if for capture device using PhysConn_Video_SerialDigital as crossbar input pin
+TEST(DISABLED_videoio_camera, channel6)
+{
+    VideoCapture capture(0);
+    ASSERT_TRUE(capture.isOpened());
+    capture.set(CAP_PROP_CHANNEL, 6);
+    std::cout << "Camera 0 via " << capture.getBackendName() << " backend" << std::endl;
+    std::cout << "Frame width: " << capture.get(CAP_PROP_FRAME_WIDTH) << std::endl;
+    std::cout << "     height: " << capture.get(CAP_PROP_FRAME_HEIGHT) << std::endl;
+    std::cout << "Capturing FPS: " << capture.get(CAP_PROP_FPS) << std::endl;
+    test_readFrames(capture);
+    capture.release();
+}
+
+TEST(DISABLED_videoio_camera, v4l_read_framesize)
 {
     VideoCapture capture(CAP_V4L2);
     ASSERT_TRUE(capture.isOpened());
@@ -121,4 +136,79 @@ TEST(DISABLED_VideoIO_Camera, validate_V4L2_FrameSize)
     capture.release();
 }
 
+
+static
+utils::Paths getTestCameras()
+{
+    static utils::Paths cameras = utils::getConfigurationParameterPaths("OPENCV_TEST_CAMERA_LIST");
+    return cameras;
+}
+
+TEST(DISABLED_videoio_camera, waitAny_V4L)
+{
+    auto cameraNames = getTestCameras();
+    if (cameraNames.empty())
+       throw SkipTestException("No list of tested cameras. Use OPENCV_TEST_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);
+    }
+
+    std::vector<size_t> frameFromCamera(cameraNames.size(), 0);
+    {
+        int counter = 0;
+        std::vector<int> cameraReady;
+        do
+        {
+            EXPECT_TRUE(VideoCapture::waitAny(cameras, cameraReady, timeoutNS));
+            EXPECT_FALSE(cameraReady.empty());
+            for (int idx : cameraReady)
+            {
+                //std::cout << "Reading frame from camera: " << idx << std::endl;
+                ASSERT_TRUE(idx >= 0 && (size_t)idx < cameras.size()) << idx;
+                VideoCapture& c = cameras[idx];
+                Mat frame;
+#if 1
+                ASSERT_TRUE(c.retrieve(frame)) << idx;
+#else
+                ASSERT_TRUE(c.read(frame)) << idx;
+#endif
+                EXPECT_EQ(frameSize.width, frame.cols) << idx;
+                EXPECT_EQ(frameSize.height, frame.rows) << idx;
+
+                ++frameFromCamera[idx];
+                ++counter;
+            }
+        }
+        while(counter < totalFrames);
+    }
+
+    for (size_t i = 0; i < cameraNames.size(); ++i)
+    {
+        EXPECT_GT(frameFromCamera[i], (size_t)0) << i;
+    }
+}
+
 }} // namespace