merged ocl module from ocl branch (it's not quite usable yet; at least on Mac)

CMakeLists.txt

@@ -139,6 +139,7 @@ OCV_OPTION(WITH_VIDEOINPUT     "Build HighGUI with DirectShow support"       ON
 OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
 OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_CLP            "Include Clp support (EPL)"                   OFF)
+OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS) )
 
 # OpenCV build components
 # ===================================================
@@ -389,6 +390,13 @@ else()
   SET(CAN_BUILD_ANDROID_PROJECTS FALSE)
 endif()
 
+# --- OpenCL ---
+if(WITH_OPENCL)
+  include(cmake/OpenCVDetectOpenCL.cmake REQUIRED)
+  if(OPENCL_FOUND)
+    set(HAVE_OPENCL 1)
+  endif()
+endif()
 
 # ----------------------------------------------------------------------------
 # Solution folders:
@@ -715,6 +723,8 @@ if(DEFINED WITH_CUDA)
   status("    Use Cuda:"  HAVE_CUDA  THEN "YES (ver ${CUDA_VERSION_STRING})" ELSE NO)
 endif(DEFINED WITH_CUDA)
 
+status("    Use OpenCL:"  HAVE_OPENCL  THEN YES ELSE NO)
+
 status("    Use Eigen:" HAVE_EIGEN THEN "YES (ver ${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION})" ELSE NO)
 status("    Use Clp:"   HAVE_CLP   THEN YES ELSE NO)
 

cmake/OpenCVDetectOpenCL.cmake

+if(APPLE)
+    set(OPENCL_FOUND YES)
+    set(OPENCL_LIBRARIES "-framework OpenCL")
+else()
+    find_package(OpenCL)
+
+    # Try AMD/ATI Stream SDK
+    if (NOT OPENCL_FOUND)
+        set(ENV_AMDSTREAMSDKROOT $ENV{AMDAPPSDKROOT})
+        set(ENV_OPENCLROOT $ENV{OPENCLROOT})
+        set(ENV_CUDA_PATH $ENV{CUDA_PATH})
+        if(ENV_AMDSTREAMSDKROOT)
+            set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_AMDSTREAMSDKROOT}/include)
+            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDSTREAMSDKROOT}/lib/x86)
+            else()
+                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_AMDSTREAMSDKROOT}/lib/x86_64)
+            endif()
+        elif(ENV_CUDAPATH AND WIN32)
+            set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_CUDA_PATH}/include)
+            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_CUDA_PATH}/lib/Win32)
+            else()
+                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} ${ENV_CUDA_PATH}/lib/x64)
+            endif()
+        elif(ENV_OPENCLROOT AND UNIX)
+            set(OPENCL_INCLUDE_SEARCH_PATH ${ENV_OPENCLROOT}/inc)
+            if(CMAKE_SIZEOF_VOID_P EQUAL 4)
+                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib)
+            else()
+                set(OPENCL_LIB_SEARCH_PATH ${OPENCL_LIB_SEARCH_PATH} /usr/lib64)
+            endif()
+        endif()
+    
+        if(OPENCL_INCLUDE_SEARCH_PATH)
+            find_path(OPENCL_INCLUDE_DIR
+                NAMES CL/cl.h OpenCL/cl.h
+                PATHS ${OPENCL_INCLUDE_SEARCH_PATH}
+                NO_DEFAULT_PATH)
+        else()
+            find_path(OPENCL_INCLUDE_DIR
+                NAMES CL/cl.h OpenCL/cl.h)
+        endif()
+    
+        if(OPENCL_LIB_SEARCH_PATH)
+            find_library(OPENCL_LIBRARY NAMES OpenCL PATHS ${OPENCL_LIB_SEARCH_PATH} NO_DEFAULT_PATH)
+        else()
+            find_library(OPENCL_LIBRARY NAMES OpenCL PATHS ${OPENCL_LIB_SEARCH_PATH} NO_DEFAULT_PATH)
+        endif()
+
+        include(FindPackageHandleStandardArgs)
+        find_package_handle_standard_args(
+          OPENCL
+          DEFAULT_MSG
+          OPENCL_LIBRARY OPENCL_INCLUDE_DIR
+          )
+
+        if(OPENCL_FOUND)
+            set(OPENCL_LIBRARIES ${OPENCL_LIBRARY})
+        else()
+            set(OPENCL_LIBRARIES)
+        endif()
+    endif()
+endif()

cmake/templates/cvconfig.h.cmake

@@ -172,6 +172,9 @@
 /* NVidia Cuda Runtime API*/
 #cmakedefine HAVE_CUDA
 
+/* OpenCL Support */
+#cmakedefine HAVE_OPENCL
+
 /* NVidia Cuda Fast Fourier Transform (FFT) API*/
 #cmakedefine HAVE_CUFFT
 

modules/ocl/CMakeLists.txt

+# Will be modified later 
+if(NOT HAVE_OPENCL)
+  ocv_module_disable(ocl)
+endif()
+
+set(the_description "OpenCL-accelerated Computer Vision")
+ocv_add_module(ocl opencv_core opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree)
+
+ocv_module_include_directories()
+
+file(GLOB CL_FILES "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels/*.cl")
+set(kernels_cpp "${CMAKE_CURRENT_BINARY_DIR}/kernels.cpp")
+set(cl2cpp_script "${CMAKE_CURRENT_SOURCE_DIR}/cl2cpp.py")
+
+add_custom_command(
+   OUTPUT ${kernels_cpp}
+   COMMAND ${PYTHON_EXECUTABLE} ${cl2cpp_script} "${CMAKE_CURRENT_SOURCE_DIR}/src/kernels" ${kernels_cpp}
+   DEPENDS ${CL_FILES} ${cl2cpp_script})
+
+file(GLOB lib_hdrs     "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
+file(GLOB lib_srcs     "src/*.cpp")
+file(GLOB lib_int_hdrs "src/*.h*")
+
+source_group("Include"   FILES ${lib_hdrs})
+source_group("Src\\Host" FILES ${lib_srcs} ${lib_int_hdrs} ${kernels_cpp})
+
+if (HAVE_OPENCL)
+  set(ocl_link_libs ${OPENCL_LIBRARIES})
+  if(OPENCL_INCLUDE_DIR)
+      ocv_include_directories(${OPENCL_INCLUDE_DIR})
+  endif()
+endif()
+
+ocv_set_module_sources(
+    HEADERS ${lib_hdrs}
+    SOURCES ${lib_int_hdrs} ${lib_srcs}
+    )
+    
+set(OPENCV_MODULE_opencv_ocl_SOURCES ${OPENCV_MODULE_opencv_ocl_SOURCES} ${kernels_cpp})
+ocv_create_module(${ocl_link_libs})
+
+install(FILES ${lib_hdrs}
+    DESTINATION include/opencv2/${name}
+    COMPONENT main)
+
+ocv_add_precompiled_headers(${the_module})
+
+################################################################################################################
+################################      OpenCL Module Tests     ##################################################
+################################################################################################################
+file(GLOB test_srcs "test/*.cpp")
+file(GLOB test_hdrs "test/*.hpp" "test/*.h")
+
+ocv_add_accuracy_tests(FILES "Include" ${test_hdrs}
+                       FILES "Src" ${test_srcs})
+################################################################################################################
+################################   OpenCL Module Performance  ##################################################
+################################################################################################################
+#file(GLOB perf_srcs "perf/*.cpp")
+#file(GLOB perf_hdrs "perf/*.hpp" "perf/*.h")
+
+#ocv_add_perf_tests(FILES "Include" ${perf_hdrs}
+#                       FILES "Src" ${perf_srcs})

modules/ocl/cl2cpp.py

+import os, os.path, sys, glob
+
+indir = sys.argv[1]
+outname = sys.argv[2]
+#indir = "/Users/vp/work/ocv/opencv/modules/ocl/src/kernels"
+#outname = "/Users/vp/work/ocv.build/xcode/modules/ocl/kernels.cpp"
+
+try:
+    os.mkdir(os.path.dirname(outname))
+except OSError:
+    pass
+
+cl_list = glob.glob(os.path.join(indir, "*.cl"))
+kfile = open(outname, "wt")
+
+kfile.write("""// This file is auto-generated. Do not edit!
+#include "precomp.hpp"
+namespace cv
+{
+namespace ocl
+{
+""")
+
+for cl in cl_list:
+    cl_file = open(cl, "rt")
+    cl_filename = os.path.basename(cl)
+    cl_filename = cl_filename[:cl_filename.rfind(".")]
+    kfile.write("const char* %s=" % cl_filename)
+    state = 0
+    
+    for cl_line in cl_file.readlines():
+        l = cl_line.strip()
+        # skip the leading comments
+        if l.startswith("//") and l.find("*/") < 0:
+            if state == 0:
+                state = 1
+        else:
+            if state == 1 or l.find("*/") >= 0:
+                state = 2
+        
+        if state == 1:
+            continue
+        
+        l = l.replace("\\", "\\\\")
+        l = l.replace("\r", "")
+        l = l.replace("\"", "\\\"")
+        l = l.replace("\t", "  ")
+        kfile.write("\"%s\\n\"\n" % l)
+    kfile.write(";\n")
+    cl_file.close()
+
+kfile.write("""}
+}
+""")
+kfile.close()

modules/ocl/doc/introduction.rst

+OpenCL Module Introduction
+==========================
+
+.. highlight:: cpp
+
+General Information
+-------------------
+
+The OpenCV OCL module is a set of classes and functions to utilize OpenCL compatible device. It should support any device compatible with OpenCL 1.1. The module includes utility functions, low-level vision primitives, and a few high-level algorithms ready to be used in the end-user applications.
+
+The OpenCV OCL module is designed as a host-level API plus device-level kernels. The device-level kernels are converted to text string and are compiled at runtime, so it need OpenCL runtime support. To correctly run the OpenCV OCL module, make sure you have OpenCL runtime provided by your device vendor, which is device driver normally.
+
+The OpenCV OCL module is designed for ease of use and does not require any knowledge of OpenCL. Though, such a knowledge will certainly be useful to handle non-trivial cases or achieve the highest performance. It is helpful to understand the cost of various operations, what the module does, what the preferred data formats are, and so on. Since there is data transfer between OpenCL host and OpenCL device, for better performance it's recommended to copy data once to the OpenCL host memory (i.e. copy ``cv::Mat`` to ``cv::ocl::OclMat``), then call several ``cv::ocl`` functions and then copy the result back to CPU memory, rather than do forward and backward transfer for each OCL function.
+
+To enable OCL support, configure OpenCV using CMake with the option ``WITH\_OPENCL=ON``. If the option is passed and if OpenCL SDK is installed (e.g. on MacOSX it's always the case), the full-featured OpenCV OCL module will be built. Otherwise, the module will not be built.
+
+Right now, the user should define the ``cv::ocl::Info`` class in the application and call ``cv::ocl::getDevice`` before any ``cv::ocl::<func>``. This operation initialize OpenCL runtime and set the first found device as computing device. If there is more than one device and you want to use non-default device, you should call ``cv::ocl::setDevice``.
+
+In the current version, all the threads share the same context and device so the multi-devices are not supported. This is to be fixed in future releases.

modules/ocl/doc/ocl.rst

+************************************
+ocl. OpenCL-accelerated Computer Vision
+************************************
+
+.. toctree::
+    :maxdepth: 1
+
+    introduction
+    initalization_and_information
+    data_structures
+    operations_on_matrices
+    per_element_operations
+    image_processing
+    matrix_reductions
+    object_detection
+    feature_detection_and_description
+    image_filtering
+    camera_calibration_and_3d_reconstruction
+    video

modules/ocl/doc/structures_and_functions.rst

+Data Structures and Functions
+=============================
+
+.. highlight:: cpp
+
+ocl::Info
+---------
+.. ocv:class:: ocl::Info
+
+this class should be maintained by the user and be passed to getDevice
+
+ocl::getDevice
+------------------
+Returns the list of devices
+
+.. ocv:function:: int ocl::getDevice(std::vector<Info>& oclinfo, int devicetype = CVCL_DEVICE_TYPE_GPU)
+
+    :param oclinfo: Output vector of ``ocl::Info`` structures
+    
+    :param devicetype: One of ``CVCL_DEVICE_TYPE_GPU``, ``CVCL_DEVICE_TYPE_CPU`` or ``CVCL_DEVICE_TYPE_DEFAULT``.
+    
+the function must be called before any other ``cv::ocl`` functions; it initializes ocl runtime.
+

modules/ocl/src/binarycaching.hpp

+/*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
+//
+// 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 oclMaterials 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*/
+
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace cv::ocl;
+using namespace std;
+using std::cout;
+using std::endl;
+
+#if !defined (HAVE_OPENCL)
+namespace cv
+{
+    namespace ocl
+    {
+        //nothing
+    }//namespace ocl
+}//namespace cv
+
+#else /* !defined (HAVE_OPENCL) */
+
+namespace cv
+{
+    namespace ocl
+    {
+        class ProgramCache
+        {
+        protected:
+            ProgramCache();
+            friend class auto_ptr<ProgramCache>;
+            static auto_ptr<ProgramCache> programCache;
+
+        public:
+            ~ProgramCache();
+            static ProgramCache *getProgramCache()
+            {
+                if( NULL == programCache.get())
+                    programCache.reset(new ProgramCache());
+                return programCache.get();
+            }
+
+            //lookup the binary given the file name
+            cl_program progLookup(string srcsign);
+
+            //add program to the cache
+            void addProgram(string srcsign, cl_program program);
+            void releaseProgram();
+
+            map <string, cl_program> codeCache;
+            unsigned int cacheSize;
+            //The presumed watermark for the cache volume (256MB). Is it enough?
+            //We may need more delicate algorithms when necessary later.
+            //Right now, let's just leave it along.
+            static const unsigned MAX_PROG_CACHE_SIZE = 1024;
+        };
+
+    }//namespace ocl
+
+}//namespace cv
+#endif

modules/ocl/src/color.cpp

+/*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
+//    Wang Weiyan, wangweiyanster@gmail.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 oclMaterials 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*/
+
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace cv::ocl;
+
+#if !defined (HAVE_OPENCL)
+
+void cv::ocl::cvtColor(const oclMat &, oclMat &, int, int)
+{
+    throw_nogpu();
+}
+void cv::ocl::cvtColor(const oclMat &, oclMat &, int, int, const Stream &)
+{
+    throw_nogpu();
+}
+
+#else /* !defined (HAVE_OPENCL) */
+#ifndef CV_DESCALE
+#define CV_DESCALE(x, n) (((x) + (1 << ((n)-1))) >> (n))
+#endif
+
+#ifndef FLT_EPSILON
+#define FLT_EPSILON     1.192092896e-07F
+#endif
+
+namespace cv
+{
+    namespace ocl
+    {
+        extern const char *cvt_color;
+    }
+}
+
+namespace
+{
+    void RGB2Gray_caller(const oclMat &src, oclMat &dst, int bidx)
+    {
+        vector<pair<size_t , const void *> > args;
+        int channels = src.channels();
+        char build_options[50];
+        //printf("depth:%d,channels:%d,bidx:%d\n",src.depth(),src.channels(),bidx);
+        sprintf(build_options, "-D DEPTH_%d", src.depth());
+        args.push_back( make_pair( sizeof(cl_int) , (void *)&src.cols));
+        args.push_back( make_pair( sizeof(cl_int) , (void *)&src.rows));
+        args.push_back( make_pair( sizeof(cl_int) , (void *)&src.step));
+        args.push_back( make_pair( sizeof(cl_int) , (void *)&dst.step));
+        args.push_back( make_pair( sizeof(cl_int) , (void *)&channels));
+        args.push_back( make_pair( sizeof(cl_int) , (void *)&bidx));
+        args.push_back( make_pair( sizeof(cl_mem) , (void *)&src.data));
+        args.push_back( make_pair( sizeof(cl_mem) , (void *)&dst.data));
+        size_t gt[3] = {src.cols, src.rows, 1}, lt[3] = {16, 16, 1};
+        openCLExecuteKernel(src.clCxt, &cvt_color, "RGB2Gray", gt, lt, args, -1, -1, build_options);
+    }
+    void cvtColor_caller(const oclMat &src, oclMat &dst, int code, int dcn)
+    {
+        Size sz = src.size();
+        int scn = src.channels(), depth = src.depth(), bidx;
+
+        CV_Assert(depth == CV_8U || depth == CV_16U);
+
+        switch (code)
+        {
+            /*
+            case CV_BGR2BGRA: case CV_RGB2BGRA: case CV_BGRA2BGR:
+            case CV_RGBA2BGR: case CV_RGB2BGR: case CV_BGRA2RGBA:
+            case CV_BGR2BGR565: case CV_BGR2BGR555: case CV_RGB2BGR565: case CV_RGB2BGR555:
+            case CV_BGRA2BGR565: case CV_BGRA2BGR555: case CV_RGBA2BGR565: case CV_RGBA2BGR555:
+            case CV_BGR5652BGR: case CV_BGR5552BGR: case CV_BGR5652RGB: case CV_BGR5552RGB:
+            case CV_BGR5652BGRA: case CV_BGR5552BGRA: case CV_BGR5652RGBA: case CV_BGR5552RGBA:
+            */
+        case CV_BGR2GRAY:
+        case CV_BGRA2GRAY:
+        case CV_RGB2GRAY:
+        case CV_RGBA2GRAY:
+        {
+            CV_Assert(scn == 3 || scn == 4);
+            bidx = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2;
+            dst.create(sz, CV_MAKETYPE(depth, 1));
+            RGB2Gray_caller(src, dst, bidx);
+            break;
+        }
+        /*
+        case CV_BGR5652GRAY: case CV_BGR5552GRAY:
+        case CV_GRAY2BGR: case CV_GRAY2BGRA:
+        case CV_GRAY2BGR565: case CV_GRAY2BGR555:
+        case CV_BGR2YCrCb: case CV_RGB2YCrCb:
+        case CV_BGR2YUV: case CV_RGB2YUV:
+        case CV_YCrCb2BGR: case CV_YCrCb2RGB:
+        case CV_YUV2BGR: case CV_YUV2RGB:
+        case CV_BGR2XYZ: case CV_RGB2XYZ:
+        case CV_XYZ2BGR: case CV_XYZ2RGB:
+        case CV_BGR2HSV: case CV_RGB2HSV: case CV_BGR2HSV_FULL: case CV_RGB2HSV_FULL:
+        case CV_BGR2HLS: case CV_RGB2HLS: case CV_BGR2HLS_FULL: case CV_RGB2HLS_FULL:
+        case CV_HSV2BGR: case CV_HSV2RGB: case CV_HSV2BGR_FULL: case CV_HSV2RGB_FULL:
+        case CV_HLS2BGR: case CV_HLS2RGB: case CV_HLS2BGR_FULL: case CV_HLS2RGB_FULL:
+        */
+        default:
+            CV_Error( CV_StsBadFlag, "Unknown/unsupported color conversion code" );
+        }
+    }
+}
+
+void cv::ocl::cvtColor(const oclMat &src, oclMat &dst, int code, int dcn)
+{
+    cvtColor_caller(src, dst, code, dcn);
+}
+
+#endif /* !defined (HAVE_OPENCL) */

modules/ocl/src/error.cpp

+/*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
+//
+// 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 oclMaterials 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*/
+#include "precomp.hpp"
+
+using namespace cv;
+using namespace cv::ocl;
+
+#if !defined (HAVE_OPENCL)
+
+// do nothing
+
+#else /* !defined (HAVE_OPENCL) */
+
+namespace cv
+{
+    namespace ocl
+    {
+
+        const char *getOpenCLErrorString( int err )
+        {
+            switch(err)
+            {
+            case CL_DEVICE_NOT_FOUND:
+                return "CL_DEVICE_NOT_FOUND";
+            case CL_DEVICE_NOT_AVAILABLE:
+                return "CL_DEVICE_NOT_AVAILABLE";
+            case CL_COMPILER_NOT_AVAILABLE:
+                return "CL_COMPILER_NOT_AVAILABLE";
+            case CL_MEM_OBJECT_ALLOCATION_FAILURE:
+                return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+            case CL_OUT_OF_RESOURCES:
+                return "CL_OUT_OF_RESOURCES";
+            case CL_OUT_OF_HOST_MEMORY:
+                return "CL_OUT_OF_HOST_MEMORY";
+            case CL_PROFILING_INFO_NOT_AVAILABLE:
+                return "CL_PROFILING_INFO_NOT_AVAILABLE";
+            case CL_MEM_COPY_OVERLAP:
+                return "CL_MEM_COPY_OVERLAP";
+            case CL_IMAGE_FORMAT_MISMATCH:
+                return "CL_IMAGE_FORMAT_MISMATCH";
+            case CL_IMAGE_FORMAT_NOT_SUPPORTED:
+                return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+            case CL_BUILD_PROGRAM_FAILURE:
+                return "CL_BUILD_PROGRAM_FAILURE";
+            case CL_MAP_FAILURE:
+                return "CL_MAP_FAILURE";
+            case CL_MISALIGNED_SUB_BUFFER_OFFSET:
+                return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
+            case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:
+                return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
+            case CL_INVALID_VALUE:
+                return "CL_INVALID_VALUE";
+            case CL_INVALID_DEVICE_TYPE:
+                return "CL_INVALID_DEVICE_TYPE";
+            case CL_INVALID_PLATFORM:
+                return "CL_INVALID_PLATFORM";
+            case CL_INVALID_DEVICE:
+                return "CL_INVALID_DEVICE";
+            case CL_INVALID_CONTEXT:
+                return "CL_INVALID_CONTEXT";
+            case CL_INVALID_QUEUE_PROPERTIES:
+                return "CL_INVALID_QUEUE_PROPERTIES";
+            case CL_INVALID_COMMAND_QUEUE:
+                return "CL_INVALID_COMMAND_QUEUE";
+            case CL_INVALID_HOST_PTR:
+                return "CL_INVALID_HOST_PTR";
+            case CL_INVALID_MEM_OBJECT:
+                return "CL_INVALID_MEM_OBJECT";
+            case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR:
+                return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+            case CL_INVALID_IMAGE_SIZE:
+                return "CL_INVALID_IMAGE_SIZE";
+            case CL_INVALID_SAMPLER:
+                return "CL_INVALID_SAMPLER";
+            case CL_INVALID_BINARY:
+                return "CL_INVALID_BINARY";
+            case CL_INVALID_BUILD_OPTIONS:
+                return "CL_INVALID_BUILD_OPTIONS";
+            case CL_INVALID_PROGRAM:
+                return "CL_INVALID_PROGRAM";
+            case CL_INVALID_PROGRAM_EXECUTABLE:
+                return "CL_INVALID_PROGRAM_EXECUTABLE";
+            case CL_INVALID_KERNEL_NAME:
+                return "CL_INVALID_KERNEL_NAME";
+            case CL_INVALID_KERNEL_DEFINITION:
+                return "CL_INVALID_KERNEL_DEFINITION";
+            case CL_INVALID_KERNEL:
+                return "CL_INVALID_KERNEL";
+            case CL_INVALID_ARG_INDEX:
+                return "CL_INVALID_ARG_INDEX";
+            case CL_INVALID_ARG_VALUE:
+                return "CL_INVALID_ARG_VALUE";
+            case CL_INVALID_ARG_SIZE:
+                return "CL_INVALID_ARG_SIZE";
+            case CL_INVALID_KERNEL_ARGS:
+                return "CL_INVALID_KERNEL_ARGS";
+            case CL_INVALID_WORK_DIMENSION:
+                return "CL_INVALID_WORK_DIMENSION";
+            case CL_INVALID_WORK_GROUP_SIZE:
+                return "CL_INVALID_WORK_GROUP_SIZE";
+            case CL_INVALID_WORK_ITEM_SIZE:
+                return "CL_INVALID_WORK_ITEM_SIZE";
+            case CL_INVALID_GLOBAL_OFFSET:
+                return "CL_INVALID_GLOBAL_OFFSET";
+            case CL_INVALID_EVENT_WAIT_LIST:
+                return "CL_INVALID_EVENT_WAIT_LIST";
+            case CL_INVALID_EVENT:
+                return "CL_INVALID_EVENT";
+            case CL_INVALID_OPERATION:
+                return "CL_INVALID_OPERATION";
+            case CL_INVALID_GL_OBJECT:
+                return "CL_INVALID_GL_OBJECT";
+            case CL_INVALID_BUFFER_SIZE:
+                return "CL_INVALID_BUFFER_SIZE";
+            case CL_INVALID_MIP_LEVEL:
+                return "CL_INVALID_MIP_LEVEL";
+            case CL_INVALID_GLOBAL_WORK_SIZE:
+                return "CL_INVALID_GLOBAL_WORK_SIZE";
+                //case CL_INVALID_PROPERTY:
+                //	return "CL_INVALID_PROPERTY";
+                //case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR:
+                //	return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
+                //case CL_PLATFORM_NOT_FOUND_KHR:
+                //	return "CL_PLATFORM_NOT_FOUND_KHR";
+                //	//case CL_INVALID_PROPERTY_EXT:
+                //	//    return "CL_INVALID_PROPERTY_EXT";
+                //case CL_DEVICE_PARTITION_FAILED_EXT:
+                //	return "CL_DEVICE_PARTITION_FAILED_EXT";
+                //case CL_INVALID_PARTITION_COUNT_EXT:
+                //	return "CL_INVALID_PARTITION_COUNT_EXT";
+                //default:
+                //	return "unknown error code";
+            }
+            static char buf[256];
+            sprintf(buf, "%d", err);
+            return buf;
+        }
+
+        void error(const char *error_string, const char *file, const int line, const char *func)
+        {
+            int code = CV_GpuApiCallError;
+
+            if (std::uncaught_exception())
+            {
+                const char *errorStr = cvErrorStr(code);
+                const char *function = func ? func : "unknown function";
+
+                std::cerr << "OpenCV Error: " << errorStr << "(" << error_string << ") in " << function << ", file " << file << ", line " << line;
+                std::cerr.flush();
+            }
+            else
+                cv::error( cv::Exception(code, error_string, func, file, line) );
+        }
+    }
+}
+
+#endif

modules/ocl/src/precomp.cpp

+/*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
+//
+// 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 oclMaterials 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*/
+
+#include "precomp.hpp"
+//CriticalSection cs;
+/* End of file. */