videoio: backends priority list

modules/videoio/CMakeLists.txt

@@ -20,6 +20,8 @@ set(videoio_hdrs
     ${CMAKE_CURRENT_LIST_DIR}/src/precomp.hpp
     )
 set(videoio_srcs
+    ${CMAKE_CURRENT_LIST_DIR}/src/videoio_registry.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/videoio_c.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/cap.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/cap_images.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/cap_mjpeg_encoder.cpp

modules/videoio/src/cap_mjpeg_encoder.cpp

@@ -1530,8 +1530,11 @@ void MotionJpegWriter::writeFrameData( const uchar* data, int step, int colorspa
 
 }
 
-Ptr<IVideoWriter> createMotionJpegWriter( const String& filename, double fps, Size frameSize, bool iscolor )
+Ptr<IVideoWriter> createMotionJpegWriter(const String& filename, int fourcc, double fps, Size frameSize, bool iscolor)
 {
+    if (fourcc != CV_FOURCC('M', 'J', 'P', 'G'))
+        return Ptr<IVideoWriter>();
+
     Ptr<IVideoWriter> iwriter = makePtr<mjpeg::MotionJpegWriter>(filename, fps, frameSize, iscolor);
     if( !iwriter->isOpened() )
         iwriter.release();

modules/videoio/src/precomp.hpp

@@ -47,6 +47,9 @@
 #include "opencv2/core/utility.hpp"
 #include "opencv2/core/private.hpp"
 
+#include <opencv2/core/utils/configuration.private.hpp>
+#include <opencv2/core/utils/logger.hpp>
+
 #include "opencv2/imgcodecs.hpp"
 
 #include "opencv2/imgproc.hpp"
@@ -59,7 +62,7 @@
 #include <string.h>
 #include <limits.h>
 #include <ctype.h>
-#include <assert.h>
+#include <assert.h>  // FIXIT remove this
 
 #if defined _WIN32 || defined WINCE
     #if !defined _WIN32_WINNT
@@ -178,7 +181,7 @@ namespace cv
     };
 
     Ptr<IVideoCapture> createMotionJpegCapture(const String& filename);
-    Ptr<IVideoWriter> createMotionJpegWriter( const String& filename, double fps, Size frameSize, bool iscolor );
+    Ptr<IVideoWriter> createMotionJpegWriter(const String& filename, int fourcc, double fps, Size frameSize, bool iscolor);
 
     Ptr<IVideoCapture> createGPhoto2Capture(int index);
     Ptr<IVideoCapture> createGPhoto2Capture(const String& deviceName);

modules/videoio/src/videoio_c.cpp

+// 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.
+
+#include "precomp.hpp"
+
+#include "videoio_registry.hpp"
+
+using namespace cv;
+
+// Legacy C-like API
+
+CV_IMPL CvCapture* cvCreateCameraCapture(int index)
+{
+    // interpret preferred interface (0 = autodetect)
+    int apiPreference = (index / 100) * 100;
+    if (apiPreference)
+    {
+        index %= 100;
+    }
+
+    const std::vector<VideoBackendInfo> backends = cv::videoio_registry::getAvailableBackends_CaptureByIndex();
+    for (size_t i = 0; i < backends.size(); i++)
+    {
+        const VideoBackendInfo& info = backends[i];
+        if (apiPreference == CAP_ANY || apiPreference == info.id)
+        {
+            CvCapture* capture = NULL;
+            Ptr<IVideoCapture> icap; // unused
+            VideoCapture_create(capture, icap, info.id, index);
+            if (capture)
+            {
+                return capture;
+            }
+            if (!icap.empty())
+            {
+                CV_LOG_WARNING(NULL, "cvCreateFileCaptureWithPreference: backend " << info.name << " doesn't support legacy API anymore.")
+            }
+        }
+    }
+    return NULL;
+}
+
+CV_IMPL CvCapture* cvCreateFileCaptureWithPreference(const char* filename, int apiPreference)
+{
+    const std::vector<VideoBackendInfo> backends = cv::videoio_registry::getAvailableBackends_CaptureByFilename();
+    for (size_t i = 0; i < backends.size(); i++)
+    {
+        const VideoBackendInfo& info = backends[i];
+        if (apiPreference == CAP_ANY || apiPreference == info.id)
+        {
+            CvCapture* capture = NULL;
+            Ptr<IVideoCapture> icap; // unused
+            VideoCapture_create(capture, icap, info.id, filename);
+            if (capture)
+            {
+                return capture;
+            }
+            if (!icap.empty())
+            {
+                CV_LOG_WARNING(NULL, "cvCreateFileCaptureWithPreference: backend " << info.name << " doesn't support legacy API anymore.")
+            }
+        }
+    }
+    return NULL;
+}
+
+CV_IMPL CvCapture* cvCreateFileCapture(const char * filename)
+{
+    return cvCreateFileCaptureWithPreference(filename, CAP_ANY);
+}
+
+CV_IMPL CvVideoWriter* cvCreateVideoWriter(const char* filename, int fourcc,
+                                           double fps, CvSize frameSize, int is_color)
+{
+    const std::vector<VideoBackendInfo> backends = cv::videoio_registry::getAvailableBackends_Writer();
+    for (size_t i = 0; i < backends.size(); i++)
+    {
+        const VideoBackendInfo& info = backends[i];
+        {
+            CvVideoWriter* writer_ = NULL;
+            Ptr<IVideoWriter> iwriter;  // unused
+            VideoWriter_create(writer_, iwriter, info.id, filename, fourcc, fps, frameSize, is_color != 0);
+            if (writer_)
+            {
+                return writer_;
+            }
+            if (!iwriter.empty())
+            {
+                CV_LOG_WARNING(NULL, "cvCreateVideoWriter: backend " << info.name << " doesn't support legacy API anymore.")
+            }
+        }
+    }
+    return NULL;
+}
+
+CV_IMPL int cvWriteFrame(CvVideoWriter* writer, const IplImage* image)
+{
+    return writer ? writer->writeFrame(image) : 0;
+}
+
+CV_IMPL void cvReleaseVideoWriter(CvVideoWriter** pwriter)
+{
+    if( pwriter && *pwriter )
+    {
+        delete *pwriter;
+        *pwriter = 0;
+    }
+}
+
+CV_IMPL void cvReleaseCapture(CvCapture** pcapture)
+{
+    if (pcapture && *pcapture)
+    {
+        delete *pcapture;
+        *pcapture = 0;
+    }
+}
+
+CV_IMPL IplImage* cvQueryFrame(CvCapture* capture)
+{
+    if (!capture)
+        return 0;
+    if (!capture->grabFrame())
+        return 0;
+    return capture->retrieveFrame(0);
+}
+
+CV_IMPL int cvGrabFrame(CvCapture* capture)
+{
+    return capture ? capture->grabFrame() : 0;
+}
+
+CV_IMPL IplImage* cvRetrieveFrame(CvCapture* capture, int idx)
+{
+    return capture ? capture->retrieveFrame(idx) : 0;
+}
+
+CV_IMPL double cvGetCaptureProperty(CvCapture* capture, int id)
+{
+    return capture ? capture->getProperty(id) : 0;
+}
+
+CV_IMPL int cvSetCaptureProperty(CvCapture* capture, int id, double value)
+{
+    return capture ? capture->setProperty(id, value) : 0;
+}
+
+CV_IMPL int cvGetCaptureDomain(CvCapture* capture)
+{
+    return capture ? capture->getCaptureDomain() : 0;
+}

modules/videoio/src/videoio_registry.hpp

+// 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.
+
+#ifndef __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__
+#define __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__
+
+namespace cv
+{
+
+/** Capabilities bitmask */
+enum BackendMode {
+    MODE_CAPTURE_BY_INDEX    = 1 << 0,           //!< device index
+    MODE_CAPTURE_BY_FILENAME = 1 << 1,           //!< filename or device path (v4l2)
+    MODE_WRITER              = 1 << 4,            //!< writer
+
+    MODE_CAPTURE_ALL = MODE_CAPTURE_BY_INDEX + MODE_CAPTURE_BY_FILENAME,
+};
+
+struct VideoBackendInfo {
+    VideoCaptureAPIs id;
+    BackendMode mode;
+    int priority;     // 1000-<index*10> - default builtin priority
+                      // 0 - disabled (OPENCV_VIDEOIO_PRIORITY_<name> = 0)
+                      // >10000 - prioritized list (OPENCV_VIDEOIO_PRIORITY_LIST)
+    const char* name;
+};
+
+namespace videoio_registry {
+
+std::vector<VideoBackendInfo> getAvailableBackends_CaptureByIndex();
+std::vector<VideoBackendInfo> getAvailableBackends_CaptureByFilename();
+std::vector<VideoBackendInfo> getAvailableBackends_Writer();
+
+} // namespace
+
+void VideoCapture_create(CvCapture*& capture, Ptr<IVideoCapture>& icap, VideoCaptureAPIs api, int index);
+void VideoCapture_create(CvCapture*& capture, Ptr<IVideoCapture>& icap, VideoCaptureAPIs api, const cv::String& filename);
+void VideoWriter_create(CvVideoWriter*& writer, Ptr<IVideoWriter>& iwriter, VideoCaptureAPIs api,
+        const String& filename, int fourcc, double fps, const Size& frameSize, bool isColor);
+
+} // namespace
+#endif // __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__

modules/videoio/test/test_ffmpeg.cpp

@@ -228,7 +228,7 @@ public:
     static std::string TmpDirectory;
 
     CreateVideoWriterInvoker(std::vector<VideoWriter*>& _writers, std::vector<std::string>& _files) :
-        ParallelLoopBody(), writers(&_writers), files(&_files)
+        writers(_writers), files(_files)
     {
     }
 
@@ -240,16 +240,16 @@ public:
             stream << i << ".avi";
             std::string fileName = tempfile(stream.str().c_str());
 
-            files->operator[](i) = fileName;
-            writers->operator[](i) = new VideoWriter(fileName, CAP_FFMPEG, VideoWriter::fourcc('X','V','I','D'), 25.0f, FrameSize);
+            files[i] = fileName;
+            writers[i] = new VideoWriter(fileName, CAP_FFMPEG, VideoWriter::fourcc('X','V','I','D'), 25.0f, FrameSize);
 
-            CV_Assert(writers->operator[](i)->isOpened());
+            CV_Assert(writers[i]->isOpened());
         }
     }
 
 private:
-    std::vector<VideoWriter*>* writers;
-    std::vector<std::string>* files;
+    std::vector<VideoWriter*>& writers;
+    std::vector<std::string>& files;
 };
 
 std::string CreateVideoWriterInvoker::TmpDirectory;