mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
198 lines
8.2 KiB
198 lines
8.2 KiB
/*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
|
|
|