added more assertion on device features to gpu functions and tests

moved TargerArchs and DeviceInfo to core
fixed bug in GpuMat::copy with mask (incorrect index in function tab)

modules/core/include/opencv2/core/gpumat.hpp

@@ -50,6 +50,96 @@
 
 namespace cv { namespace gpu
 {
+    //////////////////////////////// Initialization & Info ////////////////////////
+
+    //! This is the only function that do not throw exceptions if the library is compiled without Cuda.
+    CV_EXPORTS int getCudaEnabledDeviceCount();
+
+    //! Functions below throw cv::Expception if the library is compiled without Cuda.
+
+    CV_EXPORTS void setDevice(int device);
+    CV_EXPORTS int getDevice();
+
+    //! Explicitly destroys and cleans up all resources associated with the current device in the current process.
+    //! Any subsequent API call to this device will reinitialize the device.
+    CV_EXPORTS void resetDevice();
+
+    enum FeatureSet
+    {
+        FEATURE_SET_COMPUTE_10 = 10,
+        FEATURE_SET_COMPUTE_11 = 11,
+        FEATURE_SET_COMPUTE_12 = 12,
+        FEATURE_SET_COMPUTE_13 = 13,
+        FEATURE_SET_COMPUTE_20 = 20,
+        FEATURE_SET_COMPUTE_21 = 21,
+        GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
+        SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
+        NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13
+    };
+
+    // Gives information about what GPU archs this OpenCV GPU module was
+    // compiled for
+    class CV_EXPORTS TargetArchs
+    {
+    public:
+        static bool builtWith(FeatureSet feature_set);
+        static bool has(int major, int minor);
+        static bool hasPtx(int major, int minor);
+        static bool hasBin(int major, int minor);
+        static bool hasEqualOrLessPtx(int major, int minor);
+        static bool hasEqualOrGreater(int major, int minor);
+        static bool hasEqualOrGreaterPtx(int major, int minor);
+        static bool hasEqualOrGreaterBin(int major, int minor);
+    private:
+        TargetArchs();
+    };
+
+    // Gives information about the given GPU
+    class CV_EXPORTS DeviceInfo
+    {
+    public:
+        // Creates DeviceInfo object for the current GPU
+        DeviceInfo() : device_id_(getDevice()) { query(); }
+
+        // Creates DeviceInfo object for the given GPU
+        DeviceInfo(int device_id) : device_id_(device_id) { query(); }
+
+        std::string name() const { return name_; }
+
+        // Return compute capability versions
+        int majorVersion() const { return majorVersion_; }
+        int minorVersion() const { return minorVersion_; }
+
+        int multiProcessorCount() const { return multi_processor_count_; }
+
+        size_t freeMemory() const;
+        size_t totalMemory() const;
+
+        // Checks whether device supports the given feature
+        bool supports(FeatureSet feature_set) const;
+
+        // Checks whether the GPU module can be run on the given device
+        bool isCompatible() const;
+
+        int deviceID() const { return device_id_; }
+
+    private:
+        void query();
+        void queryMemory(size_t& free_memory, size_t& total_memory) const;
+
+        int device_id_;
+
+        std::string name_;
+        int multi_processor_count_;
+        int majorVersion_;
+        int minorVersion_;
+    };
+
+    CV_EXPORTS void printCudaDeviceInfo(int device);
+    CV_EXPORTS void printShortCudaDeviceInfo(int device);
+
+    //////////////////////////////// GpuMat ///////////////////////////////
+
     //! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
     class CV_EXPORTS GpuMat
     {
@@ -75,7 +165,7 @@ namespace cv { namespace gpu
         //! creates a matrix header for a part of the bigger matrix
         GpuMat(const GpuMat& m, Range rowRange, Range colRange);
         GpuMat(const GpuMat& m, Rect roi);
-        
+
         //! builds GpuMat from Mat. Perfom blocking upload to device.
         explicit GpuMat(const Mat& m);
 
@@ -84,7 +174,7 @@ namespace cv { namespace gpu
 
         //! assignment operators
         GpuMat& operator = (const GpuMat& m);
-        
+
         //! pefroms blocking upload data to GpuMat.
         void upload(const Mat& m);
 
@@ -225,26 +315,26 @@ namespace cv { namespace gpu
     ////////////////////////////////////////////////////////////////////////
     ////////////////////////////////////////////////////////////////////////
 
-    inline GpuMat::GpuMat() 
-        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) 
+    inline GpuMat::GpuMat()
+        : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
     {
     }
 
-    inline GpuMat::GpuMat(int rows_, int cols_, int type_) 
+    inline GpuMat::GpuMat(int rows_, int cols_, int type_)
         : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
     {
         if (rows_ > 0 && cols_ > 0)
             create(rows_, cols_, type_);
     }
 
-    inline GpuMat::GpuMat(Size size_, int type_) 
+    inline GpuMat::GpuMat(Size size_, int type_)
         : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
     {
         if (size_.height > 0 && size_.width > 0)
             create(size_.height, size_.width, type_);
     }
 
-    inline GpuMat::GpuMat(int rows_, int cols_, int type_, Scalar s_) 
+    inline GpuMat::GpuMat(int rows_, int cols_, int type_, Scalar s_)
         : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
     {
         if (rows_ > 0 && cols_ > 0)
@@ -254,7 +344,7 @@ namespace cv { namespace gpu
         }
     }
 
-    inline GpuMat::GpuMat(Size size_, int type_, Scalar s_) 
+    inline GpuMat::GpuMat(Size size_, int type_, Scalar s_)
         : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
     {
         if (size_.height > 0 && size_.width > 0)
@@ -262,11 +352,11 @@ namespace cv { namespace gpu
             create(size_.height, size_.width, type_);
             setTo(s_);
         }
-    }    
+    }
 
-    inline GpuMat::~GpuMat() 
-    { 
-        release(); 
+    inline GpuMat::~GpuMat()
+    {
+        release();
     }
 
     inline GpuMat GpuMat::clone() const
@@ -284,14 +374,14 @@ namespace cv { namespace gpu
             convertTo(m, type);
     }
 
-    inline size_t GpuMat::step1() const 
-    { 
-        return step / elemSize1(); 
+    inline size_t GpuMat::step1() const
+    {
+        return step / elemSize1();
     }
 
-    inline bool GpuMat::empty() const 
-    { 
-        return data == 0; 
+    inline bool GpuMat::empty() const
+    {
+        return data == 0;
     }
 
     template<typename _Tp> inline _Tp* GpuMat::ptr(int y)
@@ -304,89 +394,89 @@ namespace cv { namespace gpu
         return (const _Tp*)ptr(y);
     }
 
-    inline void swap(GpuMat& a, GpuMat& b) 
-    { 
-        a.swap(b); 
+    inline void swap(GpuMat& a, GpuMat& b)
+    {
+        a.swap(b);
     }
 
-    inline GpuMat GpuMat::row(int y) const 
-    { 
-        return GpuMat(*this, Range(y, y+1), Range::all()); 
+    inline GpuMat GpuMat::row(int y) const
+    {
+        return GpuMat(*this, Range(y, y+1), Range::all());
     }
 
-    inline GpuMat GpuMat::col(int x) const 
-    { 
-        return GpuMat(*this, Range::all(), Range(x, x+1)); 
+    inline GpuMat GpuMat::col(int x) const
+    {
+        return GpuMat(*this, Range::all(), Range(x, x+1));
     }
 
-    inline GpuMat GpuMat::rowRange(int startrow, int endrow) const 
-    { 
-        return GpuMat(*this, Range(startrow, endrow), Range::all()); 
+    inline GpuMat GpuMat::rowRange(int startrow, int endrow) const
+    {
+        return GpuMat(*this, Range(startrow, endrow), Range::all());
     }
 
-    inline GpuMat GpuMat::rowRange(Range r) const 
-    { 
-        return GpuMat(*this, r, Range::all()); 
+    inline GpuMat GpuMat::rowRange(Range r) const
+    {
+        return GpuMat(*this, r, Range::all());
     }
 
-    inline GpuMat GpuMat::colRange(int startcol, int endcol) const 
-    { 
-        return GpuMat(*this, Range::all(), Range(startcol, endcol)); 
+    inline GpuMat GpuMat::colRange(int startcol, int endcol) const
+    {
+        return GpuMat(*this, Range::all(), Range(startcol, endcol));
     }
 
-    inline GpuMat GpuMat::colRange(Range r) const 
-    { 
-        return GpuMat(*this, Range::all(), r); 
+    inline GpuMat GpuMat::colRange(Range r) const
+    {
+        return GpuMat(*this, Range::all(), r);
     }
 
-    inline void GpuMat::create(Size size_, int type_) 
-    { 
-        create(size_.height, size_.width, type_); 
+    inline void GpuMat::create(Size size_, int type_)
+    {
+        create(size_.height, size_.width, type_);
     }
 
-    inline GpuMat GpuMat::operator()(Range rowRange, Range colRange) const 
-    { 
-        return GpuMat(*this, rowRange, colRange); 
+    inline GpuMat GpuMat::operator()(Range rowRange, Range colRange) const
+    {
+        return GpuMat(*this, rowRange, colRange);
     }
 
-    inline GpuMat GpuMat::operator()(Rect roi) const 
-    { 
-        return GpuMat(*this, roi); 
+    inline GpuMat GpuMat::operator()(Rect roi) const
+    {
+        return GpuMat(*this, roi);
     }
 
-    inline bool GpuMat::isContinuous() const 
-    { 
-        return (flags & Mat::CONTINUOUS_FLAG) != 0; 
+    inline bool GpuMat::isContinuous() const
+    {
+        return (flags & Mat::CONTINUOUS_FLAG) != 0;
     }
 
-    inline size_t GpuMat::elemSize() const 
-    { 
-        return CV_ELEM_SIZE(flags); 
+    inline size_t GpuMat::elemSize() const
+    {
+        return CV_ELEM_SIZE(flags);
     }
 
-    inline size_t GpuMat::elemSize1() const 
-    { 
-        return CV_ELEM_SIZE1(flags); 
+    inline size_t GpuMat::elemSize1() const
+    {
+        return CV_ELEM_SIZE1(flags);
     }
 
-    inline int GpuMat::type() const 
-    { 
-        return CV_MAT_TYPE(flags); 
+    inline int GpuMat::type() const
+    {
+        return CV_MAT_TYPE(flags);
     }
 
-    inline int GpuMat::depth() const 
-    { 
-        return CV_MAT_DEPTH(flags); 
+    inline int GpuMat::depth() const
+    {
+        return CV_MAT_DEPTH(flags);
     }
 
-    inline int GpuMat::channels() const 
-    { 
-        return CV_MAT_CN(flags); 
+    inline int GpuMat::channels() const
+    {
+        return CV_MAT_CN(flags);
     }
 
-    inline Size GpuMat::size() const 
-    { 
-        return Size(cols, rows); 
+    inline Size GpuMat::size() const
+    {
+        return Size(cols, rows);
     }
 
     inline uchar* GpuMat::ptr(int y)
@@ -407,19 +497,19 @@ namespace cv { namespace gpu
         return *this;
     }
 
-    template <class T> inline GpuMat::operator DevMem2D_<T>() const 
-    { 
-        return DevMem2D_<T>(rows, cols, (T*)data, step); 
+    template <class T> inline GpuMat::operator DevMem2D_<T>() const
+    {
+        return DevMem2D_<T>(rows, cols, (T*)data, step);
     }
 
-    template <class T> inline GpuMat::operator PtrStep_<T>() const 
-    { 
-        return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this)); 
+    template <class T> inline GpuMat::operator PtrStep_<T>() const
+    {
+        return PtrStep_<T>(static_cast< DevMem2D_<T> >(*this));
     }
 
-    template <class T> inline GpuMat::operator PtrStep<T>() const 
-    { 
-        return PtrStep<T>((T*)data, step); 
+    template <class T> inline GpuMat::operator PtrStep<T>() const
+    {
+        return PtrStep<T>((T*)data, step);
     }
 
     inline GpuMat createContinuous(int rows, int cols, int type)

modules/core/src/gpumat.cpp

@@ -46,7 +46,8 @@
 #include <iostream>
 
 #ifdef HAVE_CUDA
-    #include <cuda_runtime.h>
+    #include <cuda.h>
+    #include <cuda_runtime_api.h>
     #include <npp.h>
 
     #define CUDART_MINIMUM_REQUIRED_VERSION 4010
@@ -65,6 +66,408 @@ using namespace std;
 using namespace cv;
 using namespace cv::gpu;
 
+//////////////////////////////// Initialization & Info ////////////////////////
+
+namespace
+{
+    // Compares value to set using the given comparator. Returns true if
+    // there is at least one element x in the set satisfying to: x cmp value
+    // predicate.
+    template <typename Comparer>
+    bool compareToSet(const std::string& set_as_str, int value, Comparer cmp)
+    {
+        if (set_as_str.find_first_not_of(" ") == string::npos)
+            return false;
+
+        std::stringstream stream(set_as_str);
+        int cur_value;
+
+        while (!stream.eof())
+        {
+            stream >> cur_value;
+            if (cmp(cur_value, value))
+                return true;
+        }
+
+        return false;
+    }
+}
+
+bool cv::gpu::TargetArchs::builtWith(cv::gpu::FeatureSet feature_set)
+{
+#ifdef HAVE_CUDA
+    return ::compareToSet(CUDA_ARCH_FEATURES, feature_set, std::greater_equal<int>());
+#else
+    (void)feature_set;
+    return false;
+#endif
+}
+
+bool cv::gpu::TargetArchs::has(int major, int minor)
+{
+    return hasPtx(major, minor) || hasBin(major, minor);
+}
+
+bool cv::gpu::TargetArchs::hasPtx(int major, int minor)
+{
+#ifdef HAVE_CUDA
+    return ::compareToSet(CUDA_ARCH_PTX, major * 10 + minor, std::equal_to<int>());
+#else
+    (void)major;
+    (void)minor;
+    return false;
+#endif
+}
+
+bool cv::gpu::TargetArchs::hasBin(int major, int minor)
+{
+#if defined (HAVE_CUDA)
+    return ::compareToSet(CUDA_ARCH_BIN, major * 10 + minor, std::equal_to<int>());
+#else
+    (void)major;
+    (void)minor;
+    return false;
+#endif
+}
+
+bool cv::gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor)
+{
+#ifdef HAVE_CUDA
+    return ::compareToSet(CUDA_ARCH_PTX, major * 10 + minor,
+                     std::less_equal<int>());
+#else
+    (void)major;
+    (void)minor;
+    return false;
+#endif
+}
+
+bool cv::gpu::TargetArchs::hasEqualOrGreater(int major, int minor)
+{
+    return hasEqualOrGreaterPtx(major, minor) ||
+           hasEqualOrGreaterBin(major, minor);
+}
+
+bool cv::gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor)
+{
+#ifdef HAVE_CUDA
+    return ::compareToSet(CUDA_ARCH_PTX, major * 10 + minor,
+                     std::greater_equal<int>());
+#else
+    (void)major;
+    (void)minor;
+    return false;
+#endif
+}
+
+bool cv::gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor)
+{
+#ifdef HAVE_CUDA
+    return ::compareToSet(CUDA_ARCH_BIN, major * 10 + minor,
+                     std::greater_equal<int>());
+#else
+    (void)major;
+    (void)minor;
+    return false;
+#endif
+}
+
+#ifndef HAVE_CUDA
+
+#define throw_nogpu CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support")
+
+int cv::gpu::getCudaEnabledDeviceCount() { return 0; }
+
+void cv::gpu::setDevice(int) { throw_nogpu; }
+int cv::gpu::getDevice() { throw_nogpu; return 0; }
+
+void cv::gpu::resetDevice() { throw_nogpu; }
+
+size_t cv::gpu::DeviceInfo::freeMemory() const { throw_nogpu; return 0; }
+size_t cv::gpu::DeviceInfo::totalMemory() const { throw_nogpu; return 0; }
+
+bool cv::gpu::DeviceInfo::supports(cv::gpu::FeatureSet) const { throw_nogpu; return false; }
+
+bool cv::gpu::DeviceInfo::isCompatible() const { throw_nogpu; return false; }
+
+void cv::gpu::DeviceInfo::query() { throw_nogpu; }
+void cv::gpu::DeviceInfo::queryMemory(size_t&, size_t&) const { throw_nogpu; }
+
+void cv::gpu::printCudaDeviceInfo(int) { throw_nogpu; }
+void cv::gpu::printShortCudaDeviceInfo(int) { throw_nogpu; }
+
+#undef throw_nogpu
+
+#else // HAVE_CUDA
+
+namespace
+{
+#if defined(__GNUC__)
+    #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
+    #define nppSafeCall(expr)  ___nppSafeCall(expr, __FILE__, __LINE__, __func__)
+#else /* defined(__CUDACC__) || defined(__MSVC__) */
+    #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__)
+    #define nppSafeCall(expr)  ___nppSafeCall(expr, __FILE__, __LINE__)
+#endif
+
+    inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "")
+    {
+        if (cudaSuccess != err)
+            cv::gpu::error(cudaGetErrorString(err), file, line, func);
+    }
+
+    inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
+    {
+        if (err < 0)
+        {
+            std::ostringstream msg;
+            msg << "NPP API Call Error: " << err;
+            cv::gpu::error(msg.str().c_str(), file, line, func);
+        }
+    }
+}
+
+int cv::gpu::getCudaEnabledDeviceCount()
+{
+    int count;
+    cudaError_t error = cudaGetDeviceCount( &count );
+
+    if (error == cudaErrorInsufficientDriver)
+        return -1;
+
+    if (error == cudaErrorNoDevice)
+        return 0;
+
+    cudaSafeCall(error);
+    return count;
+}
+
+void cv::gpu::setDevice(int device)
+{
+    cudaSafeCall( cudaSetDevice( device ) );
+}
+
+int cv::gpu::getDevice()
+{
+    int device;
+    cudaSafeCall( cudaGetDevice( &device ) );
+    return device;
+}
+
+void cv::gpu::resetDevice()
+{
+    cudaSafeCall( cudaDeviceReset() );
+}
+
+size_t cv::gpu::DeviceInfo::freeMemory() const
+{
+    size_t free_memory, total_memory;
+    queryMemory(free_memory, total_memory);
+    return free_memory;
+}
+
+size_t cv::gpu::DeviceInfo::totalMemory() const
+{
+    size_t free_memory, total_memory;
+    queryMemory(free_memory, total_memory);
+    return total_memory;
+}
+
+bool cv::gpu::DeviceInfo::supports(cv::gpu::FeatureSet feature_set) const
+{
+    int version = majorVersion() * 10 + minorVersion();
+    return version >= feature_set;
+}
+
+bool cv::gpu::DeviceInfo::isCompatible() const
+{
+    // Check PTX compatibility
+    if (TargetArchs::hasEqualOrLessPtx(majorVersion(), minorVersion()))
+        return true;
+
+    // Check BIN compatibility
+    for (int i = minorVersion(); i >= 0; --i)
+        if (TargetArchs::hasBin(majorVersion(), i))
+            return true;
+
+    return false;
+}
+
+void cv::gpu::DeviceInfo::query()
+{
+    cudaDeviceProp prop;
+    cudaSafeCall(cudaGetDeviceProperties(&prop, device_id_));
+    name_ = prop.name;
+    multi_processor_count_ = prop.multiProcessorCount;
+    majorVersion_ = prop.major;
+    minorVersion_ = prop.minor;
+}
+
+void cv::gpu::DeviceInfo::queryMemory(size_t& free_memory, size_t& total_memory) const
+{
+    int prev_device_id = getDevice();
+    if (prev_device_id != device_id_)
+        setDevice(device_id_);
+
+    cudaSafeCall(cudaMemGetInfo(&free_memory, &total_memory));
+
+    if (prev_device_id != device_id_)
+        setDevice(prev_device_id);
+}
+
+namespace
+{
+    template <class T> void getCudaAttribute(T *attribute, CUdevice_attribute device_attribute, int device)
+    {
+        *attribute = T();
+        CUresult error = CUDA_SUCCESS;// = cuDeviceGetAttribute( attribute, device_attribute, device ); why link erros under ubuntu??
+        if( CUDA_SUCCESS == error )
+            return;
+
+        printf("Driver API error = %04d\n", error);
+        cv::gpu::error("driver API error", __FILE__, __LINE__);
+    }
+
+    int convertSMVer2Cores(int major, int minor)
+    {
+        // Defines for GPU Architecture types (using the SM version to determine the # of cores per SM
+        typedef struct {
+            int SM; // 0xMm (hexidecimal notation), M = SM Major version, and m = SM minor version
+            int Cores;
+        } SMtoCores;
+
+        SMtoCores gpuArchCoresPerSM[] =  { { 0x10,  8 }, { 0x11,  8 }, { 0x12,  8 }, { 0x13,  8 }, { 0x20, 32 }, { 0x21, 48 }, { -1, -1 } };
+
+        int index = 0;
+        while (gpuArchCoresPerSM[index].SM != -1)
+        {
+            if (gpuArchCoresPerSM[index].SM == ((major << 4) + minor) )
+                return gpuArchCoresPerSM[index].Cores;
+            index++;
+        }
+        printf("MapSMtoCores undefined SMversion %d.%d!\n", major, minor);
+        return -1;
+    }
+}
+
+void cv::gpu::printCudaDeviceInfo(int device)
+{
+    int count = getCudaEnabledDeviceCount();
+    bool valid = (device >= 0) && (device < count);
+
+    int beg = valid ? device   : 0;
+    int end = valid ? device+1 : count;
+
+    printf("*** CUDA Device Query (Runtime API) version (CUDART static linking) *** \n\n");
+    printf("Device count: %d\n", count);
+
+    int driverVersion = 0, runtimeVersion = 0;
+    cudaSafeCall( cudaDriverGetVersion(&driverVersion) );
+    cudaSafeCall( cudaRuntimeGetVersion(&runtimeVersion) );
+
+    const char *computeMode[] = {
+        "Default (multiple host threads can use ::cudaSetDevice() with device simultaneously)",
+        "Exclusive (only one host thread in one process is able to use ::cudaSetDevice() with this device)",
+        "Prohibited (no host thread can use ::cudaSetDevice() with this device)",
+        "Exclusive Process (many threads in one process is able to use ::cudaSetDevice() with this device)",
+        "Unknown",
+        NULL
+    };
+
+    for(int dev = beg; dev < end; ++dev)
+    {
+        cudaDeviceProp prop;
+        cudaSafeCall( cudaGetDeviceProperties(&prop, dev) );
+
+        printf("\nDevice %d: \"%s\"\n", dev, prop.name);
+        printf("  CUDA Driver Version / Runtime Version          %d.%d / %d.%d\n", driverVersion/1000, driverVersion%100, runtimeVersion/1000, runtimeVersion%100);
+        printf("  CUDA Capability Major/Minor version number:    %d.%d\n", prop.major, prop.minor);
+        printf("  Total amount of global memory:                 %.0f MBytes (%llu bytes)\n", (float)prop.totalGlobalMem/1048576.0f, (unsigned long long) prop.totalGlobalMem);
+        printf("  (%2d) Multiprocessors x (%2d) CUDA Cores/MP:     %d CUDA Cores\n",
+            prop.multiProcessorCount, convertSMVer2Cores(prop.major, prop.minor),
+            convertSMVer2Cores(prop.major, prop.minor) * prop.multiProcessorCount);
+        printf("  GPU Clock Speed:                               %.2f GHz\n", prop.clockRate * 1e-6f);
+
+        // This is not available in the CUDA Runtime API, so we make the necessary calls the driver API to support this for output
+        int memoryClock, memBusWidth, L2CacheSize;
+        getCudaAttribute<int>( &memoryClock, CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, dev );
+        getCudaAttribute<int>( &memBusWidth, CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH, dev );
+        getCudaAttribute<int>( &L2CacheSize, CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE, dev );
+
+        printf("  Memory Clock rate:                             %.2f Mhz\n", memoryClock * 1e-3f);
+        printf("  Memory Bus Width:                              %d-bit\n", memBusWidth);
+        if (L2CacheSize)
+            printf("  L2 Cache Size:                                 %d bytes\n", L2CacheSize);
+
+        printf("  Max Texture Dimension Size (x,y,z)             1D=(%d), 2D=(%d,%d), 3D=(%d,%d,%d)\n",
+            prop.maxTexture1D, prop.maxTexture2D[0], prop.maxTexture2D[1],
+            prop.maxTexture3D[0], prop.maxTexture3D[1], prop.maxTexture3D[2]);
+        printf("  Max Layered Texture Size (dim) x layers        1D=(%d) x %d, 2D=(%d,%d) x %d\n",
+            prop.maxTexture1DLayered[0], prop.maxTexture1DLayered[1],
+            prop.maxTexture2DLayered[0], prop.maxTexture2DLayered[1], prop.maxTexture2DLayered[2]);
+
+        printf("  Total amount of constant memory:               %u bytes\n", (int)prop.totalConstMem);
+        printf("  Total amount of shared memory per block:       %u bytes\n", (int)prop.sharedMemPerBlock);
+        printf("  Total number of registers available per block: %d\n", prop.regsPerBlock);
+        printf("  Warp size:                                     %d\n", prop.warpSize);
+        printf("  Maximum number of threads per block:           %d\n", prop.maxThreadsPerBlock);
+        printf("  Maximum sizes of each dimension of a block:    %d x %d x %d\n", prop.maxThreadsDim[0], prop.maxThreadsDim[1], prop.maxThreadsDim[2]);
+        printf("  Maximum sizes of each dimension of a grid:     %d x %d x %d\n", prop.maxGridSize[0], prop.maxGridSize[1],  prop.maxGridSize[2]);
+        printf("  Maximum memory pitch:                          %u bytes\n", (int)prop.memPitch);
+        printf("  Texture alignment:                             %u bytes\n", (int)prop.textureAlignment);
+
+        printf("  Concurrent copy and execution:                 %s with %d copy engine(s)\n", (prop.deviceOverlap ? "Yes" : "No"), prop.asyncEngineCount);
+        printf("  Run time limit on kernels:                     %s\n", prop.kernelExecTimeoutEnabled ? "Yes" : "No");
+        printf("  Integrated GPU sharing Host Memory:            %s\n", prop.integrated ? "Yes" : "No");
+        printf("  Support host page-locked memory mapping:       %s\n", prop.canMapHostMemory ? "Yes" : "No");
+
+        printf("  Concurrent kernel execution:                   %s\n", prop.concurrentKernels ? "Yes" : "No");
+        printf("  Alignment requirement for Surfaces:            %s\n", prop.surfaceAlignment ? "Yes" : "No");
+        printf("  Device has ECC support enabled:                %s\n", prop.ECCEnabled ? "Yes" : "No");
+        printf("  Device is using TCC driver mode:               %s\n", prop.tccDriver ? "Yes" : "No");
+        printf("  Device supports Unified Addressing (UVA):      %s\n", prop.unifiedAddressing ? "Yes" : "No");
+        printf("  Device PCI Bus ID / PCI location ID:           %d / %d\n", prop.pciBusID, prop.pciDeviceID );
+        printf("  Compute Mode:\n");
+        printf("      %s \n", computeMode[prop.computeMode]);
+    }
+
+    printf("\n");
+    printf("deviceQuery, CUDA Driver = CUDART");
+    printf(", CUDA Driver Version  = %d.%d", driverVersion / 1000, driverVersion % 100);
+    printf(", CUDA Runtime Version = %d.%d", runtimeVersion/1000, runtimeVersion%100);
+    printf(", NumDevs = %d\n\n", count);
+    fflush(stdout);
+}
+
+void cv::gpu::printShortCudaDeviceInfo(int device)
+{
+    int count = getCudaEnabledDeviceCount();
+    bool valid = (device >= 0) && (device < count);
+
+    int beg = valid ? device   : 0;
+    int end = valid ? device+1 : count;
+
+    int driverVersion = 0, runtimeVersion = 0;
+    cudaSafeCall( cudaDriverGetVersion(&driverVersion) );
+    cudaSafeCall( cudaRuntimeGetVersion(&runtimeVersion) );
+
+    for(int dev = beg; dev < end; ++dev)
+    {
+        cudaDeviceProp prop;
+        cudaSafeCall( cudaGetDeviceProperties(&prop, dev) );
+
+        const char *arch_str = prop.major < 2 ? " (not Fermi)" : "";
+        printf("Device %d:  \"%s\"  %.0fMb", dev, prop.name, (float)prop.totalGlobalMem/1048576.0f);
+        printf(", sm_%d%d%s, %d cores", prop.major, prop.minor, arch_str, convertSMVer2Cores(prop.major, prop.minor) * prop.multiProcessorCount);
+        printf(", Driver/Runtime ver.%d.%d/%d.%d\n", driverVersion/1000, driverVersion%100, runtimeVersion/1000, runtimeVersion%100);
+    }
+    fflush(stdout);
+}
+
+#endif // HAVE_CUDA
+
+//////////////////////////////// GpuMat ///////////////////////////////
+
 cv::gpu::GpuMat::GpuMat(const GpuMat& m)
     : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend)
 {
@@ -326,25 +729,23 @@ namespace
 
 #ifndef HAVE_CUDA
 
-#define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support")
-
 namespace
 {
     class EmptyFuncTable : public GpuFuncTable
     {
     public:
-        void copy(const Mat&, GpuMat&) const { throw_nocuda; }
-        void copy(const GpuMat&, Mat&) const { throw_nocuda; }
-        void copy(const GpuMat&, GpuMat&) const { throw_nocuda; }
+        void copy(const Mat&, GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
+        void copy(const GpuMat&, Mat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
+        void copy(const GpuMat&, GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
 
-        void copyWithMask(const GpuMat&, GpuMat&, const GpuMat&) const { throw_nocuda; }
+        void copyWithMask(const GpuMat&, GpuMat&, const GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
 
-        void convert(const GpuMat&, GpuMat&) const { throw_nocuda; }
-        void convert(const GpuMat&, GpuMat&, double, double) const { throw_nocuda; }
+        void convert(const GpuMat&, GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
+        void convert(const GpuMat&, GpuMat&, double, double) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
 
-        void setTo(GpuMat&, Scalar, const GpuMat&) const { throw_nocuda; }
+        void setTo(GpuMat&, Scalar, const GpuMat&) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
 
-        void mallocPitch(void**, size_t*, size_t, size_t) const { throw_nocuda; }
+        void mallocPitch(void**, size_t*, size_t, size_t) const { CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support"); }
         void free(void*) const {}
     };
 
@@ -370,33 +771,6 @@ namespace cv { namespace gpu { namespace device
     void convert_gpu(DevMem2Db src, int sdepth, DevMem2Db dst, int ddepth, double alpha, double beta, cudaStream_t stream);
 }}}
 
-namespace
-{
-#if defined(__GNUC__)
-    #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
-    #define nppSafeCall(expr)  ___nppSafeCall(expr, __FILE__, __LINE__, __func__)
-#else /* defined(__CUDACC__) || defined(__MSVC__) */
-    #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__)
-    #define nppSafeCall(expr)  ___nppSafeCall(expr, __FILE__, __LINE__)
-#endif
-
-    inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "")
-    {
-        if (cudaSuccess != err)
-            cv::gpu::error(cudaGetErrorString(err), file, line, func);
-    }
-
-    inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
-    {
-        if (err < 0)
-        {
-            std::ostringstream msg;
-            msg << "NPP API Call Error: " << err;
-            cv::gpu::error(msg.str().c_str(), file, line, func);
-        }
-    }
-}
-
 namespace
 {
     template <typename T> void kernelSetCaller(GpuMat& src, Scalar s, cudaStream_t stream)
@@ -502,7 +876,7 @@ namespace
         typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
         typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
 
-        static void cvt(const GpuMat& src, GpuMat& dst)
+        static void call(const GpuMat& src, GpuMat& dst)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -517,7 +891,7 @@ namespace
     {
         typedef typename NPPTypeTraits<DDEPTH>::npp_type dst_t;
 
-        static void cvt(const GpuMat& src, GpuMat& dst)
+        static void call(const GpuMat& src, GpuMat& dst)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -557,7 +931,7 @@ namespace
     {
         typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
 
-        static void set(GpuMat& src, Scalar s)
+        static void call(GpuMat& src, Scalar s)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -574,7 +948,7 @@ namespace
     {
         typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
 
-        static void set(GpuMat& src, Scalar s)
+        static void call(GpuMat& src, Scalar s)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -605,7 +979,7 @@ namespace
     {
         typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
 
-        static void set(GpuMat& src, Scalar s, const GpuMat& mask)
+        static void call(GpuMat& src, Scalar s, const GpuMat& mask)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -622,7 +996,7 @@ namespace
     {
         typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
 
-        static void set(GpuMat& src, Scalar s, const GpuMat& mask)
+        static void call(GpuMat& src, Scalar s, const GpuMat& mask)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -650,7 +1024,7 @@ namespace
     {
         typedef typename NPPTypeTraits<SDEPTH>::npp_type src_t;
 
-        static void copyMasked(const GpuMat& src, GpuMat& dst, const GpuMat& mask, cudaStream_t /*stream*/)
+        static void call(const GpuMat& src, GpuMat& dst, const GpuMat& mask, cudaStream_t /*stream*/)
         {
             NppiSize sz;
             sz.width = src.cols;
@@ -683,99 +1057,114 @@ namespace
 
         void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask) const
         {
+            CV_Assert(src.depth() <= CV_64F && src.channels() <= 4);
             CV_Assert(src.size() == dst.size() && src.type() == dst.type());
             CV_Assert(src.size() == mask.size() && mask.depth() == CV_8U && (mask.channels() == 1 || mask.channels() == src.channels()));
 
-            typedef void (*caller_t)(const GpuMat& src, GpuMat& dst, const GpuMat& mask, cudaStream_t stream);
-
-            static const caller_t callers[7][4] = 
+            if (src.depth() == CV_64F)
             {
-                /*  8U */ {NppCopyMasked<CV_8U, nppiCopy_8u_C1MR>::copyMasked, cv::gpu::copyWithMask, NppCopyMasked<CV_8U, nppiCopy_8u_C3MR>::copyMasked, NppCopyMasked<CV_8U, nppiCopy_8u_C4MR>::copyMasked},
-                /*  8S */ {cv::gpu::copyWithMask, cv::gpu::copyWithMask, cv::gpu::copyWithMask, cv::gpu::copyWithMask},
-                /* 16U */ {NppCopyMasked<CV_16U, nppiCopy_16u_C1MR>::copyMasked, cv::gpu::copyWithMask, NppCopyMasked<CV_16U, nppiCopy_16u_C3MR>::copyMasked, NppCopyMasked<CV_16U, nppiCopy_16u_C4MR>::copyMasked},
-                /* 16S */ {NppCopyMasked<CV_16S, nppiCopy_16s_C1MR>::copyMasked, cv::gpu::copyWithMask, NppCopyMasked<CV_16S, nppiCopy_16s_C3MR>::copyMasked, NppCopyMasked<CV_16S, nppiCopy_16s_C4MR>::copyMasked},
-                /* 32S */ {NppCopyMasked<CV_32S, nppiCopy_32s_C1MR>::copyMasked, cv::gpu::copyWithMask, NppCopyMasked<CV_32S, nppiCopy_32s_C3MR>::copyMasked, NppCopyMasked<CV_32S, nppiCopy_32s_C4MR>::copyMasked},
-                /* 32F */ {NppCopyMasked<CV_32F, nppiCopy_32f_C1MR>::copyMasked, cv::gpu::copyWithMask, NppCopyMasked<CV_32F, nppiCopy_32f_C3MR>::copyMasked, NppCopyMasked<CV_32F, nppiCopy_32f_C4MR>::copyMasked},
-                /* 64F */ {cv::gpu::copyWithMask, cv::gpu::copyWithMask, cv::gpu::copyWithMask, cv::gpu::copyWithMask}
+                if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                    CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+            }
+
+            typedef void (*func_t)(const GpuMat& src, GpuMat& dst, const GpuMat& mask, cudaStream_t stream);
+            static const func_t funcs[7][4] =
+            {
+                /*  8U */ {NppCopyMasked<CV_8U , nppiCopy_8u_C1MR >::call, cv::gpu::copyWithMask, NppCopyMasked<CV_8U , nppiCopy_8u_C3MR >::call, NppCopyMasked<CV_8U , nppiCopy_8u_C4MR >::call},
+                /*  8S */ {cv::gpu::copyWithMask                         , cv::gpu::copyWithMask, cv::gpu::copyWithMask                         , cv::gpu::copyWithMask                         },
+                /* 16U */ {NppCopyMasked<CV_16U, nppiCopy_16u_C1MR>::call, cv::gpu::copyWithMask, NppCopyMasked<CV_16U, nppiCopy_16u_C3MR>::call, NppCopyMasked<CV_16U, nppiCopy_16u_C4MR>::call},
+                /* 16S */ {NppCopyMasked<CV_16S, nppiCopy_16s_C1MR>::call, cv::gpu::copyWithMask, NppCopyMasked<CV_16S, nppiCopy_16s_C3MR>::call, NppCopyMasked<CV_16S, nppiCopy_16s_C4MR>::call},
+                /* 32S */ {NppCopyMasked<CV_32S, nppiCopy_32s_C1MR>::call, cv::gpu::copyWithMask, NppCopyMasked<CV_32S, nppiCopy_32s_C3MR>::call, NppCopyMasked<CV_32S, nppiCopy_32s_C4MR>::call},
+                /* 32F */ {NppCopyMasked<CV_32F, nppiCopy_32f_C1MR>::call, cv::gpu::copyWithMask, NppCopyMasked<CV_32F, nppiCopy_32f_C3MR>::call, NppCopyMasked<CV_32F, nppiCopy_32f_C4MR>::call},
+                /* 64F */ {cv::gpu::copyWithMask                         , cv::gpu::copyWithMask, cv::gpu::copyWithMask                         , cv::gpu::copyWithMask                         }
             };
 
-            caller_t func =  mask.channels() == src.channels() ? callers[src.depth()][src.channels()] : cv::gpu::copyWithMask;
-            CV_DbgAssert(func != 0);
+            const func_t func =  mask.channels() == src.channels() ? funcs[src.depth()][src.channels() - 1] : cv::gpu::copyWithMask;
 
             func(src, dst, mask, 0);
         }
 
         void convert(const GpuMat& src, GpuMat& dst) const
         {
-            typedef void (*caller_t)(const GpuMat& src, GpuMat& dst);
-            static const caller_t callers[7][7][7] =
+            typedef void (*func_t)(const GpuMat& src, GpuMat& dst);
+            static const func_t funcs[7][7][4] =
             {
                 {
                     /*  8U ->  8U */ {0, 0, 0, 0},
-                    /*  8U ->  8S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
-                    /*  8U -> 16U */ {NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C4R>::cvt},
-                    /*  8U -> 16S */ {NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C4R>::cvt},
-                    /*  8U -> 32S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /*  8U -> 32F */ {NppCvt<CV_8U, CV_32F, nppiConvert_8u32f_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /*  8U -> 64F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo}
+                    /*  8U ->  8S */ {cv::gpu::convertTo                                , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /*  8U -> 16U */ {NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, NppCvt<CV_8U, CV_16U, nppiConvert_8u16u_C4R>::call},
+                    /*  8U -> 16S */ {NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, NppCvt<CV_8U, CV_16S, nppiConvert_8u16s_C4R>::call},
+                    /*  8U -> 32S */ {cv::gpu::convertTo                                , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /*  8U -> 32F */ {NppCvt<CV_8U, CV_32F, nppiConvert_8u32f_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /*  8U -> 64F */ {cv::gpu::convertTo                                , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                }
                 },
                 {
-                    /*  8S ->  8U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
+                    /*  8S ->  8U */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
                     /*  8S ->  8S */ {0,0,0,0},
-                    /*  8S -> 16U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /*  8S -> 16S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /*  8S -> 32S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /*  8S -> 32F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /*  8S -> 64F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo}
+                    /*  8S -> 16U */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /*  8S -> 16S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /*  8S -> 32S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /*  8S -> 32F */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /*  8S -> 64F */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo}
                 },
                 {
-                    /* 16U ->  8U */ {NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C4R>::cvt},
-                    /* 16U ->  8S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
+                    /* 16U ->  8U */ {NppCvt<CV_16U, CV_8U , nppiConvert_16u8u_C1R >::call, cv::gpu::convertTo, cv::gpu::convertTo, NppCvt<CV_16U, CV_8U, nppiConvert_16u8u_C4R>::call},
+                    /* 16U ->  8S */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
                     /* 16U -> 16U */ {0,0,0,0},
-                    /* 16U -> 16S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 16U -> 32S */ {NppCvt<CV_16U, CV_32S, nppiConvert_16u32s_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 16U -> 32F */ {NppCvt<CV_16U, CV_32F, nppiConvert_16u32f_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 16U -> 64F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo}
+                    /* 16U -> 16S */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /* 16U -> 32S */ {NppCvt<CV_16U, CV_32S, nppiConvert_16u32s_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /* 16U -> 32F */ {NppCvt<CV_16U, CV_32F, nppiConvert_16u32f_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /* 16U -> 64F */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                }
                 },
                 {
-                    /* 16S ->  8U */ {NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C4R>::cvt},
-                    /* 16S ->  8S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 16S -> 16U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
+                    /* 16S ->  8U */ {NppCvt<CV_16S, CV_8U , nppiConvert_16s8u_C1R >::call, cv::gpu::convertTo, cv::gpu::convertTo, NppCvt<CV_16S, CV_8U, nppiConvert_16s8u_C4R>::call},
+                    /* 16S ->  8S */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /* 16S -> 16U */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
                     /* 16S -> 16S */ {0,0,0,0},
-                    /* 16S -> 32S */ {NppCvt<CV_16S, CV_32S, nppiConvert_16s32s_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 16S -> 32F */ {NppCvt<CV_16S, CV_32F, nppiConvert_16s32f_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 16S -> 64F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo}
+                    /* 16S -> 32S */ {NppCvt<CV_16S, CV_32S, nppiConvert_16s32s_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /* 16S -> 32F */ {NppCvt<CV_16S, CV_32F, nppiConvert_16s32f_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                },
+                    /* 16S -> 64F */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo                                }
                 },
                 {
-                    /* 32S ->  8U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32S ->  8S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32S -> 16U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32S -> 16S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
+                    /* 32S ->  8U */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32S ->  8S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32S -> 16U */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32S -> 16S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
                     /* 32S -> 32S */ {0,0,0,0},
-                    /* 32S -> 32F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32S -> 64F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo}
+                    /* 32S -> 32F */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32S -> 64F */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo}
                 },
                 {
-                    /* 32F ->  8U */ {NppCvt<CV_32F, CV_8U, nppiConvert_32f8u_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32F ->  8S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32F -> 16U */ {NppCvt<CV_32F, CV_16U, nppiConvert_32f16u_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32F -> 16S */ {NppCvt<CV_32F, CV_16S, nppiConvert_32f16s_C1R>::cvt,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 32F -> 32S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
+                    /* 32F ->  8U */ {NppCvt<CV_32F, CV_8U , nppiConvert_32f8u_C1R >::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32F ->  8S */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32F -> 16U */ {NppCvt<CV_32F, CV_16U, nppiConvert_32f16u_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32F -> 16S */ {NppCvt<CV_32F, CV_16S, nppiConvert_32f16s_C1R>::call, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 32F -> 32S */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
                     /* 32F -> 32F */ {0,0,0,0},
-                    /* 32F -> 64F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo}
+                    /* 32F -> 64F */ {cv::gpu::convertTo                                  , cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo}
                 },
                 {
-                    /* 64F ->  8U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 64F ->  8S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 64F -> 16U */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 64F -> 16S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 64F -> 32S */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
-                    /* 64F -> 32F */ {cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo,cv::gpu::convertTo},
+                    /* 64F ->  8U */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 64F ->  8S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 64F -> 16U */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 64F -> 16S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 64F -> 32S */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
+                    /* 64F -> 32F */ {cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo, cv::gpu::convertTo},
                     /* 64F -> 64F */ {0,0,0,0}
                 }
             };
 
-            caller_t func = callers[src.depth()][dst.depth()][src.channels() - 1];
+            CV_Assert(src.depth() <= CV_64F && src.channels() <= 4);
+            CV_Assert(dst.depth() <= CV_64F);
+            CV_Assert(src.size() == dst.size() && src.channels() == dst.channels());
+
+            if (src.depth() == CV_64F || dst.depth() == CV_64F)
+            {
+                if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                    CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+            }
+
+            const func_t func = funcs[src.depth()][dst.depth()][src.channels() - 1];
             CV_DbgAssert(func != 0);
 
             func(src, dst);
@@ -783,6 +1172,15 @@ namespace
 
         void convert(const GpuMat& src, GpuMat& dst, double alpha, double beta) const
         {
+            CV_Assert(src.depth() <= CV_64F && src.channels() <= 4);
+            CV_Assert(dst.depth() <= CV_64F);
+
+            if (src.depth() == CV_64F || dst.depth() == CV_64F)
+            {
+                if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                    CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+            }
+
             cv::gpu::convertTo(src, dst, alpha, beta);
         }
 
@@ -812,36 +1210,51 @@ namespace
                     }
                 }
 
-                typedef void (*caller_t)(GpuMat& src, Scalar s);
-                static const caller_t callers[7][4] =
+                typedef void (*func_t)(GpuMat& src, Scalar s);
+                static const func_t funcs[7][4] =
                 {
-                    {NppSet<CV_8U, 1, nppiSet_8u_C1R>::set, cv::gpu::setTo, cv::gpu::setTo, NppSet<CV_8U, 4, nppiSet_8u_C4R>::set},
-                    {NppSet<CV_8S, 1, nppiSet_8s_C1R>::set, NppSet<CV_8S, 2, nppiSet_8s_C2R>::set, NppSet<CV_8S, 3, nppiSet_8s_C3R>::set, NppSet<CV_8S, 4, nppiSet_8s_C4R>::set},
-                    {NppSet<CV_16U, 1, nppiSet_16u_C1R>::set, NppSet<CV_16U, 2, nppiSet_16u_C2R>::set, cv::gpu::setTo, NppSet<CV_16U, 4, nppiSet_16u_C4R>::set},
-                    {NppSet<CV_16S, 1, nppiSet_16s_C1R>::set, NppSet<CV_16S, 2, nppiSet_16s_C2R>::set, cv::gpu::setTo, NppSet<CV_16S, 4, nppiSet_16s_C4R>::set},
-                    {NppSet<CV_32S, 1, nppiSet_32s_C1R>::set, cv::gpu::setTo, cv::gpu::setTo, NppSet<CV_32S, 4, nppiSet_32s_C4R>::set},
-                    {NppSet<CV_32F, 1, nppiSet_32f_C1R>::set, cv::gpu::setTo, cv::gpu::setTo, NppSet<CV_32F, 4, nppiSet_32f_C4R>::set},
-                    {cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo}
+                    {NppSet<CV_8U , 1, nppiSet_8u_C1R >::call, cv::gpu::setTo                          , cv::gpu::setTo                        , NppSet<CV_8U , 4, nppiSet_8u_C4R >::call},
+                    {NppSet<CV_8S , 1, nppiSet_8s_C1R >::call, NppSet<CV_8S , 2, nppiSet_8s_C2R >::call, NppSet<CV_8S, 3, nppiSet_8s_C3R>::call, NppSet<CV_8S , 4, nppiSet_8s_C4R >::call},
+                    {NppSet<CV_16U, 1, nppiSet_16u_C1R>::call, NppSet<CV_16U, 2, nppiSet_16u_C2R>::call, cv::gpu::setTo                        , NppSet<CV_16U, 4, nppiSet_16u_C4R>::call},
+                    {NppSet<CV_16S, 1, nppiSet_16s_C1R>::call, NppSet<CV_16S, 2, nppiSet_16s_C2R>::call, cv::gpu::setTo                        , NppSet<CV_16S, 4, nppiSet_16s_C4R>::call},
+                    {NppSet<CV_32S, 1, nppiSet_32s_C1R>::call, cv::gpu::setTo                          , cv::gpu::setTo                        , NppSet<CV_32S, 4, nppiSet_32s_C4R>::call},
+                    {NppSet<CV_32F, 1, nppiSet_32f_C1R>::call, cv::gpu::setTo                          , cv::gpu::setTo                        , NppSet<CV_32F, 4, nppiSet_32f_C4R>::call},
+                    {cv::gpu::setTo                          , cv::gpu::setTo                          , cv::gpu::setTo                        , cv::gpu::setTo                          }
                 };
 
-                callers[m.depth()][m.channels() - 1](m, s);
+                CV_Assert(m.depth() <= CV_64F && m.channels() <= 4);
+
+                if (m.depth() == CV_64F)
+                {
+                    if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                        CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+                }
+
+                funcs[m.depth()][m.channels() - 1](m, s);
             }
             else
             {
-                typedef void (*caller_t)(GpuMat& src, Scalar s, const GpuMat& mask);
-
-                static const caller_t callers[7][4] =
+                typedef void (*func_t)(GpuMat& src, Scalar s, const GpuMat& mask);
+                static const func_t funcs[7][4] =
                 {
-                    {NppSetMask<CV_8U, 1, nppiSet_8u_C1MR>::set, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_8U, 4, nppiSet_8u_C4MR>::set},
-                    {cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo},
-                    {NppSetMask<CV_16U, 1, nppiSet_16u_C1MR>::set, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_16U, 4, nppiSet_16u_C4MR>::set},
-                    {NppSetMask<CV_16S, 1, nppiSet_16s_C1MR>::set, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_16S, 4, nppiSet_16s_C4MR>::set},
-                    {NppSetMask<CV_32S, 1, nppiSet_32s_C1MR>::set, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_32S, 4, nppiSet_32s_C4MR>::set},
-                    {NppSetMask<CV_32F, 1, nppiSet_32f_C1MR>::set, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_32F, 4, nppiSet_32f_C4MR>::set},
-                    {cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo}
+                    {NppSetMask<CV_8U , 1, nppiSet_8u_C1MR >::call, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_8U , 4, nppiSet_8u_C4MR >::call},
+                    {cv::gpu::setTo                               , cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo                               },
+                    {NppSetMask<CV_16U, 1, nppiSet_16u_C1MR>::call, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_16U, 4, nppiSet_16u_C4MR>::call},
+                    {NppSetMask<CV_16S, 1, nppiSet_16s_C1MR>::call, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_16S, 4, nppiSet_16s_C4MR>::call},
+                    {NppSetMask<CV_32S, 1, nppiSet_32s_C1MR>::call, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_32S, 4, nppiSet_32s_C4MR>::call},
+                    {NppSetMask<CV_32F, 1, nppiSet_32f_C1MR>::call, cv::gpu::setTo, cv::gpu::setTo, NppSetMask<CV_32F, 4, nppiSet_32f_C4MR>::call},
+                    {cv::gpu::setTo                               , cv::gpu::setTo, cv::gpu::setTo, cv::gpu::setTo                               }
                 };
 
-                callers[m.depth()][m.channels() - 1](m, s, mask);
+                CV_Assert(m.depth() <= CV_64F && m.channels() <= 4);
+
+                if (m.depth() == CV_64F)
+                {
+                    if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+                        CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+                }
+
+                funcs[m.depth()][m.channels() - 1](m, s, mask);
             }
         }