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/* The header is mostly for internal use and it is likely to change. 43 It contains some macro definitions that are used in cxcore, cv, cvaux 44 and, probably, other libraries. If you need some of this functionality, 45 the safe way is to copy it into your code and rename the macros. 46*/ 47#ifndef _CXCORE_MISC_H_ 48#define _CXCORE_MISC_H_ 49 50#ifdef HAVE_CONFIG_H 51 #include "cvconfig.h" 52#endif 53 54#include <limits.h> 55#ifdef _OPENMP 56#include "omp.h" 57#endif 58 59/****************************************************************************************\ 60* Compile-time tuning parameters * 61\****************************************************************************************/ 62 63/* maximal size of vector to run matrix operations on it inline (i.e. w/o ipp calls) */ 64#define CV_MAX_INLINE_MAT_OP_SIZE 10 65 66/* maximal linear size of matrix to allocate it on stack. */ 67#define CV_MAX_LOCAL_MAT_SIZE 32 68 69/* maximal size of local memory storage */ 70#define CV_MAX_LOCAL_SIZE \ 71 (CV_MAX_LOCAL_MAT_SIZE*CV_MAX_LOCAL_MAT_SIZE*(int)sizeof(double)) 72 73/* default image row align (in bytes) */ 74#define CV_DEFAULT_IMAGE_ROW_ALIGN 4 75 76/* matrices are continuous by default */ 77#define CV_DEFAULT_MAT_ROW_ALIGN 1 78 79/* maximum size of dynamic memory buffer. 80 cvAlloc reports an error if a larger block is requested. */ 81#define CV_MAX_ALLOC_SIZE (((size_t)1 << (sizeof(size_t)*8-2))) 82 83/* the alignment of all the allocated buffers */ 84#define CV_MALLOC_ALIGN 32 85 86/* default alignment for dynamic data strucutures, resided in storages. */ 87#define CV_STRUCT_ALIGN ((int)sizeof(double)) 88 89/* default storage block size */ 90#define CV_STORAGE_BLOCK_SIZE ((1<<16) - 128) 91 92/* default memory block for sparse array elements */ 93#define CV_SPARSE_MAT_BLOCK (1<<12) 94 95/* initial hash table size */ 96#define CV_SPARSE_HASH_SIZE0 (1<<10) 97 98/* maximal average node_count/hash_size ratio beyond which hash table is resized */ 99#define CV_SPARSE_HASH_RATIO 3 100 101/* max length of strings */ 102#define CV_MAX_STRLEN 1024 103 104/* maximum possible number of threads in parallel implementations */ 105#ifdef _OPENMP 106#define CV_MAX_THREADS 128 107#else 108#define CV_MAX_THREADS 1 109#endif 110 111#if 0 /*def CV_CHECK_FOR_NANS*/ 112 #define CV_CHECK_NANS( arr ) cvCheckArray((arr)) 113#else 114 #define CV_CHECK_NANS( arr ) 115#endif 116 117/****************************************************************************************\ 118* Common declarations * 119\****************************************************************************************/ 120 121/* get alloca declaration */ 122#ifdef __GNUC__ 123 #undef alloca 124 #define alloca __builtin_alloca 125#elif defined WIN32 || defined WIN64 126 #if defined _MSC_VER || defined __BORLANDC__ 127 #include <malloc.h> 128 #endif 129#elif defined HAVE_ALLOCA_H 130 #include <alloca.h> 131#elif defined HAVE_ALLOCA 132 #include <stdlib.h> 133#else 134 #error 135#endif 136 137/* ! DO NOT make it an inline function */ 138#define cvStackAlloc(size) cvAlignPtr( alloca((size) + CV_MALLOC_ALIGN), CV_MALLOC_ALIGN ) 139 140#if defined _MSC_VER || defined __BORLANDC__ 141 #define CV_BIG_INT(n) n##I64 142 #define CV_BIG_UINT(n) n##UI64 143#else 144 #define CV_BIG_INT(n) n##LL 145 #define CV_BIG_UINT(n) n##ULL 146#endif 147 148#define CV_IMPL CV_EXTERN_C 149 150#define CV_DBG_BREAK() { volatile int* crashMe = 0; *crashMe = 0; } 151 152/* default step, set in case of continuous data 153 to work around checks for valid step in some ipp functions */ 154#define CV_STUB_STEP (1 << 30) 155 156#define CV_SIZEOF_FLOAT ((int)sizeof(float)) 157#define CV_SIZEOF_SHORT ((int)sizeof(short)) 158 159#define CV_ORIGIN_TL 0 160#define CV_ORIGIN_BL 1 161 162/* IEEE754 constants and macros */ 163#define CV_POS_INF 0x7f800000 164#define CV_NEG_INF 0x807fffff /* CV_TOGGLE_FLT(0xff800000) */ 165#define CV_1F 0x3f800000 166#define CV_TOGGLE_FLT(x) ((x)^((int)(x) < 0 ? 0x7fffffff : 0)) 167#define CV_TOGGLE_DBL(x) \ 168 ((x)^((int64)(x) < 0 ? CV_BIG_INT(0x7fffffffffffffff) : 0)) 169 170#define CV_NOP(a) (a) 171#define CV_ADD(a, b) ((a) + (b)) 172#define CV_SUB(a, b) ((a) - (b)) 173#define CV_MUL(a, b) ((a) * (b)) 174#define CV_AND(a, b) ((a) & (b)) 175#define CV_OR(a, b) ((a) | (b)) 176#define CV_XOR(a, b) ((a) ^ (b)) 177#define CV_ANDN(a, b) (~(a) & (b)) 178#define CV_ORN(a, b) (~(a) | (b)) 179#define CV_SQR(a) ((a) * (a)) 180 181#define CV_LT(a, b) ((a) < (b)) 182#define CV_LE(a, b) ((a) <= (b)) 183#define CV_EQ(a, b) ((a) == (b)) 184#define CV_NE(a, b) ((a) != (b)) 185#define CV_GT(a, b) ((a) > (b)) 186#define CV_GE(a, b) ((a) >= (b)) 187 188#define CV_NONZERO(a) ((a) != 0) 189#define CV_NONZERO_FLT(a) (((a)+(a)) != 0) 190 191/* general-purpose saturation macros */ 192#define CV_CAST_8U(t) (uchar)(!((t) & ~255) ? (t) : (t) > 0 ? 255 : 0) 193#define CV_CAST_8S(t) (schar)(!(((t)+128) & ~255) ? (t) : (t) > 0 ? 127 : -128) 194#define CV_CAST_16U(t) (ushort)(!((t) & ~65535) ? (t) : (t) > 0 ? 65535 : 0) 195#define CV_CAST_16S(t) (short)(!(((t)+32768) & ~65535) ? (t) : (t) > 0 ? 32767 : -32768) 196#define CV_CAST_32S(t) (int)(t) 197#define CV_CAST_64S(t) (int64)(t) 198#define CV_CAST_32F(t) (float)(t) 199#define CV_CAST_64F(t) (double)(t) 200 201#define CV_PASTE2(a,b) a##b 202#define CV_PASTE(a,b) CV_PASTE2(a,b) 203 204#define CV_EMPTY 205#define CV_MAKE_STR(a) #a 206 207#define CV_DEFINE_MASK \ 208 float maskTab[2]; maskTab[0] = 0.f; maskTab[1] = 1.f; 209#define CV_ANDMASK( m, x ) ((x) & (((m) == 0) - 1)) 210 211/* (x) * ((m) == 1 ? 1.f : (m) == 0 ? 0.f : <ERR> */ 212#define CV_MULMASK( m, x ) (maskTab[(m) != 0]*(x)) 213 214/* (x) * ((m) == -1 ? 1.f : (m) == 0 ? 0.f : <ERR> */ 215#define CV_MULMASK1( m, x ) (maskTab[(m)+1]*(x)) 216 217#define CV_ZERO_OBJ(x) memset((x), 0, sizeof(*(x))) 218 219#define CV_DIM(static_array) ((int)(sizeof(static_array)/sizeof((static_array)[0]))) 220 221#define CV_UN_ENTRY_C1(worktype) \ 222 worktype s0 = scalar[0] 223 224#define CV_UN_ENTRY_C2(worktype) \ 225 worktype s0 = scalar[0], s1 = scalar[1] 226 227#define CV_UN_ENTRY_C3(worktype) \ 228 worktype s0 = scalar[0], s1 = scalar[1], s2 = scalar[2] 229 230#define CV_UN_ENTRY_C4(worktype) \ 231 worktype s0 = scalar[0], s1 = scalar[1], s2 = scalar[2], s3 = scalar[3] 232 233#define cvUnsupportedFormat "Unsupported format" 234 235CV_INLINE void* cvAlignPtr( const void* ptr, int align=32 ) 236{ 237 assert( (align & (align-1)) == 0 ); 238 return (void*)( ((size_t)ptr + align - 1) & ~(size_t)(align-1) ); 239} 240 241CV_INLINE int cvAlign( int size, int align ) 242{ 243 assert( (align & (align-1)) == 0 && size < INT_MAX ); 244 return (size + align - 1) & -align; 245} 246 247CV_INLINE CvSize cvGetMatSize( const CvMat* mat ) 248{ 249 CvSize size = { mat->width, mat->height }; 250 return size; 251} 252 253#define CV_DESCALE(x,n) (((x) + (1 << ((n)-1))) >> (n)) 254#define CV_FLT_TO_FIX(x,n) cvRound((x)*(1<<(n))) 255 256#if 0 257/* This is a small engine for performing fast division of multiple numbers 258 by the same constant. Most compilers do it too if they know the divisor value 259 at compile-time. The algorithm was taken from Agner Fog's optimization guide 260 at http://www.agner.org/assem */ 261typedef struct CvFastDiv 262{ 263 unsigned delta, scale, divisor; 264} 265CvFastDiv; 266 267#define CV_FAST_DIV_SHIFT 32 268 269CV_INLINE CvFastDiv cvFastDiv( int divisor ) 270{ 271 CvFastDiv fastdiv; 272 273 assert( divisor >= 1 ); 274 uint64 temp = ((uint64)1 << CV_FAST_DIV_SHIFT)/divisor; 275 276 fastdiv.divisor = divisor; 277 fastdiv.delta = (unsigned)(((temp & 1) ^ 1) + divisor - 1); 278 fastdiv.scale = (unsigned)((temp + 1) >> 1); 279 280 return fastdiv; 281} 282 283#define CV_FAST_DIV( x, fastdiv ) \ 284 ((int)(((int64)((x)*2 + (int)(fastdiv).delta))*(int)(fastdiv).scale>>CV_FAST_DIV_SHIFT)) 285 286#define CV_FAST_UDIV( x, fastdiv ) \ 287 ((int)(((uint64)((x)*2 + (fastdiv).delta))*(fastdiv).scale>>CV_FAST_DIV_SHIFT)) 288#endif 289 290#define CV_MEMCPY_CHAR( dst, src, len ) \ 291{ \ 292 size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \ 293 char* _icv_memcpy_dst_ = (char*)(dst); \ 294 const char* _icv_memcpy_src_ = (const char*)(src); \ 295 \ 296 for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++ ) \ 297 _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_]; \ 298} 299 300 301#define CV_MEMCPY_INT( dst, src, len ) \ 302{ \ 303 size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \ 304 int* _icv_memcpy_dst_ = (int*)(dst); \ 305 const int* _icv_memcpy_src_ = (const int*)(src); \ 306 assert( ((size_t)_icv_memcpy_src_&(sizeof(int)-1)) == 0 && \ 307 ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 ); \ 308 \ 309 for(_icv_memcpy_i_=0;_icv_memcpy_i_<_icv_memcpy_len_;_icv_memcpy_i_++) \ 310 _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_]; \ 311} 312 313 314#define CV_MEMCPY_AUTO( dst, src, len ) \ 315{ \ 316 size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \ 317 char* _icv_memcpy_dst_ = (char*)(dst); \ 318 const char* _icv_memcpy_src_ = (const char*)(src); \ 319 if( (_icv_memcpy_len_ & (sizeof(int)-1)) == 0 ) \ 320 { \ 321 assert( ((size_t)_icv_memcpy_src_&(sizeof(int)-1)) == 0 && \ 322 ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 ); \ 323 for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; \ 324 _icv_memcpy_i_+=sizeof(int) ) \ 325 { \ 326 *(int*)(_icv_memcpy_dst_+_icv_memcpy_i_) = \ 327 *(const int*)(_icv_memcpy_src_+_icv_memcpy_i_); \ 328 } \ 329 } \ 330 else \ 331 { \ 332 for(_icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++)\ 333 _icv_memcpy_dst_[_icv_memcpy_i_] = _icv_memcpy_src_[_icv_memcpy_i_]; \ 334 } \ 335} 336 337 338#define CV_ZERO_CHAR( dst, len ) \ 339{ \ 340 size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \ 341 char* _icv_memcpy_dst_ = (char*)(dst); \ 342 \ 343 for( _icv_memcpy_i_ = 0; _icv_memcpy_i_ < _icv_memcpy_len_; _icv_memcpy_i_++ ) \ 344 _icv_memcpy_dst_[_icv_memcpy_i_] = '\0'; \ 345} 346 347 348#define CV_ZERO_INT( dst, len ) \ 349{ \ 350 size_t _icv_memcpy_i_, _icv_memcpy_len_ = (len); \ 351 int* _icv_memcpy_dst_ = (int*)(dst); \ 352 assert( ((size_t)_icv_memcpy_dst_&(sizeof(int)-1)) == 0 ); \ 353 \ 354 for(_icv_memcpy_i_=0;_icv_memcpy_i_<_icv_memcpy_len_;_icv_memcpy_i_++) \ 355 _icv_memcpy_dst_[_icv_memcpy_i_] = 0; \ 356} 357 358 359/****************************************************************************************\ 360 361 Generic implementation of QuickSort algorithm. 362 ---------------------------------------------- 363 Using this macro user can declare customized sort function that can be much faster 364 than built-in qsort function because of lower overhead on elements 365 comparison and exchange. The macro takes less_than (or LT) argument - a macro or function 366 that takes 2 arguments returns non-zero if the first argument should be before the second 367 one in the sorted sequence and zero otherwise. 368 369 Example: 370 371 Suppose that the task is to sort points by ascending of y coordinates and if 372 y's are equal x's should ascend. 373 374 The code is: 375 ------------------------------------------------------------------------------ 376 #define cmp_pts( pt1, pt2 ) \ 377 ((pt1).y < (pt2).y || ((pt1).y < (pt2).y && (pt1).x < (pt2).x)) 378 379 [static] CV_IMPLEMENT_QSORT( icvSortPoints, CvPoint, cmp_pts ) 380 ------------------------------------------------------------------------------ 381 382 After that the function "void icvSortPoints( CvPoint* array, size_t total, int aux );" 383 is available to user. 384 385 aux is an additional parameter, which can be used when comparing elements. 386 The current implementation was derived from *BSD system qsort(): 387 388 * Copyright (c) 1992, 1993 389 * The Regents of the University of California. All rights reserved. 390 * 391 * Redistribution and use in source and binary forms, with or without 392 * modification, are permitted provided that the following conditions 393 * are met: 394 * 1. Redistributions of source code must retain the above copyright 395 * notice, this list of conditions and the following disclaimer. 396 * 2. Redistributions in binary form must reproduce the above copyright 397 * notice, this list of conditions and the following disclaimer in the 398 * documentation and/or other materials provided with the distribution. 399 * 3. All advertising materials mentioning features or use of this software 400 * must display the following acknowledgement: 401 * This product includes software developed by the University of 402 * California, Berkeley and its contributors. 403 * 4. Neither the name of the University nor the names of its contributors 404 * may be used to endorse or promote products derived from this software 405 * without specific prior written permission. 406 * 407 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 408 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 409 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 410 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 411 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 412 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 413 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 414 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 415 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 416 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 417 * SUCH DAMAGE. 418 419\****************************************************************************************/ 420 421#define CV_IMPLEMENT_QSORT_EX( func_name, T, LT, user_data_type ) \ 422void func_name( T *array, size_t total, user_data_type aux ) \ 423{ \ 424 int isort_thresh = 7; \ 425 T t; \ 426 int sp = 0; \ 427 \ 428 struct \ 429 { \ 430 T *lb; \ 431 T *ub; \ 432 } \ 433 stack[48]; \ 434 \ 435 aux = aux; \ 436 \ 437 if( total <= 1 ) \ 438 return; \ 439 \ 440 stack[0].lb = array; \ 441 stack[0].ub = array + (total - 1); \ 442 \ 443 while( sp >= 0 ) \ 444 { \ 445 T* left = stack[sp].lb; \ 446 T* right = stack[sp--].ub; \ 447 \ 448 for(;;) \ 449 { \ 450 int i, n = (int)(right - left) + 1, m; \ 451 T* ptr; \ 452 T* ptr2; \ 453 \ 454 if( n <= isort_thresh ) \ 455 { \ 456 insert_sort: \ 457 for( ptr = left + 1; ptr <= right; ptr++ ) \ 458 { \ 459 for( ptr2 = ptr; ptr2 > left && LT(ptr2[0],ptr2[-1]); ptr2--) \ 460 CV_SWAP( ptr2[0], ptr2[-1], t ); \ 461 } \ 462 break; \ 463 } \ 464 else \ 465 { \ 466 T* left0; \ 467 T* left1; \ 468 T* right0; \ 469 T* right1; \ 470 T* pivot; \ 471 T* a; \ 472 T* b; \ 473 T* c; \ 474 int swap_cnt = 0; \ 475 \ 476 left0 = left; \ 477 right0 = right; \ 478 pivot = left + (n/2); \ 479 \ 480 if( n > 40 ) \ 481 { \ 482 int d = n / 8; \ 483 a = left, b = left + d, c = left + 2*d; \ 484 left = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \ 485 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \ 486 \ 487 a = pivot - d, b = pivot, c = pivot + d; \ 488 pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \ 489 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \ 490 \ 491 a = right - 2*d, b = right - d, c = right; \ 492 right = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \ 493 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \ 494 } \ 495 \ 496 a = left, b = pivot, c = right; \ 497 pivot = LT(*a, *b) ? (LT(*b, *c) ? b : (LT(*a, *c) ? c : a)) \ 498 : (LT(*c, *b) ? b : (LT(*a, *c) ? a : c)); \ 499 if( pivot != left0 ) \ 500 { \ 501 CV_SWAP( *pivot, *left0, t ); \ 502 pivot = left0; \ 503 } \ 504 left = left1 = left0 + 1; \ 505 right = right1 = right0; \ 506 \ 507 for(;;) \ 508 { \ 509 while( left <= right && !LT(*pivot, *left) ) \ 510 { \ 511 if( !LT(*left, *pivot) ) \ 512 { \ 513 if( left > left1 ) \ 514 CV_SWAP( *left1, *left, t ); \ 515 swap_cnt = 1; \ 516 left1++; \ 517 } \ 518 left++; \ 519 } \ 520 \ 521 while( left <= right && !LT(*right, *pivot) ) \ 522 { \ 523 if( !LT(*pivot, *right) ) \ 524 { \ 525 if( right < right1 ) \ 526 CV_SWAP( *right1, *right, t ); \ 527 swap_cnt = 1; \ 528 right1--; \ 529 } \ 530 right--; \ 531 } \ 532 \ 533 if( left > right ) \ 534 break; \ 535 CV_SWAP( *left, *right, t ); \ 536 swap_cnt = 1; \ 537 left++; \ 538 right--; \ 539 } \ 540 \ 541 if( swap_cnt == 0 ) \ 542 { \ 543 left = left0, right = right0; \ 544 goto insert_sort; \ 545 } \ 546 \ 547 n = MIN( (int)(left1 - left0), (int)(left - left1) ); \ 548 for( i = 0; i < n; i++ ) \ 549 CV_SWAP( left0[i], left[i-n], t ); \ 550 \ 551 n = MIN( (int)(right0 - right1), (int)(right1 - right) ); \ 552 for( i = 0; i < n; i++ ) \ 553 CV_SWAP( left[i], right0[i-n+1], t ); \ 554 n = (int)(left - left1); \ 555 m = (int)(right1 - right); \ 556 if( n > 1 ) \ 557 { \ 558 if( m > 1 ) \ 559 { \ 560 if( n > m ) \ 561 { \ 562 stack[++sp].lb = left0; \ 563 stack[sp].ub = left0 + n - 1; \ 564 left = right0 - m + 1, right = right0; \ 565 } \ 566 else \ 567 { \ 568 stack[++sp].lb = right0 - m + 1; \ 569 stack[sp].ub = right0; \ 570 left = left0, right = left0 + n - 1; \ 571 } \ 572 } \ 573 else \ 574 left = left0, right = left0 + n - 1; \ 575 } \ 576 else if( m > 1 ) \ 577 left = right0 - m + 1, right = right0; \ 578 else \ 579 break; \ 580 } \ 581 } \ 582 } \ 583} 584 585#define CV_IMPLEMENT_QSORT( func_name, T, cmp ) \ 586 CV_IMPLEMENT_QSORT_EX( func_name, T, cmp, int ) 587 588/****************************************************************************************\ 589* Structures and macros for integration with IPP * 590\****************************************************************************************/ 591 592/* IPP-compatible return codes */ 593typedef enum CvStatus 594{ 595 CV_BADMEMBLOCK_ERR = -113, 596 CV_INPLACE_NOT_SUPPORTED_ERR= -112, 597 CV_UNMATCHED_ROI_ERR = -111, 598 CV_NOTFOUND_ERR = -110, 599 CV_BADCONVERGENCE_ERR = -109, 600 601 CV_BADDEPTH_ERR = -107, 602 CV_BADROI_ERR = -106, 603 CV_BADHEADER_ERR = -105, 604 CV_UNMATCHED_FORMATS_ERR = -104, 605 CV_UNSUPPORTED_COI_ERR = -103, 606 CV_UNSUPPORTED_CHANNELS_ERR = -102, 607 CV_UNSUPPORTED_DEPTH_ERR = -101, 608 CV_UNSUPPORTED_FORMAT_ERR = -100, 609 610 CV_BADARG_ERR = -49, //ipp comp 611 CV_NOTDEFINED_ERR = -48, //ipp comp 612 613 CV_BADCHANNELS_ERR = -47, //ipp comp 614 CV_BADRANGE_ERR = -44, //ipp comp 615 CV_BADSTEP_ERR = -29, //ipp comp 616 617 CV_BADFLAG_ERR = -12, 618 CV_DIV_BY_ZERO_ERR = -11, //ipp comp 619 CV_BADCOEF_ERR = -10, 620 621 CV_BADFACTOR_ERR = -7, 622 CV_BADPOINT_ERR = -6, 623 CV_BADSCALE_ERR = -4, 624 CV_OUTOFMEM_ERR = -3, 625 CV_NULLPTR_ERR = -2, 626 CV_BADSIZE_ERR = -1, 627 CV_NO_ERR = 0, 628 CV_OK = CV_NO_ERR 629} 630CvStatus; 631 632#define CV_ERROR_FROM_STATUS( result ) \ 633 CV_ERROR( cvErrorFromIppStatus( result ), "OpenCV function failed" ) 634 635#define IPPI_CALL( Func ) \ 636{ \ 637 CvStatus ippi_call_result; \ 638 ippi_call_result = Func; \ 639 \ 640 if( ippi_call_result < 0 ) \ 641 CV_ERROR_FROM_STATUS( (ippi_call_result)); \ 642} 643 644#define CV_PLUGIN_NONE 0 645#define CV_PLUGIN_OPTCV 1 /* custom "emerged" ippopencv library */ 646#define CV_PLUGIN_IPPCV 2 /* IPP: computer vision */ 647#define CV_PLUGIN_IPPI 3 /* IPP: image processing */ 648#define CV_PLUGIN_IPPS 4 /* IPP: signal processing */ 649#define CV_PLUGIN_IPPVM 5 /* IPP: vector math functions */ 650#define CV_PLUGIN_IPPCC 6 /* IPP: color space conversion */ 651#define CV_PLUGIN_MKL 8 /* Intel Math Kernel Library */ 652 653#define CV_PLUGIN_MAX 16 654 655#define CV_PLUGINS1(lib1) ((lib1)&15) 656#define CV_PLUGINS2(lib1,lib2) (((lib1)&15)|(((lib2)&15)<<4)) 657#define CV_PLUGINS3(lib1,lib2,lib3) (((lib1)&15)|(((lib2)&15)<<4)|(((lib2)&15)<<8)) 658 659#define CV_NOTHROW throw() 660 661#ifndef IPCVAPI 662#define IPCVAPI(type,declspec,name,args) \ 663 /* function pointer */ \ 664 typedef type (declspec* name##_t) args; \ 665 extern name##_t name##_p; \ 666 type declspec name args; 667#endif 668 669#define IPCVAPI_EX(type,name,ipp_name,ipp_search_modules,args) \ 670 IPCVAPI(type,CV_STDCALL,name,args) 671 672#define IPCVAPI_C_EX(type,name,ipp_name,ipp_search_modules,args)\ 673 IPCVAPI(type,CV_CDECL,name,args) 674 675#ifndef IPCVAPI_IMPL 676#define IPCVAPI_IMPL(type,name,args,arg_names) \ 677 static type CV_STDCALL name##_f args; \ 678 name##_t name##_p = name##_f; \ 679 type CV_STDCALL name args { return name##_p arg_names; } \ 680 static type CV_STDCALL name##_f args 681#endif 682 683/* IPP types' enumeration */ 684typedef enum CvDataType { 685 cv1u, 686 cv8u, cv8s, 687 cv16u, cv16s, cv16sc, 688 cv32u, cv32s, cv32sc, 689 cv32f, cv32fc, 690 cv64u, cv64s, cv64sc, 691 cv64f, cv64fc 692} CvDataType; 693 694typedef enum CvHintAlgorithm { 695 cvAlgHintNone, 696 cvAlgHintFast, 697 cvAlgHintAccurate 698} CvHintAlgorithm; 699 700typedef enum CvCmpOp { 701 cvCmpLess, 702 cvCmpLessEq, 703 cvCmpEq, 704 cvCmpGreaterEq, 705 cvCmpGreater 706} CvCmpOp; 707 708typedef struct CvFuncTable 709{ 710 void* fn_2d[CV_DEPTH_MAX]; 711} 712CvFuncTable; 713 714typedef struct CvBigFuncTable 715{ 716 void* fn_2d[CV_DEPTH_MAX*CV_CN_MAX]; 717} 718CvBigFuncTable; 719 720 721typedef struct CvBtFuncTable 722{ 723 void* fn_2d[33]; 724} 725CvBtFuncTable; 726 727typedef CvStatus (CV_STDCALL *CvFunc2D_1A)(void* arr, int step, CvSize size); 728 729typedef CvStatus (CV_STDCALL *CvFunc2D_1A1P)(void* arr, int step, CvSize size, void* param); 730 731typedef CvStatus (CV_STDCALL *CvFunc2D_1A1P1I)(void* arr, int step, CvSize size, 732 void* param, int flag); 733 734typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A1P)( void* arr, int step, CvSize size, 735 int cn, int coi, void* param ); 736 737typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A1P)( void* arr, int step, CvSize size, 738 int cn, int coi, void* param ); 739 740typedef CvStatus (CV_STDCALL *CvFunc2D_1A2P)( void* arr, int step, CvSize size, 741 void* param1, void* param2 ); 742 743typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A2P)( void* arr, int step, 744 CvSize size, int cn, int coi, 745 void* param1, void* param2 ); 746 747typedef CvStatus (CV_STDCALL *CvFunc2D_1A4P)( void* arr, int step, CvSize size, 748 void* param1, void* param2, 749 void* param3, void* param4 ); 750 751typedef CvStatus (CV_STDCALL *CvFunc2DnC_1A4P)( void* arr, int step, 752 CvSize size, int cn, int coi, 753 void* param1, void* param2, 754 void* param3, void* param4 ); 755 756typedef CvStatus (CV_STDCALL *CvFunc2D_2A)( void* arr0, int step0, 757 void* arr1, int step1, CvSize size ); 758 759typedef CvStatus (CV_STDCALL *CvFunc2D_2A1P)( void* arr0, int step0, 760 void* arr1, int step1, 761 CvSize size, void* param ); 762 763typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A1P)( void* arr0, int step0, 764 void* arr1, int step1, 765 CvSize size, int cn, 766 int coi, void* param ); 767 768typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A1P)( void* arr0, int step0, 769 void* arr1, int step1, 770 CvSize size, int cn, 771 int coi, void* param ); 772 773typedef CvStatus (CV_STDCALL *CvFunc2D_2A2P)( void* arr0, int step0, 774 void* arr1, int step1, CvSize size, 775 void* param1, void* param2 ); 776 777typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A2P)( void* arr0, int step0, 778 void* arr1, int step1, 779 CvSize size, int cn, int coi, 780 void* param1, void* param2 ); 781 782typedef CvStatus (CV_STDCALL *CvFunc2D_2A1P1I)( void* arr0, int step0, 783 void* arr1, int step1, CvSize size, 784 void* param, int flag ); 785 786typedef CvStatus (CV_STDCALL *CvFunc2D_2A4P)( void* arr0, int step0, 787 void* arr1, int step1, CvSize size, 788 void* param1, void* param2, 789 void* param3, void* param4 ); 790 791typedef CvStatus (CV_STDCALL *CvFunc2DnC_2A4P)( void* arr0, int step0, 792 void* arr1, int step1, CvSize size, 793 int cn, int coi, 794 void* param1, void* param2, 795 void* param3, void* param4 ); 796 797typedef CvStatus (CV_STDCALL *CvFunc2D_3A)( void* arr0, int step0, 798 void* arr1, int step1, 799 void* arr2, int step2, CvSize size ); 800 801typedef CvStatus (CV_STDCALL *CvFunc2D_3A1P)( void* arr0, int step0, 802 void* arr1, int step1, 803 void* arr2, int step2, 804 CvSize size, void* param ); 805 806typedef CvStatus (CV_STDCALL *CvFunc2D_3A1I)( void* arr0, int step0, 807 void* arr1, int step1, 808 void* arr2, int step2, 809 CvSize size, int flag ); 810 811typedef CvStatus (CV_STDCALL *CvFunc2DnC_3A1P)( void* arr0, int step0, 812 void* arr1, int step1, 813 void* arr2, int step2, 814 CvSize size, int cn, 815 int coi, void* param ); 816 817typedef CvStatus (CV_STDCALL *CvFunc2D_4A)( void* arr0, int step0, 818 void* arr1, int step1, 819 void* arr2, int step2, 820 void* arr3, int step3, 821 CvSize size ); 822 823typedef CvStatus (CV_STDCALL *CvFunc0D)( const void* src, void* dst, int param ); 824 825#define CV_DEF_INIT_FUNC_TAB_2D( FUNCNAME, FLAG ) \ 826static void icvInit##FUNCNAME##FLAG##Table( CvFuncTable* tab ) \ 827{ \ 828 assert( tab ); \ 829 \ 830 tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u_##FLAG; \ 831 tab->fn_2d[CV_8S] = (void*)icv##FUNCNAME##_8s_##FLAG; \ 832 tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u_##FLAG; \ 833 tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s_##FLAG; \ 834 tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s_##FLAG; \ 835 tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f_##FLAG; \ 836 tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f_##FLAG; \ 837} 838 839 840#define CV_DEF_INIT_BIG_FUNC_TAB_2D( FUNCNAME, FLAG ) \ 841static void icvInit##FUNCNAME##FLAG##Table( CvBigFuncTable* tab ) \ 842{ \ 843 assert( tab ); \ 844 \ 845 tab->fn_2d[CV_8UC1] = (void*)icv##FUNCNAME##_8u_C1##FLAG; \ 846 tab->fn_2d[CV_8UC2] = (void*)icv##FUNCNAME##_8u_C2##FLAG; \ 847 tab->fn_2d[CV_8UC3] = (void*)icv##FUNCNAME##_8u_C3##FLAG; \ 848 tab->fn_2d[CV_8UC4] = (void*)icv##FUNCNAME##_8u_C4##FLAG; \ 849 \ 850 tab->fn_2d[CV_8SC1] = (void*)icv##FUNCNAME##_8s_C1##FLAG; \ 851 tab->fn_2d[CV_8SC2] = (void*)icv##FUNCNAME##_8s_C2##FLAG; \ 852 tab->fn_2d[CV_8SC3] = (void*)icv##FUNCNAME##_8s_C3##FLAG; \ 853 tab->fn_2d[CV_8SC4] = (void*)icv##FUNCNAME##_8s_C4##FLAG; \ 854 \ 855 tab->fn_2d[CV_16UC1] = (void*)icv##FUNCNAME##_16u_C1##FLAG; \ 856 tab->fn_2d[CV_16UC2] = (void*)icv##FUNCNAME##_16u_C2##FLAG; \ 857 tab->fn_2d[CV_16UC3] = (void*)icv##FUNCNAME##_16u_C3##FLAG; \ 858 tab->fn_2d[CV_16UC4] = (void*)icv##FUNCNAME##_16u_C4##FLAG; \ 859 \ 860 tab->fn_2d[CV_16SC1] = (void*)icv##FUNCNAME##_16s_C1##FLAG; \ 861 tab->fn_2d[CV_16SC2] = (void*)icv##FUNCNAME##_16s_C2##FLAG; \ 862 tab->fn_2d[CV_16SC3] = (void*)icv##FUNCNAME##_16s_C3##FLAG; \ 863 tab->fn_2d[CV_16SC4] = (void*)icv##FUNCNAME##_16s_C4##FLAG; \ 864 \ 865 tab->fn_2d[CV_32SC1] = (void*)icv##FUNCNAME##_32s_C1##FLAG; \ 866 tab->fn_2d[CV_32SC2] = (void*)icv##FUNCNAME##_32s_C2##FLAG; \ 867 tab->fn_2d[CV_32SC3] = (void*)icv##FUNCNAME##_32s_C3##FLAG; \ 868 tab->fn_2d[CV_32SC4] = (void*)icv##FUNCNAME##_32s_C4##FLAG; \ 869 \ 870 tab->fn_2d[CV_32FC1] = (void*)icv##FUNCNAME##_32f_C1##FLAG; \ 871 tab->fn_2d[CV_32FC2] = (void*)icv##FUNCNAME##_32f_C2##FLAG; \ 872 tab->fn_2d[CV_32FC3] = (void*)icv##FUNCNAME##_32f_C3##FLAG; \ 873 tab->fn_2d[CV_32FC4] = (void*)icv##FUNCNAME##_32f_C4##FLAG; \ 874 \ 875 tab->fn_2d[CV_64FC1] = (void*)icv##FUNCNAME##_64f_C1##FLAG; \ 876 tab->fn_2d[CV_64FC2] = (void*)icv##FUNCNAME##_64f_C2##FLAG; \ 877 tab->fn_2d[CV_64FC3] = (void*)icv##FUNCNAME##_64f_C3##FLAG; \ 878 tab->fn_2d[CV_64FC4] = (void*)icv##FUNCNAME##_64f_C4##FLAG; \ 879} 880 881#define CV_DEF_INIT_FUNC_TAB_0D( FUNCNAME ) \ 882static void icvInit##FUNCNAME##Table( CvFuncTable* tab ) \ 883{ \ 884 tab->fn_2d[CV_8U] = (void*)icv##FUNCNAME##_8u; \ 885 tab->fn_2d[CV_8S] = (void*)icv##FUNCNAME##_8s; \ 886 tab->fn_2d[CV_16U] = (void*)icv##FUNCNAME##_16u; \ 887 tab->fn_2d[CV_16S] = (void*)icv##FUNCNAME##_16s; \ 888 tab->fn_2d[CV_32S] = (void*)icv##FUNCNAME##_32s; \ 889 tab->fn_2d[CV_32F] = (void*)icv##FUNCNAME##_32f; \ 890 tab->fn_2d[CV_64F] = (void*)icv##FUNCNAME##_64f; \ 891} 892 893#define CV_DEF_INIT_FUNC_TAB_1D CV_DEF_INIT_FUNC_TAB_0D 894 895 896#define CV_DEF_INIT_PIXSIZE_TAB_2D( FUNCNAME, FLAG ) \ 897static void icvInit##FUNCNAME##FLAG##Table( CvBtFuncTable* table ) \ 898{ \ 899 table->fn_2d[1] = (void*)icv##FUNCNAME##_8u_C1##FLAG; \ 900 table->fn_2d[2] = (void*)icv##FUNCNAME##_8u_C2##FLAG; \ 901 table->fn_2d[3] = (void*)icv##FUNCNAME##_8u_C3##FLAG; \ 902 table->fn_2d[4] = (void*)icv##FUNCNAME##_16u_C2##FLAG; \ 903 table->fn_2d[6] = (void*)icv##FUNCNAME##_16u_C3##FLAG; \ 904 table->fn_2d[8] = (void*)icv##FUNCNAME##_32s_C2##FLAG; \ 905 table->fn_2d[12] = (void*)icv##FUNCNAME##_32s_C3##FLAG; \ 906 table->fn_2d[16] = (void*)icv##FUNCNAME##_64s_C2##FLAG; \ 907 table->fn_2d[24] = (void*)icv##FUNCNAME##_64s_C3##FLAG; \ 908 table->fn_2d[32] = (void*)icv##FUNCNAME##_64s_C4##FLAG; \ 909} 910 911#define CV_GET_FUNC_PTR( func, table_entry ) \ 912 func = (table_entry); \ 913 \ 914 if( !func ) \ 915 CV_ERROR( CV_StsUnsupportedFormat, "" ) 916 917 918#endif /*_CXCORE_MISC_H_*/ 919