potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-29 23:33:05 +04:00
Code Packages Releases Wiki Activity

Merge branch 4.x

Browse Source
This commit is contained in:
Alexander Alekhin
2022-02-22 19:33:07 +00:00
parent e5d648d2d0 92312fbc0c
commit 899b4d1452
256 changed files with 10503 additions and 5119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/core/src/cuda/gpu_mat.cu
+1 -4
View File
@@ -184,11 +184,8 @@ void cv::cuda::GpuMat::create(int _rows, int _cols, int _type)
if (esz * cols == step)
flags |= Mat::CONTINUOUS_FLAG;
int64 _nettosize = static_cast<int64>(step) * rows;
size_t nettosize = static_cast<size_t>(_nettosize);
datastart = data;
dataend = data + nettosize;
dataend = data + step * (rows - 1) + cols * esz;
if (refcount)
*refcount = 1;
modules/core/src/cuda_stream.cpp
+1 -1
View File
@@ -811,7 +811,7 @@ Event cv::cuda::EventAccessor::wrapEvent(cudaEvent_t event)
#endif
cv::cuda::Event::Event(CreateFlags flags)
cv::cuda::Event::Event(const Event::CreateFlags flags)
{
#ifndef HAVE_CUDA
CV_UNUSED(flags);
modules/core/src/hal_internal.cpp
+22
View File
@@ -64,6 +64,16 @@
#define HAL_LU_SMALL_MATRIX_THRESH 100
#define HAL_CHOLESKY_SMALL_MATRIX_THRESH 100
#if defined(__clang__) && defined(__has_feature)
#if __has_feature(memory_sanitizer)
#define CV_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
__msan_unpoison(adresse, size)
#endif
#endif
#ifndef CV_ANNOTATE_MEMORY_IS_INITIALIZED
#define CV_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) do { } while(0)
#endif
//lapack stores matrices in column-major order so transposing is needed everywhere
template <typename fptype> static inline void
transpose_square_inplace(fptype *src, size_t src_ld, size_t m)
@@ -248,6 +258,17 @@ lapack_SVD(fptype* a, size_t a_step, fptype *w, fptype* u, size_t u_step, fptype
OCV_LAPACK_FUNC(dgesdd)(mode, &m, &n, (double*)a, &lda, (double*)w, (double*)u, &ldu,
(double*)vt, &ldv, (double*)&buffer[0], &lwork, &iworkBuf[0], info);
// Make sure MSAN sees the memory as having been written.
// MSAN does not think it has been written because a different language was called.
CV_ANNOTATE_MEMORY_IS_INITIALIZED(a, a_step * n);
CV_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, sizeof(fptype) * (lwork + 1));
if (u)
CV_ANNOTATE_MEMORY_IS_INITIALIZED(u, u_step * m);
if (vt)
CV_ANNOTATE_MEMORY_IS_INITIALIZED(vt, v_step * n);
if (w)
CV_ANNOTATE_MEMORY_IS_INITIALIZED(w, sizeof(fptype) * std::min(m, n));
if(!(flags & CV_HAL_SVD_NO_UV))
transpose_square_inplace(vt, ldv, n);
@@ -359,6 +380,7 @@ lapack_QR(fptype* a, size_t a_step, int m, int n, int k, fptype* b, size_t b_ste
dgeqrf_(&m, &n, (double*)tmpA, &ldtmpA, (double*)dst, (double*)buffer, &lwork, info);
}
CV_ANNOTATE_MEMORY_IS_INITIALIZED(info, sizeof(int));
if (m == n)
transpose_square_inplace(a, lda, m);
else
modules/core/src/kmeans.cpp
+1 -1
View File
@@ -240,7 +240,7 @@ double cv::kmeans( InputArray _data, int K,
attempts = std::max(attempts, 1);
CV_Assert( data0.dims <= 2 && type == CV_32F && K > 0 );
CV_CheckGE(N, K, "Number of clusters should be more than number of elements");
CV_CheckGE(N, K, "There can't be more clusters than elements");
Mat data(N, dims, CV_32F, data0.ptr(), isrow ? dims * sizeof(float) : static_cast<size_t>(data0.step));
modules/core/src/matmul.dispatch.cpp
+1 -1
View File
@@ -804,7 +804,7 @@ void calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mea
else
{
ctype = std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), CV_32F);
reduce( _src, _mean, takeRows ? 0 : 1, CV_REDUCE_AVG, ctype );
reduce( _src, _mean, takeRows ? 0 : 1, REDUCE_AVG, ctype );
mean = _mean.getMat();
}
modules/core/src/matrix.cpp
+9 -13
View File
@@ -176,27 +176,23 @@ public:
}
};
namespace
static
MatAllocator*& getDefaultAllocatorMatRef()
{
MatAllocator* volatile g_matAllocator = NULL;
static MatAllocator* g_matAllocator = Mat::getStdAllocator();
return g_matAllocator;
}
MatAllocator* Mat::getDefaultAllocator()
{
if (g_matAllocator == NULL)
{
cv::AutoLock lock(cv::getInitializationMutex());
if (g_matAllocator == NULL)
{
g_matAllocator = getStdAllocator();
}
}
return g_matAllocator;
return getDefaultAllocatorMatRef();
}
void Mat::setDefaultAllocator(MatAllocator* allocator)
{
g_matAllocator = allocator;
getDefaultAllocatorMatRef() = allocator;
}
MatAllocator* Mat::getStdAllocator()
{
CV_SINGLETON_LAZY_INIT(MatAllocator, new StdMatAllocator())
@@ -269,7 +265,7 @@ void setSize( Mat& m, int _dims, const int* _sz, const size_t* _steps, bool auto
else if( autoSteps )
{
m.step.p[i] = total;
int64 total1 = (int64)total*s;
uint64 total1 = (uint64)total*s;
if( (uint64)total1 != (size_t)total1 )
CV_Error( CV_StsOutOfRange, "The total matrix size does not fit to \"size_t\" type" );
total = (size_t)total1;
modules/core/src/matrix_operations.cpp
+16 -16
View File
@@ -616,7 +616,7 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
if (!doubleSupport && (sdepth == CV_64F || ddepth == CV_64F))
return false;
if (op == CV_REDUCE_AVG)
if (op == REDUCE_AVG)
{
if (sdepth < CV_32S && ddepth < CV_32S)
ddepth = CV_32S;
@@ -654,7 +654,7 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
_dst.create(dsize, dtype);
UMat dst = _dst.getUMat();
if (op0 == CV_REDUCE_AVG)
if (op0 == REDUCE_AVG)
k.args(ocl::KernelArg::ReadOnly(src),
ocl::KernelArg::WriteOnlyNoSize(dst), 1.0f / src.cols);
else
@@ -690,7 +690,7 @@ static bool ocl_reduce(InputArray _src, OutputArray _dst,
ocl::KernelArg srcarg = ocl::KernelArg::ReadOnly(src),
temparg = ocl::KernelArg::WriteOnlyNoSize(dst);
if (op0 == CV_REDUCE_AVG)
if (op0 == REDUCE_AVG)
k.args(srcarg, temparg, 1.0f / (dim == 0 ? src.rows : src.cols));
else
k.args(srcarg, temparg);
@@ -717,8 +717,8 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
int ddepth = CV_MAT_DEPTH(dtype);
CV_Assert( cn == CV_MAT_CN(dtype) );
CV_Assert( op == CV_REDUCE_SUM || op == CV_REDUCE_MAX ||
op == CV_REDUCE_MIN || op == CV_REDUCE_AVG );
CV_Assert( op == REDUCE_SUM || op == REDUCE_MAX ||
op == REDUCE_MIN || op == REDUCE_AVG );
CV_OCL_RUN(_dst.isUMat(),
ocl_reduce(_src, _dst, dim, op, op0, stype, dtype))
@@ -732,9 +732,9 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
_dst.create(dim == 0 ? 1 : src.rows, dim == 0 ? src.cols : 1, dtype);
Mat dst = _dst.getMat(), temp = dst;
if( op == CV_REDUCE_AVG )
if( op == REDUCE_AVG )
{
op = CV_REDUCE_SUM;
op = REDUCE_SUM;
if( sdepth < CV_32S && ddepth < CV_32S )
{
temp.create(dst.rows, dst.cols, CV_32SC(cn));
@@ -745,7 +745,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
ReduceFunc func = 0;
if( dim == 0 )
{
if( op == CV_REDUCE_SUM )
if( op == REDUCE_SUM )
{
if(sdepth == CV_8U && ddepth == CV_32S)
func = GET_OPTIMIZED(reduceSumR8u32s);
@@ -768,7 +768,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
else if(sdepth == CV_64F && ddepth == CV_64F)
func = reduceSumR64f64f;
}
else if(op == CV_REDUCE_MAX)
else if(op == REDUCE_MAX)
{
if(sdepth == CV_8U && ddepth == CV_8U)
func = GET_OPTIMIZED(reduceMaxR8u);
@@ -781,7 +781,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
else if(sdepth == CV_64F && ddepth == CV_64F)
func = reduceMaxR64f;
}
else if(op == CV_REDUCE_MIN)
else if(op == REDUCE_MIN)
{
if(sdepth == CV_8U && ddepth == CV_8U)
func = GET_OPTIMIZED(reduceMinR8u);
@@ -797,7 +797,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
}
else
{
if(op == CV_REDUCE_SUM)
if(op == REDUCE_SUM)
{
if(sdepth == CV_8U && ddepth == CV_32S)
func = GET_OPTIMIZED(reduceSumC8u32s);
@@ -820,7 +820,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
else if(sdepth == CV_64F && ddepth == CV_64F)
func = reduceSumC64f64f;
}
else if(op == CV_REDUCE_MAX)
else if(op == REDUCE_MAX)
{
if(sdepth == CV_8U && ddepth == CV_8U)
func = GET_OPTIMIZED(reduceMaxC8u);
@@ -833,7 +833,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
else if(sdepth == CV_64F && ddepth == CV_64F)
func = reduceMaxC64f;
}
else if(op == CV_REDUCE_MIN)
else if(op == REDUCE_MIN)
{
if(sdepth == CV_8U && ddepth == CV_8U)
func = GET_OPTIMIZED(reduceMinC8u);
@@ -854,7 +854,7 @@ void cv::reduce(InputArray _src, OutputArray _dst, int dim, int op, int dtype)
func( src, temp );
if( op0 == CV_REDUCE_AVG )
if( op0 == REDUCE_AVG )
temp.convertTo(dst, dst.type(), 1./(dim == 0 ? src.rows : src.cols));
}
@@ -940,8 +940,8 @@ static bool ipp_sort(const Mat& src, Mat& dst, int flags)
{
CV_INSTRUMENT_REGION_IPP();
bool sortRows = (flags & 1) == CV_SORT_EVERY_ROW;
bool sortDescending = (flags & CV_SORT_DESCENDING) != 0;
bool sortRows = (flags & 1) == SORT_EVERY_ROW;
bool sortDescending = (flags & SORT_DESCENDING) != 0;
bool inplace = (src.data == dst.data);
int depth = src.depth();
IppDataType type = ippiGetDataType(depth);
modules/core/src/parallel.cpp
+14
View File
@@ -153,6 +153,9 @@
#include "opencv2/core/detail/exception_ptr.hpp" // CV__EXCEPTION_PTR = 1 if std::exception_ptr is available
#include <opencv2/core/utils/fp_control_utils.hpp>
#include <opencv2/core/utils/fp_control.private.hpp>
using namespace cv;
namespace cv {
@@ -203,6 +206,9 @@ namespace {
// propagate main thread state
rng = cv::theRNG();
#if OPENCV_SUPPORTS_FP_DENORMALS_HINT && OPENCV_IMPL_FP_HINTS
details::saveFPDenormalsState(fp_denormals_base_state);
#endif
#ifdef OPENCV_TRACE
traceRootRegion = CV_TRACE_NS::details::getCurrentRegion();
@@ -283,6 +289,11 @@ namespace {
}
}
}
#if OPENCV_SUPPORTS_FP_DENORMALS_HINT && OPENCV_IMPL_FP_HINTS
details::FPDenormalsModeState fp_denormals_base_state;
#endif
private:
ParallelLoopBodyWrapperContext(const ParallelLoopBodyWrapperContext&); // disabled
ParallelLoopBodyWrapperContext& operator=(const ParallelLoopBodyWrapperContext&); // disabled
@@ -319,6 +330,9 @@ namespace {
// propagate main thread state
cv::theRNG() = ctx.rng;
#if OPENCV_SUPPORTS_FP_DENORMALS_HINT && OPENCV_IMPL_FP_HINTS
FPDenormalsIgnoreHintScope fp_denormals_scope(ctx.fp_denormals_base_state);
#endif
cv::Range r;
cv::Range wholeRange = ctx.wholeRange;
modules/core/src/persistence.cpp
+36 -24
View File
@@ -9,6 +9,8 @@
#include <unordered_map>
#include <iterator>
#include <opencv2/core/utils/logger.hpp>
namespace cv
{
@@ -499,21 +501,29 @@ bool FileStorage::Impl::open(const char *filename_or_buf, int _flags, const char
if (!isGZ) {
file = fopen(filename.c_str(), !write_mode ? "rt" : !append ? "wt" : "a+t");
if (!file)
{
CV_LOG_ERROR(NULL, "Can't open file: '" << filename << "' in " << (!write_mode ? "read" : !append ? "write" : "append") << " mode");
return false;
}
} else {
#if USE_ZLIB
char mode[] = {write_mode ? 'w' : 'r', 'b', compression ? compression : '3', '\0'};
gzfile = gzopen(filename.c_str(), mode);
if (!gzfile)
{
CV_LOG_ERROR(NULL, "Can't open archive: '" << filename << "' mode=" << mode);
return false;
}
#else
CV_Error(cv::Error::StsNotImplemented, "There is no compressed file storage support in this configuration");
#endif
}
}
// FIXIT release() must do that, use CV_Assert() here instead
roots.clear();
fs_data.clear();
wrap_margin = 71;
fmt = FileStorage::FORMAT_AUTO;
@@ -616,14 +626,14 @@ bool FileStorage::Impl::open(const char *filename_or_buf, int _flags, const char
puts("\n");
}
emitter = createXMLEmitter(this);
emitter_do_not_use_direct_dereference = createXMLEmitter(this);
} else if (fmt == FileStorage::FORMAT_YAML) {
if (!append)
puts("%YAML:1.0\n---\n");
else
puts("...\n---\n");
emitter = createYAMLEmitter(this);
emitter_do_not_use_direct_dereference = createYAMLEmitter(this);
} else {
CV_Assert(fmt == FileStorage::FORMAT_JSON);
if (!append)
@@ -653,7 +663,7 @@ bool FileStorage::Impl::open(const char *filename_or_buf, int _flags, const char
}
}
write_stack.back().indent = 4;
emitter = createJSONEmitter(this);
emitter_do_not_use_direct_dereference = createJSONEmitter(this);
}
is_opened = true;
} else {
@@ -701,20 +711,20 @@ bool FileStorage::Impl::open(const char *filename_or_buf, int _flags, const char
switch (fmt) {
case FileStorage::FORMAT_XML:
parser = createXMLParser(this);
parser_do_not_use_direct_dereference = createXMLParser(this);
break;
case FileStorage::FORMAT_YAML:
parser = createYAMLParser(this);
parser_do_not_use_direct_dereference = createYAMLParser(this);
break;
case FileStorage::FORMAT_JSON:
parser = createJSONParser(this);
parser_do_not_use_direct_dereference = createJSONParser(this);
break;
default:
parser = Ptr<FileStorageParser>();
parser_do_not_use_direct_dereference = Ptr<FileStorageParser>();
}
if (!parser.empty()) {
ok = parser->parse(ptr);
if (!parser_do_not_use_direct_dereference.empty()) {
ok = getParser().parse(ptr);
if (ok) {
finalizeCollection(root_nodes);
@@ -728,7 +738,9 @@ bool FileStorage::Impl::open(const char *filename_or_buf, int _flags, const char
}
}
}
catch (...) {
catch (...)
{
// FIXIT log error message
is_opened = true;
release();
throw;
@@ -926,7 +938,7 @@ void FileStorage::Impl::endWriteStruct() {
if (fmt == FileStorage::FORMAT_JSON && !FileNode::isFlow(current_struct.flags) && write_stack.size() > 1)
current_struct.indent = write_stack[write_stack.size() - 2].indent;
emitter->endWriteStruct(current_struct);
getEmitter().endWriteStruct(current_struct);
write_stack.pop_back();
if (!write_stack.empty())
@@ -945,7 +957,7 @@ void FileStorage::Impl::startWriteStruct_helper(const char *key, int struct_flag
if (type_name && type_name[0] == '\0')
type_name = 0;
FStructData s = emitter->startWriteStruct(write_stack.back(), key, struct_flags, type_name);
FStructData s = getEmitter().startWriteStruct(write_stack.back(), key, struct_flags, type_name);
write_stack.push_back(s);
size_t write_stack_size = write_stack.size();
@@ -956,7 +968,7 @@ void FileStorage::Impl::startWriteStruct_helper(const char *key, int struct_flag
flush();
if (fmt == FileStorage::FORMAT_JSON && type_name && type_name[0] && FileNode::isMap(struct_flags)) {
emitter->write("type_id", type_name, false);
getEmitter().write("type_id", type_name, false);
}
}
@@ -997,7 +1009,7 @@ void FileStorage::Impl::startWriteStruct(const char *key, int struct_flags,
void FileStorage::Impl::writeComment(const char *comment, bool eol_comment) {
CV_Assert(write_mode);
emitter->writeComment(comment, eol_comment);
getEmitter().writeComment(comment, eol_comment);
}
void FileStorage::Impl::startNextStream() {
@@ -1006,7 +1018,7 @@ void FileStorage::Impl::startNextStream() {
while (!write_stack.empty())
endWriteStruct();
flush();
emitter->startNextStream();
getEmitter().startNextStream();
empty_stream = true;
write_stack.push_back(FStructData("", FileNode::EMPTY, 0));
bufofs = 0;
@@ -1015,17 +1027,17 @@ void FileStorage::Impl::startNextStream() {
void FileStorage::Impl::write(const String &key, int value) {
CV_Assert(write_mode);
emitter->write(key.c_str(), value);
getEmitter().write(key.c_str(), value);
}
void FileStorage::Impl::write(const String &key, double value) {
CV_Assert(write_mode);
emitter->write(key.c_str(), value);
getEmitter().write(key.c_str(), value);
}
void FileStorage::Impl::write(const String &key, const String &value) {
CV_Assert(write_mode);
emitter->write(key.c_str(), value.c_str(), false);
getEmitter().write(key.c_str(), value.c_str(), false);
}
void FileStorage::Impl::writeRawData(const std::string &dt, const void *_data, size_t len) {
@@ -1111,7 +1123,7 @@ void FileStorage::Impl::writeRawData(const std::string &dt, const void *_data, s
return;
}
emitter->writeScalar(0, ptr);
getEmitter().writeScalar(0, ptr);
}
offset = (int) (data - data0);
@@ -1597,8 +1609,8 @@ FileStorage::Impl::Base64Decoder::Base64Decoder() {
eos = true;
}
void FileStorage::Impl::Base64Decoder::init(Ptr<FileStorageParser> &_parser, char *_ptr, int _indent) {
parser = _parser;
void FileStorage::Impl::Base64Decoder::init(const Ptr<FileStorageParser> &_parser, char *_ptr, int _indent) {
parser_do_not_use_direct_dereference = _parser;
ptr = _ptr;
indent = _indent;
encoded.clear();
@@ -1641,9 +1653,9 @@ bool FileStorage::Impl::Base64Decoder::readMore(int needed) {
decoded.resize(sz);
ofs = 0;
CV_Assert(!parser.empty() && ptr);
CV_Assert(ptr);
char *beg = 0, *end = 0;
bool ok = parser->getBase64Row(ptr, indent, beg, end);
bool ok = getParser().getBase64Row(ptr, indent, beg, end);
ptr = end;
std::copy(beg, end, std::back_inserter(encoded));
totalchars += end - beg;
@@ -1730,7 +1742,7 @@ char *FileStorage::Impl::Base64Decoder::getPtr() const { return ptr; }
char *FileStorage::Impl::parseBase64(char *ptr, int indent, FileNode &collection) {
const int BASE64_HDR_SIZE = 24;
char dt[BASE64_HDR_SIZE + 1] = {0};
base64decoder.init(parser, ptr, indent);
base64decoder.init(parser_do_not_use_direct_dereference, ptr, indent);
int i, k;
modules/core/src/persistence_impl.hpp
+23 -5
View File
@@ -139,7 +139,7 @@ public:
{
public:
Base64Decoder();
void init(Ptr<FileStorageParser>& _parser, char* _ptr, int _indent);
void init(const Ptr<FileStorageParser>& _parser, char* _ptr, int _indent);
bool readMore(int needed);
@@ -155,7 +155,13 @@ public:
char* getPtr() const;
protected:
Ptr<FileStorageParser> parser;
Ptr<FileStorageParser> parser_do_not_use_direct_dereference;
FileStorageParser& getParser() const
{
if (!parser_do_not_use_direct_dereference)
CV_Error(Error::StsNullPtr, "Parser is not available");
return *parser_do_not_use_direct_dereference;
}
char* ptr;
int indent;
std::vector<char> encoded;
@@ -205,8 +211,20 @@ public:
std::deque<char> outbuf;
Ptr<FileStorageEmitter> emitter;
Ptr<FileStorageParser> parser;
Ptr<FileStorageEmitter> emitter_do_not_use_direct_dereference;
FileStorageEmitter& getEmitter()
{
if (!emitter_do_not_use_direct_dereference)
CV_Error(Error::StsNullPtr, "Emitter is not available");
return *emitter_do_not_use_direct_dereference;
}
Ptr<FileStorageParser> parser_do_not_use_direct_dereference;
FileStorageParser& getParser() const
{
if (!parser_do_not_use_direct_dereference)
CV_Error(Error::StsNullPtr, "Parser is not available");
return *parser_do_not_use_direct_dereference;
}
Base64Decoder base64decoder;
base64::Base64Writer* base64_writer;
@@ -228,4 +246,4 @@ public:
}
#endif
#endif
modules/core/src/system.cpp
+80 -1
View File
@@ -55,6 +55,9 @@
#include <opencv2/core/utils/filesystem.private.hpp>
#include <opencv2/core/utils/fp_control_utils.hpp>
#include <opencv2/core/utils/fp_control.private.hpp>
#ifndef OPENCV_WITH_THREAD_SANITIZER
#if defined(__clang__) && defined(__has_feature)
#if __has_feature(thread_sanitizer)
@@ -630,7 +633,7 @@ struct HWFeatures
}
}
#elif (defined __ppc64__ || defined __PPC64__) && defined __FreeBSD__
unsigned int hwcap = 0;
unsigned long hwcap = 0;
elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap));
if (hwcap & PPC_FEATURE_HAS_VSX) {
elf_aux_info(AT_HWCAP2, &hwcap, sizeof(hwcap));
@@ -2720,6 +2723,82 @@ void setUseIPP_NotExact(bool flag)
} // namespace ipp
namespace details {
#if OPENCV_IMPL_FP_HINTS_X86
#ifndef _MM_DENORMALS_ZERO_ON // requires pmmintrin.h (SSE3)
#define _MM_DENORMALS_ZERO_ON 0x0040
#endif
#ifndef _MM_DENORMALS_ZERO_MASK // requires pmmintrin.h (SSE3)
#define _MM_DENORMALS_ZERO_MASK 0x0040
#endif
#endif
void setFPDenormalsIgnoreHint(bool ignore, CV_OUT FPDenormalsModeState& state)
{
#if OPENCV_IMPL_FP_HINTS_X86
unsigned mask = _MM_FLUSH_ZERO_MASK;
unsigned value = ignore ? _MM_FLUSH_ZERO_ON : 0;
if (featuresEnabled.have[CPU_SSE3])
{
mask |= _MM_DENORMALS_ZERO_MASK;
value |= ignore ? _MM_DENORMALS_ZERO_ON : 0;
}
const unsigned old_flags = _mm_getcsr();
const unsigned old_value = old_flags & mask;
unsigned flags = (old_flags & ~mask) | value;
CV_LOG_DEBUG(NULL, "core: update FP mxcsr flags = " << cv::format("0x%08x", flags));
// save state
state.reserved[0] = (uint32_t)mask;
state.reserved[1] = (uint32_t)old_value;
_mm_setcsr(flags);
#else
CV_UNUSED(ignore); CV_UNUSED(state);
#endif
}
int saveFPDenormalsState(CV_OUT FPDenormalsModeState& state)
{
#if OPENCV_IMPL_FP_HINTS_X86
unsigned mask = _MM_FLUSH_ZERO_MASK;
if (featuresEnabled.have[CPU_SSE3])
{
mask |= _MM_DENORMALS_ZERO_MASK;
}
const unsigned old_flags = _mm_getcsr();
const unsigned old_value = old_flags & mask;
// save state
state.reserved[0] = (uint32_t)mask;
state.reserved[1] = (uint32_t)old_value;
return 2;
#else
CV_UNUSED(state);
return 0;
#endif
}
bool restoreFPDenormalsState(const FPDenormalsModeState& state)
{
#if OPENCV_IMPL_FP_HINTS_X86
const unsigned mask = (unsigned)state.reserved[0];
CV_DbgAssert(mask != 0); // invalid state (ensure that state is properly saved earlier)
const unsigned value = (unsigned)state.reserved[1];
CV_DbgCheck((int)value, value == (value & mask), "invalid SSE FP state");
const unsigned old_flags = _mm_getcsr();
unsigned flags = (old_flags & ~mask) | value;
CV_LOG_DEBUG(NULL, "core: restore FP mxcsr flags = " << cv::format("0x%08x", flags));
_mm_setcsr(flags);
return true;
#else
CV_UNUSED(state);
return false;
#endif
}
} // namespace details
} // namespace cv
/* End of file. */
modules/core/src/va_intel.cpp
+67 -4
View File
@@ -606,10 +606,36 @@ void convertToVASurface(VADisplay display, InputArray src, VASurfaceID surface,
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaSyncSurface failed");
bool indirect_buffer = false;
VAImage image;
status = vaDeriveImage(display, surface, &image);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaDeriveImage failed");
if (status != VA_STATUS_SUCCESS){
//try vaCreateImage + vaPutImage
//pick a format
indirect_buffer = true;
int num_formats = vaMaxNumImageFormats(display);
if (num_formats <= 0)
CV_Error(cv::Error::StsError, "VA-API: vaMaxNumImageFormats failed");
std::vector<VAImageFormat> fmt_list(num_formats);
status = vaQueryImageFormats(display, fmt_list.data(), &num_formats);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaQueryImageFormats failed");
VAImageFormat *selected_format = nullptr;
for (auto &fmt : fmt_list){
if (fmt.fourcc == VA_FOURCC_NV12 || fmt.fourcc == VA_FOURCC_YV12){
selected_format = &fmt;
break;
}
}
if (selected_format == nullptr)
CV_Error(cv::Error::StsError, "VA-API: vaQueryImageFormats did not return a supported format");
status = vaCreateImage(display, selected_format, size.width, size.height, &image);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaCreateImage failed");
}
unsigned char* buffer = 0;
status = vaMapBuffer(display, image.buf, (void **)&buffer);
@@ -627,6 +653,14 @@ void convertToVASurface(VADisplay display, InputArray src, VASurfaceID surface,
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaUnmapBuffer failed");
if (indirect_buffer){
status = vaPutImage(display, surface, image.image_id, 0, 0, size.width, size.height, 0, 0, size.width, size.height);
if (status != VA_STATUS_SUCCESS){
vaDestroyImage(display, image.image_id);
CV_Error(cv::Error::StsError, "VA-API: vaPutImage failed");
}
}
status = vaDestroyImage(display, image.image_id);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaDestroyImage failed");
@@ -711,8 +745,37 @@ void convertFromVASurface(VADisplay display, VASurfaceID surface, Size size, Out
VAImage image;
status = vaDeriveImage(display, surface, &image);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaDeriveImage failed");
if (status != VA_STATUS_SUCCESS){
//try vaCreateImage + vaGetImage
//pick a format
int num_formats = vaMaxNumImageFormats(display);
if (num_formats <= 0)
CV_Error(cv::Error::StsError, "VA-API: vaMaxNumImageFormats failed");
std::vector<VAImageFormat> fmt_list(num_formats);
status = vaQueryImageFormats(display, fmt_list.data(), &num_formats);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaQueryImageFormats failed");
VAImageFormat *selected_format = nullptr;
for (auto &fmt : fmt_list){
if (fmt.fourcc == VA_FOURCC_NV12 || fmt.fourcc == VA_FOURCC_YV12){
selected_format = &fmt;
break;
}
}
if (selected_format == nullptr)
CV_Error(cv::Error::StsError, "VA-API: vaQueryImageFormats did not return a supported format");
status = vaCreateImage(display, selected_format, size.width, size.height, &image);
if (status != VA_STATUS_SUCCESS)
CV_Error(cv::Error::StsError, "VA-API: vaCreateImage failed");
status = vaGetImage(display, surface, 0, 0, size.width, size.height, image.image_id);
if (status != VA_STATUS_SUCCESS){
vaDestroyImage(display, image.image_id);
CV_Error(cv::Error::StsError, "VA-API: vaPutImage failed");
}
}
unsigned char* buffer = 0;
status = vaMapBuffer(display, image.buf, (void **)&buffer);