catching OpenCL double not supported exceptions

modules/core/include/opencv2/core/types_c.h

@@ -264,7 +264,9 @@ enum {
  CV_GpuNotSupported=           -216,
  CV_GpuApiCallError=           -217,
  CV_OpenGlNotSupported=        -218,
- CV_OpenGlApiCallError=        -219
+ CV_OpenGlApiCallError=        -219,
+ CV_OpenCLDoubleNotSupported=  -220,
+ CV_OpenCLInitError=           -221
 };
 
 /****************************************************************************************\

modules/ocl/perf/perf_kalman.cpp

@@ -43,30 +43,33 @@
 // the use of this software, even if advised of the possibility of such damage.
 //
 //M*/
+
 #include "perf_precomp.hpp"
+
+#ifdef HAVE_CLAMDBLAS
+
 using namespace perf;
 using namespace std;
 using namespace cv::ocl;
 using namespace cv;
 using std::tr1::tuple;
 using std::tr1::get;
+
 ///////////// Kalman Filter ////////////////////////
 
-typedef tuple<int> KalmanFilterType;
-typedef TestBaseWithParam<KalmanFilterType> KalmanFilterFixture;
+typedef TestBaseWithParam<int> KalmanFilterFixture;
 
 PERF_TEST_P(KalmanFilterFixture, KalmanFilter,
             ::testing::Values(1000, 1500))
 {
-    KalmanFilterType params = GetParam();
-    const int dim = get<0>(params);
+    const int dim = GetParam();
 
     cv::Mat sample(dim, 1, CV_32FC1), dresult;
     randu(sample, -1, 1);
 
     cv::Mat statePre_;
 
-    if(RUN_PLAIN_IMPL)
+    if (RUN_PLAIN_IMPL)
     {
         cv::KalmanFilter kalman;
         TEST_CYCLE()
@@ -76,7 +79,8 @@ PERF_TEST_P(KalmanFilterFixture, KalmanFilter,
             kalman.predict();
         }
         statePre_ = kalman.statePre;
-    }else if(RUN_OCL_IMPL)
+    }
+    else if(RUN_OCL_IMPL)
     {
         cv::ocl::oclMat dsample(sample);
         cv::ocl::KalmanFilter kalman_ocl;
@@ -87,7 +91,11 @@ PERF_TEST_P(KalmanFilterFixture, KalmanFilter,
             kalman_ocl.predict();
         }
         kalman_ocl.statePre.download(statePre_);
-    }else
+    }
+    else
         OCL_PERF_ELSE
+
     SANITY_CHECK(statePre_);
-}
+}
\ No newline at end of file
+
+#endif // HAVE_CLAMDBLAS

modules/ocl/src/cl_context.cpp

@@ -517,14 +517,14 @@ Context* Context::getContext()
             {
                 if (initializeOpenCLDevices() == 0)
                 {
-                    CV_Error(CV_GpuNotSupported, "OpenCL not available");
+                    CV_Error(CV_OpenCLInitError, "OpenCL not available");
                 }
             }
             if (!__deviceSelected)
             {
                 if (!selectOpenCLDevice())
                 {
-                    CV_Error(CV_GpuNotSupported, "Can't select OpenCL device");
+                    CV_Error(CV_OpenCLInitError, "Can't select OpenCL device");
                 }
             }
         }

modules/ocl/src/filtering.cpp

@@ -1417,7 +1417,7 @@ void cv::ocl::Laplacian(const oclMat &src, oclMat &dst, int ddepth, int ksize, d
 {
     if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.type() == CV_64F)
     {
-        CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
+        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 

modules/ocl/src/imgproc.cpp

@@ -977,7 +977,7 @@ namespace cv
             CV_Assert(src.type() == CV_8UC1);
             if(!src.clCxt->supportsFeature(ocl::FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
             {
-                CV_Error(CV_GpuNotSupported, "select device don't support double");
+                CV_Error(CV_OpenCLDoubleNotSupported, "select device don't support double");
                 return;
             }
 
@@ -1168,7 +1168,7 @@ namespace cv
         {
             if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
             {
-                CV_Error(CV_GpuNotSupported, "select device don't support double");
+                CV_Error(CV_OpenCLDoubleNotSupported, "select device don't support double");
             }
             CV_Assert(src.cols >= blockSize / 2 && src.rows >= blockSize / 2);
             CV_Assert(borderType == cv::BORDER_CONSTANT || borderType == cv::BORDER_REFLECT101 || borderType == cv::BORDER_REPLICATE || borderType == cv::BORDER_REFLECT);
@@ -1187,7 +1187,7 @@ namespace cv
         {
             if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
             {
-                CV_Error(CV_GpuNotSupported, "select device don't support double");
+                CV_Error(CV_OpenCLDoubleNotSupported, "select device don't support double");
             }
             CV_Assert(src.cols >= blockSize / 2 && src.rows >= blockSize / 2);
             CV_Assert(borderType == cv::BORDER_CONSTANT || borderType == cv::BORDER_REFLECT101 || borderType == cv::BORDER_REPLICATE || borderType == cv::BORDER_REFLECT);
@@ -1301,10 +1301,11 @@ namespace cv
             if( src.depth() != CV_8U || src.oclchannels() != 4 )
                 CV_Error( CV_StsUnsupportedFormat, "Only 8-bit, 4-channel images are supported" );
 
-            //            if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE))
-            //            {
-            //                CV_Error( CV_GpuNotSupported, "Selected device doesn't support double, so a deviation exists.\nIf the accuracy is acceptable, the error can be ignored.\n");
-            //            }
+//            if(!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE))
+//            {
+//                CV_Error( CV_OpenCLDoubleNotSupportedNotSupported, "Selected device doesn't support double, so a deviation exists.\nIf the accuracy is acceptable, the error can be ignored.\n");
+//                return;
+//            }
 
             dstr.create( src.size(), CV_8UC4 );
             dstsp.create( src.size(), CV_16SC2 );

modules/ocl/src/kmeans.cpp

@@ -164,7 +164,7 @@ void cv::ocl::distanceToCenters(oclMat &dists, oclMat &labels, const oclMat &src
 {
     //if(src.clCxt -> impl -> double_support == 0 && src.type() == CV_64F)
     //{
-    //    CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
+    //    CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
     //    return;
     //}
 

modules/ocl/src/matrix_operations.cpp

@@ -119,6 +119,12 @@ static void convert_C4C3(const oclMat &src, cl_mem &dst)
 
 void cv::ocl::oclMat::upload(const Mat &m)
 {
+    if (!Context::getContext()->supportsFeature(FEATURE_CL_DOUBLE) && m.depth() == CV_64F)
+    {
+        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
+        return;
+    }
+
     CV_DbgAssert(!m.empty());
     Size wholeSize;
     Point ofs;
@@ -308,7 +314,7 @@ void cv::ocl::oclMat::convertTo( oclMat &dst, int rtype, double alpha, double be
     if (!clCxt->supportsFeature(FEATURE_CL_DOUBLE) &&
             (depth() == CV_64F || dst.depth() == CV_64F))
     {
-        CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
+        CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
         return;
     }
 

modules/ocl/src/split_merge.cpp

@@ -59,7 +59,7 @@ namespace cv
             {
                 if(!mat_dst.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && mat_dst.type() == CV_64F)
                 {
-                    CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
+                    CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
                     return;
                 }
 
@@ -154,7 +154,7 @@ namespace cv
 
                 if(!mat_src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && mat_src.type() == CV_64F)
                 {
-                    CV_Error(CV_GpuNotSupported, "Selected device don't support double\r\n");
+                    CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
                     return;
                 }
 

modules/ocl/test/test_bgfg.cpp

@@ -90,7 +90,7 @@ PARAM_TEST_CASE(mog, UseGray, LearningRate, bool)
     }
 };
 
-TEST_P(mog, Update)
+OCL_TEST_P(mog, Update)
 {
     std::string inputFile = string(cvtest::TS::ptr()->get_data_path()) + "gpu/video/768x576.avi";
     cv::VideoCapture cap(inputFile);
@@ -151,7 +151,7 @@ PARAM_TEST_CASE(mog2, UseGray, DetectShadow, bool)
     }
 };
 
-TEST_P(mog2, Update)
+OCL_TEST_P(mog2, Update)
 {
     std::string inputFile = string(cvtest::TS::ptr()->get_data_path()) + "gpu/video/768x576.avi";
     cv::VideoCapture cap(inputFile);
@@ -192,7 +192,7 @@ TEST_P(mog2, Update)
     }
 }
 
-TEST_P(mog2, getBackgroundImage)
+OCL_TEST_P(mog2, getBackgroundImage)
 {
     if (useGray)
         return;

modules/ocl/test/test_blend.cpp

@@ -88,7 +88,7 @@ PARAM_TEST_CASE(Blend, cv::Size, MatType/*, UseRoi*/)
     }
 };
 
-TEST_P(Blend, Accuracy)
+OCL_TEST_P(Blend, Accuracy)
 {
     int depth = CV_MAT_DEPTH(type);
 

modules/ocl/test/test_brute_force_matcher.cpp

@@ -106,7 +106,7 @@ namespace
         }
     };
 
-    TEST_P(BruteForceMatcher, Match_Single)
+    OCL_TEST_P(BruteForceMatcher, Match_Single)
     {
         cv::ocl::BruteForceMatcher_OCL_base matcher(distType);
 
@@ -126,7 +126,7 @@ namespace
         ASSERT_EQ(0, badCount);
     }
 
-    TEST_P(BruteForceMatcher, KnnMatch_2_Single)
+    OCL_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
     {
         const int knn = 2;
 
@@ -158,7 +158,7 @@ namespace
         ASSERT_EQ(0, badCount);
     }
 
-    TEST_P(BruteForceMatcher, RadiusMatch_Single)
+    OCL_TEST_P(BruteForceMatcher, RadiusMatch_Single)
     {
         float radius = 1.f / countFactor;
 

modules/ocl/test/test_calib3d.cpp

@@ -62,7 +62,7 @@ PARAM_TEST_CASE(StereoMatchBM, int, int)
     }
 };
 
-TEST_P(StereoMatchBM, Regression)
+OCL_TEST_P(StereoMatchBM, Regression)
 {
 
     Mat left_image  = readImage("gpu/stereobm/aloe-L.png", IMREAD_GRAYSCALE);
@@ -110,7 +110,7 @@ PARAM_TEST_CASE(StereoMatchBP, int, int, int, float, float, float, float)
         disc_single_jump_  = GET_PARAM(6);
     }
 };
-TEST_P(StereoMatchBP, Regression)
+OCL_TEST_P(StereoMatchBP, Regression)
 {
     Mat left_image  = readImage("gpu/stereobp/aloe-L.png");
     Mat right_image = readImage("gpu/stereobp/aloe-R.png");
@@ -163,7 +163,7 @@ PARAM_TEST_CASE(StereoMatchConstSpaceBP, int, int, int, int, float, float, float
         msg_type_  = GET_PARAM(9);
     }
 };
-TEST_P(StereoMatchConstSpaceBP, Regression)
+OCL_TEST_P(StereoMatchConstSpaceBP, Regression)
 {
     Mat left_image  = readImage("gpu/csstereobp/aloe-L.png");
     Mat right_image = readImage("gpu/csstereobp/aloe-R.png");

modules/ocl/test/test_canny.cpp

@@ -64,7 +64,7 @@ PARAM_TEST_CASE(Canny, AppertureSize, L2gradient)
     }
 };
 
-TEST_P(Canny, Accuracy)
+OCL_TEST_P(Canny, Accuracy)
 {
     cv::Mat img = readImage("cv/shared/fruits.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());

modules/ocl/test/test_color.cpp

@@ -90,7 +90,7 @@ PARAM_TEST_CASE(CvtColor, cv::Size, MatDepth)
 };
 
 #define CVTCODE(name) cv::COLOR_ ## name
-#define TEST_P_CVTCOLOR(name) TEST_P(CvtColor, name)\
+#define OCL_TEST_P_CVTCOLOR(name) OCL_TEST_P(CvtColor, name)\
 {\
     cv::Mat src = img;\
     cv::ocl::oclMat ocl_img, dst;\
@@ -104,17 +104,17 @@ PARAM_TEST_CASE(CvtColor, cv::Size, MatDepth)
 }
 
 //add new ones here using macro
-TEST_P_CVTCOLOR(RGB2GRAY)
-TEST_P_CVTCOLOR(BGR2GRAY)
-TEST_P_CVTCOLOR(RGBA2GRAY)
-TEST_P_CVTCOLOR(BGRA2GRAY)
-
-TEST_P_CVTCOLOR(RGB2YUV)
-TEST_P_CVTCOLOR(BGR2YUV)
-TEST_P_CVTCOLOR(YUV2RGB)
-TEST_P_CVTCOLOR(YUV2BGR)
-TEST_P_CVTCOLOR(RGB2YCrCb)
-TEST_P_CVTCOLOR(BGR2YCrCb)
+OCL_TEST_P_CVTCOLOR(RGB2GRAY)
+OCL_TEST_P_CVTCOLOR(BGR2GRAY)
+OCL_TEST_P_CVTCOLOR(RGBA2GRAY)
+OCL_TEST_P_CVTCOLOR(BGRA2GRAY)
+
+OCL_TEST_P_CVTCOLOR(RGB2YUV)
+OCL_TEST_P_CVTCOLOR(BGR2YUV)
+OCL_TEST_P_CVTCOLOR(YUV2RGB)
+OCL_TEST_P_CVTCOLOR(YUV2BGR)
+OCL_TEST_P_CVTCOLOR(RGB2YCrCb)
+OCL_TEST_P_CVTCOLOR(BGR2YCrCb)
 
 PARAM_TEST_CASE(CvtColor_Gray2RGB, cv::Size, MatDepth, int)
 {
@@ -131,7 +131,7 @@ PARAM_TEST_CASE(CvtColor_Gray2RGB, cv::Size, MatDepth, int)
         img   = randomMat(size, CV_MAKETYPE(depth, 1), 0.0, depth == CV_32F ? 1.0 : 255.0);
     }
 };
-TEST_P(CvtColor_Gray2RGB, Accuracy)
+OCL_TEST_P(CvtColor_Gray2RGB, Accuracy)
 {
     cv::Mat src = img;
     cv::ocl::oclMat ocl_img, dst;
@@ -160,7 +160,7 @@ PARAM_TEST_CASE(CvtColor_YUV420, cv::Size, int)
     }
 };
 
-TEST_P(CvtColor_YUV420, Accuracy)
+OCL_TEST_P(CvtColor_YUV420, Accuracy)
 {
     cv::Mat src = img;
     cv::ocl::oclMat ocl_img, dst;

modules/ocl/test/test_fft.cpp

@@ -44,10 +44,14 @@
 //M*/
 
 #include "test_precomp.hpp"
+
 using namespace std;
+
 #ifdef HAVE_CLAMDFFT
+
 ////////////////////////////////////////////////////////////////////////////
 // Dft
+
 PARAM_TEST_CASE(Dft, cv::Size, int)
 {
     cv::Size dft_size;
@@ -59,7 +63,7 @@ PARAM_TEST_CASE(Dft, cv::Size, int)
     }
 };
 
-TEST_P(Dft, C2C)
+OCL_TEST_P(Dft, C2C)
 {
     cv::Mat a = randomMat(dft_size, CV_32FC2, 0.0, 100.0);
     cv::Mat b_gold;
@@ -71,7 +75,7 @@ TEST_P(Dft, C2C)
     EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), a.size().area() * 1e-4);
 }
 
-TEST_P(Dft, R2C)
+OCL_TEST_P(Dft, R2C)
 {
     cv::Mat a = randomMat(dft_size, CV_32FC1, 0.0, 100.0);
     cv::Mat b_gold, b_gold_roi;
@@ -88,7 +92,7 @@ TEST_P(Dft, R2C)
     EXPECT_MAT_NEAR(b_gold_roi, cv::Mat(d_b), a.size().area() * 1e-4);
 }
 
-TEST_P(Dft, R2CthenC2R)
+OCL_TEST_P(Dft, R2CthenC2R)
 {
     cv::Mat a = randomMat(dft_size, CV_32FC1, 0.0, 10.0);
 

modules/ocl/test/test_filters.cpp

@@ -145,7 +145,7 @@ struct Blur : FilterTestBase
     }
 };
 
-TEST_P(Blur, Mat)
+OCL_TEST_P(Blur, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -172,7 +172,7 @@ struct Laplacian : FilterTestBase
     }
 };
 
-TEST_P(Laplacian, Accuracy)
+OCL_TEST_P(Laplacian, Accuracy)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -205,7 +205,7 @@ struct ErodeDilate : FilterTestBase
 
 };
 
-TEST_P(ErodeDilate, Mat)
+OCL_TEST_P(ErodeDilate, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -244,7 +244,7 @@ struct Sobel : FilterTestBase
     }
 };
 
-TEST_P(Sobel, Mat)
+OCL_TEST_P(Sobel, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -274,7 +274,7 @@ struct Scharr : FilterTestBase
     }
 };
 
-TEST_P(Scharr, Mat)
+OCL_TEST_P(Scharr, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -307,7 +307,7 @@ struct GaussianBlur : FilterTestBase
     }
 };
 
-TEST_P(GaussianBlur, Mat)
+OCL_TEST_P(GaussianBlur, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -339,7 +339,7 @@ struct Filter2D : FilterTestBase
     }
 };
 
-TEST_P(Filter2D, Mat)
+OCL_TEST_P(Filter2D, Mat)
 {
     cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
     for(int j = 0; j < LOOP_TIMES; j++)
@@ -370,7 +370,7 @@ struct Bilateral : FilterTestBase
     }
 };
 
-TEST_P(Bilateral, Mat)
+OCL_TEST_P(Bilateral, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -400,7 +400,7 @@ struct AdaptiveBilateral : FilterTestBase
     }
 };
 
-TEST_P(AdaptiveBilateral, Mat)
+OCL_TEST_P(AdaptiveBilateral, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {

modules/ocl/test/test_gemm.cpp

@@ -62,7 +62,7 @@ PARAM_TEST_CASE(Gemm, int, cv::Size, int)
     }
 };
 
-TEST_P(Gemm, Accuracy)
+OCL_TEST_P(Gemm, Accuracy)
 {
     cv::Mat a = randomMat(mat_size, type, 0.0, 10.0);
     cv::Mat b = randomMat(mat_size, type, 0.0, 10.0);

modules/ocl/test/test_imgproc.cpp

@@ -453,7 +453,7 @@ PARAM_TEST_CASE(ImgprocTestBase, MatType, MatType, MatType, MatType, MatType, bo
 
 struct equalizeHist : ImgprocTestBase {};
 
-TEST_P(equalizeHist, Mat)
+OCL_TEST_P(equalizeHist, Mat)
 {
     if (mat1.type() != CV_8UC1 || mat1.type() != dst.type())
     {
@@ -477,7 +477,7 @@ TEST_P(equalizeHist, Mat)
 
 struct CopyMakeBorder : ImgprocTestBase {};
 
-TEST_P(CopyMakeBorder, Mat)
+OCL_TEST_P(CopyMakeBorder, Mat)
 {
     int bordertype[] = {cv::BORDER_CONSTANT, cv::BORDER_REPLICATE, cv::BORDER_REFLECT, cv::BORDER_WRAP, cv::BORDER_REFLECT_101};
     int top = rng.uniform(0, 10);
@@ -532,7 +532,7 @@ TEST_P(CopyMakeBorder, Mat)
 
 struct cornerMinEigenVal : ImgprocTestBase {};
 
-TEST_P(cornerMinEigenVal, Mat)
+OCL_TEST_P(cornerMinEigenVal, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -554,7 +554,7 @@ TEST_P(cornerMinEigenVal, Mat)
 
 struct cornerHarris : ImgprocTestBase {};
 
-TEST_P(cornerHarris, Mat)
+OCL_TEST_P(cornerHarris, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -576,7 +576,7 @@ TEST_P(cornerHarris, Mat)
 
 struct integral : ImgprocTestBase {};
 
-TEST_P(integral, Mat1)
+OCL_TEST_P(integral, Mat1)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -588,7 +588,7 @@ TEST_P(integral, Mat1)
     }
 }
 
-TEST_P(integral, Mat2)
+OCL_TEST_P(integral, Mat2)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -690,7 +690,7 @@ PARAM_TEST_CASE(WarpTestBase, MatType, int)
 
 struct WarpAffine : WarpTestBase {};
 
-TEST_P(WarpAffine, Mat)
+OCL_TEST_P(WarpAffine, Mat)
 {
     static const double coeffs[2][3] =
     {
@@ -718,7 +718,7 @@ TEST_P(WarpAffine, Mat)
 
 struct WarpPerspective : WarpTestBase {};
 
-TEST_P(WarpPerspective, Mat)
+OCL_TEST_P(WarpPerspective, Mat)
 {
     static const double coeffs[3][3] =
     {
@@ -887,7 +887,7 @@ PARAM_TEST_CASE(Remap, MatType, MatType, MatType, int, int)
     }
 };
 
-TEST_P(Remap, Mat)
+OCL_TEST_P(Remap, Mat)
 {
     if((interpolation == 1 && map1Type == CV_16SC2) || (map1Type == CV_32FC1 && map2Type == nulltype) || (map1Type == CV_16SC2 && map2Type == CV_32FC1) || (map1Type == CV_32FC2 && map2Type == CV_32FC1))
     {
@@ -1012,7 +1012,7 @@ PARAM_TEST_CASE(Resize, MatType, cv::Size, double, double, int)
 
 };
 
-TEST_P(Resize, Mat)
+OCL_TEST_P(Resize, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -1105,7 +1105,7 @@ PARAM_TEST_CASE(Threshold, MatType, ThreshOp)
 
 };
 
-TEST_P(Threshold, Mat)
+OCL_TEST_P(Threshold, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -1206,7 +1206,7 @@ PARAM_TEST_CASE(meanShiftTestBase, MatType, MatType, int, int, cv::TermCriteria)
 /////////////////////////meanShiftFiltering/////////////////////////////
 struct meanShiftFiltering : meanShiftTestBase {};
 
-TEST_P(meanShiftFiltering, Mat)
+OCL_TEST_P(meanShiftFiltering, Mat)
 {
 
     for(int j = 0; j < LOOP_TIMES; j++)
@@ -1227,7 +1227,7 @@ TEST_P(meanShiftFiltering, Mat)
 ///////////////////////////meanShiftProc//////////////////////////////////
 struct meanShiftProc : meanShiftTestBase {};
 
-TEST_P(meanShiftProc, Mat)
+OCL_TEST_P(meanShiftProc, Mat)
 {
 
     for(int j = 0; j < LOOP_TIMES; j++)
@@ -1315,7 +1315,7 @@ PARAM_TEST_CASE(histTestBase, MatType, MatType)
 ///////////////////////////calcHist///////////////////////////////////////
 struct calcHist : histTestBase {};
 
-TEST_P(calcHist, Mat)
+OCL_TEST_P(calcHist, Mat)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -1354,7 +1354,7 @@ PARAM_TEST_CASE(CLAHE, cv::Size, double)
     }
 };
 
-TEST_P(CLAHE, Accuracy)
+OCL_TEST_P(CLAHE, Accuracy)
 {
     cv::Ptr<cv::CLAHE> clahe = cv::ocl::createCLAHE(clipLimit, gridSize);
     clahe->apply(g_src, g_dst);
@@ -1477,7 +1477,7 @@ void conv2( cv::Mat x, cv::Mat y, cv::Mat z)
             dstdata[i * (z.step >> 2) + j] = temp;
         }
 }
-TEST_P(Convolve, Mat)
+OCL_TEST_P(Convolve, Mat)
 {
     if(mat1.type() != CV_32FC1)
     {
@@ -1512,7 +1512,7 @@ PARAM_TEST_CASE(ColumnSum, cv::Size)
     }
 };
 
-TEST_P(ColumnSum, Accuracy)
+OCL_TEST_P(ColumnSum, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_32FC1, 0, 255);
     cv::ocl::oclMat d_dst;

modules/ocl/test/test_kalman.cpp

@@ -43,7 +43,11 @@
 //M*/
 
 #include "test_precomp.hpp"
+
 #ifdef HAVE_OPENCL
+
+#ifdef HAVE_CLAMDBLAS
+
 using namespace cv;
 using namespace cv::ocl;
 using namespace cvtest;
@@ -51,6 +55,7 @@ using namespace testing;
 using namespace std;
 
 //////////////////////////////////////////////////////////////////////////
+
 PARAM_TEST_CASE(Kalman, int, int)
 {
     int size_;
@@ -62,7 +67,7 @@ PARAM_TEST_CASE(Kalman, int, int)
     }
 };
 
-TEST_P(Kalman, Accuracy)
+OCL_TEST_P(Kalman, Accuracy)
 {
     const int Dim = size_;
     const int Steps = iteration;
@@ -139,6 +144,9 @@ TEST_P(Kalman, Accuracy)
     //test end
     EXPECT_MAT_NEAR(kalman_filter_cpu.statePost, kalman_filter_ocl.statePost, 0);
 }
+
 INSTANTIATE_TEST_CASE_P(OCL_Video, Kalman, Combine(Values(3, 7), Values(30)));
 
-#endif // HAVE_OPENCL
+#endif // HAVE_CLAMDBLAS
\ No newline at end of file
+
+#endif // HAVE_OPENCL

modules/ocl/test/test_kmeans.cpp

@@ -98,7 +98,7 @@ PARAM_TEST_CASE(Kmeans, int, int, int)
         }
     }
 };
-TEST_P(Kmeans, Mat){
+OCL_TEST_P(Kmeans, Mat){
 
     if(flags & KMEANS_USE_INITIAL_LABELS)
     {

modules/ocl/test/test_match_template.cpp

@@ -70,7 +70,7 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::Size, TemplateSize, Channels, TemplateMetho
     }
 };
 
-TEST_P(MatchTemplate8U, Accuracy)
+OCL_TEST_P(MatchTemplate8U, Accuracy)
 {
     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn), 0, 255);
     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn), 0, 255);
@@ -103,7 +103,7 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::Size, TemplateSize, Channels, TemplateMeth
     }
 };
 
-TEST_P(MatchTemplate32F, Accuracy)
+OCL_TEST_P(MatchTemplate32F, Accuracy)
 {
     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn), 0, 255);
     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn), 0, 255);

modules/ocl/test/test_matrix_operation.cpp

@@ -126,7 +126,7 @@ PARAM_TEST_CASE(ConvertToTestBase, MatType, MatType, int, bool)
 
 typedef ConvertToTestBase ConvertTo;
 
-TEST_P(ConvertTo, Accuracy)
+OCL_TEST_P(ConvertTo, Accuracy)
 {
     if((src_depth == CV_64F || dst_depth == CV_64F) &&
             !cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@@ -219,7 +219,7 @@ PARAM_TEST_CASE(CopyToTestBase, MatType, int, bool)
 
 typedef CopyToTestBase CopyTo;
 
-TEST_P(CopyTo, Without_mask)
+OCL_TEST_P(CopyTo, Without_mask)
 {
     if((src.depth() == CV_64F) &&
             !cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@@ -237,7 +237,7 @@ TEST_P(CopyTo, Without_mask)
     }
 }
 
-TEST_P(CopyTo, With_mask)
+OCL_TEST_P(CopyTo, With_mask)
 {
     if(src.depth() == CV_64F &&
         !cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@@ -331,7 +331,7 @@ PARAM_TEST_CASE(SetToTestBase, MatType, int, bool)
 
 typedef SetToTestBase SetTo;
 
-TEST_P(SetTo, Without_mask)
+OCL_TEST_P(SetTo, Without_mask)
 {
     if(depth == CV_64F &&
             !cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@@ -349,7 +349,7 @@ TEST_P(SetTo, Without_mask)
     }
 }
 
-TEST_P(SetTo, With_mask)
+OCL_TEST_P(SetTo, With_mask)
 {
     if(depth == CV_64F &&
             !cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))
@@ -417,7 +417,7 @@ PARAM_TEST_CASE(convertC3C4, MatType, bool)
     }
 };
 
-TEST_P(convertC3C4, Accuracy)
+OCL_TEST_P(convertC3C4, Accuracy)
 {
     if(depth == CV_64F &&
         !cv::ocl::Context::getContext()->supportsFeature(cv::ocl::FEATURE_CL_DOUBLE))

modules/ocl/test/test_ml.cpp

@@ -44,12 +44,16 @@
 //M*/
 
 #include "test_precomp.hpp"
+
 #ifdef HAVE_OPENCL
+
 using namespace cv;
 using namespace cv::ocl;
 using namespace cvtest;
 using namespace testing;
+
 ///////K-NEAREST NEIGHBOR//////////////////////////
+
 static void genTrainData(cv::RNG& rng, Mat& trainData, int trainDataRow, int trainDataCol,
                          Mat& trainLabel = Mat().setTo(Scalar::all(0)), int nClasses = 0)
 {
@@ -80,7 +84,7 @@ PARAM_TEST_CASE(KNN, int, Size, int, bool)
     }
 };
 
-TEST_P(KNN, Accuracy)
+OCL_TEST_P(KNN, Accuracy)
 {
     Mat trainData, trainLabels;
     const int trainDataRow = 500;
@@ -118,10 +122,14 @@ TEST_P(KNN, Accuracy)
         EXPECT_MAT_NEAR(Mat(best_label_ocl), best_label_cpu, 0.0);
     }
 }
+
 INSTANTIATE_TEST_CASE_P(OCL_ML, KNN, Combine(Values(6, 5), Values(Size(200, 400), Size(300, 600)),
     Values(4, 3), Values(false, true)));
 
 ////////////////////////////////SVM/////////////////////////////////////////////////
+
+#ifdef HAVE_CLAMDBLAS
+
 PARAM_TEST_CASE(SVM_OCL, int, int, int)
 {
     cv::Size size;
@@ -193,7 +201,8 @@ PARAM_TEST_CASE(SVM_OCL, int, int, int)
         labels_predict.convertTo(labels_predict, CV_32FC1);
     }
 };
-TEST_P(SVM_OCL, Accuracy)
+
+OCL_TEST_P(SVM_OCL, Accuracy)
 {
     CvSVMParams params;
     params.degree = 0.4;
@@ -289,11 +298,15 @@ TEST_P(SVM_OCL, Accuracy)
         }
     }
 }
+
 // TODO FIXIT: CvSVM::EPS_SVR case is crashed inside CPU implementation
 // Anonymous enums are not supported well so cast them to 'int'
+
 INSTANTIATE_TEST_CASE_P(OCL_ML, SVM_OCL, testing::Combine(
                             Values((int)CvSVM::LINEAR, (int)CvSVM::POLY, (int)CvSVM::RBF, (int)CvSVM::SIGMOID),
                             Values((int)CvSVM::C_SVC, (int)CvSVM::NU_SVC, (int)CvSVM::ONE_CLASS, (int)CvSVM::NU_SVR),
                             Values(2, 3, 4)
                         ));
+#endif // HAVE_CLAMDBLAS
+
 #endif // HAVE_OPENCL

modules/ocl/test/test_moments.cpp

@@ -35,7 +35,7 @@ PARAM_TEST_CASE(MomentsTest, MatType, bool)
 };
 
 
-TEST_P(MomentsTest, Mat)
+OCL_TEST_P(MomentsTest, Mat)
 {
     bool binaryImage = 0;
 

modules/ocl/test/test_objdetect.cpp

@@ -66,7 +66,7 @@ PARAM_TEST_CASE(HOG, Size, int)
     }
 };
 
-TEST_P(HOG, GetDescriptors)
+OCL_TEST_P(HOG, GetDescriptors)
 {
     // Convert image
     Mat img;
@@ -112,7 +112,7 @@ TEST_P(HOG, GetDescriptors)
     EXPECT_MAT_SIMILAR(down_descriptors, cpu_descriptors, 1e-2);
 }
 
-TEST_P(HOG, Detect)
+OCL_TEST_P(HOG, Detect)
 {
     // Convert image
     Mat img;
@@ -216,7 +216,7 @@ PARAM_TEST_CASE(Haar, int, CascadeName)
     }
 };
 
-TEST_P(Haar, FaceDetect)
+OCL_TEST_P(Haar, FaceDetect)
 {
     MemStorage storage(cvCreateMemStorage(0));
     CvSeq *_objects;
@@ -234,7 +234,7 @@ TEST_P(Haar, FaceDetect)
     EXPECT_LT(checkRectSimilarity(img.size(), faces, oclfaces), 1.0);
 }
 
-TEST_P(Haar, FaceDetectUseBuf)
+OCL_TEST_P(Haar, FaceDetectUseBuf)
 {
     ocl::OclCascadeClassifierBuf cascadebuf;
     ASSERT_TRUE(cascadebuf.load(cascadeName)) << "could not load classifier cascade for FaceDetectUseBuf!";

modules/ocl/test/test_optflow.cpp

@@ -70,7 +70,7 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, MinDistance)
     }
 };
 
-TEST_P(GoodFeaturesToTrack, Accuracy)
+OCL_TEST_P(GoodFeaturesToTrack, Accuracy)
 {
     cv::Mat frame = readImage("gpu/opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame.empty());
@@ -111,7 +111,7 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
     ASSERT_LE(bad_ratio, 0.01);
 }
 
-TEST_P(GoodFeaturesToTrack, EmptyCorners)
+OCL_TEST_P(GoodFeaturesToTrack, EmptyCorners)
 {
     int maxCorners = 1000;
     double qualityLevel = 0.01;
@@ -141,7 +141,7 @@ PARAM_TEST_CASE(TVL1, bool)
 
 };
 
-TEST_P(TVL1, Accuracy)
+OCL_TEST_P(TVL1, Accuracy)
 {
     cv::Mat frame0 = readImage("gpu/opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame0.empty());
@@ -182,7 +182,7 @@ PARAM_TEST_CASE(Sparse, bool, bool)
     }
 };
 
-TEST_P(Sparse, Mat)
+OCL_TEST_P(Sparse, Mat)
 {
     cv::Mat frame0 = readImage("gpu/opticalflow/rubberwhale1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
     ASSERT_FALSE(frame0.empty());
@@ -295,7 +295,7 @@ PARAM_TEST_CASE(Farneback, PyrScale, PolyN, FarnebackOptFlowFlags, UseInitFlow)
     }
 };
 
-TEST_P(Farneback, Accuracy)
+OCL_TEST_P(Farneback, Accuracy)
 {
     cv::Mat frame0 = readImage("gpu/opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(frame0.empty());

modules/ocl/test/test_pyramids.cpp

@@ -74,7 +74,7 @@ PARAM_TEST_CASE(PyrBase, MatType, int)
 
 typedef PyrBase PyrDown;
 
-TEST_P(PyrDown, Mat)
+OCL_TEST_P(PyrDown, Mat)
 {
     for (int j = 0; j < LOOP_TIMES; j++)
     {
@@ -97,7 +97,7 @@ INSTANTIATE_TEST_CASE_P(OCL_ImgProc, PyrDown, Combine(
 
 typedef PyrBase PyrUp;
 
-TEST_P(PyrUp, Accuracy)
+OCL_TEST_P(PyrUp, Accuracy)
 {
     for (int j = 0; j < LOOP_TIMES; j++)
     {

modules/ocl/test/test_sort.cpp

@@ -229,7 +229,7 @@ PARAM_TEST_CASE(SortByKey, InputSize, MatType, MatType, SortMethod, IsGreaterTha
     }
 };
 
-TEST_P(SortByKey, Accuracy)
+OCL_TEST_P(SortByKey, Accuracy)
 {
     using namespace cv;
     ocl::oclMat oclmat_key(mat_key);

modules/ocl/test/test_split_merge.cpp

@@ -139,7 +139,7 @@ PARAM_TEST_CASE(MergeTestBase, MatType, int, bool)
 
 struct Merge : MergeTestBase {};
 
-TEST_P(Merge, Accuracy)
+OCL_TEST_P(Merge, Accuracy)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {
@@ -238,7 +238,7 @@ PARAM_TEST_CASE(SplitTestBase, MatType, int, bool)
 
 struct Split : SplitTestBase {};
 
-TEST_P(Split, Accuracy)
+OCL_TEST_P(Split, Accuracy)
 {
     for(int j = 0; j < LOOP_TIMES; j++)
     {

modules/ocl/test/utility.hpp

@@ -42,7 +42,7 @@
 #ifndef __OPENCV_TEST_UTILITY_HPP__
 #define __OPENCV_TEST_UTILITY_HPP__
 
-#define LOOP_TIMES 10
+#define LOOP_TIMES 1
 
 #define MWIDTH 256
 #define MHEIGHT 256
@@ -254,4 +254,50 @@ CV_FLAGS(GemmFlags, GEMM_1_T, GEMM_2_T, GEMM_3_T);
 CV_FLAGS(WarpFlags, INTER_NEAREST, INTER_LINEAR, INTER_CUBIC, WARP_INVERSE_MAP)
 CV_FLAGS(DftFlags, DFT_INVERSE, DFT_SCALE, DFT_ROWS, DFT_COMPLEX_OUTPUT, DFT_REAL_OUTPUT)
 
+# define OCL_TEST_P(test_case_name, test_name) \
+    class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : \
+        public test_case_name { \
+    public: \
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() { } \
+        virtual void TestBody(); \
+        void OCLTestBody(); \
+    private: \
+        static int AddToRegistry() \
+        { \
+            ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+              GetTestCasePatternHolder<test_case_name>(\
+                  #test_case_name, __FILE__, __LINE__)->AddTestPattern(\
+                      #test_case_name, \
+                      #test_name, \
+                      new ::testing::internal::TestMetaFactory< \
+                          GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
+            return 0; \
+        } \
+    \
+        static int gtest_registering_dummy_; \
+        GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
+    }; \
+    \
+    int GTEST_TEST_CLASS_NAME_(test_case_name, \
+                             test_name)::gtest_registering_dummy_ = \
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
+    \
+    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() \
+    { \
+        try \
+        { \
+            OCLTestBody(); \
+        } \
+        catch (const cv::Exception & ex) \
+        { \
+            if (ex.code != CV_OpenCLDoubleNotSupported) \
+               throw; \
+            else \
+                std::cout << "Test skipped (selected device does not support double)" << std::endl; \
+        } \
+    } \
+    \
+    void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::OCLTestBody()
+
 #endif // __OPENCV_TEST_UTILITY_HPP__