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 // Intel License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000, Intel Corporation, all rights reserved. 14 // Third party copyrights are property of their respective owners. 15 // 16 // Redistribution and use in source and binary forms, with or without modification, 17 // are permitted provided that the following conditions are met: 18 // 19 // * Redistribution's of source code must retain the above copyright notice, 20 // this list of conditions and the following disclaimer. 21 // 22 // * Redistribution's in binary form must reproduce the above copyright notice, 23 // this list of conditions and the following disclaimer in the documentation 24 // and/or other materials provided with the distribution. 25 // 26 // * The name of Intel Corporation may not be used to endorse or promote products 27 // derived from this software without specific prior written permission. 28 // 29 // This software is provided by the copyright holders and contributors "as is" and 30 // any express or implied warranties, including, but not limited to, the implied 31 // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 // In no event shall the Intel Corporation or contributors be liable for any direct, 33 // indirect, incidental, special, exemplary, or consequential damages 34 // (including, but not limited to, procurement of substitute goods or services; 35 // loss of use, data, or profits; or business interruption) however caused 36 // and on any theory of liability, whether in contract, strict liability, 37 // or tort (including negligence or otherwise) arising in any way out of 38 // the use of this software, even if advised of the possibility of such damage. 39 // 40 //M*/ 41 42 #ifndef _CXCORE_IPP_H_ 43 #define _CXCORE_IPP_H_ 44 45 /****************************************************************************************\ 46 * Copy/Set * 47 \****************************************************************************************/ 48 49 /* temporary disable ipp zero and copy functions as they affect subsequent functions' performance */ 50 IPCVAPI_EX( CvStatus, icvCopy_8u_C1R, "ippiCopy_8u_C1R", 0/*CV_PLUGINS1(CV_PLUGIN_IPPI)*/, 51 ( const uchar* src, int src_step, 52 uchar* dst, int dst_step, CvSize size )) 53 54 IPCVAPI_EX( CvStatus, icvSetByte_8u_C1R, "ippiSet_8u_C1R", 0/*CV_PLUGINS1(CV_PLUGIN_IPPI)*/, 55 ( uchar value, uchar* dst, int dst_step, CvSize size )) 56 57 IPCVAPI_EX( CvStatus, icvCvt_32f64f, "ippsConvert_32f64f", 58 CV_PLUGINS1(CV_PLUGIN_IPPS), ( const float* src, double* dst, int len )) 59 IPCVAPI_EX( CvStatus, icvCvt_64f32f, "ippsConvert_64f32f", 60 CV_PLUGINS1(CV_PLUGIN_IPPS), ( const double* src, float* dst, int len )) 61 62 #define IPCV_COPYSET( flavor, arrtype, scalartype ) \ 63 IPCVAPI_EX( CvStatus, icvCopy##flavor, "ippiCopy" #flavor, \ 64 CV_PLUGINS1(CV_PLUGIN_IPPI), \ 65 ( const arrtype* src, int srcstep, \ 66 arrtype* dst, int dststep, CvSize size, \ 67 const uchar* mask, int maskstep )) \ 68 IPCVAPI_EX( CvStatus, icvSet##flavor, "ippiSet" #flavor, \ 69 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 70 ( arrtype* dst, int dststep, \ 71 const uchar* mask, int maskstep, \ 72 CvSize size, const arrtype* scalar )) 73 74 IPCV_COPYSET( _8u_C1MR, uchar, int ) 75 IPCV_COPYSET( _16s_C1MR, ushort, int ) 76 IPCV_COPYSET( _8u_C3MR, uchar, int ) 77 IPCV_COPYSET( _8u_C4MR, int, int ) 78 IPCV_COPYSET( _16s_C3MR, ushort, int ) 79 IPCV_COPYSET( _16s_C4MR, int64, int64 ) 80 IPCV_COPYSET( _32f_C3MR, int, int ) 81 IPCV_COPYSET( _32f_C4MR, int, int ) 82 IPCV_COPYSET( _64s_C3MR, int64, int64 ) 83 IPCV_COPYSET( _64s_C4MR, int64, int64 ) 84 85 86 /****************************************************************************************\ 87 * Arithmetics * 88 \****************************************************************************************/ 89 90 #define IPCV_BIN_ARITHM( name ) \ 91 IPCVAPI_EX( CvStatus, icv##name##_8u_C1R, \ 92 "ippi" #name "_8u_C1RSfs", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 93 ( const uchar* src1, int srcstep1, const uchar* src2, int srcstep2, \ 94 uchar* dst, int dststep, CvSize size, int scalefactor )) \ 95 IPCVAPI_EX( CvStatus, icv##name##_16u_C1R, \ 96 "ippi" #name "_16u_C1RSfs", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 97 ( const ushort* src1, int srcstep1, const ushort* src2, int srcstep2,\ 98 ushort* dst, int dststep, CvSize size, int scalefactor )) \ 99 IPCVAPI_EX( CvStatus, icv##name##_16s_C1R, \ 100 "ippi" #name "_16s_C1RSfs", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 101 ( const short* src1, int srcstep1, const short* src2, int srcstep2, \ 102 short* dst, int dststep, CvSize size, int scalefactor )) \ 103 IPCVAPI_EX( CvStatus, icv##name##_32s_C1R, \ 104 "ippi" #name "_32s_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 105 ( const int* src1, int srcstep1, const int* src2, int srcstep2, \ 106 int* dst, int dststep, CvSize size )) \ 107 IPCVAPI_EX( CvStatus, icv##name##_32f_C1R, \ 108 "ippi" #name "_32f_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 109 ( const float* src1, int srcstep1, const float* src2, int srcstep2, \ 110 float* dst, int dststep, CvSize size )) \ 111 IPCVAPI_EX( CvStatus, icv##name##_64f_C1R, \ 112 "ippi" #name "_64f_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 113 ( const double* src1, int srcstep1, const double* src2, int srcstep2,\ 114 double* dst, int dststep, CvSize size )) 115 116 117 IPCV_BIN_ARITHM( Add ) 118 IPCV_BIN_ARITHM( Sub ) 119 120 #undef IPCV_BIN_ARITHM 121 122 /****************************************************************************************\ 123 * Logical operations * 124 \****************************************************************************************/ 125 126 #define IPCV_LOGIC( name ) \ 127 IPCVAPI_EX( CvStatus, icv##name##_8u_C1R, \ 128 "ippi" #name "_8u_C1R", 0/*CV_PLUGINS1(CV_PLUGIN_IPPI)*/, \ 129 ( const uchar* src1, int srcstep1, const uchar* src2, int srcstep2, \ 130 uchar* dst, int dststep, CvSize size )) 131 132 IPCV_LOGIC( And ) 133 IPCV_LOGIC( Or ) 134 IPCV_LOGIC( Xor ) 135 136 #undef IPCV_LOGIC 137 138 IPCVAPI_EX( CvStatus, icvNot_8u_C1R, "ippiNot_8u_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), 139 ( const uchar* src, int step1, uchar* dst, int step, CvSize size )) 140 141 /****************************************************************************************\ 142 * Image Statistics * 143 \****************************************************************************************/ 144 145 ///////////////////////////////////////// Mean ////////////////////////////////////////// 146 147 #define IPCV_DEF_MEAN_MASK( flavor, srctype ) \ 148 IPCVAPI_EX( CvStatus, icvMean_##flavor##_C1MR, \ 149 "ippiMean_" #flavor "_C1MR", CV_PLUGINS1(CV_PLUGIN_IPPCV), \ 150 ( const srctype* img, int imgstep, const uchar* mask, \ 151 int maskStep, CvSize size, double* mean )) \ 152 IPCVAPI_EX( CvStatus, icvMean_##flavor##_C2MR, \ 153 "ippiMean_" #flavor "_C2MR", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 154 ( const srctype* img, int imgstep, const uchar* mask, \ 155 int maskStep, CvSize size, double* mean )) \ 156 IPCVAPI_EX( CvStatus, icvMean_##flavor##_C3MR, \ 157 "ippiMean_" #flavor "_C3MR", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 158 ( const srctype* img, int imgstep, const uchar* mask, \ 159 int maskStep, CvSize size, double* mean )) \ 160 IPCVAPI_EX( CvStatus, icvMean_##flavor##_C4MR, \ 161 "ippiMean_" #flavor "_C4MR", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 162 ( const srctype* img, int imgstep, const uchar* mask, \ 163 int maskStep, CvSize size, double* mean )) 164 165 IPCV_DEF_MEAN_MASK( 8u, uchar ) 166 IPCV_DEF_MEAN_MASK( 16u, ushort ) 167 IPCV_DEF_MEAN_MASK( 16s, short ) 168 IPCV_DEF_MEAN_MASK( 32s, int ) 169 IPCV_DEF_MEAN_MASK( 32f, float ) 170 IPCV_DEF_MEAN_MASK( 64f, double ) 171 172 #undef IPCV_DEF_MEAN_MASK 173 174 //////////////////////////////////// Mean_StdDev //////////////////////////////////////// 175 176 #undef IPCV_MEAN_SDV_PLUGIN 177 #define ICV_MEAN_SDV_PLUGIN 0 /* CV_PLUGINS1(IPPCV) */ 178 179 #define IPCV_DEF_MEAN_SDV( flavor, srctype ) \ 180 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C1R, \ 181 "ippiMean_StdDev_" #flavor "_C1R", ICV_MEAN_SDV_PLUGIN, \ 182 ( const srctype* img, int imgstep, CvSize size, double* mean, double* sdv ))\ 183 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C2R, \ 184 "ippiMean_StdDev_" #flavor "_C2R", ICV_MEAN_SDV_PLUGIN, \ 185 ( const srctype* img, int imgstep, CvSize size, double* mean, double* sdv ))\ 186 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C3R, \ 187 "ippiMean_StdDev_" #flavor "_C3R", ICV_MEAN_SDV_PLUGIN, \ 188 ( const srctype* img, int imgstep, CvSize size, double* mean, double* sdv ))\ 189 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C4R, \ 190 "ippiMean_StdDev_" #flavor "_C4R", ICV_MEAN_SDV_PLUGIN, \ 191 ( const srctype* img, int imgstep, CvSize size, double* mean, double* sdv ))\ 192 \ 193 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C1MR, \ 194 "ippiMean_StdDev_" #flavor "_C1MR", ICV_MEAN_SDV_PLUGIN, \ 195 ( const srctype* img, int imgstep, \ 196 const uchar* mask, int maskStep, \ 197 CvSize size, double* mean, double* sdv )) \ 198 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C2MR, \ 199 "ippiMean_StdDev_" #flavor "_C2MR", ICV_MEAN_SDV_PLUGIN, \ 200 ( const srctype* img, int imgstep, const uchar* mask, int maskStep, \ 201 CvSize size, double* mean, double* sdv )) \ 202 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C3MR, \ 203 "ippiMean_StdDev_" #flavor "_C3MR", ICV_MEAN_SDV_PLUGIN, \ 204 ( const srctype* img, int imgstep, \ 205 const uchar* mask, int maskStep, \ 206 CvSize size, double* mean, double* sdv )) \ 207 IPCVAPI_EX( CvStatus, icvMean_StdDev_##flavor##_C4MR, \ 208 "ippiMean_StdDev_" #flavor "_C4MR", ICV_MEAN_SDV_PLUGIN, \ 209 ( const srctype* img, int imgstep, \ 210 const uchar* mask, int maskStep, \ 211 CvSize size, double* mean, double* sdv )) 212 213 IPCV_DEF_MEAN_SDV( 8u, uchar ) 214 IPCV_DEF_MEAN_SDV( 16u, ushort ) 215 IPCV_DEF_MEAN_SDV( 16s, short ) 216 IPCV_DEF_MEAN_SDV( 32s, int ) 217 IPCV_DEF_MEAN_SDV( 32f, float ) 218 IPCV_DEF_MEAN_SDV( 64f, double ) 219 220 #undef IPCV_DEF_MEAN_SDV 221 #undef IPCV_MEAN_SDV_PLUGIN 222 223 //////////////////////////////////// MinMaxIndx ///////////////////////////////////////// 224 225 #define IPCV_DEF_MIN_MAX_LOC( flavor, srctype, extrtype, plugin ) \ 226 IPCVAPI_EX( CvStatus, icvMinMaxIndx_##flavor##_C1R, \ 227 "ippiMinMaxIndx_" #flavor "_C1R", plugin, \ 228 ( const srctype* img, int imgstep, \ 229 CvSize size, extrtype* minVal, extrtype* maxVal, \ 230 CvPoint* minLoc, CvPoint* maxLoc )) \ 231 \ 232 IPCVAPI_EX( CvStatus, icvMinMaxIndx_##flavor##_C1MR, \ 233 "ippiMinMaxIndx_" #flavor "_C1MR", plugin, \ 234 ( const srctype* img, int imgstep, \ 235 const uchar* mask, int maskStep, \ 236 CvSize size, extrtype* minVal, extrtype* maxVal, \ 237 CvPoint* minLoc, CvPoint* maxLoc )) 238 239 IPCV_DEF_MIN_MAX_LOC( 8u, uchar, float, CV_PLUGINS1(CV_PLUGIN_IPPCV) ) 240 IPCV_DEF_MIN_MAX_LOC( 16u, ushort, float, 0 ) 241 IPCV_DEF_MIN_MAX_LOC( 16s, short, float, CV_PLUGINS1(CV_PLUGIN_IPPCV) ) 242 IPCV_DEF_MIN_MAX_LOC( 32s, int, double, 0 ) 243 #if !defined WIN64 && (defined WIN32 || defined __i386__) 244 IPCV_DEF_MIN_MAX_LOC( 32f, int, float, CV_PLUGINS1(CV_PLUGIN_IPPCV) ) 245 #else 246 IPCV_DEF_MIN_MAX_LOC( 32f, int, float, 0 ) 247 #endif 248 IPCV_DEF_MIN_MAX_LOC( 64f, int64, double, 0 ) 249 250 #undef IPCV_DEF_MIN_MAX_LOC 251 252 ////////////////////////////////////////// Sum ////////////////////////////////////////// 253 254 #define IPCV_DEF_SUM_NOHINT( flavor, srctype, plugin ) \ 255 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C1R, \ 256 "ippiSum_" #flavor "_C1R", plugin, \ 257 ( const srctype* img, int imgstep, CvSize size, double* sum )) \ 258 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C2R, \ 259 "ippiSum_" #flavor "_C2R", plugin, \ 260 ( const srctype* img, int imgstep, CvSize size, double* sum )) \ 261 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C3R, \ 262 "ippiSum_" #flavor "_C3R", plugin, \ 263 ( const srctype* img, int imgstep, CvSize size, double* sum )) \ 264 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C4R, \ 265 "ippiSum_" #flavor "_C4R", plugin, \ 266 ( const srctype* img, int imgstep, CvSize size, double* sum )) 267 268 #define IPCV_DEF_SUM_HINT( flavor, srctype ) \ 269 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C1R, \ 270 "ippiSum_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 271 ( const srctype* img, int imgstep, \ 272 CvSize size, double* sum, CvHintAlgorithm )) \ 273 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C2R, \ 274 "ippiSum_" #flavor "_C2R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 275 ( const srctype* img, int imgstep, \ 276 CvSize size, double* sum, CvHintAlgorithm )) \ 277 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C3R, \ 278 "ippiSum_" #flavor "_C3R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 279 ( const srctype* img, int imgstep, \ 280 CvSize size, double* sum, CvHintAlgorithm )) \ 281 IPCVAPI_EX( CvStatus, icvSum_##flavor##_C4R, \ 282 "ippiSum_" #flavor "_C4R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 283 ( const srctype* img, int imgstep, \ 284 CvSize size, double* sum, CvHintAlgorithm )) 285 286 IPCV_DEF_SUM_NOHINT( 8u, uchar, CV_PLUGINS1(CV_PLUGIN_IPPI) ) 287 IPCV_DEF_SUM_NOHINT( 16s, short, CV_PLUGINS1(CV_PLUGIN_IPPI) ) 288 IPCV_DEF_SUM_NOHINT( 16u, ushort, 0 ) 289 IPCV_DEF_SUM_NOHINT( 32s, int, 0 ) 290 IPCV_DEF_SUM_HINT( 32f, float ) 291 IPCV_DEF_SUM_NOHINT( 64f, double, 0 ) 292 293 #undef IPCV_DEF_SUM_NOHINT 294 #undef IPCV_DEF_SUM_HINT 295 296 ////////////////////////////////////////// CountNonZero ///////////////////////////////// 297 298 #define IPCV_DEF_NON_ZERO( flavor, srctype ) \ 299 IPCVAPI_EX( CvStatus, icvCountNonZero_##flavor##_C1R, \ 300 "ippiCountNonZero_" #flavor "_C1R", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 301 ( const srctype* img, int imgstep, CvSize size, int* nonzero )) 302 303 IPCV_DEF_NON_ZERO( 8u, uchar ) 304 IPCV_DEF_NON_ZERO( 16s, ushort ) 305 IPCV_DEF_NON_ZERO( 32s, int ) 306 IPCV_DEF_NON_ZERO( 32f, int ) 307 IPCV_DEF_NON_ZERO( 64f, int64 ) 308 309 #undef IPCV_DEF_NON_ZERO 310 311 ////////////////////////////////////////// Norms ///////////////////////////////// 312 313 #define IPCV_DEF_NORM_NOHINT_C1( flavor, srctype, plugin ) \ 314 IPCVAPI_EX( CvStatus, icvNorm_Inf_##flavor##_C1R, \ 315 "ippiNorm_Inf_" #flavor "_C1R", plugin, \ 316 ( const srctype* img, int imgstep, CvSize size, double* norm )) \ 317 IPCVAPI_EX( CvStatus, icvNorm_L1_##flavor##_C1R, \ 318 "ippiNorm_L1_" #flavor "_C1R", plugin, \ 319 ( const srctype* img, int imgstep, CvSize size, double* norm )) \ 320 IPCVAPI_EX( CvStatus, icvNorm_L2_##flavor##_C1R, \ 321 "ippiNorm_L2_" #flavor "_C1R", plugin, \ 322 ( const srctype* img, int imgstep, CvSize size, double* norm )) \ 323 IPCVAPI_EX( CvStatus, icvNormDiff_Inf_##flavor##_C1R, \ 324 "ippiNormDiff_Inf_" #flavor "_C1R", plugin, \ 325 ( const srctype* img1, int imgstep1, \ 326 const srctype* img2, int imgstep2, \ 327 CvSize size, double* norm )) \ 328 IPCVAPI_EX( CvStatus, icvNormDiff_L1_##flavor##_C1R, \ 329 "ippiNormDiff_L1_" #flavor "_C1R", plugin, \ 330 ( const srctype* img1, int imgstep1, \ 331 const srctype* img2, int imgstep2, \ 332 CvSize size, double* norm )) \ 333 IPCVAPI_EX( CvStatus, icvNormDiff_L2_##flavor##_C1R, \ 334 "ippiNormDiff_L2_" #flavor "_C1R", plugin, \ 335 ( const srctype* img1, int imgstep1, \ 336 const srctype* img2, int imgstep2, \ 337 CvSize size, double* norm )) 338 339 #define IPCV_DEF_NORM_HINT_C1( flavor, srctype ) \ 340 IPCVAPI_EX( CvStatus, icvNorm_Inf_##flavor##_C1R, \ 341 "ippiNorm_Inf_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 342 ( const srctype* img, int imgstep, \ 343 CvSize size, double* norm )) \ 344 IPCVAPI_EX( CvStatus, icvNorm_L1_##flavor##_C1R, \ 345 "ippiNorm_L1_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 346 ( const srctype* img, int imgstep, \ 347 CvSize size, double* norm, CvHintAlgorithm )) \ 348 IPCVAPI_EX( CvStatus, icvNorm_L2_##flavor##_C1R, \ 349 "ippiNorm_L2_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 350 ( const srctype* img, int imgstep, \ 351 CvSize size, double* norm, CvHintAlgorithm )) \ 352 IPCVAPI_EX( CvStatus, icvNormDiff_Inf_##flavor##_C1R, \ 353 "ippiNormDiff_Inf_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 354 ( const srctype* img1, int imgstep1, \ 355 const srctype* img2, int imgstep2, \ 356 CvSize size, double* norm )) \ 357 IPCVAPI_EX( CvStatus, icvNormDiff_L1_##flavor##_C1R, \ 358 "ippiNormDiff_L1_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 359 ( const srctype* img1, int imgstep1, \ 360 const srctype* img2, int imgstep2, \ 361 CvSize size, double* norm, CvHintAlgorithm )) \ 362 IPCVAPI_EX( CvStatus, icvNormDiff_L2_##flavor##_C1R, \ 363 "ippiNormDiff_L2_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 364 ( const srctype* img1, int imgstep1, \ 365 const srctype* img2, int imgstep2, \ 366 CvSize size, double* norm, CvHintAlgorithm )) 367 368 #define IPCV_DEF_NORM_MASK_C1( flavor, srctype, plugin ) \ 369 IPCVAPI_EX( CvStatus, icvNorm_Inf_##flavor##_C1MR, \ 370 "ippiNorm_Inf_" #flavor "_C1MR", plugin, \ 371 ( const srctype* img, int imgstep, \ 372 const uchar* mask, int maskstep, \ 373 CvSize size, double* norm )) \ 374 IPCVAPI_EX( CvStatus, icvNorm_L1_##flavor##_C1MR, \ 375 "ippiNorm_L1_" #flavor "_C1MR", plugin, \ 376 ( const srctype* img, int imgstep, \ 377 const uchar* mask, int maskstep, \ 378 CvSize size, double* norm )) \ 379 IPCVAPI_EX( CvStatus, icvNorm_L2_##flavor##_C1MR, \ 380 "ippiNorm_L2_" #flavor "_C1MR", plugin, \ 381 ( const srctype* img, int imgstep, \ 382 const uchar* mask, int maskstep, \ 383 CvSize size, double* norm )) \ 384 IPCVAPI_EX( CvStatus, icvNormDiff_Inf_##flavor##_C1MR, \ 385 "ippiNormDiff_Inf_" #flavor "_C1MR", plugin, \ 386 ( const srctype* img1, int imgstep1, \ 387 const srctype* img2, int imgstep2, \ 388 const uchar* mask, int maskstep, \ 389 CvSize size, double* norm )) \ 390 IPCVAPI_EX( CvStatus, icvNormDiff_L1_##flavor##_C1MR, \ 391 "ippiNormDiff_L1_" #flavor "_C1MR", plugin, \ 392 ( const srctype* img1, int imgstep1, \ 393 const srctype* img2, int imgstep2, \ 394 const uchar* mask, int maskstep, \ 395 CvSize size, double* norm )) \ 396 IPCVAPI_EX( CvStatus, icvNormDiff_L2_##flavor##_C1MR, \ 397 "ippiNormDiff_L2_" #flavor "_C1MR", plugin, \ 398 ( const srctype* img1, int imgstep1, \ 399 const srctype* img2, int imgstep2, \ 400 const uchar* mask, int maskstep, \ 401 CvSize size, double* norm )) 402 403 IPCV_DEF_NORM_NOHINT_C1( 8u, uchar, CV_PLUGINS1(CV_PLUGIN_IPPI) ) 404 IPCV_DEF_NORM_MASK_C1( 8u, uchar, CV_PLUGINS1(CV_PLUGIN_IPPCV) ) 405 406 IPCV_DEF_NORM_NOHINT_C1( 16u, ushort, 0 ) 407 IPCV_DEF_NORM_MASK_C1( 16u, ushort, 0 ) 408 409 IPCV_DEF_NORM_NOHINT_C1( 16s, short, CV_PLUGINS1(CV_PLUGIN_IPPI) ) 410 IPCV_DEF_NORM_MASK_C1( 16s, short, CV_PLUGINS1(CV_PLUGIN_IPPCV) ) 411 412 IPCV_DEF_NORM_NOHINT_C1( 32s, int, 0 ) 413 IPCV_DEF_NORM_MASK_C1( 32s, int, 0 ) 414 415 IPCV_DEF_NORM_HINT_C1( 32f, float ) 416 IPCV_DEF_NORM_MASK_C1( 32f, float, CV_PLUGINS1(CV_PLUGIN_IPPCV) ) 417 418 IPCV_DEF_NORM_NOHINT_C1( 64f, double, 0 ) 419 IPCV_DEF_NORM_MASK_C1( 64f, double, 0 ) 420 421 #undef IPCV_DEF_NORM_HONINT_C1 422 #undef IPCV_DEF_NORM_HINT_C1 423 #undef IPCV_DEF_NORM_MASK_C1 424 425 426 ////////////////////////////////////// AbsDiff /////////////////////////////////////////// 427 428 #define IPCV_ABS_DIFF( flavor, arrtype ) \ 429 IPCVAPI_EX( CvStatus, icvAbsDiff_##flavor##_C1R, \ 430 "ippiAbsDiff_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPCV),\ 431 ( const arrtype* src1, int srcstep1, \ 432 const arrtype* src2, int srcstep2, \ 433 arrtype* dst, int dststep, CvSize size )) 434 435 IPCV_ABS_DIFF( 8u, uchar ) 436 IPCV_ABS_DIFF( 16u, ushort ) 437 IPCV_ABS_DIFF( 16s, short ) 438 IPCV_ABS_DIFF( 32s, int ) 439 IPCV_ABS_DIFF( 32f, float ) 440 IPCV_ABS_DIFF( 64f, double ) 441 442 #undef IPCV_ABS_DIFF 443 444 ////////////////////////////// Comparisons ////////////////////////////////////////// 445 446 #define IPCV_CMP( arrtype, flavor ) \ 447 IPCVAPI_EX( CvStatus, icvCompare_##flavor##_C1R, \ 448 "ippiCompare_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 449 ( const arrtype* src1, int srcstep1, const arrtype* src2, int srcstep2, \ 450 arrtype* dst, int dststep, CvSize size, int cmp_op )) \ 451 IPCVAPI_EX( CvStatus, icvCompareC_##flavor##_C1R, \ 452 "ippiCompareC_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 453 ( const arrtype* src1, int srcstep1, arrtype scalar, \ 454 arrtype* dst, int dststep, CvSize size, int cmp_op )) \ 455 IPCVAPI_EX( CvStatus, icvThreshold_GT_##flavor##_C1R, \ 456 "ippiThreshold_GT_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 457 ( const arrtype* pSrc, int srcstep, arrtype* pDst, int dststep, \ 458 CvSize size, arrtype threshold )) \ 459 IPCVAPI_EX( CvStatus, icvThreshold_LT_##flavor##_C1R, \ 460 "ippiThreshold_LT_" #flavor "_C1R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 461 ( const arrtype* pSrc, int srcstep, arrtype* pDst, int dststep, \ 462 CvSize size, arrtype threshold )) 463 IPCV_CMP( uchar, 8u ) 464 IPCV_CMP( short, 16s ) 465 IPCV_CMP( float, 32f ) 466 #undef IPCV_CMP 467 468 /****************************************************************************************\ 469 * Utilities * 470 \****************************************************************************************/ 471 472 ////////////////////////////// Copy Pixel <-> Plane ///////////////////////////////// 473 474 #define IPCV_PIX_PLANE( flavor, arrtype ) \ 475 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_C2P2R, \ 476 "ippiCopy_" #flavor "_C2P2R", 0/*CV_PLUGINS1(CV_PLUGIN_IPPI)*/, \ 477 ( const arrtype* src, int srcstep, arrtype** dst, int dststep, CvSize size )) \ 478 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_C3P3R, \ 479 "ippiCopy_" #flavor "_C3P3R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 480 ( const arrtype* src, int srcstep, arrtype** dst, int dststep, CvSize size )) \ 481 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_C4P4R, \ 482 "ippiCopy_" #flavor "_C4P4R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 483 ( const arrtype* src, int srcstep, arrtype** dst, int dststep, CvSize size )) \ 484 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_CnC1CR, \ 485 "ippiCopy_" #flavor "_CnC1CR", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 486 ( const arrtype* src, int srcstep, arrtype* dst, int dststep, \ 487 CvSize size, int cn, int coi )) \ 488 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_C1CnCR, \ 489 "ippiCopy_" #flavor "_CnC1CR", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, \ 490 ( const arrtype* src, int srcstep, arrtype* dst, int dststep, \ 491 CvSize size, int cn, int coi )) \ 492 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_P2C2R, \ 493 "ippiCopy_" #flavor "_P2C2R", 0/*CV_PLUGINS1(CV_PLUGIN_IPPI)*/, \ 494 ( const arrtype** src, int srcstep, arrtype* dst, int dststep, CvSize size )) \ 495 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_P3C3R, \ 496 "ippiCopy_" #flavor "_P3C3R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 497 ( const arrtype** src, int srcstep, arrtype* dst, int dststep, CvSize size )) \ 498 IPCVAPI_EX( CvStatus, icvCopy_##flavor##_P4C4R, \ 499 "ippiCopy_" #flavor "_P4C4R", CV_PLUGINS1(CV_PLUGIN_IPPI), \ 500 ( const arrtype** src, int srcstep, arrtype* dst, int dststep, CvSize size )) 501 502 IPCV_PIX_PLANE( 8u, uchar ) 503 IPCV_PIX_PLANE( 16s, ushort ) 504 IPCV_PIX_PLANE( 32f, int ) 505 IPCV_PIX_PLANE( 64f, int64 ) 506 507 #undef IPCV_PIX_PLANE 508 509 /****************************************************************************************/ 510 /* Math routines and RNGs */ 511 /****************************************************************************************/ 512 513 IPCVAPI_EX( CvStatus, icvInvSqrt_32f, "ippsInvSqrt_32f_A21", 514 CV_PLUGINS1(CV_PLUGIN_IPPVM), 515 ( const float* src, float* dst, int len )) 516 IPCVAPI_EX( CvStatus, icvSqrt_32f, "ippsSqrt_32f_A21, ippsSqrt_32f", 517 CV_PLUGINS2(CV_PLUGIN_IPPVM,CV_PLUGIN_IPPS), 518 ( const float* src, float* dst, int len )) 519 IPCVAPI_EX( CvStatus, icvInvSqrt_64f, "ippsInvSqrt_64f_A50", 520 CV_PLUGINS1(CV_PLUGIN_IPPVM), 521 ( const double* src, double* dst, int len )) 522 IPCVAPI_EX( CvStatus, icvSqrt_64f, "ippsSqrt_64f_A50, ippsSqrt_64f", 523 CV_PLUGINS2(CV_PLUGIN_IPPVM,CV_PLUGIN_IPPS), 524 ( const double* src, double* dst, int len )) 525 526 IPCVAPI_EX( CvStatus, icvLog_32f, "ippsLn_32f_A21, ippsLn_32f", 527 CV_PLUGINS2(CV_PLUGIN_IPPVM,CV_PLUGIN_IPPS), 528 ( const float *x, float *y, int n ) ) 529 IPCVAPI_EX( CvStatus, icvLog_64f, "ippsLn_64f_A50, ippsLn_64f", 530 CV_PLUGINS2(CV_PLUGIN_IPPVM,CV_PLUGIN_IPPS), 531 ( const double *x, double *y, int n ) ) 532 IPCVAPI_EX( CvStatus, icvExp_32f, "ippsExp_32f_A21, ippsExp_32f", 533 CV_PLUGINS2(CV_PLUGIN_IPPVM,CV_PLUGIN_IPPS), 534 ( const float *x, float *y, int n ) ) 535 IPCVAPI_EX( CvStatus, icvExp_64f, "ippsExp_64f_A50, ippsExp_64f", 536 CV_PLUGINS2(CV_PLUGIN_IPPVM,CV_PLUGIN_IPPS), 537 ( const double *x, double *y, int n ) ) 538 IPCVAPI_EX( CvStatus, icvFastArctan_32f, "ippibFastArctan_32f", 539 CV_PLUGINS1(CV_PLUGIN_IPPCV), 540 ( const float* y, const float* x, float* angle, int len )) 541 542 /****************************************************************************************/ 543 /* Error handling functions */ 544 /****************************************************************************************/ 545 546 IPCVAPI_EX( CvStatus, icvCheckArray_32f_C1R, 547 "ippiCheckArray_32f_C1R", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, 548 ( const float* src, int srcstep, 549 CvSize size, int flags, 550 double min_val, double max_val )) 551 552 IPCVAPI_EX( CvStatus, icvCheckArray_64f_C1R, 553 "ippiCheckArray_64f_C1R", 0/*CV_PLUGINS1(CV_PLUGIN_OPTCV)*/, 554 ( const double* src, int srcstep, 555 CvSize size, int flags, 556 double min_val, double max_val )) 557 558 /****************************************************************************************/ 559 /* Affine transformations of matrix/image elements */ 560 /****************************************************************************************/ 561 562 #define IPCV_TRANSFORM( suffix, ipp_suffix, cn ) \ 563 IPCVAPI_EX( CvStatus, icvColorTwist##suffix##_C##cn##R, \ 564 "ippiColorTwist" #ipp_suffix "_C" #cn \ 565 "R,ippiColorTwist" #ipp_suffix "_C" #cn "R", \ 566 CV_PLUGINS2(CV_PLUGIN_IPPI, CV_PLUGIN_IPPCC), \ 567 ( const void* src, int srcstep, void* dst, int dststep, \ 568 CvSize roisize, const float* twist_matrix )) 569 570 IPCV_TRANSFORM( _8u, 32f_8u, 3 ) 571 IPCV_TRANSFORM( _16u, 32f_16u, 3 ) 572 IPCV_TRANSFORM( _16s, 32f_16s, 3 ) 573 IPCV_TRANSFORM( _32f, _32f, 3 ) 574 IPCV_TRANSFORM( _32f, _32f, 4 ) 575 576 #undef IPCV_TRANSFORM 577 578 #define IPCV_TRANSFORM_N1( suffix ) \ 579 IPCVAPI_EX( CvStatus, icvColorToGray##suffix, \ 580 "ippiColorToGray" #suffix ",ippiColorToGray" #suffix, \ 581 CV_PLUGINS2(CV_PLUGIN_IPPI,CV_PLUGIN_IPPCC), \ 582 ( const void* src, int srcstep, void* dst, int dststep, \ 583 CvSize roisize, const float* coeffs )) 584 585 IPCV_TRANSFORM_N1( _8u_C3C1R ) 586 IPCV_TRANSFORM_N1( _16u_C3C1R ) 587 IPCV_TRANSFORM_N1( _16s_C3C1R ) 588 IPCV_TRANSFORM_N1( _32f_C3C1R ) 589 IPCV_TRANSFORM_N1( _8u_AC4C1R ) 590 IPCV_TRANSFORM_N1( _16u_AC4C1R ) 591 IPCV_TRANSFORM_N1( _16s_AC4C1R ) 592 IPCV_TRANSFORM_N1( _32f_AC4C1R ) 593 594 #undef IPCV_TRANSFORM_N1 595 596 /****************************************************************************************/ 597 /* Matrix routines from BLAS/LAPACK compatible libraries */ 598 /****************************************************************************************/ 599 600 IPCVAPI_C_EX( void, icvBLAS_GEMM_32f, "sgemm, mkl_sgemm", CV_PLUGINS2(CV_PLUGIN_MKL,CV_PLUGIN_MKL), 601 (const char *transa, const char *transb, int *n, int *m, int *k, 602 const void *alpha, const void *a, int *lda, const void *b, int *ldb, 603 const void *beta, void *c, int *ldc )) 604 605 IPCVAPI_C_EX( void, icvBLAS_GEMM_64f, "dgemm, mkl_dgemm", CV_PLUGINS2(CV_PLUGIN_MKL,CV_PLUGIN_MKL), 606 (const char *transa, const char *transb, int *n, int *m, int *k, 607 const void *alpha, const void *a, int *lda, const void *b, int *ldb, 608 const void *beta, void *c, int *ldc )) 609 610 IPCVAPI_C_EX( void, icvBLAS_GEMM_32fc, "cgemm, mkl_cgemm", CV_PLUGINS2(CV_PLUGIN_MKL,CV_PLUGIN_MKL), 611 (const char *transa, const char *transb, int *n, int *m, int *k, 612 const void *alpha, const void *a, int *lda, const void *b, int *ldb, 613 const void *beta, void *c, int *ldc )) 614 615 IPCVAPI_C_EX( void, icvBLAS_GEMM_64fc, "zgemm, mkl_zgemm", CV_PLUGINS2(CV_PLUGIN_MKL,CV_PLUGIN_MKL), 616 (const char *transa, const char *transb, int *n, int *m, int *k, 617 const void *alpha, const void *a, int *lda, const void *b, int *ldb, 618 const void *beta, void *c, int *ldc )) 619 620 621 #define IPCV_DFT( init_flavor, fwd_flavor, inv_flavor ) \ 622 IPCVAPI_EX( CvStatus, icvDFTInitAlloc_##init_flavor, "ippsDFTInitAlloc_" #init_flavor, \ 623 CV_PLUGINS1(CV_PLUGIN_IPPS), ( void**, int, int, CvHintAlgorithm )) \ 624 \ 625 IPCVAPI_EX( CvStatus, icvDFTFree_##init_flavor, "ippsDFTFree_" #init_flavor, \ 626 CV_PLUGINS1(CV_PLUGIN_IPPS), ( void* )) \ 627 \ 628 IPCVAPI_EX( CvStatus, icvDFTGetBufSize_##init_flavor, "ippsDFTGetBufSize_" #init_flavor,\ 629 CV_PLUGINS1(CV_PLUGIN_IPPS), ( const void* spec, int* buf_size )) \ 630 \ 631 IPCVAPI_EX( CvStatus, icvDFTFwd_##fwd_flavor, "ippsDFTFwd_" #fwd_flavor, \ 632 CV_PLUGINS1(CV_PLUGIN_IPPS), ( const void* src, void* dst, \ 633 const void* spec, void* buffer )) \ 634 \ 635 IPCVAPI_EX( CvStatus, icvDFTInv_##inv_flavor, "ippsDFTInv_" #inv_flavor, \ 636 CV_PLUGINS1(CV_PLUGIN_IPPS), ( const void* src, void* dst, \ 637 const void* spec, void* buffer )) 638 639 IPCV_DFT( C_32fc, CToC_32fc, CToC_32fc ) 640 IPCV_DFT( R_32f, RToPack_32f, PackToR_32f ) 641 IPCV_DFT( C_64fc, CToC_64fc, CToC_64fc ) 642 IPCV_DFT( R_64f, RToPack_64f, PackToR_64f ) 643 #undef IPCV_DFT 644 645 #endif /*_CXCORE_IPP_H_*/ 646 647