ocl.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) 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 OpenCV Foundation 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_OPENCL_HPP




#define OPENCV_OPENCL_HPP








#include "opencv2/core.hpp"




#include <typeinfo>




#include <typeindex>








namespace

cv
{
namespace
ocl {










CV_EXPORTS_W
bool
haveOpenCL();


CV_EXPORTS_W
bool
useOpenCL();


CV_EXPORTS_W
bool
haveAmdBlas();


CV_EXPORTS_W
bool
haveAmdFft();


CV_EXPORTS_W
void
setUseOpenCL(bool
flag);


CV_EXPORTS_W
void
finish();






CV_EXPORTS
bool
haveSVM();







class
CV_EXPORTS Context;



class
CV_EXPORTS_W_SIMPLE Device;



class
CV_EXPORTS Kernel;



class
CV_EXPORTS Program;



class
CV_EXPORTS ProgramSource;



class
CV_EXPORTS Queue;



class
CV_EXPORTS PlatformInfo;



class
CV_EXPORTS Image2D;







class
CV_EXPORTS_W_SIMPLE
Device



{



public:



CV_WRAP
Device() CV_NOEXCEPT;



explicit
Device(void* d);



Device(const
Device& d);



Device& operator = (const
Device& d);



Device(Device&& d) CV_NOEXCEPT;



Device& operator = (Device&& d) CV_NOEXCEPT;



CV_WRAP
~Device();







void
set(void* d);







enum




{



TYPE_DEFAULT     = (1 << 0),



TYPE_CPU         = (1 << 1),



TYPE_GPU         = (1 << 2),



TYPE_ACCELERATOR = (1 << 3),



TYPE_DGPU        = TYPE_GPU + (1 << 16),



TYPE_IGPU        = TYPE_GPU + (1 << 17),



TYPE_ALL         = 0xFFFFFFFF



};







CV_WRAP String name()
const;



CV_WRAP String extensions()
const;



CV_WRAP
bool
isExtensionSupported(const
String& extensionName)
const;



CV_WRAP String version()
const;



CV_WRAP String vendorName()
const;



CV_WRAP String OpenCL_C_Version()
const;



CV_WRAP String OpenCLVersion()
const;



CV_WRAP
int
deviceVersionMajor()
const;



CV_WRAP
int
deviceVersionMinor()
const;



CV_WRAP String driverVersion()
const;



void* ptr()
const;







CV_WRAP
int
type()
const;







CV_WRAP
int
addressBits()
const;



CV_WRAP
bool
available()
const;



CV_WRAP
bool
compilerAvailable()
const;



CV_WRAP
bool
linkerAvailable()
const;







enum




{



FP_DENORM=(1 << 0),



FP_INF_NAN=(1 << 1),



FP_ROUND_TO_NEAREST=(1 << 2),



FP_ROUND_TO_ZERO=(1 << 3),



FP_ROUND_TO_INF=(1 << 4),



FP_FMA=(1 << 5),



FP_SOFT_FLOAT=(1 << 6),



FP_CORRECTLY_ROUNDED_DIVIDE_SQRT=(1 << 7)



};



CV_WRAP
int
doubleFPConfig()
const;



CV_WRAP
int
singleFPConfig()
const;



CV_WRAP
int
halfFPConfig()
const;







CV_WRAP
bool
endianLittle()
const;



CV_WRAP
bool
errorCorrectionSupport()
const;







enum




{



EXEC_KERNEL=(1 << 0),



EXEC_NATIVE_KERNEL=(1 << 1)



};



CV_WRAP
int
executionCapabilities()
const;







CV_WRAP
size_t
globalMemCacheSize()
const;







enum




{



NO_CACHE=0,



READ_ONLY_CACHE=1,



READ_WRITE_CACHE=2



};



CV_WRAP
int
globalMemCacheType()
const;



CV_WRAP
int
globalMemCacheLineSize()
const;



CV_WRAP
size_t
globalMemSize()
const;







CV_WRAP
size_t
localMemSize()
const;



enum




{



NO_LOCAL_MEM=0,



LOCAL_IS_LOCAL=1,



LOCAL_IS_GLOBAL=2



};



CV_WRAP
int
localMemType()
const;



CV_WRAP
bool
hostUnifiedMemory()
const;







CV_WRAP
bool
imageSupport()
const;







CV_WRAP
bool
imageFromBufferSupport()
const;



uint imagePitchAlignment()
const;



uint imageBaseAddressAlignment()
const;







CV_WRAP
bool
intelSubgroupsSupport()
const;







CV_WRAP
size_t
image2DMaxWidth()
const;



CV_WRAP
size_t
image2DMaxHeight()
const;







CV_WRAP
size_t
image3DMaxWidth()
const;



CV_WRAP
size_t
image3DMaxHeight()
const;



CV_WRAP
size_t
image3DMaxDepth()
const;







CV_WRAP
size_t
imageMaxBufferSize()
const;



CV_WRAP
size_t
imageMaxArraySize()
const;







enum




{



UNKNOWN_VENDOR=0,



VENDOR_AMD=1,



VENDOR_INTEL=2,



VENDOR_NVIDIA=3



};



CV_WRAP
int
vendorID()
const;



// FIXIT




// dev.isAMD() doesn't work for OpenCL CPU devices from AMD OpenCL platform.




// This method should use platform name instead of vendor name.




// After fix restore code in arithm.cpp: ocl_compare()




CV_WRAP
inline
bool
isAMD()
const
{
return
vendorID() == VENDOR_AMD; }



CV_WRAP
inline
bool
isIntel()
const
{
return
vendorID() == VENDOR_INTEL; }



CV_WRAP
inline
bool
isNVidia()
const
{
return
vendorID() == VENDOR_NVIDIA; }







CV_WRAP
int
maxClockFrequency()
const;



CV_WRAP
int
maxComputeUnits()
const;



CV_WRAP
int
maxConstantArgs()
const;



CV_WRAP
size_t
maxConstantBufferSize()
const;







CV_WRAP
size_t
maxMemAllocSize()
const;



CV_WRAP
size_t
maxParameterSize()
const;







CV_WRAP
int
maxReadImageArgs()
const;



CV_WRAP
int
maxWriteImageArgs()
const;



CV_WRAP
int
maxSamplers()
const;







CV_WRAP
size_t
maxWorkGroupSize()
const;



CV_WRAP
int
maxWorkItemDims()
const;



void
maxWorkItemSizes(size_t*)
const;







CV_WRAP
int
memBaseAddrAlign()
const;







CV_WRAP
int
nativeVectorWidthChar()
const;



CV_WRAP
int
nativeVectorWidthShort()
const;



CV_WRAP
int
nativeVectorWidthInt()
const;



CV_WRAP
int
nativeVectorWidthLong()
const;



CV_WRAP
int
nativeVectorWidthFloat()
const;



CV_WRAP
int
nativeVectorWidthDouble()
const;



CV_WRAP
int
nativeVectorWidthHalf()
const;







CV_WRAP
int
preferredVectorWidthChar()
const;



CV_WRAP
int
preferredVectorWidthShort()
const;



CV_WRAP
int
preferredVectorWidthInt()
const;



CV_WRAP
int
preferredVectorWidthLong()
const;



CV_WRAP
int
preferredVectorWidthFloat()
const;



CV_WRAP
int
preferredVectorWidthDouble()
const;



CV_WRAP
int
preferredVectorWidthHalf()
const;







CV_WRAP
size_t
printfBufferSize()
const;



CV_WRAP
size_t
profilingTimerResolution()
const;







CV_WRAP
static
const
Device& getDefault();







static
Device
fromHandle(void* d);







struct
Impl;



inline
Impl* getImpl()
const
{
return
(Impl*)p; }



inline
bool
empty()
const
{
return
!p; }



protected:



Impl* p;


};











class
CV_EXPORTS
Context



{



public:



Context() CV_NOEXCEPT;



explicit
Context(int
dtype);




~Context();



Context(const
Context& c);



Context& operator= (const
Context& c);



Context(Context&& c) CV_NOEXCEPT;



Context& operator = (Context&& c) CV_NOEXCEPT;







bool
create();



bool
create(int
dtype);







size_t
ndevices()
const;



Device& device(size_t
idx)
const;



Program
getProg(const
ProgramSource& prog,



const
String& buildopt, String& errmsg);



void
unloadProg(Program& prog);











#if 0

// OpenCV 5.0




static
Context& getDefault();



#else




static
Context&
getDefault(bool
initialize =
true);



#endif








void*
ptr()
const;







void*
getOpenCLContextProperty(int
propertyId)
const;







bool
useSVM()
const;



void
setUseSVM(bool
enabled);







static
Context
fromHandle(void* context);



static
Context
fromDevice(const
ocl::Device& device);



static
Context
create(const
std::string& configuration);







void
release();







class
CV_EXPORTS
UserContext
{



public:



virtual
~UserContext();



};



template
<typename
T>



inline
void
setUserContext(const
std::shared_ptr<T>& userContext) {



setUserContext(typeid(T), userContext);



}



template
<typename
T>



inline
std::shared_ptr<T> getUserContext() {



return
std::dynamic_pointer_cast<T>(getUserContext(typeid(T)));



}



void
setUserContext(std::type_index typeId,
const
std::shared_ptr<UserContext>& userContext);



std::shared_ptr<UserContext> getUserContext(std::type_index typeId);







struct
Impl;



inline
Impl* getImpl()
const
{
return
(Impl*)p; }



inline
bool
empty()
const
{
return
!p; }



// TODO OpenCV 5.0




//protected:




Impl* p;


};







class
CV_EXPORTS
Platform



{



public:



Platform() CV_NOEXCEPT;



~Platform();



Platform(const
Platform& p);



Platform& operator = (const
Platform& p);



Platform(Platform&& p) CV_NOEXCEPT;



Platform& operator = (Platform&& p) CV_NOEXCEPT;







void* ptr()
const;







static
Platform&
getDefault();







struct
Impl;



inline
Impl* getImpl()
const
{
return
(Impl*)p; }



inline
bool
empty()
const
{
return
!p; }



protected:



Impl* p;


};






CV_EXPORTS
void
attachContext(const
String& platformName,
void* platformID,
void* context,
void* deviceID);






CV_EXPORTS
void
convertFromBuffer(void* cl_mem_buffer,
size_t
step,
int
rows,
int
cols,
int
type,
UMat& dst);






CV_EXPORTS
void
convertFromImage(void* cl_mem_image,
UMat& dst);







// TODO Move to internal header





void
initializeContextFromHandle(Context& ctx,
void* platform,
void* context,
void* device);







class
CV_EXPORTS
Queue



{



public:



Queue() CV_NOEXCEPT;



explicit
Queue(const
Context& c,
const
Device& d=Device());



~Queue();



Queue(const
Queue& q);



Queue& operator = (const
Queue& q);



Queue(Queue&& q) CV_NOEXCEPT;



Queue& operator = (Queue&& q) CV_NOEXCEPT;







bool
create(const
Context& c=Context(),
const
Device& d=Device());



void
finish();



void* ptr()
const;



static
Queue& getDefault();







const
Queue&
getProfilingQueue()
const;







struct
Impl;
friend
struct
Impl;



inline
Impl* getImpl()
const
{
return
p; }



inline
bool
empty()
const
{
return
!p; }



protected:



Impl* p;


};











class
CV_EXPORTS
KernelArg



{



public:



enum
{ LOCAL=1, READ_ONLY=2, WRITE_ONLY=4, READ_WRITE=6, CONSTANT=8, PTR_ONLY = 16, NO_SIZE=256 };



KernelArg(int
_flags,
UMat* _m,
int
wscale=1,
int
iwscale=1,
const
void* _obj=0,
size_t
_sz=0);



KernelArg() CV_NOEXCEPT;







static
KernelArg
Local(size_t
localMemSize)



{
return
KernelArg(LOCAL, 0, 1, 1, 0, localMemSize); }



static
KernelArg
PtrWriteOnly(const
UMat& m)



{
return
KernelArg(PTR_ONLY+WRITE_ONLY, (UMat*)&m); }



static
KernelArg
PtrReadOnly(const
UMat& m)



{
return
KernelArg(PTR_ONLY+READ_ONLY, (UMat*)&m); }



static
KernelArg
PtrReadWrite(const
UMat& m)



{
return
KernelArg(PTR_ONLY+READ_WRITE, (UMat*)&m); }



static
KernelArg
ReadWrite(const
UMat& m,
int
wscale=1,
int
iwscale=1)



{
return
KernelArg(READ_WRITE, (UMat*)&m, wscale, iwscale); }



static
KernelArg
ReadWriteNoSize(const
UMat& m,
int
wscale=1,
int
iwscale=1)



{
return
KernelArg(READ_WRITE+NO_SIZE, (UMat*)&m, wscale, iwscale); }



static
KernelArg
ReadOnly(const
UMat& m,
int
wscale=1,
int
iwscale=1)



{
return
KernelArg(READ_ONLY, (UMat*)&m, wscale, iwscale); }



static
KernelArg
WriteOnly(const
UMat& m,
int
wscale=1,
int
iwscale=1)



{
return
KernelArg(WRITE_ONLY, (UMat*)&m, wscale, iwscale); }



static
KernelArg
ReadOnlyNoSize(const
UMat& m,
int
wscale=1,
int
iwscale=1)



{
return
KernelArg(READ_ONLY+NO_SIZE, (UMat*)&m, wscale, iwscale); }



static
KernelArg
WriteOnlyNoSize(const
UMat& m,
int
wscale=1,
int
iwscale=1)



{
return
KernelArg(WRITE_ONLY+NO_SIZE, (UMat*)&m, wscale, iwscale); }



static
KernelArg
Constant(const
Mat& m);



template<typename
_Tp>
static
KernelArg
Constant(const
_Tp* arr,
size_t
n)



{
return
KernelArg(CONSTANT, 0, 1, 1, (void*)arr, n); }







int
flags;



UMat* m;



const
void* obj;



size_t
sz;



int
wscale, iwscale;


};











class
CV_EXPORTS
Kernel



{



public:



Kernel() CV_NOEXCEPT;



Kernel(const
char* kname,
const
Program& prog);



Kernel(const
char* kname,
const
ProgramSource& prog,



const
String& buildopts = String(), String* errmsg=0);



~Kernel();



Kernel(const
Kernel& k);



Kernel& operator = (const
Kernel& k);



Kernel(Kernel&& k) CV_NOEXCEPT;



Kernel& operator = (Kernel&& k) CV_NOEXCEPT;







bool
empty()
const;



bool
create(const
char* kname,
const
Program& prog);



bool
create(const
char* kname,
const
ProgramSource& prog,



const
String& buildopts, String* errmsg=0);







int
set(int
i,
const
void* value,
size_t
sz);



int
set(int
i,
const
Image2D& image2D);



int
set(int
i,
const
UMat& m);



int
set(int
i,
const
KernelArg& arg);



template<typename
_Tp>
int
set(int
i,
const
_Tp& value)



{
return
set(i, &value,
sizeof(value)); }











protected:



template<typename
_Tp0>
inline




int
set_args_(int
i,
const
_Tp0& a0) {
return
set(i, a0); }



template<typename
_Tp0,
typename... _Tps>
inline




int
set_args_(int
i,
const
_Tp0& a0,
const
_Tps&... rest_args) { i = set(i, a0);
return
set_args_(i, rest_args...); }



public:



template<typename... _Tps>
inline




Kernel&
args(const
_Tps&... kernel_args) { set_args_(0, kernel_args...);
return
*this; }











bool
run(int
dims,
size_t
globalsize[],



size_t
localsize[],
bool
sync,
const
Queue& q=Queue());



bool
runTask(bool
sync,
const
Queue& q=Queue());







int64
runProfiling(int
dims,
size_t
globalsize[],
size_t
localsize[],
const
Queue& q=Queue());







size_t
workGroupSize()
const;



size_t
preferedWorkGroupSizeMultiple()
const;



bool
compileWorkGroupSize(size_t
wsz[])
const;



size_t
localMemSize()
const;







void* ptr()
const;



struct
Impl;







protected:



Impl* p;


};







class
CV_EXPORTS
Program



{



public:



Program() CV_NOEXCEPT;



Program(const
ProgramSource& src,



const
String& buildflags, String& errmsg);



Program(const
Program& prog);



Program& operator = (const
Program& prog);



Program(Program&& prog) CV_NOEXCEPT;



Program& operator = (Program&& prog) CV_NOEXCEPT;



~Program();







bool
create(const
ProgramSource& src,



const
String& buildflags, String& errmsg);







void* ptr()
const;







void
getBinary(std::vector<char>& binary)
const;







struct
Impl;
friend
struct
Impl;



inline
Impl* getImpl()
const
{
return
(Impl*)p; }



inline
bool
empty()
const
{
return
!p; }



protected:



Impl* p;



public:



#ifndef OPENCV_REMOVE_DEPRECATED_API




// TODO Remove this




CV_DEPRECATED
bool
read(const
String& buf,
const
String& buildflags);
// removed, use ProgramSource instead




CV_DEPRECATED
bool
write(String& buf)
const;
// removed, use getBinary() method instead (RAW OpenCL binary)




CV_DEPRECATED
const
ProgramSource& source()
const;
// implementation removed




CV_DEPRECATED String getPrefix()
const;
// deprecated, implementation replaced




CV_DEPRECATED
static
String getPrefix(const
String& buildflags);
// deprecated, implementation replaced




#endif



};











class
CV_EXPORTS
ProgramSource



{



public:



typedef
uint64 hash_t;
// deprecated








ProgramSource() CV_NOEXCEPT;



explicit
ProgramSource(const
String& module,
const
String& name,
const
String& codeStr,
const
String& codeHash);



explicit
ProgramSource(const
String& prog);
// deprecated




explicit
ProgramSource(const
char* prog);
// deprecated




~ProgramSource();



ProgramSource(const
ProgramSource& prog);



ProgramSource& operator = (const
ProgramSource& prog);



ProgramSource(ProgramSource&& prog) CV_NOEXCEPT;



ProgramSource& operator = (ProgramSource&& prog) CV_NOEXCEPT;







const
String& source()
const;
// deprecated




hash_t hash()
const;
// deprecated












static
ProgramSource
fromBinary(const
String& module,
const
String& name,



const
unsigned
char* binary,
const
size_t
size,



const
cv::String& buildOptions = cv::String());







static
ProgramSource
fromSPIR(const
String& module,
const
String& name,



const
unsigned
char* binary,
const
size_t
size,



const
cv::String& buildOptions = cv::String());







//OpenCL 2.1+ only




//static Program fromSPIRV(const String& module, const String& name,




//        const unsigned char* binary, const size_t size,




//        const cv::String& buildOptions = cv::String());








struct
Impl;
friend
struct
Impl;



inline
Impl* getImpl()
const
{
return
(Impl*)p; }



inline
bool
empty()
const
{
return
!p; }



protected:



Impl* p;


};







class
CV_EXPORTS
PlatformInfo



{



public:



PlatformInfo() CV_NOEXCEPT;



explicit
PlatformInfo(void*
id);



~PlatformInfo();







PlatformInfo(const
PlatformInfo& i);



PlatformInfo& operator =(const
PlatformInfo& i);



PlatformInfo(PlatformInfo&& i) CV_NOEXCEPT;



PlatformInfo& operator = (PlatformInfo&& i) CV_NOEXCEPT;







String name()
const;



String vendor()
const;







String
version()
const;



int
versionMajor()
const;



int
versionMinor()
const;







int
deviceNumber()
const;



void
getDevice(Device& device,
int
d)
const;







struct
Impl;



bool
empty()
const
{
return
!p; }



protected:



Impl* p;


};






CV_EXPORTS
const
char* convertTypeStr(int
sdepth,
int
ddepth,
int
cn,
char* buf);


CV_EXPORTS
const
char* typeToStr(int
t);


CV_EXPORTS
const
char* memopTypeToStr(int
t);


CV_EXPORTS
const
char* vecopTypeToStr(int
t);


CV_EXPORTS
const
char* getOpenCLErrorString(int
errorCode);


CV_EXPORTS String kernelToStr(InputArray _kernel,
int
ddepth = -1,
const
char
* name = NULL);


CV_EXPORTS
void
getPlatfomsInfo(std::vector<PlatformInfo>& platform_info);











enum
OclVectorStrategy


{



// all matrices have its own vector width




OCL_VECTOR_OWN = 0,



// all matrices have maximal vector width among all matrices




// (useful for cases when matrices have different data types)




OCL_VECTOR_MAX = 1,







// default strategy




OCL_VECTOR_DEFAULT = OCL_VECTOR_OWN


};






CV_EXPORTS
int
predictOptimalVectorWidth(InputArray src1, InputArray src2 = noArray(), InputArray src3 = noArray(),



InputArray src4 = noArray(), InputArray src5 = noArray(), InputArray src6 = noArray(),



InputArray src7 = noArray(), InputArray src8 = noArray(), InputArray src9 = noArray(),



OclVectorStrategy strat = OCL_VECTOR_DEFAULT);






CV_EXPORTS
int
checkOptimalVectorWidth(const
int
*vectorWidths,



InputArray src1, InputArray src2 = noArray(), InputArray src3 = noArray(),



InputArray src4 = noArray(), InputArray src5 = noArray(), InputArray src6 = noArray(),



InputArray src7 = noArray(), InputArray src8 = noArray(), InputArray src9 = noArray(),



OclVectorStrategy strat = OCL_VECTOR_DEFAULT);







// with OCL_VECTOR_MAX strategy



CV_EXPORTS
int
predictOptimalVectorWidthMax(InputArray src1, InputArray src2 = noArray(), InputArray src3 = noArray(),



InputArray src4 = noArray(), InputArray src5 = noArray(), InputArray src6 = noArray(),



InputArray src7 = noArray(), InputArray src8 = noArray(), InputArray src9 = noArray());






CV_EXPORTS
void
buildOptionsAddMatrixDescription(String& buildOptions,
const
String& name, InputArray _m);







class
CV_EXPORTS
Image2D



{



public:



Image2D() CV_NOEXCEPT;







explicit
Image2D(const
UMat
&src,
bool
norm
=
false,
bool
alias =
false);



Image2D(const
Image2D
& i);



~Image2D();







Image2D
& operator = (const
Image2D
& i);



Image2D(Image2D
&&) CV_NOEXCEPT;



Image2D
&operator=(Image2D
&&) CV_NOEXCEPT;







static
bool
canCreateAlias(const
UMat
&u);







static
bool
isFormatSupported(int
depth,
int
cn,
bool
norm);







void* ptr() const;


protected:



struct Impl;



Impl* p;


};






class CV_EXPORTS
Timer



{



public:



Timer(const
Queue& q);



~Timer();



void
start();



void
stop();







uint64 durationNS()
const;
//< duration in nanoseconds








protected:



struct
Impl;



Impl*
const
p;







private:



Timer(const
Timer&);
// disabled




Timer& operator=(const
Timer&);
// disabled



};






CV_EXPORTS
MatAllocator* getOpenCLAllocator();











class
CV_EXPORTS_W
OpenCLExecutionContext



{



public:



OpenCLExecutionContext() =
default;



~OpenCLExecutionContext() =
default;







OpenCLExecutionContext(const
OpenCLExecutionContext&) =
default;



OpenCLExecutionContext(OpenCLExecutionContext&&) =
default;







OpenCLExecutionContext& operator=(const
OpenCLExecutionContext&) =
default;



OpenCLExecutionContext& operator=(OpenCLExecutionContext&&) =
default;







Context&
getContext()
const;



Device&
getDevice()
const;



Queue&
getQueue()
const;







bool
useOpenCL()
const;



void
setUseOpenCL(bool
flag);







static
OpenCLExecutionContext&
getCurrent();







static
OpenCLExecutionContext&
getCurrentRef();







void
bind()
const;







OpenCLExecutionContext
cloneWithNewQueue(const
ocl::Queue& q)
const;



OpenCLExecutionContext
cloneWithNewQueue()
const;







static
OpenCLExecutionContext
create(const
std::string& platformName,
void* platformID,
void* context,
void* deviceID);







static
OpenCLExecutionContext
create(const
Context& context,
const
Device& device,
const
ocl::Queue& queue);



static
OpenCLExecutionContext
create(const
Context& context,
const
Device& device);







struct
Impl;



inline
bool
empty()
const
{
return
!p; }



void
release();



protected:



std::shared_ptr<Impl> p;


};







class

OpenCLExecutionContextScope



{



OpenCLExecutionContext
ctx_;



public:



inline
OpenCLExecutionContextScope(const
OpenCLExecutionContext& ctx)



{



CV_Assert(!ctx.empty());



ctx_ =
OpenCLExecutionContext::getCurrentRef();



ctx.bind();



}







inline
~OpenCLExecutionContextScope()



{



if
(!ctx_.empty())



{



ctx_.bind();



}



}


};







#ifdef __OPENCV_BUILD




namespace
internal {






CV_EXPORTS
bool
isOpenCLForced();



#define OCL_FORCE_CHECK(condition) (cv::ocl::internal::isOpenCLForced() || (condition))







CV_EXPORTS
bool
isPerformanceCheckBypassed();



#define OCL_PERFORMANCE_CHECK(condition) (cv::ocl::internal::isPerformanceCheckBypassed() || (condition))







CV_EXPORTS
bool
isCLBuffer(UMat& u);






}
// namespace internal




#endif











}}







#endif