cuda.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.
// Copyright (C) 2013, OpenCV Foundation, 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_CORE_CUDA_HPP
#define OPENCV_CORE_CUDA_HPP
 
#ifndef __cplusplus
#  error cuda.hpp header must be compiled as C++
#endif
 
#include "opencv2/core.hpp"
#include "opencv2/core/cuda_types.hpp"
 
namespace cv { namespace cuda {
 
 
//===================================================================================
// GpuMat
//===================================================================================
 
class CV_EXPORTS_W GpuMat
{
public:
    class CV_EXPORTS_W Allocator
    {
    public:
        virtual ~Allocator() {}
 
        // allocator must fill data, step and refcount fields
        virtual bool allocate(GpuMat* mat, int rows, int cols, size_t elemSize) = 0;
        virtual void free(GpuMat* mat) = 0;
    };
 
    CV_WRAP static GpuMat::Allocator* defaultAllocator();
    CV_WRAP static void setDefaultAllocator(GpuMat::Allocator* allocator);
 
    CV_WRAP explicit GpuMat(GpuMat::Allocator* allocator = GpuMat::defaultAllocator());
 
    CV_WRAP GpuMat(int rows, int cols, int type, GpuMat::Allocator* allocator = GpuMat::defaultAllocator());
    CV_WRAP GpuMat(Size size, int type, GpuMat::Allocator* allocator = GpuMat::defaultAllocator());
 
    CV_WRAP GpuMat(int rows, int cols, int type, Scalar s, GpuMat::Allocator* allocator = GpuMat::defaultAllocator());
    CV_WRAP GpuMat(Size size, int type, Scalar s, GpuMat::Allocator* allocator = GpuMat::defaultAllocator());
 
    CV_WRAP GpuMat(const GpuMat& m);
 
    GpuMat(int rows, int cols, int type, void* data, size_t step = Mat::AUTO_STEP);
    GpuMat(Size size, int type, void* data, size_t step = Mat::AUTO_STEP);
 
    CV_WRAP GpuMat(const GpuMat& m, Range rowRange, Range colRange);
    CV_WRAP GpuMat(const GpuMat& m, Rect roi);
 
    CV_WRAP explicit GpuMat(InputArray arr, GpuMat::Allocator* allocator = GpuMat::defaultAllocator());
 
    ~GpuMat();
 
    GpuMat& operator =(const GpuMat& m);
 
    CV_WRAP void create(int rows, int cols, int type);
    CV_WRAP void create(Size size, int type);
 
    CV_WRAP void release();
 
    CV_WRAP void swap(GpuMat& mat);
 
    CV_WRAP void upload(InputArray arr);
 
    CV_WRAP void upload(InputArray arr, Stream& stream);
 
    CV_WRAP void download(OutputArray dst) const;
 
    CV_WRAP void download(OutputArray dst, Stream& stream) const;
 
    CV_WRAP GpuMat clone() const;
 
    void copyTo(OutputArray dst) const;
    CV_WRAP void copyTo(CV_OUT GpuMat& dst) const {
        copyTo(static_cast<OutputArray>(dst));
    }
 
    void copyTo(OutputArray dst, Stream& stream) const;
    CV_WRAP void copyTo(CV_OUT GpuMat& dst, Stream& stream) const {
        copyTo(static_cast<OutputArray>(dst), stream);
    }
 
    void copyTo(OutputArray dst, InputArray mask) const;
    CV_WRAP void copyTo(CV_OUT GpuMat& dst, GpuMat& mask) const {
        copyTo(static_cast<OutputArray>(dst), static_cast<InputArray>(mask));
    }
 
    void copyTo(OutputArray dst, InputArray mask, Stream& stream) const;
    CV_WRAP void copyTo(CV_OUT GpuMat& dst, GpuMat& mask, Stream& stream) const {
        copyTo(static_cast<OutputArray>(dst), static_cast<InputArray>(mask), stream);
    }
 
    CV_WRAP GpuMat& setTo(Scalar s);
 
    CV_WRAP GpuMat& setTo(Scalar s, Stream& stream);
 
    CV_WRAP GpuMat& setTo(Scalar s, InputArray mask);
 
    CV_WRAP GpuMat& setTo(Scalar s, InputArray mask, Stream& stream);
 
    void convertTo(OutputArray dst, int rtype) const;
 
    void convertTo(OutputArray dst, int rtype, Stream& stream) const;
    CV_WRAP void convertTo(CV_OUT GpuMat& dst, int rtype, Stream& stream) const {
        convertTo(static_cast<OutputArray>(dst), rtype, stream);
    }
 
    void convertTo(OutputArray dst, int rtype, double alpha, double beta = 0.0) const;
    CV_WRAP void convertTo(CV_OUT GpuMat& dst, int rtype, double alpha = 1.0, double beta = 0.0) const {
        convertTo(static_cast<OutputArray>(dst), rtype, alpha, beta);
    }
 
    void convertTo(OutputArray dst, int rtype, double alpha, Stream& stream) const;
 
    void convertTo(OutputArray dst, int rtype, double alpha, double beta, Stream& stream) const;
    CV_WRAP void convertTo(CV_OUT GpuMat& dst, int rtype, double alpha, double beta, Stream& stream) const {
        convertTo(static_cast<OutputArray>(dst), rtype, alpha, beta, stream);
    }
 
    CV_WRAP void assignTo(GpuMat& m, int type = -1) const;
 
    uchar* ptr(int y = 0);
    const uchar* ptr(int y = 0) const;
 
    template<typename _Tp> _Tp* ptr(int y = 0);
    template<typename _Tp> const _Tp* ptr(int y = 0) const;
 
    template <typename _Tp> operator PtrStepSz<_Tp>() const;
    template <typename _Tp> operator PtrStep<_Tp>() const;
 
    CV_WRAP GpuMat row(int y) const;
 
    CV_WRAP GpuMat col(int x) const;
 
    CV_WRAP GpuMat rowRange(int startrow, int endrow) const;
    CV_WRAP GpuMat rowRange(Range r) const;
 
    CV_WRAP GpuMat colRange(int startcol, int endcol) const;
    CV_WRAP GpuMat colRange(Range r) const;
 
    GpuMat operator ()(Range rowRange, Range colRange) const;
    GpuMat operator ()(Rect roi) const;
 
    CV_WRAP GpuMat reshape(int cn, int rows = 0) const;
 
    CV_WRAP void locateROI(Size& wholeSize, Point& ofs) const;
 
    CV_WRAP GpuMat& adjustROI(int dtop, int dbottom, int dleft, int dright);
 
    CV_WRAP bool isContinuous() const;
 
    CV_WRAP size_t elemSize() const;
 
    CV_WRAP size_t elemSize1() const;
 
    CV_WRAP int type() const;
 
    CV_WRAP int depth() const;
 
    CV_WRAP int channels() const;
 
    CV_WRAP size_t step1() const;
 
    CV_WRAP Size size() const;
 
    CV_WRAP bool empty() const;
 
    // returns pointer to cuda memory
    CV_WRAP void* cudaPtr() const;
 
    CV_WRAP void updateContinuityFlag();
 
    int flags;
 
    int rows, cols;
 
    CV_PROP size_t step;
 
    uchar* data;
 
    int* refcount;
 
    uchar* datastart;
    const uchar* dataend;
 
    Allocator* allocator;
};
 
struct CV_EXPORTS_W GpuData
{
    explicit GpuData(size_t _size);
     ~GpuData();
 
    GpuData(const GpuData&) = delete;
    GpuData& operator=(const GpuData&) = delete;
 
    GpuData(GpuData&&) = delete;
    GpuData& operator=(GpuData&&) = delete;
 
    uchar* data;
    size_t size;
};
 
class CV_EXPORTS_W GpuMatND
{
public:
    using SizeArray = std::vector<int>;
    using StepArray = std::vector<size_t>;
    using IndexArray = std::vector<int>;
 
    ~GpuMatND();
 
    GpuMatND();
 
    GpuMatND(SizeArray size, int type);
 
    GpuMatND(SizeArray size, int type, void* data, StepArray step = StepArray());
 
    void create(SizeArray size, int type);
 
    void release();
 
    void swap(GpuMatND& m) noexcept;
 
    GpuMatND clone() const;
 
    GpuMatND clone(Stream& stream) const;
 
    GpuMatND operator()(const std::vector<Range>& ranges) const;
 
    GpuMat createGpuMatHeader(IndexArray idx, Range rowRange, Range colRange) const;
 
    GpuMat createGpuMatHeader() const;
 
    GpuMat operator()(IndexArray idx, Range rowRange, Range colRange) const;
 
    operator GpuMat() const;
 
    GpuMatND(const GpuMatND&) = default;
    GpuMatND& operator=(const GpuMatND&) = default;
 
#if defined(__GNUC__) && __GNUC__ < 5
    // error: function '...' defaulted on its first declaration with an exception-specification
    // that differs from the implicit declaration '...'
 
    GpuMatND(GpuMatND&&) = default;
    GpuMatND& operator=(GpuMatND&&) = default;
#else
    GpuMatND(GpuMatND&&) noexcept = default;
    GpuMatND& operator=(GpuMatND&&) noexcept = default;
#endif
 
    void upload(InputArray src);
    void upload(InputArray src, Stream& stream);
    void download(OutputArray dst) const;
    void download(OutputArray dst, Stream& stream) const;
 
    bool isContinuous() const;
 
    bool isSubmatrix() const;
 
    size_t elemSize() const;
 
    size_t elemSize1() const;
 
    bool empty() const;
 
    bool external() const;
 
    uchar* getDevicePtr() const;
 
    size_t total() const;
 
    size_t totalMemSize() const;
 
    int type() const;
 
private:
    void setFields(SizeArray size, int type, StepArray step = StepArray());
 
public:
    int flags;
 
    int dims;
 
    SizeArray size;
 
    StepArray step;
 
private:
    std::shared_ptr<GpuData> data_;
 
    uchar* data;
 
    size_t offset;
};
 
CV_EXPORTS_W void createContinuous(int rows, int cols, int type, OutputArray arr);
 
CV_EXPORTS_W void ensureSizeIsEnough(int rows, int cols, int type, OutputArray arr);
 
CV_EXPORTS_W GpuMat inline createGpuMatFromCudaMemory(int rows, int cols, int type, size_t cudaMemoryAddress, size_t step = Mat::AUTO_STEP) {
    return GpuMat(rows, cols, type, reinterpret_cast<void*>(cudaMemoryAddress), step);
}
 
CV_EXPORTS_W inline GpuMat createGpuMatFromCudaMemory(Size size, int type, size_t cudaMemoryAddress, size_t step = Mat::AUTO_STEP) {
    return GpuMat(size, type, reinterpret_cast<void*>(cudaMemoryAddress), step);
}
 
class CV_EXPORTS_W BufferPool
{
public:
 
    CV_WRAP explicit BufferPool(Stream& stream);
 
    CV_WRAP GpuMat getBuffer(int rows, int cols, int type);
 
// WARNING: unreachable code using Ninja
#if defined _MSC_VER && _MSC_VER >= 1920
#pragma warning(push)
#pragma warning(disable: 4702)
#endif
    CV_WRAP GpuMat getBuffer(Size size, int type) { return getBuffer(size.height, size.width, type); }
#if defined _MSC_VER && _MSC_VER >= 1920
#pragma warning(pop)
#endif
 
    CV_WRAP Ptr<GpuMat::Allocator> getAllocator() const { return allocator_; }
 
private:
    Ptr<GpuMat::Allocator> allocator_;
};
 
CV_EXPORTS_W void setBufferPoolUsage(bool on);
CV_EXPORTS_W void setBufferPoolConfig(int deviceId, size_t stackSize, int stackCount);
 
//===================================================================================
// HostMem
//===================================================================================
 
class CV_EXPORTS_W HostMem
{
public:
    enum AllocType { PAGE_LOCKED = 1, SHARED = 2, WRITE_COMBINED = 4 };
 
    static MatAllocator* getAllocator(HostMem::AllocType alloc_type = HostMem::AllocType::PAGE_LOCKED);
 
    CV_WRAP explicit HostMem(HostMem::AllocType alloc_type = HostMem::AllocType::PAGE_LOCKED);
 
    HostMem(const HostMem& m);
 
    CV_WRAP HostMem(int rows, int cols, int type, HostMem::AllocType alloc_type = HostMem::AllocType::PAGE_LOCKED);
    CV_WRAP HostMem(Size size, int type, HostMem::AllocType alloc_type = HostMem::AllocType::PAGE_LOCKED);
 
    CV_WRAP explicit HostMem(InputArray arr, HostMem::AllocType alloc_type = HostMem::AllocType::PAGE_LOCKED);
 
    ~HostMem();
 
    HostMem& operator =(const HostMem& m);
 
    CV_WRAP void swap(HostMem& b);
 
    CV_WRAP HostMem clone() const;
 
    CV_WRAP void create(int rows, int cols, int type);
    void create(Size size, int type);
 
    CV_WRAP HostMem reshape(int cn, int rows = 0) const;
 
    void release();
 
    CV_WRAP Mat createMatHeader() const;
 
    GpuMat createGpuMatHeader() const;
 
    // Please see cv::Mat for descriptions
    CV_WRAP bool isContinuous() const;
    CV_WRAP size_t elemSize() const;
    CV_WRAP size_t elemSize1() const;
    CV_WRAP int type() const;
    CV_WRAP int depth() const;
    CV_WRAP int channels() const;
    CV_WRAP size_t step1() const;
    CV_WRAP Size size() const;
    CV_WRAP bool empty() const;
 
    // Please see cv::Mat for descriptions
    int flags;
    int rows, cols;
    CV_PROP size_t step;
 
    uchar* data;
    int* refcount;
 
    uchar* datastart;
    const uchar* dataend;
 
    AllocType alloc_type;
};
 
CV_EXPORTS_W void registerPageLocked(Mat& m);
 
CV_EXPORTS_W void unregisterPageLocked(Mat& m);
 
//===================================================================================
// Stream
//===================================================================================
 
class CV_EXPORTS_W Stream
{
    typedef void (Stream::*bool_type)() const;
    void this_type_does_not_support_comparisons() const {}
 
public:
    typedef void (*StreamCallback)(int status, void* userData);
 
    CV_WRAP Stream();
 
    CV_WRAP Stream(const Ptr<GpuMat::Allocator>& allocator);
 
    CV_WRAP Stream(const size_t cudaFlags);
 
    CV_WRAP bool queryIfComplete() const;
 
    CV_WRAP void waitForCompletion();
 
    CV_WRAP void waitEvent(const Event& event);
 
    void enqueueHostCallback(StreamCallback callback, void* userData);
 
    CV_WRAP static Stream& Null();
 
    operator bool_type() const;
 
    CV_WRAP void* cudaPtr() const;
 
    class Impl;
 
private:
    Ptr<Impl> impl_;
    Stream(const Ptr<Impl>& impl);
 
    friend struct StreamAccessor;
    friend class BufferPool;
    friend class DefaultDeviceInitializer;
};
 
 
CV_EXPORTS_W Stream wrapStream(size_t cudaStreamMemoryAddress);
 
class CV_EXPORTS_W Event
{
public:
    enum CreateFlags
    {
        DEFAULT        = 0x00,  
        BLOCKING_SYNC  = 0x01,  
        DISABLE_TIMING = 0x02,  
        INTERPROCESS   = 0x04   
    };
 
    CV_WRAP explicit Event(const Event::CreateFlags flags = Event::CreateFlags::DEFAULT);
 
    CV_WRAP void record(Stream& stream = Stream::Null());
 
    CV_WRAP bool queryIfComplete() const;
 
    CV_WRAP void waitForCompletion();
 
    CV_WRAP static float elapsedTime(const Event& start, const Event& end);
 
    class Impl;
 
private:
    Ptr<Impl> impl_;
    Event(const Ptr<Impl>& impl);
 
    friend struct EventAccessor;
};
CV_ENUM_FLAGS(Event::CreateFlags)
 
 
//===================================================================================
// Initialization & Info
//===================================================================================
 
 
CV_EXPORTS_W int getCudaEnabledDeviceCount();
 
CV_EXPORTS_W void setDevice(int device);
 
CV_EXPORTS_W int getDevice();
 
CV_EXPORTS_W void resetDevice();
 
enum FeatureSet
{
    FEATURE_SET_COMPUTE_10 = 10,
    FEATURE_SET_COMPUTE_11 = 11,
    FEATURE_SET_COMPUTE_12 = 12,
    FEATURE_SET_COMPUTE_13 = 13,
    FEATURE_SET_COMPUTE_20 = 20,
    FEATURE_SET_COMPUTE_21 = 21,
    FEATURE_SET_COMPUTE_30 = 30,
    FEATURE_SET_COMPUTE_32 = 32,
    FEATURE_SET_COMPUTE_35 = 35,
    FEATURE_SET_COMPUTE_50 = 50,
 
    GLOBAL_ATOMICS = FEATURE_SET_COMPUTE_11,
    SHARED_ATOMICS = FEATURE_SET_COMPUTE_12,
    NATIVE_DOUBLE = FEATURE_SET_COMPUTE_13,
    WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30,
    DYNAMIC_PARALLELISM = FEATURE_SET_COMPUTE_35
};
 
CV_EXPORTS bool deviceSupports(FeatureSet feature_set);
 
class CV_EXPORTS_W TargetArchs
{
public:
    static bool builtWith(FeatureSet feature_set);
 
    CV_WRAP static bool has(int major, int minor);
    CV_WRAP static bool hasPtx(int major, int minor);
    CV_WRAP static bool hasBin(int major, int minor);
 
    CV_WRAP static bool hasEqualOrLessPtx(int major, int minor);
    CV_WRAP static bool hasEqualOrGreater(int major, int minor);
    CV_WRAP static bool hasEqualOrGreaterPtx(int major, int minor);
    CV_WRAP static bool hasEqualOrGreaterBin(int major, int minor);
};
 
class CV_EXPORTS_W DeviceInfo
{
public:
    CV_WRAP DeviceInfo();
 
    CV_WRAP DeviceInfo(int device_id);
 
    CV_WRAP int deviceID() const;
 
    const char* name() const;
 
    CV_WRAP size_t totalGlobalMem() const;
 
    CV_WRAP size_t sharedMemPerBlock() const;
 
    CV_WRAP int regsPerBlock() const;
 
    CV_WRAP int warpSize() const;
 
    CV_WRAP size_t memPitch() const;
 
    CV_WRAP int maxThreadsPerBlock() const;
 
    CV_WRAP Vec3i maxThreadsDim() const;
 
    CV_WRAP Vec3i maxGridSize() const;
 
    CV_WRAP int clockRate() const;
 
    CV_WRAP size_t totalConstMem() const;
 
    CV_WRAP int majorVersion() const;
 
    CV_WRAP int minorVersion() const;
 
    CV_WRAP size_t textureAlignment() const;
 
    CV_WRAP size_t texturePitchAlignment() const;
 
    CV_WRAP int multiProcessorCount() const;
 
    CV_WRAP bool kernelExecTimeoutEnabled() const;
 
    CV_WRAP bool integrated() const;
 
    CV_WRAP bool canMapHostMemory() const;
 
    enum ComputeMode
    {
        ComputeModeDefault,         
        ComputeModeExclusive,       
        ComputeModeProhibited,      
        ComputeModeExclusiveProcess 
    };
 
    CV_WRAP DeviceInfo::ComputeMode computeMode() const;
 
    CV_WRAP int maxTexture1D() const;
 
    CV_WRAP int maxTexture1DMipmap() const;
 
    CV_WRAP int maxTexture1DLinear() const;
 
    CV_WRAP Vec2i maxTexture2D() const;
 
    CV_WRAP Vec2i maxTexture2DMipmap() const;
 
    CV_WRAP Vec3i maxTexture2DLinear() const;
 
    CV_WRAP Vec2i maxTexture2DGather() const;
 
    CV_WRAP Vec3i maxTexture3D() const;
 
    CV_WRAP int maxTextureCubemap() const;
 
    CV_WRAP Vec2i maxTexture1DLayered() const;
 
    CV_WRAP Vec3i maxTexture2DLayered() const;
 
    CV_WRAP Vec2i maxTextureCubemapLayered() const;
 
    CV_WRAP int maxSurface1D() const;
 
    CV_WRAP Vec2i maxSurface2D() const;
 
    CV_WRAP Vec3i maxSurface3D() const;
 
    CV_WRAP Vec2i maxSurface1DLayered() const;
 
    CV_WRAP Vec3i maxSurface2DLayered() const;
 
    CV_WRAP int maxSurfaceCubemap() const;
 
    CV_WRAP Vec2i maxSurfaceCubemapLayered() const;
 
    CV_WRAP size_t surfaceAlignment() const;
 
    CV_WRAP bool concurrentKernels() const;
 
    CV_WRAP bool ECCEnabled() const;
 
    CV_WRAP int pciBusID() const;
 
    CV_WRAP int pciDeviceID() const;
 
    CV_WRAP int pciDomainID() const;
 
    CV_WRAP bool tccDriver() const;
 
    CV_WRAP int asyncEngineCount() const;
 
    CV_WRAP bool unifiedAddressing() const;
 
    CV_WRAP int memoryClockRate() const;
 
    CV_WRAP int memoryBusWidth() const;
 
    CV_WRAP int l2CacheSize() const;
 
    CV_WRAP int maxThreadsPerMultiProcessor() const;
 
    CV_WRAP void queryMemory(size_t& totalMemory, size_t& freeMemory) const;
    CV_WRAP size_t freeMemory() const;
    CV_WRAP size_t totalMemory() const;
 
    bool supports(FeatureSet feature_set) const;
 
    CV_WRAP bool isCompatible() const;
 
private:
    int device_id_;
};
 
CV_EXPORTS_W void printCudaDeviceInfo(int device);
CV_EXPORTS_W void printShortCudaDeviceInfo(int device);
 
CV_EXPORTS void convertFp16(InputArray _src, OutputArray _dst, Stream& stream = Stream::Null());
 
 
}} // namespace cv { namespace cuda {
 
 
#include "opencv2/core/cuda.inl.hpp"
 
#endif /* OPENCV_CORE_CUDA_HPP */