From f2df784830fcac1c56c3b8de3d32fdc8ca104720 Mon Sep 17 00:00:00 2001 From: Anatoly Baksheev Date: Mon, 15 Nov 2010 16:22:52 +0000 Subject: [PATCH] fixed error reporting in GPU module (exceptions in destructors, etc) --- modules/core/include/opencv2/core/types_c.h | 2 +- modules/core/src/system.cpp | 3 + modules/gpu/include/opencv2/gpu/gpu.hpp | 142 ++++++++++---------- modules/gpu/src/error.cpp | 95 +++++++------ modules/gpu/src/precomp.hpp | 3 +- tests/gpu/src/gputest.hpp | 4 +- 6 files changed, 134 insertions(+), 115 deletions(-) diff --git a/modules/core/include/opencv2/core/types_c.h b/modules/core/include/opencv2/core/types_c.h index 51e925cc31..2cdbed1582 100644 --- a/modules/core/include/opencv2/core/types_c.h +++ b/modules/core/include/opencv2/core/types_c.h @@ -245,7 +245,7 @@ enum { CV_StsNotImplemented= -213, /* the requested function/feature is not implemented */ CV_StsBadMemBlock= -214, /* an allocated block has been corrupted */ CV_StsAssert= -215, /* assertion failed */ - CV_GpuNotFound= -216, + CV_GpuNotSupported= -216, CV_GpuApiCallError= -217, CV_GpuNppCallError= -218 }; diff --git a/modules/core/src/system.cpp b/modules/core/src/system.cpp index c04469b0b1..c7b31c05fb 100644 --- a/modules/core/src/system.cpp +++ b/modules/core/src/system.cpp @@ -527,6 +527,9 @@ CV_IMPL const char* cvErrorStr( int status ) case CV_StsNotImplemented : return "The function/feature is not implemented"; case CV_StsBadMemBlock : return "Memory block has been corrupted"; case CV_StsAssert : return "Assertion failed"; + case CV_GpuNotSupported : return "No GPU support"; + case CV_GpuApiCallError : return "GPU API error"; + case CV_GpuNppCallError : return "NPP API error"; }; sprintf(buf, "Unknown %s code %d", status >= 0 ? "status":"error", status); diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp index 0fdec1ec90..752d4df809 100644 --- a/modules/gpu/include/opencv2/gpu/gpu.hpp +++ b/modules/gpu/include/opencv2/gpu/gpu.hpp @@ -69,7 +69,7 @@ namespace cv CV_EXPORTS void getGpuMemInfo(size_t& free, size_t& total); //////////////////////////////// Error handling //////////////////////// - + CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func); CV_EXPORTS void nppError( int err, const char *file, const int line, const char *func); @@ -83,19 +83,18 @@ namespace cv public: //! default constructor GpuMat(); - //! constructs GpuMatrix of the specified size and type - // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.) - GpuMat(int _rows, int _cols, int _type); - GpuMat(Size _size, int _type); + //! constructs GpuMatrix of the specified size and type (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.) + GpuMat(int rows, int cols, int type); + GpuMat(Size size, int type); //! constucts GpuMatrix and fills it with the specified value _s. - GpuMat(int _rows, int _cols, int _type, const Scalar& _s); - GpuMat(Size _size, int _type, const Scalar& _s); + GpuMat(int rows, int cols, int type, const Scalar& s); + GpuMat(Size size, int type, const Scalar& s); //! copy constructor GpuMat(const GpuMat& m); //! constructor for GpuMatrix headers pointing to user-allocated data - GpuMat(int _rows, int _cols, int _type, void* _data, size_t _step = Mat::AUTO_STEP); - GpuMat(Size _size, int _type, void* _data, size_t _step = Mat::AUTO_STEP); + GpuMat(int rows, int cols, int type, void* data, size_t step = Mat::AUTO_STEP); + GpuMat(Size size, int type, void* data, size_t step = Mat::AUTO_STEP); //! creates a matrix header for a part of the bigger matrix GpuMat(const GpuMat& m, const Range& rowRange, const Range& colRange); @@ -117,7 +116,7 @@ namespace cv template operator DevMem2D_() const; template operator PtrStep_() const; - //! pefroms blocking upload data to GpuMat. . + //! pefroms blocking upload data to GpuMat. void upload(const cv::Mat& m); //! upload async @@ -156,15 +155,15 @@ namespace cv //! sets every GpuMatrix element to s GpuMat& operator = (const Scalar& s); //! sets some of the GpuMatrix elements to s, according to the mask - GpuMat& setTo(const Scalar& s, const GpuMat& mask=GpuMat()); + GpuMat& setTo(const Scalar& s, const GpuMat& mask = GpuMat()); //! creates alternative GpuMatrix header for the same data, with different // number of channels and/or different number of rows. see cvReshape. - GpuMat reshape(int _cn, int _rows=0) const; + GpuMat reshape(int cn, int rows = 0) const; //! allocates new GpuMatrix data unless the GpuMatrix already has specified size and type. // previous data is unreferenced if needed. - void create(int _rows, int _cols, int _type); - void create(Size _size, int _type); + void create(int rows, int cols, int type); + void create(Size size, int type); //! decreases reference counter; // deallocate the data when reference counter reaches 0. void release(); @@ -205,12 +204,12 @@ namespace cv bool empty() const; //! returns pointer to y-th row - uchar* ptr(int y=0); - const uchar* ptr(int y=0) const; + uchar* ptr(int y = 0); + const uchar* ptr(int y = 0) const; //! template version of the above method - template _Tp* ptr(int y=0); - template const _Tp* ptr(int y=0) const; + template _Tp* ptr(int y = 0); + template const _Tp* ptr(int y = 0) const; //! matrix transposition GpuMat t() const; @@ -238,6 +237,11 @@ namespace cv uchar* dataend; }; +//#define TemplatedGpuMat // experimental now, deprecated to use +#ifdef TemplatedGpuMat + #include "GpuMat_BetaDeprecated.hpp" +#endif + //////////////////////////////// CudaMem //////////////////////////////// // CudaMem is limited cv::Mat with page locked memory allocation. // Page locked memory is only needed for async and faster coping to GPU. @@ -252,12 +256,12 @@ namespace cv CudaMem(); CudaMem(const CudaMem& m); - CudaMem(int _rows, int _cols, int _type, int _alloc_type = ALLOC_PAGE_LOCKED); - CudaMem(Size _size, int _type, int _alloc_type = ALLOC_PAGE_LOCKED); + CudaMem(int rows, int cols, int type, int _alloc_type = ALLOC_PAGE_LOCKED); + CudaMem(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED); //! creates from cv::Mat with coping data - explicit CudaMem(const Mat& m, int _alloc_type = ALLOC_PAGE_LOCKED); + explicit CudaMem(const Mat& m, int alloc_type = ALLOC_PAGE_LOCKED); ~CudaMem(); @@ -267,8 +271,8 @@ namespace cv CudaMem clone() const; //! allocates new matrix data unless the matrix already has specified size and type. - void create(int _rows, int _cols, int _type, int _alloc_type = ALLOC_PAGE_LOCKED); - void create(Size _size, int _type, int _alloc_type = ALLOC_PAGE_LOCKED); + void create(int rows, int cols, int type, int alloc_type = ALLOC_PAGE_LOCKED); + void create(Size size, int type, int alloc_type = ALLOC_PAGE_LOCKED); //! decrements reference counter and released memory if needed. void release(); @@ -362,30 +366,30 @@ namespace cv CV_EXPORTS void add(const GpuMat& a, const Scalar& sc, GpuMat& c); //! subtracts one matrix from another (c = a - b) //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types - CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c); + CV_EXPORTS void subtract(const GpuMat& a, const GpuMat& b, GpuMat& c); //! subtracts scalar from a matrix (c = a - s) //! supports CV_32FC1 and CV_32FC2 type CV_EXPORTS void subtract(const GpuMat& a, const Scalar& sc, GpuMat& c); //! computes element-wise product of the two arrays (c = a * b) //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types - CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c); + CV_EXPORTS void multiply(const GpuMat& a, const GpuMat& b, GpuMat& c); //! multiplies matrix to a scalar (c = a * s) //! supports CV_32FC1 and CV_32FC2 type CV_EXPORTS void multiply(const GpuMat& a, const Scalar& sc, GpuMat& c); //! computes element-wise quotient of the two arrays (c = a / b) //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types - CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c); + CV_EXPORTS void divide(const GpuMat& a, const GpuMat& b, GpuMat& c); //! computes element-wise quotient of matrix and scalar (c = a / s) //! supports CV_32FC1 and CV_32FC2 type CV_EXPORTS void divide(const GpuMat& a, const Scalar& sc, GpuMat& c); //! transposes the matrix //! supports only CV_8UC1 type - CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst); + CV_EXPORTS void transpose(const GpuMat& src1, GpuMat& dst); //! computes element-wise absolute difference of two arrays (c = abs(a - b)) //! supports CV_8UC1, CV_8UC4, CV_32SC1, CV_32FC1 types - CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c); + CV_EXPORTS void absdiff(const GpuMat& a, const GpuMat& b, GpuMat& c); //! computes element-wise absolute difference of array and scalar (c = abs(a - s)) //! supports only CV_32FC1 type CV_EXPORTS void absdiff(const GpuMat& a, const Scalar& s, GpuMat& c); @@ -402,7 +406,7 @@ namespace cv //! supports NORM_INF, NORM_L1, NORM_L2 //! supports only CV_8UC1 type CV_EXPORTS double norm(const GpuMat& src1, int normType=NORM_L2); - + //! computes norm of the difference between two arrays //! supports NORM_INF, NORM_L1, NORM_L2 //! supports only CV_8UC1 type @@ -454,7 +458,7 @@ namespace cv //! computes exponent of each matrix element (b = e**a) //! supports only CV_32FC1 type CV_EXPORTS void exp(const GpuMat& a, GpuMat& b); - + //! computes natural logarithm of absolute value of each matrix element: b = log(abs(a)) //! supports only CV_32FC1 type CV_EXPORTS void log(const GpuMat& a, GpuMat& b); @@ -472,7 +476,7 @@ namespace cv CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude); //! Acync version CV_EXPORTS void magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream); - + //! computes squared magnitude of each (x(i), y(i)) vector //! supports only floating-point source CV_EXPORTS void magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude); @@ -496,7 +500,7 @@ namespace cv CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees = false); //! Acync version CV_EXPORTS void polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, const Stream& stream); - + ////////////////////////////// Image processing ////////////////////////////// //! DST[x,y] = SRC[xmap[x,y],ymap[x,y]] with bilinear interpolation. @@ -544,7 +548,7 @@ namespace cv //! Supports INTER_NEAREST, INTER_LINEAR //! supports CV_8UC1, CV_8UC4 types CV_EXPORTS void resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR); - + //! warps the image using affine transformation //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC CV_EXPORTS void warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR); @@ -552,16 +556,16 @@ namespace cv //! warps the image using perspective transformation //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC CV_EXPORTS void warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR); - + //! rotate 8bit single or four channel image //! Supports INTER_NEAREST, INTER_LINEAR, INTER_CUBIC //! supports CV_8UC1, CV_8UC4 types CV_EXPORTS void rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR); - + //! copies 2D array to a larger destination array and pads borders with user-specifiable constant //! supports CV_8UC1, CV_8UC4, CV_32SC1 types CV_EXPORTS void copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar()); - + //! computes the integral image and integral for the squared image //! sum will have CV_32S type, sqsum - CV32F type //! supports only CV_8UC1 source type @@ -580,11 +584,11 @@ namespace cv //////////////////////////////// Filter Engine //////////////////////////////// /*! - The Base Class for 1D or Row-wise Filters - - This is the base class for linear or non-linear filters that process 1D data. - In particular, such filters are used for the "horizontal" filtering parts in separable filters. - */ + The Base Class for 1D or Row-wise Filters + + This is the base class for linear or non-linear filters that process 1D data. + In particular, such filters are used for the "horizontal" filtering parts in separable filters. + */ class CV_EXPORTS BaseRowFilter_GPU { public: @@ -595,11 +599,11 @@ namespace cv }; /*! - The Base Class for Column-wise Filters - - This is the base class for linear or non-linear filters that process columns of 2D arrays. - Such filters are used for the "vertical" filtering parts in separable filters. - */ + The Base Class for Column-wise Filters + + This is the base class for linear or non-linear filters that process columns of 2D arrays. + Such filters are used for the "vertical" filtering parts in separable filters. + */ class CV_EXPORTS BaseColumnFilter_GPU { public: @@ -610,10 +614,10 @@ namespace cv }; /*! - The Base Class for Non-Separable 2D Filters. - - This is the base class for linear or non-linear 2D filters. - */ + The Base Class for Non-Separable 2D Filters. + + This is the base class for linear or non-linear 2D filters. + */ class CV_EXPORTS BaseFilter_GPU { public: @@ -625,10 +629,10 @@ namespace cv }; /*! - The Base Class for Filter Engine. - - The class can be used to apply an arbitrary filtering operation to an image. - It contains all the necessary intermediate buffers. + The Base Class for Filter Engine. + + The class can be used to apply an arbitrary filtering operation to an image. + It contains all the necessary intermediate buffers. */ class CV_EXPORTS FilterEngine_GPU { @@ -711,7 +715,7 @@ namespace cv //! a synonym for normalized box filter static inline void blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1)) { boxFilter(src, dst, -1, ksize, anchor); } - + //! erodes the image (applies the local minimum operator) CV_EXPORTS void erode( const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1); @@ -733,7 +737,7 @@ namespace cv //! applies the vertical or horizontal Scharr operator to the image CV_EXPORTS void Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1); - + //! smooths the image using Gaussian filter. CV_EXPORTS void GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigma1, double sigma2 = 0); @@ -825,9 +829,9 @@ namespace cv //! the default constructor explicit StereoBeliefPropagation(int ndisp = DEFAULT_NDISP, - int iters = DEFAULT_ITERS, - int levels = DEFAULT_LEVELS, - int msg_type = CV_32F); + int iters = DEFAULT_ITERS, + int levels = DEFAULT_LEVELS, + int msg_type = CV_32F); //! the full constructor taking the number of disparities, number of BP iterations on each level, //! number of levels, truncation of data cost, data weight, @@ -836,9 +840,9 @@ namespace cv //! DiscTerm = min(disc_single_jump * fabs(f1-f2), max_disc_term) //! please see paper for more details StereoBeliefPropagation(int ndisp, int iters, int levels, - float max_data_term, float data_weight, - float max_disc_term, float disc_single_jump, - int msg_type = CV_32F); + float max_data_term, float data_weight, + float max_disc_term, float disc_single_jump, + int msg_type = CV_32F); //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair, //! if disparity is empty output type will be CV_16S else output type will be disparity.type(). @@ -886,18 +890,18 @@ namespace cv //! the default constructor explicit StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, - int iters = DEFAULT_ITERS, - int levels = DEFAULT_LEVELS, - int nr_plane = DEFAULT_NR_PLANE, - int msg_type = CV_32F); + int iters = DEFAULT_ITERS, + int levels = DEFAULT_LEVELS, + int nr_plane = DEFAULT_NR_PLANE, + int msg_type = CV_32F); //! the full constructor taking the number of disparities, number of BP iterations on each level, //! number of levels, number of active disparity on the first level, truncation of data cost, data weight, //! truncation of discontinuity cost, discontinuity single jump and minimum disparity threshold StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, - float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, - int min_disp_th = 0, - int msg_type = CV_32F); + float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, + int min_disp_th = 0, + int msg_type = CV_32F); //! the stereo correspondence operator. Finds the disparity for the specified rectified stereo pair, //! if disparity is empty output type will be CV_16S else output type will be disparity.type(). diff --git a/modules/gpu/src/error.cpp b/modules/gpu/src/error.cpp index a30679e933..c699ed33d7 100644 --- a/modules/gpu/src/error.cpp +++ b/modules/gpu/src/error.cpp @@ -54,53 +54,54 @@ using namespace cv::gpu; namespace { + #define error_entry(entry) { entry, #entry } + struct NppError { int error; string str; } + npp_errors [] = { - { NPP_NOT_SUPPORTED_MODE_ERROR, "NPP_NOT_SUPPORTED_MODE_ERROR" }, - { NPP_ROUND_MODE_NOT_SUPPORTED_ERROR, "NPP_ROUND_MODE_NOT_SUPPORTED_ERROR" }, - { NPP_RESIZE_NO_OPERATION_ERROR, "NPP_RESIZE_NO_OPERATION_ERROR" }, - { NPP_BAD_ARG_ERROR, "NPP_BAD_ARG_ERROR" }, - { NPP_LUT_NUMBER_OF_LEVELS_ERROR, "NPP_LUT_NUMBER_OF_LEVELS_ERROR" }, - { NPP_TEXTURE_BIND_ERROR, "NPP_TEXTURE_BIND_ERROR" }, - { NPP_COEFF_ERROR, "NPP_COEFF_ERROR" }, - { NPP_RECT_ERROR, "NPP_RECT_ERROR" }, - { NPP_QUAD_ERROR, "NPP_QUAD_ERROR" }, - { NPP_WRONG_INTERSECTION_ROI_ERROR, "NPP_WRONG_INTERSECTION_ROI_ERROR" }, - { NPP_NOT_EVEN_STEP_ERROR, "NPP_NOT_EVEN_STEP_ERROR" }, - { NPP_INTERPOLATION_ERROR, "NPP_INTERPOLATION_ERROR" }, - { NPP_RESIZE_FACTOR_ERROR, "NPP_RESIZE_FACTOR_ERROR" }, - { NPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR, "NPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR" }, - { NPP_MEMFREE_ERR, "NPP_MEMFREE_ERR" }, - { NPP_MEMSET_ERR, "NPP_MEMSET_ERR" }, - { NPP_MEMCPY_ERROR, "NPP_MEMCPY_ERROR" }, - { NPP_MEM_ALLOC_ERR, "NPP_MEM_ALLOC_ERR" }, - { NPP_HISTO_NUMBER_OF_LEVELS_ERROR, "NPP_HISTO_NUMBER_OF_LEVELS_ERROR" }, - { NPP_MIRROR_FLIP_ERR, "NPP_MIRROR_FLIP_ERR" }, - { NPP_INVALID_INPUT, "NPP_INVALID_INPUT" }, - { NPP_ALIGNMENT_ERROR, "NPP_ALIGNMENT_ERROR" }, - { NPP_STEP_ERROR, "NPP_STEP_ERROR" }, - { NPP_SIZE_ERROR, "NPP_SIZE_ERROR" }, - { NPP_POINTER_ERROR, "NPP_POINTER_ERROR" }, - { NPP_NULL_POINTER_ERROR, "NPP_NULL_POINTER_ERROR" }, - { NPP_CUDA_KERNEL_EXECUTION_ERROR, "NPP_CUDA_KERNEL_EXECUTION_ERROR" }, - { NPP_NOT_IMPLEMENTED_ERROR, "NPP_NOT_IMPLEMENTED_ERROR" }, - { NPP_ERROR, "NPP_ERROR" }, - { NPP_NO_ERROR, "NPP_NO_ERROR" }, - { NPP_SUCCESS, "NPP_SUCCESS" }, - { NPP_WARNING, "NPP_WARNING" }, - { NPP_WRONG_INTERSECTION_QUAD_WARNING, "NPP_WRONG_INTERSECTION_QUAD_WARNING" }, - { NPP_MISALIGNED_DST_ROI_WARNING, "NPP_MISALIGNED_DST_ROI_WARNING" }, - { NPP_AFFINE_QUAD_INCORRECT_WARNING, "NPP_AFFINE_QUAD_INCORRECT_WARNING" }, - //disabled in NPP for cuda 3.2-rc - //{ NPP_AFFINE_QUAD_CHANGED_WARNING, "NPP_AFFINE_QUAD_CHANGED_WARNING" }, - //{ NPP_ADJUSTED_ROI_SIZE_WARNING, "NPP_ADJUSTED_ROI_SIZE_WARNING" }, - { NPP_DOUBLE_SIZE_WARNING, "NPP_DOUBLE_SIZE_WARNING" }, - { NPP_ODD_ROI_WARNING, "NPP_ODD_ROI_WARNING" } + error_entry( NPP_NOT_SUPPORTED_MODE_ERROR ), + error_entry( NPP_ROUND_MODE_NOT_SUPPORTED_ERROR ), + error_entry( NPP_RESIZE_NO_OPERATION_ERROR ), + error_entry( NPP_NOT_SUFFICIENT_COMPUTE_CAPABILITY ), + error_entry( NPP_BAD_ARG_ERROR ), + error_entry( NPP_LUT_NUMBER_OF_LEVELS_ERROR ), + error_entry( NPP_TEXTURE_BIND_ERROR ), + error_entry( NPP_COEFF_ERROR ), + error_entry( NPP_RECT_ERROR ), + error_entry( NPP_QUAD_ERROR ), + error_entry( NPP_WRONG_INTERSECTION_ROI_ERROR ), + error_entry( NPP_NOT_EVEN_STEP_ERROR ), + error_entry( NPP_INTERPOLATION_ERROR ), + error_entry( NPP_RESIZE_FACTOR_ERROR ), + error_entry( NPP_HAAR_CLASSIFIER_PIXEL_MATCH_ERROR ), + error_entry( NPP_MEMFREE_ERR ), + error_entry( NPP_MEMSET_ERR ), + error_entry( NPP_MEMCPY_ERROR ), + error_entry( NPP_MEM_ALLOC_ERR ), + error_entry( NPP_HISTO_NUMBER_OF_LEVELS_ERROR ), + error_entry( NPP_MIRROR_FLIP_ERR ), + error_entry( NPP_INVALID_INPUT ), + error_entry( NPP_ALIGNMENT_ERROR ), + error_entry( NPP_STEP_ERROR ), + error_entry( NPP_SIZE_ERROR ), + error_entry( NPP_POINTER_ERROR ), + error_entry( NPP_NULL_POINTER_ERROR ), + error_entry( NPP_CUDA_KERNEL_EXECUTION_ERROR ), + error_entry( NPP_NOT_IMPLEMENTED_ERROR ), + error_entry( NPP_ERROR ), + error_entry( NPP_NO_ERROR ), + error_entry( NPP_SUCCESS ), + error_entry( NPP_WARNING ), + error_entry( NPP_WRONG_INTERSECTION_QUAD_WARNING ), + error_entry( NPP_MISALIGNED_DST_ROI_WARNING ), + error_entry( NPP_AFFINE_QUAD_INCORRECT_WARNING ), + error_entry( NPP_DOUBLE_SIZE_WARNING ), + error_entry( NPP_ODD_ROI_WARNING ) }; int error_num = sizeof(npp_errors)/sizeof(npp_errors[0]); @@ -136,8 +137,18 @@ namespace cv void error(const char *error_string, const char *file, const int line, const char *func) { - //if (uncaught_exception()) - cv::error( cv::Exception(CV_GpuApiCallError, error_string, func, file, line) ); + 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) ); } } } diff --git a/modules/gpu/src/precomp.hpp b/modules/gpu/src/precomp.hpp index d9a7a9152c..9ac73a912a 100644 --- a/modules/gpu/src/precomp.hpp +++ b/modules/gpu/src/precomp.hpp @@ -55,6 +55,7 @@ #include #include #include +#include #include "opencv2/gpu/gpu.hpp" #include "opencv2/imgproc/imgproc.hpp" @@ -68,7 +69,7 @@ #else /* defined(HAVE_CUDA) */ - static inline void throw_nogpu() { CV_Error(CV_GpuNotFound, "The library is compilled with no GPU support"); } + static inline void throw_nogpu() { CV_Error(CV_GpuNotFound, "The library is compilled without GPU support"); } #endif /* defined(HAVE_CUDA) */ diff --git a/tests/gpu/src/gputest.hpp b/tests/gpu/src/gputest.hpp index d1edf80d3b..fea8ef90de 100644 --- a/tests/gpu/src/gputest.hpp +++ b/tests/gpu/src/gputest.hpp @@ -69,8 +69,8 @@ static inline bool check_and_treat_gpu_exception(const cv::Exception& e, CvTS* t { switch (e.code) { - case CV_GpuNotFound: - ts->printf(CvTS::LOG, "\nGpu not found"); + case CV_GpuNotSupported: + ts->printf(CvTS::LOG, "\nGpu not supported by the library"); break; case CV_GpuApiCallError: