generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #3332 from lupustr3:pvlasov/implementation_detector

Browse Source
This commit is contained in:
Alexander Alekhin 2014-10-16 14:51:53 +00:00
commit af1d29db83
49 changed files with 4279 additions and 2799 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@ -222,6 +222,11 @@ OCV_OPTION(OPENCV_WARNINGS_ARE_ERRORS "Treat warnings as errors"
OCV_OPTION(ENABLE_WINRT_MODE "Build with Windows Runtime support" OFF IF WIN32 )
OCV_OPTION(ENABLE_WINRT_MODE_NATIVE "Build with Windows Runtime native C++ support" OFF IF WIN32 )
OCV_OPTION(ANDROID_EXAMPLES_WITH_LIBS "Build binaries of Android examples with native libraries" OFF IF ANDROID )
OCV_OPTION(ENABLE_IMPL_COLLECTION "Collect implementation data on function call" OFF )
if(ENABLE_IMPL_COLLECTION)
add_definitions(-DCV_COLLECT_IMPL_DATA)
endif()
# ----------------------------------------------------------------------------

1
modules/calib3d/src/stereobm.cpp
View File

@ -925,6 +925,7 @@ public:
filterSpeckles(disparr.getMat(), FILTERED, params.speckleWindowSize, params.speckleRange, slidingSumBuf);
if (dtype == CV_32F)
disparr.getUMat().convertTo(disparr, CV_32FC1, 1./(1 << DISPARITY_SHIFT), 0);
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}

6
modules/calib3d/src/stereosgbm.cpp
View File

@ -1085,6 +1085,8 @@ void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSi
int newVal = cvRound(_newval), maxDiff = cvRound(_maxDiff);
#if IPP_VERSION_X100 >= 801
CV_IPP_CHECK()
{
Ipp32s bufsize = 0;
IppiSize roisize = { img.cols, img.rows };
IppDataType datatype = type == CV_8UC1 ? ipp8u : ipp16s;
@ -1105,9 +1107,13 @@ void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSi
}
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if (type == CV_8UC1)

2
modules/core/include/opencv2/core/base.hpp
View File

@ -566,6 +566,8 @@ CV_EXPORTS void setIppStatus(int status, const char * const funcname = NULL, con
int line = 0);
CV_EXPORTS int getIppStatus();
CV_EXPORTS String getIppErrorLocation();
CV_EXPORTS bool useIPP();
CV_EXPORTS void setUseIPP(bool flag);
} // ipp

16
modules/core/include/opencv2/core/opencl/ocl_defs.hpp
View File

@ -5,6 +5,7 @@
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
#include "opencv2/core/utility.hpp"
//#define CV_OPENCL_RUN_ASSERT
#ifdef HAVE_OPENCL
@ -16,6 +17,7 @@
{ \
printf("%s: OpenCL implementation is running\n", CV_Func); \
fflush(stdout); \
CV_IMPL_ADD(CV_IMPL_OCL); \
return __VA_ARGS__; \
} \
else \
@ -29,14 +31,24 @@
{ \
if (cv::ocl::useOpenCL() && (condition)) \
{ \
CV_Assert(func); \
if(func) \
{ \
CV_IMPL_ADD(CV_IMPL_OCL); \
} \
else \
{ \
CV_Error(cv::Error::StsAssert, #func); \
} \
return __VA_ARGS__; \
} \
}
#else
#define CV_OCL_RUN_(condition, func, ...) \
if (cv::ocl::useOpenCL() && (condition) && func) \
return __VA_ARGS__;
{ \
CV_IMPL_ADD(CV_IMPL_OCL); \
return __VA_ARGS__; \
}
#endif
#else

3
modules/core/include/opencv2/core/private.hpp
View File

@ -254,6 +254,9 @@ static inline IppDataType ippiGetDataType(int depth)
# define IPP_VERSION_X100 0
#endif
#define CV_IPP_CHECK_COND (cv::ipp::useIPP())
#define CV_IPP_CHECK() if(CV_IPP_CHECK_COND)
#ifndef IPPI_CALL
# define IPPI_CALL(func) CV_Assert((func) >= 0)
#endif

24
modules/core/include/opencv2/core/utility.hpp
View File

@ -53,6 +53,30 @@
namespace cv
{
#ifdef CV_COLLECT_IMPL_DATA
CV_EXPORTS void setImpl(int flags); // set implementation flags and reset storage arrays
CV_EXPORTS void addImpl(int flag, const char* func = 0); // add implementation and function name to storage arrays
// Get stored implementation flags and fucntions names arrays
// Each implementation entry correspond to function name entry, so you can find which implementation was executed in which fucntion
CV_EXPORTS int getImpl(std::vector<int> &impl, std::vector<String> &funName);
CV_EXPORTS bool useCollection(); // return implementation colelction state
CV_EXPORTS void setUseCollection(bool flag); // set implementation collection state
#define CV_IMPL_PLAIN 0x01 // native CPU OpenCV implementation
#define CV_IMPL_OCL 0x02 // OpenCL implementation
#define CV_IMPL_IPP 0x04 // IPP implementation
#define CV_IMPL_MT 0x10 // multithreaded implementation
#define CV_IMPL_ADD(impl) \
if(cv::useCollection()) \
{ \
cv::addImpl(impl, CV_Func); \
}
#else
#define CV_IMPL_ADD(impl)
#endif
/*!
Automatically Allocated Buffer Class

186
modules/core/src/arithm.cpp
View File

@ -562,10 +562,16 @@ static void add8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAdd_8u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz), 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpAdd<uchar>, IF_SIMD(VAdd<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -582,10 +588,16 @@ static void add16u( const ushort* src1, size_t step1,
ushort* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAdd_16u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz), 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<ushort, OpAdd<ushort>, IF_SIMD(VAdd<ushort>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -595,10 +607,16 @@ static void add16s( const short* src1, size_t step1,
short* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAdd_16s_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz), 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<short, OpAdd<short>, IF_SIMD(VAdd<short>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -615,10 +633,16 @@ static void add32f( const float* src1, size_t step1,
float* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAdd_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp32<float, OpAdd<float>, IF_SIMD(VAdd<float>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -635,10 +659,16 @@ static void sub8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiSub_8u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, ippiSize(sz), 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpSub<uchar>, IF_SIMD(VSub<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -655,10 +685,16 @@ static void sub16u( const ushort* src1, size_t step1,
ushort* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiSub_16u_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, ippiSize(sz), 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<ushort, OpSub<ushort>, IF_SIMD(VSub<ushort>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -668,10 +704,16 @@ static void sub16s( const short* src1, size_t step1,
short* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiSub_16s_C1RSfs(src2, (int)step2, src1, (int)step1, dst, (int)step, ippiSize(sz), 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<short, OpSub<short>, IF_SIMD(VSub<short>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -688,10 +730,16 @@ static void sub32f( const float* src1, size_t step1,
float* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiSub_32f_C1R(src2, (int)step2, src1, (int)step1, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp32<float, OpSub<float>, IF_SIMD(VSub<float>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -711,6 +759,8 @@ static void max8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
uchar* s1 = (uchar*)src1;
uchar* s2 = (uchar*)src2;
uchar* d = dst;
@ -725,8 +775,12 @@ static void max8u( const uchar* src1, size_t step1,
d += step;
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp<uchar, OpMax<uchar>, IF_SIMD(VMax<uchar>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -743,6 +797,8 @@ static void max16u( const ushort* src1, size_t step1,
ushort* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
ushort* s1 = (ushort*)src1;
ushort* s2 = (ushort*)src2;
ushort* d = dst;
@ -757,8 +813,12 @@ static void max16u( const ushort* src1, size_t step1,
d = (ushort*)((uchar*)d + step);
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp<ushort, OpMax<ushort>, IF_SIMD(VMax<ushort>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -782,6 +842,8 @@ static void max32f( const float* src1, size_t step1,
float* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
float* s1 = (float*)src1;
float* s2 = (float*)src2;
float* d = dst;
@ -796,8 +858,12 @@ static void max32f( const float* src1, size_t step1,
d = (float*)((uchar*)d + step);
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp32<float, OpMax<float>, IF_SIMD(VMax<float>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -807,6 +873,8 @@ static void max64f( const double* src1, size_t step1,
double* dst, size_t step, Size sz, void* )
{
#if ARITHM_USE_IPP == 1
CV_IPP_CHECK()
{
double* s1 = (double*)src1;
double* s2 = (double*)src2;
double* d = dst;
@ -821,8 +889,12 @@ static void max64f( const double* src1, size_t step1,
d = (double*)((uchar*)d + step);
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp64<double, OpMax<double>, IF_SIMD(VMax<double>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -832,6 +904,8 @@ static void min8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
uchar* s1 = (uchar*)src1;
uchar* s2 = (uchar*)src2;
uchar* d = dst;
@ -846,8 +920,12 @@ static void min8u( const uchar* src1, size_t step1,
d += step;
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp<uchar, OpMin<uchar>, IF_SIMD(VMin<uchar>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -864,6 +942,8 @@ static void min16u( const ushort* src1, size_t step1,
ushort* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
ushort* s1 = (ushort*)src1;
ushort* s2 = (ushort*)src2;
ushort* d = dst;
@ -878,8 +958,12 @@ static void min16u( const ushort* src1, size_t step1,
d = (ushort*)((uchar*)d + step);
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp<ushort, OpMin<ushort>, IF_SIMD(VMin<ushort>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -903,6 +987,8 @@ static void min32f( const float* src1, size_t step1,
float* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
float* s1 = (float*)src1;
float* s2 = (float*)src2;
float* d = dst;
@ -917,8 +1003,12 @@ static void min32f( const float* src1, size_t step1,
d = (float*)((uchar*)d + step);
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp32<float, OpMin<float>, IF_SIMD(VMin<float>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -928,6 +1018,8 @@ static void min64f( const double* src1, size_t step1,
double* dst, size_t step, Size sz, void* )
{
#if ARITHM_USE_IPP == 1
CV_IPP_CHECK()
{
double* s1 = (double*)src1;
double* s2 = (double*)src2;
double* d = dst;
@ -942,8 +1034,12 @@ static void min64f( const double* src1, size_t step1,
d = (double*)((uchar*)d + step);
}
if (i == sz.height)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
vBinOp64<double, OpMin<double>, IF_SIMD(VMin<double>)>(src1, step1, src2, step2, dst, step, sz);
}
@ -953,10 +1049,16 @@ static void absdiff8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAbsDiff_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpAbsDiff<uchar>, IF_SIMD(VAbsDiff<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -973,10 +1075,16 @@ static void absdiff16u( const ushort* src1, size_t step1,
ushort* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAbsDiff_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<ushort, OpAbsDiff<ushort>, IF_SIMD(VAbsDiff<ushort>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -1000,10 +1108,16 @@ static void absdiff32f( const float* src1, size_t step1,
float* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAbsDiff_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp32<float, OpAbsDiff<float>, IF_SIMD(VAbsDiff<float>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -1021,10 +1135,16 @@ static void and8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiAnd_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpAnd<uchar>, IF_SIMD(VAnd<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -1034,10 +1154,16 @@ static void or8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiOr_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpOr<uchar>, IF_SIMD(VOr<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -1047,10 +1173,16 @@ static void xor8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiXor_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpXor<uchar>, IF_SIMD(VXor<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -1060,10 +1192,16 @@ static void not8u( const uchar* src1, size_t step1,
uchar* dst, size_t step, Size sz, void* )
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
fixSteps(sz, sizeof(dst[0]), step1, step2, step); (void)src2;
if (0 <= ippiNot_8u_C1R(src1, (int)step1, dst, (int)step, ippiSize(sz)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
(vBinOp<uchar, OpNot<uchar>, IF_SIMD(VNot<uchar>)>(src1, step1, src2, step2, dst, step, sz));
}
@ -2376,12 +2514,18 @@ static void mul8u( const uchar* src1, size_t step1, const uchar* src2, size_t st
{
float fscale = (float)*(const double*)scale;
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (std::fabs(fscale - 1) <= FLT_EPSILON)
{
if (ippiMul_8u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz), 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
mul_(src1, step1, src2, step2, dst, step, sz, fscale);
}
@ -2397,12 +2541,18 @@ static void mul16u( const ushort* src1, size_t step1, const ushort* src2, size_t
{
float fscale = (float)*(const double*)scale;
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (std::fabs(fscale - 1) <= FLT_EPSILON)
{
if (ippiMul_16u_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz), 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
mul_(src1, step1, src2, step2, dst, step, sz, fscale);
}
@ -2412,12 +2562,18 @@ static void mul16s( const short* src1, size_t step1, const short* src2, size_t s
{
float fscale = (float)*(const double*)scale;
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (std::fabs(fscale - 1) <= FLT_EPSILON)
{
if (ippiMul_16s_C1RSfs(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz), 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
mul_(src1, step1, src2, step2, dst, step, sz, fscale);
}
@ -2433,12 +2589,18 @@ static void mul32f( const float* src1, size_t step1, const float* src2, size_t s
{
float fscale = (float)*(const double*)scale;
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (std::fabs(fscale - 1) <= FLT_EPSILON)
{
if (ippiMul_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(sz)) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
mul_(src1, step1, src2, step2, dst, step, sz, fscale);
}
@ -3185,14 +3347,20 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste
uchar* dst, size_t step, Size size, void* _cmpop)
{
#if ARITHM_USE_IPP
CV_IPP_CHECK()
{
IppCmpOp op = convert_cmp(*(int *)_cmpop);
if( op >= 0 )
{
fixSteps(size, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiCompare_8u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(size), op))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
//vz optimized cmp_(src1, step1, src2, step2, dst, step, size, *(int*)_cmpop);
int code = *(int*)_cmpop;
@ -3284,14 +3452,20 @@ static void cmp16u(const ushort* src1, size_t step1, const ushort* src2, size_t
uchar* dst, size_t step, Size size, void* _cmpop)
{
#if ARITHM_USE_IPP
CV_IPP_CHECK()
{
IppCmpOp op = convert_cmp(*(int *)_cmpop);
if( op >= 0 )
{
fixSteps(size, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiCompare_16u_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(size), op))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
cmp_(src1, step1, src2, step2, dst, step, size, *(int*)_cmpop);
}
@ -3300,14 +3474,20 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st
uchar* dst, size_t step, Size size, void* _cmpop)
{
#if ARITHM_USE_IPP
CV_IPP_CHECK()
{
IppCmpOp op = convert_cmp(*(int *)_cmpop);
if( op > 0 )
{
fixSteps(size, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiCompare_16s_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(size), op))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
//vz optimized cmp_(src1, step1, src2, step2, dst, step, size, *(int*)_cmpop);
@ -3438,14 +3618,20 @@ static void cmp32f(const float* src1, size_t step1, const float* src2, size_t st
uchar* dst, size_t step, Size size, void* _cmpop)
{
#if ARITHM_USE_IPP
CV_IPP_CHECK()
{
IppCmpOp op = convert_cmp(*(int *)_cmpop);
if( op >= 0 )
{
fixSteps(size, sizeof(dst[0]), step1, step2, step);
if (0 <= ippiCompare_32f_C1R(src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(size), op))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
cmp_(src1, step1, src2, step2, dst, step, size, *(int*)_cmpop);
}

24
modules/core/src/convert.cpp
View File

@ -2989,12 +2989,18 @@ dtype* dst, size_t dstep, Size size, double* scale) \
static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
dtype* dst, size_t dstep, Size size, double*) \
{ \
CV_IPP_CHECK()\
{\
if (src && dst)\
{\
if (ippiConvert_##ippFavor(src, (int)sstep, dst, (int)dstep, ippiSize(size.width, size.height)) >= 0) \
{\
CV_IMPL_ADD(CV_IMPL_IPP)\
return; \
}\
setIppErrorStatus(); \
}\
}\
cvt_(src, sstep, dst, dstep, size); \
}
@ -3002,12 +3008,18 @@ static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
dtype* dst, size_t dstep, Size size, double*) \
{ \
CV_IPP_CHECK()\
{\
if (src && dst)\
{\
if (ippiConvert_##ippFavor(src, (int)sstep, dst, (int)dstep, ippiSize(size.width, size.height), ippRndFinancial, 0) >= 0) \
{\
CV_IMPL_ADD(CV_IMPL_IPP)\
return; \
}\
setIppErrorStatus(); \
}\
}\
cvt_(src, sstep, dst, dstep, size); \
}
#else
@ -3524,6 +3536,7 @@ public:
setIppErrorStatus();
*ok = false;
}
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
private:
IppLUTParallelBody_LUTC1(const IppLUTParallelBody_LUTC1&);
@ -3567,6 +3580,7 @@ public:
setIppErrorStatus();
return;
}
CV_IMPL_ADD(CV_IMPL_IPP);
}
else if (lutcn == 4)
{
@ -3576,6 +3590,7 @@ public:
setIppErrorStatus();
return;
}
CV_IMPL_ADD(CV_IMPL_IPP);
}
*ok = true;
@ -3605,15 +3620,21 @@ public:
if (ippiLUTPalette_8u_C3R(
src.ptr(), (int)src.step[0], dst.ptr(), (int)dst.step[0],
ippiSize(dst.size()), lutTable, 8) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
}
else if (lutcn == 4)
{
if (ippiLUTPalette_8u_C4R(
src.ptr(), (int)src.step[0], dst.ptr(), (int)dst.step[0],
ippiSize(dst.size()), lutTable, 8) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
}
setIppErrorStatus();
*ok = false;
}
@ -3690,6 +3711,8 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
bool ok = false;
Ptr<ParallelLoopBody> body;
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
size_t elemSize1 = CV_ELEM_SIZE1(dst.depth());
#if 0 // there are no performance benefits (PR #2653)
if (lutcn == 1)
@ -3704,6 +3727,7 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst )
ParallelLoopBody* p = new ipp::IppLUTParallelBody_LUTCN(src, lut, dst, &ok);
body.reset(p);
}
}
#endif
if (body == NULL || ok == false)
{

64
modules/core/src/copy.cpp
View File

@ -82,9 +82,15 @@ template<> void
copyMask_<uchar>(const uchar* _src, size_t sstep, const uchar* mask, size_t mstep, uchar* _dst, size_t dstep, Size size)
{
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (ippiCopy_8u_C1MR(_src, (int)sstep, _dst, (int)dstep, ippiSize(size), mask, (int)mstep) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
for( ; size.height--; mask += mstep, _src += sstep, _dst += dstep )
@ -126,9 +132,15 @@ template<> void
copyMask_<ushort>(const uchar* _src, size_t sstep, const uchar* mask, size_t mstep, uchar* _dst, size_t dstep, Size size)
{
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (ippiCopy_16u_C1MR((const Ipp16u *)_src, (int)sstep, (Ipp16u *)_dst, (int)dstep, ippiSize(size), mask, (int)mstep) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
for( ; size.height--; mask += mstep, _src += sstep, _dst += dstep )
@ -201,9 +213,15 @@ static void copyMask##suffix(const uchar* src, size_t sstep, const uchar* mask,
static void copyMask##suffix(const uchar* src, size_t sstep, const uchar* mask, size_t mstep, \
uchar* dst, size_t dstep, Size size, void*) \
{ \
CV_IPP_CHECK()\
{\
if (ippiCopy_##ippfavor((const ipptype *)src, (int)sstep, (ipptype *)dst, (int)dstep, ippiSize(size), (const Ipp8u *)mask, (int)mstep) >= 0) \
return; \
{\
CV_IMPL_ADD(CV_IMPL_IPP);\
return;\
}\
setIppErrorStatus(); \
}\
copyMask_<type>(src, sstep, mask, mstep, dst, dstep, size); \
}
#else
@ -301,9 +319,15 @@ void Mat::copyTo( OutputArray _dst ) const
size_t len = sz.width*elemSize();
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (ippiCopy_8u_C1R(sptr, (int)step, dptr, (int)dst.step, ippiSize((int)len, sz.height)) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP)
return;
}
setIppErrorStatus();
}
#endif
for( ; sz.height--; sptr += step, dptr += dst.step )
@ -380,6 +404,8 @@ Mat& Mat::operator = (const Scalar& s)
if( is[0] == 0 && is[1] == 0 && is[2] == 0 && is[3] == 0 )
{
#if defined HAVE_IPP && !defined HAVE_IPP_ICV_ONLY && 0
CV_IPP_CHECK()
{
if (dims <= 2 || isContinuous())
{
IppiSize roisize = { cols, rows };
@ -389,15 +415,22 @@ Mat& Mat::operator = (const Scalar& s)
roisize.height = 1;
if (ippsZero_8u(data, static_cast<int>(roisize.width * elemSize())) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP)
return *this;
}
setIppErrorStatus();
}
roisize.width *= (int)elemSize();
if (ippiSet_8u_C1R(0, data, (int)step, roisize) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP)
return *this;
}
setIppErrorStatus();
}
}
#endif
for( size_t i = 0; i < it.nplanes; i++, ++it )
@ -439,6 +472,8 @@ Mat& Mat::setTo(InputArray _value, InputArray _mask)
CV_Assert( mask.empty() || (mask.type() == CV_8U && size == mask.size) );
#if defined HAVE_IPP
CV_IPP_CHECK()
{
int cn = channels(), depth0 = depth();
if (!mask.empty() && (dims <= 2 || (isContinuous() && mask.isContinuous())) &&
@ -508,9 +543,13 @@ Mat& Mat::setTo(InputArray _value, InputArray _mask)
}
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return *this;
}
setIppErrorStatus();
}
}
#endif
size_t esz = elemSize();
@ -714,6 +753,8 @@ void flip( InputArray _src, OutputArray _dst, int flip_mode )
size_t esz = CV_ELEM_SIZE(type);
#if defined HAVE_IPP
CV_IPP_CHECK()
{
typedef IppStatus (CV_STDCALL * ippiMirror)(const void * pSrc, int srcStep, void * pDst, int dstStep, IppiSize roiSize, IppiAxis flip);
typedef IppStatus (CV_STDCALL * ippiMirrorI)(const void * pSrcDst, int srcDstStep, IppiSize roiSize, IppiAxis flip);
ippiMirror ippFunc = 0;
@ -766,15 +807,22 @@ void flip( InputArray _src, OutputArray _dst, int flip_mode )
if (ippFunc != 0)
{
if (ippFunc(src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, ippiSize(src.cols, src.rows), axis) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
else if (ippFuncI != 0)
{
if (ippFuncI(dst.ptr(), (int)dst.step, roisize, axis) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if( flip_mode <= 0 )
@ -1135,6 +1183,8 @@ void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
borderType &= ~BORDER_ISOLATED;
#if defined HAVE_IPP && 0
CV_IPP_CHECK()
{
typedef IppStatus (CV_STDCALL * ippiCopyMakeBorder)(const void * pSrc, int srcStep, IppiSize srcRoiSize, void * pDst,
int dstStep, IppiSize dstRoiSize, int topBorderHeight, int leftBorderWidth);
typedef IppStatus (CV_STDCALL * ippiCopyMakeBorderI)(const void * pSrc, int srcDstStep, IppiSize srcRoiSize, IppiSize dstRoiSize,
@ -1151,11 +1201,11 @@ void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
if (borderType == BORDER_CONSTANT)
{
ippFuncConst =
// type == CV_8UC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_8u_C1R : bug in IPP 8.1
// type == CV_8UC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_8u_C1R : bug in IPP 8.1
type == CV_16UC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_16u_C1R :
// type == CV_16SC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_16s_C1R : bug in IPP 8.1
// type == CV_32SC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_32s_C1R : bug in IPP 8.1
// type == CV_32FC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_32f_C1R : bug in IPP 8.1
// type == CV_16SC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_16s_C1R : bug in IPP 8.1
// type == CV_32SC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_32s_C1R : bug in IPP 8.1
// type == CV_32FC1 ? (ippiCopyConstBorder)ippiCopyConstBorder_32f_C1R : bug in IPP 8.1
type == CV_8UC3 ? (ippiCopyConstBorder)ippiCopyConstBorder_8u_C3R :
type == CV_16UC3 ? (ippiCopyConstBorder)ippiCopyConstBorder_16u_C3R :
type == CV_16SC3 ? (ippiCopyConstBorder)ippiCopyConstBorder_16s_C3R :
@ -1237,10 +1287,14 @@ void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
(ippFuncI && ippFuncI(src.data, (int)src.step, srcRoiSize, dstRoiSize, top, left) >= 0) ||
(ippFuncConst && ippFuncConst(src.data, (int)src.step, srcRoiSize, dst.data, (int)dst.step,
dstRoiSize, top, left, scbuf) >= 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if( borderType != BORDER_CONSTANT )

58
modules/core/src/dxt.cpp
View File

@ -554,13 +554,19 @@ DFT( const Complex<T>* src, Complex<T>* dst, int n,
if( !inv )
{
if (ippsDFTFwd_CToC( src, dst, spec, (uchar*)buf ) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
else
{
if (ippsDFTInv_CToC( src, dst, spec, (uchar*)buf ) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
setIppErrorStatus();
}
#endif
@ -997,6 +1003,7 @@ RealDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab,
if( (n & 1) == 0 )
dst[n] = 0;
}
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
@ -1124,7 +1131,12 @@ CCSIDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab,
if( spec )
{
if (ippsDFTInv_PackToR( src, dst, spec, (uchar*)buf ) >=0)
goto finalize;
{
if( complex_input )
((T*)src)[0] = (T)save_s1;
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
@ -1249,10 +1261,6 @@ CCSIDFT( const T* src, T* dst, int n, int nf, int* factors, const int* itab,
dst[j+1] = t1;
}
}
#ifdef USE_IPP_DFT
finalize:
#endif
if( complex_input )
((T*)src)[0] = (T)save_s1;
}
@ -1556,6 +1564,7 @@ public:
ippFree( pBuffer );
ippFree( pDFTSpec );
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
private:
@ -1629,6 +1638,7 @@ public:
ippFree( pBuffer );
ippFree( pDFTSpec );
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
private:
@ -1727,8 +1737,13 @@ static bool ippi_DFT_C_32F(const Mat& src, Mat& dst, bool inv, int norm_flag)
ippFree( pDFTSpec );
return status >= 0;
if(status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return true;
}
return false;
}
static bool ippi_DFT_R_32F(const Mat& src, Mat& dst, bool inv, int norm_flag)
{
@ -1776,7 +1791,12 @@ static bool ippi_DFT_R_32F(const Mat& src, Mat& dst, bool inv, int norm_flag)
ippFree( pDFTSpec );
return status >= 0;
if(status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return true;
}
return false;
}
#endif
@ -2455,7 +2475,8 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
Mat dst = _dst.getMat();
#if defined USE_IPP_DFT
CV_IPP_CHECK()
{
if ((src.depth() == CV_32F) && (src.total()>(int)(1<<6)) && nonzero_rows == 0)
{
if ((flags & DFT_ROWS) == 0)
@ -2463,13 +2484,19 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
if (src.channels() == 2 && !(inv && (flags & DFT_REAL_OUTPUT)))
{
if (ippi_DFT_C_32F(src, dst, inv, ipp_norm_flag))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
if (src.channels() == 1 && (inv || !(flags & DFT_COMPLEX_OUTPUT)))
{
if (ippi_DFT_R_32F(src, dst, inv, ipp_norm_flag))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
@ -2479,18 +2506,25 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
{
ippiDFT_C_Func ippiFunc = inv ? (ippiDFT_C_Func)ippiDFTInv_CToC_32fc_C1R : (ippiDFT_C_Func)ippiDFTFwd_CToC_32fc_C1R;
if (Dft_C_IPPLoop(src, dst, IPPDFT_C_Functor(ippiFunc),ipp_norm_flag))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
if (src.channels() == 1 && (inv || !(flags & DFT_COMPLEX_OUTPUT)))
{
ippiDFT_R_Func ippiFunc = inv ? (ippiDFT_R_Func)ippiDFTInv_PackToR_32f_C1R : (ippiDFT_R_Func)ippiDFTFwd_RToPack_32f_C1R;
if (Dft_R_IPPLoop(src, dst, IPPDFT_R_Functor(ippiFunc),ipp_norm_flag))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
}
}
#endif
if( !real_transform )
@ -2538,7 +2572,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
spec = 0;
#ifdef USE_IPP_DFT
if( len*count >= 64 ) // use IPP DFT if available
if( CV_IPP_CHECK_COND && (len*count >= 64) ) // use IPP DFT if available
{
int specsize=0, initsize=0, worksize=0;
IppDFTGetSizeFunc getSizeFunc = 0;
@ -3432,13 +3466,19 @@ void cv::dct( InputArray _src0, OutputArray _dst, int flags )
Mat dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
bool row = (flags & DCT_ROWS) != 0;
if (src.type() == CV_32F)
{
if(ippi_DCT_32f(src,dst,inv, row))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
DCTFunc dct_func = dct_tbl[(int)inv + (depth == CV_64F)*2];

72
modules/core/src/mathfuncs.cpp
View File

@ -240,10 +240,16 @@ float cubeRoot( float value )
static void Magnitude_32f(const float* x, const float* y, float* mag, int len)
{
#if defined HAVE_IPP && 0
CV_IPP_CHECK()
{
IppStatus status = ippsMagnitude_32f(x, y, mag, len);
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
int i = 0;
@ -286,10 +292,16 @@ static void Magnitude_32f(const float* x, const float* y, float* mag, int len)
static void Magnitude_64f(const double* x, const double* y, double* mag, int len)
{
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
IppStatus status = ippsMagnitude_64f(x, y, mag, len);
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
int i = 0;
@ -320,9 +332,15 @@ static void Magnitude_64f(const double* x, const double* y, double* mag, int len
static void InvSqrt_32f(const float* src, float* dst, int len)
{
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (ippsInvSqrt_32f_A21(src, dst, len) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
int i = 0;
@ -380,9 +398,15 @@ static void InvSqrt_64f(const double* src, double* dst, int len)
static void Sqrt_32f(const float* src, float* dst, int len)
{
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (ippsSqrt_32f_A21(src, dst, len) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
int i = 0;
@ -414,9 +438,15 @@ static void Sqrt_32f(const float* src, float* dst, int len)
static void Sqrt_64f(const double* src, double* dst, int len)
{
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (ippsSqrt_64f_A50(src, dst, len) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
int i = 0;
@ -790,6 +820,8 @@ void polarToCart( InputArray src1, InputArray src2,
Mat X = dst1.getMat(), Y = dst2.getMat();
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (Mag.isContinuous() && Angle.isContinuous() && X.isContinuous() && Y.isContinuous() && !angleInDegrees)
{
typedef IppStatus (CV_STDCALL * ippsPolarToCart)(const void * pSrcMagn, const void * pSrcPhase,
@ -801,9 +833,13 @@ void polarToCart( InputArray src1, InputArray src2,
IppStatus status = ippFunc(Mag.ptr(), Angle.ptr(), X.ptr(), Y.ptr(), static_cast<int>(cn * X.total()));
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
const Mat* arrays[] = {&Mag, &Angle, &X, &Y, 0};
@ -1353,17 +1389,29 @@ static void Exp_64f( const double *_x, double *y, int n )
#ifdef HAVE_IPP
static void Exp_32f_ipp(const float *x, float *y, int n)
{
CV_IPP_CHECK()
{
if (0 <= ippsExp_32f_A21(x, y, n))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
Exp_32f(x, y, n);
}
static void Exp_64f_ipp(const double *x, double *y, int n)
{
CV_IPP_CHECK()
{
if (0 <= ippsExp_64f_A50(x, y, n))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
Exp_64f(x, y, n);
}
@ -2013,17 +2061,29 @@ static void Log_64f( const double *x, double *y, int n )
#ifdef HAVE_IPP
static void Log_32f_ipp(const float *x, float *y, int n)
{
CV_IPP_CHECK()
{
if (0 <= ippsLn_32f_A21(x, y, n))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
Log_32f(x, y, n);
}
static void Log_64f_ipp(const double *x, double *y, int n)
{
CV_IPP_CHECK()
{
if (0 <= ippsLn_64f_A50(x, y, n))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
Log_64f(x, y, n);
}
@ -2216,6 +2276,8 @@ void pow( InputArray _src, double power, OutputArray _dst )
return;
case 2:
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (depth == CV_32F && !same && ( (_src.dims() <= 2 && !ocl::useOpenCL()) ||
(_src.dims() > 2 && _src.isContinuous() && _dst.isContinuous()) ))
{
@ -2236,9 +2298,13 @@ void pow( InputArray _src, double power, OutputArray _dst )
IppStatus status = ippiSqr_32f_C1R(src.ptr<Ipp32f>(), srcstep, dst.ptr<Ipp32f>(), dststep, ippiSize(size.width, size.height));
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if (same)
multiply(_dst, _dst, _dst);
@ -2288,6 +2354,8 @@ void pow( InputArray _src, double power, OutputArray _dst )
else
{
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (src.isContinuous() && dst.isContinuous())
{
IppStatus status = depth == CV_32F ?
@ -2295,9 +2363,13 @@ void pow( InputArray _src, double power, OutputArray _dst )
ippsPowx_64f_A50(src.ptr<Ipp64f>(), power, dst.ptr<Ipp64f>(), (Ipp32s)(src.total() * cn));
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
int j, k, blockSize = std::min(len, ((BLOCK_SIZE + cn-1)/cn)*cn);

36
modules/core/src/matmul.cpp
View File

@ -2821,11 +2821,17 @@ static double dotProd_8u(const uchar* src1, const uchar* src2, int len)
{
double r = 0;
#if ARITHM_USE_IPP && 0
CV_IPP_CHECK()
{
if (0 <= ippiDotProd_8u64f_C1R(src1, (int)(len*sizeof(src1[0])),
src2, (int)(len*sizeof(src2[0])),
ippiSize(len, 1), &r))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return r;
}
setIppErrorStatus();
}
#endif
int i = 0;
@ -2968,10 +2974,16 @@ static double dotProd_8s(const schar* src1, const schar* src2, int len)
static double dotProd_16u(const ushort* src1, const ushort* src2, int len)
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
double r = 0;
if (0 <= ippiDotProd_16u64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return r;
}
setIppErrorStatus();
}
#endif
return dotProd_(src1, src2, len);
}
@ -2979,10 +2991,16 @@ static double dotProd_16u(const ushort* src1, const ushort* src2, int len)
static double dotProd_16s(const short* src1, const short* src2, int len)
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
double r = 0;
if (0 <= ippiDotProd_16s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return r;
}
setIppErrorStatus();
}
#endif
return dotProd_(src1, src2, len);
}
@ -2990,10 +3008,16 @@ static double dotProd_16s(const short* src1, const short* src2, int len)
static double dotProd_32s(const int* src1, const int* src2, int len)
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
double r = 0;
if (0 <= ippiDotProd_32s64f_C1R(src1, (int)(len*sizeof(src1[0])), src2, (int)(len*sizeof(src2[0])), ippiSize(len, 1), &r))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return r;
}
setIppErrorStatus();
}
#endif
return dotProd_(src1, src2, len);
}
@ -3004,9 +3028,15 @@ static double dotProd_32f(const float* src1, const float* src2, int len)
int i = 0;
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
if (0 <= ippsDotProd_32f64f(src1, src2, len, &r))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return r;
}
setIppErrorStatus();
}
#elif CV_NEON
int len0 = len & -4, blockSize0 = (1 << 13), blockSize;
float32x4_t v_zero = vdupq_n_f32(0.0f);
@ -3035,10 +3065,16 @@ static double dotProd_32f(const float* src1, const float* src2, int len)
static double dotProd_64f(const double* src1, const double* src2, int len)
{
#if (ARITHM_USE_IPP == 1)
CV_IPP_CHECK()
{
double r = 0;
if (0 <= ippsDotProd_64f(src1, src2, len, &r))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return r;
}
setIppErrorStatus();
}
#endif
return dotProd_(src1, src2, len);
}

62
modules/core/src/matrix.cpp
View File

@ -3066,6 +3066,8 @@ void cv::transpose( InputArray _src, OutputArray _dst )
}
#if defined HAVE_IPP
CV_IPP_CHECK()
{
typedef IppStatus (CV_STDCALL * ippiTranspose)(const void * pSrc, int srcStep, void * pDst, int dstStep, IppiSize roiSize);
typedef IppStatus (CV_STDCALL * ippiTransposeI)(const void * pSrcDst, int srcDstStep, IppiSize roiSize);
ippiTranspose ippFunc = 0;
@ -3116,15 +3118,22 @@ void cv::transpose( InputArray _src, OutputArray _dst )
if (ippFunc != 0)
{
if (ippFunc(src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roiSize) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
else if (ippFuncI != 0)
{
if (ippFuncI(dst.ptr(), (int)dst.step, roiSize) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if( dst.data == src.data )
@ -3353,6 +3362,8 @@ static inline void reduceSumC_8u16u16s32f_64f(const cv::Mat& srcmat, cv::Mat& ds
}
CV_Assert(!(ippFunc && ippFuncHint) && func);
CV_IPP_CHECK()
{
if (ippFunc)
{
for (int y = 0; y < size.height; ++y)
@ -3362,6 +3373,7 @@ static inline void reduceSumC_8u16u16s32f_64f(const cv::Mat& srcmat, cv::Mat& ds
cv::Mat dstroi = dstmat.rowRange(y, y + 1);
func(srcmat.rowRange(y, y + 1), dstroi);
}
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
else if (ippFuncHint)
@ -3373,8 +3385,10 @@ static inline void reduceSumC_8u16u16s32f_64f(const cv::Mat& srcmat, cv::Mat& ds
cv::Mat dstroi = dstmat.rowRange(y, y + 1);
func(srcmat.rowRange(y, y + 1), dstroi);
}
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
func(srcmat, dstmat);
}
@ -3409,7 +3423,7 @@ static inline void reduce##optype##C##favor(const cv::Mat& srcmat, cv::Mat& dstm
IppiSize roisize = ippiSize(size.width, 1);\
int sstep = (int)srcmat.step; \
\
if (srcmat.channels() == 1) \
if (CV_IPP_CHECK_COND && (srcmat.channels() == 1)) \
{ \
for (int y = 0; y < size.height; ++y) \
if (ippi##optype##_##favor##_C1R(srcmat.ptr<IppType>(y), sstep, roisize, dstmat.ptr<IppType>(y)) < 0) \
@ -3418,6 +3432,10 @@ static inline void reduce##optype##C##favor(const cv::Mat& srcmat, cv::Mat& dstm
cv::Mat dstroi = dstmat.rowRange(y, y + 1); \
cv::reduceC_ < type1, type2, cv::Op##optype < type2 > >(srcmat.rowRange(y, y + 1), dstroi); \
} \
else \
{ \
CV_IMPL_ADD(CV_IMPL_IPP);\
} \
return; \
} \
cv::reduceC_ < type1, type2, cv::Op##optype < type2 > >(srcmat, dstmat); \
@ -3768,8 +3786,13 @@ template<typename T> static void sort_( const Mat& src, Mat& dst, int flags )
#ifdef USE_IPP_SORT
int depth = src.depth();
IppSortFunc ippSortFunc = getSortFunc(depth, sortDescending);
IppFlipFunc ippFlipFunc = getFlipFunc(depth);
IppSortFunc ippSortFunc = 0;
IppFlipFunc ippFlipFunc = 0;
CV_IPP_CHECK()
{
ippSortFunc = getSortFunc(depth, sortDescending);
ippFlipFunc = getFlipFunc(depth);
}
#endif
for( i = 0; i < n; i++ )
@ -3812,8 +3835,20 @@ template<typename T> static void sort_( const Mat& src, Mat& dst, int flags )
for( j = 0; j < len/2; j++ )
std::swap(ptr[j], ptr[len-1-j]);
}
#ifdef USE_IPP_SORT
else
{
CV_IMPL_ADD(CV_IMPL_IPP);
}
#endif
}
}
#ifdef USE_IPP_SORT
else
{
CV_IMPL_ADD(CV_IMPL_IPP);
}
#endif
if( !sortRows )
for( j = 0; j < len; j++ )
@ -3878,8 +3913,13 @@ template<typename T> static void sortIdx_( const Mat& src, Mat& dst, int flags )
#if defined USE_IPP_SORT && 0
int depth = src.depth();
IppSortIndexFunc ippFunc = getSortIndexFunc(depth, sortDescending);
IppFlipFunc ippFlipFunc = getFlipFunc(depth);
IppSortIndexFunc ippFunc = 0;
IppFlipFunc ippFlipFunc = 0;
CV_IPP_CHECK()
{
ippFunc = getSortIndexFunc(depth, sortDescending);
ippFlipFunc = getFlipFunc(depth);
}
#endif
for( i = 0; i < n; i++ )
@ -3920,8 +3960,20 @@ template<typename T> static void sortIdx_( const Mat& src, Mat& dst, int flags )
for( j = 0; j < len/2; j++ )
std::swap(iptr[j], iptr[len-1-j]);
}
#if defined USE_IPP_SORT && 0
else
{
CV_IMPL_ADD(CV_IMPL_IPP);
}
#endif
}
}
#if defined USE_IPP_SORT && 0
else
{
CV_IMPL_ADD(CV_IMPL_IPP);
}
#endif
if( !sortRows )
for( j = 0; j < len; j++ )

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

@ -2893,6 +2893,9 @@ bool Kernel::create(const char* kname, const Program& prog)
p->release();
p = 0;
}
#ifdef CV_OPENCL_RUN_ASSERT // check kernel compilation fails
CV_Assert(p);
#endif
return p != 0;
}
@ -3523,6 +3526,10 @@ protected:
entry.clBuffer_ = clCreateBuffer((cl_context)ctx.ptr(), CL_MEM_READ_WRITE, entry.capacity_, 0, &retval);
CV_Assert(retval == CL_SUCCESS);
CV_Assert(entry.clBuffer_ != NULL);
if(retval == CL_SUCCESS)
{
CV_IMPL_ADD(CV_IMPL_OCL);
}
LOG_BUFFER_POOL("OpenCL allocate %lld (0x%llx) bytes: %p\n",
(long long)entry.capacity_, (long long)entry.capacity_, entry.clBuffer_);
}
@ -3747,6 +3754,7 @@ public:
CL_MEM_READ_WRITE|createFlags, total, 0, &retval);
if( !handle || retval != CL_SUCCESS )
return defaultAllocate(dims, sizes, type, data, step, flags, usageFlags);
CV_IMPL_ADD(CV_IMPL_OCL)
}
UMatData* u = new UMatData(this);
u->data = 0;
@ -4187,20 +4195,24 @@ public:
CV_Assert(dst->refcount == 0);
cl_command_queue q = (cl_command_queue)Queue::getDefault().ptr();
cl_int retval;
if( iscontinuous )
{
CV_Assert( clEnqueueCopyBuffer(q, (cl_mem)src->handle, (cl_mem)dst->handle,
srcrawofs, dstrawofs, total, 0, 0, 0) == CL_SUCCESS );
CV_Assert( (retval = clEnqueueCopyBuffer(q, (cl_mem)src->handle, (cl_mem)dst->handle,
srcrawofs, dstrawofs, total, 0, 0, 0)) == CL_SUCCESS );
}
else
{
cl_int retval;
CV_Assert( (retval = clEnqueueCopyBufferRect(q, (cl_mem)src->handle, (cl_mem)dst->handle,
new_srcofs, new_dstofs, new_sz,
new_srcstep[0], new_srcstep[1],
new_dststep[0], new_dststep[1],
0, 0, 0)) == CL_SUCCESS );
}
if(retval == CL_SUCCESS)
{
CV_IMPL_ADD(CV_IMPL_OCL)
}
dst->markHostCopyObsolete(true);
dst->markDeviceCopyObsolete(false);

16
modules/core/src/precomp.hpp
View File

@ -233,13 +233,25 @@ void convertAndUnrollScalar( const Mat& sc, int buftype, uchar* scbuf, size_t bl
struct CoreTLSData
{
CoreTLSData() : device(0), useOpenCL(-1)
{}
CoreTLSData() : device(0), useOpenCL(-1), useIPP(-1), useCollection(false)
{
#ifdef CV_COLLECT_IMPL_DATA
implFlags = 0;
#endif
}
RNG rng;
int device;
ocl::Queue oclQueue;
int useOpenCL; // 1 - use, 0 - do not use, -1 - auto/not initialized
int useIPP; // 1 - use, 0 - do not use, -1 - auto/not initialized
bool useCollection; // enable/disable impl data collection
#ifdef CV_COLLECT_IMPL_DATA
int implFlags;
std::vector<int> implCode;
std::vector<String> implFun;
#endif
};
extern TLSData<CoreTLSData> coreTlsData;

68
modules/core/src/stat.cpp
View File

@ -879,6 +879,8 @@ cv::Scalar cv::sum( InputArray _src )
int k, cn = src.channels(), depth = src.depth();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
size_t total_size = src.total();
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( src.dims == 2 || (src.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) )
@ -914,11 +916,13 @@ cv::Scalar cv::sum( InputArray _src )
Scalar sc;
for( int i = 0; i < cn; i++ )
sc[i] = res[i];
CV_IMPL_ADD(CV_IMPL_IPP);
return sc;
}
setIppErrorStatus();
}
}
}
#endif
SumFunc func = getSumFunc(depth);
@ -1029,6 +1033,8 @@ int cv::countNonZero( InputArray _src )
Mat src = _src.getMat();
#if defined HAVE_IPP && !defined HAVE_IPP_ICV_ONLY && 0
CV_IPP_CHECK()
{
if (src.dims <= 2 || src.isContinuous())
{
IppiSize roiSize = { src.cols, src.rows };
@ -1049,9 +1055,13 @@ int cv::countNonZero( InputArray _src )
status = ippiCountInRange_32f_C1R((const Ipp32f *)src.data, srcstep, roiSize, &count, 0, 0);
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return (Ipp32s)src.total() - count;
}
setIppErrorStatus();
}
}
#endif
CountNonZeroFunc func = getCountNonZeroTab(src.depth());
@ -1076,6 +1086,8 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
int k, cn = src.channels(), depth = src.depth();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
size_t total_size = src.total();
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( src.dims == 2 || (src.isContinuous() && mask.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) )
@ -1094,7 +1106,10 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
{
Ipp64f res;
if( ippFuncC1(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, &res) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return Scalar(res);
}
setIppErrorStatus();
}
typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *);
@ -1110,6 +1125,7 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
ippFuncC3(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, 2, &res2) >= 0 &&
ippFuncC3(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, 3, &res3) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return Scalar(res1, res2, res3);
}
setIppErrorStatus();
@ -1147,12 +1163,14 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
Scalar sc;
for( int i = 0; i < cn; i++ )
sc[i] = res[i];
CV_IMPL_ADD(CV_IMPL_IPP);
return sc;
}
setIppErrorStatus();
}
}
}
}
#endif
SumFunc func = getSumFunc(depth);
@ -1338,6 +1356,8 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
int k, cn = src.channels(), depth = src.depth();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
size_t total_size = src.total();
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( src.dims == 2 || (src.isContinuous() && mask.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) )
@ -1382,7 +1402,10 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
if( ippFuncC1 )
{
if( ippFuncC1(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, pmean, pstddev) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *, Ipp64f *);
@ -1396,7 +1419,10 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
if( ippFuncC3(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, 1, &pmean[0], &pstddev[0]) >= 0 &&
ippFuncC3(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, 2, &pmean[1], &pstddev[1]) >= 0 &&
ippFuncC3(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, 3, &pmean[2], &pstddev[2]) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
@ -1413,7 +1439,10 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
if( ippFuncC1 )
{
if( ippFuncC1(src.ptr(), (int)src.step[0], sz, pmean, pstddev) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
typedef IppStatus (CV_STDCALL* ippiMeanStdDevFuncC3)(const void *, int, IppiSize, int, Ipp64f *, Ipp64f *);
@ -1427,11 +1456,15 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
if( ippFuncC3(src.ptr(), (int)src.step[0], sz, 1, &pmean[0], &pstddev[0]) >= 0 &&
ippFuncC3(src.ptr(), (int)src.step[0], sz, 2, &pmean[1], &pstddev[1]) >= 0 &&
ippFuncC3(src.ptr(), (int)src.step[0], sz, 3, &pmean[2], &pstddev[2]) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
}
#endif
@ -1885,6 +1918,8 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
Mat src = _src.getMat(), mask = _mask.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
size_t total_size = src.total();
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( src.dims == 2 || (src.isContinuous() && mask.isContinuous() && cols > 0 && (size_t)rows*cols == total_size) )
@ -1926,6 +1961,7 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
size_t maxidx = maxp.y * cols + maxp.x + 1;
ofs2idx(src, maxidx, maxIdx);
}
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
@ -1963,12 +1999,14 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
size_t maxidx = maxp.y * cols + maxp.x + 1;
ofs2idx(src, maxidx, maxIdx);
}
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
}
#endif
MinMaxIdxFunc func = getMinmaxTab(depth);
@ -2569,6 +2607,8 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
int depth = src.depth(), cn = src.channels();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
size_t total_size = src.total();
int rows = src.size[0], cols = rows ? (int)(total_size/rows) : 0;
@ -2586,7 +2626,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
normType == NORM_INF ?
(type == CV_8UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8u_C1MR :
type == CV_8SC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_8s_C1MR :
// type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_16u_C1MR :
// type == CV_16UC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_16u_C1MR :
type == CV_32FC1 ? (ippiMaskNormFuncC1)ippiNorm_Inf_32f_C1MR :
0) :
normType == NORM_L1 ?
@ -2605,7 +2645,10 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
{
Ipp64f norm;
if( ippFuncC1(src.ptr(), (int)src.step[0], mask.ptr(), (int)mask.step[0], sz, &norm) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm;
}
setIppErrorStatus();
}
@ -2641,6 +2684,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
normType == NORM_L1 ? norm1 + norm2 + norm3 :
normType == NORM_L2 || normType == NORM_L2SQR ? std::sqrt(norm1 * norm1 + norm2 * norm2 + norm3 * norm3) :
0;
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm;
}
setIppErrorStatus();
@ -2718,12 +2762,14 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
normType == NORM_L2 || normType == NORM_L2SQR ? norm + norm_array[i] * norm_array[i] :
0;
}
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2 ? (double)std::sqrt(norm) : (double)norm;
}
setIppErrorStatus();
}
}
}
}
#endif
if( src.isContinuous() && mask.empty() )
@ -2925,6 +2971,8 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
if( normType & CV_RELATIVE )
{
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat();
normType &= NORM_TYPE_MASK;
@ -2969,7 +3017,10 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
{
Ipp64f norm;
if( ippFuncC1(src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], mask.ptr(), (int)mask.step[0], sz, &norm) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm;
}
setIppErrorStatus();
}
}
@ -3005,18 +3056,25 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
{
Ipp64f norm;
if( ippFuncNoHint(src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], sz, &norm) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return (double)norm;
}
setIppErrorStatus();
}
if (ippFuncHint)
{
Ipp64f norm;
if( ippFuncHint(src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], sz, &norm, ippAlgHintAccurate) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return (double)norm;
}
setIppErrorStatus();
}
}
}
}
#endif
return norm(_src1, _src2, normType & ~CV_RELATIVE, _mask)/(norm(_src2, normType, _mask) + DBL_EPSILON);
}
@ -3030,6 +3088,8 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
((normType == NORM_HAMMING || normType == NORM_HAMMING2) && src1.type() == CV_8U) );
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
size_t total_size = src1.total();
int rows = src1.size[0], cols = rows ? (int)(total_size/rows) : 0;
if( (src1.dims == 2 || (src1.isContinuous() && src2.isContinuous() && mask.isContinuous()))
@ -3067,7 +3127,10 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
{
Ipp64f norm;
if( ippFuncC1(src1.ptr(), (int)src1.step[0], src2.ptr(), (int)src2.step[0], mask.ptr(), (int)mask.step[0], sz, &norm) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm;
}
setIppErrorStatus();
}
#ifndef __APPLE__
@ -3103,6 +3166,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
normType == NORM_L1 ? norm1 + norm2 + norm3 :
normType == NORM_L2 || normType == NORM_L2SQR ? std::sqrt(norm1 * norm1 + norm2 * norm2 + norm3 * norm3) :
0;
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2SQR ? (double)(norm * norm) : (double)norm;
}
setIppErrorStatus();
@ -3181,12 +3245,14 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
normType == NORM_L2 || normType == NORM_L2SQR ? norm + norm_array[i] * norm_array[i] :
0;
}
CV_IMPL_ADD(CV_IMPL_IPP);
return normType == NORM_L2 ? (double)std::sqrt(norm) : (double)norm;
}
setIppErrorStatus();
}
}
}
}
#endif
if( src1.isContinuous() && src2.isContinuous() && mask.empty() )

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

@ -1059,6 +1059,51 @@ TLSStorage::~TLSStorage()
TLSData<CoreTLSData> coreTlsData;
#ifdef CV_COLLECT_IMPL_DATA
void setImpl(int flags)
{
CoreTLSData* data = coreTlsData.get();
data->implFlags = flags;
data->implCode.clear();
data->implFun.clear();
}
void addImpl(int flag, const char* func)
{
CoreTLSData* data = coreTlsData.get();
data->implFlags |= flag;
if(func) // use lazy collection if name was not specified
{
size_t index = data->implCode.size();
if(!index || (data->implCode[index-1] != flag || data->implFun[index-1].compare(func))) // avoid duplicates
{
data->implCode.push_back(flag);
data->implFun.push_back(func);
}
}
}
int getImpl(std::vector<int> &impl, std::vector<String> &funName)
{
CoreTLSData* data = coreTlsData.get();
impl = data->implCode;
funName = data->implFun;
return data->implFlags; // return actual flags for lazy collection
}
bool useCollection()
{
CoreTLSData* data = coreTlsData.get();
return data->useCollection;
}
void setUseCollection(bool flag)
{
CoreTLSData* data = coreTlsData.get();
data->useCollection = flag;
}
#endif
namespace ipp
{
@ -1084,6 +1129,35 @@ String getIppErrorLocation()
return format("%s:%d %s", filename ? filename : "", linen, funcname ? funcname : "");
}
bool useIPP()
{
#ifdef HAVE_IPP
CoreTLSData* data = coreTlsData.get();
if(data->useIPP < 0)
{
const char* pIppEnv = getenv("OPENCV_IPP");
if(pIppEnv && (cv::String(pIppEnv) == "disabled"))
data->useIPP = false;
else
data->useIPP = true;
}
return (data->useIPP > 0);
#else
return false;
#endif
}
void setUseIPP(bool flag)
{
CoreTLSData* data = coreTlsData.get();
#ifdef HAVE_IPP
data->useIPP = flag;
#else
(void)flag;
data->useIPP = false;
#endif
}
} // namespace ipp
} // namespace cv

9
modules/core/src/umatrix.cpp
View File

@ -697,9 +697,12 @@ void UMat::copyTo(OutputArray _dst, InputArray _mask) const
size_t globalsize[2] = { cols, rows };
if (k.run(2, globalsize, NULL, false))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
}
#endif
Mat src = getMat(ACCESS_READ);
src.copyTo(_dst, _mask);
@ -753,9 +756,12 @@ void UMat::convertTo(OutputArray _dst, int _type, double alpha, double beta) con
size_t globalsize[2] = { dst.cols * cn, (dst.rows + rowsPerWI - 1) / rowsPerWI };
if (k.run(2, globalsize, NULL, false))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
}
#endif
Mat m = getMat(ACCESS_READ);
m.convertTo(_dst, _type, alpha, beta);
@ -802,9 +808,12 @@ UMat& UMat::setTo(InputArray _value, InputArray _mask)
size_t globalsize[] = { cols, (rows + rowsPerWI - 1) / rowsPerWI };
if( setK.run(2, globalsize, NULL, false) )
{
CV_IMPL_ADD(CV_IMPL_OCL);
return *this;
}
}
}
#endif
Mat m = getMat(haveMask ? ACCESS_RW : ACCESS_WRITE);
m.setTo(_value, _mask);

3
modules/features2d/src/fast.cpp
View File

@ -332,7 +332,10 @@ void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool
{
if( ocl::useOpenCL() && _img.isUMat() && type == FastFeatureDetector::TYPE_9_16 &&
ocl_FAST(_img, keypoints, threshold, nonmax_suppression, 10000))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
switch(type) {
case FastFeatureDetector::TYPE_5_8:

18
modules/features2d/src/matchers.cpp
View File

@ -943,28 +943,40 @@ void BFMatcher::knnMatchImpl( InputArray _queryDescriptors, std::vector<std::vec
if(trainDescCollection.empty())
{
if(ocl_match(_queryDescriptors, utrainDescCollection[0], matches, normType))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
else
{
if(ocl_match(_queryDescriptors, trainDescCollection[0], matches, normType))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
}
else
{
if(trainDescCollection.empty())
{
if(ocl_knnMatch(_queryDescriptors, utrainDescCollection[0], matches, knn, normType, compactResult) )
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
else
{
if(ocl_knnMatch(_queryDescriptors, trainDescCollection[0], matches, knn, normType, compactResult) )
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
}
}
Mat queryDescriptors = _queryDescriptors.getMat();
if(trainDescCollection.empty() && !utrainDescCollection.empty())
@ -1073,14 +1085,20 @@ void BFMatcher::radiusMatchImpl( InputArray _queryDescriptors, std::vector<std::
if (trainDescCollection.empty())
{
if(ocl_radiusMatch(_queryDescriptors, utrainDescCollection[0], matches, maxDistance, normType, compactResult) )
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
else
{
if (ocl_radiusMatch(_queryDescriptors, trainDescCollection[0], matches, maxDistance, normType, compactResult) )
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
}
}
Mat queryDescriptors = _queryDescriptors.getMat();
if(trainDescCollection.empty() && !utrainDescCollection.empty())

6
modules/features2d/src/orb.cpp
View File

@ -823,6 +823,7 @@ static void computeKeyPoints(const Mat& imagePyramid,
uresponses, nkeypoints, 7, HARRIS_K );
if( useOCL )
{
CV_IMPL_ADD(CV_IMPL_OCL);
uresponses.copyTo(responses);
for( i = 0; i < nkeypoints; i++ )
allKeypoints[i].response = responses.at<float>(i);
@ -867,6 +868,7 @@ static void computeKeyPoints(const Mat& imagePyramid,
if( useOCL )
{
CV_IMPL_ADD(CV_IMPL_OCL);
uresponses.copyTo(responses);
for( i = 0; i < nkeypoints; i++ )
allKeypoints[i].angle = responses.at<float>(i);
@ -1110,6 +1112,10 @@ void ORB::operator()( InputArray _image, InputArray _mask, std::vector<KeyPoint>
useOCL = ocl_computeOrbDescriptors(uimagePyramid, ulayerInfo,
ukeypoints, udescriptors, upattern,
nkeypoints, dsize, WTA_K);
if(useOCL)
{
CV_IMPL_ADD(CV_IMPL_OCL);
}
}
if( !useOCL )

24
modules/imgproc/src/accum.cpp
View File

@ -856,6 +856,8 @@ void cv::accumulate( InputArray _src, InputOutputArray _dst, InputArray _mask )
Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (src.dims <= 2 || (src.isContinuous() && dst.isContinuous() && (mask.empty() || mask.isContinuous())))
{
typedef IppStatus (CV_STDCALL * ippiAdd)(const void * pSrc, int srcStep, Ipp32f * pSrcDst, int srcdstStep, IppiSize roiSize);
@ -902,10 +904,14 @@ void cv::accumulate( InputArray _src, InputOutputArray _dst, InputArray _mask )
dst.ptr<Ipp32f>(), dststep, ippiSize(size.width, size.height));
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
#endif
int fidx = getAccTabIdx(sdepth, ddepth);
@ -935,6 +941,8 @@ void cv::accumulateSquare( InputArray _src, InputOutputArray _dst, InputArray _m
Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (src.dims <= 2 || (src.isContinuous() && dst.isContinuous() && (mask.empty() || mask.isContinuous())))
{
typedef IppStatus (CV_STDCALL * ippiAddSquare)(const void * pSrc, int srcStep, Ipp32f * pSrcDst, int srcdstStep, IppiSize roiSize);
@ -979,10 +987,14 @@ void cv::accumulateSquare( InputArray _src, InputOutputArray _dst, InputArray _m
dst.ptr<Ipp32f>(), dststep, ippiSize(size.width, size.height));
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
#endif
int fidx = getAccTabIdx(sdepth, ddepth);
@ -1014,6 +1026,8 @@ void cv::accumulateProduct( InputArray _src1, InputArray _src2,
Mat src1 = _src1.getMat(), src2 = _src2.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (src1.dims <= 2 || (src1.isContinuous() && src2.isContinuous() && dst.isContinuous()))
{
typedef IppStatus (CV_STDCALL * ippiAddProduct)(const void * pSrc1, int src1Step, const void * pSrc2,
@ -1061,10 +1075,14 @@ void cv::accumulateProduct( InputArray _src1, InputArray _src2,
dst.ptr<Ipp32f>(), dststep, ippiSize(size.width, size.height));
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
#endif
int fidx = getAccTabIdx(sdepth, ddepth);
@ -1095,6 +1113,8 @@ void cv::accumulateWeighted( InputArray _src, InputOutputArray _dst,
Mat src = _src.getMat(), dst = _dst.getMat(), mask = _mask.getMat();
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (src.dims <= 2 || (src.isContinuous() && dst.isContinuous() && mask.isContinuous()))
{
typedef IppStatus (CV_STDCALL * ippiAddWeighted)(const void * pSrc, int srcStep, Ipp32f * pSrcDst, int srcdstStep,
@ -1141,10 +1161,14 @@ void cv::accumulateWeighted( InputArray _src, InputOutputArray _dst,
dst.ptr<Ipp32f>(), dststep, ippiSize(size.width, size.height), (Ipp32f)alpha);
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
#endif
int fidx = getAccTabIdx(sdepth, ddepth);

6
modules/imgproc/src/canny.cpp
View File

@ -265,12 +265,18 @@ void cv::Canny( InputArray _src, OutputArray _dst,
#endif
#ifdef USE_IPP_CANNY
CV_IPP_CHECK()
{
if( aperture_size == 3 && !L2gradient && 1 == cn )
{
if (ippCanny(src, dst, (float)low_thresh, (float)high_thresh))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
Mat dx(src.rows, src.cols, CV_16SC(cn));

3
modules/imgproc/src/clahe.cpp
View File

@ -404,7 +404,10 @@ namespace
#ifdef HAVE_OPENCL
if (useOpenCL && clahe::calcLut(_srcForLut, ulut_, tilesX_, tilesY_, tileSize, clipLimit, lutScale) )
if( clahe::transform(_src, _dst, ulut_, tilesX_, tilesY_, tileSize) )
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
#endif
cv::Mat src = _src.getMat();

260
modules/imgproc/src/color.cpp
View File

@ -223,6 +223,10 @@ public:
void *yD = dst.ptr<uchar>(range.start);
if( !cvt(yS, (int)src.step[0], yD, (int)dst.step[0], src.cols, range.end - range.start) )
*ok = false;
else
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
}
private:
@ -5427,44 +5431,65 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( code == CV_BGR2BGRA)
{
if ( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC3C4RTab[depth], 0, 1, 2)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGRA2BGR )
{
if ( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiCopyAC4C3RTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGR2RGBA )
{
if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC3C4RTab[depth], 2, 1, 0)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGBA2BGR )
{
if( CvtColorIPPLoop(src, dst, IPPReorderFunctor(ippiSwapChannelsC4C3RTab[depth], 2, 1, 0)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2BGR )
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC3RTab[depth], 2, 1, 0)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
#if IPP_VERSION_X100 >= 801
else if( code == CV_RGBA2BGRA )
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderFunctor(ippiSwapChannelsC4RTab[depth], 2, 1, 0)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
#endif
}
#endif
if( depth == CV_8U )
@ -5487,12 +5512,17 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined(HAVE_IPP) && 0 // breaks OCL accuracy tests
CV_IPP_CHECK()
{
CV_SUPPRESS_DEPRECATED_START
if (code == CV_BGR2BGR565 && scn == 3)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiBGRToBGR565_8u16u_C3R)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_BGRA2BGR565 && scn == 4)
@ -5500,24 +5530,34 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
if (CvtColorIPPLoopCopy(src, dst,
IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
(ippiGeneralFunc)ippiBGRToBGR565_8u16u_C3R, 0, 1, 2, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_RGB2BGR565 && scn == 3)
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth],
(ippiGeneralFunc)ippiBGRToBGR565_8u16u_C3R, 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_RGBA2BGR565 && scn == 4)
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
(ippiGeneralFunc)ippiBGRToBGR565_8u16u_C3R, 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
CV_SUPPRESS_DEPRECATED_END
}
#endif
#ifdef HAVE_TEGRA_OPTIMIZATION
@ -5542,35 +5582,50 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#ifdef HAVE_IPP
CV_IPP_CHECK()
{
CV_SUPPRESS_DEPRECATED_START
if (code == CV_BGR5652BGR && dcn == 3)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiBGR565ToBGR_16u8u_C3R)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_BGR5652RGB && dcn == 3)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiBGR565ToBGR_16u8u_C3R,
ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_BGR5652BGRA && dcn == 4)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiBGR565ToBGR_16u8u_C3R,
ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_BGR5652RGBA && dcn == 4)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiBGR565ToBGR_16u8u_C3R,
ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
CV_SUPPRESS_DEPRECATED_END
}
#endif
CvtColorLoop(src, dst, RGB5x52RGB(dcn,
@ -5587,30 +5642,45 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( code == CV_BGR2GRAY && depth == CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippiColor2GrayC3Tab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2GRAY && depth == CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGB2GrayC3Tab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGRA2GRAY && depth == CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPColor2GrayFunctor(ippiColor2GrayC4Tab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGBA2GRAY && depth == CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGB2GrayC4Tab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
bidx = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2;
@ -5643,18 +5713,27 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( code == CV_GRAY2BGR )
{
if( CvtColorIPPLoop(src, dst, IPPGray2BGRFunctor(ippiCopyP3C3RTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_GRAY2BGRA )
{
if( CvtColorIPPLoop(src, dst, IPPGray2BGRAFunctor(ippiCopyP3C3RTab[depth], ippiSwapChannelsC3C4RTab[depth], depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
@ -5693,33 +5772,48 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined HAVE_IPP && 0
CV_IPP_CHECK()
{
if (code == CV_RGB2YUV && scn == 3 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiRGBToYUV_8u_C3R)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_BGR2YUV && scn == 3 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth],
(ippiGeneralFunc)ippiRGBToYUV_8u_C3R, 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_RGB2YUV && scn == 4 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
(ippiGeneralFunc)ippiRGBToYUV_8u_C3R, 0, 1, 2, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_BGR2YUV && scn == 4 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
(ippiGeneralFunc)ippiRGBToYUV_8u_C3R, 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
if( depth == CV_8U )
@ -5752,33 +5846,48 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined HAVE_IPP && 0
CV_IPP_CHECK()
{
if (code == CV_YUV2RGB && dcn == 3 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiYUVToRGB_8u_C3R)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_YUV2BGR && dcn == 3 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiYUVToRGB_8u_C3R,
ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_YUV2RGB && dcn == 4 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiYUVToRGB_8u_C3R,
ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_YUV2BGR && dcn == 4 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiYUVToRGB_8u_C3R,
ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
if( depth == CV_8U )
@ -5798,30 +5907,45 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( code == CV_BGR2XYZ && scn == 3 && depth != CV_32F )
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2XYZTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGR2XYZ && scn == 4 && depth != CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2XYZTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2XYZ && scn == 3 && depth != CV_32F )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2XYZTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2XYZ && scn == 4 && depth != CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2XYZTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
if( depth == CV_8U )
@ -5841,30 +5965,45 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( code == CV_XYZ2BGR && dcn == 3 && depth != CV_32F )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_XYZ2BGR && dcn == 4 && depth != CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
if( code == CV_XYZ2RGB && dcn == 3 && depth != CV_32F )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiXYZ2RGBTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_XYZ2RGB && dcn == 4 && depth != CV_32F )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiXYZ2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
if( depth == CV_8U )
@ -5888,59 +6027,86 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( depth == CV_8U || depth == CV_16U )
{
#if 0 // breaks OCL accuracy tests
if( code == CV_BGR2HSV_FULL && scn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGR2HSV_FULL && scn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2HSV_FULL && scn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HSVTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
} else
#endif
if( code == CV_RGB2HSV_FULL && scn == 3 && depth == CV_16U )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2HSVTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGR2HLS_FULL && scn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_BGR2HLS_FULL && scn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2HLS_FULL && scn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiRGB2HLSTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_RGB2HLS_FULL && scn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth], ippiRGB2HLSTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
}
#endif
if( code == CV_BGR2HSV || code == CV_RGB2HSV ||
@ -5979,57 +6145,84 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if( depth == CV_8U || depth == CV_16U )
{
if( code == CV_HSV2BGR_FULL && dcn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HSV2BGR_FULL && dcn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HSV2RGB_FULL && dcn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiHSV2RGBTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HSV2RGB_FULL && dcn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHSV2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HLS2BGR_FULL && dcn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HLS2BGR_FULL && dcn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HLS2RGB_FULL && dcn == 3 )
{
if( CvtColorIPPLoopCopy(src, dst, IPPGeneralFunctor(ippiHLS2RGBTab[depth])) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_HLS2RGB_FULL && dcn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiHLS2RGBTab[depth], ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
}
#endif
if( code == CV_HSV2BGR || code == CV_HSV2RGB ||
@ -6062,19 +6255,26 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
_dst.create(sz, CV_MAKETYPE(depth, 3));
dst = _dst.getMat();
#ifdef HAVE_IPP
#if 0
#if defined HAVE_IPP && 0
CV_IPP_CHECK()
{
if (code == CV_LBGR2Lab && scn == 3 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiBGRToLab_8u_C3R)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_LBGR2Lab && scn == 4 && depth == CV_8U)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
(ippiGeneralFunc)ippiBGRToLab_8u_C3R, 0, 1, 2, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else
@ -6082,44 +6282,62 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth],
(ippiGeneralFunc)ippiBGRToLab_8u_C3R, 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_LRGB2Lab && scn == 4 && depth == CV_8U) // slower than OpenCV
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
(ippiGeneralFunc)ippiBGRToLab_8u_C3R, 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_LRGB2Luv && scn == 3)
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor(ippiRGBToLUVTab[depth])))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_LRGB2Luv && scn == 4)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
ippiRGBToLUVTab[depth], 0, 1, 2, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_LBGR2Luv && scn == 3)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC3RTab[depth],
ippiRGBToLUVTab[depth], 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if (code == CV_LBGR2Luv && scn == 4)
{
if (CvtColorIPPLoop(src, dst, IPPReorderGeneralFunctor(ippiSwapChannelsC4C3RTab[depth],
ippiRGBToLUVTab[depth], 2, 1, 0, depth)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
#endif
}
#endif
if( code == CV_BGR2Lab || code == CV_RGB2Lab ||
@ -6154,31 +6372,45 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
dst = _dst.getMat();
#if defined HAVE_IPP && 0
CV_IPP_CHECK()
{
if( code == CV_Lab2LBGR && dcn == 3 && depth == CV_8U)
{
if( CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiLabToBGR_8u_C3R)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_Lab2LBGR && dcn == 4 && depth == CV_8U )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiLabToBGR_8u_C3R,
ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
if( code == CV_Lab2LRGB && dcn == 3 && depth == CV_8U )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiLabToBGR_8u_C3R,
ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
else if( code == CV_Lab2LRGB && dcn == 4 && depth == CV_8U )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor((ippiGeneralFunc)ippiLabToBGR_8u_C3R,
ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
if( code == CV_Luv2LRGB && dcn == 3 )
@ -6190,20 +6422,30 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiLUVToRGBTab[depth],
ippiSwapChannelsC3C4RTab[depth], 0, 1, 2, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
}
if( code == CV_Luv2LBGR && dcn == 3 )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiLUVToRGBTab[depth],
ippiSwapChannelsC3RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
}
else if( code == CV_Luv2LBGR && dcn == 4 )
{
if( CvtColorIPPLoop(src, dst, IPPGeneralReorderFunctor(ippiLUVToRGBTab[depth],
ippiSwapChannelsC3C4RTab[depth], 2, 1, 0, depth)) )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
}
}
#endif
if( code == CV_Lab2BGR || code == CV_Lab2RGB ||
@ -6314,10 +6556,16 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
_dst.create(dstSz, CV_MAKETYPE(depth, dcn));
dst = _dst.getMat();
#if defined HAVE_IPP
CV_IPP_CHECK()
{
if (ippStsNoErr == ippiCopy_8u_C1R(src.data, (int)src.step, dst.data, (int)dst.step,
ippiSize(dstSz.width, dstSz.height)))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
#endif
src(Range(0, dstSz.height), Range::all()).copyTo(dst);
}
@ -6409,9 +6657,15 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
if( depth == CV_8U )
{
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
if (CvtColorIPPLoop(src, dst, IPPGeneralFunctor((ippiGeneralFunc)ippiAlphaPremul_8u_AC4R)))
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
#endif
CvtColorLoop(src, dst, RGBA2mRGBA<uchar>());
}

12
modules/imgproc/src/corner.cpp
View File

@ -472,6 +472,8 @@ void cv::cornerMinEigenVal( InputArray _src, OutputArray _dst, int blockSize, in
_dst.create( src.size(), CV_32FC1 );
Mat dst = _dst.getMat();
#if defined(HAVE_IPP) && (IPP_VERSION_MAJOR >= 8)
CV_IPP_CHECK()
{
typedef IppStatus (CV_STDCALL * ippiMinEigenValGetBufferSize)(IppiSize, int, int, int*);
typedef IppStatus (CV_STDCALL * ippiMinEigenVal)(const void*, int, Ipp32f*, int, IppiSize, IppiKernelType, int, int, Ipp8u*);
IppiKernelType kerType;
@ -519,11 +521,15 @@ void cv::cornerMinEigenVal( InputArray _src, OutputArray _dst, int blockSize, in
if (ok >= 0) ok = ippiMulC_32f_C1IR(norm_coef, dst.ptr<Ipp32f>(), (int) dst.step, srcRoi);
CV_SUPPRESS_DEPRECATED_END
if (ok >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
setIppErrorStatus();
}
}
}
#endif
cornerEigenValsVecs( src, dst, blockSize, ksize, MINEIGENVAL, 0, borderType );
}
@ -538,6 +544,8 @@ void cv::cornerHarris( InputArray _src, OutputArray _dst, int blockSize, int ksi
Mat dst = _dst.getMat();
#if IPP_VERSION_X100 >= 801 && 0
CV_IPP_CHECK()
{
int type = src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
int borderTypeNI = borderType & ~BORDER_ISOLATED;
bool isolated = (borderType & BORDER_ISOLATED) != 0;
@ -573,10 +581,14 @@ void cv::cornerHarris( InputArray _src, OutputArray _dst, int blockSize, int ksi
ippsFree(buffer);
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
setIppErrorStatus();
}
}
#endif
cornerEigenValsVecs( src, dst, blockSize, ksize, HARRIS, k, borderType );

21
modules/imgproc/src/deriv.cpp
View File

@ -573,16 +573,25 @@ void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
#endif
#ifdef HAVE_IPP
CV_IPP_CHECK()
{
if (ksize < 0)
{
if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
else if (0 < ksize)
{
if (IPPDerivSobel(_src, _dst, ddepth, dx, dy, ksize, scale, delta, borderType))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
}
#endif
int ktype = std::max(CV_32F, std::max(ddepth, sdepth));
@ -620,8 +629,14 @@ void cv::Scharr( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
#endif
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
if (IPPDerivScharr(_src, _dst, ddepth, dx, dy, scale, delta, borderType))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
#endif
int ktype = std::max(CV_32F, std::max(ddepth, sdepth));
@ -793,6 +808,8 @@ void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
_dst.create( _src.size(), CV_MAKETYPE(ddepth, cn) );
#ifdef HAVE_IPP
CV_IPP_CHECK()
{
if ((ksize == 3 || ksize == 5) && ((borderType & BORDER_ISOLATED) != 0 || !_src.isSubmatrix()) &&
((stype == CV_8UC1 && ddepth == CV_16S) || (ddepth == CV_32F && stype == CV_32FC1)) && !ocl::useOpenCL())
{
@ -844,11 +861,15 @@ void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
CV_SUPPRESS_DEPRECATED_END
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#undef IPP_FILTER_LAPLACIAN
}
#endif
#ifdef HAVE_TEGRA_OPTIMIZATION

36
modules/imgproc/src/distransform.cpp
View File

@ -688,13 +688,19 @@ static void distanceTransform_L1_8U(InputArray _src, OutputArray _dst)
_dst.create( src.size(), CV_8UC1);
Mat dst = _dst.getMat();
#ifdef HAVE_IPP
#ifdef HAVE_IPP
CV_IPP_CHECK()
{
IppiSize roi = { src.cols, src.rows };
Ipp32s pMetrics[2] = { 1, 2 }; //L1, 3x3 mask
if (ippiDistanceTransform_3x3_8u_C1R(src.ptr<uchar>(), (int)src.step, dst.ptr<uchar>(), (int)dst.step, roi, pMetrics)>=0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
#endif
}
#endif
distanceATS_L1_8u(src, dst);
}
@ -735,6 +741,8 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe
{
#ifdef HAVE_IPP
CV_IPP_CHECK()
{
if ((currentParallelFramework()==NULL) || (src.total()<(int)(1<<14)))
{
IppStatus status;
@ -749,10 +757,14 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe
status = ippiTrueDistanceTransform_8u32f_C1R(src.ptr<uchar>(),(int)src.step, dst.ptr<float>(), (int)dst.step, roi, pBuffer);
ippFree( pBuffer );
if (status>=0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
#endif
trueDistTrans( src, dst );
@ -773,23 +785,35 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe
{
if( maskSize == CV_DIST_MASK_3 )
{
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
IppiSize roi = { src.cols, src.rows };
if (ippiDistanceTransform_3x3_8u32f_C1R(src.ptr<uchar>(), (int)src.step, dst.ptr<float>(), (int)dst.step, roi, _mask)>=0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
#endif
}
#endif
distanceTransform_3x3(src, temp, dst, _mask);
}
else
{
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
IppiSize roi = { src.cols, src.rows };
if (ippiDistanceTransform_5x5_8u32f_C1R(src.ptr<uchar>(), (int)src.step, dst.ptr<float>(), (int)dst.step, roi, _mask)>=0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
#endif
}
#endif
distanceTransform_5x5(src, temp, dst, _mask);
}

10
modules/imgproc/src/filter.cpp
View File

@ -1423,9 +1423,12 @@ struct RowVec_32f
int operator()(const uchar* _src, uchar* _dst, int width, int cn) const
{
#if defined USE_IPP_SEP_FILTERS && 0
CV_IPP_CHECK()
{
int ret = ippiOperator(_src, _dst, width, cn);
if (ret > 0)
return ret;
}
#endif
int _ksize = kernel.rows + kernel.cols - 1;
const float* src0 = (const float*)_src;
@ -1494,6 +1497,7 @@ private:
setIppErrorStatus();
return 0;
}
CV_IMPL_ADD(CV_IMPL_IPP);
return width - _ksize + 1;
}
#endif
@ -3743,6 +3747,8 @@ void cv::filter2D( InputArray _src, OutputArray _dst, int ddepth,
Point anchor = normalizeAnchor(anchor0, kernel.size());
#if IPP_VERSION_X100 > 0 && !defined HAVE_IPP_ICV_ONLY
CV_IPP_CHECK()
{
typedef IppStatus (CV_STDCALL * ippiFilterBorder)(const void * pSrc, int srcStep, void * pDst, int dstStep, IppiSize dstRoiSize,
IppiBorderType border, const void * borderValue,
const IppiFilterBorderSpec* pSpec, Ipp8u* pBuffer);
@ -3802,10 +3808,14 @@ void cv::filter2D( InputArray _src, OutputArray _dst, int ddepth,
}
if (status >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
#endif
#ifdef HAVE_TEGRA_OPTIMIZATION

5
modules/imgproc/src/histogram.cpp
View File

@ -1200,6 +1200,7 @@ public:
*ok = false;
return;
}
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
for (int i = 0; i < histSize; ++i)
CV_XADD((int *)(hist->data + i * hist->step), *(int *)(phist.data + i * phist.step));
@ -1233,6 +1234,8 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
ihist.flags = (ihist.flags & ~CV_MAT_TYPE_MASK)|CV_32S;
#ifdef HAVE_IPP
CV_IPP_CHECK()
{
if (nimages == 1 && images[0].type() == CV_8UC1 && dims == 1 && channels &&
channels[0] == 0 && mask.empty() && images[0].dims <= 2 &&
!accumulate && uniform)
@ -1253,10 +1256,12 @@ void cv::calcHist( const Mat* images, int nimages, const int* channels,
if (ok)
{
ihist.convertTo(hist, CV_32F);
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
if( !accumulate || histdata != hist.data )

8
modules/imgproc/src/hough.cpp
View File

@ -100,6 +100,8 @@ HoughLinesStandard( const Mat& img, float rho, float theta,
int numrho = cvRound(((width + height) * 2 + 1) / rho);
#if (0 && defined(HAVE_IPP) && !defined(HAVE_IPP_ICV_ONLY) && IPP_VERSION_X100 >= 801)
CV_IPP_CHECK()
{
IppiSize srcSize = { width, height };
IppPointPolar delta = { rho, theta };
IppPointPolar dstRoi[2] = {{(Ipp32f) -(width + height), (Ipp32f) min_theta},{(Ipp32f) (width + height), (Ipp32f) max_theta}};
@ -115,10 +117,12 @@ HoughLinesStandard( const Mat& img, float rho, float theta,
if (ok >= 0)
{
lines.resize(linesCount);
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
lines.clear();
setIppErrorStatus();
}
#endif
AutoBuffer<int> _accum((numangle+2) * (numrho+2));
@ -429,6 +433,8 @@ HoughLinesProbabilistic( Mat& image,
int numrho = cvRound(((width + height) * 2 + 1) / rho);
#if (0 && defined(HAVE_IPP) && !defined(HAVE_IPP_ICV_ONLY) && IPP_VERSION_X100 >= 801)
CV_IPP_CHECK()
{
IppiSize srcSize = { width, height };
IppPointPolar delta = { rho, theta };
IppiHoughProbSpec* pSpec;
@ -447,10 +453,12 @@ HoughLinesProbabilistic( Mat& image,
if (ok >= 0)
{
lines.resize(linesCount);
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
lines.clear();
setIppErrorStatus();
}
#endif
Mat accum = Mat::zeros( numangle, numrho, CV_32SC1 );

40
modules/imgproc/src/imgwarp.cpp
View File

@ -2271,6 +2271,10 @@ public:
if( func( pSrc, (int)src.step[0], pDst, (int)dst.step[0], dstOffset, dstSize, ippBorderRepl, 0, pSpec, bufptr ) < 0 )
*ok = false;
else
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
}
private:
const Mat & src;
@ -2694,6 +2698,8 @@ void cv::resize( InputArray _src, OutputArray _dst, Size dsize,
std::abs(scale_y - iscale_y) < DBL_EPSILON;
#if IPP_VERSION_X100 >= 701
CV_IPP_CHECK()
{
#define IPP_RESIZE_EPS 1e-10
double ex = fabs((double)dsize.width / src.cols - inv_scale_x) / inv_scale_x;
@ -2718,11 +2724,15 @@ void cv::resize( InputArray _src, OutputArray _dst, Size dsize,
IPPresizeInvoker invoker(src, dst, inv_scale_x, inv_scale_y, mode, &ok);
parallel_for_(range, invoker, dst.total()/(double)(1<<16));
if( ok )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#undef IPP_RESIZE_EPS
}
#endif
if( interpolation == INTER_NEAREST )
@ -4033,6 +4043,10 @@ public:
map1.ptr<Ipp32f>(), (int)map1.step, map2.ptr<Ipp32f>(), (int)map2.step,
dstRoi.ptr(), (int)dstRoi.step, dstRoiSize, ippInterpolation) < 0)
*ok = false;
else
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
}
private:
@ -4102,6 +4116,8 @@ void cv::remap( InputArray _src, OutputArray _dst,
int type = src.type(), depth = CV_MAT_DEPTH(type);
#if IPP_VERSION_X100 >= 0 && !defined HAVE_IPP_ICV_ONLY && 0
CV_IPP_CHECK()
{
if ((interpolation == INTER_LINEAR || interpolation == INTER_CUBIC || interpolation == INTER_NEAREST) &&
map1.type() == CV_32FC1 && map2.type() == CV_32FC1 &&
(borderType == BORDER_CONSTANT || borderType == BORDER_TRANSPARENT))
@ -4130,10 +4146,14 @@ void cv::remap( InputArray _src, OutputArray _dst,
parallel_for_(range, invoker, dst.total() / (double)(1 << 16));
if (ok)
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
}
#endif
RemapNNFunc nnfunc = 0;
@ -4482,6 +4502,10 @@ public:
(int)dst.step[0], dstroi, coeffs, mode );
if( status < 0)
*ok = false;
else
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
}
private:
Mat &src;
@ -4649,6 +4673,8 @@ void cv::warpAffine( InputArray _src, OutputArray _dst,
const int AB_SCALE = 1 << AB_BITS;
#if defined (HAVE_IPP) && IPP_VERSION_MAJOR * 100 + IPP_VERSION_MINOR >= 801 && 0
CV_IPP_CHECK()
{
int type = src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
if( ( depth == CV_8U || depth == CV_16U || depth == CV_32F ) &&
( cn == 1 || cn == 3 || cn == 4 ) &&
@ -4701,9 +4727,13 @@ void cv::warpAffine( InputArray _src, OutputArray _dst,
IPPWarpAffineInvoker invoker(src, dst, coeffs, mode, borderType, borderValue, ippFunc, &ok);
parallel_for_(range, invoker, dst.total()/(double)(1<<16));
if( ok )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
for( x = 0; x < dst.cols; x++ )
@ -4847,6 +4877,10 @@ public:
IppStatus status = func(src.ptr(), srcsize, (int)src.step[0], srcroi, dst.ptr(), (int)dst.step[0], dstroi, coeffs, mode);
if (status != ippStsNoErr)
*ok = false;
else
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
}
private:
Mat &src;
@ -4895,6 +4929,8 @@ void cv::warpPerspective( InputArray _src, OutputArray _dst, InputArray _M0,
#if defined (HAVE_IPP) && IPP_VERSION_MAJOR * 100 + IPP_VERSION_MINOR >= 801 && 0
CV_IPP_CHECK()
{
int type = src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
if( (depth == CV_8U || depth == CV_16U || depth == CV_32F) &&
(cn == 1 || cn == 3 || cn == 4) &&
@ -4942,9 +4978,13 @@ void cv::warpPerspective( InputArray _src, OutputArray _dst, InputArray _M0,
IPPWarpPerspectiveInvoker invoker(src, dst, coeffs, mode, borderType, borderValue, ippFunc, &ok);
parallel_for_(range, invoker, dst.total()/(double)(1<<16));
if( ok )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
if( !(flags & WARP_INVERSE_MAP) )

4
modules/imgproc/src/moments.cpp
View File

@ -578,6 +578,8 @@ cv::Moments cv::moments( InputArray _src, bool binary )
CV_Error( CV_StsBadArg, "Invalid image type (must be single-channel)" );
#if IPP_VERSION_X100 >= 801 && 0
CV_IPP_CHECK()
{
if (!binary)
{
IppiSize roi = { mat.cols, mat.rows };
@ -627,6 +629,7 @@ cv::Moments cv::moments( InputArray _src, bool binary )
ippiGetNormalizedCentralMoment_64f(moment, 0, 3, 0, &m.nu03);
ippiMomentFree_64f(moment);
CV_IMPL_ADD(CV_IMPL_IPP);
return m;
}
setIppErrorStatus();
@ -637,6 +640,7 @@ cv::Moments cv::moments( InputArray _src, bool binary )
setIppErrorStatus();
CV_SUPPRESS_DEPRECATED_END
}
}
#endif
if( binary || depth == CV_8U )

6
modules/imgproc/src/morph.cpp
View File

@ -1707,8 +1707,14 @@ static void morphOp( int op, InputArray _src, OutputArray _dst,
}
#if IPP_VERSION_X100 >= 801
CV_IPP_CHECK()
{
if( IPPMorphOp(op, _src, _dst, kernel, anchor, iterations, borderType, borderValue) )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
}
#endif
Mat src = _src.getMat();

19
modules/imgproc/src/pyramids.cpp
View File

@ -703,6 +703,8 @@ void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borde
#endif
#if IPP_VERSION_X100 >= 801 && 0
CV_IPP_CHECK()
{
bool isolated = (borderType & BORDER_ISOLATED) != 0;
int borderTypeNI = borderType & ~BORDER_ISOLATED;
if (borderTypeNI == BORDER_DEFAULT && (!src.isSubmatrix() || isolated) && dsz == Size((src.cols + 1)/2, (src.rows + 1)/2))
@ -731,11 +733,15 @@ void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borde
ippsFree(buffer);
if (ok >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
}
#endif
PyrFunc func = 0;
@ -774,6 +780,8 @@ void cv::pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz, int borderT
#endif
#if IPP_VERSION_X100 >= 801 && 0
CV_IPP_CHECK()
{
bool isolated = (borderType & BORDER_ISOLATED) != 0;
int borderTypeNI = borderType & ~BORDER_ISOLATED;
if (borderTypeNI == BORDER_DEFAULT && (!src.isSubmatrix() || isolated) && dsz == Size(src.cols*2, src.rows*2))
@ -802,11 +810,15 @@ void cv::pyrUp( InputArray _src, OutputArray _dst, const Size& _dsz, int borderT
ippsFree(buffer);
if (ok >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
}
}
#endif
PyrFunc func = 0;
@ -847,6 +859,8 @@ void cv::buildPyramid( InputArray _src, OutputArrayOfArrays _dst, int maxlevel,
int i=1;
#if IPP_VERSION_X100 >= 801 && 0
CV_IPP_CHECK()
{
bool isolated = (borderType & BORDER_ISOLATED) != 0;
int borderTypeNI = borderType & ~BORDER_ISOLATED;
if (borderTypeNI == BORDER_DEFAULT && (!src.isSubmatrix() || isolated))
@ -921,6 +935,10 @@ void cv::buildPyramid( InputArray _src, OutputArrayOfArrays _dst, int maxlevel,
setIppErrorStatus();
break;
}
else
{
CV_IMPL_ADD(CV_IMPL_IPP);
}
}
pyrFreeFunc(gPyr->pState);
}
@ -930,6 +948,7 @@ void cv::buildPyramid( InputArray _src, OutputArrayOfArrays _dst, int maxlevel,
ippiPyramidFree(gPyr);
}
}
}
#endif
for( ; i <= maxlevel; i++ )
pyrDown( _dst.getMatRef(i-1), _dst.getMatRef(i), Size(), borderType );

6
modules/imgproc/src/samplers.cpp
View File

@ -375,6 +375,8 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center,
Mat patch = _patch.getMat();
#if defined (HAVE_IPP) && (IPP_VERSION_MAJOR >= 7)
CV_IPP_CHECK()
{
typedef IppStatus (CV_STDCALL *ippiGetRectSubPixFunc)( const void* src, int src_step,
IppiSize src_size, void* dst,
int dst_step, IppiSize win_size,
@ -394,9 +396,13 @@ void cv::getRectSubPix( InputArray _image, Size patchSize, Point2f center,
{
if (ippfunc(image.ptr(), (int)image.step, src_size, patch.ptr(),
(int)patch.step, win_size, icenter, &minpt, &maxpt) >= 0 )
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if( depth == CV_8U && ddepth == CV_8U )

28
modules/imgproc/src/smooth.cpp
View File

@ -1178,6 +1178,8 @@ void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
#endif
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
int ippBorderType = borderType & ~BORDER_ISOLATED;
Point ocvAnchor, ippAnchor;
ocvAnchor.x = anchor.x < 0 ? ksize.width / 2 : anchor.x;
@ -1206,8 +1208,11 @@ void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
(IppiBorderType)ippBorderType, borderValue, buffer); \
ippsFree(buffer); \
if (status >= 0) \
{ \
CV_IMPL_ADD(CV_IMPL_IPP); \
return; \
} \
} \
setIppErrorStatus(); \
} while ((void)0, 0)
@ -1240,6 +1245,7 @@ void cv::boxFilter( InputArray _src, OutputArray _dst, int ddepth,
IPP_FILTER_BOX_BORDER(Ipp32f, ipp32f, 32f_C4R);
}
#undef IPP_FILTER_BOX_BORDER
}
#endif
Ptr<FilterEngine> f = createBoxFilter( src.type(), dst.type(),
@ -1494,6 +1500,8 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
#endif
#if IPP_VERSION_X100 >= 801 && 0 // these functions are slower in IPP 8.1
CV_IPP_CHECK()
{
int depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
if ((depth == CV_8U || depth == CV_16U || depth == CV_16S || depth == CV_32F) && (cn == 1 || cn == 3) &&
@ -1527,7 +1535,10 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
ippFree(pBuffer); \
ippFree(pSpec); \
if (status >= 0) \
{ \
CV_IMPL_ADD(CV_IMPL_IPP); \
return; \
} \
} while ((void)0, 0)
if (type == CV_8UC1)
@ -1552,6 +1563,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
setIppErrorStatus();
}
}
}
#endif
Mat kx, ky;
@ -2483,6 +2495,8 @@ void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
Mat dst = _dst.getMat();
#if IPP_VERSION_X100 >= 801
CV_IPP_CHECK()
{
#define IPP_FILTER_MEDIAN_BORDER(ippType, ippDataType, flavor) \
do \
{ \
@ -2495,8 +2509,11 @@ void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
ippBorderRepl, (ippType)0, buffer); \
ippsFree(buffer); \
if (status >= 0) \
{ \
CV_IMPL_ADD(CV_IMPL_IPP); \
return; \
} \
} \
setIppErrorStatus(); \
} \
while ((void)0, 0)
@ -2522,6 +2539,7 @@ void cv::medianBlur( InputArray _src0, OutputArray _dst, int ksize )
IPP_FILTER_MEDIAN_BORDER(Ipp32f, ipp32f, 32f_C1R);
}
#undef IPP_FILTER_MEDIAN_BORDER
}
#endif
#ifdef HAVE_TEGRA_OPTIMIZATION
@ -2771,6 +2789,10 @@ public:
}
if (0 > ippiFilterBilateral_8u_C1R( src.ptr<uchar>(range.start) + radius * ((int)src.step[0] + 1), (int)src.step[0], dst.ptr<uchar>(range.start), (int)dst.step[0], roi, kernel, pSpec ))
*ok = false;
else
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
}
}
private:
Mat &src;
@ -2902,15 +2924,21 @@ bilateralFilter_8u( const Mat& src, Mat& dst, int d,
copyMakeBorder( src, temp, radius, radius, radius, radius, borderType );
#if defined HAVE_IPP && (IPP_VERSION_MAJOR >= 7) && 0
CV_IPP_CHECK()
{
if( cn == 1 )
{
bool ok;
IPPBilateralFilter_8u_Invoker body(temp, dst, sigma_color * sigma_color, sigma_space * sigma_space, radius, &ok );
parallel_for_(Range(0, dst.rows), body, dst.total()/(double)(1<<16));
if( ok )
{
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
return;
}
setIppErrorStatus();
}
}
#endif
std::vector<float> _color_weight(cn*256);

6
modules/imgproc/src/sumpixels.cpp
View File

@ -355,6 +355,8 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output
};
#if defined(HAVE_IPP) && !defined(HAVE_IPP_ICV_ONLY) // Disabled on ICV due invalid results
CV_IPP_CHECK()
{
if( ( depth == CV_8U ) && ( sdepth == CV_32F || sdepth == CV_32S ) && ( !_tilted.needed() ) && ( !_sqsum.needed() || sqdepth == CV_64F ) && ( cn == 1 ) )
{
IppStatus status = ippStsErr;
@ -382,9 +384,13 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output
}
}
if (0 <= status)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
if( _tilted.needed() )

13
modules/imgproc/src/templmatch.cpp
View File

@ -853,14 +853,21 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
#endif
#if defined HAVE_IPP
bool useIppMT = (templ.rows < img.rows/2 && templ.cols < img.cols/2);
bool useIppMT = false;
CV_IPP_CHECK()
{
useIppMT = (templ.rows < img.rows/2 && templ.cols < img.cols/2);
if (method == CV_TM_SQDIFF && cn == 1 && useIppMT)
{
if (ipp_sqrDistance(img, templ, result))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
}
}
#endif
#if defined HAVE_IPP
@ -871,6 +878,10 @@ void cv::matchTemplate( InputArray _img, InputArray _templ, OutputArray _result,
setIppErrorStatus();
crossCorr( img, templ, result, result.size(), result.type(), Point(0,0), 0, 0);
}
else
{
CV_IMPL_ADD(CV_IMPL_IPP);
}
}
else
#endif

60
modules/imgproc/src/thresh.cpp
View File

@ -69,6 +69,8 @@ thresh_8u( const Mat& _src, Mat& _dst, uchar thresh, uchar maxval, int type )
#endif
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
IppiSize sz = { roi.width, roi.height };
CV_SUPPRESS_DEPRECATED_START
switch( type )
@ -76,32 +78,51 @@ thresh_8u( const Mat& _src, Mat& _dst, uchar thresh, uchar maxval, int type )
case THRESH_TRUNC:
#ifndef HAVE_IPP_ICV_ONLY
if (_src.data == _dst.data && ippiThreshold_GT_8u_C1IR(_dst.ptr(), (int)dst_step, sz, thresh) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
#endif
if (ippiThreshold_GT_8u_C1R(_src.ptr(), (int)src_step, _dst.ptr(), (int)dst_step, sz, thresh) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
case THRESH_TOZERO:
#ifndef HAVE_IPP_ICV_ONLY
if (_src.data == _dst.data && ippiThreshold_LTVal_8u_C1IR(_dst.ptr(), (int)dst_step, sz, thresh+1, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
#endif
if (ippiThreshold_LTVal_8u_C1R(_src.ptr(), (int)src_step, _dst.ptr(), (int)dst_step, sz, thresh+1, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
case THRESH_TOZERO_INV:
#ifndef HAVE_IPP_ICV_ONLY
if (_src.data == _dst.data && ippiThreshold_GTVal_8u_C1IR(_dst.ptr(), (int)dst_step, sz, thresh, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
#endif
if (ippiThreshold_GTVal_8u_C1R(_src.ptr(), (int)src_step, _dst.ptr(), (int)dst_step, sz, thresh, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
}
CV_SUPPRESS_DEPRECATED_END
}
#endif
switch( type )
@ -392,6 +413,8 @@ thresh_16s( const Mat& _src, Mat& _dst, short thresh, short maxval, int type )
#endif
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
IppiSize sz = { roi.width, roi.height };
CV_SUPPRESS_DEPRECATED_START
switch( type )
@ -399,32 +422,51 @@ thresh_16s( const Mat& _src, Mat& _dst, short thresh, short maxval, int type )
case THRESH_TRUNC:
#ifndef HAVE_IPP_ICV_ONLY
if (_src.data == _dst.data && ippiThreshold_GT_16s_C1IR(dst, (int)dst_step*sizeof(dst[0]), sz, thresh) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
#endif
if (ippiThreshold_GT_16s_C1R(src, (int)src_step*sizeof(src[0]), dst, (int)dst_step*sizeof(dst[0]), sz, thresh) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
case THRESH_TOZERO:
#ifndef HAVE_IPP_ICV_ONLY
if (_src.data == _dst.data && ippiThreshold_LTVal_16s_C1IR(dst, (int)dst_step*sizeof(dst[0]), sz, thresh + 1, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
#endif
if (ippiThreshold_LTVal_16s_C1R(src, (int)src_step*sizeof(src[0]), dst, (int)dst_step*sizeof(dst[0]), sz, thresh+1, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
case THRESH_TOZERO_INV:
#ifndef HAVE_IPP_ICV_ONLY
if (_src.data == _dst.data && ippiThreshold_GTVal_16s_C1IR(dst, (int)dst_step*sizeof(dst[0]), sz, thresh, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
#endif
if (ippiThreshold_GTVal_16s_C1R(src, (int)src_step*sizeof(src[0]), dst, (int)dst_step*sizeof(dst[0]), sz, thresh, 0) >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
}
CV_SUPPRESS_DEPRECATED_END
}
#endif
switch( type )
@ -639,25 +681,37 @@ thresh_32f( const Mat& _src, Mat& _dst, float thresh, float maxval, int type )
#endif
#if defined(HAVE_IPP)
CV_IPP_CHECK()
{
IppiSize sz = { roi.width, roi.height };
switch( type )
{
case THRESH_TRUNC:
if (0 <= ippiThreshold_GT_32f_C1R(src, (int)src_step*sizeof(src[0]), dst, (int)dst_step*sizeof(dst[0]), sz, thresh))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
case THRESH_TOZERO:
if (0 <= ippiThreshold_LTVal_32f_C1R(src, (int)src_step*sizeof(src[0]), dst, (int)dst_step*sizeof(dst[0]), sz, thresh+FLT_EPSILON, 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
case THRESH_TOZERO_INV:
if (0 <= ippiThreshold_GTVal_32f_C1R(src, (int)src_step*sizeof(src[0]), dst, (int)dst_step*sizeof(dst[0]), sz, thresh, 0))
{
CV_IMPL_ADD(CV_IMPL_IPP);
return;
}
setIppErrorStatus();
break;
}
}
#endif
switch( type )
@ -864,14 +918,20 @@ getThreshVal_Otsu_8u( const Mat& _src )
}
#if IPP_VERSION_X100 >= 801 && !defined(HAVE_IPP_ICV_ONLY)
CV_IPP_CHECK()
{
IppiSize srcSize = { size.width, size.height };
Ipp8u thresh;
CV_SUPPRESS_DEPRECATED_START
IppStatus ok = ippiComputeThreshold_Otsu_8u_C1R(_src.ptr(), step, srcSize, &thresh);
CV_SUPPRESS_DEPRECATED_END
if (ok >= 0)
{
CV_IMPL_ADD(CV_IMPL_IPP);
return thresh;
}
setIppErrorStatus();
}
#endif
const int N = 256;

6
modules/objdetect/src/cascadedetect.cpp
View File

@ -1213,6 +1213,7 @@ void CascadeClassifierImpl::detectMultiScaleNoGrouping( InputArray _image, std::
if( maxObjectSize.height == 0 || maxObjectSize.width == 0 )
maxObjectSize = imgsz;
#ifdef HAVE_OPENCL
bool use_ocl = tryOpenCL && ocl::useOpenCL() &&
featureEvaluator->getLocalSize().area() > 0 &&
ocl::Device::getDefault().type() != ocl::Device::TYPE_CPU &&
@ -1220,6 +1221,7 @@ void CascadeClassifierImpl::detectMultiScaleNoGrouping( InputArray _image, std::
!isOldFormatCascade() &&
maskGenerator.empty() &&
!outputRejectLevels;
#endif
/*if( use_ocl )
{
@ -1262,8 +1264,8 @@ void CascadeClassifierImpl::detectMultiScaleNoGrouping( InputArray _image, std::
return;
// OpenCL code
if( use_ocl && ocl_detectMultiScaleNoGrouping( scales, candidates ))
return;
CV_OCL_RUN(use_ocl, ocl_detectMultiScaleNoGrouping( scales, candidates ))
tryOpenCL = false;
// CPU code

9
modules/objdetect/src/haar.cpp
View File

@ -159,7 +159,7 @@ icvReleaseHidHaarClassifierCascade( CvHidHaarClassifierCascade** _cascade )
{
#ifdef HAVE_IPP
CvHidHaarClassifierCascade* cascade = *_cascade;
if( cascade->ipp_stages )
if( CV_IPP_CHECK_COND && cascade->ipp_stages )
{
int i;
for( i = 0; i < cascade->count; i++ )
@ -338,7 +338,7 @@ icvCreateHidHaarClassifierCascade( CvHaarClassifierCascade* cascade )
}
/*
#ifdef HAVE_IPP
int can_use_ipp = !out->has_tilted_features && !out->is_tree && out->isStumpBased;
int can_use_ipp = CV_IPP_CHECK_COND && (!out->has_tilted_features && !out->is_tree && out->isStumpBased);
if( can_use_ipp )
{
@ -1315,7 +1315,7 @@ public:
int x, y, ystep = factor > 2 ? 1 : 2;
#ifdef HAVE_IPP
if( cascade->hid_cascade->ipp_stages )
if(CV_IPP_CHECK_COND && cascade->hid_cascade->ipp_stages )
{
IppiRect iequRect = {equRect.x, equRect.y, equRect.width, equRect.height};
ippiRectStdDev_32f_C1R(sum1.ptr<float>(y1), (int)sum1.step,
@ -1351,6 +1351,7 @@ public:
if( positive <= 0 )
break;
}
CV_IMPL_ADD(CV_IMPL_IPP|CV_IMPL_MT);
if( positive > 0 )
for( y = y1; y < y2; y += ystep )
@ -1561,7 +1562,7 @@ cvHaarDetectObjectsForROC( const CvArr* _img,
{
CvSize winSize0 = cascade->orig_window_size;
#ifdef HAVE_IPP
int use_ipp = cascade->hid_cascade->ipp_stages != 0;
int use_ipp = CV_IPP_CHECK_COND && (cascade->hid_cascade->ipp_stages != 0);
if( use_ipp )
normImg.reset(cvCreateMat( img->rows, img->cols, CV_32FC1));

12
modules/stitching/src/blenders.cpp
View File

@ -414,6 +414,12 @@ void MultiBandBlender::feed(InputArray _img, InputArray mask, Point tl)
}
}
}
#ifdef HAVE_OPENCL
else
{
CV_IMPL_ADD(CV_IMPL_OCL);
}
#endif
x_tl /= 2; y_tl /= 2;
x_br /= 2; y_br /= 2;
@ -519,6 +525,12 @@ void normalizeUsingWeightMap(InputArray _weight, InputOutputArray _src)
}
}
}
#ifdef HAVE_OPENCL
else
{
CV_IMPL_ADD(CV_IMPL_OCL);
}
#endif
}

9
modules/stitching/src/warpers.cpp
View File

@ -114,9 +114,12 @@ Rect PlaneWarper::buildMaps(Size src_size, InputArray K, InputArray R, InputArra
size_t globalsize[2] = { dsize.width, (dsize.height + rowsPerWI - 1) / rowsPerWI };
if (k.run(2, globalsize, NULL, true))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return Rect(dst_tl, dst_br);
}
}
}
Mat xmap = _xmap.getMat(), ymap = _ymap.getMat();
@ -389,9 +392,12 @@ Rect SphericalWarper::buildMaps(Size src_size, InputArray K, InputArray R, Outpu
size_t globalsize[2] = { dsize.width, (dsize.height + rowsPerWI - 1) / rowsPerWI };
if (k.run(2, globalsize, NULL, true))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return Rect(dst_tl, dst_br);
}
}
}
return RotationWarperBase<SphericalProjector>::buildMaps(src_size, K, R, xmap, ymap);
}
@ -435,9 +441,12 @@ Rect CylindricalWarper::buildMaps(Size src_size, InputArray K, InputArray R, Out
size_t globalsize[2] = { dsize.width, (dsize.height + rowsPerWI - 1) / rowsPerWI };
if (k.run(2, globalsize, NULL, true))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return Rect(dst_tl, dst_br);
}
}
}
return RotationWarperBase<CylindricalProjector>::buildMaps(src_size, K, R, xmap, ymap);
}

93
modules/ts/include/opencv2/ts/ts_perf.hpp
View File

@ -265,6 +265,95 @@ enum PERF_STRATEGY
/*****************************************************************************************\
* Base fixture for performance tests *
\*****************************************************************************************/
#ifdef CV_COLLECT_IMPL_DATA
// Implementation collection processing class.
// Accumulates and shapes implementation data.
typedef struct ImplData
{
bool ipp;
bool icv;
bool ipp_mt;
bool ocl;
bool plain;
std::vector<int> implCode;
std::vector<cv::String> funName;
ImplData()
{
Reset();
}
void Reset()
{
cv::setImpl(0);
ipp = icv = ocl = ipp_mt = false;
implCode.clear();
funName.clear();
}
void GetImpl()
{
flagsToVars(cv::getImpl(implCode, funName));
}
std::vector<cv::String> GetCallsForImpl(int impl)
{
std::vector<cv::String> out;
for(int i = 0; i < implCode.size(); i++)
{
if(impl == implCode[i])
out.push_back(funName[i]);
}
return out;
}
// Remove duplicate entries
void ShapeUp()
{
std::vector<int> savedCode;
std::vector<cv::String> savedName;
for(int i = 0; i < implCode.size(); i++)
{
bool match = false;
for(int j = 0; j < savedCode.size(); j++)
{
if(implCode[i] == savedCode[j] && !funName[i].compare(savedName[j]))
{
match = true;
break;
}
}
if(!match)
{
savedCode.push_back(implCode[i]);
savedName.push_back(funName[i]);
}
}
implCode = savedCode;
funName = savedName;
}
// convert flags register to more handy variables
void flagsToVars(int flags)
{
#if defined(HAVE_IPP_ICV_ONLY)
ipp = 0;
icv = ((flags&CV_IMPL_IPP) > 0);
#else
ipp = ((flags&CV_IMPL_IPP) > 0);
icv = 0;
#endif
ipp_mt = ((flags&CV_IMPL_MT) > 0);
ocl = ((flags&CV_IMPL_OCL) > 0);
plain = (flags == 0);
}
} ImplData;
#endif
class CV_EXPORTS TestBase: public ::testing::Test
{
public:
@ -308,6 +397,10 @@ protected:
performance_metrics& calcMetrics();
void RunPerfTestBody();
#ifdef CV_COLLECT_IMPL_DATA
ImplData implConf;
#endif
private:
typedef std::vector<std::pair<int, cv::Size> > SizeVector;
typedef std::vector<int64> TimeVector;

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

@ -31,6 +31,9 @@ static double param_time_limit;
static int param_threads;
static bool param_write_sanity;
static bool param_verify_sanity;
#ifdef CV_COLLECT_IMPL_DATA
static bool param_collect_impl;
#endif
extern bool test_ipp_check;
#ifdef HAVE_CUDA
static int param_cuda_device;
@ -673,6 +676,9 @@ void TestBase::Init(const std::vector<std::string> & availableImpls,
"{ perf_max_deviation |1.0 |}"
#ifdef HAVE_IPP
"{ perf_ipp_check |false |check whether IPP works without failures}"
#endif
#ifdef CV_COLLECT_IMPL_DATA
"{ perf_collect_impl |false |collect info about executed implementations}"
#endif
"{ help h |false |print help info}"
#ifdef HAVE_CUDA
@ -719,6 +725,9 @@ void TestBase::Init(const std::vector<std::string> & availableImpls,
param_verify_sanity = args.has("perf_verify_sanity");
test_ipp_check = !args.has("perf_ipp_check") ? getenv("OPENCV_IPP_CHECK") != NULL : true;
param_threads = args.get<int>("perf_threads");
#ifdef CV_COLLECT_IMPL_DATA
param_collect_impl = args.has("perf_collect_impl");
#endif
#ifdef ANDROID
param_affinity_mask = args.get<int>("perf_affinity_mask");
log_power_checkpoints = args.has("perf_log_power_checkpoints");
@ -743,6 +752,13 @@ void TestBase::Init(const std::vector<std::string> & availableImpls,
exit(1);
}
#ifdef CV_COLLECT_IMPL_DATA
if(param_collect_impl)
cv::setUseCollection(1);
else
cv::setUseCollection(0);
#endif
#ifdef HAVE_CUDA
bool printOnly = args.has("perf_cuda_info_only");
@ -1242,6 +1258,28 @@ void TestBase::reportMetrics(bool toJUnitXML)
RecordProperty("gstddev", cv::format("%.6f", m.gstddev).c_str());
RecordProperty("mean", cv::format("%.0f", m.mean).c_str());
RecordProperty("stddev", cv::format("%.0f", m.stddev).c_str());
#ifdef CV_COLLECT_IMPL_DATA
if(param_collect_impl)
{
RecordProperty("impl_ipp", (int)(implConf.ipp || implConf.icv));
RecordProperty("impl_ocl", (int)implConf.ocl);
RecordProperty("impl_plain", (int)implConf.plain);
std::string rec_line;
std::vector<cv::String> rec;
rec_line.clear();
rec = implConf.GetCallsForImpl(CV_IMPL_IPP|CV_IMPL_MT);
for(int i=0; i<rec.size();i++ ){rec_line += rec[i].c_str(); rec_line += " ";}
rec = implConf.GetCallsForImpl(CV_IMPL_IPP);
for(int i=0; i<rec.size();i++ ){rec_line += rec[i].c_str(); rec_line += " ";}
RecordProperty("impl_rec_ipp", rec_line.c_str());
rec_line.clear();
rec = implConf.GetCallsForImpl(CV_IMPL_OCL);
for(int i=0; i<rec.size();i++ ){rec_line += rec[i].c_str(); rec_line += " ";}
RecordProperty("impl_rec_ocl", rec_line.c_str());
}
#endif
}
else
{
@ -1276,6 +1314,29 @@ void TestBase::reportMetrics(bool toJUnitXML)
break;
};
#ifdef CV_COLLECT_IMPL_DATA
if(param_collect_impl)
{
LOGD("impl_ipp =%11d", (int)(implConf.ipp || implConf.icv));
LOGD("impl_ocl =%11d", (int)implConf.ocl);
LOGD("impl_plain =%11d", (int)implConf.plain);
std::string rec_line;
std::vector<cv::String> rec;
rec_line.clear();
rec = implConf.GetCallsForImpl(CV_IMPL_IPP|CV_IMPL_MT);
for(int i=0; i<rec.size();i++ ){rec_line += rec[i].c_str(); rec_line += " ";}
rec = implConf.GetCallsForImpl(CV_IMPL_IPP);
for(int i=0; i<rec.size();i++ ){rec_line += rec[i].c_str(); rec_line += " ";}
LOGD("impl_rec_ipp =%s", rec_line.c_str());
rec_line.clear();
rec = implConf.GetCallsForImpl(CV_IMPL_OCL);
for(int i=0; i<rec.size();i++ ){rec_line += rec[i].c_str(); rec_line += " ";}
LOGD("impl_rec_ocl =%s", rec_line.c_str());
}
#endif
LOGD("bytesIn =%11lu", (unsigned long)m.bytesIn);
LOGD("bytesOut =%11lu", (unsigned long)m.bytesOut);
if (nIters == (unsigned int)-1 || m.terminationReason == performance_metrics::TERM_ITERATIONS)
@ -1343,6 +1404,30 @@ void TestBase::TearDown()
const char* value_param = test_info->value_param();
if (value_param) printf("[ VALUE ] \t%s\n", value_param), fflush(stdout);
if (type_param) printf("[ TYPE ] \t%s\n", type_param), fflush(stdout);
#ifdef CV_COLLECT_IMPL_DATA
if(param_collect_impl)
{
implConf.ShapeUp();
printf("[ I. FLAGS ] \t");
if(implConf.ipp_mt)
{
if(implConf.icv) {printf("ICV_MT "); std::vector<cv::String> fun = implConf.GetCallsForImpl(CV_IMPL_IPP|CV_IMPL_MT); printf("("); for(int i=0; i<fun.size();i++ ){printf("%s ", fun[i].c_str());} printf(") "); }
if(implConf.ipp) {printf("IPP_MT "); std::vector<cv::String> fun = implConf.GetCallsForImpl(CV_IMPL_IPP|CV_IMPL_MT); printf("("); for(int i=0; i<fun.size();i++ ){printf("%s ", fun[i].c_str());} printf(") "); }
}
else
{
if(implConf.icv) {printf("ICV "); std::vector<cv::String> fun = implConf.GetCallsForImpl(CV_IMPL_IPP); printf("("); for(int i=0; i<fun.size();i++ ){printf("%s ", fun[i].c_str());} printf(") "); }
if(implConf.ipp) {printf("IPP "); std::vector<cv::String> fun = implConf.GetCallsForImpl(CV_IMPL_IPP); printf("("); for(int i=0; i<fun.size();i++ ){printf("%s ", fun[i].c_str());} printf(") "); }
}
if(implConf.ocl) {printf("OCL "); std::vector<cv::String> fun = implConf.GetCallsForImpl(CV_IMPL_OCL); printf("("); for(int i=0; i<fun.size();i++ ){printf("%s ", fun[i].c_str());} printf(") "); }
if(implConf.plain) printf("PLAIN ");
if(!(implConf.ipp_mt || implConf.icv || implConf.ipp || implConf.ocl || implConf.plain))
printf("ERROR ");
printf("\n");
fflush(stdout);
}
#endif
reportMetrics(true);
}
@ -1391,7 +1476,15 @@ void TestBase::RunPerfTestBody()
{
try
{
#ifdef CV_COLLECT_IMPL_DATA
if(param_collect_impl)
implConf.Reset();
#endif
this->PerfTestBody();
#ifdef CV_COLLECT_IMPL_DATA
if(param_collect_impl)
implConf.GetImpl();
#endif
}
catch(PerfSkipTestException&)
{

3
modules/video/src/lkpyramid.cpp
View File

@ -1096,7 +1096,10 @@ void cv::calcOpticalFlowPyrLK( InputArray _prevImg, InputArray _nextImg,
(_prevImg.isUMat() || _nextImg.isUMat()) &&
ocl::Image2D::isFormatSupported(CV_32F, 1, false);
if ( use_opencl && ocl_calcOpticalFlowPyrLK(_prevImg, _nextImg, _prevPts, _nextPts, _status, _err, winSize, maxLevel, criteria, flags/*, minEigThreshold*/))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
Mat prevPtsMat = _prevPts.getMat();
const int derivDepth = DataType<cv::detail::deriv_type>::depth;

3
modules/video/src/optflowgf.cpp
View File

@ -1081,7 +1081,10 @@ void cv::calcOpticalFlowFarneback( InputArray _prev0, InputArray _next0,
{
bool use_opencl = ocl::useOpenCL() && _flow0.isUMat();
if( use_opencl && ocl_calcOpticalFlowFarneback(_prev0, _next0, _flow0, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags))
{
CV_IMPL_ADD(CV_IMPL_OCL);
return;
}
Mat prev0 = _prev0.getMat(), next0 = _next0.getMat();
const int min_size = 32;