compilation with no cuda re factored

modules/gpu/src/cudastream.cpp

@@ -41,56 +41,118 @@
 //M*/
 
 #include "precomp.hpp"
-//#include "opencv2/gpu/stream_access.hpp"
 
 using namespace cv;
 using namespace cv::gpu;
 
 
-cv::gpu::CudaStream::CudaStream() //: impl( (Impl*)fastMalloc(sizeof(Impl)) )
+#if !defined (HAVE_CUDA)
+
+void cv::gpu::CudaStream::create() { throw_nogpu(); }
+void cv::gpu::CudaStream::release() { throw_nogpu(); }
+cv::gpu::CudaStream::CudaStream() : impl(0) { throw_nogpu(); }
+cv::gpu::CudaStream::~CudaStream() { throw_nogpu(); }
+cv::gpu::CudaStream::CudaStream(const CudaStream& stream) { throw_nogpu(); }
+CudaStream& cv::gpu::CudaStream::operator=(const CudaStream& stream) { throw_nogpu(); return *this; }
+bool cv::gpu::CudaStream::queryIfComplete() { throw_nogpu(); return true; }
+void cv::gpu::CudaStream::waitForCompletion() { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueDownload(const GpuMat& src, Mat& dst) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueDownload(const GpuMat& src, MatPL& dst) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueUpload(const MatPL& src, GpuMat& dst) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueUpload(const Mat& src, GpuMat& dst) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueCopy(const GpuMat& src, GpuMat& dst) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueMemSet(const GpuMat& src, Scalar val) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueMemSet(const GpuMat& src, Scalar val, const GpuMat& mask) { throw_nogpu(); }
+void cv::gpu::CudaStream::enqueueConvert(const GpuMat& src, GpuMat& dst, int type, double a, double b) { throw_nogpu(); }
+
+#else /* !defined (HAVE_CUDA) */
+
+#include "opencv2/gpu/stream_accessor.hpp"
+
+struct CudaStream::Impl
 {
-    //cudaSafeCall( cudaStreamCreate( &impl->stream) );
+    cudaStream_t stream;
+    int ref_counter;
+};
+namespace 
+{
+    template<class S, class D> void devcopy(const S& src, D& dst, cudaStream_t s, cudaMemcpyKind k)
+    {
+        dst.create(src.size(), src.type());
+        size_t bwidth = src.cols * src.elemSize();
+        cudaSafeCall( cudaMemcpy2DAsync(dst.data, dst.step, src.data, src.step, bwidth, src.rows, k, s) ); 
+    };
 }
-cv::gpu::CudaStream::~CudaStream()
+
+CV_EXPORTS cudaStream_t cv::gpu::StreamAccessor::getStream(const CudaStream& stream) { return stream.impl->stream; };
+
+void cv::gpu::CudaStream::create()
 {
     if (impl)
+        release();
+
+    cudaStream_t stream;
+    cudaSafeCall( cudaStreamCreate( &stream ) );
+
+    impl = (CudaStream::Impl*)fastMalloc(sizeof(CudaStream::Impl));
+
+    impl->stream = stream;
+    impl->ref_counter = 1;    
+}
+
+void cv::gpu::CudaStream::release()
+{
+    if( impl && CV_XADD(&impl->ref_counter, -1) == 1 )
     {
-        cudaSafeCall( cudaStreamDestroy( *(cudaStream_t*)impl ) );
+        cudaSafeCall( cudaStreamDestroy( impl->stream ) );
         cv::fastFree( impl );
     }
 }
 
+cv::gpu::CudaStream::CudaStream() : impl(0) { create(); }
+cv::gpu::CudaStream::~CudaStream() { release(); }
+
+cv::gpu::CudaStream::CudaStream(const CudaStream& stream) : impl(stream.impl)
+{
+    if( impl )
+        CV_XADD(&impl->ref_counter, 1);
+}
+CudaStream& cv::gpu::CudaStream::operator=(const CudaStream& stream)
+{
+    if( this != &stream )
+    {
+        if( stream.impl )
+            CV_XADD(&stream.impl->ref_counter, 1);
+
+        release();
+        impl = stream.impl;        
+    }
+    return *this;
+}
+
 bool cv::gpu::CudaStream::queryIfComplete()
 {
-    //cudaError_t err = cudaStreamQuery( *(cudaStream_t*)impl );
+    cudaError_t err = cudaStreamQuery( impl->stream );
 
-    //if (err == cudaSuccess)
-    //    return true;
+    if (err == cudaErrorNotReady || err == cudaSuccess)
+        return err == cudaSuccess;
 
-    //if (err == cudaErrorNotReady)
-    //    return false;
-
-    ////cudaErrorInvalidResourceHandle
-    //cudaSafeCall( err );
-    return true;
-}
-void cv::gpu::CudaStream::waitForCompletion()
-{
-    cudaSafeCall( cudaStreamSynchronize(  *(cudaStream_t*)impl ) );
+    cudaSafeCall(err);
 }
 
-void cv::gpu::CudaStream::enqueueDownload(const GpuMat& src, Mat& dst)
-{
-//    cudaMemcpy2DAsync(dst.data, dst.step, src.data, src.step, src.cols * src.elemSize(), src.rows, cudaMemcpyDeviceToHost,
-}
-void cv::gpu::CudaStream::enqueueUpload(const Mat& src, GpuMat& dst)
-{
-    CV_Assert(!"Not implemented");
-}
-void cv::gpu::CudaStream::enqueueCopy(const GpuMat& src, GpuMat& dst)
-{
-    CV_Assert(!"Not implemented");
+void cv::gpu::CudaStream::waitForCompletion() { cudaSafeCall( cudaStreamSynchronize( impl->stream ) ); }
+
+void cv::gpu::CudaStream::enqueueDownload(const GpuMat& src, Mat& dst) 
+{ 
+    // if not -> allocation will be done, but after that dst will not point to page locked memory
+    CV_Assert(src.cols == dst.cols && src.rows == dst.rows && src.type() == dst.type() )
+     devcopy(src, dst, impl->stream, cudaMemcpyDeviceToHost); 
 }
+void cv::gpu::CudaStream::enqueueDownload(const GpuMat& src, MatPL& dst) { devcopy(src, dst, impl->stream, cudaMemcpyDeviceToHost); }
+
+void cv::gpu::CudaStream::enqueueUpload(const MatPL& src, GpuMat& dst){ devcopy(src, dst, impl->stream,   cudaMemcpyHostToDevice); }
+void cv::gpu::CudaStream::enqueueUpload(const Mat& src, GpuMat& dst)  { devcopy(src, dst, impl->stream,   cudaMemcpyHostToDevice); }   
+void cv::gpu::CudaStream::enqueueCopy(const GpuMat& src, GpuMat& dst) { devcopy(src, dst, impl->stream, cudaMemcpyDeviceToDevice); }
 
 void cv::gpu::CudaStream::enqueueMemSet(const GpuMat& src, Scalar val)
 {
@@ -102,11 +164,10 @@ void cv::gpu::CudaStream::enqueueMemSet(const GpuMat& src, Scalar val, const Gpu
     CV_Assert(!"Not implemented");
 }
 
-void cv::gpu::CudaStream::enqueueConvert(const GpuMat& src, GpuMat& dst, int type)
+void cv::gpu::CudaStream::enqueueConvert(const GpuMat& src, GpuMat& dst, int type, double a, double b)
 {
     CV_Assert(!"Not implemented");
 }
 
-//struct cudaStream_t& cv::gpu::CudaStream::getStream() { return stream; }
-
 
+#endif /* !defined (HAVE_CUDA) */