Skip to content

O
opencv
Commit b46fa2e5 authored by Alexander Alekhin's avatar Alexander Alekhin
Browse files
Options

Merge pull request #13970 from alalek:videoio_plugins_update

parents 746cd1e1 25a9a32f
Expand all Show whitespace changes
Inline Side-by-side
Showing with 671 additions and 297 deletions
modules/core/include/opencv2/core.hpp
View file @ b46fa2e5
...@@ -92,6 +92,7 @@ ...@@ -92,6 +92,7 @@
@{ @{
@defgroup core_hal_intrin_impl Private implementation helpers @defgroup core_hal_intrin_impl Private implementation helpers
@} @}
@defgroup core_lowlevel_api Low-level API for external libraries / plugins
@} @}
@} @}
*/ */
......
modules/core/include/opencv2/core/llapi/llapi.h 0 → 100644
View file @ b46fa2e5
// 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_CORE_LLAPI_LLAPI_H
#define OPENCV_CORE_LLAPI_LLAPI_H
/**
@addtogroup core_lowlevel_api
API for OpenCV external plugins:
- HAL accelerators
- VideoIO camera backends / decoders / encoders
- Imgcodecs encoders / decoders
Plugins are usually built separately or before OpenCV (OpenCV can depend on them - like HAL libraries).
Using this approach OpenCV provides some basic low level functionality for external plugins.
@note Preview only (no backward compatibility)
@{
*/
#ifndef CV_API_CALL
//! calling convention (including callbacks)
#define CV_API_CALL
#endif
typedef enum cvResult
{
CV_ERROR_FAIL = -1, //!< Some error occured (TODO Require to fill exception information)
CV_ERROR_OK = 0 //!< No error
} CvResult;
typedef struct OpenCV_API_Header_t
{
/** @brief valid size of this structure
@details `assert(api.header.valid_size >= sizeof(OpenCV_<Name>_API_v<N>));`
*/
size_t valid_size;
unsigned min_api_version; //!< backward compatible API version
unsigned api_version; //!< provided API version (features)
unsigned opencv_version_major; //!< compiled OpenCV version
unsigned opencv_version_minor; //!< compiled OpenCV version
unsigned opencv_version_patch; //!< compiled OpenCV version
const char* opencv_version_status; //!< compiled OpenCV version
const char* api_description; //!< API description (debug purposes only)
} OpenCV_API_Header;
#if 0
typedef int (CV_API_CALL *cv_example_callback1_cb_t)(unsigned const char* cb_result, void* cb_context);
struct OpenCV_Example_API_v1
{
OpenCV_API_Header header;
/** @brief Some API call
@param param1 description1
@param param2 description2
@note API-CALL 1, API-Version >=1
*/
CvResult (CV_API_CALL *Request1)(int param1, const char* param2);
/** @brief Register callback
@param callback function to handle callback
@param cb_context context data passed to callback function
@param[out] cb_handle callback id (used to unregister callback)
@note API-CALL 2, API-Version >=1
*/
CvResult (CV_API_CALL *RegisterCallback)(cv_example_callback1_cb_t callback, void* cb_context, CV_OUT unsigned* cb_handle);
/** @brief Unregister callback
@param cb_handle callback handle
@note API-CALL 3, API-Version >=1
*/
CvResult (CV_API_CALL *UnegisterCallback)(unsigned cb_handle);
...
};
#endif // 0
//! @}
#endif // OPENCV_CORE_LLAPI_LLAPI_H
modules/videoio/CMakeLists.txt
View file @ b46fa2e5
...@@ -21,7 +21,8 @@ set(videoio_srcs ...@@ -21,7 +21,8 @@ set(videoio_srcs
"${CMAKE_CURRENT_LIST_DIR}/src/cap_images.cpp" "${CMAKE_CURRENT_LIST_DIR}/src/cap_images.cpp"
"${CMAKE_CURRENT_LIST_DIR}/src/cap_mjpeg_encoder.cpp" "${CMAKE_CURRENT_LIST_DIR}/src/cap_mjpeg_encoder.cpp"
"${CMAKE_CURRENT_LIST_DIR}/src/cap_mjpeg_decoder.cpp" "${CMAKE_CURRENT_LIST_DIR}/src/cap_mjpeg_decoder.cpp"
"${CMAKE_CURRENT_LIST_DIR}/src/backend.cpp" "${CMAKE_CURRENT_LIST_DIR}/src/backend_plugin.cpp"
"${CMAKE_CURRENT_LIST_DIR}/src/backend_static.cpp"
"${CMAKE_CURRENT_LIST_DIR}/src/container_avi.cpp") "${CMAKE_CURRENT_LIST_DIR}/src/container_avi.cpp")
file(GLOB videoio_ext_hdrs file(GLOB videoio_ext_hdrs
......
modules/videoio/cmake/plugin.cmake
View file @ b46fa2e5
...@@ -16,7 +16,7 @@ function(ocv_create_builtin_videoio_plugin name target videoio_src_file) ...@@ -16,7 +16,7 @@ function(ocv_create_builtin_videoio_plugin name target videoio_src_file)
add_library(${name} MODULE add_library(${name} MODULE
"${CMAKE_CURRENT_LIST_DIR}/src/${videoio_src_file}" "${CMAKE_CURRENT_LIST_DIR}/src/${videoio_src_file}"
"${CMAKE_CURRENT_LIST_DIR}/src/plugin_api.cpp") )
target_include_directories(${name} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}") target_include_directories(${name} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}")
target_compile_definitions(${name} PRIVATE BUILD_PLUGIN) target_compile_definitions(${name} PRIVATE BUILD_PLUGIN)
target_link_libraries(${name} PRIVATE ${target}) target_link_libraries(${name} PRIVATE ${target})
...@@ -66,7 +66,7 @@ function(ocv_create_videoio_plugin default_name target target_desc videoio_src_f ...@@ -66,7 +66,7 @@ function(ocv_create_videoio_plugin default_name target target_desc videoio_src_f
set(imgproc_ROOT "${modules_ROOT}/imgproc") set(imgproc_ROOT "${modules_ROOT}/imgproc")
set(imgcodecs_ROOT "${modules_ROOT}/imgcodecs") set(imgcodecs_ROOT "${modules_ROOT}/imgcodecs")
add_library(${OPENCV_PLUGIN_NAME} MODULE "${videoio_ROOT}/src/${videoio_src_file}" "${videoio_ROOT}/src/plugin_api.cpp") add_library(${OPENCV_PLUGIN_NAME} MODULE "${videoio_ROOT}/src/${videoio_src_file}")
target_include_directories(${OPENCV_PLUGIN_NAME} PRIVATE target_include_directories(${OPENCV_PLUGIN_NAME} PRIVATE
"${CMAKE_CURRENT_BINARY_DIR}" "${CMAKE_CURRENT_BINARY_DIR}"
"${videoio_ROOT}/src" "${videoio_ROOT}/src"
......
modules/videoio/include/opencv2/videoio/registry.hpp
View file @ b46fa2e5
...@@ -38,15 +38,8 @@ CV_EXPORTS_W std::vector<VideoCaptureAPIs> getStreamBackends(); ...@@ -38,15 +38,8 @@ CV_EXPORTS_W std::vector<VideoCaptureAPIs> getStreamBackends();
/** @brief Returns list of available backends which works via `cv::VideoWriter()` */ /** @brief Returns list of available backends which works via `cv::VideoWriter()` */
CV_EXPORTS_W std::vector<VideoCaptureAPIs> getWriterBackends(); CV_EXPORTS_W std::vector<VideoCaptureAPIs> getWriterBackends();
enum Capability
{
Read,
Write,
ReadWrite
};
/** @brief Returns true if backend is available */ /** @brief Returns true if backend is available */
CV_EXPORTS bool hasBackend(VideoCaptureAPIs api, Capability cap = ReadWrite); CV_EXPORTS bool hasBackend(VideoCaptureAPIs api);
//! @} //! @}
}} // namespace }} // namespace
......
modules/videoio/src/backend.cpp deleted 100644 → 0
View file @ 746cd1e1
This diff is collapsed.
modules/videoio/src/backend.hpp
View file @ b46fa2e5
...@@ -15,71 +15,30 @@ namespace cv { ...@@ -15,71 +15,30 @@ namespace cv {
class IBackend class IBackend
{ {
public: public:
Ptr<IVideoCapture> tryOpenCapture(const std::string & backendName, const std::string & filename, int cameraNum) const;
Ptr<IVideoWriter> tryOpenWriter(const std::string & backendName, const std::string& filename, int _fourcc, double fps, const Size &frameSize, bool isColor) const;
protected:
virtual Ptr<IVideoCapture> createCapture(const std::string &filename, int camera) const = 0;
virtual Ptr<IVideoWriter> createWriter(const std::string &filename, int fourcc, double fps, const cv::Size &sz, bool isColor) const = 0;
virtual ~IBackend() {} virtual ~IBackend() {}
virtual Ptr<IVideoCapture> createCapture(int camera) const = 0;
virtual Ptr<IVideoCapture> createCapture(const std::string &filename) const = 0;
virtual Ptr<IVideoWriter> createWriter(const std::string &filename, int fourcc, double fps, const cv::Size &sz, bool isColor) const = 0;
}; };
//================================================================================================== class IBackendFactory
class StaticBackend : public IBackend
{ {
typedef Ptr<IVideoCapture> (*OpenFileFun)(const std::string &);
typedef Ptr<IVideoCapture> (*OpenCamFun)(int);
typedef Ptr<IVideoWriter> (*OpenWriterFun)(const std::string&, int, double, const Size&, bool);
private:
OpenFileFun FUN_FILE;
OpenCamFun FUN_CAM;
OpenWriterFun FUN_WRITE;
public: public:
StaticBackend(OpenFileFun f1, OpenCamFun f2, OpenWriterFun f3) virtual ~IBackendFactory() {}
: FUN_FILE(f1), FUN_CAM(f2), FUN_WRITE(f3) virtual Ptr<IBackend> getBackend() const = 0;
{
}
protected:
Ptr<IVideoCapture> createCapture(const std::string &filename, int camera) const CV_OVERRIDE
{
if (filename.empty() && FUN_CAM)
return FUN_CAM(camera);
if (FUN_FILE)
return FUN_FILE(filename);
return 0;
}
Ptr<IVideoWriter> createWriter(const std::string &filename, int fourcc, double fps, const Size &sz, bool isColor) const CV_OVERRIDE
{
if (FUN_WRITE)
return FUN_WRITE(filename, fourcc, fps, sz, isColor);
return 0;
}
}; };
//================================================================================================== //=============================================================================
class DynamicBackend : public IBackend typedef Ptr<IVideoCapture> (*FN_createCaptureFile)(const std::string & filename);
{ typedef Ptr<IVideoCapture> (*FN_createCaptureCamera)(int camera);
public: typedef Ptr<IVideoWriter> (*FN_createWriter)(const std::string& filename, int fourcc, double fps, const Size& sz, bool isColor);
class CaptureTable; Ptr<IBackendFactory> createBackendFactory(FN_createCaptureFile createCaptureFile,
class WriterTable; FN_createCaptureCamera createCaptureCamera,
class DynamicLib; FN_createWriter createWriter);
private:
DynamicLib * lib;
CaptureTable const * cap_tbl;
WriterTable const * wri_tbl;
public:
DynamicBackend(const std::string &filename);
~DynamicBackend();
static Ptr<DynamicBackend> load(VideoCaptureAPIs api, int mode);
protected:
bool canCreateCapture(cv::VideoCaptureAPIs api) const;
bool canCreateWriter(VideoCaptureAPIs api) const;
Ptr<IVideoCapture> createCapture(const std::string &filename, int camera) const CV_OVERRIDE;
Ptr<IVideoWriter> createWriter(const std::string &filename, int fourcc, double fps, const cv::Size &sz, bool isColor) const CV_OVERRIDE;
};
} // cv:: Ptr<IBackendFactory> createPluginBackendFactory(VideoCaptureAPIs id, const char* baseName);
} // namespace cv::
#endif // BACKEND_HPP_DEFINED #endif // BACKEND_HPP_DEFINED
modules/videoio/src/backend_plugin.cpp 0 → 100644
View file @ b46fa2e5
This diff is collapsed.
modules/videoio/src/backend_static.cpp 0 → 100644
View file @ b46fa2e5
// 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 "backend.hpp"
namespace cv {
class StaticBackend: public IBackend
{
public:
FN_createCaptureFile fn_createCaptureFile_;
FN_createCaptureCamera fn_createCaptureCamera_;
FN_createWriter fn_createWriter_;
StaticBackend(FN_createCaptureFile fn_createCaptureFile, FN_createCaptureCamera fn_createCaptureCamera, FN_createWriter fn_createWriter)
: fn_createCaptureFile_(fn_createCaptureFile), fn_createCaptureCamera_(fn_createCaptureCamera), fn_createWriter_(fn_createWriter)
{
// nothing
}
~StaticBackend() CV_OVERRIDE {}
Ptr<IVideoCapture> createCapture(int camera) const CV_OVERRIDE
{
if (fn_createCaptureCamera_)
return fn_createCaptureCamera_(camera);
return Ptr<IVideoCapture>();
}
Ptr<IVideoCapture> createCapture(const std::string &filename) const CV_OVERRIDE
{
if (fn_createCaptureFile_)
return fn_createCaptureFile_(filename);
return Ptr<IVideoCapture>();
}
Ptr<IVideoWriter> createWriter(const std::string &filename, int fourcc, double fps, const cv::Size &sz, bool isColor) const CV_OVERRIDE
{
if (fn_createWriter_)
return fn_createWriter_(filename, fourcc, fps, sz, isColor);
return Ptr<IVideoWriter>();
}
}; // StaticBackend
class StaticBackendFactory : public IBackendFactory
{
protected:
Ptr<StaticBackend> backend;
public:
StaticBackendFactory(FN_createCaptureFile createCaptureFile, FN_createCaptureCamera createCaptureCamera, FN_createWriter createWriter)
: backend(makePtr<StaticBackend>(createCaptureFile, createCaptureCamera, createWriter))
{
// nothing
}
~StaticBackendFactory() CV_OVERRIDE {}
Ptr<IBackend> getBackend() const CV_OVERRIDE
{
return backend.staticCast<IBackend>();
}
};
Ptr<IBackendFactory> createBackendFactory(FN_createCaptureFile createCaptureFile,
FN_createCaptureCamera createCaptureCamera,
FN_createWriter createWriter)
{
return makePtr<StaticBackendFactory>(createCaptureFile, createCaptureCamera, createWriter).staticCast<IBackendFactory>();
}
} // namespace
modules/videoio/src/cap.cpp
View file @ b46fa2e5
...@@ -46,6 +46,11 @@ ...@@ -46,6 +46,11 @@
namespace cv { namespace cv {
static bool param_VIDEOIO_DEBUG = utils::getConfigurationParameterBool("OPENCV_VIDEOIO_DEBUG", false);
static bool param_VIDEOCAPTURE_DEBUG = utils::getConfigurationParameterBool("OPENCV_VIDEOCAPTURE_DEBUG", false);
static bool param_VIDEOWRITER_DEBUG = utils::getConfigurationParameterBool("OPENCV_VIDEOWRITER_DEBUG", false);
void DefaultDeleter<CvCapture>::operator ()(CvCapture* obj) const { cvReleaseCapture(&obj); } void DefaultDeleter<CvCapture>::operator ()(CvCapture* obj) const { cvReleaseCapture(&obj); }
void DefaultDeleter<CvVideoWriter>::operator ()(CvVideoWriter* obj) const { cvReleaseVideoWriter(&obj); } void DefaultDeleter<CvVideoWriter>::operator ()(CvVideoWriter* obj) const { cvReleaseVideoWriter(&obj); }
...@@ -77,22 +82,48 @@ bool VideoCapture::open(const String& filename, int apiPreference) ...@@ -77,22 +82,48 @@ bool VideoCapture::open(const String& filename, int apiPreference)
if (isOpened()) release(); if (isOpened()) release();
const std::vector<VideoCaptureAPIs> backends = cv::videoio_registry::getStreamBackends(); const std::vector<VideoBackendInfo> backends = cv::videoio_registry::getAvailableBackends_CaptureByFilename();
for (size_t i = 0; i < backends.size(); i++) for (size_t i = 0; i < backends.size(); i++)
{ {
const VideoCaptureAPIs id = backends[i]; const VideoBackendInfo& info = backends[i];
const std::string backendName = cv::videoio_registry::getBackendName(id); if (apiPreference == CAP_ANY || apiPreference == info.id)
if (apiPreference == CAP_ANY || apiPreference == id) {
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): trying capture filename='%s' ...", info.name, filename.c_str()));
CV_Assert(!info.backendFactory.empty());
const Ptr<IBackend> backend = info.backendFactory->getBackend();
if (!backend.empty())
{
try
{ {
Ptr<IBackend> factory = VideoBackendRegistry::getInstance().getBackend(id); icap = backend->createCapture(filename);
if (factory)
icap = factory->tryOpenCapture(backendName, filename, 0);
if (!icap.empty()) if (!icap.empty())
{ {
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): created, isOpened=%d",
info.name, icap->isOpened()));
if (icap->isOpened()) if (icap->isOpened())
return true; return true;
icap.release(); icap.release();
} }
else
{
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): can't create capture", info.name));
}
} catch(const cv::Exception& e) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised OpenCV exception:\n\n%s\n", info.name, e.what()));
} catch (const std::exception& e) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised C++ exception:\n\n%s\n", info.name, e.what()));
} catch(...) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised unknown C++ exception!\n\n", info.name));
}
}
else
{
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG) \
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): backend is not available (plugin is missing, or can't be loaded due dependencies or it is not compatible)", info.name));
}
} }
} }
return false; return false;
...@@ -115,22 +146,48 @@ bool VideoCapture::open(int cameraNum, int apiPreference) ...@@ -115,22 +146,48 @@ bool VideoCapture::open(int cameraNum, int apiPreference)
} }
} }
const std::vector<VideoCaptureAPIs> backends = cv::videoio_registry::getCameraBackends(); const std::vector<VideoBackendInfo> backends = cv::videoio_registry::getAvailableBackends_CaptureByIndex();
for (size_t i = 0; i < backends.size(); i++) for (size_t i = 0; i < backends.size(); i++)
{ {
const VideoCaptureAPIs id = backends[i]; const VideoBackendInfo& info = backends[i];
const std::string backendName = cv::videoio_registry::getBackendName(id); if (apiPreference == CAP_ANY || apiPreference == info.id)
if (apiPreference == CAP_ANY || apiPreference == id)
{ {
Ptr<IBackend> factory = VideoBackendRegistry::getInstance().getBackend(id); if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG)
if (factory) CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): trying capture cameraNum=%d ...", info.name, cameraNum));
icap = factory->tryOpenCapture(backendName, std::string(), cameraNum); CV_Assert(!info.backendFactory.empty());
const Ptr<IBackend> backend = info.backendFactory->getBackend();
if (!backend.empty())
{
try
{
icap = backend->createCapture(cameraNum);
if (!icap.empty()) if (!icap.empty())
{ {
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): created, isOpened=%d",
info.name, icap->isOpened()));
if (icap->isOpened()) if (icap->isOpened())
return true; return true;
icap.release(); icap.release();
} }
else
{
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): can't create capture", info.name));
}
} catch(const cv::Exception& e) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised OpenCV exception:\n\n%s\n", info.name, e.what()));
} catch (const std::exception& e) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised C++ exception:\n\n%s\n", info.name, e.what()));
} catch(...) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised unknown C++ exception!\n\n", info.name));
}
}
else
{
if (param_VIDEOIO_DEBUG || param_VIDEOCAPTURE_DEBUG) \
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): backend is not available (plugin is missing, or can't be loaded due dependencies or it is not compatible)", info.name));
}
} }
} }
return false; return false;
...@@ -277,22 +334,49 @@ bool VideoWriter::open(const String& filename, int apiPreference, int _fourcc, d ...@@ -277,22 +334,49 @@ bool VideoWriter::open(const String& filename, int apiPreference, int _fourcc, d
if (isOpened()) release(); if (isOpened()) release();
const std::vector<VideoCaptureAPIs> backends = cv::videoio_registry::getWriterBackends(); const std::vector<VideoBackendInfo> backends = cv::videoio_registry::getAvailableBackends_Writer();
for (size_t i = 0; i < backends.size(); i++) for (size_t i = 0; i < backends.size(); i++)
{ {
const VideoCaptureAPIs id = backends[i]; const VideoBackendInfo& info = backends[i];
const std::string backendName = cv::videoio_registry::getBackendName(id); if (apiPreference == CAP_ANY || apiPreference == info.id)
if (apiPreference == CAP_ANY || apiPreference == id) {
if (param_VIDEOIO_DEBUG || param_VIDEOWRITER_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): trying writer with filename='%s' fourcc=0x%08x fps=%g sz=%dx%d isColor=%d...",
info.name, filename.c_str(), (unsigned)_fourcc, fps, frameSize.width, frameSize.height, (int)isColor));
CV_Assert(!info.backendFactory.empty());
const Ptr<IBackend> backend = info.backendFactory->getBackend();
if (!backend.empty())
{
try
{ {
Ptr<IBackend> factory = VideoBackendRegistry::getInstance().getBackend(id); iwriter = backend->createWriter(filename, _fourcc, fps, frameSize, isColor);
if (factory)
iwriter = factory->tryOpenWriter(backendName, filename, _fourcc, fps, frameSize, isColor);
if (!iwriter.empty()) if (!iwriter.empty())
{ {
if (param_VIDEOIO_DEBUG || param_VIDEOWRITER_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): created, isOpened=%d",
info.name, iwriter->isOpened()));
if (iwriter->isOpened()) if (iwriter->isOpened())
return true; return true;
iwriter.release(); iwriter.release();
} }
else
{
if (param_VIDEOIO_DEBUG || param_VIDEOWRITER_DEBUG)
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): can't create writer", info.name));
}
} catch(const cv::Exception& e) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised OpenCV exception:\n\n%s\n", info.name, e.what()));
} catch (const std::exception& e) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised C++ exception:\n\n%s\n", info.name, e.what()));
} catch(...) {
CV_LOG_ERROR(NULL, cv::format("VIDEOIO(%s): raised unknown C++ exception!\n\n", info.name));
}
}
else
{
if (param_VIDEOIO_DEBUG || param_VIDEOWRITER_DEBUG) \
CV_LOG_WARNING(NULL, cv::format("VIDEOIO(%s): backend is not available (plugin is missing, or can't be loaded due dependencies or it is not compatible)", info.name));
}
} }
} }
return false; return false;
......
modules/videoio/src/cap_ffmpeg.cpp
View file @ b46fa2e5
...@@ -351,23 +351,25 @@ cv::Ptr<cv::IVideoWriter> cvCreateVideoWriter_FFMPEG_proxy(const std::string& fi ...@@ -351,23 +351,25 @@ cv::Ptr<cv::IVideoWriter> cvCreateVideoWriter_FFMPEG_proxy(const std::string& fi
#include "plugin_api.hpp" #include "plugin_api.hpp"
CV_EXTERN_C int cv_domain() namespace cv {
{
return cv::CAP_FFMPEG;
}
CV_EXTERN_C bool cv_open_capture(const char * filename, int, void * &handle) static
CvResult CV_API_CALL cv_capture_open(const char* filename, int camera_index, CV_OUT CvPluginCapture* handle)
{ {
if (!handle)
return CV_ERROR_FAIL;
*handle = NULL;
if (!filename) if (!filename)
return false; return CV_ERROR_FAIL;
cv::CvCapture_FFMPEG_proxy *cap = 0; CV_UNUSED(camera_index);
CvCapture_FFMPEG_proxy *cap = 0;
try try
{ {
cap = new cv::CvCapture_FFMPEG_proxy(filename); cap = new CvCapture_FFMPEG_proxy(filename);
if (cap->isOpened()) if (cap->isOpened())
{ {
handle = cap; *handle = (CvPluginCapture)cap;
return true; return CV_ERROR_OK;
} }
} }
catch (...) catch (...)
...@@ -375,94 +377,104 @@ CV_EXTERN_C bool cv_open_capture(const char * filename, int, void * &handle) ...@@ -375,94 +377,104 @@ CV_EXTERN_C bool cv_open_capture(const char * filename, int, void * &handle)
} }
if (cap) if (cap)
delete cap; delete cap;
return false; return CV_ERROR_FAIL;
} }
CV_EXTERN_C bool cv_get_cap_prop(void * handle, int prop, double & val) static
CvResult CV_API_CALL cv_capture_release(CvPluginCapture handle)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
CvCapture_FFMPEG_proxy* instance = (CvCapture_FFMPEG_proxy*)handle;
delete instance;
return CV_ERROR_OK;
}
static
CvResult CV_API_CALL cv_capture_get_prop(CvPluginCapture handle, int prop, CV_OUT double* val)
{
if (!handle)
return CV_ERROR_FAIL;
if (!val)
return CV_ERROR_FAIL;
try try
{ {
cv::CvCapture_FFMPEG_proxy *instance = static_cast<cv::CvCapture_FFMPEG_proxy*>(handle); CvCapture_FFMPEG_proxy* instance = (CvCapture_FFMPEG_proxy*)handle;
val = instance->getProperty(prop); *val = instance->getProperty(prop);
return true; return CV_ERROR_OK;
} }
catch (...) catch (...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_set_cap_prop(void * handle, int prop, double val) static
CvResult CV_API_CALL cv_capture_set_prop(CvPluginCapture handle, int prop, double val)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
cv::CvCapture_FFMPEG_proxy *instance = static_cast<cv::CvCapture_FFMPEG_proxy*>(handle); CvCapture_FFMPEG_proxy* instance = (CvCapture_FFMPEG_proxy*)handle;
return instance->setProperty(prop, val); return instance->setProperty(prop, val) ? CV_ERROR_OK : CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_grab(void * handle) static
CvResult CV_API_CALL cv_capture_grab(CvPluginCapture handle)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
cv::CvCapture_FFMPEG_proxy *instance = static_cast<cv::CvCapture_FFMPEG_proxy*>(handle); CvCapture_FFMPEG_proxy* instance = (CvCapture_FFMPEG_proxy*)handle;
return instance->grabFrame(); return instance->grabFrame() ? CV_ERROR_OK : CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_retrieve(void * handle, int idx, cv_retrieve_cb_t * callback, void * userdata) static
CvResult CV_API_CALL cv_capture_retrieve(CvPluginCapture handle, int stream_idx, cv_videoio_retrieve_cb_t callback, void* userdata)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
cv::CvCapture_FFMPEG_proxy *instance = static_cast<cv::CvCapture_FFMPEG_proxy*>(handle); CvCapture_FFMPEG_proxy* instance = (CvCapture_FFMPEG_proxy*)handle;
cv::Mat img; Mat img;
// TODO: avoid unnecessary copying // TODO: avoid unnecessary copying
if (instance->retrieveFrame(idx, img)) if (instance->retrieveFrame(stream_idx, img))
return callback(img.data, img.step, img.cols, img.rows, img.channels(), userdata); return callback(stream_idx, img.data, img.step, img.cols, img.rows, img.channels(), userdata);
return false; return CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_release_capture(void * handle) static
{ CvResult CV_API_CALL cv_writer_open(const char* filename, int fourcc, double fps, int width, int height, int isColor,
if (!handle) CV_OUT CvPluginWriter* handle)
return false;
cv::CvCapture_FFMPEG_proxy *instance = static_cast<cv::CvCapture_FFMPEG_proxy*>(handle);
delete instance;
return true;
}
CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, int width, int height, int isColor, void * &handle)
{ {
cv::Size sz(width, height); Size sz(width, height);
cv::CvVideoWriter_FFMPEG_proxy* wrt = 0; CvVideoWriter_FFMPEG_proxy* wrt = 0;
try try
{ {
wrt = new cv::CvVideoWriter_FFMPEG_proxy(filename, fourcc, fps, sz, isColor != 0); wrt = new CvVideoWriter_FFMPEG_proxy(filename, fourcc, fps, sz, isColor != 0);
if(wrt && wrt->isOpened()) if(wrt && wrt->isOpened())
{ {
handle = wrt; *handle = (CvPluginWriter)wrt;
return true; return CV_ERROR_OK;
} }
} }
catch(...) catch(...)
...@@ -470,43 +482,79 @@ CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, i ...@@ -470,43 +482,79 @@ CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, i
} }
if (wrt) if (wrt)
delete wrt; delete wrt;
return false; return CV_ERROR_FAIL;
} }
CV_EXTERN_C bool cv_get_wri_prop(void*, int, double&) static
CvResult CV_API_CALL cv_writer_release(CvPluginWriter handle)
{ {
return false; if (!handle)
return CV_ERROR_FAIL;
CvVideoWriter_FFMPEG_proxy* instance = (CvVideoWriter_FFMPEG_proxy*)handle;
delete instance;
return CV_ERROR_OK;
} }
CV_EXTERN_C bool cv_set_wri_prop(void*, int, double) static
CvResult CV_API_CALL cv_writer_get_prop(CvPluginWriter /*handle*/, int /*prop*/, CV_OUT double* /*val*/)
{ {
return false; return CV_ERROR_FAIL;
}
static
CvResult CV_API_CALL cv_writer_set_prop(CvPluginWriter /*handle*/, int /*prop*/, double /*val*/)
{
return CV_ERROR_FAIL;
} }
CV_EXTERN_C bool cv_write(void * handle, const unsigned char * data, int step, int width, int height, int cn) static
CvResult CV_API_CALL cv_writer_write(CvPluginWriter handle, const unsigned char *data, int step, int width, int height, int cn)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
cv::CvVideoWriter_FFMPEG_proxy * instance = static_cast<cv::CvVideoWriter_FFMPEG_proxy*>(handle); CvVideoWriter_FFMPEG_proxy* instance = (CvVideoWriter_FFMPEG_proxy*)handle;
cv::Mat img(cv::Size(width, height), CV_MAKETYPE(CV_8U, cn), const_cast<uchar*>(data), step); Mat img(Size(width, height), CV_MAKETYPE(CV_8U, cn), const_cast<uchar*>(data), step);
instance->write(img); instance->write(img);
return true; return CV_ERROR_OK;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_release_writer(void * handle) static const OpenCV_VideoIO_Plugin_API_preview plugin_api_v0 =
{ {
if (!handle) {
return false; sizeof(OpenCV_VideoIO_Plugin_API_preview), ABI_VERSION, API_VERSION,
cv::CvVideoWriter_FFMPEG_proxy * instance = static_cast<cv::CvVideoWriter_FFMPEG_proxy*>(handle); CV_VERSION_MAJOR, CV_VERSION_MINOR, CV_VERSION_REVISION, CV_VERSION_STATUS,
delete instance; "FFmpeg OpenCV Video I/O plugin"
return true; },
/* 1*/CAP_FFMPEG,
/* 2*/cv_capture_open,
/* 3*/cv_capture_release,
/* 4*/cv_capture_get_prop,
/* 5*/cv_capture_set_prop,
/* 6*/cv_capture_grab,
/* 7*/cv_capture_retrieve,
/* 8*/cv_writer_open,
/* 9*/cv_writer_release,
/* 10*/cv_writer_get_prop,
/* 11*/cv_writer_set_prop,
/* 12*/cv_writer_write
};
} // namespace
const OpenCV_VideoIO_Plugin_API_preview* opencv_videoio_plugin_init_v0(int requested_abi_version, int requested_api_version, void* /*reserved=NULL*/) CV_NOEXCEPT
{
if (requested_abi_version != 0)
return NULL;
if (requested_api_version != 0)
return NULL;
return &cv::plugin_api_v0;
} }
#endif // BUILD_PLUGIN #endif // BUILD_PLUGIN
modules/videoio/src/cap_ffmpeg_api.hpp
View file @ b46fa2e5
...@@ -6,13 +6,17 @@ extern "C" ...@@ -6,13 +6,17 @@ extern "C"
{ {
#endif #endif
#if defined _WIN32 #ifndef OPENCV_FFMPEG_API
#if defined(__OPENCV_BUILD) || defined(BUILD_PLUGIN)
# define OPENCV_FFMPEG_API
#elif defined _WIN32
# define OPENCV_FFMPEG_API __declspec(dllexport) # define OPENCV_FFMPEG_API __declspec(dllexport)
#elif defined __GNUC__ && __GNUC__ >= 4 #elif defined __GNUC__ && __GNUC__ >= 4
# define OPENCV_FFMPEG_API __attribute__ ((visibility ("default"))) # define OPENCV_FFMPEG_API __attribute__ ((visibility ("default")))
#else #else
# define OPENCV_FFMPEG_API # define OPENCV_FFMPEG_API
#endif #endif
#endif
enum enum
{ {
......
modules/videoio/src/cap_gstreamer.cpp
View file @ b46fa2e5
...@@ -1629,13 +1629,16 @@ void handleMessage(GstElement * pipeline) ...@@ -1629,13 +1629,16 @@ void handleMessage(GstElement * pipeline)
#include "plugin_api.hpp" #include "plugin_api.hpp"
CV_EXTERN_C int cv_domain() namespace cv {
{
return cv::CAP_GSTREAMER;
}
CV_EXTERN_C bool cv_open_capture(const char * filename, int camera_index, void * &handle) static
CvResult CV_API_CALL cv_capture_open(const char* filename, int camera_index, CV_OUT CvPluginCapture* handle)
{ {
if (!handle)
return CV_ERROR_FAIL;
*handle = NULL;
if (!filename)
return CV_ERROR_FAIL;
GStreamerCapture *cap = 0; GStreamerCapture *cap = 0;
try try
{ {
...@@ -1647,8 +1650,8 @@ CV_EXTERN_C bool cv_open_capture(const char * filename, int camera_index, void * ...@@ -1647,8 +1650,8 @@ CV_EXTERN_C bool cv_open_capture(const char * filename, int camera_index, void *
res = cap->open(camera_index); res = cap->open(camera_index);
if (res) if (res)
{ {
handle = cap; *handle = (CvPluginCapture)cap;
return true; return CV_ERROR_OK;
} }
} }
catch (...) catch (...)
...@@ -1656,84 +1659,94 @@ CV_EXTERN_C bool cv_open_capture(const char * filename, int camera_index, void * ...@@ -1656,84 +1659,94 @@ CV_EXTERN_C bool cv_open_capture(const char * filename, int camera_index, void *
} }
if (cap) if (cap)
delete cap; delete cap;
return false; return CV_ERROR_FAIL;
} }
CV_EXTERN_C bool cv_get_cap_prop(void * handle, int prop, double & val) static
CvResult CV_API_CALL cv_capture_release(CvPluginCapture handle)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
GStreamerCapture* instance = (GStreamerCapture*)handle;
delete instance;
return CV_ERROR_OK;
}
static
CvResult CV_API_CALL cv_capture_get_prop(CvPluginCapture handle, int prop, CV_OUT double* val)
{
if (!handle)
return CV_ERROR_FAIL;
if (!val)
return CV_ERROR_FAIL;
try try
{ {
GStreamerCapture * instance = static_cast<GStreamerCapture*>(handle); GStreamerCapture* instance = (GStreamerCapture*)handle;
val = instance->getProperty(prop); *val = instance->getProperty(prop);
return true; return CV_ERROR_OK;
} }
catch(...) catch (...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_set_cap_prop(void * handle, int prop, double val) static
CvResult CV_API_CALL cv_capture_set_prop(CvPluginCapture handle, int prop, double val)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
GStreamerCapture * instance = static_cast<GStreamerCapture*>(handle); GStreamerCapture* instance = (GStreamerCapture*)handle;
return instance->setProperty(prop, val); return instance->setProperty(prop, val) ? CV_ERROR_OK : CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_grab(void * handle) static
CvResult CV_API_CALL cv_capture_grab(CvPluginCapture handle)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
GStreamerCapture * instance = static_cast<GStreamerCapture*>(handle); GStreamerCapture* instance = (GStreamerCapture*)handle;
return instance->grabFrame(); return instance->grabFrame() ? CV_ERROR_OK : CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_retrieve(void * handle, int idx, cv_retrieve_cb_t * callback, void * userdata) static
CvResult CV_API_CALL cv_capture_retrieve(CvPluginCapture handle, int stream_idx, cv_videoio_retrieve_cb_t callback, void* userdata)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
GStreamerCapture * instance = static_cast<GStreamerCapture*>(handle); GStreamerCapture* instance = (GStreamerCapture*)handle;
Mat img; Mat img;
// TODO: avoid unnecessary copying - implement lower level GStreamerCapture::retrieve // TODO: avoid unnecessary copying - implement lower level GStreamerCapture::retrieve
if (instance->retrieveFrame(idx, img)) if (instance->retrieveFrame(stream_idx, img))
return callback(img.data, img.step, img.cols, img.rows, img.channels(), userdata); return callback(stream_idx, img.data, img.step, img.cols, img.rows, img.channels(), userdata);
return false; return CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_release_capture(void * handle) static
{ CvResult CV_API_CALL cv_writer_open(const char* filename, int fourcc, double fps, int width, int height, int isColor,
if (!handle) CV_OUT CvPluginWriter* handle)
return false;
GStreamerCapture * instance = static_cast<GStreamerCapture*>(handle);
delete instance;
return true;
}
CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, int width, int height, int isColor, void * &handle)
{ {
CvVideoWriter_GStreamer* wrt = 0; CvVideoWriter_GStreamer* wrt = 0;
try try
...@@ -1742,8 +1755,8 @@ CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, i ...@@ -1742,8 +1755,8 @@ CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, i
CvSize sz = { width, height }; CvSize sz = { width, height };
if(wrt && wrt->open(filename, fourcc, fps, sz, isColor)) if(wrt && wrt->open(filename, fourcc, fps, sz, isColor))
{ {
handle = wrt; *handle = (CvPluginWriter)wrt;
return true; return CV_ERROR_OK;
} }
} }
catch(...) catch(...)
...@@ -1751,45 +1764,81 @@ CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, i ...@@ -1751,45 +1764,81 @@ CV_EXTERN_C bool cv_open_writer(const char * filename, int fourcc, double fps, i
} }
if (wrt) if (wrt)
delete wrt; delete wrt;
return false; return CV_ERROR_FAIL;
} }
CV_EXTERN_C bool cv_get_wri_prop(void*, int, double&) static
CvResult CV_API_CALL cv_writer_release(CvPluginWriter handle)
{ {
return false; if (!handle)
return CV_ERROR_FAIL;
CvVideoWriter_GStreamer* instance = (CvVideoWriter_GStreamer*)handle;
delete instance;
return CV_ERROR_OK;
} }
CV_EXTERN_C bool cv_set_wri_prop(void*, int, double) static
CvResult CV_API_CALL cv_writer_get_prop(CvPluginWriter /*handle*/, int /*prop*/, CV_OUT double* /*val*/)
{ {
return false; return CV_ERROR_FAIL;
} }
CV_EXTERN_C bool cv_write(void * handle, const unsigned char * data, int step, int width, int height, int cn) static
CvResult CV_API_CALL cv_writer_set_prop(CvPluginWriter /*handle*/, int /*prop*/, double /*val*/)
{
return CV_ERROR_FAIL;
}
static
CvResult CV_API_CALL cv_writer_write(CvPluginWriter handle, const unsigned char *data, int step, int width, int height, int cn)
{ {
if (!handle) if (!handle)
return false; return CV_ERROR_FAIL;
try try
{ {
CvVideoWriter_GStreamer * instance = static_cast<CvVideoWriter_GStreamer*>(handle); CvVideoWriter_GStreamer* instance = (CvVideoWriter_GStreamer*)handle;
CvSize sz = { width, height }; CvSize sz = { width, height };
IplImage img; IplImage img;
cvInitImageHeader(&img, sz, IPL_DEPTH_8U, cn); cvInitImageHeader(&img, sz, IPL_DEPTH_8U, cn);
cvSetData(&img, const_cast<unsigned char*>(data), step); cvSetData(&img, const_cast<unsigned char*>(data), step);
return instance->writeFrame(&img); return instance->writeFrame(&img) ? CV_ERROR_OK : CV_ERROR_FAIL;
} }
catch(...) catch(...)
{ {
return false; return CV_ERROR_FAIL;
} }
} }
CV_EXTERN_C bool cv_release_writer(void * handle) static const OpenCV_VideoIO_Plugin_API_preview plugin_api_v0 =
{ {
if (!handle) {
return false; sizeof(OpenCV_VideoIO_Plugin_API_preview), ABI_VERSION, API_VERSION,
CvVideoWriter_GStreamer * instance = static_cast<CvVideoWriter_GStreamer*>(handle); CV_VERSION_MAJOR, CV_VERSION_MINOR, CV_VERSION_REVISION, CV_VERSION_STATUS,
delete instance; "GStreamer OpenCV Video I/O plugin"
return true; },
/* 1*/CAP_GSTREAMER,
/* 2*/cv_capture_open,
/* 3*/cv_capture_release,
/* 4*/cv_capture_get_prop,
/* 5*/cv_capture_set_prop,
/* 6*/cv_capture_grab,
/* 7*/cv_capture_retrieve,
/* 8*/cv_writer_open,
/* 9*/cv_writer_release,
/* 10*/cv_writer_get_prop,
/* 11*/cv_writer_set_prop,
/* 12*/cv_writer_write
};
} // namespace
const OpenCV_VideoIO_Plugin_API_preview* opencv_videoio_plugin_init_v0(int requested_abi_version, int requested_api_version, void* /*reserved=NULL*/) CV_NOEXCEPT
{
if (requested_abi_version != 0)
return NULL;
if (requested_api_version != 0)
return NULL;
return &cv::plugin_api_v0;
} }
#endif // BUILD_PLUGIN #endif // BUILD_PLUGIN
modules/videoio/src/plugin_api.cpp deleted 100644 → 0
View file @ 746cd1e1
// 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.
#ifdef BUILD_PLUGIN
#include "plugin_api.hpp"
#include "opencv2/core/version.hpp"
void cv_get_version(int & major, int & minor, int & patch, int & api, int & abi)
{
major = CV_VERSION_MAJOR;
minor = CV_VERSION_MINOR;
patch = CV_VERSION_REVISION;
api = API_VERSION;
abi = ABI_VERSION;
}
#endif // BUILD_PLUGIN
modules/videoio/src/plugin_api.hpp
View file @ b46fa2e5
...@@ -5,63 +5,164 @@ ...@@ -5,63 +5,164 @@
#ifndef PLUGIN_API_HPP #ifndef PLUGIN_API_HPP
#define PLUGIN_API_HPP #define PLUGIN_API_HPP
#include <opencv2/core/cvdef.h>
#include <opencv2/core/llapi/llapi.h>
// increase for backward-compatible changes, e.g. add new function // increase for backward-compatible changes, e.g. add new function
// Main API <= Plugin API -> plugin is compatible // Main API <= Plugin API -> plugin is compatible
#define API_VERSION 1 #define API_VERSION 0 // preview
// increase for incompatible changes, e.g. remove function argument // increase for incompatible changes, e.g. remove function argument
// Main ABI == Plugin ABI -> plugin is compatible // Main ABI == Plugin ABI -> plugin is compatible
#define ABI_VERSION 1 #define ABI_VERSION 0 // preview
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
// common typedef CvResult (CV_API_CALL *cv_videoio_retrieve_cb_t)(int stream_idx, unsigned const char* data, int step, int width, int height, int cn, void* userdata);
typedef void cv_get_version_t(int & major, int & minor, int & patch, int & api, int & abi);
typedef int cv_domain_t(); typedef struct CvPluginCapture_t* CvPluginCapture;
typedef struct CvPluginWriter_t* CvPluginWriter;
// capture
typedef bool cv_open_capture_t(const char * filename, int camera_index, void * &handle); typedef struct OpenCV_VideoIO_Plugin_API_preview
typedef bool cv_get_cap_prop_t(void * handle, int prop, double & val); {
typedef bool cv_set_cap_prop_t(void * handle, int prop, double val); OpenCV_API_Header api_header;
typedef bool cv_grab_t(void * handle);
// callback function type /** OpenCV capture ID (VideoCaptureAPIs)
typedef bool cv_retrieve_cb_t(unsigned char * data, int step, int width, int height, int cn, void * userdata); @note API-ENTRY 1, API-Version == 0
typedef bool cv_retrieve_t(void * handle, int idx, cv_retrieve_cb_t * cb, void * userdata); */
typedef bool cv_release_capture_t(void * handle); int captureAPI;
// writer /** @brief Open video capture
typedef bool cv_open_writer_t(const char * filename, int fourcc, double fps, int width, int height, int isColor, void * &handle);
typedef bool cv_get_wri_prop_t(void * handle, int prop, double & val); @param filename File name or NULL to use camera_index instead
typedef bool cv_set_wri_prop_t(void * handle, int prop, double val); @param camera_index Camera index (used if filename == NULL)
typedef bool cv_write_t(void * handle, const unsigned char * data, int step, int width, int height, int cn); @param[out] handle pointer on Capture handle
typedef bool cv_release_writer_t(void * handle);
@note API-CALL 2, API-Version == 0
*/
CvResult (CV_API_CALL *Capture_open)(const char* filename, int camera_index, CV_OUT CvPluginCapture* handle);
/** @brief Release Capture handle
@param handle Capture handle
@note API-CALL 3, API-Version == 0
*/
CvResult (CV_API_CALL *Capture_release)(CvPluginCapture handle);
/** @brief Get property value
@param handle Capture handle
@param prop Property index
@param[out] val property value
@note API-CALL 4, API-Version == 0
*/
CvResult (CV_API_CALL *Capture_getProperty)(CvPluginCapture handle, int prop, CV_OUT double* val);
/** @brief Set property value
@param handle Capture handle
@param prop Property index
@param val property value
@note API-CALL 5, API-Version == 0
*/
CvResult (CV_API_CALL *Capture_setProperty)(CvPluginCapture handle, int prop, double val);
/** @brief Grab frame
@param handle Capture handle
@note API-CALL 6, API-Version == 0
*/
CvResult (CV_API_CALL *Capture_grab)(CvPluginCapture handle);
/** @brief Retrieve frame
@param handle Capture handle
@param stream_idx stream index to retrieve (BGR/IR/depth data)
@param callback retrieve callback (synchronous)
@param userdata callback context data
@note API-CALL 7, API-Version == 0
*/
CvResult (CV_API_CALL *Capture_retreive)(CvPluginCapture handle, int stream_idx, cv_videoio_retrieve_cb_t callback, void* userdata);
/** @brief Try to open video writer
@param filename File name or NULL to use camera_index instead
@param camera_index Camera index (used if filename == NULL)
@param[out] handle pointer on Writer handle
@note API-CALL 8, API-Version == 0
*/
CvResult (CV_API_CALL *Writer_open)(const char* filename, int fourcc, double fps, int width, int height, int isColor,
CV_OUT CvPluginWriter* handle);
/** @brief Release Writer handle
@param handle Writer handle
@note API-CALL 9, API-Version == 0
*/
CvResult (CV_API_CALL *Writer_release)(CvPluginWriter handle);
/** @brief Get property value
@param handle Capture handle
@param prop Property index
@param[out] val property value
@note API-CALL 10, API-Version == 0
*/
CvResult (CV_API_CALL *Writer_getProperty)(CvPluginWriter handle, int prop, CV_OUT double* val);
/** @brief Set property value
@param handle Capture handle
@param prop Property index
@param val property value
@note API-CALL 11, API-Version == 0
*/
CvResult (CV_API_CALL *Writer_setProperty)(CvPluginWriter handle, int prop, double val);
/** @brief Write frame
@param handle Capture handle
@param data Capture handle
@param step step in bytes
@param width frame width in pixels
@param height frame height
@param cn number of channels per pixel
@note API-CALL 12, API-Version == 0
*/
CvResult (CV_API_CALL *Writer_write)(CvPluginWriter handle, const unsigned char *data, int step, int width, int height, int cn);
} OpenCV_VideoIO_Plugin_API_preview;
#ifdef BUILD_PLUGIN #ifdef BUILD_PLUGIN
#ifndef CV_PLUGIN_EXPORTS
#if (defined _WIN32 || defined WINCE || defined __CYGWIN__) #if (defined _WIN32 || defined WINCE || defined __CYGWIN__)
# define CV_PLUGIN_EXPORTS __declspec(dllexport) # define CV_PLUGIN_EXPORTS __declspec(dllexport)
#elif defined __GNUC__ && __GNUC__ >= 4 #elif defined __GNUC__ && __GNUC__ >= 4
# define CV_PLUGIN_EXPORTS __attribute__ ((visibility ("default"))) # define CV_PLUGIN_EXPORTS __attribute__ ((visibility ("default")))
#endif #endif
#endif
CV_PLUGIN_EXPORTS cv_get_version_t cv_get_version; CV_PLUGIN_EXPORTS
CV_PLUGIN_EXPORTS cv_domain_t cv_domain; const OpenCV_VideoIO_Plugin_API_preview* CV_API_CALL opencv_videoio_plugin_init_v0
(int requested_abi_version, int requested_api_version, void* reserved /*NULL*/) CV_NOEXCEPT;
CV_PLUGIN_EXPORTS cv_open_capture_t cv_open_capture;
CV_PLUGIN_EXPORTS cv_get_cap_prop_t cv_get_cap_prop;
CV_PLUGIN_EXPORTS cv_set_cap_prop_t cv_set_cap_prop;
CV_PLUGIN_EXPORTS cv_grab_t cv_grab;
CV_PLUGIN_EXPORTS cv_retrieve_t cv_retrieve;
CV_PLUGIN_EXPORTS cv_release_capture_t cv_release_capture;
CV_PLUGIN_EXPORTS cv_open_writer_t cv_open_writer;
CV_PLUGIN_EXPORTS cv_get_wri_prop_t cv_get_wri_prop;
CV_PLUGIN_EXPORTS cv_set_wri_prop_t cv_set_wri_prop;
CV_PLUGIN_EXPORTS cv_write_t cv_write;
CV_PLUGIN_EXPORTS cv_release_writer_t cv_release_writer;
#endif #else // BUILD_PLUGIN
typedef const OpenCV_VideoIO_Plugin_API_preview* (CV_API_CALL *FN_opencv_videoio_plugin_init_t)
(int requested_abi_version, int requested_api_version, void* reserved /*NULL*/);
#endif // BUILD_PLUGIN
#ifdef __cplusplus #ifdef __cplusplus
......
modules/videoio/src/videoio_registry.cpp
View file @ b46fa2e5
This diff is collapsed.
modules/videoio/src/videoio_registry.hpp
View file @ b46fa2e5
...@@ -5,8 +5,6 @@ ...@@ -5,8 +5,6 @@
#ifndef __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__ #ifndef __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__
#define __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__ #define __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__
#include "opencv2/videoio.hpp"
#include "opencv2/videoio/registry.hpp"
#include "backend.hpp" #include "backend.hpp"
namespace cv namespace cv
...@@ -17,7 +15,6 @@ enum BackendMode { ...@@ -17,7 +15,6 @@ enum BackendMode {
MODE_CAPTURE_BY_INDEX = 1 << 0, //!< device index MODE_CAPTURE_BY_INDEX = 1 << 0, //!< device index
MODE_CAPTURE_BY_FILENAME = 1 << 1, //!< filename or device path (v4l2) MODE_CAPTURE_BY_FILENAME = 1 << 1, //!< filename or device path (v4l2)
MODE_WRITER = 1 << 4, //!< writer MODE_WRITER = 1 << 4, //!< writer
MODE_DYNAMIC = 1 << 5,
MODE_CAPTURE_ALL = MODE_CAPTURE_BY_INDEX + MODE_CAPTURE_BY_FILENAME, MODE_CAPTURE_ALL = MODE_CAPTURE_BY_INDEX + MODE_CAPTURE_BY_FILENAME,
}; };
...@@ -29,26 +26,16 @@ struct VideoBackendInfo { ...@@ -29,26 +26,16 @@ struct VideoBackendInfo {
// 0 - disabled (OPENCV_VIDEOIO_PRIORITY_<name> = 0) // 0 - disabled (OPENCV_VIDEOIO_PRIORITY_<name> = 0)
// >10000 - prioritized list (OPENCV_VIDEOIO_PRIORITY_LIST) // >10000 - prioritized list (OPENCV_VIDEOIO_PRIORITY_LIST)
const char* name; const char* name;
Ptr<IBackend> backendFactory; Ptr<IBackendFactory> backendFactory;
}; };
/** @brief Manages list of enabled backends namespace videoio_registry {
*/
class VideoBackendRegistry std::vector<VideoBackendInfo> getAvailableBackends_CaptureByIndex();
{ std::vector<VideoBackendInfo> getAvailableBackends_CaptureByFilename();
public: std::vector<VideoBackendInfo> getAvailableBackends_Writer();
typedef std::vector<VideoBackendInfo> BackendsVec;
protected: } // namespace
BackendsVec enabledBackends;
VideoBackendRegistry();
public:
std::string dumpBackends() const;
Ptr<IBackend> getBackend(VideoCaptureAPIs api) const;
BackendsVec getBackends(int capabilityMask, VideoCaptureAPIs filter = CAP_ANY) const;
bool hasBackend(int mask, VideoCaptureAPIs api) const;
static VideoBackendRegistry& getInstance();
};
} // namespace } // namespace
#endif // __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__ #endif // __OPENCV_VIDEOIO_VIDEOIO_REGISTRY_HPP__
modules/videoio/test/test_dynamic.cpp
View file @ b46fa2e5
...@@ -20,7 +20,7 @@ TEST(videoio_dynamic, basic_write) ...@@ -20,7 +20,7 @@ TEST(videoio_dynamic, basic_write)
const Size FRAME_SIZE(640, 480); const Size FRAME_SIZE(640, 480);
const double FPS = 100; const double FPS = 100;
const String filename = cv::tempfile(".avi"); const String filename = cv::tempfile(".avi");
const int fourcc = VideoWriter::fourcc('H', '2', '6', '4'); const int fourcc = VideoWriter::fourcc('M', 'J', 'P', 'G');
bool fileExists = false; bool fileExists = false;
{ {
......
modules/videoio/test/test_video_io.cpp
View file @ b46fa2e5
...@@ -82,7 +82,7 @@ protected: ...@@ -82,7 +82,7 @@ protected:
public: public:
void doTest() void doTest()
{ {
if (!videoio_registry::hasBackend(apiPref, videoio_registry::Read)) if (!videoio_registry::hasBackend(apiPref))
throw SkipTestException(cv::String("Backend is not available/disabled: ") + cv::videoio_registry::getBackendName(apiPref)); throw SkipTestException(cv::String("Backend is not available/disabled: ") + cv::videoio_registry::getBackendName(apiPref));
writeVideo(); writeVideo();
VideoCapture cap; VideoCapture cap;
...@@ -168,7 +168,7 @@ public: ...@@ -168,7 +168,7 @@ public:
} }
void doFrameCountTest() void doFrameCountTest()
{ {
if (!videoio_registry::hasBackend(apiPref, videoio_registry::Read)) if (!videoio_registry::hasBackend(apiPref))
throw SkipTestException(cv::String("Backend is not available/disabled: ") + cv::videoio_registry::getBackendName(apiPref)); throw SkipTestException(cv::String("Backend is not available/disabled: ") + cv::videoio_registry::getBackendName(apiPref));
VideoCapture cap; VideoCapture cap;
EXPECT_NO_THROW(cap.open(video_file, apiPref)); EXPECT_NO_THROW(cap.open(video_file, apiPref));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment