mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-12-01 06:49:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #2475 from ilya-lavrenov:ocl_2.4_fix

Browse Source
This commit is contained in:
Andrey Pavlenko 2014-03-14 19:05:55 +04:00 committed by OpenCV Buildbot
commit 5726e80f77
13 changed files with 211 additions and 806 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/nonfree/perf/perf_main.cpp
View File

@ -5,7 +5,7 @@ static const char * impls[] = {
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
"cuda", "cuda",
#endif #endif
#ifdef HAVE_OPENCL #ifdef HAVE_OPENCV_OCL
"ocl", "ocl",
#endif #endif
"plain" "plain"

4
modules/nonfree/perf/perf_surf_ocl.cpp
View File

@ -59,7 +59,7 @@ typedef perf::TestBaseWithParam<std::string> OCL_SURF;
#define OCL_TEST_CYCLE() for( ; startTimer(), next(); cv::ocl::finish(), stopTimer()) #define OCL_TEST_CYCLE() for( ; startTimer(), next(); cv::ocl::finish(), stopTimer())
PERF_TEST_P(OCL_SURF, with_data_transfer, testing::Values(SURF_IMAGES)) PERF_TEST_P(OCL_SURF, DISABLED_with_data_transfer, testing::Values(SURF_IMAGES))
{ {
string filename = getDataPath(GetParam()); string filename = getDataPath(GetParam());
Mat src = imread(filename, IMREAD_GRAYSCALE); Mat src = imread(filename, IMREAD_GRAYSCALE);
@ -94,7 +94,7 @@ PERF_TEST_P(OCL_SURF, with_data_transfer, testing::Values(SURF_IMAGES))
SANITY_CHECK_NOTHING(); SANITY_CHECK_NOTHING();
} }
PERF_TEST_P(OCL_SURF, without_data_transfer, testing::Values(SURF_IMAGES)) PERF_TEST_P(OCL_SURF, DISABLED_without_data_transfer, testing::Values(SURF_IMAGES))
{ {
string filename = getDataPath(GetParam()); string filename = getDataPath(GetParam());
Mat src = imread(filename, IMREAD_GRAYSCALE); Mat src = imread(filename, IMREAD_GRAYSCALE);

285
modules/ocl/src/arithm.cpp
View File

@ -313,32 +313,28 @@ void cv::ocl::compare(const oclMat &src1, const oclMat &src2, oclMat &dst , int
enum { SUM = 0, ABS_SUM, SQR_SUM }; enum { SUM = 0, ABS_SUM, SQR_SUM };
static void arithmetic_sum_buffer_run(const oclMat &src, cl_mem &dst, int groupnum, int type, int ddepth) static void arithmetic_sum_buffer_run(const oclMat &src, cl_mem &dst, int groupnum, int type, int ddepth, int vlen)
{ {
int ochannels = src.oclchannels(); int vElemSize = vlen * src.elemSize();
int all_cols = src.step / src.elemSize(); int src_offset = src.offset / vElemSize, src_step = src.step / vElemSize;
int pre_cols = (src.offset % src.step) / src.elemSize(); int src_cols = src.cols / vlen, total = src.size().area() / vlen;
int sec_cols = all_cols - (src.offset % src.step + src.cols * src.elemSize() - 1) / src.elemSize() - 1;
int invalid_cols = pre_cols + sec_cols; vlen *= src.oclchannels();
int cols = all_cols - invalid_cols , elemnum = cols * src.rows;;
int offset = src.offset / src.elemSize();
const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" }; const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
const char * const funcMap[] = { "FUNC_SUM", "FUNC_ABS_SUM", "FUNC_SQR_SUM" }; const char * const funcMap[] = { "FUNC_SUM", "FUNC_ABS_SUM", "FUNC_SQR_SUM" };
const char * const channelMap[] = { " ", " ", "2", "4", "4" }; const char * const channelMap[] = { " ", " ", "2", "4", "4", "", "", "", "8" };
string buildOptions = format("-D srcT=%s%s -D dstT=%s%s -D convertToDstT=convert_%s%s -D %s", string buildOptions = format("-D srcT=%s%s -D dstT=%s%s -D convertToDstT=convert_%s%s -D %s",
typeMap[src.depth()], channelMap[ochannels], typeMap[src.depth()], channelMap[vlen], typeMap[ddepth],
typeMap[ddepth], channelMap[ochannels], channelMap[vlen], typeMap[ddepth], channelMap[vlen], funcMap[type]);
typeMap[ddepth], channelMap[ochannels],
funcMap[type]);
vector<pair<size_t , const void *> > args; vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data)); args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
args.push_back( make_pair( sizeof(cl_int) , (void *)&src_step ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&src_offset ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&src_cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&total ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum ));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst )); args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
size_t globalThreads[3] = { groupnum * 256, 1, 1 }; size_t globalThreads[3] = { groupnum * 256, 1, 1 };
@ -360,7 +356,11 @@ Scalar arithmetic_sum(const oclMat &src, int type, int ddepth)
size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits; size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits;
CV_Assert(groupnum != 0); CV_Assert(groupnum != 0);
int dbsize = groupnum * src.oclchannels(); int vlen = 8 / src.channels(), vElemSize = vlen * src.elemSize1();
while (src.offset % vElemSize != 0 || src.step % vElemSize != 0 || src.cols % vlen != 0)
vlen >>= 1, vElemSize >>= 1;
int dbsize = groupnum * src.oclchannels() * vlen;
Context *clCxt = src.clCxt; Context *clCxt = src.clCxt;
AutoBuffer<T> _buf(dbsize); AutoBuffer<T> _buf(dbsize);
@ -368,7 +368,7 @@ Scalar arithmetic_sum(const oclMat &src, int type, int ddepth)
memset(p, 0, dbsize * sizeof(T)); memset(p, 0, dbsize * sizeof(T));
cl_mem dstBuffer = openCLCreateBuffer(clCxt, CL_MEM_WRITE_ONLY, dbsize * sizeof(T)); cl_mem dstBuffer = openCLCreateBuffer(clCxt, CL_MEM_WRITE_ONLY, dbsize * sizeof(T));
arithmetic_sum_buffer_run(src, dstBuffer, groupnum, type, ddepth); arithmetic_sum_buffer_run(src, dstBuffer, groupnum, type, ddepth, vlen);
openCLReadBuffer(clCxt, dstBuffer, (void *)p, dbsize * sizeof(T)); openCLReadBuffer(clCxt, dstBuffer, (void *)p, dbsize * sizeof(T));
openCLFree(dstBuffer); openCLFree(dstBuffer);
@ -473,20 +473,13 @@ void cv::ocl::meanStdDev(const oclMat &src, Scalar &mean, Scalar &stddev)
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
template <typename T, typename WT> template <typename T, typename WT>
static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem &dst, int groupnum, string kernelName) static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem &dst, int vlen, int groupnum)
{ {
int all_cols = src.step / src.elemSize();
int pre_cols = (src.offset % src.step) / src.elemSize();
int sec_cols = all_cols - (src.offset % src.step + src.cols * src.elemSize() - 1) / src.elemSize() - 1;
int invalid_cols = pre_cols + sec_cols;
int cols = all_cols - invalid_cols , elemnum = cols * src.rows;
int offset = src.offset / src.elemSize();
const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" }; const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
const char * const channelMap[] = { " ", " ", "2", "4", "4" }; const char * const channelMap[] = { " ", " ", "2", "4", "4", "", "", "", "8" };
ostringstream stream; ostringstream stream;
stream << "-D T=" << typeMap[src.depth()] << channelMap[src.channels()]; stream << "-D T=" << typeMap[src.depth()] << channelMap[vlen];
if (numeric_limits<T>::is_integer) if (numeric_limits<T>::is_integer)
{ {
stream << " -D MAX_VAL=" << (WT)numeric_limits<T>::max(); stream << " -D MAX_VAL=" << (WT)numeric_limits<T>::max();
@ -494,38 +487,38 @@ static void arithmetic_minMax_run(const oclMat &src, const oclMat & mask, cl_mem
} }
else else
stream << " -D DEPTH_" << src.depth(); stream << " -D DEPTH_" << src.depth();
stream << " -D vlen=" << vlen;
std::string buildOptions = stream.str(); std::string buildOptions = stream.str();
int vElemSize = src.elemSize1() * vlen, src_cols = src.cols / vlen;
int src_step = src.step / vElemSize, src_offset = src.offset / vElemSize;
int mask_step = mask.step / vlen, mask_offset = mask.offset / vlen;
int total = src.size().area() / vlen;
vector<pair<size_t , const void *> > args; vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data)); args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst )); args.push_back( make_pair( sizeof(cl_int) , (void *)&src_step ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&cols )); args.push_back( make_pair( sizeof(cl_int) , (void *)&src_offset ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols )); args.push_back( make_pair( sizeof(cl_int) , (void *)&src.rows ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&offset)); args.push_back( make_pair( sizeof(cl_int) , (void *)&src_cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum)); args.push_back( make_pair( sizeof(cl_int) , (void *)&total));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum)); args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst));
int minvalid_cols = 0, moffset = 0;
if (!mask.empty()) if (!mask.empty())
{ {
int mall_cols = mask.step / mask.elemSize();
int mpre_cols = (mask.offset % mask.step) / mask.elemSize();
int msec_cols = mall_cols - (mask.offset % mask.step + mask.cols * mask.elemSize() - 1) / mask.elemSize() - 1;
minvalid_cols = mpre_cols + msec_cols;
moffset = mask.offset / mask.elemSize();
args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data )); args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&minvalid_cols )); args.push_back( make_pair( sizeof(cl_int) , (void *)&mask_step ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&moffset )); args.push_back( make_pair( sizeof(cl_int) , (void *)&mask_offset ));
kernelName += "_mask"; buildOptions += " -D WITH_MASK";
} }
size_t globalThreads[3] = { groupnum * 256, 1, 1 }; size_t globalThreads[3] = { groupnum * 256, 1, 1 };
size_t localThreads[3] = { 256, 1, 1 }; size_t localThreads[3] = { 256, 1, 1 };
// kernel use fixed grid size, replace lt on NULL is imposible without kernel changes // kernel use fixed grid size, replace lt on NULL is impossible without kernel changes
openCLExecuteKernel(src.clCxt, &arithm_minMax, kernelName, globalThreads, localThreads, openCLExecuteKernel(src.clCxt, &arithm_minMax, "arithm_op_minMax", globalThreads, localThreads,
args, -1, -1, buildOptions.c_str()); args, -1, -1, buildOptions.c_str());
} }
@ -535,25 +528,33 @@ void arithmetic_minMax(const oclMat &src, double *minVal, double *maxVal, const
size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits; size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits;
CV_Assert(groupnum != 0); CV_Assert(groupnum != 0);
int dbsize = groupnum * 2 * src.elemSize(); int vlen = mask.empty() ? 8 : 1, vElemSize = vlen * src.elemSize1();
while (src.offset % vElemSize != 0 || src.step % vElemSize != 0 || src.cols % vlen != 0)
{
vlen >>= 1;
vElemSize >>= 1;
}
int dbsize = groupnum * 2 * vElemSize;
oclMat buf; oclMat buf;
ensureSizeIsEnough(1, dbsize, CV_8UC1, buf); ensureSizeIsEnough(1, dbsize, CV_8UC1, buf);
cl_mem buf_data = reinterpret_cast<cl_mem>(buf.data); cl_mem buf_data = reinterpret_cast<cl_mem>(buf.data);
arithmetic_minMax_run<T, WT>(src, mask, buf_data, groupnum, "arithm_op_minMax"); arithmetic_minMax_run<T, WT>(src, mask, buf_data, vlen, groupnum);
Mat matbuf = Mat(buf); Mat matbuf = Mat(buf);
T *p = matbuf.ptr<T>(); T *p = matbuf.ptr<T>();
if (minVal != NULL) if (minVal != NULL)
{ {
*minVal = std::numeric_limits<double>::max(); *minVal = std::numeric_limits<double>::max();
for (int i = 0, end = src.oclchannels() * (int)groupnum; i < end; i++) for (int i = 0, end = vlen * (int)groupnum; i < end; i++)
*minVal = *minVal < p[i] ? *minVal : p[i]; *minVal = *minVal < p[i] ? *minVal : p[i];
} }
if (maxVal != NULL) if (maxVal != NULL)
{ {
*maxVal = -std::numeric_limits<double>::max(); *maxVal = -std::numeric_limits<double>::max();
for (int i = src.oclchannels() * (int)groupnum, end = i << 1; i < end; i++) for (int i = vlen * (int)groupnum, end = i << 1; i < end; i++)
*maxVal = *maxVal > p[i] ? *maxVal : p[i]; *maxVal = *maxVal > p[i] ? *maxVal : p[i];
} }
} }
@ -564,7 +565,7 @@ void cv::ocl::minMax(const oclMat &src, double *minVal, double *maxVal, const oc
{ {
CV_Assert(src.channels() == 1); CV_Assert(src.channels() == 1);
CV_Assert(src.size() == mask.size() || mask.empty()); CV_Assert(src.size() == mask.size() || mask.empty());
CV_Assert(src.step % src.elemSize() == 0); CV_Assert(src.step % src.elemSize1() == 0);
if (minVal == NULL && maxVal == NULL) if (minVal == NULL && maxVal == NULL)
return; return;
@ -1139,7 +1140,7 @@ static void arithmetic_minMaxLoc_run(const oclMat &src, cl_mem &dst, int vlen ,
sprintf(build_options, "-D DEPTH_%d -D REPEAT_S%d -D REPEAT_E%d", src.depth(), repeat_s, repeat_e); sprintf(build_options, "-D DEPTH_%d -D REPEAT_S%d -D REPEAT_E%d", src.depth(), repeat_s, repeat_e);
size_t gt[3] = {groupnum * 256, 1, 1}, lt[3] = {256, 1, 1}; size_t gt[3] = {groupnum * 256, 1, 1}, lt[3] = {256, 1, 1};
// kernel use fixed grid size, replace lt on NULL is imposible without kernel changes // kernel use fixed grid size, replace lt on NULL is impossible without kernel changes
openCLExecuteKernel(src.clCxt, &arithm_minMaxLoc, "arithm_op_minMaxLoc", gt, lt, args, -1, -1, build_options); openCLExecuteKernel(src.clCxt, &arithm_minMaxLoc, "arithm_op_minMaxLoc", gt, lt, args, -1, -1, build_options);
} }
@ -1169,7 +1170,7 @@ static void arithmetic_minMaxLoc_mask_run(const oclMat &src, const oclMat &mask,
args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data )); args.push_back( make_pair( sizeof(cl_mem) , (void *)&mask.data ));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst )); args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
// kernel use fixed grid size, replace lt on NULL is imposible without kernel changes // kernel use fixed grid size, replace lt on NULL is impossible without kernel changes
openCLExecuteKernel(src.clCxt, &arithm_minMaxLoc_mask, "arithm_op_minMaxLoc_mask", gt, lt, args, -1, -1, build_options); openCLExecuteKernel(src.clCxt, &arithm_minMaxLoc_mask, "arithm_op_minMaxLoc_mask", gt, lt, args, -1, -1, build_options);
} }
} }
@ -1262,38 +1263,35 @@ void cv::ocl::minMaxLoc(const oclMat &src, double *minVal, double *maxVal,
///////////////////////////// countNonZero /////////////////////////////////// ///////////////////////////// countNonZero ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
static void arithmetic_countNonZero_run(const oclMat &src, cl_mem &dst, int groupnum, string kernelName) static void arithmetic_countNonZero_run(const oclMat &src, cl_mem &dst, int groupnum, int vlen)
{ {
int ochannels = src.oclchannels(); int vElemSize = vlen * src.elemSize1();
int all_cols = src.step / src.elemSize(); int src_step = src.step / vElemSize, src_offset = src.offset / vElemSize;
int pre_cols = (src.offset % src.step) / src.elemSize(); int src_cols = src.cols / vlen, total = src.size().area() / vlen;
int sec_cols = all_cols - (src.offset % src.step + src.cols * src.elemSize() - 1) / src.elemSize() - 1;
int invalid_cols = pre_cols + sec_cols;
int cols = all_cols - invalid_cols , elemnum = cols * src.rows;;
int offset = src.offset / src.elemSize();
const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" }; const char * const typeMap[] = { "uchar", "char", "ushort", "short", "int", "float", "double" };
const char * const channelMap[] = { " ", " ", "2", "4", "4" }; const char * const channelMap[] = { "", "", "2", "4", "4", "", "", "", "8" };
string buildOptions = format("-D srcT=%s%s -D dstT=int%s", typeMap[src.depth()], channelMap[ochannels], string buildOptions = format("-D srcT=%s%s -D dstT=int%s -D convertToDstT=convert_int%s",
channelMap[ochannels]); typeMap[src.depth()], channelMap[vlen],
channelMap[vlen], channelMap[vlen]);
vector<pair<size_t , const void *> > args; vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_int) , (void *)&cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&offset));
args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data)); args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
args.push_back( make_pair( sizeof(cl_int) , (void *)&src_step ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&src_offset ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&src_cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&total ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum ));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst )); args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst ));
size_t globalThreads[3] = { groupnum * 256, 1, 1 }; size_t globalThreads[3] = { groupnum * 256, 1, 1 };
#ifdef ANDROID #ifdef ANDROID
openCLExecuteKernel(src.clCxt, &arithm_nonzero, kernelName, globalThreads, NULL, openCLExecuteKernel(src.clCxt, &arithm_nonzero, "arithm_op_nonzero", globalThreads, NULL,
args, -1, -1, buildOptions.c_str()); args, -1, -1, buildOptions.c_str());
#else #else
size_t localThreads[3] = { 256, 1, 1 }; size_t localThreads[3] = { 256, 1, 1 };
openCLExecuteKernel(src.clCxt, &arithm_nonzero, kernelName, globalThreads, localThreads, openCLExecuteKernel(src.clCxt, &arithm_nonzero, "arithm_op_nonzero", globalThreads, localThreads,
args, -1, -1, buildOptions.c_str()); args, -1, -1, buildOptions.c_str());
#endif #endif
} }
@ -1310,18 +1308,20 @@ int cv::ocl::countNonZero(const oclMat &src)
return -1; return -1;
} }
int vlen = 8, vElemSize = src.elemSize1() * vlen;
while (src.offset % vElemSize != 0 || src.step % vElemSize != 0 || src.cols % vlen != 0)
vlen >>= 1, vElemSize >>= 1;
size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits; size_t groupnum = src.clCxt->getDeviceInfo().maxComputeUnits;
CV_Assert(groupnum != 0); CV_Assert(groupnum != 0);
int dbsize = groupnum; int dbsize = groupnum * vlen;
string kernelName = "arithm_op_nonzero";
AutoBuffer<int> _buf(dbsize); AutoBuffer<int> _buf(dbsize);
int *p = (int*)_buf, nonzero = 0; int *p = (int*)_buf, nonzero = 0;
memset(p, 0, dbsize * sizeof(int)); memset(p, 0, dbsize * sizeof(int));
cl_mem dstBuffer = openCLCreateBuffer(clCxt, CL_MEM_WRITE_ONLY, dbsize * sizeof(int)); cl_mem dstBuffer = openCLCreateBuffer(clCxt, CL_MEM_WRITE_ONLY, dbsize * sizeof(int));
arithmetic_countNonZero_run(src, dstBuffer, groupnum, kernelName); arithmetic_countNonZero_run(src, dstBuffer, groupnum, vlen);
openCLReadBuffer(clCxt, dstBuffer, (void *)p, dbsize * sizeof(int)); openCLReadBuffer(clCxt, dstBuffer, (void *)p, dbsize * sizeof(int));
for (int i = 0; i < dbsize; i++) for (int i = 0; i < dbsize; i++)
@ -1336,157 +1336,118 @@ int cv::ocl::countNonZero(const oclMat &src)
////////////////////////////////bitwise_op//////////////////////////////////// ////////////////////////////////bitwise_op////////////////////////////////////
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
static void bitwise_unary_run(const oclMat &src1, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source) enum { AND = 0, OR, XOR, NOT };
{
dst.create(src1.size(), src1.type());
int channels = dst.oclchannels(); static void bitwise_run(const oclMat & src1, const oclMat & src2, const Scalar & src3, const oclMat & mask,
int depth = dst.depth();
int vector_lengths[4][7] = {{4, 4, 4, 4, 1, 1, 1},
{4, 4, 4, 4, 1, 1, 1},
{4, 4, 4, 4, 1, 1, 1},
{4, 4, 4, 4, 1, 1, 1}
};
size_t vector_length = vector_lengths[channels - 1][depth];
int offset_cols = (dst.offset / dst.elemSize1()) & (vector_length - 1);
int cols = divUp(dst.cols * channels + offset_cols, vector_length);
#ifdef ANDROID
size_t localThreads[3] = { 64, 2, 1 };
#else
size_t localThreads[3] = { 64, 4, 1 };
#endif
size_t globalThreads[3] = { cols, dst.rows, 1 };
int dst_step1 = dst.cols * dst.elemSize();
vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
}
enum { AND = 0, OR, XOR };
static void bitwise_binary_run(const oclMat &src1, const oclMat &src2, const Scalar& src3, const oclMat &mask,
oclMat & dst, int operationType) oclMat & dst, int operationType)
{ {
CV_Assert(operationType >= AND && operationType <= XOR); CV_Assert(operationType >= AND && operationType <= NOT);
CV_Assert(src2.empty() || (!src2.empty() && src1.type() == src2.type() && src1.size() == src2.size())); CV_Assert(src2.empty() || (src1.type() == src2.type() && src1.size() == src2.size()));
CV_Assert(mask.empty() || (!mask.empty() && mask.type() == CV_8UC1 && mask.size() == src1.size())); CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src1.size()));
dst.create(src1.size(), src1.type()); dst.create(src1.size(), src1.type());
oclMat m; double scalar[4];
const char operationMap[] = { '&', '|', '^' }; bool haveScalar = src2.empty() && operationType != NOT, haveMask = !mask.empty();
std::string kernelName("arithm_bitwise_binary"); int ocn = dst.oclchannels(), depth = dst.depth();
const char operationMap[] = { '&', '|', '^', '~' };
const char * const typeMap[] = { "uchar", "uchar", "ushort", "ushort", "int", "int", "ulong" };
const char * const channelMap[] = { "", "", "2", "4", "4", "", "", "", "8", "", "", "", "", "", "", "", "16" };
const int preferredVectorWidth[] = { 4, 4, 2, 2, 1, 1, 1 };
int kercn = haveMask || haveScalar ? ocn : preferredVectorWidth[depth];
int vlen = std::min<int>(8, src1.elemSize1() * src1.oclchannels()); if (!haveScalar && !haveMask)
std::string vlenstr = vlen > 1 ? format("%d", vlen) : ""; {
std::string buildOptions = format("-D Operation=%c -D vloadn=vload%s -D vstoren=vstore%s -D elemSize=%d -D vlen=%d" int velemsize = dst.elemSize1() * kercn;
" -D ucharv=uchar%s", while (src1.offset % velemsize != 0 || src1.step % velemsize != 0 || src1.cols * ocn % kercn != 0 ||
operationMap[operationType], vlenstr.c_str(), vlenstr.c_str(), src2.offset % velemsize != 0 || src2.step % velemsize != 0 || src2.cols * ocn % kercn != 0 ||
(int)src1.elemSize(), vlen, vlenstr.c_str()); dst.offset % velemsize != 0 || dst.step % velemsize != 0 || dst.cols * ocn % kercn != 0)
kercn >>= 1, velemsize >>= 1;
}
#ifdef ANDROID int cols = dst.cols * ocn / kercn;
size_t localThreads[3] = { 16, 10, 1 };
#else std::string buildOptions = format("-D Operation=%c -D T=%s%s", operationMap[operationType],
size_t localThreads[3] = { 16, 16, 1 }; typeMap[depth], channelMap[kercn]);
#endif
size_t globalThreads[3] = { dst.cols, dst.rows, 1 };
vector<pair<size_t , const void *> > args; vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data )); args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step )); args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset )); args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
if (src2.empty()) if (haveScalar)
{ {
m.create(1, 1, dst.type()); int sctype = CV_MAKE_TYPE(dst.depth(), ocn);
m.setTo(src3); cv::scalarToRawData(src3, scalar, sctype);
args.push_back( make_pair( sizeof(cl_mem), (void *)&m.data )); args.push_back( make_pair( CV_ELEM_SIZE(sctype), (void *)scalar ));
kernelName += "_scalar"; buildOptions += " -D HAVE_SCALAR";
} }
else else if (operationType != NOT)
{ {
args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data )); args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src2.step )); args.push_back( make_pair( sizeof(cl_int), (void *)&src2.step ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src2.offset )); args.push_back( make_pair( sizeof(cl_int), (void *)&src2.offset ));
buildOptions += " -D OP_BINARY";
} }
if (!mask.empty()) if (haveMask)
{ {
args.push_back( make_pair( sizeof(cl_mem), (void *)&mask.data )); args.push_back( make_pair( sizeof(cl_mem), (void *)&mask.data ));
args.push_back( make_pair( sizeof(cl_int), (void *)&mask.step )); args.push_back( make_pair( sizeof(cl_int), (void *)&mask.step ));
args.push_back( make_pair( sizeof(cl_int), (void *)&mask.offset )); args.push_back( make_pair( sizeof(cl_int), (void *)&mask.offset ));
kernelName += "_mask"; buildOptions += " -D HAVE_MASK";
} }
args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data )); args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step )); args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step ));
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset )); args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols )); args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows )); args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
openCLExecuteKernel(src1.clCxt, mask.empty() ? (!src2.empty() ? &arithm_bitwise_binary : &arithm_bitwise_binary_scalar) : size_t globalsize[3] = { dst.cols * ocn / kercn, dst.rows, 1 };
(!src2.empty() ? &arithm_bitwise_binary_mask : &arithm_bitwise_binary_scalar_mask), globalsize[0] = divUp(globalsize[0], 256) * 256;
kernelName, globalThreads, localThreads, openCLExecuteKernel(src1.clCxt, &arithm_bitwise, "arithm_bitwise", globalsize, NULL,
args, -1, -1, buildOptions.c_str()); args, -1, -1, buildOptions.c_str());
} }
void cv::ocl::bitwise_not(const oclMat &src, oclMat &dst) void cv::ocl::bitwise_not(const oclMat &src, oclMat &dst)
{ {
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F) bitwise_run(src, oclMat(), Scalar(), oclMat(), dst, NOT);
{
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
return;
}
dst.create(src.size(), src.type());
bitwise_unary_run(src, dst, "arithm_bitwise_not", &arithm_bitwise_not);
} }
void cv::ocl::bitwise_or(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask) void cv::ocl::bitwise_or(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
{ {
bitwise_binary_run(src1, src2, Scalar(), mask, dst, OR); bitwise_run(src1, src2, Scalar(), mask, dst, OR);
} }
void cv::ocl::bitwise_or(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask) void cv::ocl::bitwise_or(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
{ {
bitwise_binary_run(src1, oclMat(), src2, mask, dst, OR); bitwise_run(src1, oclMat(), src2, mask, dst, OR);
} }
void cv::ocl::bitwise_and(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask) void cv::ocl::bitwise_and(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
{ {
bitwise_binary_run(src1, src2, Scalar(), mask, dst, AND); bitwise_run(src1, src2, Scalar(), mask, dst, AND);
} }
void cv::ocl::bitwise_and(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask) void cv::ocl::bitwise_and(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
{ {
bitwise_binary_run(src1, oclMat(), src2, mask, dst, AND); bitwise_run(src1, oclMat(), src2, mask, dst, AND);
} }
void cv::ocl::bitwise_xor(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask) void cv::ocl::bitwise_xor(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
{ {
bitwise_binary_run(src1, src2, Scalar(), mask, dst, XOR); bitwise_run(src1, src2, Scalar(), mask, dst, XOR);
} }
void cv::ocl::bitwise_xor(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask) void cv::ocl::bitwise_xor(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
{ {
bitwise_binary_run(src1, oclMat(), src2, mask, dst, XOR); bitwise_run(src1, oclMat(), src2, mask, dst, XOR);
} }
oclMat cv::ocl::operator ~ (const oclMat &src) oclMat cv::ocl::operator ~ (const oclMat &src)

29
modules/ocl/src/gftt.cpp
View File

@ -146,34 +146,33 @@ static void minMaxEig_caller(const oclMat &src, oclMat &dst, oclMat & tozero)
CV_Assert(groupnum != 0); CV_Assert(groupnum != 0);
int dbsize = groupnum * 2 * src.elemSize(); int dbsize = groupnum * 2 * src.elemSize();
ensureSizeIsEnough(1, dbsize, CV_8UC1, dst); ensureSizeIsEnough(1, dbsize, CV_8UC1, dst);
cl_mem dst_data = reinterpret_cast<cl_mem>(dst.data); cl_mem dst_data = reinterpret_cast<cl_mem>(dst.data);
int all_cols = src.step / src.elemSize(); int vElemSize = src.elemSize1();
int pre_cols = (src.offset % src.step) / src.elemSize(); int src_step = src.step / vElemSize, src_offset = src.offset / vElemSize;
int sec_cols = all_cols - (src.offset % src.step + src.cols * src.elemSize() - 1) / src.elemSize() - 1; int total = src.size().area();
int invalid_cols = pre_cols + sec_cols;
int cols = all_cols - invalid_cols , elemnum = cols * src.rows;
int offset = src.offset / src.elemSize();
{// first parallel pass {
// first parallel pass
vector<pair<size_t , const void *> > args; vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data)); args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst_data )); args.push_back( make_pair( sizeof(cl_int) , (void *)&src_step));
args.push_back( make_pair( sizeof(cl_int) , (void *)&cols )); args.push_back( make_pair( sizeof(cl_int) , (void *)&src_offset));
args.push_back( make_pair( sizeof(cl_int) , (void *)&invalid_cols )); args.push_back( make_pair( sizeof(cl_int) , (void *)&src.rows ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&offset)); args.push_back( make_pair( sizeof(cl_int) , (void *)&src.cols ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&elemnum)); args.push_back( make_pair( sizeof(cl_int) , (void *)&total));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum)); args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum));
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst_data ));
size_t globalThreads[3] = {groupnum * 256, 1, 1}; size_t globalThreads[3] = {groupnum * 256, 1, 1};
size_t localThreads[3] = {256, 1, 1}; size_t localThreads[3] = {256, 1, 1};
openCLExecuteKernel(src.clCxt, &arithm_minMax, "arithm_op_minMax", globalThreads, localThreads, openCLExecuteKernel(src.clCxt, &arithm_minMax, "arithm_op_minMax", globalThreads, localThreads,
args, -1, -1, "-D T=float -D DEPTH_5"); args, -1, -1, "-D T=float -D DEPTH_5 -D vlen=1");
} }
{// run final "serial" kernel to find accumulate results from threads and reset corner counter {
// run final "serial" kernel to find accumulate results from threads and reset corner counter
vector<pair<size_t , const void *> > args; vector<pair<size_t , const void *> > args;
args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst_data )); args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst_data ));
args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum )); args.push_back( make_pair( sizeof(cl_int) , (void *)&groupnum ));

51
modules/ocl/src/opencl/arithm_bitwise_binary.cl → modules/ocl/src/opencl/arithm_bitwise.cl
View File

@ -48,35 +48,46 @@
/////////////////////////////////////////// bitwise_binary ////////////////////////////////////////// /////////////////////////////////////////// bitwise_binary //////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void arithm_bitwise_binary(__global uchar * src1, int src1_step, int src1_offset, __kernel void arithm_bitwise(__global uchar * src1ptr, int src1_step, int src1_offset,
__global uchar * src2, int src2_step, int src2_offset, #ifdef OP_BINARY
__global uchar * dst, int dst_step, int dst_offset, __global uchar * src2ptr, int src2_step, int src2_offset,
int cols, int rows) #elif defined HAVE_SCALAR
T scalar,
#endif
#ifdef HAVE_MASK
__global uchar * mask, int mask_step, int mask_offset,
#endif
__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols)
{ {
int x = get_global_id(0); int x = get_global_id(0);
int y = get_global_id(1); int y = get_global_id(1);
if (x < cols && y < rows) if (x < dst_cols && y < dst_rows)
{ {
#if elemSize > 1 #ifdef HAVE_MASK
x *= elemSize; mask += mad24(y, mask_step, x + mask_offset);
if (mask[0])
#endif #endif
int src1_index = mad24(y, src1_step, x + src1_offset);
int src2_index = mad24(y, src2_step, x + src2_offset);
int dst_index = mad24(y, dst_step, x + dst_offset);
#if elemSize > 1
#pragma unroll
for (int i = 0; i < elemSize; i += vlen)
{ {
ucharv t0 = vloadn(0, src1 + src1_index + i); int src1_index = mad24(y, src1_step, mad24(x, (int)sizeof(T), src1_offset));
ucharv t1 = vloadn(0, src2 + src2_index + i); #ifdef OP_BINARY
ucharv t2 = t0 Operation t1; int src2_index = mad24(y, src2_step, mad24(x, (int)sizeof(T), src2_offset));
#endif
int dst_index = mad24(y, dst_step, mad24(x, (int)sizeof(T), dst_offset));
vstoren(t2, 0, dst + dst_index + i); __global const T * src1 = (__global const T *)(src1ptr + src1_index);
} #ifdef OP_BINARY
__global const T * src2 = (__global const T *)(src2ptr + src2_index);
#endif
__global T * dst = (__global T *)(dstptr + dst_index);
#ifdef OP_BINARY
dst[0] = src1[0] Operation src2[0];
#elif defined HAVE_SCALAR
dst[0] = src1[0] Operation scalar;
#else #else
dst[dst_index] = src1[src1_index] Operation src2[src2_index]; dst[0] = Operation src1[0];
#endif #endif
} }
} }
}

88
modules/ocl/src/opencl/arithm_bitwise_binary_mask.cl
View File

@ -1,88 +0,0 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// @Authors
// Jiang Liyuan, jlyuan001.good@163.com
// Peng Xiao, pengxiao@outlook.com
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
//////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////bitwise_binary////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void arithm_bitwise_binary_mask(__global uchar * src1, int src1_step, int src1_offset,
__global uchar * src2, int src2_step, int src2_offset,
__global uchar * mask, int mask_step, int mask_offset,
__global uchar * dst, int dst_step, int dst_offset,
int cols1, int rows)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols1 && y < rows)
{
int mask_index = mad24(y, mask_step, mask_offset + x);
if (mask[mask_index])
{
#if elemSize > 1
x *= elemSize;
#endif
int src1_index = mad24(y, src1_step, x + src1_offset);
int src2_index = mad24(y, src2_step, x + src2_offset);
int dst_index = mad24(y, dst_step, x + dst_offset);
#if elemSize > 1
#pragma unroll
for (int i = 0; i < elemSize; i += vlen)
{
ucharv t0 = vloadn(0, src1 + src1_index + i);
ucharv t1 = vloadn(0, src2 + src2_index + i);
ucharv t2 = t0 Operation t1;
vstoren(t2, 0, dst + dst_index + i);
}
#else
dst[dst_index] = src1[src1_index] Operation src2[src2_index];
#endif
}
}
}

82
modules/ocl/src/opencl/arithm_bitwise_binary_scalar.cl
View File

@ -1,82 +0,0 @@
////////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// @Authors
// Jiang Liyuan, jlyuan001.good@163.com
// Peng Xiao, pengxiao@outlook.com
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//
///////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////bitwise_binary/////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void arithm_bitwise_binary_scalar(
__global uchar *src1, int src1_step, int src1_offset,
__global uchar *src2,
__global uchar *dst, int dst_step, int dst_offset,
int cols, int rows)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
#if elemSize > 1
x *= elemSize;
#endif
int src1_index = mad24(y, src1_step, src1_offset + x);
int dst_index = mad24(y, dst_step, dst_offset + x);
#if elemSize > 1
#pragma unroll
for (int i = 0; i < elemSize; i += vlen)
{
ucharv t0 = vloadn(0, src1 + src1_index + i);
ucharv t1 = vloadn(0, src2 + i);
ucharv t2 = t0 Operation t1;
vstoren(t2, 0, dst + dst_index + i);
}
#else
dst[dst_index] = src1[src1_index] Operation src2[0];
#endif
}
}

86
modules/ocl/src/opencl/arithm_bitwise_binary_scalar_mask.cl
View File

@ -1,86 +0,0 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// @Authors
// Jiang Liyuan, jlyuan001.good@163.com
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
//////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////bitwise_binary////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void arithm_bitwise_binary_scalar_mask(__global uchar *src1, int src1_step, int src1_offset,
__global uchar *src2,
__global uchar *mask, int mask_step, int mask_offset,
__global uchar *dst, int dst_step, int dst_offset,
int cols, int rows)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
int mask_index = mad24(y, mask_step, x + mask_offset);
if (mask[mask_index])
{
#if elemSize > 1
x *= elemSize;
#endif
int src1_index = mad24(y, src1_step, x + src1_offset);
int dst_index = mad24(y, dst_step, x + dst_offset);
#if elemSize > 1
#pragma unroll
for (int i = 0; i < elemSize; i += vlen)
{
ucharv t0 = vloadn(0, src1 + src1_index + i);
ucharv t1 = vloadn(0, src2 + i);
ucharv t2 = t0 Operation t1;
vstoren(t2, 0, dst + dst_index + i);
}
#else
dst[dst_index] = src1[src1_index] Operation src2[0];
#endif
}
}
}

253
modules/ocl/src/opencl/arithm_bitwise_not.cl
View File

@ -1,253 +0,0 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// @Authors
// Jiang Liyuan, jlyuan001.good@163.com
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors as is and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#ifdef DOUBLE_SUPPORT
#ifdef cl_amd_fp64
#pragma OPENCL EXTENSION cl_amd_fp64:enable
#elif defined (cl_khr_fp64)
#pragma OPENCL EXTENSION cl_khr_fp64:enable
#endif
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////BITWISE_NOT////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
__kernel void arithm_bitwise_not_D0 (__global uchar *src1, int src1_step, int src1_offset,
__global uchar *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
x = x << 2;
int src1_index = mad24(y, src1_step, x + src1_offset);
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
int dst_index = mad24(y, dst_step, dst_offset + x);
uchar4 src1_data = vload4(0, src1 + src1_index);
uchar4 dst_data = vload4(0, dst + dst_index);
uchar4 tmp_data = ~src1_data;
dst_data.x = dst_index + 0 < dst_end ? tmp_data.x : dst_data.x;
dst_data.y = dst_index + 1 < dst_end ? tmp_data.y : dst_data.y;
dst_data.z = dst_index + 2 < dst_end ? tmp_data.z : dst_data.z;
dst_data.w = dst_index + 3 < dst_end ? tmp_data.w : dst_data.w;
vstore4(dst_data, 0, dst + dst_index);
}
}
__kernel void arithm_bitwise_not_D1 (__global char *src1, int src1_step, int src1_offset,
__global char *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
x = x << 2;
int src1_index = mad24(y, src1_step, x + src1_offset);
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
int dst_index = mad24(y, dst_step, dst_offset + x);
char4 src1_data = vload4(0, src1 + src1_index);
char4 dst_data = vload4(0, dst + dst_index);
char4 tmp_data = ~src1_data;
dst_data.x = dst_index + 0 < dst_end ? tmp_data.x : dst_data.x;
dst_data.y = dst_index + 1 < dst_end ? tmp_data.y : dst_data.y;
dst_data.z = dst_index + 2 < dst_end ? tmp_data.z : dst_data.z;
dst_data.w = dst_index + 3 < dst_end ? tmp_data.w : dst_data.w;
vstore4(dst_data, 0, dst + dst_index);
}
}
__kernel void arithm_bitwise_not_D2 (__global ushort *src1, int src1_step, int src1_offset,
__global ushort *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
x = x << 2;
#ifdef dst_align
#undef dst_align
#endif
#define dst_align ((dst_offset >> 1) & 3)
int src1_index = mad24(y, src1_step, (x << 1) + src1_offset - (dst_align << 1));
int dst_start = mad24(y, dst_step, dst_offset);
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
int dst_index = mad24(y, dst_step, dst_offset + (x << 1) & (int)0xfffffff8);
ushort4 src1_data = vload4(0, (__global ushort *)((__global char *)src1 + src1_index));
ushort4 dst_data = *((__global ushort4 *)((__global char *)dst + dst_index));
ushort4 tmp_data = ~ src1_data;
dst_data.x = ((dst_index + 0 >= dst_start) && (dst_index + 0 < dst_end)) ? tmp_data.x : dst_data.x;
dst_data.y = ((dst_index + 2 >= dst_start) && (dst_index + 2 < dst_end)) ? tmp_data.y : dst_data.y;
dst_data.z = ((dst_index + 4 >= dst_start) && (dst_index + 4 < dst_end)) ? tmp_data.z : dst_data.z;
dst_data.w = ((dst_index + 6 >= dst_start) && (dst_index + 6 < dst_end)) ? tmp_data.w : dst_data.w;
*((__global ushort4 *)((__global char *)dst + dst_index)) = dst_data;
}
}
__kernel void arithm_bitwise_not_D3 (__global short *src1, int src1_step, int src1_offset,
__global short *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
x = x << 2;
#ifdef dst_align
#undef dst_align
#endif
#define dst_align ((dst_offset >> 1) & 3)
int src1_index = mad24(y, src1_step, (x << 1) + src1_offset - (dst_align << 1));
int dst_start = mad24(y, dst_step, dst_offset);
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
int dst_index = mad24(y, dst_step, dst_offset + (x << 1) & (int)0xfffffff8);
short4 src1_data = vload4(0, (__global short *)((__global char *)src1 + src1_index));
short4 dst_data = *((__global short4 *)((__global char *)dst + dst_index));
short4 tmp_data = ~ src1_data;
dst_data.x = ((dst_index + 0 >= dst_start) && (dst_index + 0 < dst_end)) ? tmp_data.x : dst_data.x;
dst_data.y = ((dst_index + 2 >= dst_start) && (dst_index + 2 < dst_end)) ? tmp_data.y : dst_data.y;
dst_data.z = ((dst_index + 4 >= dst_start) && (dst_index + 4 < dst_end)) ? tmp_data.z : dst_data.z;
dst_data.w = ((dst_index + 6 >= dst_start) && (dst_index + 6 < dst_end)) ? tmp_data.w : dst_data.w;
*((__global short4 *)((__global char *)dst + dst_index)) = dst_data;
}
}
__kernel void arithm_bitwise_not_D4 (__global int *src1, int src1_step, int src1_offset,
__global int *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
int src1_index = mad24(y, src1_step, (x << 2) + src1_offset);
int dst_index = mad24(y, dst_step, (x << 2) + dst_offset);
int data1 = *((__global int *)((__global char *)src1 + src1_index));
int tmp = ~ data1;
*((__global int *)((__global char *)dst + dst_index)) = tmp;
}
}
__kernel void arithm_bitwise_not_D5 (__global char *src, int src_step, int src_offset,
__global char *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
int src_index = mad24(y, src_step, (x << 2) + src_offset);
int dst_index = mad24(y, dst_step, (x << 2) + dst_offset);
char4 data;
data = *((__global char4 *)((__global char *)src + src_index));
data = ~ data;
*((__global char4 *)((__global char *)dst + dst_index)) = data;
}
}
#if defined (DOUBLE_SUPPORT)
__kernel void arithm_bitwise_not_D6 (__global char *src, int src_step, int src_offset,
__global char *dst, int dst_step, int dst_offset,
int rows, int cols, int dst_step1)
{
int x = get_global_id(0);
int y = get_global_id(1);
if (x < cols && y < rows)
{
int src_index = mad24(y, src_step, (x << 3) + src_offset);
int dst_index = mad24(y, dst_step, (x << 3) + dst_offset);
char8 data;
data = *((__global char8 *)((__global char *)src + src_index));
data = ~ data;
*((__global char8 *)((__global char *)dst + dst_index)) = data;
}
}
#endif

78
modules/ocl/src/opencl/arithm_minMax.cl
View File

@ -63,81 +63,31 @@
/**************************************Array minMax**************************************/ /**************************************Array minMax**************************************/
__kernel void arithm_op_minMax(__global const T * src, __global T * dst, __kernel void arithm_op_minMax(__global const T * src, int src_step, int src_offset, int src_rows, int src_cols,
int cols, int invalid_cols, int offset, int elemnum, int groupnum) int total, int groupnum, __global T * dst
#ifdef WITH_MASK
, __global const uchar * mask, int mask_step, int mask_offset
#endif
)
{ {
int lid = get_local_id(0); int lid = get_local_id(0);
int gid = get_group_id(0); int gid = get_group_id(0);
int id = get_global_id(0); int id = get_global_id(0);
int idx = offset + id + (id / cols) * invalid_cols;
__local T localmem_max[128], localmem_min[128]; __local T localmem_max[128], localmem_min[128];
T minval = (T)(MAX_VAL), maxval = (T)(MIN_VAL), temp; T minval = (T)(MAX_VAL), maxval = (T)(MIN_VAL), temp;
int y, x;
for (int grainSize = groupnum << 8; id < elemnum; id += grainSize) for (int grainSize = groupnum << 8; id < total; id += grainSize)
{ {
idx = offset + id + (id / cols) * invalid_cols; y = id / src_cols;
temp = src[idx]; x = id % src_cols;
minval = min(minval, temp);
maxval = max(maxval, temp);
}
if (lid > 127) #ifdef WITH_MASK
if (mask[mad24(y, mask_step, x + mask_offset)])
#endif
{ {
localmem_min[lid - 128] = minval; temp = src[mad24(y, src_step, x + src_offset)];
localmem_max[lid - 128] = maxval;
}
barrier(CLK_LOCAL_MEM_FENCE);
if (lid < 128)
{
localmem_min[lid] = min(minval, localmem_min[lid]);
localmem_max[lid] = max(maxval, localmem_max[lid]);
}
barrier(CLK_LOCAL_MEM_FENCE);
for (int lsize = 64; lsize > 0; lsize >>= 1)
{
if (lid < lsize)
{
int lid2 = lsize + lid;
localmem_min[lid] = min(localmem_min[lid], localmem_min[lid2]);
localmem_max[lid] = max(localmem_max[lid], localmem_max[lid2]);
}
barrier(CLK_LOCAL_MEM_FENCE);
}
if (lid == 0)
{
dst[gid] = localmem_min[0];
dst[gid + groupnum] = localmem_max[0];
}
}
__kernel void arithm_op_minMax_mask(__global const T * src, __global T * dst,
int cols, int invalid_cols, int offset,
int elemnum, int groupnum,
const __global uchar * mask, int minvalid_cols, int moffset)
{
int lid = get_local_id(0);
int gid = get_group_id(0);
int id = get_global_id(0);
int idx = offset + id + (id / cols) * invalid_cols;
int midx = moffset + id + (id / cols) * minvalid_cols;
__local T localmem_max[128], localmem_min[128];
T minval = (T)(MAX_VAL), maxval = (T)(MIN_VAL), temp;
for (int grainSize = groupnum << 8; id < elemnum; id += grainSize)
{
idx = offset + id + (id / cols) * invalid_cols;
midx = moffset + id + (id / cols) * minvalid_cols;
if (mask[midx])
{
temp = src[idx];
minval = min(minval, temp); minval = min(minval, temp);
maxval = max(maxval, temp); maxval = max(maxval, temp);
} }

13
modules/ocl/src/opencl/arithm_nonzero.cl
View File

@ -52,23 +52,18 @@
/**************************************Count NonZero**************************************/ /**************************************Count NonZero**************************************/
__kernel void arithm_op_nonzero(int cols, int invalid_cols, int offset, int elemnum, int groupnum, __kernel void arithm_op_nonzero(__global srcT * src, int src_step, int src_offset, int src_cols,
__global srcT *src, __global dstT *dst) int total, int groupnum, __global dstT * dst)
{ {
int lid = get_local_id(0); int lid = get_local_id(0);
int gid = get_group_id(0); int gid = get_group_id(0);
int id = get_global_id(0); int id = get_global_id(0);
int idx = offset + id + (id / cols) * invalid_cols;
__local dstT localmem_nonzero[128]; __local dstT localmem_nonzero[128];
dstT nonzero = (dstT)(0); dstT nonzero = (dstT)(0);
srcT zero = (srcT)(0), one = (srcT)(1);
for (int grain = groupnum << 8; id < elemnum; id += grain) for (int grain = groupnum << 8; id < total; id += grain)
{ nonzero += convertToDstT(src[mad24(id / src_cols, src_step, id % src_cols + src_offset)] == (srcT)(0)) ? (dstT)(0) : (dstT)(1);
idx = offset + id + (id / cols) * invalid_cols;
nonzero += src[idx] == zero ? zero : one;
}
if (lid > 127) if (lid > 127)
localmem_nonzero[lid - 128] = nonzero; localmem_nonzero[lid - 128] = nonzero;

10
modules/ocl/src/opencl/arithm_sum.cl
View File

@ -63,21 +63,19 @@
/**************************************Array buffer SUM**************************************/ /**************************************Array buffer SUM**************************************/
__kernel void arithm_op_sum(int cols,int invalid_cols,int offset,int elemnum,int groupnum, __kernel void arithm_op_sum(__global srcT * src, int src_step, int src_offset, int src_cols,
__global srcT *src, __global dstT *dst) int total, int groupnum, __global dstT * dst)
{ {
int lid = get_local_id(0); int lid = get_local_id(0);
int gid = get_group_id(0); int gid = get_group_id(0);
int id = get_global_id(0); int id = get_global_id(0);
int idx = offset + id + (id / cols) * invalid_cols;
__local dstT localmem_sum[128]; __local dstT localmem_sum[128];
dstT sum = (dstT)(0), temp; dstT sum = (dstT)(0), temp;
for (int grainSize = groupnum << 8; id < elemnum; id += grainSize) for (int grainSize = groupnum << 8; id < total; id += grainSize)
{ {
idx = offset + id + (id / cols) * invalid_cols; temp = convertToDstT(src[mad24(id / src_cols, src_step, id % src_cols + src_offset)]);
temp = convertToDstT(src[idx]);
FUNC(temp, sum); FUNC(temp, sum);
} }

4
modules/ocl/test/test_arithm.cpp
View File

@ -198,7 +198,7 @@ PARAM_TEST_CASE(ArithmTestBase, MatDepth, Channels, bool)
Size roiSize = randomSize(1, MAX_VALUE); Size roiSize = randomSize(1, MAX_VALUE);
Border src1Border = randomBorder(0, use_roi ? MAX_VALUE : 0); Border src1Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
randomSubMat(src1, src1_roi, roiSize, src1Border, type, 2, 11); randomSubMat(src1, src1_roi, roiSize, src1Border, type, -11, 11);
Border src2Border = randomBorder(0, use_roi ? MAX_VALUE : 0); Border src2Border = randomBorder(0, use_roi ? MAX_VALUE : 0);
randomSubMat(src2, src2_roi, roiSize, src2Border, type, -1540, 1740); randomSubMat(src2, src2_roi, roiSize, src2Border, type, -1540, 1740);
@ -1163,7 +1163,7 @@ OCL_TEST_P(CountNonZero, MAT)
int cpures = cv::countNonZero(src1_roi); int cpures = cv::countNonZero(src1_roi);
int gpures = cv::ocl::countNonZero(gsrc1_roi); int gpures = cv::ocl::countNonZero(gsrc1_roi);
EXPECT_DOUBLE_EQ((double)cpures, (double)gpures); EXPECT_EQ(cpures, gpures);
} }
} }