git.maemo.org Git - opencv/blob - cxcore/src/cxconvert.cpp

   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 #include "_cxcore.h"
  43
  44 /****************************************************************************************\
  45 *                            Splitting/extracting array channels                         *
  46 \****************************************************************************************/
  47
  48 #define  ICV_DEF_PX2PL2PX_ENTRY_C2( arrtype_ptr, ptr )  \
  49     arrtype_ptr plane0 = ptr[0];                        \
  50     arrtype_ptr plane1 = ptr[1];
  51
  52 #define  ICV_DEF_PX2PL2PX_ENTRY_C3( arrtype_ptr, ptr )  \
  53     arrtype_ptr plane0 = ptr[0];                        \
  54     arrtype_ptr plane1 = ptr[1];                        \
  55     arrtype_ptr plane2 = ptr[2];
  56
  57 #define  ICV_DEF_PX2PL2PX_ENTRY_C4( arrtype_ptr, ptr )  \
  58     arrtype_ptr plane0 = ptr[0];                        \
  59     arrtype_ptr plane1 = ptr[1];                        \
  60     arrtype_ptr plane2 = ptr[2];                        \
  61     arrtype_ptr plane3 = ptr[3];
  62
  63
  64 #define  ICV_DEF_PX2PL_C2( arrtype, len )           \
  65 {                                                   \
  66     int j;                                          \
  67                                                     \
  68     for( j = 0; j < (len); j++, (src) += 2 )        \
  69     {                                               \
  70         arrtype t0 = (src)[0];                      \
  71         arrtype t1 = (src)[1];                      \
  72                                                     \
  73         plane0[j] = t0;                             \
  74         plane1[j] = t1;                             \
  75     }                                               \
  76     plane0 += dststep;                              \
  77     plane1 += dststep;                              \
  78 }
  79
  80
  81 #define  ICV_DEF_PX2PL_C3( arrtype, len )           \
  82 {                                                   \
  83     int j;                                          \
  84                                                     \
  85     for( j = 0; j < (len); j++, (src) += 3 )        \
  86     {                                               \
  87         arrtype t0 = (src)[0];                      \
  88         arrtype t1 = (src)[1];                      \
  89         arrtype t2 = (src)[2];                      \
  90                                                     \
  91         plane0[j] = t0;                             \
  92         plane1[j] = t1;                             \
  93         plane2[j] = t2;                             \
  94     }                                               \
  95     plane0 += dststep;                              \
  96     plane1 += dststep;                              \
  97     plane2 += dststep;                              \
  98 }
  99
 100
 101 #define  ICV_DEF_PX2PL_C4( arrtype, len )           \
 102 {                                                   \
 103     int j;                                          \
 104                                                     \
 105     for( j = 0; j < (len); j++, (src) += 4 )        \
 106     {                                               \
 107         arrtype t0 = (src)[0];                      \
 108         arrtype t1 = (src)[1];                      \
 109                                                     \
 110         plane0[j] = t0;                             \
 111         plane1[j] = t1;                             \
 112                                                     \
 113         t0 = (src)[2];                              \
 114         t1 = (src)[3];                              \
 115                                                     \
 116         plane2[j] = t0;                             \
 117         plane3[j] = t1;                             \
 118     }                                               \
 119     plane0 += dststep;                              \
 120     plane1 += dststep;                              \
 121     plane2 += dststep;                              \
 122     plane3 += dststep;                              \
 123 }
 124
 125
 126 #define  ICV_DEF_PX2PL_COI( arrtype, len, cn )      \
 127 {                                                   \
 128     int j;                                          \
 129                                                     \
 130     for( j = 0; j <= (len) - 4; j += 4, (src) += 4*(cn))\
 131     {                                               \
 132         arrtype t0 = (src)[0];                      \
 133         arrtype t1 = (src)[(cn)];                   \
 134                                                     \
 135         (dst)[j] = t0;                              \
 136         (dst)[j+1] = t1;                            \
 137                                                     \
 138         t0 = (src)[(cn)*2];                         \
 139         t1 = (src)[(cn)*3];                         \
 140                                                     \
 141         (dst)[j+2] = t0;                            \
 142         (dst)[j+3] = t1;                            \
 143     }                                               \
 144                                                     \
 145     for( ; j < (len); j++, (src) += (cn))           \
 146     {                                               \
 147         (dst)[j] = (src)[0];                        \
 148     }                                               \
 149 }
 150
 151
 152 #define  ICV_DEF_COPY_PX2PL_FUNC_2D( arrtype, flavor,   \
 153                                      cn, entry_macro )  \
 154 IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_C##cn##P##cn##R,\
 155 ( const arrtype* src, int srcstep,                      \
 156   arrtype** dst, int dststep, CvSize size ),            \
 157   (src, srcstep, dst, dststep, size))                   \
 158 {                                                       \
 159     entry_macro(arrtype*, dst);                         \
 160     srcstep /= sizeof(src[0]);                          \
 161     dststep /= sizeof(dst[0][0]);                       \
 162                                                         \
 163     for( ; size.height--; src += srcstep )              \
 164     {                                                   \
 165         ICV_DEF_PX2PL_C##cn( arrtype, size.width );     \
 166         src -= size.width*(cn);                         \
 167     }                                                   \
 168                                                         \
 169     return CV_OK;                                       \
 170 }
 171
 172
 173 #define  ICV_DEF_COPY_PX2PL_FUNC_2D_COI( arrtype, flavor )\
 174 IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_CnC1CR,      \
 175 ( const arrtype* src, int srcstep, arrtype* dst, int dststep,\
 176   CvSize size, int cn, int coi ),                       \
 177   (src, srcstep, dst, dststep, size, cn, coi))          \
 178 {                                                       \
 179     src += coi - 1;                                     \
 180     srcstep /= sizeof(src[0]);                          \
 181     dststep /= sizeof(dst[0]);                          \
 182                                                         \
 183     for( ; size.height--; src += srcstep, dst += dststep )\
 184     {                                                   \
 185         ICV_DEF_PX2PL_COI( arrtype, size.width, cn );   \
 186         src -= size.width*(cn);                         \
 187     }                                                   \
 188                                                         \
 189     return CV_OK;                                       \
 190 }
 191
 192
 193 ICV_DEF_COPY_PX2PL_FUNC_2D( uchar, 8u, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 194 ICV_DEF_COPY_PX2PL_FUNC_2D( uchar, 8u, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 195 ICV_DEF_COPY_PX2PL_FUNC_2D( uchar, 8u, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 196 ICV_DEF_COPY_PX2PL_FUNC_2D( ushort, 16s, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 197 ICV_DEF_COPY_PX2PL_FUNC_2D( ushort, 16s, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 198 ICV_DEF_COPY_PX2PL_FUNC_2D( ushort, 16s, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 199 ICV_DEF_COPY_PX2PL_FUNC_2D( int, 32f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 200 ICV_DEF_COPY_PX2PL_FUNC_2D( int, 32f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 201 ICV_DEF_COPY_PX2PL_FUNC_2D( int, 32f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 202 ICV_DEF_COPY_PX2PL_FUNC_2D( int64, 64f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 203 ICV_DEF_COPY_PX2PL_FUNC_2D( int64, 64f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 204 ICV_DEF_COPY_PX2PL_FUNC_2D( int64, 64f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 205
 206
 207 ICV_DEF_COPY_PX2PL_FUNC_2D_COI( uchar, 8u )
 208 ICV_DEF_COPY_PX2PL_FUNC_2D_COI( ushort, 16s )
 209 ICV_DEF_COPY_PX2PL_FUNC_2D_COI( int, 32f )
 210 ICV_DEF_COPY_PX2PL_FUNC_2D_COI( int64, 64f )
 211
 212
 213 /****************************************************************************************\
 214 *                            Merging/inserting array channels                            *
 215 \****************************************************************************************/
 216
 217
 218 #define  ICV_DEF_PL2PX_C2( arrtype, len )   \
 219 {                                           \
 220     int j;                                  \
 221                                             \
 222     for( j = 0; j < (len); j++, (dst) += 2 )\
 223     {                                       \
 224         arrtype t0 = plane0[j];             \
 225         arrtype t1 = plane1[j];             \
 226                                             \
 227         dst[0] = t0;                        \
 228         dst[1] = t1;                        \
 229     }                                       \
 230     plane0 += srcstep;                      \
 231     plane1 += srcstep;                      \
 232 }
 233
 234
 235 #define  ICV_DEF_PL2PX_C3( arrtype, len )   \
 236 {                                           \
 237     int j;                                  \
 238                                             \
 239     for( j = 0; j < (len); j++, (dst) += 3 )\
 240     {                                       \
 241         arrtype t0 = plane0[j];             \
 242         arrtype t1 = plane1[j];             \
 243         arrtype t2 = plane2[j];             \
 244                                             \
 245         dst[0] = t0;                        \
 246         dst[1] = t1;                        \
 247         dst[2] = t2;                        \
 248     }                                       \
 249     plane0 += srcstep;                      \
 250     plane1 += srcstep;                      \
 251     plane2 += srcstep;                      \
 252 }
 253
 254
 255 #define  ICV_DEF_PL2PX_C4( arrtype, len )   \
 256 {                                           \
 257     int j;                                  \
 258                                             \
 259     for( j = 0; j < (len); j++, (dst) += 4 )\
 260     {                                       \
 261         arrtype t0 = plane0[j];             \
 262         arrtype t1 = plane1[j];             \
 263                                             \
 264         dst[0] = t0;                        \
 265         dst[1] = t1;                        \
 266                                             \
 267         t0 = plane2[j];                     \
 268         t1 = plane3[j];                     \
 269                                             \
 270         dst[2] = t0;                        \
 271         dst[3] = t1;                        \
 272     }                                       \
 273     plane0 += srcstep;                      \
 274     plane1 += srcstep;                      \
 275     plane2 += srcstep;                      \
 276     plane3 += srcstep;                      \
 277 }
 278
 279
 280 #define  ICV_DEF_PL2PX_COI( arrtype, len, cn )          \
 281 {                                                       \
 282     int j;                                              \
 283                                                         \
 284     for( j = 0; j <= (len) - 4; j += 4, (dst) += 4*(cn))\
 285     {                                                   \
 286         arrtype t0 = (src)[j];                          \
 287         arrtype t1 = (src)[j+1];                        \
 288                                                         \
 289         (dst)[0] = t0;                                  \
 290         (dst)[(cn)] = t1;                               \
 291                                                         \
 292         t0 = (src)[j+2];                                \
 293         t1 = (src)[j+3];                                \
 294                                                         \
 295         (dst)[(cn)*2] = t0;                             \
 296         (dst)[(cn)*3] = t1;                             \
 297     }                                                   \
 298                                                         \
 299     for( ; j < (len); j++, (dst) += (cn))               \
 300     {                                                   \
 301         (dst)[0] = (src)[j];                            \
 302     }                                                   \
 303 }
 304
 305
 306 #define  ICV_DEF_COPY_PL2PX_FUNC_2D( arrtype, flavor, cn, entry_macro ) \
 307 IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_P##cn##C##cn##R, \
 308 ( const arrtype** src, int srcstep,                         \
 309   arrtype* dst, int dststep, CvSize size ),                 \
 310   (src, srcstep, dst, dststep, size))                       \
 311 {                                                           \
 312     entry_macro(const arrtype*, src);                       \
 313     srcstep /= sizeof(src[0][0]);                           \
 314     dststep /= sizeof(dst[0]);                              \
 315                                                             \
 316     for( ; size.height--; dst += dststep )                  \
 317     {                                                       \
 318         ICV_DEF_PL2PX_C##cn( arrtype, size.width );         \
 319         dst -= size.width*(cn);                             \
 320     }                                                       \
 321                                                             \
 322     return CV_OK;                                           \
 323 }
 324
 325
 326 #define  ICV_DEF_COPY_PL2PX_FUNC_2D_COI( arrtype, flavor )  \
 327 IPCVAPI_IMPL( CvStatus, icvCopy_##flavor##_C1CnCR,          \
 328 ( const arrtype* src, int srcstep,                          \
 329   arrtype* dst, int dststep,                                \
 330   CvSize size, int cn, int coi ),                           \
 331   (src, srcstep, dst, dststep, size, cn, coi))              \
 332 {                                                           \
 333     dst += coi - 1;                                         \
 334     srcstep /= sizeof(src[0]); dststep /= sizeof(dst[0]);   \
 335                                                             \
 336     for( ; size.height--; src += srcstep, dst += dststep )  \
 337     {                                                       \
 338         ICV_DEF_PL2PX_COI( arrtype, size.width, cn );       \
 339         dst -= size.width*(cn);                             \
 340     }                                                       \
 341                                                             \
 342     return CV_OK;                                           \
 343 }
 344
 345
 346 ICV_DEF_COPY_PL2PX_FUNC_2D( uchar, 8u, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 347 ICV_DEF_COPY_PL2PX_FUNC_2D( uchar, 8u, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 348 ICV_DEF_COPY_PL2PX_FUNC_2D( uchar, 8u, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 349 ICV_DEF_COPY_PL2PX_FUNC_2D( ushort, 16s, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 350 ICV_DEF_COPY_PL2PX_FUNC_2D( ushort, 16s, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 351 ICV_DEF_COPY_PL2PX_FUNC_2D( ushort, 16s, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 352 ICV_DEF_COPY_PL2PX_FUNC_2D( int, 32f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 353 ICV_DEF_COPY_PL2PX_FUNC_2D( int, 32f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 354 ICV_DEF_COPY_PL2PX_FUNC_2D( int, 32f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 355 ICV_DEF_COPY_PL2PX_FUNC_2D( int64, 64f, 2, ICV_DEF_PX2PL2PX_ENTRY_C2 )
 356 ICV_DEF_COPY_PL2PX_FUNC_2D( int64, 64f, 3, ICV_DEF_PX2PL2PX_ENTRY_C3 )
 357 ICV_DEF_COPY_PL2PX_FUNC_2D( int64, 64f, 4, ICV_DEF_PX2PL2PX_ENTRY_C4 )
 358
 359 ICV_DEF_COPY_PL2PX_FUNC_2D_COI( uchar, 8u )
 360 ICV_DEF_COPY_PL2PX_FUNC_2D_COI( ushort, 16s )
 361 ICV_DEF_COPY_PL2PX_FUNC_2D_COI( int, 32f )
 362 ICV_DEF_COPY_PL2PX_FUNC_2D_COI( int64, 64f )
 363
 364
 365 #define  ICV_DEF_PXPLPX_TAB( name, FROM, TO )                           \
 366 static void                                                             \
 367 name( CvBigFuncTable* tab )                                             \
 368 {                                                                       \
 369     tab->fn_2d[CV_8UC2] = (void*)icvCopy##_8u_##FROM##2##TO##2R;        \
 370     tab->fn_2d[CV_8UC3] = (void*)icvCopy##_8u_##FROM##3##TO##3R;        \
 371     tab->fn_2d[CV_8UC4] = (void*)icvCopy##_8u_##FROM##4##TO##4R;        \
 372                                                                         \
 373     tab->fn_2d[CV_8SC2] = (void*)icvCopy##_8u_##FROM##2##TO##2R;        \
 374     tab->fn_2d[CV_8SC3] = (void*)icvCopy##_8u_##FROM##3##TO##3R;        \
 375     tab->fn_2d[CV_8SC4] = (void*)icvCopy##_8u_##FROM##4##TO##4R;        \
 376                                                                         \
 377     tab->fn_2d[CV_16UC2] = (void*)icvCopy##_16s_##FROM##2##TO##2R;      \
 378     tab->fn_2d[CV_16UC3] = (void*)icvCopy##_16s_##FROM##3##TO##3R;      \
 379     tab->fn_2d[CV_16UC4] = (void*)icvCopy##_16s_##FROM##4##TO##4R;      \
 380                                                                         \
 381     tab->fn_2d[CV_16SC2] = (void*)icvCopy##_16s_##FROM##2##TO##2R;      \
 382     tab->fn_2d[CV_16SC3] = (void*)icvCopy##_16s_##FROM##3##TO##3R;      \
 383     tab->fn_2d[CV_16SC4] = (void*)icvCopy##_16s_##FROM##4##TO##4R;      \
 384                                                                         \
 385     tab->fn_2d[CV_32SC2] = (void*)icvCopy##_32f_##FROM##2##TO##2R;      \
 386     tab->fn_2d[CV_32SC3] = (void*)icvCopy##_32f_##FROM##3##TO##3R;      \
 387     tab->fn_2d[CV_32SC4] = (void*)icvCopy##_32f_##FROM##4##TO##4R;      \
 388                                                                         \
 389     tab->fn_2d[CV_32FC2] = (void*)icvCopy##_32f_##FROM##2##TO##2R;      \
 390     tab->fn_2d[CV_32FC3] = (void*)icvCopy##_32f_##FROM##3##TO##3R;      \
 391     tab->fn_2d[CV_32FC4] = (void*)icvCopy##_32f_##FROM##4##TO##4R;      \
 392                                                                         \
 393     tab->fn_2d[CV_64FC2] = (void*)icvCopy##_64f_##FROM##2##TO##2R;      \
 394     tab->fn_2d[CV_64FC3] = (void*)icvCopy##_64f_##FROM##3##TO##3R;      \
 395     tab->fn_2d[CV_64FC4] = (void*)icvCopy##_64f_##FROM##4##TO##4R;      \
 396 }
 397
 398
 399
 400 #define  ICV_DEF_PXPLCOI_TAB( name, FROM, TO )                          \
 401 static void                                                             \
 402 name( CvFuncTable* tab )                                                \
 403 {                                                                       \
 404     tab->fn_2d[CV_8U] = (void*)icvCopy##_8u_##FROM##TO##CR;             \
 405     tab->fn_2d[CV_8S] = (void*)icvCopy##_8u_##FROM##TO##CR;             \
 406     tab->fn_2d[CV_16U] = (void*)icvCopy##_16s_##FROM##TO##CR;           \
 407     tab->fn_2d[CV_16S] = (void*)icvCopy##_16s_##FROM##TO##CR;           \
 408     tab->fn_2d[CV_32S] = (void*)icvCopy##_32f_##FROM##TO##CR;           \
 409     tab->fn_2d[CV_32F] = (void*)icvCopy##_32f_##FROM##TO##CR;           \
 410     tab->fn_2d[CV_64F] = (void*)icvCopy##_64f_##FROM##TO##CR;           \
 411 }
 412
 413
 414 ICV_DEF_PXPLPX_TAB( icvInitSplitRTable, C, P )
 415 ICV_DEF_PXPLCOI_TAB( icvInitSplitRCoiTable, Cn, C1 )
 416 ICV_DEF_PXPLPX_TAB( icvInitCvtPlaneToPixRTable, P, C )
 417 ICV_DEF_PXPLCOI_TAB( icvInitCvtPlaneToPixRCoiTable, C1, Cn )
 418
 419 typedef CvStatus (CV_STDCALL *CvSplitFunc)( const void* src, int srcstep,
 420                                                     void** dst, int dststep, CvSize size);
 421
 422 typedef CvStatus (CV_STDCALL *CvExtractPlaneFunc)( const void* src, int srcstep,
 423                                                    void* dst, int dststep,
 424                                                    CvSize size, int cn, int coi );
 425
 426 typedef CvStatus (CV_STDCALL *CvMergeFunc)( const void** src, int srcstep,
 427                                                     void* dst, int dststep, CvSize size);
 428
 429 typedef CvStatus (CV_STDCALL *CvInsertPlaneFunc)( const void* src, int srcstep,
 430                                                   void* dst, int dststep,
 431                                                   CvSize size, int cn, int coi );
 432
 433 CV_IMPL void
 434 cvSplit( const void* srcarr, void* dstarr0, void* dstarr1, void* dstarr2, void* dstarr3 )
 435 {
 436     static CvBigFuncTable  pxpl_tab;
 437     static CvFuncTable  pxplcoi_tab;
 438     static int inittab = 0;
 439
 440     CV_FUNCNAME( "cvSplit" );
 441
 442     __BEGIN__;
 443
 444     CvMat stub[5], *dst[4], *src = (CvMat*)srcarr;
 445     CvSize size;
 446     void* dstptr[4] = { 0, 0, 0, 0 };
 447     int type, cn, coi = 0;
 448     int i, nzplanes = 0, nzidx = -1;
 449     int cont_flag;
 450     int src_step, dst_step = 0;
 451
 452     if( !inittab )
 453     {
 454         icvInitSplitRTable( &pxpl_tab );
 455         icvInitSplitRCoiTable( &pxplcoi_tab );
 456         inittab = 1;
 457     }
 458
 459     dst[0] = (CvMat*)dstarr0;
 460     dst[1] = (CvMat*)dstarr1;
 461     dst[2] = (CvMat*)dstarr2;
 462     dst[3] = (CvMat*)dstarr3;
 463
 464     CV_CALL( src = cvGetMat( src, stub + 4, &coi ));
 465
 466     //if( coi != 0 )
 467     //    CV_ERROR( CV_BadCOI, "" );
 468
 469     type = CV_MAT_TYPE( src->type );
 470     cn = CV_MAT_CN( type );
 471
 472     cont_flag = src->type;
 473
 474     if( cn == 1 )
 475         CV_ERROR( CV_BadNumChannels, "" );
 476
 477     for( i = 0; i < 4; i++ )
 478     {
 479         if( dst[i] )
 480         {
 481             nzplanes++;
 482             nzidx = i;
 483             CV_CALL( dst[i] = cvGetMat( dst[i], stub + i ));
 484             if( CV_MAT_CN( dst[i]->type ) != 1 )
 485                 CV_ERROR( CV_BadNumChannels, "" );
 486             if( !CV_ARE_DEPTHS_EQ( dst[i], src ))
 487                 CV_ERROR( CV_StsUnmatchedFormats, "" );
 488             if( !CV_ARE_SIZES_EQ( dst[i], src ))
 489                 CV_ERROR( CV_StsUnmatchedSizes, "" );
 490             if( nzplanes > i && i > 0 && dst[i]->step != dst[i-1]->step )
 491                 CV_ERROR( CV_BadStep, "" );
 492             dst_step = dst[i]->step;
 493             dstptr[nzplanes-1] = dst[i]->data.ptr;
 494
 495             cont_flag &= dst[i]->type;
 496         }
 497     }
 498
 499     src_step = src->step;
 500     size = cvGetMatSize( src );
 501
 502     if( CV_IS_MAT_CONT( cont_flag ))
 503     {
 504         size.width *= size.height;
 505         src_step = dst_step = CV_STUB_STEP;
 506
 507         size.height = 1;
 508     }
 509
 510     if( nzplanes == cn )
 511     {
 512         CvSplitFunc func = (CvSplitFunc)pxpl_tab.fn_2d[type];
 513
 514         if( !func )
 515             CV_ERROR( CV_StsUnsupportedFormat, "" );
 516
 517         IPPI_CALL( func( src->data.ptr, src_step, dstptr, dst_step, size ));
 518     }
 519     else if( nzplanes == 1 )
 520     {
 521         CvExtractPlaneFunc func = (CvExtractPlaneFunc)pxplcoi_tab.fn_2d[CV_MAT_DEPTH(type)];
 522
 523         if( !func )
 524             CV_ERROR( CV_StsUnsupportedFormat, "" );
 525
 526         IPPI_CALL( func( src->data.ptr, src_step,
 527                          dst[nzidx]->data.ptr, dst_step,
 528                          size, cn, nzidx + 1 ));
 529     }
 530     else
 531     {
 532         CV_ERROR( CV_StsBadArg,
 533             "Either all output planes or only one output plane should be non zero" );
 534     }
 535
 536     __END__;
 537 }
 538
 539
 540
 541 CV_IMPL void
 542 cvMerge( const void* srcarr0, const void* srcarr1, const void* srcarr2,
 543          const void* srcarr3, void* dstarr )
 544 {
 545     static CvBigFuncTable plpx_tab;
 546     static CvFuncTable plpxcoi_tab;
 547     static int inittab = 0;
 548
 549     CV_FUNCNAME( "cvMerge" );
 550
 551     __BEGIN__;
 552
 553     int src_step = 0, dst_step;
 554     CvMat stub[5], *src[4], *dst = (CvMat*)dstarr;
 555     CvSize size;
 556     const void* srcptr[4] = { 0, 0, 0, 0 };
 557     int type, cn, coi = 0;
 558     int i, nzplanes = 0, nzidx = -1;
 559     int cont_flag;
 560
 561     if( !inittab )
 562     {
 563         icvInitCvtPlaneToPixRTable( &plpx_tab );
 564         icvInitCvtPlaneToPixRCoiTable( &plpxcoi_tab );
 565         inittab = 1;
 566     }
 567
 568     src[0] = (CvMat*)srcarr0;
 569     src[1] = (CvMat*)srcarr1;
 570     src[2] = (CvMat*)srcarr2;
 571     src[3] = (CvMat*)srcarr3;
 572
 573     CV_CALL( dst = cvGetMat( dst, stub + 4, &coi ));
 574
 575     type = CV_MAT_TYPE( dst->type );
 576     cn = CV_MAT_CN( type );
 577
 578     cont_flag = dst->type;
 579
 580     if( cn == 1 )
 581         CV_ERROR( CV_BadNumChannels, "" );
 582
 583     for( i = 0; i < 4; i++ )
 584     {
 585         if( src[i] )
 586         {
 587             nzplanes++;
 588             nzidx = i;
 589             CV_CALL( src[i] = cvGetMat( src[i], stub + i ));
 590             if( CV_MAT_CN( src[i]->type ) != 1 )
 591                 CV_ERROR( CV_BadNumChannels, "" );
 592             if( !CV_ARE_DEPTHS_EQ( src[i], dst ))
 593                 CV_ERROR( CV_StsUnmatchedFormats, "" );
 594             if( !CV_ARE_SIZES_EQ( src[i], dst ))
 595                 CV_ERROR( CV_StsUnmatchedSizes, "" );
 596             if( nzplanes > i && i > 0 && src[i]->step != src[i-1]->step )
 597                 CV_ERROR( CV_BadStep, "" );
 598             src_step = src[i]->step;
 599             srcptr[nzplanes-1] = (const void*)(src[i]->data.ptr);
 600
 601             cont_flag &= src[i]->type;
 602         }
 603     }
 604
 605     size = cvGetMatSize( dst );
 606     dst_step = dst->step;
 607
 608     if( CV_IS_MAT_CONT( cont_flag ))
 609     {
 610         size.width *= size.height;
 611         src_step = dst_step = CV_STUB_STEP;
 612         size.height = 1;
 613     }
 614
 615     if( nzplanes == cn )
 616     {
 617         CvMergeFunc func = (CvMergeFunc)plpx_tab.fn_2d[type];
 618
 619         if( !func )
 620             CV_ERROR( CV_StsUnsupportedFormat, "" );
 621
 622         IPPI_CALL( func( srcptr, src_step, dst->data.ptr, dst_step, size ));
 623     }
 624     else if( nzplanes == 1 )
 625     {
 626         CvInsertPlaneFunc func = (CvInsertPlaneFunc)plpxcoi_tab.fn_2d[CV_MAT_DEPTH(type)];
 627
 628         if( !func )
 629             CV_ERROR( CV_StsUnsupportedFormat, "" );
 630
 631         IPPI_CALL( func( src[nzidx]->data.ptr, src_step,
 632                          dst->data.ptr, dst_step,
 633                          size, cn, nzidx + 1 ));
 634     }
 635     else
 636     {
 637         CV_ERROR( CV_StsBadArg,
 638             "Either all input planes or only one input plane should be non zero" );
 639     }
 640
 641     __END__;
 642 }
 643
 644
 645 /****************************************************************************************\
 646 *                       Generalized split/merge: mixing channels                         *
 647 \****************************************************************************************/
 648
 649 #define  ICV_DEF_MIX_CH_FUNC_2D( arrtype, flavor )              \
 650 static CvStatus CV_STDCALL                                      \
 651 icvMixChannels_##flavor( const arrtype** src, int* sdelta0,     \
 652                          int* sdelta1, arrtype** dst,           \
 653                          int* ddelta0, int* ddelta1,            \
 654                          int n, CvSize size )                   \
 655 {                                                               \
 656     int i, k;                                                   \
 657     int block_size0 = n == 1 ? size.width : 1024;               \
 658                                                                 \
 659     for( ; size.height--; )                                     \
 660     {                                                           \
 661         int remaining = size.width;                             \
 662         for( ; remaining > 0; )                                 \
 663         {                                                       \
 664             int block_size = MIN( remaining, block_size0 );     \
 665             for( k = 0; k < n; k++ )                            \
 666             {                                                   \
 667                 const arrtype* s = src[k];                      \
 668                 arrtype* d = dst[k];                            \
 669                 int ds = sdelta1[k], dd = ddelta1[k];           \
 670                 if( s )                                         \
 671                 {                                               \
 672                     for( i = 0; i <= block_size - 2; i += 2,    \
 673                                         s += ds*2, d += dd*2 )  \
 674                     {                                           \
 675                         arrtype t0 = s[0], t1 = s[ds];          \
 676                         d[0] = t0; d[dd] = t1;                  \
 677                     }                                           \
 678                     if( i < block_size )                        \
 679                         d[0] = s[0], s += ds, d += dd;          \
 680                     src[k] = s;                                 \
 681                 }                                               \
 682                 else                                            \
 683                 {                                               \
 684                     for( i=0; i <= block_size-2; i+=2, d+=dd*2 )\
 685                         d[0] = d[dd] = 0;                       \
 686                     if( i < block_size )                        \
 687                         d[0] = 0, d += dd;                      \
 688                 }                                               \
 689                 dst[k] = d;                                     \
 690             }                                                   \
 691             remaining -= block_size;                            \
 692         }                                                       \
 693         for( k = 0; k < n; k++ )                                \
 694             src[k] += sdelta0[k], dst[k] += ddelta0[k];         \
 695     }                                                           \
 696                                                                 \
 697     return CV_OK;                                               \
 698 }
 699
 700
 701 ICV_DEF_MIX_CH_FUNC_2D( uchar, 8u )
 702 ICV_DEF_MIX_CH_FUNC_2D( ushort, 16u )
 703 ICV_DEF_MIX_CH_FUNC_2D( int, 32s )
 704 ICV_DEF_MIX_CH_FUNC_2D( int64, 64s )
 705
 706 static void
 707 icvInitMixChannelsTab( CvFuncTable* tab )
 708 {
 709     tab->fn_2d[CV_8U] = (void*)icvMixChannels_8u;
 710     tab->fn_2d[CV_8S] = (void*)icvMixChannels_8u;
 711     tab->fn_2d[CV_16U] = (void*)icvMixChannels_16u;
 712     tab->fn_2d[CV_16S] = (void*)icvMixChannels_16u;
 713     tab->fn_2d[CV_32S] = (void*)icvMixChannels_32s;
 714     tab->fn_2d[CV_32F] = (void*)icvMixChannels_32s;
 715     tab->fn_2d[CV_64F] = (void*)icvMixChannels_64s;
 716 }
 717
 718 typedef CvStatus (CV_STDCALL * CvMixChannelsFunc)( const void** src, int* sdelta0,
 719         int* sdelta1, void** dst, int* ddelta0, int* ddelta1, int n, CvSize size );
 720
 721 CV_IMPL void
 722 cvMixChannels( const CvArr** src, int src_count,
 723                CvArr** dst, int dst_count,
 724                const int* from_to, int pair_count )
 725 {
 726     static CvFuncTable mixcn_tab;
 727     static int inittab = 0;
 728     uchar* buffer = 0;
 729     int heap_alloc = 0;
 730
 731     CV_FUNCNAME( "cvMixChannels" );
 732
 733     __BEGIN__;
 734
 735     CvSize size = {0,0};
 736     int depth = -1, elem_size = 1;
 737     int *sdelta0 = 0, *sdelta1 = 0, *ddelta0 = 0, *ddelta1 = 0;
 738     uchar **sptr = 0, **dptr = 0;
 739     uchar **src0 = 0, **dst0 = 0;
 740     int* src_cn = 0, *dst_cn = 0;
 741     int* src_step = 0, *dst_step = 0;
 742     int buf_size, i, k;
 743     int cont_flag = CV_MAT_CONT_FLAG;
 744     CvMixChannelsFunc func;
 745
 746     if( !inittab )
 747     {
 748         icvInitMixChannelsTab( &mixcn_tab );
 749         inittab = 1;
 750     }
 751
 752     src_count = MAX( src_count, 0 );
 753
 754     if( !src && src_count > 0 )
 755         CV_ERROR( CV_StsNullPtr, "The input array of arrays is NULL" );
 756
 757     if( !dst )
 758         CV_ERROR( CV_StsNullPtr, "The output array of arrays is NULL" );
 759
 760     if( dst_count <= 0 || pair_count <= 0 )
 761         CV_ERROR( CV_StsOutOfRange,
 762         "The number of output arrays and the number of copied channels must be positive" );
 763
 764     if( !from_to )
 765         CV_ERROR( CV_StsNullPtr, "The array of copied channel indices is NULL" );
 766
 767     buf_size = (src_count + dst_count + 2)*
 768         (sizeof(src0[0]) + sizeof(src_cn[0]) + sizeof(src_step[0])) +
 769         pair_count*2*(sizeof(sptr[0]) + sizeof(sdelta0[0]) + sizeof(sdelta1[0]));
 770
 771     if( buf_size > CV_MAX_LOCAL_SIZE )
 772     {
 773         CV_CALL( buffer = (uchar*)cvAlloc( buf_size ) );
 774         heap_alloc = 1;
 775     }
 776     else
 777         buffer = (uchar*)cvStackAlloc( buf_size );
 778
 779     src0 = (uchar**)buffer;
 780     dst0 = src0 + src_count;
 781     src_cn = (int*)(dst0 + dst_count);
 782     dst_cn = src_cn + src_count + 1;
 783     src_step = dst_cn + dst_count + 1;
 784     dst_step = src_step + src_count;
 785
 786     sptr = (uchar**)cvAlignPtr( dst_step + dst_count, (int)sizeof(void*) );
 787     dptr = sptr + pair_count;
 788     sdelta0 = (int*)(dptr + pair_count);
 789     sdelta1 = sdelta0 + pair_count;
 790     ddelta0 = sdelta1 + pair_count;
 791     ddelta1 = ddelta0 + pair_count;
 792
 793     src_cn[0] = dst_cn[0] = 0;
 794
 795     for( k = 0; k < 2; k++ )
 796     {
 797         for( i = 0; i < (k == 0 ? src_count : dst_count); i++ )
 798         {
 799             CvMat stub, *mat = (CvMat*)(k == 0 ? src[i] : dst[i]);
 800             int cn;
 801
 802             if( !CV_IS_MAT(mat) )
 803                 CV_CALL( mat = cvGetMat( mat, &stub ));
 804
 805             if( depth < 0 )
 806             {
 807                 depth = CV_MAT_DEPTH(mat->type);
 808                 elem_size = CV_ELEM_SIZE1(depth);
 809                 size = cvGetMatSize(mat);
 810             }
 811
 812             if( CV_MAT_DEPTH(mat->type) != depth )
 813                 CV_ERROR( CV_StsUnmatchedFormats, "All the arrays must have the same bit depth" );
 814
 815             if( mat->cols != size.width || mat->rows != size.height )
 816                 CV_ERROR( CV_StsUnmatchedSizes, "All the arrays must have the same size" );
 817
 818             if( k == 0 )
 819             {
 820                 src0[i] = mat->data.ptr;
 821                 cn = CV_MAT_CN(mat->type);
 822                 src_cn[i+1] = src_cn[i] + cn;
 823                 src_step[i] = mat->step / elem_size - size.width * cn;
 824             }
 825             else
 826             {
 827                 dst0[i] = mat->data.ptr;
 828                 cn = CV_MAT_CN(mat->type);
 829                 dst_cn[i+1] = dst_cn[i] + cn;
 830                 dst_step[i] = mat->step / elem_size - size.width * cn;
 831             }
 832
 833             cont_flag &= mat->type;
 834         }
 835     }
 836
 837     if( cont_flag )
 838     {
 839         size.width *= size.height;
 840         size.height = 1;
 841     }
 842
 843     for( i = 0; i < pair_count; i++ )
 844     {
 845         for( k = 0; k < 2; k++ )
 846         {
 847             int cn = from_to[i*2 + k];
 848             const int* cn_arr = k == 0 ? src_cn : dst_cn;
 849             int a = 0, b = k == 0 ? src_count-1 : dst_count-1;
 850
 851             if( cn < 0 || cn >= cn_arr[b+1] )
 852             {
 853                 if( k == 0 && cn < 0 )
 854                 {
 855                     sptr[i] = 0;
 856                     sdelta0[i] = sdelta1[i] = 0;
 857                     continue;
 858                 }
 859                 else
 860                 {
 861                     char err_str[100];
 862                     sprintf( err_str, "channel index #%d in the array of pairs is negative "
 863                         "or exceeds the total number of channels in all the %s arrays", i*2+k,
 864                         k == 0 ? "input" : "output" );
 865                     CV_ERROR( CV_StsOutOfRange, err_str );
 866                 }
 867             }
 868
 869             for( ; cn >= cn_arr[a+1]; a++ )
 870                 ;
 871
 872             if( k == 0 )
 873             {
 874                 sptr[i] = src0[a] + (cn - cn_arr[a])*elem_size;
 875                 sdelta1[i] = cn_arr[a+1] - cn_arr[a];
 876                 sdelta0[i] = src_step[a];
 877             }
 878             else
 879             {
 880                 dptr[i] = dst0[a] + (cn - cn_arr[a])*elem_size;
 881                 ddelta1[i] = cn_arr[a+1] - cn_arr[a];
 882                 ddelta0[i] = dst_step[a];
 883             }
 884         }
 885     }
 886
 887     func = (CvMixChannelsFunc)mixcn_tab.fn_2d[depth];
 888     if( !func )
 889         CV_ERROR( CV_StsUnsupportedFormat, "The data type is not supported by the function" );
 890
 891     IPPI_CALL( func( (const void**)sptr, sdelta0, sdelta1, (void**)dptr,
 892                      ddelta0, ddelta1, pair_count, size ));
 893
 894     __END__;
 895
 896     if( buffer && heap_alloc )
 897         cvFree( &buffer );
 898 }
 899
 900
 901 /****************************************************************************************\
 902 *                                   cvConvertScaleAbs                                    *
 903 \****************************************************************************************/
 904
 905 #define ICV_DEF_CVT_SCALE_ABS_CASE( srctype, worktype,                  \
 906             scale_macro, abs_macro, cast_macro, a, b )                  \
 907                                                                         \
 908 {                                                                       \
 909     const srctype* _src = (const srctype*)src;                          \
 910     srcstep /= sizeof(_src[0]); /*dststep /= sizeof(_dst[0]);*/         \
 911                                                                         \
 912     for( ; size.height--; _src += srcstep, dst += dststep )             \
 913     {                                                                   \
 914         int i;                                                          \
 915                                                                         \
 916         for( i = 0; i <= size.width - 4; i += 4 )                       \
 917         {                                                               \
 918             worktype t0 = scale_macro((a)*_src[i] + (b));               \
 919             worktype t1 = scale_macro((a)*_src[i+1] + (b));             \
 920                                                                         \
 921             t0 = (worktype)abs_macro(t0);                               \
 922             t1 = (worktype)abs_macro(t1);                               \
 923                                                                         \
 924             dst[i] = cast_macro(t0);                                    \
 925             dst[i+1] = cast_macro(t1);                                  \
 926                                                                         \
 927             t0 = scale_macro((a)*_src[i+2] + (b));                      \
 928             t1 = scale_macro((a)*_src[i+3] + (b));                      \
 929                                                                         \
 930             t0 = (worktype)abs_macro(t0);                               \
 931             t1 = (worktype)abs_macro(t1);                               \
 932                                                                         \
 933             dst[i+2] = cast_macro(t0);                                  \
 934             dst[i+3] = cast_macro(t1);                                  \
 935         }                                                               \
 936                                                                         \
 937         for( ; i < size.width; i++ )                                    \
 938         {                                                               \
 939             worktype t0 = scale_macro((a)*_src[i] + (b));               \
 940             t0 = (worktype)abs_macro(t0);                               \
 941             dst[i] = cast_macro(t0);                                    \
 942         }                                                               \
 943     }                                                                   \
 944 }
 945
 946
 947 #define ICV_FIX_SHIFT  15
 948 #define ICV_SCALE(x)   (((x) + (1 << (ICV_FIX_SHIFT-1))) >> ICV_FIX_SHIFT)
 949
 950 static CvStatus CV_STDCALL
 951 icvCvtScaleAbsTo_8u_C1R( const uchar* src, int srcstep,
 952                          uchar* dst, int dststep,
 953                          CvSize size, double scale, double shift,
 954                          int param )
 955 {
 956     int srctype = param;
 957     int srcdepth = CV_MAT_DEPTH(srctype);
 958
 959     size.width *= CV_MAT_CN(srctype);
 960
 961     switch( srcdepth )
 962     {
 963     case  CV_8S:
 964     case  CV_8U:
 965         {
 966         uchar lut[256];
 967         int i;
 968         double val = shift;
 969
 970         for( i = 0; i < 128; i++, val += scale )
 971         {
 972             int t = cvRound(fabs(val));
 973             lut[i] = CV_CAST_8U(t);
 974         }
 975
 976         if( srcdepth == CV_8S )
 977             val = -val;
 978
 979         for( ; i < 256; i++, val += scale )
 980         {
 981             int t = cvRound(fabs(val));
 982             lut[i] = CV_CAST_8U(t);
 983         }
 984
 985         icvLUT_Transform8u_8u_C1R( src, srcstep, dst,
 986                                    dststep, size, lut );
 987         }
 988         break;
 989     case  CV_16U:
 990         if( fabs( scale ) <= 1. && fabs(shift) < DBL_EPSILON )
 991         {
 992             int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));
 993
 994             if( iscale == ICV_FIX_SHIFT )
 995             {
 996                 ICV_DEF_CVT_SCALE_ABS_CASE( ushort, int, CV_NOP, CV_IABS,
 997                                             CV_CAST_8U, 1, 0 );
 998             }
 999             else
1000             {
1001                 ICV_DEF_CVT_SCALE_ABS_CASE( ushort, int, ICV_SCALE, CV_IABS,
1002                                             CV_CAST_8U, iscale, 0 );
1003             }
1004         }
1005         else
1006         {
1007             ICV_DEF_CVT_SCALE_ABS_CASE( ushort, int, cvRound, CV_IABS,
1008                                         CV_CAST_8U, scale, shift );
1009         }
1010         break;
1011     case  CV_16S:
1012         if( fabs( scale ) <= 1. &&
1013             fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT))
1014         {
1015             int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));
1016             int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT));
1017
1018             if( iscale == ICV_FIX_SHIFT && ishift == 0 )
1019             {
1020                 ICV_DEF_CVT_SCALE_ABS_CASE( short, int, CV_NOP, CV_IABS,
1021                                             CV_CAST_8U, 1, 0 );
1022             }
1023             else
1024             {
1025                 ICV_DEF_CVT_SCALE_ABS_CASE( short, int, ICV_SCALE, CV_IABS,
1026                                             CV_CAST_8U, iscale, ishift );
1027             }
1028         }
1029         else
1030         {
1031             ICV_DEF_CVT_SCALE_ABS_CASE( short, int, cvRound, CV_IABS,
1032                                         CV_CAST_8U, scale, shift );
1033         }
1034         break;
1035     case  CV_32S:
1036         ICV_DEF_CVT_SCALE_ABS_CASE( int, int, cvRound, CV_IABS,
1037                                     CV_CAST_8U, scale, shift );
1038         break;
1039     case  CV_32F:
1040         ICV_DEF_CVT_SCALE_ABS_CASE( float, int, cvRound, CV_IABS,
1041                                     CV_CAST_8U, scale, shift );
1042         break;
1043     case  CV_64F:
1044         ICV_DEF_CVT_SCALE_ABS_CASE( double, int, cvRound, CV_IABS,
1045                                     CV_CAST_8U, scale, shift );
1046         break;
1047     default:
1048         assert(0);
1049         return CV_BADFLAG_ERR;
1050     }
1051
1052     return  CV_OK;
1053 }
1054
1055
1056 CV_IMPL void
1057 cvConvertScaleAbs( const void* srcarr, void* dstarr,
1058                    double scale, double shift )
1059 {
1060     CV_FUNCNAME( "cvConvertScaleAbs" );
1061
1062     __BEGIN__;
1063
1064     int coi1 = 0, coi2 = 0;
1065     CvMat  srcstub, *src = (CvMat*)srcarr;
1066     CvMat  dststub, *dst = (CvMat*)dstarr;
1067     CvSize size;
1068     int src_step, dst_step;
1069
1070     CV_CALL( src = cvGetMat( src, &srcstub, &coi1 ));
1071     CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 ));
1072
1073     if( coi1 != 0 || coi2 != 0 )
1074         CV_ERROR( CV_BadCOI, "" );
1075
1076     if( !CV_ARE_SIZES_EQ( src, dst ))
1077         CV_ERROR( CV_StsUnmatchedSizes, "" );
1078
1079     if( !CV_ARE_CNS_EQ( src, dst ))
1080         CV_ERROR( CV_StsUnmatchedFormats, "" );
1081
1082     if( CV_MAT_DEPTH( dst->type ) != CV_8U )
1083         CV_ERROR( CV_StsUnsupportedFormat, "" );
1084
1085     size = cvGetMatSize( src );
1086     src_step = src->step;
1087     dst_step = dst->step;
1088
1089     if( CV_IS_MAT_CONT( src->type & dst->type ))
1090     {
1091         size.width *= size.height;
1092         src_step = dst_step = CV_STUB_STEP;
1093         size.height = 1;
1094     }
1095
1096     IPPI_CALL( icvCvtScaleAbsTo_8u_C1R( src->data.ptr, src_step,
1097                              (uchar*)(dst->data.ptr), dst_step,
1098                              size, scale, shift, CV_MAT_TYPE(src->type)));
1099     __END__;
1100 }
1101
1102 /****************************************************************************************\
1103 *                                      cvConvertScale                                    *
1104 \****************************************************************************************/
1105
1106 #define ICV_DEF_CVT_SCALE_CASE( srctype, worktype,          \
1107                             scale_macro, cast_macro, a, b ) \
1108                                                             \
1109 {                                                           \
1110     const srctype* _src = (const srctype*)src;              \
1111     srcstep /= sizeof(_src[0]);                             \
1112                                                             \
1113     for( ; size.height--; _src += srcstep, dst += dststep ) \
1114     {                                                       \
1115         for( i = 0; i <= size.width - 4; i += 4 )           \
1116         {                                                   \
1117             worktype t0 = scale_macro((a)*_src[i]+(b));     \
1118             worktype t1 = scale_macro((a)*_src[i+1]+(b));   \
1119                                                             \
1120             dst[i] = cast_macro(t0);                        \
1121             dst[i+1] = cast_macro(t1);                      \
1122                                                             \
1123             t0 = scale_macro((a)*_src[i+2] + (b));          \
1124             t1 = scale_macro((a)*_src[i+3] + (b));          \
1125                                                             \
1126             dst[i+2] = cast_macro(t0);                      \
1127             dst[i+3] = cast_macro(t1);                      \
1128         }                                                   \
1129                                                             \
1130         for( ; i < size.width; i++ )                        \
1131         {                                                   \
1132             worktype t0 = scale_macro((a)*_src[i] + (b));   \
1133             dst[i] = cast_macro(t0);                        \
1134         }                                                   \
1135     }                                                       \
1136 }
1137
1138
1139 #define  ICV_DEF_CVT_SCALE_FUNC_INT( flavor, dsttype, cast_macro )      \
1140 static  CvStatus  CV_STDCALL                                            \
1141 icvCvtScaleTo_##flavor##_C1R( const uchar* src, int srcstep,            \
1142                               dsttype* dst, int dststep, CvSize size,   \
1143                               double scale, double shift, int param )   \
1144 {                                                                       \
1145     int i, srctype = param;                                             \
1146     dsttype lut[256];                                                   \
1147     dststep /= sizeof(dst[0]);                                          \
1148                                                                         \
1149     switch( CV_MAT_DEPTH(srctype) )                                     \
1150     {                                                                   \
1151     case  CV_8U:                                                        \
1152         if( size.width*size.height >= 256 )                             \
1153         {                                                               \
1154             double val = shift;                                         \
1155             for( i = 0; i < 256; i++, val += scale )                    \
1156             {                                                           \
1157                 int t = cvRound(val);                                   \
1158                 lut[i] = cast_macro(t);                                 \
1159             }                                                           \
1160                                                                         \
1161             icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst,       \
1162                                 dststep*sizeof(dst[0]), size, lut );    \
1163         }                                                               \
1164         else if( fabs( scale ) <= 128. &&                               \
1165                  fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT))   \
1166         {                                                               \
1167             int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));           \
1168             int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT));           \
1169                                                                         \
1170             ICV_DEF_CVT_SCALE_CASE( uchar, int, ICV_SCALE,              \
1171                                     cast_macro, iscale, ishift );       \
1172         }                                                               \
1173         else                                                            \
1174         {                                                               \
1175             ICV_DEF_CVT_SCALE_CASE( uchar, int, cvRound,                \
1176                                     cast_macro, scale, shift );         \
1177         }                                                               \
1178         break;                                                          \
1179     case  CV_8S:                                                        \
1180         if( size.width*size.height >= 256 )                             \
1181         {                                                               \
1182             for( i = 0; i < 256; i++ )                                  \
1183             {                                                           \
1184                 int t = cvRound( (schar)i*scale + shift );              \
1185                 lut[i] = cast_macro(t);                                 \
1186             }                                                           \
1187                                                                         \
1188             icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst,       \
1189                                 dststep*sizeof(dst[0]), size, lut );    \
1190         }                                                               \
1191         else if( fabs( scale ) <= 128. &&                               \
1192                  fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT))   \
1193         {                                                               \
1194             int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));           \
1195             int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT));           \
1196                                                                         \
1197             ICV_DEF_CVT_SCALE_CASE( schar, int, ICV_SCALE,              \
1198                                     cast_macro, iscale, ishift );       \
1199         }                                                               \
1200         else                                                            \
1201         {                                                               \
1202             ICV_DEF_CVT_SCALE_CASE( schar, int, cvRound,                \
1203                                     cast_macro, scale, shift );         \
1204         }                                                               \
1205         break;                                                          \
1206     case  CV_16U:                                                       \
1207         if( fabs( scale ) <= 1. && fabs(shift) < DBL_EPSILON )          \
1208         {                                                               \
1209             int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));           \
1210                                                                         \
1211             ICV_DEF_CVT_SCALE_CASE( ushort, int, ICV_SCALE,             \
1212                                     cast_macro, iscale, 0 );            \
1213         }                                                               \
1214         else                                                            \
1215         {                                                               \
1216             ICV_DEF_CVT_SCALE_CASE( ushort, int, cvRound,               \
1217                                     cast_macro, scale, shift );         \
1218         }                                                               \
1219         break;                                                          \
1220     case  CV_16S:                                                       \
1221         if( fabs( scale ) <= 1. &&                                      \
1222             fabs( shift ) <= (INT_MAX*0.5)/(1 << ICV_FIX_SHIFT))        \
1223         {                                                               \
1224             int iscale = cvRound(scale*(1 << ICV_FIX_SHIFT));           \
1225             int ishift = cvRound(shift*(1 << ICV_FIX_SHIFT));           \
1226                                                                         \
1227             ICV_DEF_CVT_SCALE_CASE( short, int, ICV_SCALE,              \
1228                                     cast_macro, iscale, ishift );       \
1229         }                                                               \
1230         else                                                            \
1231         {                                                               \
1232             ICV_DEF_CVT_SCALE_CASE( short, int, cvRound,                \
1233                                     cast_macro, scale, shift );         \
1234         }                                                               \
1235         break;                                                          \
1236     case  CV_32S:                                                       \
1237         ICV_DEF_CVT_SCALE_CASE( int, int, cvRound,                      \
1238                                 cast_macro, scale, shift );             \
1239         break;                                                          \
1240     case  CV_32F:                                                       \
1241         ICV_DEF_CVT_SCALE_CASE( float, int, cvRound,                    \
1242                                 cast_macro, scale, shift );             \
1243         break;                                                          \
1244     case  CV_64F:                                                       \
1245         ICV_DEF_CVT_SCALE_CASE( double, int, cvRound,                   \
1246                                 cast_macro, scale, shift );             \
1247         break;                                                          \
1248     default:                                                            \
1249         assert(0);                                                      \
1250         return CV_BADFLAG_ERR;                                          \
1251     }                                                                   \
1252                                                                         \
1253     return  CV_OK;                                                      \
1254 }
1255
1256
1257 #define  ICV_DEF_CVT_SCALE_FUNC_FLT( flavor, dsttype, cast_macro )      \
1258 static  CvStatus  CV_STDCALL                                            \
1259 icvCvtScaleTo_##flavor##_C1R( const uchar* src, int srcstep,            \
1260                               dsttype* dst, int dststep, CvSize size,   \
1261                               double scale, double shift, int param )   \
1262 {                                                                       \
1263     int i, srctype = param;                                             \
1264     dsttype lut[256];                                                   \
1265     dststep /= sizeof(dst[0]);                                          \
1266                                                                         \
1267     switch( CV_MAT_DEPTH(srctype) )                                     \
1268     {                                                                   \
1269     case  CV_8U:                                                        \
1270         if( size.width*size.height >= 256 )                             \
1271         {                                                               \
1272             double val = shift;                                         \
1273             for( i = 0; i < 256; i++, val += scale )                    \
1274                 lut[i] = (dsttype)val;                                  \
1275                                                                         \
1276             icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst,       \
1277                                 dststep*sizeof(dst[0]), size, lut );    \
1278         }                                                               \
1279         else                                                            \
1280         {                                                               \
1281             ICV_DEF_CVT_SCALE_CASE( uchar, double, CV_NOP,              \
1282                                     cast_macro, scale, shift );         \
1283         }                                                               \
1284         break;                                                          \
1285     case  CV_8S:                                                        \
1286         if( size.width*size.height >= 256 )                             \
1287         {                                                               \
1288             for( i = 0; i < 256; i++ )                                  \
1289                 lut[i] = (dsttype)((schar)i*scale + shift);             \
1290                                                                         \
1291             icvLUT_Transform8u_##flavor##_C1R( src, srcstep, dst,       \
1292                                 dststep*sizeof(dst[0]), size, lut );    \
1293         }                                                               \
1294         else                                                            \
1295         {                                                               \
1296             ICV_DEF_CVT_SCALE_CASE( schar, double, CV_NOP,              \
1297                                     cast_macro, scale, shift );         \
1298         }                                                               \
1299         break;                                                          \
1300     case  CV_16U:                                                       \
1301         ICV_DEF_CVT_SCALE_CASE( ushort, double, CV_NOP,                 \
1302                                 cast_macro, scale, shift );             \
1303         break;                                                          \
1304     case  CV_16S:                                                       \
1305         ICV_DEF_CVT_SCALE_CASE( short, double, CV_NOP,                  \
1306                                 cast_macro, scale, shift );             \
1307         break;                                                          \
1308     case  CV_32S:                                                       \
1309         ICV_DEF_CVT_SCALE_CASE( int, double, CV_NOP,                    \
1310                                 cast_macro, scale, shift );             \
1311         break;                                                          \
1312     case  CV_32F:                                                       \
1313         ICV_DEF_CVT_SCALE_CASE( float, double, CV_NOP,                  \
1314                                 cast_macro, scale, shift );             \
1315         break;                                                          \
1316     case  CV_64F:                                                       \
1317         ICV_DEF_CVT_SCALE_CASE( double, double, CV_NOP,                 \
1318                                 cast_macro, scale, shift );             \
1319         break;                                                          \
1320     default:                                                            \
1321         assert(0);                                                      \
1322         return CV_BADFLAG_ERR;                                          \
1323     }                                                                   \
1324                                                                         \
1325     return  CV_OK;                                                      \
1326 }
1327
1328
1329 ICV_DEF_CVT_SCALE_FUNC_INT( 8u, uchar, CV_CAST_8U )
1330 ICV_DEF_CVT_SCALE_FUNC_INT( 8s, schar, CV_CAST_8S )
1331 ICV_DEF_CVT_SCALE_FUNC_INT( 16s, short, CV_CAST_16S )
1332 ICV_DEF_CVT_SCALE_FUNC_INT( 16u, ushort, CV_CAST_16U )
1333 ICV_DEF_CVT_SCALE_FUNC_INT( 32s, int, CV_CAST_32S )
1334
1335 ICV_DEF_CVT_SCALE_FUNC_FLT( 32f, float, CV_CAST_32F )
1336 ICV_DEF_CVT_SCALE_FUNC_FLT( 64f, double, CV_CAST_64F )
1337
1338 CV_DEF_INIT_FUNC_TAB_2D( CvtScaleTo, C1R )
1339
1340
1341 /****************************************************************************************\
1342 *                             Conversion w/o scaling macros                              *
1343 \****************************************************************************************/
1344
1345 #define ICV_DEF_CVT_CASE_2D( srctype, worktype,             \
1346                              cast_macro1, cast_macro2 )     \
1347 {                                                           \
1348     const srctype* _src = (const srctype*)src;              \
1349     srcstep /= sizeof(_src[0]);                             \
1350                                                             \
1351     for( ; size.height--; _src += srcstep, dst += dststep ) \
1352     {                                                       \
1353         int i;                                              \
1354                                                             \
1355         for( i = 0; i <= size.width - 4; i += 4 )           \
1356         {                                                   \
1357             worktype t0 = cast_macro1(_src[i]);             \
1358             worktype t1 = cast_macro1(_src[i+1]);           \
1359                                                             \
1360             dst[i] = cast_macro2(t0);                       \
1361             dst[i+1] = cast_macro2(t1);                     \
1362                                                             \
1363             t0 = cast_macro1(_src[i+2]);                    \
1364             t1 = cast_macro1(_src[i+3]);                    \
1365                                                             \
1366             dst[i+2] = cast_macro2(t0);                     \
1367             dst[i+3] = cast_macro2(t1);                     \
1368         }                                                   \
1369                                                             \
1370         for( ; i < size.width; i++ )                        \
1371         {                                                   \
1372             worktype t0 = cast_macro1(_src[i]);             \
1373             dst[i] = cast_macro2(t0);                       \
1374         }                                                   \
1375     }                                                       \
1376 }
1377
1378
1379 #define ICV_DEF_CVT_FUNC_2D( flavor, dsttype, worktype, cast_macro2,    \
1380                              srcdepth1, srctype1, cast_macro11,         \
1381                              srcdepth2, srctype2, cast_macro12,         \
1382                              srcdepth3, srctype3, cast_macro13,         \
1383                              srcdepth4, srctype4, cast_macro14,         \
1384                              srcdepth5, srctype5, cast_macro15,         \
1385                              srcdepth6, srctype6, cast_macro16 )        \
1386 static CvStatus CV_STDCALL                                              \
1387 icvCvtTo_##flavor##_C1R( const uchar* src, int srcstep,                 \
1388                          dsttype* dst, int dststep,                     \
1389                          CvSize size, int param )                       \
1390 {                                                                       \
1391     int srctype = param;                                                \
1392     dststep /= sizeof(dst[0]);                                          \
1393                                                                         \
1394     switch( CV_MAT_DEPTH(srctype) )                                     \
1395     {                                                                   \
1396     case srcdepth1:                                                     \
1397         ICV_DEF_CVT_CASE_2D( srctype1, worktype,                        \
1398                              cast_macro11, cast_macro2 );               \
1399         break;                                                          \
1400     case srcdepth2:                                                     \
1401         ICV_DEF_CVT_CASE_2D( srctype2, worktype,                        \
1402                              cast_macro12, cast_macro2 );               \
1403         break;                                                          \
1404     case srcdepth3:                                                     \
1405         ICV_DEF_CVT_CASE_2D( srctype3, worktype,                        \
1406                              cast_macro13, cast_macro2 );               \
1407         break;                                                          \
1408     case srcdepth4:                                                     \
1409         ICV_DEF_CVT_CASE_2D( srctype4, worktype,                        \
1410                              cast_macro14, cast_macro2 );               \
1411         break;                                                          \
1412     case srcdepth5:                                                     \
1413         ICV_DEF_CVT_CASE_2D( srctype5, worktype,                        \
1414                              cast_macro15, cast_macro2 );               \
1415         break;                                                          \
1416     case srcdepth6:                                                     \
1417         ICV_DEF_CVT_CASE_2D( srctype6, worktype,                        \
1418                              cast_macro16, cast_macro2 );               \
1419         break;                                                          \
1420     }                                                                   \
1421                                                                         \
1422     return  CV_OK;                                                      \
1423 }
1424
1425
1426 ICV_DEF_CVT_FUNC_2D( 8u, uchar, int, CV_CAST_8U,
1427                      CV_8S,  schar,  CV_NOP,
1428                      CV_16U, ushort, CV_NOP,
1429                      CV_16S, short,  CV_NOP,
1430                      CV_32S, int,    CV_NOP,
1431                      CV_32F, float,  cvRound,
1432                      CV_64F, double, cvRound )
1433
1434 ICV_DEF_CVT_FUNC_2D( 8s, schar, int, CV_CAST_8S,
1435                      CV_8U,  uchar,  CV_NOP,
1436                      CV_16U, ushort, CV_NOP,
1437                      CV_16S, short,  CV_NOP,
1438                      CV_32S, int,    CV_NOP,
1439                      CV_32F, float,  cvRound,
1440                      CV_64F, double, cvRound )
1441
1442 ICV_DEF_CVT_FUNC_2D( 16u, ushort, int, CV_CAST_16U,
1443                      CV_8U,  uchar,  CV_NOP,
1444                      CV_8S,  schar,  CV_NOP,
1445                      CV_16S, short,  CV_NOP,
1446                      CV_32S, int,    CV_NOP,
1447                      CV_32F, float,  cvRound,
1448                      CV_64F, double, cvRound )
1449
1450 ICV_DEF_CVT_FUNC_2D( 16s, short, int, CV_CAST_16S,
1451                      CV_8U,  uchar,  CV_NOP,
1452                      CV_8S,  schar,  CV_NOP,
1453                      CV_16U, ushort, CV_NOP,
1454                      CV_32S, int,    CV_NOP,
1455                      CV_32F, float,  cvRound,
1456                      CV_64F, double, cvRound )
1457
1458 ICV_DEF_CVT_FUNC_2D( 32s, int, int, CV_NOP,
1459                      CV_8U,  uchar,  CV_NOP,
1460                      CV_8S,  schar,  CV_NOP,
1461                      CV_16U, ushort, CV_NOP,
1462                      CV_16S, short,  CV_NOP,
1463                      CV_32F, float,  cvRound,
1464                      CV_64F, double, cvRound )
1465
1466 ICV_DEF_CVT_FUNC_2D( 32f, float, float, CV_NOP,
1467                      CV_8U,  uchar,  CV_8TO32F,
1468                      CV_8S,  schar,  CV_8TO32F,
1469                      CV_16U, ushort, CV_NOP,
1470                      CV_16S, short,  CV_NOP,
1471                      CV_32S, int,    CV_CAST_32F,
1472                      CV_64F, double, CV_CAST_32F )
1473
1474 ICV_DEF_CVT_FUNC_2D( 64f, double, double, CV_NOP,
1475                      CV_8U,  uchar,  CV_8TO32F,
1476                      CV_8S,  schar,  CV_8TO32F,
1477                      CV_16U, ushort, CV_NOP,
1478                      CV_16S, short,  CV_NOP,
1479                      CV_32S, int,    CV_NOP,
1480                      CV_32F, float,  CV_NOP )
1481
1482 CV_DEF_INIT_FUNC_TAB_2D( CvtTo, C1R )
1483
1484
1485 typedef  CvStatus (CV_STDCALL *CvCvtFunc)( const void* src, int srcstep,
1486                                            void* dst, int dststep, CvSize size,
1487                                            int param );
1488
1489 typedef  CvStatus (CV_STDCALL *CvCvtScaleFunc)( const void* src, int srcstep,
1490                                              void* dst, int dststep, CvSize size,
1491                                              double scale, double shift,
1492                                              int param );
1493
1494 CV_IMPL void
1495 cvConvertScale( const void* srcarr, void* dstarr,
1496                 double scale, double shift )
1497 {
1498     static CvFuncTable cvt_tab, cvtscale_tab;
1499     static int inittab = 0;
1500
1501     CV_FUNCNAME( "cvConvertScale" );
1502
1503     __BEGIN__;
1504
1505     int type;
1506     int is_nd = 0;
1507     CvMat  srcstub, *src = (CvMat*)srcarr;
1508     CvMat  dststub, *dst = (CvMat*)dstarr;
1509     CvSize size;
1510     int src_step, dst_step;
1511     int no_scale = scale == 1 && shift == 0;
1512
1513     if( !CV_IS_MAT(src) )
1514     {
1515         if( CV_IS_MATND(src) )
1516             is_nd = 1;
1517         else
1518         {
1519             int coi = 0;
1520             CV_CALL( src = cvGetMat( src, &srcstub, &coi ));
1521
1522             if( coi != 0 )
1523                 CV_ERROR( CV_BadCOI, "" );
1524         }
1525     }
1526
1527     if( !CV_IS_MAT(dst) )
1528     {
1529         if( CV_IS_MATND(dst) )
1530             is_nd = 1;
1531         else
1532         {
1533             int coi = 0;
1534             CV_CALL( dst = cvGetMat( dst, &dststub, &coi ));
1535
1536             if( coi != 0 )
1537                 CV_ERROR( CV_BadCOI, "" );
1538         }
1539     }
1540
1541     if( is_nd )
1542     {
1543         CvArr* arrs[] = { src, dst };
1544         CvMatND stubs[2];
1545         CvNArrayIterator iterator;
1546         int dsttype;
1547
1548         CV_CALL( cvInitNArrayIterator( 2, arrs, 0, stubs, &iterator, CV_NO_DEPTH_CHECK ));
1549
1550         type = iterator.hdr[0]->type;
1551         dsttype = iterator.hdr[1]->type;
1552         iterator.size.width *= CV_MAT_CN(type);
1553
1554         if( !inittab )
1555         {
1556             icvInitCvtToC1RTable( &cvt_tab );
1557             icvInitCvtScaleToC1RTable( &cvtscale_tab );
1558             inittab = 1;
1559         }
1560
1561         if( no_scale )
1562         {
1563             CvCvtFunc func = (CvCvtFunc)(cvt_tab.fn_2d[CV_MAT_DEPTH(dsttype)]);
1564             if( !func )
1565                 CV_ERROR( CV_StsUnsupportedFormat, "" );
1566
1567             do
1568             {
1569                 IPPI_CALL( func( iterator.ptr[0], CV_STUB_STEP,
1570                                  iterator.ptr[1], CV_STUB_STEP,
1571                                  iterator.size, type ));
1572             }
1573             while( cvNextNArraySlice( &iterator ));
1574         }
1575         else
1576         {
1577             CvCvtScaleFunc func =
1578                 (CvCvtScaleFunc)(cvtscale_tab.fn_2d[CV_MAT_DEPTH(dsttype)]);
1579             if( !func )
1580                 CV_ERROR( CV_StsUnsupportedFormat, "" );
1581
1582             do
1583             {
1584                 IPPI_CALL( func( iterator.ptr[0], CV_STUB_STEP,
1585                                  iterator.ptr[1], CV_STUB_STEP,
1586                                  iterator.size, scale, shift, type ));
1587             }
1588             while( cvNextNArraySlice( &iterator ));
1589         }
1590         EXIT;
1591     }
1592
1593     if( no_scale && CV_ARE_TYPES_EQ( src, dst ) )
1594     {
1595         if( src != dst )
1596           cvCopy( src, dst );
1597         EXIT;
1598     }
1599
1600     if( !CV_ARE_SIZES_EQ( src, dst ))
1601         CV_ERROR( CV_StsUnmatchedSizes, "" );
1602
1603     size = cvGetMatSize( src );
1604     type = CV_MAT_TYPE(src->type);
1605     src_step = src->step;
1606     dst_step = dst->step;
1607
1608     if( CV_IS_MAT_CONT( src->type & dst->type ))
1609     {
1610         size.width *= size.height;
1611         src_step = dst_step = CV_STUB_STEP;
1612         size.height = 1;
1613     }
1614
1615     size.width *= CV_MAT_CN( type );
1616
1617     if( CV_ARE_TYPES_EQ( src, dst ) && size.height == 1 &&
1618         size.width <= CV_MAX_INLINE_MAT_OP_SIZE )
1619     {
1620         if( CV_MAT_DEPTH(type) == CV_32F )
1621         {
1622             const float* srcdata = (const float*)(src->data.ptr);
1623             float* dstdata = (float*)(dst->data.ptr);
1624
1625             do
1626             {
1627                 dstdata[size.width - 1] = (float)(srcdata[size.width-1]*scale + shift);
1628             }
1629             while( --size.width );
1630
1631             EXIT;
1632         }
1633
1634         if( CV_MAT_DEPTH(type) == CV_64F )
1635         {
1636             const double* srcdata = (const double*)(src->data.ptr);
1637             double* dstdata = (double*)(dst->data.ptr);
1638
1639             do
1640             {
1641                 dstdata[size.width - 1] = srcdata[size.width-1]*scale + shift;
1642             }
1643             while( --size.width );
1644
1645             EXIT;
1646         }
1647     }
1648
1649     if( !inittab )
1650     {
1651         icvInitCvtToC1RTable( &cvt_tab );
1652         icvInitCvtScaleToC1RTable( &cvtscale_tab );
1653         inittab = 1;
1654     }
1655
1656     if( !CV_ARE_CNS_EQ( src, dst ))
1657         CV_ERROR( CV_StsUnmatchedFormats, "" );
1658
1659     if( no_scale )
1660     {
1661         CvCvtFunc func = (CvCvtFunc)(cvt_tab.fn_2d[CV_MAT_DEPTH(dst->type)]);
1662
1663         if( !func )
1664             CV_ERROR( CV_StsUnsupportedFormat, "" );
1665
1666         IPPI_CALL( func( src->data.ptr, src_step,
1667                    dst->data.ptr, dst_step, size, type ));
1668     }
1669     else
1670     {
1671         CvCvtScaleFunc func = (CvCvtScaleFunc)
1672             (cvtscale_tab.fn_2d[CV_MAT_DEPTH(dst->type)]);
1673
1674         if( !func )
1675             CV_ERROR( CV_StsUnsupportedFormat, "" );
1676
1677         IPPI_CALL( func( src->data.ptr, src_step,
1678                    dst->data.ptr, dst_step, size,
1679                    scale, shift, type ));
1680     }
1681
1682     __END__;
1683 }
1684
1685 /********************* helper functions for converting 32f<->64f ************************/
1686
1687 IPCVAPI_IMPL( CvStatus, icvCvt_32f64f,
1688     ( const float* src, double* dst, int len ), (src, dst, len) )
1689 {
1690     int i;
1691     for( i = 0; i <= len - 4; i += 4 )
1692     {
1693         double t0 = src[i];
1694         double t1 = src[i+1];
1695
1696         dst[i] = t0;
1697         dst[i+1] = t1;
1698
1699         t0 = src[i+2];
1700         t1 = src[i+3];
1701
1702         dst[i+2] = t0;
1703         dst[i+3] = t1;
1704     }
1705
1706     for( ; i < len; i++ )
1707         dst[i] = src[i];
1708
1709     return CV_OK;
1710 }
1711
1712
1713 IPCVAPI_IMPL( CvStatus, icvCvt_64f32f,
1714     ( const double* src, float* dst, int len ), (src, dst, len) )
1715 {
1716     int i = 0;
1717     for( ; i <= len - 4; i += 4 )
1718     {
1719         double t0 = src[i];
1720         double t1 = src[i+1];
1721
1722         dst[i] = (float)t0;
1723         dst[i+1] = (float)t1;
1724
1725         t0 = src[i+2];
1726         t1 = src[i+3];
1727
1728         dst[i+2] = (float)t0;
1729         dst[i+3] = (float)t1;
1730     }
1731
1732     for( ; i < len; i++ )
1733         dst[i] = (float)src[i];
1734
1735     return CV_OK;
1736 }
1737
1738
1739 CvStatus CV_STDCALL icvScale_32f( const float* src, float* dst, int len, float a, float b )
1740 {
1741     int i;
1742     for( i = 0; i <= len - 4; i += 4 )
1743     {
1744         double t0 = src[i]*a + b;
1745         double t1 = src[i+1]*a + b;
1746
1747         dst[i] = (float)t0;
1748         dst[i+1] = (float)t1;
1749
1750         t0 = src[i+2]*a + b;
1751         t1 = src[i+3]*a + b;
1752
1753         dst[i+2] = (float)t0;
1754         dst[i+3] = (float)t1;
1755     }
1756
1757     for( ; i < len; i++ )
1758         dst[i] = (float)(src[i]*a + b);
1759
1760     return CV_OK;
1761 }
1762
1763
1764 CvStatus CV_STDCALL icvScale_64f( const double* src, double* dst, int len, double a, double b )
1765 {
1766     int i;
1767     for( i = 0; i <= len - 4; i += 4 )
1768     {
1769         double t0 = src[i]*a + b;
1770         double t1 = src[i+1]*a + b;
1771
1772         dst[i] = t0;
1773         dst[i+1] = t1;
1774
1775         t0 = src[i+2]*a + b;
1776         t1 = src[i+3]*a + b;
1777
1778         dst[i+2] = t0;
1779         dst[i+3] = t1;
1780     }
1781
1782     for( ; i < len; i++ )
1783         dst[i] = src[i]*a + b;
1784
1785     return CV_OK;
1786 }
1787
1788 /* End of file. */