mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-23 18:50:21 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

build: made environment access a separate feature

Browse Source
This commit is contained in:
Maksim Shabunin 2024-10-17 23:35:38 +03:00
parent 2756c20e3e
commit 04818d6dd5
44 changed files with 176 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -536,6 +536,7 @@ OCV_OPTION(ENABLE_CONFIG_VERIFICATION "Fail build if actual configuration doesn'
OCV_OPTION(OPENCV_ENABLE_MEMALIGN "Enable posix_memalign or memalign usage" ON)
OCV_OPTION(OPENCV_DISABLE_FILESYSTEM_SUPPORT "Disable filesystem support" OFF)
OCV_OPTION(OPENCV_DISABLE_THREAD_SUPPORT "Build the library without multi-threaded code." OFF)
OCV_OPTION(OPENCV_DISABLE_ENV_SUPPORT "Disable environment variables access (getenv)" (CMAKE_SYSTEM_NAME MATCHES "Windows(CE|Phone|Store)"))
OCV_OPTION(OPENCV_SEMIHOSTING "Build the library for semihosting target (Arm). See https://developer.arm.com/documentation/100863/latest." OFF)
OCV_OPTION(ENABLE_CUDA_FIRST_CLASS_LANGUAGE "Enable CUDA as a first class language, if enabled dependant projects will need to use CMake >= 3.18" OFF
VISIBLE_IF (WITH_CUDA AND NOT CMAKE_VERSION VERSION_LESS 3.18)

2
cmake/platforms/OpenCV-WinRT.cmake
View File

@ -1,6 +1,6 @@
set(WINRT TRUE)
add_definitions(-DWINRT -DNO_GETENV)
add_definitions(-DWINRT)
# Making definitions available to other configurations and
# to filter dependency restrictions at compile time.

2
cmake/platforms/OpenCV-WindowsCE.cmake
View File

@ -1 +1 @@
add_definitions(-DNO_GETENV)
# empty

15
doc/tutorials/introduction/env_reference/env_reference.markdown
View File

@ -59,7 +59,6 @@ import cv2 # variables set after this may not have effect
## Types
- _non-null_ - set to anything to enable feature, in some cases can be interpreted as other types (e.g. path)
- _bool_ - `1`, `True`, `true`, `TRUE` / `0`, `False`, `false`, `FALSE`
- _number_/_size_ - unsigned number, suffixes `MB`, `Mb`, `mb`, `KB`, `Kb`, `kb`
- _string_ - plain string or can have a structure
@ -70,7 +69,7 @@ import cv2 # variables set after this may not have effect
## General, core
| name | type | default | description |
|------|------|---------|-------------|
| OPENCV_SKIP_CPU_BASELINE_CHECK | non-null | | do not check that current CPU supports all features used by the build (baseline) |
| OPENCV_SKIP_CPU_BASELINE_CHECK | bool | false | do not check that current CPU supports all features used by the build (baseline) |
| OPENCV_CPU_DISABLE | `,` or `;`-separated | | disable code branches which use CPU features (dispatched code) |
| OPENCV_SETUP_TERMINATE_HANDLER | bool | true (Windows) | use std::set_terminate to install own termination handler |
| OPENCV_LIBVA_RUNTIME | file path | | libva for VA interoperability utils |
@ -78,9 +77,9 @@ import cv2 # variables set after this may not have effect
| OPENCV_BUFFER_AREA_ALWAYS_SAFE | bool | false | enable safe mode for multi-buffer allocations (each buffer separately) |
| OPENCV_KMEANS_PARALLEL_GRANULARITY | num | 1000 | tune algorithm parallel work distribution parameter `parallel_for_(..., ..., ..., granularity)` |
| OPENCV_DUMP_ERRORS | bool | true (Debug or Android), false (others) | print extra information on exception (log to Android) |
| OPENCV_DUMP_CONFIG | non-null | | print build configuration to stderr (`getBuildInformation`) |
| OPENCV_DUMP_CONFIG | bool | false | print build configuration to stderr (`getBuildInformation`) |
| OPENCV_PYTHON_DEBUG | bool | false | enable extra warnings in Python bindings |
| OPENCV_TEMP_PATH | non-null / path | `/tmp/` (Linux), `/data/local/tmp/` (Android), `GetTempPathA` (Windows) | directory for temporary files |
| OPENCV_TEMP_PATH | path | `/tmp/` (Linux), `/data/local/tmp/` (Android), `GetTempPathA` (Windows) | directory for temporary files |
| OPENCV_DATA_PATH_HINT | paths | | paths for findDataFile |
| OPENCV_DATA_PATH | paths | | paths for findDataFile |
| OPENCV_SAMPLES_DATA_PATH_HINT | paths | | paths for findDataFile |
@ -272,7 +271,7 @@ Some external dependencies can be detached into a dynamic library, which will be
| ⭐ OPENCV_FFMPEG_CAPTURE_OPTIONS | string (see note) | | extra options for VideoCapture FFmpeg backend |
| ⭐ OPENCV_FFMPEG_WRITER_OPTIONS | string (see note) | | extra options for VideoWriter FFmpeg backend |
| OPENCV_FFMPEG_THREADS | num | | set FFmpeg thread count |
| OPENCV_FFMPEG_DEBUG | non-null | | enable logging messages from FFmpeg |
| OPENCV_FFMPEG_DEBUG | bool | false | enable logging messages from FFmpeg |
| OPENCV_FFMPEG_LOGLEVEL | num | | set FFmpeg logging level |
| OPENCV_FFMPEG_DLL_DIR | dir path | | directory with FFmpeg plugin (legacy) |
| OPENCV_FFMPEG_IS_THREAD_SAFE | bool | false | enabling this option will turn off thread safety locks in the FFmpeg backend (use only if you are sure FFmpeg is built with threading support, tested on Linux) |
@ -286,7 +285,7 @@ Some external dependencies can be detached into a dynamic library, which will be
| OPENCV_VIDEOIO_MFX_BITRATE_DIVISOR | num | 300 | this option allows to tune encoding bitrate (video quality/size) |
| OPENCV_VIDEOIO_MFX_WRITER_TIMEOUT | num | 1 | timeout for encoding operation (in seconds) |
| OPENCV_VIDEOIO_MSMF_ENABLE_HW_TRANSFORMS | bool | true | allow HW-accelerated transformations (DXVA) in MediaFoundation processing graph (may slow down camera probing process) |
| OPENCV_DSHOW_DEBUG | non-null | | enable verbose logging in the DShow backend |
| OPENCV_DSHOW_DEBUG | bool | false | enable verbose logging in the DShow backend |
| OPENCV_DSHOW_SAVEGRAPH_FILENAME | file path | | enable processing graph tump in the DShow backend |
| OPENCV_VIDEOIO_V4L_RANGE_NORMALIZED | bool | false | use (0, 1) range for properties (V4L) |
| OPENCV_VIDEOIO_V4L_SELECT_TIMEOUT | num | 10 | timeout for select call (in seconds) (V4L) |
@ -297,7 +296,7 @@ Some external dependencies can be detached into a dynamic library, which will be
### videoio tests
| name | type | default | description |
|------|------|---------|-------------|
| OPENCV_TEST_VIDEOIO_BACKEND_REQUIRE_FFMPEG | | | test app will exit if no FFmpeg backend is available |
| OPENCV_TEST_VIDEOIO_BACKEND_REQUIRE_FFMPEG | bool | false | test app will exit if no FFmpeg backend is available |
| OPENCV_TEST_V4L2_VIVID_DEVICE | file path | | path to VIVID virtual camera device for V4L2 test (e.g. `/dev/video5`) |
| OPENCV_TEST_PERF_CAMERA_LIST | paths | | cameras to use in performance test (waitAny_V4L test) |
| OPENCV_TEST_CAMERA_%d_FPS | num | | fps to set for N-th camera (0-based index) (waitAny_V4L test) |
@ -327,7 +326,7 @@ Some external dependencies can be detached into a dynamic library, which will be
| name | type | default | description |
|------|------|---------|-------------|
| OPENCV_LEGACY_WAITKEY | non-null | | switch `waitKey` return result (default behavior: `return code & 0xff` (or -1), legacy behavior: `return code`) |
| OPENCV_LEGACY_WAITKEY | bool | false | switch `waitKey` return result (default behavior: `return code & 0xff` (or -1), legacy behavior: `return code`) |
| $XDG_RUNTIME_DIR | | | Wayland backend specific - create shared memory-mapped file for interprocess communication (named `opencv-shared-??????`) |
| OPENCV_HIGHGUI_FB_MODE | string | `FB` | Selects output mode for the framebuffer backend (`FB` - regular frambuffer, `EMU` - emulation, perform internal checks but does nothing, `XVFB` - compatible with _xvfb_ virtual frambuffer) |
| OPENCV_HIGHGUI_FB_DEVICE | file path | | Path to frambuffer device to use (will be checked first) |

4
modules/core/CMakeLists.txt
View File

@ -182,6 +182,10 @@ if(OPENCV_DISABLE_THREAD_SUPPORT)
ocv_target_compile_definitions(${the_module} PUBLIC "OPENCV_DISABLE_THREAD_SUPPORT=1")
endif()
if(OPENCV_DISABLE_ENV_SUPPORT)
ocv_append_source_file_compile_definitions(${CMAKE_CURRENT_SOURCE_DIR}/src/system.cpp "NO_GETENV")
endif()
if(OPENCV_SEMIHOSTING)
ocv_target_compile_definitions(${the_module} PRIVATE "-DOPENCV_SEMIHOSTING")
endif(OPENCV_SEMIHOSTING)

6
modules/core/include/opencv2/core/utils/configuration.private.hpp
View File

@ -12,9 +12,9 @@
namespace cv { namespace utils {
typedef std::vector<std::string> Paths;
CV_EXPORTS bool getConfigurationParameterBool(const char* name, bool defaultValue);
CV_EXPORTS size_t getConfigurationParameterSizeT(const char* name, size_t defaultValue);
CV_EXPORTS cv::String getConfigurationParameterString(const char* name, const char* defaultValue);
CV_EXPORTS bool getConfigurationParameterBool(const char* name, bool defaultValue = false);
CV_EXPORTS size_t getConfigurationParameterSizeT(const char* name, size_t defaultValue = 0);
CV_EXPORTS std::string getConfigurationParameterString(const char* name, const std::string & defaultValue = std::string());
CV_EXPORTS Paths getConfigurationParameterPaths(const char* name, const Paths &defaultValue = Paths());
}} // namespace

43
modules/core/src/ocl.cpp
View File

@ -1170,10 +1170,10 @@ bool haveOpenCL()
if (!g_isOpenCLInitialized)
{
CV_TRACE_REGION("Init_OpenCL_Runtime");
const char* envPath = getenv("OPENCV_OPENCL_RUNTIME");
if (envPath)
std::string envPath = utils::getConfigurationParameterString("OPENCV_OPENCL_RUNTIME");
if (!envPath.empty())
{
if (cv::String(envPath) == "disabled")
if (envPath == "disabled")
{
g_isOpenCLAvailable = false;
g_isOpenCLInitialized = true;
@ -2119,24 +2119,18 @@ static bool parseOpenCLDeviceConfiguration(const std::string& configurationStr,
return true;
}
#if defined WINRT || defined _WIN32_WCE
static cl_device_id selectOpenCLDevice(const char* configuration = NULL)
{
CV_UNUSED(configuration)
return NULL;
}
#else
static cl_device_id selectOpenCLDevice(const char* configuration = NULL)
static cl_device_id selectOpenCLDevice(const std::string & configuration_ = std::string())
{
std::string platform, deviceName;
std::vector<std::string> deviceTypes;
if (!configuration)
configuration = getenv("OPENCV_OPENCL_DEVICE");
std::string configuration(configuration_);
if (configuration.empty())
configuration = utils::getConfigurationParameterString("OPENCV_OPENCL_DEVICE");
if (configuration &&
(strcmp(configuration, "disabled") == 0 ||
!parseOpenCLDeviceConfiguration(std::string(configuration), platform, deviceTypes, deviceName)
if (!configuration.empty() &&
(configuration == "disabled" ||
!parseOpenCLDeviceConfiguration(configuration, platform, deviceTypes, deviceName)
))
return NULL;
@ -2204,7 +2198,7 @@ static cl_device_id selectOpenCLDevice(const char* configuration = NULL)
if (!isID)
{
deviceTypes.push_back("GPU");
if (configuration)
if (!configuration.empty())
deviceTypes.push_back("CPU");
}
else
@ -2272,7 +2266,7 @@ static cl_device_id selectOpenCLDevice(const char* configuration = NULL)
}
not_found:
if (!configuration)
if (configuration.empty())
return NULL; // suppress messages on stderr
std::ostringstream msg;
@ -2287,7 +2281,6 @@ not_found:
CV_LOG_ERROR(NULL, msg.str());
return NULL;
}
#endif
#ifdef HAVE_OPENCL_SVM
namespace svm {
@ -2340,12 +2333,12 @@ static unsigned int getSVMCapabilitiesMask()
static unsigned int mask = 0;
if (!initialized)
{
const char* envValue = getenv("OPENCV_OPENCL_SVM_CAPABILITIES_MASK");
if (envValue == NULL)
const std::string envValue = utils::getConfigurationParameterString("OPENCV_OPENCL_SVM_CAPABILITIES_MASK");
if (envValue.empty())
{
return ~0U; // all bits 1
}
mask = atoi(envValue);
mask = atoi(envValue.c_str());
initialized = true;
}
return mask;
@ -2482,8 +2475,8 @@ public:
std::string configuration = configuration_;
if (configuration_.empty())
{
const char* c = getenv("OPENCV_OPENCL_DEVICE");
if (c)
const std::string c = utils::getConfigurationParameterString("OPENCV_OPENCL_DEVICE");
if (!c.empty())
configuration = c;
}
Impl* impl = findContext(configuration);
@ -2494,7 +2487,7 @@ public:
return impl;
}
cl_device_id d = selectOpenCLDevice(configuration.empty() ? NULL : configuration.c_str());
cl_device_id d = selectOpenCLDevice(configuration);
if (d == NULL)
return NULL;

45
modules/core/src/opencl/runtime/opencl_core.cpp
View File

@ -44,6 +44,7 @@
#if defined(HAVE_OPENCL)
#include "opencv2/core.hpp" // CV_Error
#include "opencv2/core/utils/configuration.private.hpp"
#if defined(HAVE_OPENCL_STATIC)
#if defined __APPLE__
@ -64,18 +65,14 @@ CV_SUPPRESS_DEPRECATED_END
#define ERROR_MSG_CANT_LOAD "Failed to load OpenCL runtime\n"
#define ERROR_MSG_INVALID_VERSION "Failed to load OpenCL runtime (expected version 1.1+)\n"
static const char* getRuntimePath(const char* defaultPath)
static std::string getRuntimePath(const std::string & defaultPath)
{
const char* envPath = getenv("OPENCV_OPENCL_RUNTIME");
if (envPath)
{
static const char disabled_str[] = "disabled";
if ((strlen(envPath) == sizeof(disabled_str) - 1) &&
(memcmp(envPath, disabled_str, sizeof(disabled_str) - 1) == 0))
return NULL;
return envPath;
}
return defaultPath;
const std::string res = cv::utils::getConfigurationParameterString(
"OPENCV_OPENCL_RUNTIME", defaultPath);
if (res == "disabled")
return std::string();
else
return res;
}
#if defined(__APPLE__)
@ -91,9 +88,9 @@ static void* AppleCLGetProcAddress(const char* name)
if (!initialized)
{
const char* defaultPath = "/System/Library/Frameworks/OpenCL.framework/Versions/Current/OpenCL";
const char* path = getRuntimePath(defaultPath);
if (path)
handle = dlopen(path, RTLD_LAZY | RTLD_GLOBAL);
std::string path = getRuntimePath(defaultPath);
if (!path.empty())
handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_GLOBAL);
if (handle == NULL)
{
if (path != NULL && path != defaultPath)
@ -129,13 +126,13 @@ static void* WinGetProcAddress(const char* name)
handle = GetModuleHandleA("OpenCL.dll");
if (!handle)
{
const char* defaultPath = "OpenCL.dll";
const char* path = getRuntimePath(defaultPath);
if (path)
handle = LoadLibraryA(path);
const std::string defaultPath = "OpenCL.dll";
const std::string path = getRuntimePath(defaultPath);
if (!path.empty())
handle = LoadLibraryA(path.c_str());
if (!handle)
{
if (path != NULL && path != defaultPath)
if (!path.empty() && path != defaultPath)
fprintf(stderr, ERROR_MSG_CANT_LOAD);
}
else if (GetProcAddress(handle, OPENCL_FUNC_TO_CHECK_1_1) == NULL)
@ -205,8 +202,8 @@ static void* GetProcAddress(const char* name)
bool foundOpenCL = false;
for (unsigned int i = 0; i < (sizeof(defaultAndroidPaths)/sizeof(char*)); i++)
{
const char* path = (i==0) ? getRuntimePath(defaultAndroidPaths[i]) : defaultAndroidPaths[i];
if (path) {
const std::string path = (i==0) ? getRuntimePath(defaultAndroidPaths[i]) : defaultAndroidPaths[i];
if (!path.empty()) {
handle = GetHandle(path);
if (handle) {
foundOpenCL = true;
@ -236,10 +233,10 @@ static void* GetProcAddress(const char* name)
if (!initialized)
{
const char* defaultPath = "libOpenCL.so";
const char* path = getRuntimePath(defaultPath);
if (path)
const std::string path = getRuntimePath(defaultPath);
if (!path.empty())
{
handle = GetHandle(path);
handle = GetHandle(path.c_str());
if (!handle)
{
if (path == defaultPath)

2
modules/core/src/parallel/registry_parallel.impl.hpp
View File

@ -111,7 +111,7 @@ protected:
bool readPrioritySettings()
{
bool hasChanges = false;
cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_PARALLEL_PRIORITY_LIST", NULL);
cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_PARALLEL_PRIORITY_LIST");
if (prioritized_backends.empty())
return hasChanges;
CV_LOG_INFO(NULL, "core(parallel): Configured priority list (OPENCV_PARALLEL_PRIORITY_LIST): " << prioritized_backends);

53
modules/core/src/system.cpp
View File

@ -450,13 +450,11 @@ struct HWFeatures
void initialize(void)
{
#ifndef NO_GETENV
if (getenv("OPENCV_DUMP_CONFIG"))
if (utils::getConfigurationParameterBool("OPENCV_DUMP_CONFIG"))
{
fprintf(stderr, "\nOpenCV build configuration is:\n%s\n",
cv::getBuildInformation().c_str());
}
#endif
initializeNames();
@ -731,12 +729,10 @@ struct HWFeatures
#endif
bool skip_baseline_check = false;
#ifndef NO_GETENV
if (getenv("OPENCV_SKIP_CPU_BASELINE_CHECK"))
if (utils::getConfigurationParameterBool("OPENCV_SKIP_CPU_BASELINE_CHECK"))
{
skip_baseline_check = true;
}
#endif
int baseline_features[] = { CV_CPU_BASELINE_FEATURES };
if (!checkFeatures(baseline_features, sizeof(baseline_features) / sizeof(baseline_features[0]))
&& !skip_baseline_check)
@ -786,15 +782,10 @@ struct HWFeatures
void readSettings(const int* baseline_features, int baseline_count)
{
bool dump = true;
const char* disabled_features =
#ifdef NO_GETENV
NULL;
#else
getenv("OPENCV_CPU_DISABLE");
#endif
if (disabled_features && disabled_features[0] != 0)
std::string disabled_features = utils::getConfigurationParameterString("OPENCV_CPU_DISABLE");
if (!disabled_features.empty())
{
const char* start = disabled_features;
const char* start = disabled_features.c_str();
for (;;)
{
while (start[0] != 0 && isSymbolSeparator(start[0]))
@ -1080,20 +1071,19 @@ String tempfile( const char* suffix )
{
#if OPENCV_HAVE_FILESYSTEM_SUPPORT
String fname;
#ifndef NO_GETENV
const char *temp_dir = getenv("OPENCV_TEMP_PATH");
#endif
std::string temp_dir = utils::getConfigurationParameterString("OPENCV_TEMP_PATH");
#if defined _WIN32
#ifdef WINRT
RoInitialize(RO_INIT_MULTITHREADED);
std::wstring temp_dir = GetTempPathWinRT();
std::wstring temp_dir_rt = GetTempPathWinRT();
std::wstring temp_file = GetTempFileNameWinRT(L"ocv");
if (temp_file.empty())
return String();
temp_file = temp_dir.append(std::wstring(L"\\")).append(temp_file);
temp_file = temp_dir_rt.append(std::wstring(L"\\")).append(temp_file);
DeleteFileW(temp_file.c_str());
char aname[MAX_PATH];
@ -1103,12 +1093,12 @@ String tempfile( const char* suffix )
RoUninitialize();
#elif defined(_WIN32_WCE)
const auto kMaxPathSize = MAX_PATH+1;
wchar_t temp_dir[kMaxPathSize] = {0};
wchar_t temp_dir_ce[kMaxPathSize] = {0};
wchar_t temp_file[kMaxPathSize] = {0};
::GetTempPathW(kMaxPathSize, temp_dir);
::GetTempPathW(kMaxPathSize, temp_dir_ce);
if(0 != ::GetTempFileNameW(temp_dir, L"ocv", 0, temp_file)) {
if(0 != ::GetTempFileNameW(temp_dir_ce, L"ocv", 0, temp_file)) {
DeleteFileW(temp_file);
char aname[MAX_PATH];
size_t copied = wcstombs(aname, temp_file, MAX_PATH);
@ -1119,12 +1109,12 @@ String tempfile( const char* suffix )
char temp_dir2[MAX_PATH] = { 0 };
char temp_file[MAX_PATH] = { 0 };
if (temp_dir == 0 || temp_dir[0] == 0)
if (temp_dir.empty())
{
::GetTempPathA(sizeof(temp_dir2), temp_dir2);
temp_dir = temp_dir2;
temp_dir = std::string(temp_dir2);
}
if(0 == ::GetTempFileNameA(temp_dir, "ocv", 0, temp_file))
if(0 == ::GetTempFileNameA(temp_dir.c_str(), "ocv", 0, temp_file))
return String();
DeleteFileA(temp_file);
@ -1139,7 +1129,7 @@ String tempfile( const char* suffix )
char defaultTemplate[] = "/tmp/__opencv_temp.XXXXXX";
# endif
if (temp_dir == 0 || temp_dir[0] == 0)
if (temp_dir.empty())
fname = defaultTemplate;
else
{
@ -2289,9 +2279,9 @@ size_t utils::getConfigurationParameterSizeT(const char* name, size_t defaultVal
return read<size_t>(name, defaultValue);
}
cv::String utils::getConfigurationParameterString(const char* name, const char* defaultValue)
std::string utils::getConfigurationParameterString(const char* name, const std::string & defaultValue)
{
return read<cv::String>(name, defaultValue ? cv::String(defaultValue) : cv::String());
return read<cv::String>(name, defaultValue);
}
utils::Paths utils::getConfigurationParameterPaths(const char* name, const utils::Paths &defaultValue)
@ -2588,11 +2578,8 @@ public:
}
ippFeatures = cpuFeatures;
const char* pIppEnv = getenv("OPENCV_IPP");
cv::String env;
if(pIppEnv != NULL)
env = pIppEnv;
if(env.size())
std::string env = utils::getConfigurationParameterString("OPENCV_IPP");
if(!env.empty())
{
#if IPP_VERSION_X100 >= 201900
const Ipp64u minorFeatures = ippCPUID_MOVBE|ippCPUID_AES|ippCPUID_CLMUL|ippCPUID_ABR|ippCPUID_RDRAND|ippCPUID_F16C|

2
modules/core/src/utils/datafile.cpp
View File

@ -60,7 +60,7 @@ static std::vector<cv::String>& _getDataSearchSubDirectory()
CV_EXPORTS void addDataSearchPath(const cv::String& path)
{
if (utils::fs::isDirectory(path))
if (!path.empty() && utils::fs::isDirectory(path))
_getDataSearchPath().push_back(path);
}
CV_EXPORTS void addDataSearchSubDirectory(const cv::String& subdir)

12
modules/core/src/utils/filesystem.cpp
View File

@ -447,8 +447,8 @@ cv::String getCacheDirectory(const char* sub_directory_name, const char* configu
#elif defined __ANDROID__
// no defaults
#elif defined __APPLE__
const char* tmpdir_env = getenv("TMPDIR");
if (tmpdir_env && utils::fs::isDirectory(tmpdir_env))
const std::string tmpdir_env = utils::getConfigurationParameterString("TMPDIR");
if (!tmpdir_env.empty() && utils::fs::isDirectory(tmpdir_env))
{
default_cache_path = tmpdir_env;
}
@ -461,16 +461,16 @@ cv::String getCacheDirectory(const char* sub_directory_name, const char* configu
// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
if (default_cache_path.empty())
{
const char* xdg_cache_env = getenv("XDG_CACHE_HOME");
if (xdg_cache_env && xdg_cache_env[0] && utils::fs::isDirectory(xdg_cache_env))
const std::string xdg_cache_env = utils::getConfigurationParameterString("XDG_CACHE_HOME");
if (!xdg_cache_env.empty() && utils::fs::isDirectory(xdg_cache_env))
{
default_cache_path = xdg_cache_env;
}
}
if (default_cache_path.empty())
{
const char* home_env = getenv("HOME");
if (home_env && home_env[0] && utils::fs::isDirectory(home_env))
const std::string home_env = utils::getConfigurationParameterString("HOME");
if (!home_env.empty() && utils::fs::isDirectory(home_env))
{
cv::String home_path = home_env;
cv::String home_cache_path = utils::fs::join(home_path, ".cache/");

5
modules/core/src/va_wrapper.impl.hpp
View File

@ -7,6 +7,7 @@
//
#include "opencv2/core/utils/plugin_loader.private.hpp" // DynamicLib
#include "opencv2/core/utils/configuration.private.hpp"
namespace cv { namespace detail {
@ -47,8 +48,8 @@ static FN_vaGetImage fn_vaGetImage = NULL;
static std::shared_ptr<cv::plugin::impl::DynamicLib> loadLibVA()
{
std::shared_ptr<cv::plugin::impl::DynamicLib> lib;
const char* envPath = getenv("OPENCV_LIBVA_RUNTIME");
if (envPath)
const std::string envPath = utils::getConfigurationParameterString("OPENCV_LIBVA_RUNTIME");
if (!envPath.empty())
{
lib = std::make_shared<cv::plugin::impl::DynamicLib>(envPath);
return lib;

11
modules/dnn/perf/perf_main.cpp
View File

@ -1,16 +1,7 @@
#include "perf_precomp.hpp"
static const char* extraTestDataPath =
#ifdef WINRT
NULL;
#else
getenv("OPENCV_DNN_TEST_DATA_PATH");
#endif
#if defined(HAVE_HPX)
#include <hpx/hpx_main.hpp>
#endif
CV_PERF_TEST_MAIN(dnn,
extraTestDataPath ? (void)cvtest::addDataSearchPath(extraTestDataPath) : (void)0
)
CV_PERF_TEST_MAIN(dnn, cvtest::addDataSearchEnv("OPENCV_DNN_TEST_DATA_PATH"))

3
modules/dnn/src/precomp.hpp
View File

@ -47,6 +47,7 @@
#endif
#include <opencv2/core.hpp>
#include "opencv2/core/utils/configuration.private.hpp"
#ifndef CV_OCL4DNN
#define CV_OCL4DNN 0
@ -89,4 +90,4 @@
#include <opencv2/dnn/all_layers.hpp>
#include <opencv2/dnn/shape_utils.hpp>
#include "dnn_common.hpp"
#include "dnn_common.hpp"

15
modules/dnn/src/vkcom/vulkan/vk_loader.cpp
View File

@ -115,21 +115,12 @@ bool loadVulkanLibrary()
if (handle != nullptr)
return true;
const char* path;
const char* envPath = getenv("OPENCV_VULKAN_RUNTIME");
if (envPath)
{
path = envPath;
}
else
{
path = DEFAULT_VK_LIBRARY_PATH;
}
const std::string path = cv::utils::getConfigurationParameterString("OPENCV_VULKAN_RUNTIME", DEFAULT_VK_LIBRARY_PATH);
handle = LOAD_VK_LIBRARY(path);
handle = LOAD_VK_LIBRARY(path.c_str());
if( handle == nullptr )
{
fprintf(stderr, "Could not load Vulkan library: %s!\n", path);
fprintf(stderr, "Could not load Vulkan library: %s!\n", path.c_str());
fprintf(stderr, "Please download the Vulkan SDK and set the environment variable of OPENCV_VULKAN_RUNTIME according "
"to your system environment.\n");
fprintf(stderr, "For M1 Mac and IOS, we use MoltenVK to map the Vulkan code to native apple Metal code.\n");

9
modules/dnn/test/test_common.impl.hpp
View File

@ -437,14 +437,7 @@ bool validateVPUType()
void initDNNTests()
{
const char* extraTestDataPath =
#ifdef WINRT
NULL;
#else
getenv("OPENCV_DNN_TEST_DATA_PATH");
#endif
if (extraTestDataPath)
cvtest::addDataSearchPath(extraTestDataPath);
cvtest::addDataSearchEnv("OPENCV_DNN_TEST_DATA_PATH");
registerGlobalSkipTag(
CV_TEST_TAG_DNN_SKIP_OPENCV_BACKEND,

12
modules/dnn/test/test_ie_models.cpp
View File

@ -40,15 +40,11 @@ static void initDLDTDataPath()
if (!initialized)
{
#if INF_ENGINE_RELEASE <= 2018050000
const char* dldtTestDataPath = getenv("INTEL_CVSDK_DIR");
if (dldtTestDataPath)
cvtest::addDataSearchPath(dldtTestDataPath);
cvtest::addDataSearchEnv("INTEL_CVSDK_DIR");
#else
const char* omzDataPath = getenv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
if (omzDataPath)
cvtest::addDataSearchPath(omzDataPath);
const char* dnnDataPath = getenv("OPENCV_DNN_TEST_DATA_PATH");
if (dnnDataPath)
cvtest::addDataSearchEnv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
const std::string dnnDataPath = cv::utils::getConfigurationParameterString("OPENCV_DNN_TEST_DATA_PATH");
if (!dnnDataPath.empty())
cvtest::addDataSearchPath(std::string(dnnDataPath) + "/omz_intel_models");
#endif
initialized = true;

1
modules/dnn/test/test_precomp.hpp
View File

@ -45,6 +45,7 @@
#include "opencv2/ts/ts_perf.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/ocl.hpp"
#include "opencv2/core/utils/configuration.private.hpp"
#include "opencv2/dnn.hpp"
#include "test_common.hpp"

6
modules/gapi/src/compiler/gcompiler.cpp
View File

@ -99,9 +99,9 @@ namespace
auto dump_info = cv::gapi::getCompileArg<cv::graph_dump_path>(args);
if (!dump_info.has_value())
{
const char* path = std::getenv("GRAPH_DUMP_PATH");
return path
? cv::util::make_optional(std::string(path))
const std::string path = cv::utils::getConfigurationParameterString("GRAPH_DUMP_PATH");
return !path.empty()
? cv::util::make_optional(path)
: cv::util::optional<std::string>();
}
else

1
modules/gapi/src/precomp.hpp
View File

@ -10,6 +10,7 @@
#if !defined(GAPI_STANDALONE)
# include <opencv2/core.hpp>
# include <opencv2/core/utils/configuration.private.hpp>
# include <opencv2/imgproc.hpp>
# include <opencv2/gapi/core.hpp>
# include <opencv2/gapi/imgproc.hpp>

10
modules/gapi/test/infer/gapi_infer_ie_test.cpp
View File

@ -101,22 +101,18 @@ public:
// FIXME: taken from DNN module
static void initDLDTDataPath()
{
#ifndef WINRT
static bool initialized = false;
if (!initialized)
{
const char* omzDataPath = getenv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
if (omzDataPath)
cvtest::addDataSearchPath(omzDataPath);
const char* dnnDataPath = getenv("OPENCV_DNN_TEST_DATA_PATH");
if (dnnDataPath) {
cvtest::addDataSearchEnv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
const std::string dnnDataPath = cv::utils::getConfigurationParameterString("OPENCV_DNN_TEST_DATA_PATH");
if (!dnnDataPath.empty()) {
// Add the dnnDataPath itself - G-API is using some images there directly
cvtest::addDataSearchPath(dnnDataPath);
cvtest::addDataSearchPath(dnnDataPath + std::string("/omz_intel_models"));
}
initialized = true;
}
#endif // WINRT
}
#if INF_ENGINE_RELEASE >= 2020010000

5
modules/gapi/test/infer/gapi_infer_onnx_test.cpp
View File

@ -58,10 +58,7 @@ public:
};
struct ONNXInitPath {
ONNXInitPath() {
const char* env_path = getenv("OPENCV_GAPI_ONNX_MODEL_PATH");
if (env_path) {
cvtest::addDataSearchPath(env_path);
}
cvtest::addDataSearchEnv("OPENCV_GAPI_ONNX_MODEL_PATH");
}
};
static ONNXInitPath g_init_path;

8
modules/gapi/test/infer/gapi_infer_ov_tests.cpp
View File

@ -25,11 +25,9 @@ void initDLDTDataPath()
static bool initialized = false;
if (!initialized)
{
const char* omzDataPath = getenv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
if (omzDataPath)
cvtest::addDataSearchPath(omzDataPath);
const char* dnnDataPath = getenv("OPENCV_DNN_TEST_DATA_PATH");
if (dnnDataPath) {
cvtest::addDataSearchEnv("OPENCV_OPEN_MODEL_ZOO_DATA_PATH");
const std::string dnnDataPath = cv::utils::getConfigurationParameterString("OPENCV_DNN_TEST_DATA_PATH");
if (!dnnDataPath.empty()) {
// Add the dnnDataPath itself - G-API is using some images there directly
cvtest::addDataSearchPath(dnnDataPath);
cvtest::addDataSearchPath(dnnDataPath + std::string("/omz_intel_models"));

2
modules/gapi/test/test_precomp.hpp
View File

@ -16,6 +16,8 @@
#include <opencv2/ts.hpp>
#include <opencv2/core/utils/configuration.private.hpp>
#include <opencv2/gapi.hpp>
#include <opencv2/gapi/core.hpp>
#include <opencv2/gapi/imgproc.hpp>

1
modules/highgui/src/precomp.hpp
View File

@ -54,6 +54,7 @@
#include "opencv2/core/utility.hpp"
#if defined(__OPENCV_BUILD)
#include "opencv2/core/private.hpp"
#include "opencv2/core/utils/configuration.private.hpp"
#endif
#include "opencv2/imgproc.hpp"

2
modules/highgui/src/registry.impl.hpp
View File

@ -133,7 +133,7 @@ protected:
bool readPrioritySettings()
{
bool hasChanges = false;
cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_UI_PRIORITY_LIST", NULL);
cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_UI_PRIORITY_LIST");
if (prioritized_backends.empty())
return hasChanges;
CV_LOG_INFO(NULL, "UI: Configured priority list (OPENCV_UI_PRIORITY_LIST): " << prioritized_backends);

2
modules/highgui/src/window.cpp
View File

@ -662,7 +662,7 @@ int cv::waitKey(int delay)
static int use_legacy = -1;
if (use_legacy < 0)
{
use_legacy = getenv("OPENCV_LEGACY_WAITKEY") != NULL ? 1 : 0;
use_legacy = utils::getConfigurationParameterBool("OPENCV_LEGACY_WAITKEY");
}
if (use_legacy > 0)
return code;

2
modules/highgui/src/window_wayland.cpp
View File

@ -1378,7 +1378,7 @@ int cv_wl_buffer::create_tmpfile(std::string const &tmpname) {
}
int cv_wl_buffer::create_anonymous_file(off_t size) {
auto path = getenv("XDG_RUNTIME_DIR") + std::string("/opencv-shared-XXXXXX");
auto path = cv::utils::getConfigurationParameterString("XDG_RUNTIME_DIR") + std::string("/opencv-shared-XXXXXX");
int fd = create_tmpfile(path);
int ret = posix_fallocate(fd, 0, size);

9
modules/objdetect/test/test_main.cpp
View File

@ -11,14 +11,7 @@ static
void initTests()
{
#ifdef HAVE_OPENCV_DNN
const char* extraTestDataPath =
#ifdef WINRT
NULL;
#else
getenv("OPENCV_DNN_TEST_DATA_PATH");
#endif
if (extraTestDataPath)
cvtest::addDataSearchPath(extraTestDataPath);
cvtest::addDataSearchEnv("OPENCV_DNN_TEST_DATA_PATH");
#endif // HAVE_OPENCV_DNN
}

1
modules/ts/include/opencv2/ts.hpp
View File

@ -754,6 +754,7 @@ void smoothBorder(Mat& img, const Scalar& color, int delta = 3);
// Utility functions
void addDataSearchPath(const std::string& path);
void addDataSearchEnv(const std::string& env_name);
void addDataSearchSubDirectory(const std::string& subdir);
/*! @brief Try to find requested data file

1
modules/ts/src/precomp.hpp
View File

@ -1,5 +1,6 @@
#include "opencv2/ts.hpp"
#include <opencv2/core/utils/logger.hpp>
#include "opencv2/core/utils/configuration.private.hpp"
#include "opencv2/core/utility.hpp"
#if !defined(__EMSCRIPTEN__)
#include "opencv2/core/private.hpp"

29
modules/ts/src/ts.cpp
View File

@ -553,13 +553,9 @@ static int tsErrorCallback( int status, const char* func_name, const char* err_m
void TS::init( const string& modulename )
{
data_search_subdir.push_back(modulename);
#ifndef WINRT
char* datapath_dir = getenv("OPENCV_TEST_DATA_PATH");
#else
char* datapath_dir = OPENCV_TEST_DATA_PATH;
#endif
std::string datapath_dir = cv::utils::getConfigurationParameterString("OPENCV_TEST_DATA_PATH");
if( datapath_dir )
if( !datapath_dir.empty() )
{
data_path = path_join(path_join(datapath_dir, modulename), "");
}
@ -903,11 +899,7 @@ void parseCustomOptions(int argc, char **argv)
test_ipp_check = parser.get<bool>("test_ipp_check");
if (!test_ipp_check)
#ifndef WINRT
test_ipp_check = getenv("OPENCV_IPP_CHECK") != NULL;
#else
test_ipp_check = false;
#endif
test_ipp_check = cv::utils::getConfigurationParameterBool("OPENCV_IPP_CHECK");
param_seed = parser.get<unsigned int>("test_seed");
@ -953,9 +945,14 @@ static bool isDirectory(const std::string& path)
void addDataSearchPath(const std::string& path)
{
if (isDirectory(path))
if (!path.empty() && isDirectory(path))
TS::ptr()->data_search_path.push_back(path);
}
void addDataSearchEnv(const std::string& env_name)
{
const std::string val = cv::utils::getConfigurationParameterString(env_name.c_str());
cvtest::addDataSearchPath(val);
}
void addDataSearchSubDirectory(const std::string& subdir)
{
TS::ptr()->data_search_subdir.push_back(subdir);
@ -1001,14 +998,10 @@ static std::string findData(const std::string& relative_path, bool required, boo
const std::vector<std::string>& search_subdir = TS::ptr()->data_search_subdir;
#ifndef WINRT
char* datapath_dir = getenv("OPENCV_TEST_DATA_PATH");
#else
char* datapath_dir = OPENCV_TEST_DATA_PATH;
#endif
std::string datapath_dir = cv::utils::getConfigurationParameterString("OPENCV_TEST_DATA_PATH");
std::string datapath;
if (datapath_dir)
if (!datapath_dir.empty())
{
datapath = datapath_dir;
//CV_Assert(isDirectory(datapath) && "OPENCV_TEST_DATA_PATH is specified but it doesn't exist");

34
modules/ts/src/ts_perf.cpp
View File

@ -192,22 +192,18 @@ void Regression::init(const std::string& testSuitName, const std::string& ext)
return;
}
#ifndef WINRT
const char *data_path_dir = getenv("OPENCV_TEST_DATA_PATH");
#else
const char *data_path_dir = OPENCV_TEST_DATA_PATH;
#endif
const std::string data_path_dir = utils::getConfigurationParameterString("OPENCV_TEST_DATA_PATH");
cvtest::addDataSearchSubDirectory("");
cvtest::addDataSearchSubDirectory(testSuitName);
const char *path_separator = "/";
if (data_path_dir)
if (!data_path_dir.empty())
{
int len = (int)strlen(data_path_dir)-1;
int len = (int)data_path_dir.size()-1;
if (len < 0) len = 0;
std::string path_base = (data_path_dir[0] == 0 ? std::string(".") : std::string(data_path_dir))
std::string path_base = (data_path_dir[0] == 0 ? std::string(".") : data_path_dir)
+ (data_path_dir[len] == '/' || data_path_dir[len] == '\\' ? "" : path_separator)
+ "perf"
+ path_separator;
@ -1042,7 +1038,7 @@ void TestBase::Init(const std::vector<std::string> & availableImpls,
param_verify_sanity = args.get<bool>("perf_verify_sanity");
#ifdef HAVE_IPP
test_ipp_check = !args.get<bool>("perf_ipp_check") ? getenv("OPENCV_IPP_CHECK") != NULL : true;
test_ipp_check = !args.get<bool>("perf_ipp_check") ? utils::getConfigurationParameterBool("OPENCV_IPP_CHECK") : true;
#endif
testThreads = args.get<int>("perf_threads");
#ifdef CV_COLLECT_IMPL_DATA
@ -1125,12 +1121,11 @@ void TestBase::Init(const std::vector<std::string> & availableImpls,
#endif
{
#ifndef WINRT
const char* path = getenv("OPENCV_PERF_VALIDATION_DIR");
#else
const char* path = OPENCV_PERF_VALIDATION_DIR;
std::string path = utils::getConfigurationParameterString("OPENCV_PERF_VALIDATION_DIR");
#ifdef WINRT
path = OPENCV_PERF_VALIDATION_DIR;
#endif
if (path)
if (!path.empty())
perf_validation_results_directory = path;
}
@ -1888,17 +1883,16 @@ std::string TestBase::getDataPath(const std::string& relativePath)
throw PerfEarlyExitException();
}
#ifndef WINRT
const char *data_path_dir = getenv("OPENCV_TEST_DATA_PATH");
#else
const char *data_path_dir = OPENCV_TEST_DATA_PATH;
std::string data_path_dir = utils::getConfigurationParameterString("OPENCV_TEST_DATA_PATH");
#ifdef WINRT
data_path_dir = OPENCV_TEST_DATA_PATH;
#endif
const char *path_separator = "/";
std::string path;
if (data_path_dir)
if (!data_path_dir.empty())
{
int len = (int)strlen(data_path_dir) - 1;
int len = (int)data_path_dir.size() - 1;
if (len < 0) len = 0;
path = (data_path_dir[0] == 0 ? std::string(".") : std::string(data_path_dir))
+ (data_path_dir[len] == '/' || data_path_dir[len] == '\\' ? "" : path_separator);

10
modules/video/perf/perf_main.cpp
View File

@ -7,15 +7,7 @@
static
void initTests()
{
const char* extraTestDataPath =
#ifdef WINRT
NULL;
#else
getenv("OPENCV_DNN_TEST_DATA_PATH");
#endif
if (extraTestDataPath)
cvtest::addDataSearchPath(extraTestDataPath);
cvtest::addDataSearchEnv("OPENCV_DNN_TEST_DATA_PATH");
cvtest::addDataSearchSubDirectory(""); // override "cv" prefix below to access without "../dnn" hacks
}

1
modules/video/perf/perf_precomp.hpp
View File

@ -7,6 +7,7 @@
#include "opencv2/ts.hpp"
#include <opencv2/video.hpp>
#include "opencv2/ts/ts_perf.hpp"
#include "opencv2/core/utils/configuration.private.hpp"
namespace cvtest
{

10
modules/video/test/test_main.cpp
View File

@ -10,15 +10,7 @@
static
void initTests()
{
const char* extraTestDataPath =
#ifdef WINRT
NULL;
#else
getenv("OPENCV_DNN_TEST_DATA_PATH");
#endif
if (extraTestDataPath)
cvtest::addDataSearchPath(extraTestDataPath);
cvtest::addDataSearchEnv("OPENCV_DNN_TEST_DATA_PATH");
cvtest::addDataSearchSubDirectory(""); // override "cv" prefix below to access without "../dnn" hacks
}

1
modules/video/test/test_precomp.hpp
View File

@ -7,6 +7,7 @@
#include "opencv2/ts.hpp"
#include "opencv2/video.hpp"
#include <opencv2/ts/ts_perf.hpp>
#include "opencv2/core/utils/configuration.private.hpp"
namespace opencv_test {
using namespace perf;

8
modules/videoio/src/backend_plugin.cpp
View File

@ -332,16 +332,14 @@ std::vector<FileSystemPath_t> getPluginCandidates(const std::string& baseName)
std::vector<FileSystemPath_t> results;
#ifdef _WIN32
FileSystemPath_t moduleName = toFileSystemPath(libraryPrefix() + "opencv_videoio_" + baseName_l + librarySuffix());
#ifndef WINRT
if (baseName_u == "FFMPEG") // backward compatibility
{
const wchar_t* ffmpeg_env_path = _wgetenv(L"OPENCV_FFMPEG_DLL_DIR");
if (ffmpeg_env_path)
const std::string ffmpeg_env_path = cv::utils::getConfigurationParameterString("OPENCV_FFMPEG_DLL_DIR");
if (!ffmpeg_env_path.empty())
{
results.push_back(FileSystemPath_t(ffmpeg_env_path) + L"\\" + moduleName);
results.push_back(toFileSystemPath(ffmpeg_env_path + "\\" + toPrintablePath(moduleName)));
}
}
#endif
if (plugin_expr != default_expr)
{
moduleName = toFileSystemPath(plugin_expr);

22
modules/videoio/src/cap_dshow.cpp
View File

@ -303,15 +303,7 @@ interface ISampleGrabber : public IUnknown
static void DebugPrintOut(const char *format, ...)
{
static int gs_verbose = -1;
if (gs_verbose < 0)
{
// Fetch initial debug state from environment - defaults to disabled
const char* s = getenv("OPENCV_DSHOW_DEBUG");
gs_verbose = s != NULL && atoi(s) != 0;
}
static const bool gs_verbose = utils::getConfigurationParameterBool("OPENCV_DSHOW_DEBUG");
if (gs_verbose)
{
va_list args;
@ -2982,18 +2974,18 @@ int videoInput::start(int deviceID, videoDevice *VD){
VD->readyToCapture = true;
// check for optional saving the direct show graph to a file
const char* graph_filename = getenv("OPENCV_DSHOW_SAVEGRAPH_FILENAME");
if (graph_filename) {
size_t filename_len = strlen(graph_filename);
std::string graph_filename = utils::getConfigurationParameterString("OPENCV_DSHOW_SAVEGRAPH_FILENAME");
if (!graph_filename.empty()) {
size_t filename_len = graph_filename.size();
std::vector<WCHAR> wfilename(filename_len + 1);
size_t len = mbstowcs(&wfilename[0], graph_filename, filename_len + 1);
size_t len = mbstowcs(&wfilename[0], &graph_filename[0], filename_len + 1);
CV_Assert(len == filename_len);
HRESULT res = SaveGraphFile(VD->pGraph, &wfilename[0]);
if (SUCCEEDED(res)) {
DebugPrintOut("Saved DSHOW graph to %s\n", graph_filename);
DebugPrintOut("Saved DSHOW graph to %s\n", graph_filename.c_str());
} else {
DebugPrintOut("Failed to save DSHOW graph to %s\n", graph_filename);
DebugPrintOut("Failed to save DSHOW graph to %s\n", graph_filename.c_str());
}
}

36
modules/videoio/src/cap_ffmpeg_impl.hpp
View File

@ -928,21 +928,19 @@ public:
}
static void initLogger_()
{
#ifndef NO_GETENV
char* debug_option = getenv("OPENCV_FFMPEG_DEBUG");
char* level_option = getenv("OPENCV_FFMPEG_LOGLEVEL");
const bool debug_option = utils::getConfigurationParameterBool("OPENCV_FFMPEG_DEBUG");
std::string level_option = utils::getConfigurationParameterString("OPENCV_FFMPEG_LOGLEVEL");
int level = AV_LOG_VERBOSE;
if (level_option != NULL)
if (!level_option.empty())
{
level = atoi(level_option);
level = atoi(level_option.c_str());
}
if ( (debug_option != NULL) || (level_option != NULL) )
if ( debug_option || (!level_option.empty()) )
{
av_log_set_level(level);
av_log_set_callback(ffmpeg_log_callback);
}
else
#endif
{
av_log_set_level(AV_LOG_ERROR);
}
@ -979,10 +977,10 @@ inline void fill_codec_context(AVCodecContext * enc, AVDictionary * dict)
{
int nCpus = cv::getNumberOfCPUs();
int requestedThreads = std::min(nCpus, 16); // [OPENCV:FFMPEG:24] Application has requested XX threads. Using a thread count greater than 16 is not recommended.
char* threads_option = getenv("OPENCV_FFMPEG_THREADS");
if (threads_option != NULL)
std::string threads_option = utils::getConfigurationParameterString("OPENCV_FFMPEG_THREADS");
if (!threads_option.empty())
{
requestedThreads = atoi(threads_option);
requestedThreads = atoi(threads_option.c_str());
}
enc->thread_count = requestedThreads;
}
@ -1122,9 +1120,8 @@ bool CvCapture_FFMPEG::open(const char* _filename, const VideoCaptureParameters&
ic->interrupt_callback.opaque = &interrupt_metadata;
#endif
#ifndef NO_GETENV
char* options = getenv("OPENCV_FFMPEG_CAPTURE_OPTIONS");
if(options == NULL)
std::string options = utils::getConfigurationParameterString("OPENCV_FFMPEG_CAPTURE_OPTIONS");
if(!options.empty())
{
#if LIBAVFORMAT_VERSION_MICRO >= 100 && LIBAVFORMAT_BUILD >= CALC_FFMPEG_VERSION(55, 48, 100)
av_dict_set(&dict, "rtsp_flags", "prefer_tcp", 0);
@ -1136,14 +1133,11 @@ bool CvCapture_FFMPEG::open(const char* _filename, const VideoCaptureParameters&
{
CV_LOG_DEBUG(NULL, "VIDEOIO/FFMPEG: using capture options from environment: " << options);
#if LIBAVUTIL_BUILD >= (LIBAVUTIL_VERSION_MICRO >= 100 ? CALC_FFMPEG_VERSION(52, 17, 100) : CALC_FFMPEG_VERSION(52, 7, 0))
av_dict_parse_string(&dict, options, ";", "|", 0);
av_dict_parse_string(&dict, options.c_str(), ";", "|", 0);
#else
av_dict_set(&dict, "rtsp_transport", "tcp", 0);
#endif
}
#else
av_dict_set(&dict, "rtsp_transport", "tcp", 0);
#endif
CV_FFMPEG_FMT_CONST AVInputFormat* input_format = NULL;
AVDictionaryEntry* entry = av_dict_get(dict, "input_format", NULL, 0);
if (entry != 0)
@ -3095,12 +3089,12 @@ bool CvVideoWriter_FFMPEG::open( const char * filename, int fourcc,
}
AVDictionary *dict = NULL;
#if !defined(NO_GETENV) && (LIBAVUTIL_VERSION_MAJOR >= 53)
char* options = getenv("OPENCV_FFMPEG_WRITER_OPTIONS");
if (options)
#if (LIBAVUTIL_VERSION_MAJOR >= 53)
std::string options = utils::getConfigurationParameterString("OPENCV_FFMPEG_WRITER_OPTIONS");
if (!options.empty())
{
CV_LOG_DEBUG(NULL, "VIDEOIO/FFMPEG: using writer options from environment: " << options);
av_dict_parse_string(&dict, options, ";", "|", 0);
av_dict_parse_string(&dict, options.c_str(), ";", "|", 0);
}
#endif

2
modules/videoio/src/videoio_registry.cpp
View File

@ -259,7 +259,7 @@ protected:
bool readPrioritySettings()
{
bool hasChanges = false;
cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_VIDEOIO_PRIORITY_LIST", NULL);
cv::String prioritized_backends = utils::getConfigurationParameterString("OPENCV_VIDEOIO_PRIORITY_LIST");
if (prioritized_backends.empty())
return hasChanges;
CV_LOG_INFO(NULL, "VIDEOIO: Configured priority list (OPENCV_VIDEOIO_PRIORITY_LIST): " << prioritized_backends);

4
modules/videoio/test/test_main.cpp
View File

@ -11,15 +11,13 @@
static
void initTests()
{
#ifndef WINRT // missing getenv
const std::vector<cv::VideoCaptureAPIs> backends = cv::videoio_registry::getStreamBackends();
const char* requireFFmpeg = getenv("OPENCV_TEST_VIDEOIO_BACKEND_REQUIRE_FFMPEG");
bool requireFFmpeg = cv::utils::getConfigurationParameterBool("OPENCV_TEST_VIDEOIO_BACKEND_REQUIRE_FFMPEG");
if (requireFFmpeg && !isBackendAvailable(cv::CAP_FFMPEG, backends))
{
CV_LOG_FATAL(NULL, "OpenCV-Test: required FFmpeg backend is not available (broken plugin?). STOP.");
exit(1);
}
#endif
}
CV_TEST_MAIN("highgui", initTests())

1
modules/videoio/test/test_precomp.hpp
View File

@ -13,6 +13,7 @@
#include "opencv2/videoio.hpp"
#include "opencv2/videoio/registry.hpp"
#include "opencv2/core/private.hpp"
#include "opencv2/core/utils/configuration.private.hpp"
namespace cv {