Add CUDA depth processor

.gitignore

@@ -2,7 +2,7 @@
 examples/protonect/include/libfreenect2/config.h
 
 # generated resource file
-examples/protonect/src/resources.inc
+examples/protonect/src/resources.inc.h
 examples/protonect/build
 
 # Dependency folders

examples/protonect/CMakeLists.txt

@@ -8,6 +8,7 @@ SET(DEPENDS_DIR "${MY_DIR}/../../depends" CACHE STRING "dependency directory")
 
 OPTION(ENABLE_CXX11 "Enable C++11 support" OFF)
 OPTION(ENABLE_OPENCL "Enable OpenCL support" ON)
+OPTION(ENABLE_CUDA "Enable CUDA support" ON)
 OPTION(ENABLE_OPENGL "Enable OpenGL support" ON)
 
 IF(ENABLE_CXX11)
@@ -40,7 +41,7 @@ SET(LIBRARY_OUTPUT_PATH ${MY_DIR}/lib)
 # dependencies
 FIND_PACKAGE(PkgConfig)    # try find PKGConfig as it will be used if found
 FIND_PACKAGE(LibUSB REQUIRED)
-FIND_PACKAGE(OpenCV REQUIRED)
+FIND_PACKAGE(OpenCV REQUIRED core highgui)
 FIND_PACKAGE(TurboJPEG REQUIRED) #does not provide a package-config file
 
 # Add includes
@@ -54,7 +55,7 @@ INCLUDE_DIRECTORIES(
 
 LINK_DIRECTORIES(${LibUSB_LIBRARY_DIRS})
 
-SET(RESOURCES_INC_FILE "${MY_DIR}/src/resources.inc")
+SET(RESOURCES_INC_FILE "${MY_DIR}/src/resources.inc.h")
 
 SET(SOURCES
   include/libfreenect2/protocol/command.h
@@ -165,30 +166,96 @@ IF(ENABLE_OPENCL)
   ENDIF(OPENCL_FOUND)
 ENDIF(ENABLE_OPENCL)
 
+IF(ENABLE_CUDA)
+  FIND_PACKAGE(CUDA)
+  IF(CUDA_FOUND)
+    SET(LIBFREENECT2_WITH_CUDA_SUPPORT 1)
+
+    CUDA_INCLUDE_DIRECTORIES(
+      "${MY_DIR}/include/"
+      "${CUDA_TOOLKIT_ROOT_DIR}/samples/common/inc"
+      "$ENV{NVCUDASAMPLES_ROOT}/common/inc"
+    )
+    SET(CUDA_FLAGS -use_fast_math)
+    IF(NOT MSVC)
+      SET(CUDA_FLAGS "${CUDA_FLAGS} -Xcompiler -fPIC")
+    ENDIF()
+    CUDA_COMPILE(CUDA_SHARED_OBJECTS
+     src/cuda_depth_packet_processor.cu SHARED
+     OPTIONS ${CUDA_FLAGS}
+    )
+    LIST(APPEND OTHER_SHARED_OBJECTS ${CUDA_SHARED_OBJECTS})
+    CUDA_COMPILE(CUDA_STATIC_OBJECTS
+     src/cuda_depth_packet_processor.cu STATIC
+     OPTIONS ${CUDA_FLAGS}
+    )
+    LIST(APPEND OTHER_STATIC_OBJECTS ${CUDA_STATIC_OBJECTS})
+
+    INCLUDE_DIRECTORIES(${CUDA_INCLUDE_DIRS})
+
+    LIST(APPEND SOURCES
+      src/cuda_depth_packet_processor.cpp
+      ${CUDA_OBJECTS}
+    )
+
+    LIST(APPEND LIBRARIES
+      ${CUDA_LIBRARIES}
+    )
+  ENDIF(CUDA_FOUND)
+ENDIF(ENABLE_CUDA)
+
 SET(CMAKE_INSTALL_RPATH ${LibUSB_LIBDIR})
 
 CONFIGURE_FILE("${MY_DIR}/include/libfreenect2/config.h.in" "${MY_DIR}/include/libfreenect2/config.h" @ONLY)
 GENERATE_RESOURCES(${RESOURCES_INC_FILE} ${MY_DIR} ${RESOURCES})
 
 ADD_DEFINITIONS(-DRESOURCES_INC)
-ADD_LIBRARY(freenect2 SHARED ${SOURCES})
+ADD_LIBRARY(freenect2 OBJECT ${SOURCES})
+set_target_properties(freenect2 PROPERTIES POSITION_INDEPENDENT_CODE 1)
+ADD_LIBRARY(freenect2shared SHARED $<TARGET_OBJECTS:freenect2> ${OTHER_SHARED_OBJECTS})
+ADD_LIBRARY(freenect2static STATIC $<TARGET_OBJECTS:freenect2> ${OTHER_STATIC_OBJECTS})
+set_target_properties(freenect2shared PROPERTIES OUTPUT_NAME freenect2)
+set_target_properties(freenect2static PROPERTIES OUTPUT_NAME freenect2)
 MESSAGE("Linking with these libraries: ${LIBRARIES}")
-TARGET_LINK_LIBRARIES(freenect2 ${LIBRARIES})
+TARGET_LINK_LIBRARIES(freenect2shared ${LIBRARIES})
 
 ADD_EXECUTABLE(Protonect
   Protonect.cpp
 )
 
 TARGET_LINK_LIBRARIES(Protonect
-  freenect2
+  freenect2shared
 )
 
 CONFIGURE_FILE(freenect2.cmake.in "${PROJECT_BINARY_DIR}/freenect2Config.cmake" @ONLY)
 
-INSTALL(TARGETS freenect2 DESTINATION lib)
+INSTALL(TARGETS Protonect DESTINATION bin)
+INSTALL(TARGETS freenect2shared DESTINATION lib)
+INSTALL(TARGETS freenect2static DESTINATION lib)
 INSTALL(DIRECTORY "${MY_DIR}/include/" DESTINATION include PATTERN "*.in" EXCLUDE)
 IF(LIBFREENECT2_THREADING_TINYTHREAD)
   INSTALL(FILES  "${MY_DIR}/src/tinythread/tinythread.h" DESTINATION include/${PROJECT_NAME}/tinythread/)
 ENDIF(LIBFREENECT2_THREADING_TINYTHREAD)
 INSTALL(FILES "${PROJECT_BINARY_DIR}/freenect2Config.cmake" DESTINATION lib/cmake/freenect2/)
 
+IF(WIN32)
+  INSTALL(TARGETS freenect2shared RUNTIME DESTINATION bin)
+
+  FOREACH(LIB ${OpenCV_LIBS})
+    INSTALL(FILES $<TARGET_PROPERTY:${LIB},IMPORTED_LOCATION_RELEASE> DESTINATION bin)
+  ENDFOREACH()
+
+  get_filename_component(LibUSB_LIBDIR ${LibUSB_LIBRARIES} DIRECTORY)
+  FIND_FILE(LibUSB_DLL libusb-1.0.dll PATHS ${LibUSB_LIBDIR} NO_DEFAULT_PATH)
+  INSTALL(FILES ${LibUSB_DLL} DESTINATION bin)
+
+  get_filename_component(TurboJPEG_LIBDIR ${TurboJPEG_LIBRARIES} DIRECTORY)
+  FIND_FILE(TurboJPEG_DLL turbojpeg.dll PATHS "${TurboJPEG_LIBDIR}/../bin" NO_DEFAULT_PATH)
+  INSTALL(FILES ${TurboJPEG_DLL} DESTINATION bin)
+
+  IF(GLFW3_FOUND)
+    get_filename_component(GLFW3_LIBDIR ${GLFW3_LIBRARIES} DIRECTORY)
+    FIND_FILE(GLFW3_DLL glfw3.dll PATHS ${GLFW3_LIBDIR} NO_DEFAULT_PATH)
+    INSTALL(FILES ${GLFW3_DLL} DESTINATION bin)
+  ENDIF()
+ENDIF()

examples/protonect/Protonect.cpp

@@ -92,6 +92,15 @@ int main(int argc, char *argv[])
         pipeline = new libfreenect2::OpenCLPacketPipeline();
 #else
       std::cout << "OpenCL pipeline is not supported!" << std::endl;
+#endif
+    }
+    else if(arg == "cuda")
+    {
+#ifdef LIBFREENECT2_WITH_CUDA_SUPPORT
+      if(!pipeline)
+        pipeline = new libfreenect2::CudaPacketPipeline();
+#else
+      std::cout << "CUDA pipeline is not supported!" << std::endl;
 #endif
     }
     else if(arg.find_first_not_of("0123456789") == std::string::npos) //check if parameter could be a serial number

examples/protonect/include/libfreenect2/async_packet_processor.h

@@ -76,6 +76,12 @@ class AsyncPacketProcessor : public PacketProcessor<PacketT>
     }
     packet_condition_.notify_one();
   }
+
+  virtual unsigned char *getPacketBuffer(size_t size)
+  {
+    return processor_->getPacketBuffer(size);
+  }
+
 private:
   PacketProcessorPtr processor_;
   bool current_packet_available_;

examples/protonect/include/libfreenect2/config.h.in

@@ -43,6 +43,8 @@
 
 #cmakedefine LIBFREENECT2_WITH_OPENCL_SUPPORT
 
+#cmakedefine LIBFREENECT2_WITH_CUDA_SUPPORT
+
 #cmakedefine LIBFREENECT2_THREADING_STDLIB
 
 #cmakedefine LIBFREENECT2_THREADING_TINYTHREAD

examples/protonect/include/libfreenect2/depth_packet_processor.h

@@ -196,5 +196,58 @@ class LIBFREENECT2_API OpenCLDepthPacketProcessor : public DepthPacketProcessor
   OpenCLDepthPacketProcessorImpl *impl_;
 };
 #endif // LIBFREENECT2_WITH_OPENCL_SUPPORT
+
+#ifdef LIBFREENECT2_WITH_CUDA_SUPPORT
+#ifdef _MSC_VER
+struct __declspec(align(16)) Float4
+#else
+struct __attribute__((aligned(16))) Float4
+#endif
+{
+    float x, y, z, w;
+};
+
+class CudaDepthPacketProcessorImpl;
+
+class LIBFREENECT2_API CudaDepthPacketProcessor : public DepthPacketProcessor
+{
+public:
+  CudaDepthPacketProcessor(const int deviceId = -1);
+  virtual ~CudaDepthPacketProcessor();
+  virtual unsigned char *getPacketBuffer(size_t size);
+  virtual void setConfiguration(const libfreenect2::DepthPacketProcessor::Config &config);
+
+  virtual void loadP0TablesFromCommandResponse(unsigned char* buffer, size_t buffer_length);
+
+  /**
+   * GUESS: the x and z table follow some polynomial, until we know the exact polynom formula and its coefficients
+   * just load them from a memory dump - although they probably vary per camera
+   */
+  void loadXTableFromFile(const char* filename);
+
+  void loadZTableFromFile(const char* filename);
+
+  void load11To16LutFromFile(const char* filename);
+
+  virtual void process(const DepthPacket &packet);
+private:
+  CudaDepthPacketProcessorImpl *impl_;
+};
+
+class CudaDepthPacketProcessorKernelImpl;
+
+class CudaDepthPacketProcessorKernel
+{
+public:
+  CudaDepthPacketProcessorKernel();
+  virtual ~CudaDepthPacketProcessorKernel();
+  void initDevice(const int deviceId, size_t image_size_, size_t block);
+  void generateOptions(const DepthPacketProcessor::Parameters &params, const DepthPacketProcessor::Config &config);
+  void loadTables(const short *lut11to16, const Float4 *p0_table, const float *x_table, const float *z_table);
+  void run(const DepthPacket &packet, Frame *ir_frame, Frame *depth_frame, const DepthPacketProcessor::Config &config);
+private:
+  CudaDepthPacketProcessorKernelImpl *impl_;
+};
+#endif // LIBFREENECT2_WITH_CUDA_SUPPORT
 } /* namespace libfreenect2 */
 #endif /* DEPTH_PACKET_PROCESSOR_H_ */

examples/protonect/include/libfreenect2/double_buffer.h

@@ -49,6 +49,8 @@ class LIBFREENECT2_API DoubleBuffer
 
   void allocate(size_t buffer_size);
 
+  void setbuffer(unsigned char *buf, size_t size);
+
   void swap();
 
   Buffer& front();
@@ -59,6 +61,7 @@ class LIBFREENECT2_API DoubleBuffer
   unsigned char front_buffer_index_;
 
   unsigned char* buffer_data_;
+  bool external_buffer_;
 };
 
 } /* namespace libfreenect2 */

examples/protonect/include/libfreenect2/frame_listener.hpp

@@ -48,15 +48,18 @@ struct LIBFREENECT2_API Frame
   size_t width, height, bytes_per_pixel;
   unsigned char* data;
 
-  Frame(size_t width, size_t height, size_t bytes_per_pixel) :
+  Frame(size_t width, size_t height, size_t bytes_per_pixel, bool alloc = true) :
     width(width),
     height(height),
-    bytes_per_pixel(bytes_per_pixel)
+    bytes_per_pixel(bytes_per_pixel),
+    data(NULL)
   {
+    if (!alloc)
+      return;
     data = new unsigned char[width * height * bytes_per_pixel];
   }
 
-  ~Frame()
+  virtual ~Frame()
   {
     delete[] data;
   }

examples/protonect/include/libfreenect2/packet_pipeline.h

@@ -107,6 +107,17 @@ class LIBFREENECT2_API OpenCLPacketPipeline : public BasePacketPipeline
 };
 #endif // LIBFREENECT2_WITH_OPENCL_SUPPORT
 
+#ifdef LIBFREENECT2_WITH_CUDA_SUPPORT
+class LIBFREENECT2_API CudaPacketPipeline : public BasePacketPipeline
+{
+protected:
+  const int deviceId;
+  virtual DepthPacketProcessor *createDepthPacketProcessor();
+public:
+  CudaPacketPipeline(const int deviceId = -1);
+  virtual ~CudaPacketPipeline();
+};
+#endif // LIBFREENECT2_WITH_CUDA_SUPPORT
 
 } /* namespace libfreenect2 */
 #endif /* PACKET_PIPELINE_H_ */

examples/protonect/include/libfreenect2/packet_processor.h

@@ -38,6 +38,7 @@ class PacketProcessor
 
   virtual bool ready() { return true; }
   virtual void process(const PacketT &packet) = 0;
+  virtual unsigned char *getPacketBuffer(size_t size) { return NULL; }
 };
 
 template<typename PacketT>

examples/protonect/include/libfreenect2/resource.h

@@ -33,6 +33,7 @@ namespace libfreenect2
 {
 
 bool loadResource(const std::string &name, unsigned char const**data, size_t *length);
+bool loadBufferFromResources(const std::string &filename, unsigned char *buffer, const size_t n);
 
 } /* namespace libfreenect2 */
 #endif /* RESOURCE_H_ */