ocl.hpp

00001 /*M///////////////////////////////////////////////////////////////////////////////////////
00002 //
00003 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
00004 //
00005 //  By downloading, copying, installing or using the software you agree to this license.
00006 //  If you do not agree to this license, do not download, install,
00007 //  copy or use the software.
00008 //
00009 //
00010 //                           License Agreement
00011 //                For Open Source Computer Vision Library
00012 //
00013 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
00014 // Third party copyrights are property of their respective owners.
00015 //
00016 // Redistribution and use in source and binary forms, with or without modification,
00017 // are permitted provided that the following conditions are met:
00018 //
00019 //   * Redistribution's of source code must retain the above copyright notice,
00020 //     this list of conditions and the following disclaimer.
00021 //
00022 //   * Redistribution's in binary form must reproduce the above copyright notice,
00023 //     this list of conditions and the following disclaimer in the documentation
00024 //     and/or other materials provided with the distribution.
00025 //
00026 //   * The name of the copyright holders may not be used to endorse or promote products
00027 //     derived from this software without specific prior written permission.
00028 //
00029 // This software is provided by the copyright holders and contributors "as is" and
00030 // any express or implied warranties, including, but not limited to, the implied
00031 // warranties of merchantability and fitness for a particular purpose are disclaimed.
00032 // In no event shall the OpenCV Foundation or contributors be liable for any direct,
00033 // indirect, incidental, special, exemplary, or consequential damages
00034 // (including, but not limited to, procurement of substitute goods or services;
00035 // loss of use, data, or profits; or business interruption) however caused
00036 // and on any theory of liability, whether in contract, strict liability,
00037 // or tort (including negligence or otherwise) arising in any way out of
00038 // the use of this software, even if advised of the possibility of such damage.
00039 //
00040 //M*/
00041 
00042 #ifndef __OPENCV_OPENCL_HPP__
00043 #define __OPENCV_OPENCL_HPP__
00044 
00045 #include "opencv2/core.hpp"
00046 
00047 namespace cv { namespace ocl {
00048 
00049 //! @addtogroup core_opencl
00050 //! @{
00051 
00052 CV_EXPORTS_W bool haveOpenCL();
00053 CV_EXPORTS_W bool useOpenCL();
00054 CV_EXPORTS_W bool haveAmdBlas();
00055 CV_EXPORTS_W bool haveAmdFft();
00056 CV_EXPORTS_W void setUseOpenCL(bool flag);
00057 CV_EXPORTS_W void finish();
00058 
00059 CV_EXPORTS bool haveSVM();
00060 
00061 class CV_EXPORTS Context;
00062 class CV_EXPORTS Device;
00063 class CV_EXPORTS Kernel;
00064 class CV_EXPORTS Program;
00065 class CV_EXPORTS ProgramSource;
00066 class CV_EXPORTS Queue;
00067 class CV_EXPORTS PlatformInfo;
00068 class CV_EXPORTS Image2D;
00069 
00070 class CV_EXPORTS Device
00071 {
00072 public:
00073     Device();
00074     explicit Device(void* d);
00075     Device(const Device& d);
00076     Device& operator = (const Device& d);
00077     ~Device();
00078 
00079     void set(void* d);
00080 
00081     enum
00082     {
00083         TYPE_DEFAULT     = (1 << 0),
00084         TYPE_CPU         = (1 << 1),
00085         TYPE_GPU         = (1 << 2),
00086         TYPE_ACCELERATOR = (1 << 3),
00087         TYPE_DGPU        = TYPE_GPU + (1 << 16),
00088         TYPE_IGPU        = TYPE_GPU + (1 << 17),
00089         TYPE_ALL         = 0xFFFFFFFF
00090     };
00091 
00092     String name() const;
00093     String extensions() const;
00094     String version() const;
00095     String vendorName() const;
00096     String OpenCL_C_Version() const;
00097     String OpenCLVersion() const;
00098     int deviceVersionMajor() const;
00099     int deviceVersionMinor() const;
00100     String driverVersion() const;
00101     void* ptr() const;
00102 
00103     int type() const;
00104 
00105     int addressBits() const;
00106     bool available() const;
00107     bool compilerAvailable() const;
00108     bool linkerAvailable() const;
00109 
00110     enum
00111     {
00112         FP_DENORM=(1 << 0),
00113         FP_INF_NAN=(1 << 1),
00114         FP_ROUND_TO_NEAREST=(1 << 2),
00115         FP_ROUND_TO_ZERO=(1 << 3),
00116         FP_ROUND_TO_INF=(1 << 4),
00117         FP_FMA=(1 << 5),
00118         FP_SOFT_FLOAT=(1 << 6),
00119         FP_CORRECTLY_ROUNDED_DIVIDE_SQRT=(1 << 7)
00120     };
00121     int doubleFPConfig() const;
00122     int singleFPConfig() const;
00123     int halfFPConfig() const;
00124 
00125     bool endianLittle() const;
00126     bool errorCorrectionSupport() const;
00127 
00128     enum
00129     {
00130         EXEC_KERNEL=(1 << 0),
00131         EXEC_NATIVE_KERNEL=(1 << 1)
00132     };
00133     int executionCapabilities() const;
00134 
00135     size_t globalMemCacheSize() const;
00136 
00137     enum
00138     {
00139         NO_CACHE=0,
00140         READ_ONLY_CACHE=1,
00141         READ_WRITE_CACHE=2
00142     };
00143     int globalMemCacheType() const;
00144     int globalMemCacheLineSize() const;
00145     size_t globalMemSize() const;
00146 
00147     size_t localMemSize() const;
00148     enum
00149     {
00150         NO_LOCAL_MEM=0,
00151         LOCAL_IS_LOCAL=1,
00152         LOCAL_IS_GLOBAL=2
00153     };
00154     int localMemType() const;
00155     bool hostUnifiedMemory() const;
00156 
00157     bool imageSupport() const;
00158 
00159     bool imageFromBufferSupport() const;
00160     uint imagePitchAlignment() const;
00161     uint imageBaseAddressAlignment() const;
00162 
00163     size_t image2DMaxWidth() const;
00164     size_t image2DMaxHeight() const;
00165 
00166     size_t image3DMaxWidth() const;
00167     size_t image3DMaxHeight() const;
00168     size_t image3DMaxDepth() const;
00169 
00170     size_t imageMaxBufferSize() const;
00171     size_t imageMaxArraySize() const;
00172 
00173     enum
00174     {
00175         UNKNOWN_VENDOR=0,
00176         VENDOR_AMD=1,
00177         VENDOR_INTEL=2,
00178         VENDOR_NVIDIA=3
00179     };
00180     int vendorID() const;
00181     // FIXIT
00182     // dev.isAMD() doesn't work for OpenCL CPU devices from AMD OpenCL platform.
00183     // This method should use platform name instead of vendor name.
00184     // After fix restore code in arithm.cpp: ocl_compare()
00185     inline bool isAMD() const { return vendorID() == VENDOR_AMD; }
00186     inline bool isIntel() const { return vendorID() == VENDOR_INTEL; }
00187     inline bool isNVidia() const { return vendorID() == VENDOR_NVIDIA; }
00188 
00189     int maxClockFrequency() const;
00190     int maxComputeUnits() const;
00191     int maxConstantArgs() const;
00192     size_t maxConstantBufferSize() const;
00193 
00194     size_t maxMemAllocSize() const;
00195     size_t maxParameterSize() const;
00196 
00197     int maxReadImageArgs() const;
00198     int maxWriteImageArgs() const;
00199     int maxSamplers() const;
00200 
00201     size_t maxWorkGroupSize() const;
00202     int maxWorkItemDims() const;
00203     void maxWorkItemSizes(size_t*) const;
00204 
00205     int memBaseAddrAlign() const;
00206 
00207     int nativeVectorWidthChar() const;
00208     int nativeVectorWidthShort() const;
00209     int nativeVectorWidthInt() const;
00210     int nativeVectorWidthLong() const;
00211     int nativeVectorWidthFloat() const;
00212     int nativeVectorWidthDouble() const;
00213     int nativeVectorWidthHalf() const;
00214 
00215     int preferredVectorWidthChar() const;
00216     int preferredVectorWidthShort() const;
00217     int preferredVectorWidthInt() const;
00218     int preferredVectorWidthLong() const;
00219     int preferredVectorWidthFloat() const;
00220     int preferredVectorWidthDouble() const;
00221     int preferredVectorWidthHalf() const;
00222 
00223     size_t printfBufferSize() const;
00224     size_t profilingTimerResolution() const;
00225 
00226     static const Device& getDefault();
00227 
00228 protected:
00229     struct Impl;
00230     Impl* p;
00231 };
00232 
00233 
00234 class CV_EXPORTS Context
00235 {
00236 public:
00237     Context();
00238     explicit Context(int dtype);
00239     ~Context();
00240     Context(const Context& c);
00241     Context& operator = (const Context& c);
00242 
00243     bool create();
00244     bool create(int dtype);
00245     size_t ndevices() const;
00246     const Device& device(size_t idx) const;
00247     Program getProg(const ProgramSource& prog,
00248                     const String& buildopt, String& errmsg);
00249 
00250     static Context& getDefault(bool initialize = true);
00251     void* ptr() const;
00252 
00253     friend void initializeContextFromHandle(Context& ctx, void* platform, void* context, void* device);
00254 
00255     bool useSVM() const;
00256     void setUseSVM(bool enabled);
00257 
00258     struct Impl;
00259     Impl* p;
00260 };
00261 
00262 class CV_EXPORTS Platform
00263 {
00264 public:
00265     Platform();
00266     ~Platform();
00267     Platform(const Platform& p);
00268     Platform& operator = (const Platform& p);
00269 
00270     void* ptr() const;
00271     static Platform& getDefault();
00272 
00273     friend void initializeContextFromHandle(Context& ctx, void* platform, void* context, void* device);
00274 protected:
00275     struct Impl;
00276     Impl* p;
00277 };
00278 
00279 /*
00280 //! @brief Attaches OpenCL context to OpenCV
00281 //
00282 //! @note Note:
00283 //    OpenCV will check if available OpenCL platform has platformName name,
00284 //    then assign context to OpenCV and call clRetainContext function.
00285 //    The deviceID device will be used as target device and new command queue
00286 //    will be created.
00287 //
00288 // Params:
00289 //! @param platformName - name of OpenCL platform to attach,
00290 //!                       this string is used to check if platform is available
00291 //!                       to OpenCV at runtime
00292 //! @param platfromID   - ID of platform attached context was created for
00293 //! @param context      - OpenCL context to be attached to OpenCV
00294 //! @param deviceID     - ID of device, must be created from attached context
00295 */
00296 CV_EXPORTS void attachContext(const String& platformName, void* platformID, void* context, void* deviceID);
00297 
00298 /*
00299 //! @brief Convert OpenCL buffer to UMat
00300 //
00301 //! @note Note:
00302 //   OpenCL buffer (cl_mem_buffer) should contain 2D image data, compatible with OpenCV.
00303 //   Memory content is not copied from clBuffer to UMat. Instead, buffer handle assigned
00304 //   to UMat and clRetainMemObject is called.
00305 //
00306 // Params:
00307 //! @param  cl_mem_buffer - source clBuffer handle
00308 //! @param  step          - num of bytes in single row
00309 //! @param  rows          - number of rows
00310 //! @param  cols          - number of cols
00311 //! @param  type          - OpenCV type of image
00312 //! @param  dst           - destination UMat
00313 */
00314 CV_EXPORTS void convertFromBuffer(void* cl_mem_buffer, size_t step, int rows, int cols, int type, UMat& dst);
00315 
00316 /*
00317 //! @brief Convert OpenCL image2d_t to UMat
00318 //
00319 //! @note Note:
00320 //   OpenCL image2d_t (cl_mem_image), should be compatible with OpenCV
00321 //   UMat formats.
00322 //   Memory content is copied from image to UMat with
00323 //   clEnqueueCopyImageToBuffer function.
00324 //
00325 // Params:
00326 //! @param  cl_mem_image - source image2d_t handle
00327 //! @param  dst          - destination UMat
00328 */
00329 CV_EXPORTS void convertFromImage(void* cl_mem_image, UMat& dst);
00330 
00331 // TODO Move to internal header
00332 void initializeContextFromHandle(Context& ctx, void* platform, void* context, void* device);
00333 
00334 class CV_EXPORTS Queue
00335 {
00336 public:
00337     Queue();
00338     explicit Queue(const Context& c, const Device& d=Device());
00339     ~Queue();
00340     Queue(const Queue& q);
00341     Queue& operator = (const Queue& q);
00342 
00343     bool create(const Context& c=Context(), const Device& d=Device());
00344     void finish();
00345     void* ptr() const;
00346     static Queue& getDefault();
00347 
00348 protected:
00349     struct Impl;
00350     Impl* p;
00351 };
00352 
00353 
00354 class CV_EXPORTS KernelArg
00355 {
00356 public:
00357     enum { LOCAL=1, READ_ONLY=2, WRITE_ONLY=4, READ_WRITE=6, CONSTANT=8, PTR_ONLY = 16, NO_SIZE=256 };
00358     KernelArg(int _flags, UMat* _m, int wscale=1, int iwscale=1, const void* _obj=0, size_t _sz=0);
00359     KernelArg();
00360 
00361     static KernelArg Local() { return KernelArg(LOCAL, 0); }
00362     static KernelArg PtrWriteOnly(const UMat& m)
00363     { return KernelArg(PTR_ONLY+WRITE_ONLY, (UMat*)&m); }
00364     static KernelArg PtrReadOnly(const UMat& m)
00365     { return KernelArg(PTR_ONLY+READ_ONLY, (UMat*)&m); }
00366     static KernelArg PtrReadWrite(const UMat& m)
00367     { return KernelArg(PTR_ONLY+READ_WRITE, (UMat*)&m); }
00368     static KernelArg ReadWrite(const UMat& m, int wscale=1, int iwscale=1)
00369     { return KernelArg(READ_WRITE, (UMat*)&m, wscale, iwscale); }
00370     static KernelArg ReadWriteNoSize(const UMat& m, int wscale=1, int iwscale=1)
00371     { return KernelArg(READ_WRITE+NO_SIZE, (UMat*)&m, wscale, iwscale); }
00372     static KernelArg ReadOnly(const UMat& m, int wscale=1, int iwscale=1)
00373     { return KernelArg(READ_ONLY, (UMat*)&m, wscale, iwscale); }
00374     static KernelArg WriteOnly(const UMat& m, int wscale=1, int iwscale=1)
00375     { return KernelArg(WRITE_ONLY, (UMat*)&m, wscale, iwscale); }
00376     static KernelArg ReadOnlyNoSize(const UMat& m, int wscale=1, int iwscale=1)
00377     { return KernelArg(READ_ONLY+NO_SIZE, (UMat*)&m, wscale, iwscale); }
00378     static KernelArg WriteOnlyNoSize(const UMat& m, int wscale=1, int iwscale=1)
00379     { return KernelArg(WRITE_ONLY+NO_SIZE, (UMat*)&m, wscale, iwscale); }
00380     static KernelArg Constant(const Mat& m);
00381     template<typename _Tp> static KernelArg Constant(const _Tp* arr, size_t n)
00382     { return KernelArg(CONSTANT, 0, 1, 1, (void*)arr, n); }
00383 
00384     int flags;
00385     UMat* m;
00386     const void* obj;
00387     size_t sz;
00388     int wscale, iwscale;
00389 };
00390 
00391 
00392 class CV_EXPORTS Kernel
00393 {
00394 public:
00395     Kernel();
00396     Kernel(const char* kname, const Program& prog);
00397     Kernel(const char* kname, const ProgramSource& prog,
00398            const String& buildopts = String(), String* errmsg=0);
00399     ~Kernel();
00400     Kernel(const Kernel& k);
00401     Kernel& operator = (const Kernel& k);
00402 
00403     bool empty() const;
00404     bool create(const char* kname, const Program& prog);
00405     bool create(const char* kname, const ProgramSource& prog,
00406                 const String& buildopts, String* errmsg=0);
00407 
00408     int set(int i, const void* value, size_t sz);
00409     int set(int i, const Image2D& image2D);
00410     int set(int i, const UMat& m);
00411     int set(int i, const KernelArg& arg);
00412     template<typename _Tp> int set(int i, const _Tp& value)
00413     { return set(i, &value, sizeof(value)); }
00414 
00415     template<typename _Tp0>
00416     Kernel& args(const _Tp0& a0)
00417     {
00418         set(0, a0); return *this;
00419     }
00420 
00421     template<typename _Tp0, typename _Tp1>
00422     Kernel& args(const _Tp0& a0, const _Tp1& a1)
00423     {
00424         int i = set(0, a0); set(i, a1); return *this;
00425     }
00426 
00427     template<typename _Tp0, typename _Tp1, typename _Tp2>
00428     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2)
00429     {
00430         int i = set(0, a0); i = set(i, a1); set(i, a2); return *this;
00431     }
00432 
00433     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3>
00434     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3)
00435     {
00436         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); return *this;
00437     }
00438 
00439     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4>
00440     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2,
00441                  const _Tp3& a3, const _Tp4& a4)
00442     {
00443         int i = set(0, a0); i = set(i, a1); i = set(i, a2);
00444         i = set(i, a3); set(i, a4); return *this;
00445     }
00446 
00447     template<typename _Tp0, typename _Tp1, typename _Tp2,
00448              typename _Tp3, typename _Tp4, typename _Tp5>
00449     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2,
00450                  const _Tp3& a3, const _Tp4& a4, const _Tp5& a5)
00451     {
00452         int i = set(0, a0); i = set(i, a1); i = set(i, a2);
00453         i = set(i, a3); i = set(i, a4); set(i, a5); return *this;
00454     }
00455 
00456     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00457              typename _Tp4, typename _Tp5, typename _Tp6>
00458     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00459                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6)
00460     {
00461         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3);
00462         i = set(i, a4); i = set(i, a5); set(i, a6); return *this;
00463     }
00464 
00465     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00466              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7>
00467     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00468                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7)
00469     {
00470         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3);
00471         i = set(i, a4); i = set(i, a5); i = set(i, a6); set(i, a7); return *this;
00472     }
00473 
00474     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4,
00475              typename _Tp5, typename _Tp6, typename _Tp7, typename _Tp8>
00476     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00477                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00478                  const _Tp8& a8)
00479     {
00480         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4);
00481         i = set(i, a5); i = set(i, a6); i = set(i, a7); set(i, a8); return *this;
00482     }
00483 
00484     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3, typename _Tp4,
00485              typename _Tp5, typename _Tp6, typename _Tp7, typename _Tp8, typename _Tp9>
00486     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00487                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00488                  const _Tp8& a8, const _Tp9& a9)
00489     {
00490         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00491         i = set(i, a6); i = set(i, a7); i = set(i, a8); set(i, a9); return *this;
00492     }
00493 
00494     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00495              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00496              typename _Tp8, typename _Tp9, typename _Tp10>
00497     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00498                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00499                  const _Tp8& a8, const _Tp9& a9, const _Tp10& a10)
00500     {
00501         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00502         i = set(i, a6); i = set(i, a7); i = set(i, a8); i = set(i, a9); set(i, a10); return *this;
00503     }
00504 
00505     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00506              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00507              typename _Tp8, typename _Tp9, typename _Tp10, typename _Tp11>
00508     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00509                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00510                  const _Tp8& a8, const _Tp9& a9, const _Tp10& a10, const _Tp11& a11)
00511     {
00512         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00513         i = set(i, a6); i = set(i, a7); i = set(i, a8); i = set(i, a9); i = set(i, a10); set(i, a11); return *this;
00514     }
00515 
00516     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00517              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00518              typename _Tp8, typename _Tp9, typename _Tp10, typename _Tp11, typename _Tp12>
00519     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00520                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00521                  const _Tp8& a8, const _Tp9& a9, const _Tp10& a10, const _Tp11& a11,
00522                  const _Tp12& a12)
00523     {
00524         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00525         i = set(i, a6); i = set(i, a7); i = set(i, a8); i = set(i, a9); i = set(i, a10); i = set(i, a11);
00526         set(i, a12); return *this;
00527     }
00528 
00529     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00530              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00531              typename _Tp8, typename _Tp9, typename _Tp10, typename _Tp11, typename _Tp12,
00532              typename _Tp13>
00533     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00534                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00535                  const _Tp8& a8, const _Tp9& a9, const _Tp10& a10, const _Tp11& a11,
00536                  const _Tp12& a12, const _Tp13& a13)
00537     {
00538         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00539         i = set(i, a6); i = set(i, a7); i = set(i, a8); i = set(i, a9); i = set(i, a10); i = set(i, a11);
00540         i = set(i, a12); set(i, a13); return *this;
00541     }
00542 
00543     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00544              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00545              typename _Tp8, typename _Tp9, typename _Tp10, typename _Tp11, typename _Tp12,
00546              typename _Tp13, typename _Tp14>
00547     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00548                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00549                  const _Tp8& a8, const _Tp9& a9, const _Tp10& a10, const _Tp11& a11,
00550                  const _Tp12& a12, const _Tp13& a13, const _Tp14& a14)
00551     {
00552         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00553         i = set(i, a6); i = set(i, a7); i = set(i, a8); i = set(i, a9); i = set(i, a10); i = set(i, a11);
00554         i = set(i, a12); i = set(i, a13); set(i, a14); return *this;
00555     }
00556 
00557     template<typename _Tp0, typename _Tp1, typename _Tp2, typename _Tp3,
00558              typename _Tp4, typename _Tp5, typename _Tp6, typename _Tp7,
00559              typename _Tp8, typename _Tp9, typename _Tp10, typename _Tp11, typename _Tp12,
00560              typename _Tp13, typename _Tp14, typename _Tp15>
00561     Kernel& args(const _Tp0& a0, const _Tp1& a1, const _Tp2& a2, const _Tp3& a3,
00562                  const _Tp4& a4, const _Tp5& a5, const _Tp6& a6, const _Tp7& a7,
00563                  const _Tp8& a8, const _Tp9& a9, const _Tp10& a10, const _Tp11& a11,
00564                  const _Tp12& a12, const _Tp13& a13, const _Tp14& a14, const _Tp15& a15)
00565     {
00566         int i = set(0, a0); i = set(i, a1); i = set(i, a2); i = set(i, a3); i = set(i, a4); i = set(i, a5);
00567         i = set(i, a6); i = set(i, a7); i = set(i, a8); i = set(i, a9); i = set(i, a10); i = set(i, a11);
00568         i = set(i, a12); i = set(i, a13); i = set(i, a14); set(i, a15); return *this;
00569     }
00570 
00571     bool run(int dims, size_t globalsize[],
00572              size_t localsize[], bool sync, const Queue& q=Queue());
00573     bool runTask(bool sync, const Queue& q=Queue());
00574 
00575     size_t workGroupSize() const;
00576     size_t preferedWorkGroupSizeMultiple() const;
00577     bool compileWorkGroupSize(size_t wsz[]) const;
00578     size_t localMemSize() const;
00579 
00580     void* ptr() const;
00581     struct Impl;
00582 
00583 protected:
00584     Impl* p;
00585 };
00586 
00587 class CV_EXPORTS Program
00588 {
00589 public:
00590     Program();
00591     Program(const ProgramSource& src,
00592             const String& buildflags, String& errmsg);
00593     explicit Program(const String& buf);
00594     Program(const Program& prog);
00595 
00596     Program& operator = (const Program& prog);
00597     ~Program();
00598 
00599     bool create(const ProgramSource& src,
00600                 const String& buildflags, String& errmsg);
00601     bool read(const String& buf, const String& buildflags);
00602     bool write(String& buf) const;
00603 
00604     const ProgramSource& source() const;
00605     void* ptr() const;
00606 
00607     String getPrefix() const;
00608     static String getPrefix(const String& buildflags);
00609 
00610 protected:
00611     struct Impl;
00612     Impl* p;
00613 };
00614 
00615 
00616 class CV_EXPORTS ProgramSource
00617 {
00618 public:
00619     typedef uint64 hash_t;
00620 
00621     ProgramSource();
00622     explicit ProgramSource(const String& prog);
00623     explicit ProgramSource(const char* prog);
00624     ~ProgramSource();
00625     ProgramSource(const ProgramSource& prog);
00626     ProgramSource& operator = (const ProgramSource& prog);
00627 
00628     const String& source() const;
00629     hash_t hash() const;
00630 
00631 protected:
00632     struct Impl;
00633     Impl* p;
00634 };
00635 
00636 class CV_EXPORTS PlatformInfo
00637 {
00638 public:
00639     PlatformInfo();
00640     explicit PlatformInfo(void* id);
00641     ~PlatformInfo();
00642 
00643     PlatformInfo(const PlatformInfo& i);
00644     PlatformInfo& operator =(const PlatformInfo& i);
00645 
00646     String name() const;
00647     String vendor() const;
00648     String version() const;
00649     int deviceNumber() const;
00650     void getDevice(Device& device, int d) const;
00651 
00652 protected:
00653     struct Impl;
00654     Impl* p;
00655 };
00656 
00657 CV_EXPORTS const char* convertTypeStr(int sdepth, int ddepth, int cn, char* buf);
00658 CV_EXPORTS const char* typeToStr(int t);
00659 CV_EXPORTS const char* memopTypeToStr(int t);
00660 CV_EXPORTS const char* vecopTypeToStr(int t);
00661 CV_EXPORTS String kernelToStr(InputArray _kernel, int ddepth = -1, const char * name = NULL);
00662 CV_EXPORTS void getPlatfomsInfo(std::vector<PlatformInfo>& platform_info);
00663 
00664 
00665 enum OclVectorStrategy
00666 {
00667     // all matrices have its own vector width
00668     OCL_VECTOR_OWN = 0,
00669     // all matrices have maximal vector width among all matrices
00670     // (useful for cases when matrices have different data types)
00671     OCL_VECTOR_MAX = 1,
00672 
00673     // default strategy
00674     OCL_VECTOR_DEFAULT = OCL_VECTOR_OWN
00675 };
00676 
00677 CV_EXPORTS int predictOptimalVectorWidth(InputArray src1, InputArray src2 = noArray(), InputArray src3 = noArray(),
00678                                          InputArray src4 = noArray(), InputArray src5 = noArray(), InputArray src6 = noArray(),
00679                                          InputArray src7 = noArray(), InputArray src8 = noArray(), InputArray src9 = noArray(),
00680                                          OclVectorStrategy strat = OCL_VECTOR_DEFAULT);
00681 
00682 CV_EXPORTS int checkOptimalVectorWidth(const int *vectorWidths,
00683                                        InputArray src1, InputArray src2 = noArray(), InputArray src3 = noArray(),
00684                                        InputArray src4 = noArray(), InputArray src5 = noArray(), InputArray src6 = noArray(),
00685                                        InputArray src7 = noArray(), InputArray src8 = noArray(), InputArray src9 = noArray(),
00686                                        OclVectorStrategy strat = OCL_VECTOR_DEFAULT);
00687 
00688 // with OCL_VECTOR_MAX strategy
00689 CV_EXPORTS int predictOptimalVectorWidthMax(InputArray src1, InputArray src2 = noArray(), InputArray src3 = noArray(),
00690                                             InputArray src4 = noArray(), InputArray src5 = noArray(), InputArray src6 = noArray(),
00691                                             InputArray src7 = noArray(), InputArray src8 = noArray(), InputArray src9 = noArray());
00692 
00693 CV_EXPORTS void buildOptionsAddMatrixDescription(String& buildOptions, const String& name, InputArray _m);
00694 
00695 class CV_EXPORTS Image2D
00696 {
00697 public:
00698     Image2D();
00699 
00700     // src:     The UMat from which to get image properties and data
00701     // norm:    Flag to enable the use of normalized channel data types
00702     // alias:   Flag indicating that the image should alias the src UMat.
00703     //          If true, changes to the image or src will be reflected in
00704     //          both objects.
00705     explicit Image2D(const UMat &src, bool norm = false, bool alias = false);
00706     Image2D(const Image2D & i);
00707     ~Image2D();
00708 
00709     Image2D & operator = (const Image2D & i);
00710 
00711     // Indicates if creating an aliased image should succeed.  Depends on the
00712     // underlying platform and the dimensions of the UMat.
00713     static bool canCreateAlias(const UMat &u);
00714 
00715     // Indicates if the image format is supported.
00716     static bool isFormatSupported(int depth, int cn, bool norm);
00717 
00718     void* ptr() const;
00719 protected:
00720     struct Impl;
00721     Impl* p;
00722 };
00723 
00724 
00725 CV_EXPORTS MatAllocator* getOpenCLAllocator();
00726 
00727 
00728 #ifdef __OPENCV_BUILD
00729 namespace internal {
00730 
00731 //CV_EXPORTS bool isPerformanceCheckBypassed();
00732 #define OCL_PERFORMANCE_CHECK(condition) #error abc (cv::ocl::internal::isPerformanceCheckBypassed() || (condition))
00733 
00734 //CV_EXPORTS bool isCLBuffer(UMat& u);
00735 
00736 } // namespace internal
00737 #endif
00738 
00739 //! @}
00740 
00741 }}
00742 
00743 #endif
00744