1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000-2008, Intel Corporation, all rights reserved. 14 // Copyright (C) 2009, Willow Garage Inc., all rights reserved. 15 // Third party copyrights are property of their respective owners. 16 // 17 // Redistribution and use in source and binary forms, with or without modification, 18 // are permitted provided that the following conditions are met: 19 // 20 // * Redistribution's of source code must retain the above copyright notice, 21 // this list of conditions and the following disclaimer. 22 // 23 // * Redistribution's in binary form must reproduce the above copyright notice, 24 // this list of conditions and the following disclaimer in the documentation 25 // and/or other materials provided with the distribution. 26 // 27 // * The name of the copyright holders may not be used to endorse or promote products 28 // derived from this software without specific prior written permission. 29 // 30 // This software is provided by the copyright holders and contributors "as is" and 31 // any express or implied warranties, including, but not limited to, the implied 32 // warranties of merchantability and fitness for a particular purpose are disclaimed. 33 // In no event shall the Intel Corporation or contributors be liable for any direct, 34 // indirect, incidental, special, exemplary, or consequential damages 35 // (including, but not limited to, procurement of substitute goods or services; 36 // loss of use, data, or profits; or business interruption) however caused 37 // and on any theory of liability, whether in contract, strict liability, 38 // or tort (including negligence or otherwise) arising in any way out of 39 // the use of this software, even if advised of the possibility of such damage. 40 // 41 //M*/ 42 43 #ifndef __OPENCV_PRECOMP_H__ 44 #define __OPENCV_PRECOMP_H__ 45 46 #include "opencv2/opencv_modules.hpp" 47 #include "cvconfig.h" 48 49 #include "opencv2/core/utility.hpp" 50 #include "opencv2/core/core_c.h" 51 #include "opencv2/core/cuda.hpp" 52 #include "opencv2/core/opengl.hpp" 53 54 #include "opencv2/core/private.hpp" 55 #include "opencv2/core/private.cuda.hpp" 56 #include "opencv2/core/ocl.hpp" 57 58 #include "opencv2/hal.hpp" 59 60 #include <assert.h> 61 #include <ctype.h> 62 #include <float.h> 63 #include <limits.h> 64 #include <math.h> 65 #include <stdio.h> 66 #include <stdlib.h> 67 #include <string.h> 68 69 #ifdef HAVE_TEGRA_OPTIMIZATION 70 #include "opencv2/core/core_tegra.hpp" 71 #else 72 #define GET_OPTIMIZED(func) (func) 73 #endif 74 75 namespace cv 76 { 77 78 typedef void (*BinaryFunc)(const uchar* src1, size_t step1, 79 const uchar* src2, size_t step2, 80 uchar* dst, size_t step, Size sz, 81 void*); 82 83 BinaryFunc getConvertFunc(int sdepth, int ddepth); 84 BinaryFunc getCopyMaskFunc(size_t esz); 85 86 /* default memory block for sparse array elements */ 87 #define CV_SPARSE_MAT_BLOCK (1<<12) 88 89 /* initial hash table size */ 90 #define CV_SPARSE_HASH_SIZE0 (1<<10) 91 92 /* maximal average node_count/hash_size ratio beyond which hash table is resized */ 93 #define CV_SPARSE_HASH_RATIO 3 94 95 96 97 // -128.f ... 255.f 98 extern const float g_8x32fTab[]; 99 #define CV_8TO32F(x) cv::g_8x32fTab[(x)+128] 100 101 extern const ushort g_8x16uSqrTab[]; 102 #define CV_SQR_8U(x) cv::g_8x16uSqrTab[(x)+255] 103 104 extern const uchar g_Saturate8u[]; 105 #define CV_FAST_CAST_8U(t) (assert(-256 <= (t) && (t) <= 512), cv::g_Saturate8u[(t)+256]) 106 #define CV_MIN_8U(a,b) ((a) - CV_FAST_CAST_8U((a) - (b))) 107 #define CV_MAX_8U(a,b) ((a) + CV_FAST_CAST_8U((b) - (a))) 108 109 110 #if defined WIN32 || defined _WIN32 111 void deleteThreadAllocData(); 112 #endif 113 114 template<typename T1, typename T2=T1, typename T3=T1> struct OpAdd 115 { 116 typedef T1 type1; 117 typedef T2 type2; 118 typedef T3 rtype; 119 T3 operator ()(const T1 a, const T2 b) const { return saturate_cast<T3>(a + b); } 120 }; 121 122 template<typename T1, typename T2=T1, typename T3=T1> struct OpSub 123 { 124 typedef T1 type1; 125 typedef T2 type2; 126 typedef T3 rtype; 127 T3 operator ()(const T1 a, const T2 b) const { return saturate_cast<T3>(a - b); } 128 }; 129 130 template<typename T1, typename T2=T1, typename T3=T1> struct OpRSub 131 { 132 typedef T1 type1; 133 typedef T2 type2; 134 typedef T3 rtype; 135 T3 operator ()(const T1 a, const T2 b) const { return saturate_cast<T3>(b - a); } 136 }; 137 138 template<typename T> struct OpMin 139 { 140 typedef T type1; 141 typedef T type2; 142 typedef T rtype; 143 T operator ()(const T a, const T b) const { return std::min(a, b); } 144 }; 145 146 template<typename T> struct OpMax 147 { 148 typedef T type1; 149 typedef T type2; 150 typedef T rtype; 151 T operator ()(const T a, const T b) const { return std::max(a, b); } 152 }; 153 154 inline Size getContinuousSize_( int flags, int cols, int rows, int widthScale ) 155 { 156 int64 sz = (int64)cols * rows * widthScale; 157 return (flags & Mat::CONTINUOUS_FLAG) != 0 && 158 (int)sz == sz ? Size((int)sz, 1) : Size(cols * widthScale, rows); 159 } 160 161 inline Size getContinuousSize( const Mat& m1, int widthScale=1 ) 162 { 163 return getContinuousSize_(m1.flags, 164 m1.cols, m1.rows, widthScale); 165 } 166 167 inline Size getContinuousSize( const Mat& m1, const Mat& m2, int widthScale=1 ) 168 { 169 return getContinuousSize_(m1.flags & m2.flags, 170 m1.cols, m1.rows, widthScale); 171 } 172 173 inline Size getContinuousSize( const Mat& m1, const Mat& m2, 174 const Mat& m3, int widthScale=1 ) 175 { 176 return getContinuousSize_(m1.flags & m2.flags & m3.flags, 177 m1.cols, m1.rows, widthScale); 178 } 179 180 inline Size getContinuousSize( const Mat& m1, const Mat& m2, 181 const Mat& m3, const Mat& m4, 182 int widthScale=1 ) 183 { 184 return getContinuousSize_(m1.flags & m2.flags & m3.flags & m4.flags, 185 m1.cols, m1.rows, widthScale); 186 } 187 188 inline Size getContinuousSize( const Mat& m1, const Mat& m2, 189 const Mat& m3, const Mat& m4, 190 const Mat& m5, int widthScale=1 ) 191 { 192 return getContinuousSize_(m1.flags & m2.flags & m3.flags & m4.flags & m5.flags, 193 m1.cols, m1.rows, widthScale); 194 } 195 196 struct NoVec 197 { 198 size_t operator()(const void*, const void*, void*, size_t) const { return 0; } 199 }; 200 201 extern volatile bool USE_SSE2; 202 extern volatile bool USE_SSE4_2; 203 extern volatile bool USE_AVX; 204 extern volatile bool USE_AVX2; 205 206 enum { BLOCK_SIZE = 1024 }; 207 208 #if defined HAVE_IPP && (IPP_VERSION_MAJOR >= 7) 209 #define ARITHM_USE_IPP 1 210 #else 211 #define ARITHM_USE_IPP 0 212 #endif 213 214 inline bool checkScalar(const Mat& sc, int atype, int sckind, int akind) 215 { 216 if( sc.dims > 2 || !sc.isContinuous() ) 217 return false; 218 Size sz = sc.size(); 219 if(sz.width != 1 && sz.height != 1) 220 return false; 221 int cn = CV_MAT_CN(atype); 222 if( akind == _InputArray::MATX && sckind != _InputArray::MATX ) 223 return false; 224 return sz == Size(1, 1) || sz == Size(1, cn) || sz == Size(cn, 1) || 225 (sz == Size(1, 4) && sc.type() == CV_64F && cn <= 4); 226 } 227 228 inline bool checkScalar(InputArray sc, int atype, int sckind, int akind) 229 { 230 if( sc.dims() > 2 || !sc.isContinuous() ) 231 return false; 232 Size sz = sc.size(); 233 if(sz.width != 1 && sz.height != 1) 234 return false; 235 int cn = CV_MAT_CN(atype); 236 if( akind == _InputArray::MATX && sckind != _InputArray::MATX ) 237 return false; 238 return sz == Size(1, 1) || sz == Size(1, cn) || sz == Size(cn, 1) || 239 (sz == Size(1, 4) && sc.type() == CV_64F && cn <= 4); 240 } 241 242 void convertAndUnrollScalar( const Mat& sc, int buftype, uchar* scbuf, size_t blocksize ); 243 244 #ifdef CV_COLLECT_IMPL_DATA 245 struct ImplCollector 246 { 247 ImplCollector() 248 { 249 useCollection = false; 250 implFlags = 0; 251 } 252 bool useCollection; // enable/disable impl data collection 253 254 int implFlags; 255 std::vector<int> implCode; 256 std::vector<String> implFun; 257 258 cv::Mutex mutex; 259 }; 260 #endif 261 262 struct CoreTLSData 263 { 264 CoreTLSData() : device(0), useOpenCL(-1), useIPP(-1) 265 { 266 #ifdef HAVE_TEGRA_OPTIMIZATION 267 useTegra = -1; 268 #endif 269 } 270 271 RNG rng; 272 int device; 273 ocl::Queue oclQueue; 274 int useOpenCL; // 1 - use, 0 - do not use, -1 - auto/not initialized 275 int useIPP; // 1 - use, 0 - do not use, -1 - auto/not initialized 276 #ifdef HAVE_TEGRA_OPTIMIZATION 277 int useTegra; // 1 - use, 0 - do not use, -1 - auto/not initialized 278 #endif 279 }; 280 281 TLSData<CoreTLSData>& getCoreTlsData(); 282 283 #if defined(BUILD_SHARED_LIBS) 284 #if defined WIN32 || defined _WIN32 || defined WINCE 285 #define CL_RUNTIME_EXPORT __declspec(dllexport) 286 #elif defined __GNUC__ && __GNUC__ >= 4 287 #define CL_RUNTIME_EXPORT __attribute__ ((visibility ("default"))) 288 #else 289 #define CL_RUNTIME_EXPORT 290 #endif 291 #else 292 #define CL_RUNTIME_EXPORT 293 #endif 294 295 #ifndef HAVE_PTHREADS 296 #if !(defined WIN32 || defined _WIN32 || defined WINCE || defined HAVE_WINRT) 297 #define HAVE_PTHREADS 1 298 #endif 299 #endif 300 301 extern bool __termination; // skip some cleanups, because process is terminating 302 // (for example, if ExitProcess() was already called) 303 304 } 305 306 #include "opencv2/hal/intrin.hpp" 307 308 #endif /*_CXCORE_INTERNAL_H_*/ 309
