generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

added support to build without cuda.

Browse Source
This commit is contained in:
Anatoly Baksheev 2010-07-15 13:36:00 +00:00
parent e1bd5aeadd
commit 2c84a66ec7
9 changed files with 169 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
CMakeLists.txt
View File

@ -282,6 +282,7 @@ endif()
set(WITH_TBB OFF CACHE BOOL "Include TBB support") set(WITH_TBB OFF CACHE BOOL "Include TBB support")
set(WITH_EIGEN2 ON CACHE BOOL "Include Eigen2 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. # Macros that checks if module have been installed.
@ -608,6 +609,15 @@ if (WITH_TBB)
endif() endif()
endif() endif()
############################### TBB ################################
if (WITH_CUDA)
find_package(CUDA)
if (CUDA_FOUND)
message(STATUS "CUDA detected.")
set(HAVE_CUDA 1)
endif()
endif()
############################## Eigen2 ############################## ############################## Eigen2 ##############################
@ -1249,6 +1259,12 @@ else()
message(STATUS " Use TBB: NO") message(STATUS " Use TBB: NO")
endif() endif()
if (HAVE_CUDA)
message(STATUS " Uue Cuda: YES")
else()
message(STATUS " Use Cuda: No")
endif()
if(HAVE_EIGEN2) if(HAVE_EIGEN2)
message(STATUS " Use Eigen2: YES") message(STATUS " Use Eigen2: YES")
else() else()

3
cvconfig.h.cmake
View File

@ -165,3 +165,6 @@
/* Qt bindings use OpenGL */ /* Qt bindings use OpenGL */
#cmakedefine HAVE_HAVE_QT_OPENGL #cmakedefine HAVE_HAVE_QT_OPENGL
/* NVidia Cuda Runtime API*/
#cmakedefine HAVE_CUDA

4
modules/core/include/opencv2/core/types_c.h
View File

@ -229,7 +229,9 @@ enum {
CV_StsParseError= -212, /* invalid syntax/structure of the parsed file */ CV_StsParseError= -212, /* invalid syntax/structure of the parsed file */
CV_StsNotImplemented= -213, /* the requested function/feature is not implemented */ CV_StsNotImplemented= -213, /* the requested function/feature is not implemented */
CV_StsBadMemBlock= -214, /* an allocated block has been corrupted */ 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
}; };
/****************************************************************************************\ /****************************************************************************************\

84
modules/gpu/CMakeLists.txt
View File

@ -1,60 +1,52 @@
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}")
#==================================================================================== project(${the_target})
set(name "gpu") add_definitions(-DCVAPI_EXPORTS)
set(DEPS "opencv_core")
project(opencv_${name}) include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
add_definitions(-DCVAPI_EXPORTS)
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include"
"${CMAKE_CURRENT_SOURCE_DIR}/cuda" "${CMAKE_CURRENT_SOURCE_DIR}/cuda"
"${CMAKE_CURRENT_SOURCE_DIR}/src" "${CMAKE_CURRENT_SOURCE_DIR}/src"
"${CMAKE_CURRENT_BINARY_DIR}") "${CMAKE_CURRENT_BINARY_DIR}")
foreach(d ${DEPS}) foreach(d ${DEPS})
if(${d} MATCHES "opencv_") if(${d} MATCHES "opencv_")
string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d}) string(REPLACE "opencv_" "${CMAKE_CURRENT_SOURCE_DIR}/../" d_dir ${d})
include_directories("${d_dir}/include") include_directories("${d_dir}/include")
endif() endif()
endforeach() endforeach()
file(GLOB lib_srcs "src/*.cpp") file(GLOB lib_srcs "src/*.cpp")
file(GLOB lib_int_hdrs "src/*.h*") file(GLOB lib_int_hdrs "src/*.h*")
file(GLOB lib_cuda "cuda/*.cu") file(GLOB lib_cuda "cuda/*.cu")
file(GLOB lib_cuda_hdrs "cuda/*.h*") file(GLOB lib_cuda_hdrs "cuda/*.h*")
source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs}) source_group("Src" FILES ${lib_srcs} ${lib_int_hdrs})
source_group("Cuda" FILES ${lib_cuda} ${lib_cuda_hdrs}) source_group("Cuda" FILES ${lib_cuda} ${lib_cuda_hdrs})
file(GLOB lib_hdrs "include/opencv2/${name}/*.h*") file(GLOB lib_hdrs "include/opencv2/${name}/*.h*")
source_group("Include" FILES ${lib_hdrs}) source_group("Include" FILES ${lib_hdrs})
if (HAVE_CUDA)
include_directories(${CUDA_INCLUDE_DIRS})
link_directories(${CUDA_LIBRARIES})
if (UNIX OR APPLE) if (UNIX OR APPLE)
set (CUDA_NVCC_FLAGS "-Xcompiler;-fPIC") set (CUDA_NVCC_FLAGS "-Xcompiler;-fPIC")
endif() endif()
CUDA_COMPILE(cuda_objs ${lib_cuda}) CUDA_COMPILE(cuda_objs ${lib_cuda})
#message ("lib cuda : ${cuda_objs}")
#CUDA_BUILD_CLEAN_TARGET() #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) 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*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
if(${CMAKE_GENERATOR} MATCHES "Visual*") if(${CMAKE_GENERATOR} MATCHES "Visual*")
@ -64,28 +56,27 @@ if (CUDA_FOUND)
elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles") elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
add_precompiled_header(${the_target} ${pch_header}) add_precompiled_header(${the_target} ${pch_header})
endif() endif()
endif() endif()
# For dynamic link numbering convenions # For dynamic link numbering convenions
set_target_properties(${the_target} PROPERTIES set_target_properties(${the_target} PROPERTIES
VERSION ${OPENCV_VERSION} VERSION ${OPENCV_VERSION}
SOVERSION ${OPENCV_SOVERSION} SOVERSION ${OPENCV_SOVERSION}
OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}" OUTPUT_NAME "${the_target}${OPENCV_DLLVERSION}"
) )
# Additional target properties # Additional target properties
set_target_properties(${the_target} PROPERTIES set_target_properties(${the_target} PROPERTIES
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}" DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/" ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/" RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib" INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
) )
# Add the required libraries for linking: # 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})
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${DEPS} ${CUDA_LIBRARIES})
if(MSVC) if(MSVC)
if(CMAKE_CROSSCOMPILING) if(CMAKE_CROSSCOMPILING)
set_target_properties(${the_target} PROPERTIES set_target_properties(${the_target} PROPERTIES
LINK_FLAGS "/NODEFAULTLIB:secchk" LINK_FLAGS "/NODEFAULTLIB:secchk"
@ -94,19 +85,18 @@ if (CUDA_FOUND)
set_target_properties(${the_target} PROPERTIES set_target_properties(${the_target} PROPERTIES
LINK_FLAGS "/NODEFAULTLIB:libc" LINK_FLAGS "/NODEFAULTLIB:libc"
) )
endif() endif()
# Dependencies of this target: # Dependencies of this target:
add_dependencies(${the_target} ${DEPS}) add_dependencies(${the_target} ${DEPS})
install(TARGETS ${the_target} install(TARGETS ${the_target}
RUNTIME DESTINATION bin COMPONENT main RUNTIME DESTINATION bin COMPONENT main
LIBRARY DESTINATION lib COMPONENT main LIBRARY DESTINATION lib COMPONENT main
ARCHIVE DESTINATION lib COMPONENT main) ARCHIVE DESTINATION lib COMPONENT main)
install(FILES ${lib_hdrs} install(FILES ${lib_hdrs}
DESTINATION include/opencv2/${name} DESTINATION include/opencv2/${name}
COMPONENT main) COMPONENT main)
endif()

11
modules/gpu/include/opencv2/gpu/gpu.hpp
View File

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

22
modules/gpu/src/cudastream.cpp
View File

@ -41,33 +41,37 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/gpu/stream_access.hpp"
using namespace cv; using namespace cv;
using namespace cv::gpu; 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() cv::gpu::CudaStream::~CudaStream()
{ {
if (impl)
{
cudaSafeCall( cudaStreamDestroy( *(cudaStream_t*)impl ) ); cudaSafeCall( cudaStreamDestroy( *(cudaStream_t*)impl ) );
cv::fastFree( impl ); cv::fastFree( impl );
}
} }
bool cv::gpu::CudaStream::queryIfComplete() bool cv::gpu::CudaStream::queryIfComplete()
{ {
cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl ); //cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl );
if (err == cudaSuccess) //if (err == cudaSuccess)
return true; // return true;
if (err == cudaErrorNotReady) //if (err == cudaErrorNotReady)
return false; // return false;
//cudaErrorInvalidResourceHandle ////cudaErrorInvalidResourceHandle
cudaSafeCall( err ); //cudaSafeCall( err );
return true; return true;
} }
void cv::gpu::CudaStream::waitForCompletion() void cv::gpu::CudaStream::waitForCompletion()

12
modules/gpu/src/initialization.cpp
View File

@ -45,6 +45,16 @@
using namespace cv; using namespace cv;
using namespace cv::gpu; 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() CV_EXPORTS int cv::gpu::getCudaEnabledDeviceCount()
{ {
int count; int count;
@ -79,3 +89,5 @@ CV_EXPORTS int cv::gpu::getNumberOfSMs(int device)
cudaSafeCall( cudaGetDeviceProperties( &prop, device ) ); cudaSafeCall( cudaGetDeviceProperties( &prop, device ) );
return prop.multiProcessorCount; return prop.multiProcessorCount;
} }
#endif

38
modules/gpu/src/precomp.hpp
View File

@ -57,41 +57,39 @@
#include "cuda_shared.hpp" #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 #if _MSC_VER >= 1200
#pragma warning (disable : 4100 4211 4201 4408) #pragma warning (disable : 4100 4211 4201 4408)
#endif #endif
#include "cuda_runtime_api.h" #include "cuda_runtime_api.h"
#define cudaCallerSafeCall(err) err;
#define cudaSafeCall(err) __cudaSafeCall(err, __FILE__, __LINE__) #ifdef __GNUC__
#define cudaSafeCall(err) __cudaSafeCall(err, __FILE__, __LINE__, __func__)
//inline void __cudaSafeCall( cudaError err, const char *file, const int line ) #else
//{ #define cudaSafeCall(err) __cudaSafeCall(err, __FILE__, __LINE__)
// if( cudaSuccess != err) #endif
// CV_Error_(CV_StsAssert, ("%s(%i) : Runtime API error : %s.\n", cudaGetErrorString(err)));
//}
namespace cv namespace cv
{ {
namespace gpu namespace gpu
{ {
static inline void __cudaSafeCall( cudaError err, const char *file, const int line, const char *func = "")
inline void __cudaSafeCall( cudaError err, const char *file, const int line )
{ {
if( cudaSuccess != err) if( cudaSuccess != err)
{ cv::error( cv::Exception(CV_GpuApiCallError, cudaGetErrorString(err), func, file, line) );
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);
} }
} }
} }
#endif /* HAVE_CUDA */
#endif #endif

3
modules/gpu/src/stereobm_gpu.cpp
View File

@ -41,7 +41,6 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
#include <limits>
using namespace cv; using namespace cv;
using namespace cv::gpu; using namespace cv::gpu;
@ -69,5 +68,5 @@ void StereoBM_GPU::operator() ( const GpuMat& left, const GpuMat& right, GpuMat&
DevMem2D disp = disparity; DevMem2D disp = disparity;
DevMem2D_<uint> mssd = minSSD; DevMem2D_<uint> mssd = minSSD;
impl::stereoBM_GPU(left, right, disp, ndisp, mssd); cudaCallerSafeCall( impl::stereoBM_GPU(left, right, disp, ndisp, mssd) );
} }