git.maemo.org Git - opencv/blob - cxcore/src/_cxipp.h

   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