added support to build without cuda.

2c84a66e · Anatoly Baksheev · e1bd5aea · 2c84a66e · 2c84a66e · 2c84a66e
9 changed file
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -282,6 +282,7 @@ endif()

 set(WITH_TBB OFF CACHE BOOL "Include TBB support")
 set(WITH_EIGEN2 ON CACHE BOOL "Include Eigen2 support")
+set(WITH_CUDA OFF CACHE BOOL "Include NVidia Cuda Runtime support")

 # ===================================================
 # Macros that checks if module have been installed.
@@ -608,6 +609,15 @@ if (WITH_TBB)
    endif()
 endif()

+############################### TBB ################################
+
+if (WITH_CUDA)
+	find_package(CUDA)	
+	if (CUDA_FOUND)
+		message(STATUS "CUDA detected.")	
+		set(HAVE_CUDA 1)
+	endif()
+endif()

 ############################## Eigen2 ##############################

@@ -1249,6 +1259,12 @@ else()
 message(STATUS "    Use TBB:                   NO")
 endif()

+if (HAVE_CUDA)
+message(STATUS "    Uue Cuda:                  YES")
+else()
+message(STATUS "    Use Cuda:                  No")
+endif()
+
 if(HAVE_EIGEN2)
 message(STATUS "    Use Eigen2:                YES")
 else()

--- a/cvconfig.h.cmake
+++ b/cvconfig.h.cmake
@@ -165,3 +165,6 @@

 /* Qt bindings use OpenGL */
 #cmakedefine  HAVE_HAVE_QT_OPENGL
+
+/* NVidia Cuda Runtime API*/
+#cmakedefine HAVE_CUDA
--- a/modules/core/include/opencv2/core/types_c.h
+++ b/modules/core/include/opencv2/core/types_c.h
@@ -229,7 +229,9 @@ enum {
 CV_StsParseError=             -212, /* invalid syntax/structure of the parsed file */
 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_StsAssert=                 -215, /* assertion failed */    
+ CV_GpuNotFound=               -216,  
+ CV_GpuApiCallError=           -217 
 };

 /****************************************************************************************\

--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt

-include(FindCUDA)
+set(name "gpu")	
+set(DEPS "opencv_core")
 	
-if (CUDA_FOUND)
-    include_directories(${CUDA_INCLUDE_DIRS})
-    link_directories(${CUDA_LIBRARIES})
-
-    #message ("CUDA_LIBRARIES = ${CUDA_LIBRARIES}")
-    #message ("CUDA_INCLUDE_DIRS = ${CUDA_INCLUDE_DIRS}")
-    #message ("CUDA_TARGET_LINK = ${CUDA_TARGET_LINK}")
-
-
-	#CUDA_GENERATED_OUTPUT_DIR (Default CMAKE_CURRENT_BINARY_DIR)

-	#====================================================================================
+set(the_target "opencv_${name}")

-	set(name "gpu")	
-	set(DEPS "opencv_core")
+project(${the_target})

-	project(opencv_${name})
-	add_definitions(-DCVAPI_EXPORTS)
+add_definitions(-DCVAPI_EXPORTS)

-	include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
 					"${CMAKE_CURRENT_SOURCE_DIR}/cuda"
 					"${CMAKE_CURRENT_SOURCE_DIR}/src"
 					"${CMAKE_CURRENT_BINARY_DIR}")

-	foreach(d ${DEPS})
+foreach(d ${DEPS})
 	if(${d} MATCHES "opencv_")			
 		string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
 		include_directories("${d_dir}/include")			
 	endif()
-  	endforeach()		
+endforeach()		

-	file(GLOB lib_srcs "src/*.cpp")
-	file(GLOB lib_int_hdrs "src/*.h*")
-        file(GLOB lib_cuda "cuda/*.cu")
-	file(GLOB lib_cuda_hdrs "cuda/*.h*")	
-	source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
-	source_group("Cuda" FILES ${lib_cuda} ${lib_cuda_hdrs})
+file(GLOB lib_srcs "src/*.cpp")
+file(GLOB lib_int_hdrs "src/*.h*")
+file(GLOB lib_cuda "cuda/*.cu")
+file(GLOB lib_cuda_hdrs "cuda/*.h*")	
+source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
+source_group("Cuda" FILES ${lib_cuda} ${lib_cuda_hdrs})

-	file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")		
-	source_group("Include" FILES ${lib_hdrs})
+file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")		
+source_group("Include" FILES ${lib_hdrs})
+
+if (HAVE_CUDA)
+	include_directories(${CUDA_INCLUDE_DIRS})
+	link_directories(${CUDA_LIBRARIES})

 	if (UNIX OR APPLE)
 		set (CUDA_NVCC_FLAGS "-Xcompiler;-fPIC")
 	endif()
 	
 	CUDA_COMPILE(cuda_objs ${lib_cuda})
-        #message ("lib cuda : ${cuda_objs}")
 	#CUDA_BUILD_CLEAN_TARGET()
+endif()
 	
-	set(the_target "opencv_${name}")
-        #message ("cuda_add_library : ${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs}")
-        add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${cuda_objs})

-	if(PCHSupport_FOUND)
+add_library(${the_target} ${lib_srcs} ${lib_hdrs} ${lib_int_hdrs} ${lib_cuda} ${lib_cuda_hdrs} ${cuda_objs})
+
+if(PCHSupport_FOUND)
 	set(pch_header ${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp)
 	if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
 		if(${CMAKE_GENERATOR} MATCHES "Visual*")
@@ -64,28 +56,27 @@ if (CUDA_FOUND)
 	elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
 		add_precompiled_header(${the_target} ${pch_header})
 	endif()
-	endif()
+endif()

-	# For dynamic link numbering convenions
-	set_target_properties(${the_target} PROPERTIES
+# For dynamic link numbering convenions
+set_target_properties(${the_target} PROPERTIES
 	VERSION ${OPENCV_VERSION}
 	SOVERSION ${OPENCV_SOVERSION}
 	OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}"
 	)

-	# Additional target properties
-	set_target_properties(${the_target} PROPERTIES
+# Additional target properties
+set_target_properties(${the_target} PROPERTIES
 	DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
 	ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/"
 	RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
 	INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
 	)

-        # Add the required libraries for linking:
-        #message (" ++++ target_link_libraries = ${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES}")
-	target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES})
+# Add the required libraries for linking:
+target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES})

-	if(MSVC)
+if(MSVC)
 	if(CMAKE_CROSSCOMPILING)
 		set_target_properties(${the_target} PROPERTIES
 			LINK_FLAGS "/NODEFAULTLIB:secchk"
@@ -94,19 +85,18 @@ if (CUDA_FOUND)
 	set_target_properties(${the_target} PROPERTIES
 		LINK_FLAGS "/NODEFAULTLIB:libc"
 		)
-	endif()
+endif()

-	# Dependencies of this target:
-	add_dependencies(${the_target} ${DEPS})
+# Dependencies of this target:
+add_dependencies(${the_target} ${DEPS})

-	install(TARGETS ${the_target}
+install(TARGETS ${the_target}
 	RUNTIME DESTINATION bin COMPONENT main
 	LIBRARY DESTINATION lib COMPONENT main
 	ARCHIVE DESTINATION lib COMPONENT main)

-	install(FILES ${lib_hdrs}
+install(FILES ${lib_hdrs}
 	DESTINATION include/opencv2/${name}
 	COMPONENT main)

-endif()

--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -216,6 +216,9 @@ namespace cv
        class CudaStream
        {
        public:
+
+            static CudaStream empty();
+
            CudaStream(); 
            ~CudaStream();

@@ -236,9 +239,13 @@ namespace cv
            // converts matrix type, ex from float to uchar depending on type
            void enqueueConvert(const GpuMat& src, GpuMat& dst, int type); 
            
-            //CUstream_st& getStream();
+            struct Impl;
+            const Impl& getImpl() const;
        private:
-            void *impl;
+            
+            Impl *impl;            
+
+            
            
            CudaStream(const CudaStream&); 
            CudaStream& operator=(const CudaStream&);

--- a/modules/gpu/src/cudastream.cpp
+++ b/modules/gpu/src/cudastream.cpp
@@ -41,33 +41,37 @@
 //M*/

 #include "precomp.hpp"
+#include "opencv2/gpu/stream_access.hpp"

 using namespace cv;
 using namespace cv::gpu;


-cv::gpu::CudaStream::CudaStream() : impl( fastMalloc(sizeof(cudaStream_t)) )
+cv::gpu::CudaStream::CudaStream() : impl( (Impl*)fastMalloc(sizeof(Impl)) )
 {
-    cudaSafeCall( cudaStreamCreate((cudaStream_t*)impl) );
+    //cudaSafeCall( cudaStreamCreate( &impl->stream) );
 }
 cv::gpu::CudaStream::~CudaStream() 
 { 
+    if (impl)
+    {
        cudaSafeCall( cudaStreamDestroy( *(cudaStream_t*)impl ) );
        cv::fastFree( impl );
+    }         
 }

 bool cv::gpu::CudaStream::queryIfComplete()
 {
-    cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl );
+    //cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl );

-    if (err == cudaSuccess)
-        return true;
+    //if (err == cudaSuccess)
+    //    return true;

-    if (err == cudaErrorNotReady)
-        return false;
+    //if (err == cudaErrorNotReady)
+    //    return false;

-    //cudaErrorInvalidResourceHandle  
-    cudaSafeCall( err );    
+    ////cudaErrorInvalidResourceHandle  
+    //cudaSafeCall( err );    
    return true;
 }
 void cv::gpu::CudaStream::waitForCompletion()

--- a/modules/gpu/src/initialization.cpp
+++ b/modules/gpu/src/initialization.cpp
@@ -45,6 +45,16 @@
 using namespace cv;
 using namespace cv::gpu;

+#ifndef HAVE_CUDA
+
+CV_EXPORTS int cv::gpu::getCudaEnabledDeviceCount() { return 0; }
+CV_EXPORTS string cv::gpu::getDeviceName(int /*device*/)  { cudaSafeCall(0); return 0; } 
+CV_EXPORTS void cv::gpu::setDevice(int /*device*/) { cudaSafeCall(0); } 
+CV_EXPORTS void cv::gpu::getComputeCapability(int /*device*/, int* /*major*/, int* /*minor*/) { cudaSafeCall(0); } 
+CV_EXPORTS int cv::gpu::getNumberOfSMs(int /*device*/) { cudaSafeCall(0); return 0; } 
+
+#else
+
 CV_EXPORTS int cv::gpu::getCudaEnabledDeviceCount()
 {
    int count;
@@ -79,3 +89,5 @@ CV_EXPORTS int cv::gpu::getNumberOfSMs(int device)
    cudaSafeCall( cudaGetDeviceProperties( &prop, device ) );
    return prop.multiProcessorCount;
 }
+
+#endif
\ No newline at end of file
--- a/modules/gpu/src/precomp.hpp
+++ b/modules/gpu/src/precomp.hpp
@@ -57,41 +57,39 @@

 #include "cuda_shared.hpp"

+#ifndef HAVE_CUDA
+
+    #define cudaSafeCall(err) CV_Error(CV_GpuNotFound, "The library is compilled with no GPU support")
+    #define cudaCallerSafeCall(err) CV_Error(CV_GpuNotFound, "The library is compilled with no GPU support")
+
+#else /* HAVE_CUDA */
+
 #if _MSC_VER >= 1200
-#pragma warning (disable : 4100 4211 4201 4408)
+    #pragma warning (disable : 4100 4211 4201 4408)
 #endif

 #include "cuda_runtime_api.h"

+#define cudaCallerSafeCall(err) err;

-#define cudaSafeCall(err)  __cudaSafeCall(err, __FILE__, __LINE__)
-
-//inline void __cudaSafeCall( cudaError err, const char *file, const int line )
-//{
-//    if( cudaSuccess != err) 
-//        CV_Error_(CV_StsAssert, ("%s(%i) : Runtime API error : %s.\n", cudaGetErrorString(err)));
-//}
+#ifdef __GNUC__
+    #define cudaSafeCall(err)  __cudaSafeCall(err, __FILE__, __LINE__, __func__)
+#else
+    #define cudaSafeCall(err)  __cudaSafeCall(err, __FILE__, __LINE__)
+#endif

 namespace cv
 {
    namespace gpu
    {
-        
-        inline void __cudaSafeCall( cudaError err, const char *file, const int line )
+        static inline void __cudaSafeCall( cudaError err, const char *file, const int line, const char *func = "")
        {                       
            if( cudaSuccess != err) 
-            {
-                std::cerr << file << "(" << line << ") : cudaSafeCall() Runtime API error : " << cudaGetErrorString(err) << "\n";
-                exit(-1);
-            }
-        }
-
-        template<class T>
-        inline DevMem2D_<T> getDevMem(const GpuMat& mat)
-        {
-            return DevMem2D_<T>(mat.rows, mat.cols, mat.data, mat.step);
+                   cv::error( cv::Exception(CV_GpuApiCallError, cudaGetErrorString(err), func, file, line) );
        }     
    }
 }

+#endif /* HAVE_CUDA */
+
 #endif
--- a/modules/gpu/src/stereobm_gpu.cpp
+++ b/modules/gpu/src/stereobm_gpu.cpp
@@ -41,7 +41,6 @@
 //M*/

 #include "precomp.hpp"
-#include <limits>

 using namespace cv;
 using namespace cv::gpu;
@@ -69,5 +68,5 @@ void StereoBM_GPU::operator() ( const GpuMat& left, const GpuMat& right, GpuMat&

    DevMem2D disp = disparity;
    DevMem2D_<uint> mssd = minSSD;    
-    impl::stereoBM_GPU(left, right, disp, ndisp, mssd);     
+    cudaCallerSafeCall( impl::stereoBM_GPU(left, right, disp, ndisp, mssd) );     
 }