moved GpuMat's operations implementation to core module

modules/core/CMakeLists.txt

@@ -3,4 +3,132 @@ if(ZLIB_FOUND)
 else()
     include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../../3rdparty/zlib")
 endif()
-define_opencv_module(core ${ZLIB_LIBRARY})
+
+#define_opencv_module(core ${ZLIB_LIBRARY})
+
+set(name "core")
+
+project(opencv_${name})
+
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
+                    "${CMAKE_CURRENT_SOURCE_DIR}/src"
+                    "${CMAKE_CURRENT_BINARY_DIR}")
+
+file(GLOB lib_srcs "src/*.cpp")
+file(GLOB lib_int_hdrs "src/*.h*")
+file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")
+file(GLOB lib_hdrs_detail "include/opencv2/${name}/detail/*.h*")
+
+if(COMMAND get_module_external_sources)
+   get_module_external_sources(${name})
+endif()
+
+source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
+source_group("Include" FILES ${lib_hdrs})
+source_group("Include\\detail" FILES ${lib_hdrs_detail})
+list(APPEND lib_hdrs ${lib_hdrs_detail})
+
+if (HAVE_CUDA)
+    file(GLOB lib_cuda "src/cuda/*.cu")
+    source_group("Cuda" FILES "${lib_cuda}")
+ 
+    include_directories(${CUDA_INCLUDE_DIRS})
+    include_directories("${OpenCV_SOURCE_DIR}/modules/gpu/src")
+    include_directories("${OpenCV_SOURCE_DIR}/modules/gpu/src/cuda")
+ 
+    set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -gencode arch=compute_10,code=sm_10
+                                            -gencode arch=compute_11,code=sm_11
+                                            -gencode arch=compute_12,code=sm_12
+                                            -gencode arch=compute_13,code=sm_13
+                                            -gencode arch=compute_20,code=sm_20
+                                            -gencode arch=compute_20,code=sm_21)
+
+    if (UNIX OR APPLE)
+        set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS}  "-Xcompiler;-fPIC;")
+        #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" "-fPIC")
+    endif()
+
+    #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-keep")
+    #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;")
+    
+    if (APPLE)
+        set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;-fno-finite-math-only;")
+    endif()
+
+    CUDA_COMPILE(cuda_objs ${lib_cuda})
+    #CUDA_BUILD_CLEAN_TARGET()
+endif()
+
+set(the_target "opencv_${name}")
+add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${cuda_objs})
+
+# For dynamic link numbering convenions
+if(NOT ANDROID)
+    # Android SDK build scripts can include only .so files into final .apk
+    # As result we should not set version properties for Android
+    set_target_properties(${the_target} PROPERTIES
+        VERSION ${OPENCV_VERSION}
+        SOVERSION ${OPENCV_SOVERSION}
+        )
+endif()
+
+set_target_properties(${the_target} PROPERTIES OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}" )    
+
+if(ENABLE_SOLUTION_FOLDERS)
+    set_target_properties(${the_target} PROPERTIES FOLDER "modules")
+endif() 
+        
+if (BUILD_SHARED_LIBS)
+    if(MSVC)
+        set_target_properties(${the_target} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)
+    else()
+        add_definitions(-DCVAPI_EXPORTS)        
+    endif()
+endif()
+
+# Additional target properties
+set_target_properties(${the_target} PROPERTIES
+    DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
+    ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
+    RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+    INSTALL_NAME_DIR lib
+    )
+
+# Add the required libraries for linking:
+target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ZLIB_LIBRARY})
+
+if (HAVE_CUDA)
+    target_link_libraries(${the_target} ${CUDA_LIBRARIES})
+
+    unset(CUDA_npp_LIBRARY CACHE)
+    find_cuda_helper_libs(npp)
+    target_link_libraries(${the_target} ${CUDA_npp_LIBRARY})
+endif()
+
+if(MSVC)
+    if(CMAKE_CROSSCOMPILING)
+        set_target_properties(${the_target} PROPERTIES
+            LINK_FLAGS "/NODEFAULTLIB:secchk"
+            )
+    endif()
+    set_target_properties(${the_target} PROPERTIES
+        LINK_FLAGS "/NODEFAULTLIB:libc /DEBUG"
+        )
+endif()
+
+# Dependencies of this target:
+add_dependencies(${the_target} ${ZLIB_LIBRARY})
+
+install(TARGETS ${the_target}
+    RUNTIME DESTINATION bin COMPONENT main
+    LIBRARY DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main
+    ARCHIVE DESTINATION ${OPENCV_LIB_INSTALL_PATH} COMPONENT main)
+
+install(FILES ${lib_hdrs}
+    DESTINATION ${OPENCV_INCLUDE_PREFIX}/opencv2/${name}
+    COMPONENT main)
+    
+add_opencv_precompiled_headers(${the_target})
+
+define_opencv_test(${name})
+define_opencv_perf_test(${name})

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

@@ -212,27 +212,9 @@ namespace cv { namespace gpu
     CV_EXPORTS void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m);
     CV_EXPORTS void ensureSizeIsEnough(Size size, int type, GpuMat& m);
 
-    class CV_EXPORTS GpuFuncTable
-    {
-    public:
-        virtual ~GpuFuncTable() {}
-
-        virtual void copy(const Mat& src, GpuMat& dst) const = 0;
-        virtual void copy(const GpuMat& src, Mat& dst) const = 0;
-        virtual void copy(const GpuMat& src, GpuMat& dst) const = 0;
-
-        virtual void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask) const = 0;
-
-        virtual void convert(const GpuMat& src, GpuMat& dst) const = 0;
-        virtual void convert(const GpuMat& src, GpuMat& dst, double alpha, double beta) const = 0;
-
-        virtual void setTo(GpuMat& m, Scalar s, const GpuMat& mask) const = 0;
-
-        virtual void mallocPitch(void** devPtr, size_t* step, size_t width, size_t height) const = 0;
-        virtual void free(void* devPtr) const = 0;
-    };
+    //////////////////////////////// Error handling ////////////////////////
 
-    CV_EXPORTS void setGpuFuncTable(const GpuFuncTable* funcTbl);
+    CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func);
 
     ////////////////////////////////////////////////////////////////////////
 

modules/gpu/src/cuda/matrix_operations.cu → modules/core/src/cuda/matrix_operations.cu

@@ -40,7 +40,6 @@
 //
 //M*/
 
-#include "internal_shared.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
@@ -75,7 +74,7 @@ namespace cv { namespace gpu { namespace device
     }
 
     template<typename T>
-    void copy_to_with_mask_run(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+    void copy_to_with_mask_run(DevMem2Db mat_src, DevMem2Db mat_dst, DevMem2Db mask, int channels, cudaStream_t stream)
     {
         dim3 threadsPerBlock(16,16, 1);
         dim3 numBlocks ( divUp(mat_src.cols * channels , threadsPerBlock.x) , divUp(mat_src.rows , threadsPerBlock.y), 1);
@@ -88,9 +87,9 @@ namespace cv { namespace gpu { namespace device
             cudaSafeCall ( cudaDeviceSynchronize() );
     }
 
-    void copy_to_with_mask(const DevMem2Db& mat_src, DevMem2Db mat_dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+    void copy_to_with_mask(DevMem2Db mat_src, DevMem2Db mat_dst, int depth, DevMem2Db mask, int channels, cudaStream_t stream)
     {
-        typedef void (*CopyToFunc)(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream);
+        typedef void (*CopyToFunc)(DevMem2Db mat_src, DevMem2Db mat_dst, DevMem2Db mask, int channels, cudaStream_t stream);
 
         static CopyToFunc tab[8] =
         {
@@ -106,7 +105,8 @@ namespace cv { namespace gpu { namespace device
 
         CopyToFunc func = tab[depth];
 
-        if (func == 0) cv::gpu::error("Unsupported copyTo operation", __FILE__, __LINE__);
+        if (func == 0) 
+            cv::gpu::error("Unsupported copyTo operation", __FILE__, __LINE__);
 
         func(mat_src, mat_dst, mask, channels, stream);
     }
@@ -188,7 +188,7 @@ namespace cv { namespace gpu { namespace device
             }
     }
     template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream)
+    void set_to_gpu(DevMem2Db mat, const T* scalar, DevMem2Db mask, int channels, cudaStream_t stream)
     {
         writeScalar(scalar);
 
@@ -202,16 +202,16 @@ namespace cv { namespace gpu { namespace device
             cudaSafeCall ( cudaDeviceSynchronize() );
     }
 
-    template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<uchar >(DevMem2Db mat, const uchar*  scalar, DevMem2Db mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<schar >(DevMem2Db mat, const schar*  scalar, DevMem2Db mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<ushort>(DevMem2Db mat, const ushort* scalar, DevMem2Db mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<short >(DevMem2Db mat, const short*  scalar, DevMem2Db mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<int   >(DevMem2Db mat, const int*    scalar, DevMem2Db mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<float >(DevMem2Db mat, const float*  scalar, DevMem2Db mask, int channels, cudaStream_t stream);
+    template void set_to_gpu<double>(DevMem2Db mat, const double* scalar, DevMem2Db mask, int channels, cudaStream_t stream);
 
     template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream)
+    void set_to_gpu(DevMem2Db mat, const T* scalar, int channels, cudaStream_t stream)
     {
         writeScalar(scalar);
 
@@ -225,13 +225,13 @@ namespace cv { namespace gpu { namespace device
             cudaSafeCall ( cudaDeviceSynchronize() );
     }
 
-    template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<uchar >(DevMem2Db mat, const uchar*  scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<schar >(DevMem2Db mat, const schar*  scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<ushort>(DevMem2Db mat, const ushort* scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<short >(DevMem2Db mat, const short*  scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<int   >(DevMem2Db mat, const int*    scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<float >(DevMem2Db mat, const float*  scalar, int channels, cudaStream_t stream);
+    template void set_to_gpu<double>(DevMem2Db mat, const double* scalar, int channels, cudaStream_t stream);
 
     ///////////////////////////////////////////////////////////////////////////
     //////////////////////////////// ConvertTo ////////////////////////////////
@@ -298,7 +298,7 @@ namespace cv { namespace gpu { namespace device
     };
         
     template<typename T, typename D>
-    void cvt_(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, cudaStream_t stream)
+    void cvt_(DevMem2Db src, DevMem2Db dst, double alpha, double beta, cudaStream_t stream)
     {
         cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
         cudaSafeCall( cudaSetDoubleForDevice(&beta) );
@@ -306,11 +306,9 @@ namespace cv { namespace gpu { namespace device
         ::cv::gpu::device::transform((DevMem2D_<T>)src, (DevMem2D_<D>)dst, op, stream);
     }
 
-    void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, 
-        cudaStream_t stream = 0)
+    void convert_gpu(DevMem2Db src, int sdepth, DevMem2Db dst, int ddepth, double alpha, double beta, cudaStream_t stream)
     {
-        typedef void (*caller_t)(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, 
-            cudaStream_t stream);
+        typedef void (*caller_t)(DevMem2Db src, DevMem2Db dst, double alpha, double beta, cudaStream_t stream);
 
         static const caller_t tab[8][8] =
         {

modules/gpu/include/opencv2/gpu/gpu.hpp

@@ -139,10 +139,6 @@ private:
     int minorVersion_;
 };
 
-//////////////////////////////// Error handling ////////////////////////
-
-CV_EXPORTS void error(const char *error_string, const char *file, const int line, const char *func);
-
 //////////////////////////////// CudaMem ////////////////////////////////
 // CudaMem is limited cv::Mat with page locked memory allocation.
 // Page locked memory is only needed for async and faster coping to GPU.

modules/gpu/src/cuda/internal_shared.hpp

@@ -49,36 +49,6 @@
 #include "opencv2/gpu/devmem2d.hpp"
 #include "safe_call.hpp"
 
-#ifndef CV_PI
-#define CV_PI   3.1415926535897932384626433832795
-#endif
-
-#ifndef CV_PI_F
-  #ifndef CV_PI
-    #define CV_PI_F 3.14159265f
-  #else
-    #define CV_PI_F ((float)CV_PI)
-  #endif
-#endif
-
-#ifdef __CUDACC__
-
-namespace cv { namespace gpu { namespace device 
-{
-    typedef unsigned char uchar;
-    typedef unsigned short ushort;
-    typedef signed char schar;
-    typedef unsigned int uint;
-
-    template<class T> static inline void bindTexture(const textureReference* tex, const DevMem2D_<T>& img)
-    {
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
-        cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
-    }
-}}}
-
-#endif
-
 namespace cv { namespace gpu 
 {
     enum 
@@ -94,8 +64,6 @@ namespace cv { namespace gpu
     // Returns true if the GPU analogue exists, false otherwise.
     bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
 
-    static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
-
     class NppStreamHandler
     {
     public:

modules/gpu/src/cuda/safe_call.hpp

@@ -69,36 +69,36 @@ namespace cv { namespace gpu
     void ncvError(int err, const char *file, const int line, const char *func = "");
     void cufftError(int err, const char *file, const int line, const char *func = "");
     void cublasError(int err, const char *file, const int line, const char *func = "");
+}}
 
-    static 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);
-    }
+static 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);
+}
 
-    static inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
-    {
-        if (err < 0)
-            cv::gpu::nppError(err, file, line, func);
-    }
+static inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
+{
+    if (err < 0)
+        cv::gpu::nppError(err, file, line, func);
+}
 
-    static inline void ___ncvSafeCall(int err, const char *file, const int line, const char *func = "")
-    {
-        if (NCV_SUCCESS != err)
-            cv::gpu::ncvError(err, file, line, func);
-    }
+static inline void ___ncvSafeCall(int err, const char *file, const int line, const char *func = "")
+{
+    if (NCV_SUCCESS != err)
+        cv::gpu::ncvError(err, file, line, func);
+}
 
-    static inline void ___cufftSafeCall(cufftResult_t err, const char *file, const int line, const char *func = "")
-    {
-        if (CUFFT_SUCCESS != err)
-            cv::gpu::cufftError(err, file, line, func);
-    }
+static inline void ___cufftSafeCall(cufftResult_t err, const char *file, const int line, const char *func = "")
+{
+    if (CUFFT_SUCCESS != err)
+        cv::gpu::cufftError(err, file, line, func);
+}
 
-    static inline void ___cublasSafeCall(cublasStatus_t err, const char *file, const int line, const char *func = "")
-    {
-        if (CUBLAS_STATUS_SUCCESS != err)
-            cv::gpu::cublasError(err, file, line, func);
-    }
-}}
+static inline void ___cublasSafeCall(cublasStatus_t err, const char *file, const int line, const char *func = "")
+{
+    if (CUBLAS_STATUS_SUCCESS != err)
+        cv::gpu::cublasError(err, file, line, func);
+}
 
 #endif /* __OPENCV_CUDA_SAFE_CALL_HPP__ */
\ No newline at end of file

modules/gpu/src/cudastream.cpp

@@ -71,19 +71,13 @@ cv::gpu::Stream::operator bool() const { throw_nogpu(); return false; }
 
 #include "opencv2/gpu/stream_accessor.hpp"
 
-namespace cv { namespace gpu { namespace device 
+namespace cv { namespace gpu
 {
-    void copy_to_with_mask(const DevMem2Db& src, DevMem2Db dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream = 0);
-
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream);
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-
-    void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, cudaStream_t stream = 0);
-}}}
-
-using namespace ::cv::gpu::device;
+    void copyWithMask(const GpuMat& src, GpuMat& dst, const GpuMat& mask, cudaStream_t stream);
+    void convertTo(const GpuMat& src, GpuMat& dst, double alpha, double beta, cudaStream_t stream);
+    void setTo(GpuMat& src, Scalar s, cudaStream_t stream);
+    void setTo(GpuMat& src, Scalar s, const GpuMat& mask, cudaStream_t stream);
+}}
 
 struct Stream::Impl
 {
@@ -99,20 +93,6 @@ namespace
         size_t bwidth = src.cols * src.elemSize();
         cudaSafeCall( cudaMemcpy2DAsync(dst.data, dst.step, src.data, src.step, bwidth, src.rows, k, s) );
     };
-
-    template <typename T>
-    void kernelSet(GpuMat& src, const Scalar& s, cudaStream_t stream)
-    {
-        Scalar_<T> sf = s;
-        set_to_gpu(src, sf.val, src.channels(), stream);
-    }
-
-    template <typename T>
-    void kernelSetMask(GpuMat& src, const Scalar& s, const GpuMat& mask, cudaStream_t stream)
-    {
-        Scalar_<T> sf = s;
-        set_to_gpu(src, sf.val, mask, src.channels(), stream);
-    }
 }
 
 CV_EXPORTS cudaStream_t cv::gpu::StreamAccessor::getStream(const Stream& stream) { return stream.impl ? stream.impl->stream : 0; };
@@ -208,13 +188,7 @@ void cv::gpu::Stream::enqueueMemSet(GpuMat& src, Scalar s)
         }
     }
 
-    typedef void (*set_caller_t)(GpuMat& src, const Scalar& s, cudaStream_t stream);
-    static const set_caller_t set_callers[] =
-    {
-        kernelSet<uchar>, kernelSet<schar>, kernelSet<ushort>, kernelSet<short>,
-        kernelSet<int>, kernelSet<float>, kernelSet<double>
-    };
-    set_callers[src.depth()](src, s, impl->stream);
+    setTo(src, s, impl->stream);
 }
 
 void cv::gpu::Stream::enqueueMemSet(GpuMat& src, Scalar val, const GpuMat& mask)
@@ -224,13 +198,7 @@ void cv::gpu::Stream::enqueueMemSet(GpuMat& src, Scalar val, const GpuMat& mask)
 
     CV_Assert(mask.type() == CV_8UC1);
 
-    typedef void (*set_caller_t)(GpuMat& src, const Scalar& s, const GpuMat& mask, cudaStream_t stream);
-    static const set_caller_t set_callers[] =
-    {
-        kernelSetMask<uchar>, kernelSetMask<schar>, kernelSetMask<ushort>, kernelSetMask<short>,
-        kernelSetMask<int>, kernelSetMask<float>, kernelSetMask<double>
-    };
-    set_callers[src.depth()](src, val, mask, impl->stream);
+    setTo(src, val, mask, impl->stream);
 }
 
 void cv::gpu::Stream::enqueueConvert(const GpuMat& src, GpuMat& dst, int rtype, double alpha, double beta)
@@ -258,7 +226,7 @@ void cv::gpu::Stream::enqueueConvert(const GpuMat& src, GpuMat& dst, int rtype,
         psrc = &(temp = src);
 
     dst.create( src.size(), rtype );
-    convert_gpu(psrc->reshape(1), sdepth, dst.reshape(1), ddepth, alpha, beta, impl->stream);
+    convertTo(src, dst, alpha, beta, impl->stream);
 }
 
 cv::gpu::Stream::operator bool() const

modules/gpu/src/error.cpp

@@ -220,22 +220,6 @@ namespace cv
 {
     namespace gpu
     {
-        void error(const char *error_string, const char *file, const int line, const char *func)
-        {          
-            int code = CV_GpuApiCallError;
-
-            if (uncaught_exception())
-            {
-                const char* errorStr = cvErrorStr(code);            
-                const char* function = func ? func : "unknown function";    
-
-                cerr << "OpenCV Error: " << errorStr << "(" << error_string << ") in " << function << ", file " << file << ", line " << line;
-                cerr.flush();            
-            }
-            else    
-                cv::error( cv::Exception(code, error_string, func, file, line) );
-        }
-
         void nppError(int code, const char *file, const int line, const char *func)
         {
             string msg = getErrorString(code, npp_errors, npp_error_num);

modules/gpu/src/opencv2/gpu/device/border_interpolate.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
 #define __OPENCV_GPU_BORDER_INTERPOLATE_HPP__
 
-#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "vec_traits.hpp"
 #include "vec_math.hpp"

modules/gpu/src/opencv2/gpu/device/color.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_COLOR_HPP__
 #define __OPENCV_GPU_COLOR_HPP__
 
-#include "internal_shared.hpp"
 #include "detail/color_detail.hpp"
 
 namespace cv { namespace gpu { namespace device 

modules/gpu/src/opencv2/gpu/device/common.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) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// 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 materials 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*/
+
+#ifndef __OPENCV_GPU_COMMON_HPP__
+#define __OPENCV_GPU_COMMON_HPP__
+
+#include <cuda_runtime.h>
+#include "opencv2/core/devmem2d.hpp"
+
+#ifndef CV_PI
+    #define CV_PI   3.1415926535897932384626433832795
+#endif
+
+#ifndef CV_PI_F
+    #ifndef CV_PI
+        #define CV_PI_F 3.14159265f
+    #else
+        #define CV_PI_F ((float)CV_PI)
+    #endif
+#endif
+
+namespace cv { namespace gpu 
+{     
+    __host__ __device__ __forceinline__ int divUp(int total, int grain) 
+    { 
+        return (total + grain - 1) / grain; 
+    }
+
+    namespace device 
+    {
+        typedef unsigned char uchar;
+        typedef unsigned short ushort;
+        typedef signed char schar;
+        typedef unsigned int uint;
+
+        template<class T> inline void bindTexture(const textureReference* tex, const DevMem2D_<T>& img)
+        {
+            cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+            cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+        }
+    }
+}}
+
+#if defined(__GNUC__)
+    #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
+#else /* defined(__CUDACC__) || defined(__MSVC__) */
+    #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__)
+#endif
+
+namespace cv { namespace gpu 
+{
+    void error(const char *error_string, const char *file, const int line, const char *func = "");
+}}
+
+static 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);
+}
+
+#endif // __OPENCV_GPU_COMMON_HPP__

modules/gpu/src/opencv2/gpu/device/datamov_utils.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_DATAMOV_UTILS_HPP__
 #define __OPENCV_GPU_DATAMOV_UTILS_HPP__
 
-#include "internal_shared.hpp"
+#include "common.hpp"
 
 namespace cv { namespace gpu { namespace device 
 {

modules/gpu/src/opencv2/gpu/device/detail/color_detail.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_COLOR_DETAIL_HPP__
 #define __OPENCV_GPU_COLOR_DETAIL_HPP__
 
-#include "internal_shared.hpp"
+#include "../common.hpp"
 #include "../vec_traits.hpp"
 #include "../saturate_cast.hpp"
 #include "../limits.hpp"

modules/gpu/src/opencv2/gpu/device/detail/transform_detail.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
 #define __OPENCV_GPU_TRANSFORM_DETAIL_HPP__
 
-#include "internal_shared.hpp"
+#include "../common.hpp"
 #include "../vec_traits.hpp"
 #include "../functional.hpp"
 

modules/gpu/src/opencv2/gpu/device/detail/type_traits_detail.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
 #define __OPENCV_GPU_TYPE_TRAITS_DETAIL_HPP__
 
-#include "internal_shared.hpp"
+#include "../common.hpp"
 #include "../vec_traits.hpp"
 
 namespace cv { namespace gpu { namespace device 

modules/gpu/src/opencv2/gpu/device/detail/utility_detail.hpp

@@ -43,8 +43,6 @@
 #ifndef __OPENCV_GPU_UTILITY_DETAIL_HPP__
 #define __OPENCV_GPU_UTILITY_DETAIL_HPP__
 
-#include "internal_shared.hpp"
-
 namespace cv { namespace gpu { namespace device 
 {
     namespace utility_detail

modules/gpu/src/opencv2/gpu/device/detail/vec_distance_detail.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
 #define __OPENCV_GPU_VEC_DISTANCE_DETAIL_HPP__
 
-#include "internal_shared.hpp"
 #include "../datamov_utils.hpp"
 
 namespace cv { namespace gpu { namespace device 

modules/gpu/src/opencv2/gpu/device/dynamic_smem.hpp

@@ -43,41 +43,38 @@
 #ifndef __OPENCV_GPU_DYNAMIC_SMEM_HPP__
 #define __OPENCV_GPU_DYNAMIC_SMEM_HPP__
 
-#include "internal_shared.hpp"
-
-BEGIN_OPENCV_DEVICE_NAMESPACE
-   
-template<class T> struct DynamicSharedMem
-{
-    __device__ __forceinline__ operator T*()
-    {
-        extern __shared__ int __smem[];
-        return (T*)__smem;
-    }
-
-    __device__ __forceinline__ operator const T*() const
+namespace cv { namespace gpu { namespace device
+{   
+    template<class T> struct DynamicSharedMem
     {
-        extern __shared__ int __smem[];
-        return (T*)__smem;
-    }
-};
+        __device__ __forceinline__ operator T*()
+        {
+            extern __shared__ int __smem[];
+            return (T*)__smem;
+        }
 
-// specialize for double to avoid unaligned memory access compile errors
-template<> struct DynamicSharedMem<double>
-{
-    __device__ __forceinline__ operator double*()
-    {
-        extern __shared__ double __smem_d[];
-        return (double*)__smem_d;
-    }
+        __device__ __forceinline__ operator const T*() const
+        {
+            extern __shared__ int __smem[];
+            return (T*)__smem;
+        }
+    };
 
-    __device__ __forceinline__ operator const double*() const
+    // specialize for double to avoid unaligned memory access compile errors
+    template<> struct DynamicSharedMem<double>
     {
-        extern __shared__ double __smem_d[];
-        return (double*)__smem_d;
-    }
-};
+        __device__ __forceinline__ operator double*()
+        {
+            extern __shared__ double __smem_d[];
+            return (double*)__smem_d;
+        }
 
-END_OPENCV_DEVICE_NAMESPACE
+        __device__ __forceinline__ operator const double*() const
+        {
+            extern __shared__ double __smem_d[];
+            return (double*)__smem_d;
+        }
+    };
+}}}
 
 #endif // __OPENCV_GPU_DYNAMIC_SMEM_HPP__

modules/gpu/src/opencv2/gpu/device/emulation.hpp

@@ -43,7 +43,6 @@
 #ifndef OPENCV_GPU_EMULATION_HPP_
 #define OPENCV_GPU_EMULATION_HPP_
 
-#include "internal_shared.hpp"
 #include "warp_reduce.hpp"
 
 namespace cv { namespace gpu { namespace device 

modules/gpu/src/opencv2/gpu/device/filters.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_FILTERS_HPP__
 #define __OPENCV_GPU_FILTERS_HPP__
 
-#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "vec_traits.hpp"
 #include "vec_math.hpp"

modules/gpu/src/opencv2/gpu/device/funcattrib.hpp

@@ -45,7 +45,6 @@
 #define __OPENCV_GPU_DEVICE_FUNCATTRIB_HPP_
 
 #include <cstdio>
-#include "internal_shared.hpp"
 
 namespace cv { namespace gpu { namespace device 
 {

modules/gpu/src/opencv2/gpu/device/functional.hpp

@@ -44,7 +44,6 @@
 #define __OPENCV_GPU_FUNCTIONAL_HPP__
 
 #include <thrust/functional.h>
-#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "vec_traits.hpp"
 #include "type_traits.hpp"

modules/gpu/src/opencv2/gpu/device/limits.hpp

@@ -44,7 +44,7 @@
 #define __OPENCV_GPU_LIMITS_GPU_HPP__
 
 #include <limits>
-#include "internal_shared.hpp"
+#include "common.hpp"
 
 namespace cv { namespace gpu { namespace device 
 {

modules/gpu/src/opencv2/gpu/device/saturate_cast.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_SATURATE_CAST_HPP__
 #define __OPENCV_GPU_SATURATE_CAST_HPP__
 
-#include "internal_shared.hpp"
+#include "common.hpp"
 
 namespace cv { namespace gpu { namespace device
 {

modules/gpu/src/opencv2/gpu/device/transform.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_TRANSFORM_HPP__
 #define __OPENCV_GPU_TRANSFORM_HPP__
 
-#include "internal_shared.hpp"
+#include "common.hpp"
 #include "utility.hpp"
 #include "detail/transform_detail.hpp"
 

modules/gpu/src/opencv2/gpu/device/type_traits.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_TYPE_TRAITS_HPP__
 #define __OPENCV_GPU_TYPE_TRAITS_HPP__
 
-#include "internal_shared.hpp"
 #include "detail/type_traits_detail.hpp"
 
 namespace cv { namespace gpu { namespace device 

modules/gpu/src/opencv2/gpu/device/utility.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_UTILITY_HPP__
 #define __OPENCV_GPU_UTILITY_HPP__
 
-#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "datamov_utils.hpp"
 #include "detail/utility_detail.hpp"

modules/gpu/src/opencv2/gpu/device/vec_distance.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_VEC_DISTANCE_HPP__
 #define __OPENCV_GPU_VEC_DISTANCE_HPP__
 
-#include "internal_shared.hpp"
 #include "utility.hpp"
 #include "functional.hpp"
 #include "detail/vec_distance_detail.hpp"

modules/gpu/src/opencv2/gpu/device/vec_math.hpp

@@ -43,7 +43,6 @@
 #ifndef __OPENCV_GPU_VECMATH_HPP__
 #define __OPENCV_GPU_VECMATH_HPP__
 
-#include "internal_shared.hpp"
 #include "saturate_cast.hpp"
 #include "vec_traits.hpp"
 #include "functional.hpp"

modules/gpu/src/opencv2/gpu/device/vec_traits.hpp

@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_VEC_TRAITS_HPP__
 #define __OPENCV_GPU_VEC_TRAITS_HPP__
 
-#include "internal_shared.hpp"
+#include "common.hpp"
 
 namespace cv { namespace gpu { namespace device 
 {

modules/gpu/src/opencv2/gpu/device/warp.hpp

@@ -43,8 +43,6 @@
 #ifndef __OPENCV_GPU_DEVICE_WARP_HPP__
 #define __OPENCV_GPU_DEVICE_WARP_HPP__
 
-#include "internal_shared.hpp"
-
 namespace cv { namespace gpu { namespace device 
 {
     struct Warp

modules/gpu/src/opencv2/gpu/device/warp_reduce.hpp

@@ -44,8 +44,6 @@
 #ifndef OPENCV_GPU_WARP_REDUCE_HPP__
 #define OPENCV_GPU_WARP_REDUCE_HPP__
 
-#include "internal_shared.hpp"
-
 namespace cv { namespace gpu { namespace device 
 {		
     template <class T>