vcs.maemo.org Git - opencv/blob - cv/src/cvcolor.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 //                        Intel License Agreement
  10 //                For Open Source Computer Vision Library
  11 //
  12 // Copyright (C) 2000, Intel Corporation, all rights reserved.
  13 // Third party copyrights are property of their respective owners.
  14 //
  15 // Redistribution and use in source and binary forms, with or without modification,
  16 // are permitted provided that the following conditions are met:
  17 //
  18 //   * Redistribution's of source code must retain the above copyright notice,
  19 //     this list of conditions and the following disclaimer.
  20 //
  21 //   * Redistribution's in binary form must reproduce the above copyright notice,
  22 //     this list of conditions and the following disclaimer in the documentation
  23 //     and/or other materials provided with the distribution.
  24 //
  25 //   * The name of Intel Corporation may not be used to endorse or promote products
  26 //     derived from this software without specific prior written permission.
  27 //
  28 // This software is provided by the copyright holders and contributors "as is" and
  29 // any express or implied warranties, including, but not limited to, the implied
  30 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  31 // In no event shall the Intel Corporation or contributors be liable for any direct,
  32 // indirect, incidental, special, exemplary, or consequential damages
  33 // (including, but not limited to, procurement of substitute goods or services;
  34 // loss of use, data, or profits; or business interruption) however caused
  35 // and on any theory of liability, whether in contract, strict liability,
  36 // or tort (including negligence or otherwise) arising in any way out of
  37 // the use of this software, even if advised of the possibility of such damage.
  38 //
  39 //M*/
  40
  41 /********************************* COPYRIGHT NOTICE *******************************\
  42   The function for RGB to Lab conversion is based on the MATLAB script
  43   RGB2Lab.m translated by Mark Ruzon from C code by Yossi Rubner, 23 September 1997.
  44   See the page [http://vision.stanford.edu/~ruzon/software/rgblab.html]
  45 \**********************************************************************************/
  46
  47 /********************************* COPYRIGHT NOTICE *******************************\
  48   Original code for Bayer->BGR/RGB conversion is provided by Dirk Schaefer
  49   from MD-Mathematische Dienste GmbH. Below is the copyright notice:
  50
  51     IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
  52     By downloading, copying, installing or using the software you agree
  53     to this license. If you do not agree to this license, do not download,
  54     install, copy or use the software.
  55
  56     Contributors License Agreement:
  57
  58       Copyright (c) 2002,
  59       MD-Mathematische Dienste GmbH
  60       Im Defdahl 5-10
  61       44141 Dortmund
  62       Germany
  63       www.md-it.de
  64
  65     Redistribution and use in source and binary forms,
  66     with or without modification, are permitted provided
  67     that the following conditions are met:
  68
  69     Redistributions of source code must retain
  70     the above copyright notice, this list of conditions and the following disclaimer.
  71     Redistributions in binary form must reproduce the above copyright notice,
  72     this list of conditions and the following disclaimer in the documentation
  73     and/or other materials provided with the distribution.
  74     The name of Contributor may not be used to endorse or promote products
  75     derived from this software without specific prior written permission.
  76
  77     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  78     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  79     THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  80     PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
  81     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  82     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  83     OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  84     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  85     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  86     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  87     THE POSSIBILITY OF SUCH DAMAGE.
  88 \**********************************************************************************/
  89
  90 #include "_cv.h"
  91
  92 typedef CvStatus (CV_STDCALL * CvColorCvtFunc0)(
  93     const void* src, int srcstep, void* dst, int dststep, CvSize size );
  94
  95 typedef CvStatus (CV_STDCALL * CvColorCvtFunc1)(
  96     const void* src, int srcstep, void* dst, int dststep,
  97     CvSize size, int param0 );
  98
  99 typedef CvStatus (CV_STDCALL * CvColorCvtFunc2)(
 100     const void* src, int srcstep, void* dst, int dststep,
 101     CvSize size, int param0, int param1 );
 102
 103 typedef CvStatus (CV_STDCALL * CvColorCvtFunc3)(
 104     const void* src, int srcstep, void* dst, int dststep,
 105     CvSize size, int param0, int param1, int param2 );
 106
 107 /****************************************************************************************\
 108 *                 Various 3/4-channel to 3/4-channel RGB transformations                 *
 109 \****************************************************************************************/
 110
 111 #define CV_IMPL_BGRX2BGR( flavor, arrtype )                             \
 112 static CvStatus CV_STDCALL                                              \
 113 icvBGRx2BGR_##flavor##_CnC3R( const arrtype* src, int srcstep,          \
 114                               arrtype* dst, int dststep,                \
 115                               CvSize size, int src_cn, int blue_idx )   \
 116 {                                                                       \
 117     int i;                                                              \
 118                                                                         \
 119     srcstep /= sizeof(src[0]);                                          \
 120     dststep /= sizeof(dst[0]);                                          \
 121     srcstep -= size.width*src_cn;                                       \
 122     size.width *= 3;                                                    \
 123                                                                         \
 124     for( ; size.height--; src += srcstep, dst += dststep )              \
 125     {                                                                   \
 126         for( i = 0; i < size.width; i += 3, src += src_cn )             \
 127         {                                                               \
 128             arrtype t0=src[blue_idx], t1=src[1], t2=src[blue_idx^2];    \
 129             dst[i] = t0;                                                \
 130             dst[i+1] = t1;                                              \
 131             dst[i+2] = t2;                                              \
 132         }                                                               \
 133     }                                                                   \
 134                                                                         \
 135     return CV_OK;                                                       \
 136 }
 137
 138
 139 #define CV_IMPL_BGR2BGRX( flavor, arrtype )                             \
 140 static CvStatus CV_STDCALL                                              \
 141 icvBGR2BGRx_##flavor##_C3C4R( const arrtype* src, int srcstep,          \
 142                               arrtype* dst, int dststep,                \
 143                               CvSize size, int blue_idx )               \
 144 {                                                                       \
 145     int i;                                                              \
 146                                                                         \
 147     srcstep /= sizeof(src[0]);                                          \
 148     dststep /= sizeof(dst[0]);                                          \
 149     srcstep -= size.width*3;                                            \
 150     size.width *= 4;                                                    \
 151                                                                         \
 152     for( ; size.height--; src += srcstep, dst += dststep )              \
 153     {                                                                   \
 154         for( i = 0; i < size.width; i += 4, src += 3 )                  \
 155         {                                                               \
 156             arrtype t0=src[blue_idx], t1=src[1], t2=src[blue_idx^2];    \
 157             dst[i] = t0;                                                \
 158             dst[i+1] = t1;                                              \
 159             dst[i+2] = t2;                                              \
 160             dst[i+3] = 0;                                               \
 161         }                                                               \
 162     }                                                                   \
 163                                                                         \
 164     return CV_OK;                                                       \
 165 }
 166
 167
 168 #define CV_IMPL_BGRA2RGBA( flavor, arrtype )                            \
 169 static CvStatus CV_STDCALL                                              \
 170 icvBGRA2RGBA_##flavor##_C4R( const arrtype* src, int srcstep,           \
 171                              arrtype* dst, int dststep, CvSize size )   \
 172 {                                                                       \
 173     int i;                                                              \
 174                                                                         \
 175     srcstep /= sizeof(src[0]);                                          \
 176     dststep /= sizeof(dst[0]);                                          \
 177     size.width *= 4;                                                    \
 178                                                                         \
 179     for( ; size.height--; src += srcstep, dst += dststep )              \
 180     {                                                                   \
 181         for( i = 0; i < size.width; i += 4 )                            \
 182         {                                                               \
 183             arrtype t0 = src[2], t1 = src[1], t2 = src[0], t3 = src[3]; \
 184             dst[i] = t0;                                                \
 185             dst[i+1] = t1;                                              \
 186             dst[i+2] = t2;                                              \
 187             dst[i+3] = t3;                                              \
 188         }                                                               \
 189     }                                                                   \
 190                                                                         \
 191     return CV_OK;                                                       \
 192 }
 193
 194
 195 CV_IMPL_BGRX2BGR( 8u, uchar )
 196 CV_IMPL_BGRX2BGR( 16u, ushort )
 197 CV_IMPL_BGRX2BGR( 32f, int )
 198 CV_IMPL_BGR2BGRX( 8u, uchar )
 199 CV_IMPL_BGR2BGRX( 16u, ushort )
 200 CV_IMPL_BGR2BGRX( 32f, int )
 201 CV_IMPL_BGRA2RGBA( 8u, uchar )
 202 CV_IMPL_BGRA2RGBA( 16u, ushort )
 203 CV_IMPL_BGRA2RGBA( 32f, int )
 204
 205
 206 /****************************************************************************************\
 207 *           Transforming 16-bit (565 or 555) RGB to/from 24/32-bit (888[8]) RGB          *
 208 \****************************************************************************************/
 209
 210 static CvStatus CV_STDCALL
 211 icvBGR5x52BGRx_8u_C2CnR( const uchar* src, int srcstep,
 212                          uchar* dst, int dststep,
 213                          CvSize size, int dst_cn,
 214                          int blue_idx, int green_bits )
 215 {
 216     int i;
 217     assert( green_bits == 5 || green_bits == 6 );
 218     dststep -= size.width*dst_cn;
 219
 220     for( ; size.height--; src += srcstep, dst += dststep )
 221     {
 222         if( green_bits == 6 )
 223             for( i = 0; i < size.width; i++, dst += dst_cn )
 224             {
 225                 unsigned t = ((const ushort*)src)[i];
 226                 dst[blue_idx] = (uchar)(t << 3);
 227                 dst[1] = (uchar)((t >> 3) & ~3);
 228                 dst[blue_idx ^ 2] = (uchar)((t >> 8) & ~7);
 229                 if( dst_cn == 4 )
 230                     dst[3] = 0;
 231             }
 232         else
 233             for( i = 0; i < size.width; i++, dst += dst_cn )
 234             {
 235                 unsigned t = ((const ushort*)src)[i];
 236                 dst[blue_idx] = (uchar)(t << 3);
 237                 dst[1] = (uchar)((t >> 2) & ~7);
 238                 dst[blue_idx ^ 2] = (uchar)((t >> 7) & ~7);
 239                 if( dst_cn == 4 )
 240                     dst[3] = 0;
 241             }
 242     }
 243
 244     return CV_OK;
 245 }
 246
 247
 248 static CvStatus CV_STDCALL
 249 icvBGRx2BGR5x5_8u_CnC2R( const uchar* src, int srcstep,
 250                          uchar* dst, int dststep,
 251                          CvSize size, int src_cn,
 252                          int blue_idx, int green_bits )
 253 {
 254     int i;
 255     srcstep -= size.width*src_cn;
 256
 257     for( ; size.height--; src += srcstep, dst += dststep )
 258     {
 259         if( green_bits == 6 )
 260             for( i = 0; i < size.width; i++, src += src_cn )
 261             {
 262                 int t = (src[blue_idx] >> 3)|((src[1]&~3) << 3)|((src[blue_idx^2]&~7) << 8);
 263                 ((ushort*)dst)[i] = (ushort)t;
 264             }
 265         else
 266             for( i = 0; i < size.width; i++, src += src_cn )
 267             {
 268                 int t = (src[blue_idx] >> 3)|((src[1]&~7) << 2)|((src[blue_idx^2]&~7) << 7);
 269                 ((ushort*)dst)[i] = (ushort)t;
 270             }
 271     }
 272
 273     return CV_OK;
 274 }
 275
 276
 277
 278 /////////////////////////// IPP Color Conversion Functions //////////////////////////////
 279
 280 icvRGB2XYZ_8u_C3R_t  icvRGB2XYZ_8u_C3R_p = 0;
 281 icvRGB2XYZ_16u_C3R_t icvRGB2XYZ_16u_C3R_p = 0;
 282 icvRGB2XYZ_32f_C3R_t icvRGB2XYZ_32f_C3R_p = 0;
 283 icvXYZ2RGB_8u_C3R_t  icvXYZ2RGB_8u_C3R_p = 0;
 284 icvXYZ2RGB_16u_C3R_t icvXYZ2RGB_16u_C3R_p = 0;
 285 icvXYZ2RGB_32f_C3R_t icvXYZ2RGB_32f_C3R_p = 0;
 286
 287 icvRGB2HSV_8u_C3R_t  icvRGB2HSV_8u_C3R_p = 0;
 288 icvHSV2RGB_8u_C3R_t  icvHSV2RGB_8u_C3R_p = 0;
 289
 290 icvBGR2Lab_8u_C3R_t  icvBGR2Lab_8u_C3R_p = 0;
 291 icvLab2BGR_8u_C3R_t  icvLab2BGR_8u_C3R_p = 0;
 292
 293 icvRGB2HLS_8u_C3R_t  icvRGB2HLS_8u_C3R_p = 0;
 294 icvRGB2HLS_32f_C3R_t icvRGB2HLS_32f_C3R_p = 0;
 295 icvHLS2RGB_8u_C3R_t  icvHLS2RGB_8u_C3R_p = 0;
 296 icvHLS2RGB_32f_C3R_t icvHLS2RGB_32f_C3R_p = 0;
 297
 298 icvRGB2Luv_8u_C3R_t  icvRGB2Luv_8u_C3R_p = 0;
 299 icvLuv2RGB_8u_C3R_t  icvLuv2RGB_8u_C3R_p = 0;
 300
 301 //icvRGB2Luv_32f_C3R_t icvRGB2Luv_32f_C3R_p = 0;
 302 //icvLuv2RGB_32f_C3R_t icvLuv2RGB_32f_C3R_p = 0;
 303 //icvRGB2Luv_32f_C3R_t icvRGB2Luv_32f_C3R_p = 0;
 304 //icvLuv2RGB_32f_C3R_t icvLuv2RGB_32f_C3R_p = 0;
 305
 306
 307 #define CV_IMPL_BGRx2ABC_IPP( flavor, arrtype )                         \
 308 static CvStatus CV_STDCALL                                              \
 309 icvBGRx2ABC_IPP_##flavor##_CnC3R( const arrtype* src, int srcstep,      \
 310     arrtype* dst, int dststep, CvSize size, int src_cn,                 \
 311     int blue_idx, CvColorCvtFunc0 ipp_func )                            \
 312 {                                                                       \
 313     int block_size = MIN(1 << 14, size.width);                          \
 314     arrtype* buffer;                                                    \
 315     int i, di, k;                                                       \
 316     int do_copy = src_cn > 3 || blue_idx != 2 || src == dst;            \
 317     CvStatus status = CV_OK;                                            \
 318                                                                         \
 319     if( !do_copy )                                                      \
 320         return ipp_func( src, srcstep, dst, dststep, size );            \
 321                                                                         \
 322     srcstep /= sizeof(src[0]);                                          \
 323     dststep /= sizeof(dst[0]);                                          \
 324                                                                         \
 325     buffer = (arrtype*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );  \
 326     srcstep -= size.width*src_cn;                                       \
 327                                                                         \
 328     for( ; size.height--; src += srcstep, dst += dststep )              \
 329     {                                                                   \
 330         for( i = 0; i < size.width; i += block_size )                   \
 331         {                                                               \
 332             arrtype* dst1 = dst + i*3;                                  \
 333             di = MIN(block_size, size.width - i);                       \
 334                                                                         \
 335             for( k = 0; k < di*3; k += 3, src += src_cn )               \
 336             {                                                           \
 337                 arrtype b = src[blue_idx];                              \
 338                 arrtype g = src[1];                                     \
 339                 arrtype r = src[blue_idx^2];                            \
 340                 buffer[k] = r;                                          \
 341                 buffer[k+1] = g;                                        \
 342                 buffer[k+2] = b;                                        \
 343             }                                                           \
 344                                                                         \
 345             status = ipp_func( buffer, CV_STUB_STEP,                    \
 346                                dst1, CV_STUB_STEP, cvSize(di,1) );      \
 347             if( status < 0 )                                            \
 348                 return status;                                          \
 349         }                                                               \
 350     }                                                                   \
 351                                                                         \
 352     return CV_OK;                                                       \
 353 }
 354
 355
 356 static CvStatus CV_STDCALL
 357 icvBGRx2ABC_IPP_8u_CnC3R( const uchar* src, int srcstep,
 358     uchar* dst, int dststep, CvSize size, int src_cn,
 359     int blue_idx, CvColorCvtFunc0 ipp_func )
 360 {
 361     int block_size = MIN(1 << 14, size.width);
 362     uchar* buffer;
 363     int i, di, k;
 364     int do_copy = src_cn > 3 || blue_idx != 2 || src == dst;
 365     CvStatus status = CV_OK;
 366
 367     if( !do_copy )
 368         return ipp_func( src, srcstep, dst, dststep, size );
 369
 370     srcstep /= sizeof(src[0]);
 371     dststep /= sizeof(dst[0]);
 372
 373     buffer = (uchar*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
 374     srcstep -= size.width*src_cn;
 375
 376     for( ; size.height--; src += srcstep, dst += dststep )
 377     {
 378         for( i = 0; i < size.width; i += block_size )
 379         {
 380             uchar* dst1 = dst + i*3;
 381             di = MIN(block_size, size.width - i);
 382
 383             for( k = 0; k < di*3; k += 3, src += src_cn )
 384             {
 385                 uchar b = src[blue_idx];
 386                 uchar g = src[1];
 387                 uchar r = src[blue_idx^2];
 388                 buffer[k] = r;
 389                 buffer[k+1] = g;
 390                 buffer[k+2] = b;
 391             }
 392
 393             status = ipp_func( buffer, CV_STUB_STEP,
 394                                dst1, CV_STUB_STEP, cvSize(di,1) );
 395             if( status < 0 )
 396                 return status;
 397         }
 398     }
 399
 400     return CV_OK;
 401 }
 402
 403
 404
 405 //CV_IMPL_BGRx2ABC_IPP( 8u, uchar )
 406 CV_IMPL_BGRx2ABC_IPP( 16u, ushort )
 407 CV_IMPL_BGRx2ABC_IPP( 32f, float )
 408
 409 #define CV_IMPL_ABC2BGRx_IPP( flavor, arrtype )                         \
 410 static CvStatus CV_STDCALL                                              \
 411 icvABC2BGRx_IPP_##flavor##_C3CnR( const arrtype* src, int srcstep,      \
 412     arrtype* dst, int dststep, CvSize size, int dst_cn,                 \
 413     int blue_idx, CvColorCvtFunc0 ipp_func )                            \
 414 {                                                                       \
 415     int block_size = MIN(1 << 10, size.width);                          \
 416     arrtype* buffer;                                                    \
 417     int i, di, k;                                                       \
 418     int do_copy = dst_cn > 3 || blue_idx != 2 || src == dst;            \
 419     CvStatus status = CV_OK;                                            \
 420                                                                         \
 421     if( !do_copy )                                                      \
 422         return ipp_func( src, srcstep, dst, dststep, size );            \
 423                                                                         \
 424     srcstep /= sizeof(src[0]);                                          \
 425     dststep /= sizeof(dst[0]);                                          \
 426                                                                         \
 427     buffer = (arrtype*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );  \
 428     dststep -= size.width*dst_cn;                                       \
 429                                                                         \
 430     for( ; size.height--; src += srcstep, dst += dststep )              \
 431     {                                                                   \
 432         for( i = 0; i < size.width; i += block_size )                   \
 433         {                                                               \
 434             const arrtype* src1 = src + i*3;                            \
 435             di = MIN(block_size, size.width - i);                       \
 436                                                                         \
 437             status = ipp_func( src1, CV_STUB_STEP,                      \
 438                                buffer, CV_STUB_STEP, cvSize(di,1) );    \
 439             if( status < 0 )                                            \
 440                 return status;                                          \
 441                                                                         \
 442             for( k = 0; k < di*3; k += 3, dst += dst_cn )               \
 443             {                                                           \
 444                 arrtype r = buffer[k];                                  \
 445                 arrtype g = buffer[k+1];                                \
 446                 arrtype b = buffer[k+2];                                \
 447                 dst[blue_idx] = b;                                      \
 448                 dst[1] = g;                                             \
 449                 dst[blue_idx^2] = r;                                    \
 450                 if( dst_cn == 4 )                                       \
 451                     dst[3] = 0;                                         \
 452             }                                                           \
 453         }                                                               \
 454     }                                                                   \
 455                                                                         \
 456     return CV_OK;                                                       \
 457 }
 458
 459 CV_IMPL_ABC2BGRx_IPP( 8u, uchar )
 460 CV_IMPL_ABC2BGRx_IPP( 16u, ushort )
 461 CV_IMPL_ABC2BGRx_IPP( 32f, float )
 462
 463
 464 /////////////////////////////////////////////////////////////////////////////////////////
 465
 466
 467 /****************************************************************************************\
 468 *                                 Color to/from Grayscale                                *
 469 \****************************************************************************************/
 470
 471 #define fix(x,n)      (int)((x)*(1 << (n)) + 0.5)
 472 #define descale       CV_DESCALE
 473
 474 #define cscGr_32f  0.299f
 475 #define cscGg_32f  0.587f
 476 #define cscGb_32f  0.114f
 477
 478 /* BGR/RGB -> Gray */
 479 #define csc_shift  14
 480 #define cscGr  fix(cscGr_32f,csc_shift)
 481 #define cscGg  fix(cscGg_32f,csc_shift)
 482 #define cscGb  /*fix(cscGb_32f,csc_shift)*/ ((1 << csc_shift) - cscGr - cscGg)
 483
 484 #define CV_IMPL_GRAY2BGRX( flavor, arrtype )                    \
 485 static CvStatus CV_STDCALL                                      \
 486 icvGray2BGRx_##flavor##_C1CnR( const arrtype* src, int srcstep, \
 487                        arrtype* dst, int dststep, CvSize size,  \
 488                        int dst_cn )                             \
 489 {                                                               \
 490     int i;                                                      \
 491     srcstep /= sizeof(src[0]);                                  \
 492     dststep /= sizeof(src[0]);                                  \
 493     dststep -= size.width*dst_cn;                               \
 494                                                                 \
 495     for( ; size.height--; src += srcstep, dst += dststep )      \
 496     {                                                           \
 497         if( dst_cn == 3 )                                       \
 498             for( i = 0; i < size.width; i++, dst += 3 )         \
 499                 dst[0] = dst[1] = dst[2] = src[i];              \
 500         else                                                    \
 501             for( i = 0; i < size.width; i++, dst += 4 )         \
 502             {                                                   \
 503                 dst[0] = dst[1] = dst[2] = src[i];              \
 504                 dst[3] = 0;                                     \
 505             }                                                   \
 506     }                                                           \
 507                                                                 \
 508     return CV_OK;                                               \
 509 }
 510
 511
 512 CV_IMPL_GRAY2BGRX( 8u, uchar )
 513 CV_IMPL_GRAY2BGRX( 16u, ushort )
 514 CV_IMPL_GRAY2BGRX( 32f, float )
 515
 516
 517 static CvStatus CV_STDCALL
 518 icvBGR5x52Gray_8u_C2C1R( const uchar* src, int srcstep,
 519                          uchar* dst, int dststep,
 520                          CvSize size, int green_bits )
 521 {
 522     int i;
 523     assert( green_bits == 5 || green_bits == 6 );
 524
 525     for( ; size.height--; src += srcstep, dst += dststep )
 526     {
 527         if( green_bits == 6 )
 528             for( i = 0; i < size.width; i++ )
 529             {
 530                 int t = ((ushort*)src)[i];
 531                 t = ((t << 3) & 0xf8)*cscGb + ((t >> 3) & 0xfc)*cscGg +
 532                     ((t >> 8) & 0xf8)*cscGr;
 533                 dst[i] = (uchar)CV_DESCALE(t,csc_shift);
 534             }
 535         else
 536             for( i = 0; i < size.width; i++ )
 537             {
 538                 int t = ((ushort*)src)[i];
 539                 t = ((t << 3) & 0xf8)*cscGb + ((t >> 2) & 0xf8)*cscGg +
 540                     ((t >> 7) & 0xf8)*cscGr;
 541                 dst[i] = (uchar)CV_DESCALE(t,csc_shift);
 542             }
 543     }
 544
 545     return CV_OK;
 546 }
 547
 548
 549 static CvStatus CV_STDCALL
 550 icvGray2BGR5x5_8u_C1C2R( const uchar* src, int srcstep,
 551                          uchar* dst, int dststep,
 552                          CvSize size, int green_bits )
 553 {
 554     int i;
 555     assert( green_bits == 5 || green_bits == 6 );
 556
 557     for( ; size.height--; src += srcstep, dst += dststep )
 558     {
 559         if( green_bits == 6 )
 560             for( i = 0; i < size.width; i++ )
 561             {
 562                 int t = src[i];
 563                 ((ushort*)dst)[i] = (ushort)((t >> 3)|((t & ~3) << 3)|((t & ~7) << 8));
 564             }
 565         else
 566             for( i = 0; i < size.width; i++ )
 567             {
 568                 int t = src[i] >> 3;
 569                 ((ushort*)dst)[i] = (ushort)(t|(t << 5)|(t << 10));
 570             }
 571     }
 572
 573     return CV_OK;
 574 }
 575
 576
 577 static CvStatus CV_STDCALL
 578 icvBGRx2Gray_8u_CnC1R( const uchar* src, int srcstep,
 579                        uchar* dst, int dststep, CvSize size,
 580                        int src_cn, int blue_idx )
 581 {
 582     int i;
 583     srcstep -= size.width*src_cn;
 584
 585     if( size.width*size.height >= 1024 )
 586     {
 587         int* tab = (int*)cvStackAlloc( 256*3*sizeof(tab[0]) );
 588         int r = 0, g = 0, b = (1 << (csc_shift-1));
 589
 590         for( i = 0; i < 256; i++ )
 591         {
 592             tab[i] = b;
 593             tab[i+256] = g;
 594             tab[i+512] = r;
 595             g += cscGg;
 596             if( !blue_idx )
 597                 b += cscGb, r += cscGr;
 598             else
 599                 b += cscGr, r += cscGb;
 600         }
 601
 602         for( ; size.height--; src += srcstep, dst += dststep )
 603         {
 604             for( i = 0; i < size.width; i++, src += src_cn )
 605             {
 606                 int t0 = tab[src[0]] + tab[src[1] + 256] + tab[src[2] + 512];
 607                 dst[i] = (uchar)(t0 >> csc_shift);
 608             }
 609         }
 610     }
 611     else
 612     {
 613         for( ; size.height--; src += srcstep, dst += dststep )
 614         {
 615             for( i = 0; i < size.width; i++, src += src_cn )
 616             {
 617                 int t0 = src[blue_idx]*cscGb + src[1]*cscGg + src[blue_idx^2]*cscGr;
 618                 dst[i] = (uchar)CV_DESCALE(t0, csc_shift);
 619             }
 620         }
 621     }
 622     return CV_OK;
 623 }
 624
 625
 626 static CvStatus CV_STDCALL
 627 icvBGRx2Gray_16u_CnC1R( const ushort* src, int srcstep,
 628                         ushort* dst, int dststep, CvSize size,
 629                         int src_cn, int blue_idx )
 630 {
 631     int i;
 632     int cb = cscGb, cr = cscGr;
 633     srcstep /= sizeof(src[0]);
 634     dststep /= sizeof(dst[0]);
 635     srcstep -= size.width*src_cn;
 636
 637     if( blue_idx )
 638         cb = cscGr, cr = cscGb;
 639
 640     for( ; size.height--; src += srcstep, dst += dststep )
 641         for( i = 0; i < size.width; i++, src += src_cn )
 642             dst[i] = (ushort)CV_DESCALE((unsigned)(src[0]*cb +
 643                     src[1]*cscGg + src[2]*cr), csc_shift);
 644
 645     return CV_OK;
 646 }
 647
 648
 649 static CvStatus CV_STDCALL
 650 icvBGRx2Gray_32f_CnC1R( const float* src, int srcstep,
 651                         float* dst, int dststep, CvSize size,
 652                         int src_cn, int blue_idx )
 653 {
 654     int i;
 655     float cb = cscGb_32f, cr = cscGr_32f;
 656     if( blue_idx )
 657         cb = cscGr_32f, cr = cscGb_32f;
 658
 659     srcstep /= sizeof(src[0]);
 660     dststep /= sizeof(dst[0]);
 661     srcstep -= size.width*src_cn;
 662     for( ; size.height--; src += srcstep, dst += dststep )
 663         for( i = 0; i < size.width; i++, src += src_cn )
 664             dst[i] = src[0]*cb + src[1]*cscGg_32f + src[2]*cr;
 665
 666     return CV_OK;
 667 }
 668
 669
 670 /****************************************************************************************\
 671 *                                     RGB <-> YCrCb                                      *
 672 \****************************************************************************************/
 673
 674 /* BGR/RGB -> YCrCb */
 675 #define yuvYr_32f cscGr_32f
 676 #define yuvYg_32f cscGg_32f
 677 #define yuvYb_32f cscGb_32f
 678 #define yuvCr_32f 0.713f
 679 #define yuvCb_32f 0.564f
 680
 681 #define yuv_shift 14
 682 #define yuvYr  fix(yuvYr_32f,yuv_shift)
 683 #define yuvYg  fix(yuvYg_32f,yuv_shift)
 684 #define yuvYb  fix(yuvYb_32f,yuv_shift)
 685 #define yuvCr  fix(yuvCr_32f,yuv_shift)
 686 #define yuvCb  fix(yuvCb_32f,yuv_shift)
 687
 688 #define yuv_descale(x)  CV_DESCALE((x), yuv_shift)
 689 #define yuv_prescale(x) ((x) << yuv_shift)
 690
 691 #define  yuvRCr_32f   1.403f
 692 #define  yuvGCr_32f   (-0.714f)
 693 #define  yuvGCb_32f   (-0.344f)
 694 #define  yuvBCb_32f   1.773f
 695
 696 #define  yuvRCr   fix(yuvRCr_32f,yuv_shift)
 697 #define  yuvGCr   (-fix(-yuvGCr_32f,yuv_shift))
 698 #define  yuvGCb   (-fix(-yuvGCb_32f,yuv_shift))
 699 #define  yuvBCb   fix(yuvBCb_32f,yuv_shift)
 700
 701 #define CV_IMPL_BGRx2YCrCb( flavor, arrtype, worktype, scale_macro, cast_macro,     \
 702                             YUV_YB, YUV_YG, YUV_YR, YUV_CR, YUV_CB, YUV_Cx_BIAS )   \
 703 static CvStatus CV_STDCALL                                                  \
 704 icvBGRx2YCrCb_##flavor##_CnC3R( const arrtype* src, int srcstep,            \
 705     arrtype* dst, int dststep, CvSize size, int src_cn, int blue_idx )      \
 706 {                                                                           \
 707     int i;                                                                  \
 708     srcstep /= sizeof(src[0]);                                              \
 709     dststep /= sizeof(src[0]);                                              \
 710     srcstep -= size.width*src_cn;                                           \
 711     size.width *= 3;                                                        \
 712                                                                             \
 713     for( ; size.height--; src += srcstep, dst += dststep )                  \
 714     {                                                                       \
 715         for( i = 0; i < size.width; i += 3, src += src_cn )                 \
 716         {                                                                   \
 717             worktype b = src[blue_idx], r = src[2^blue_idx], y;             \
 718             y = scale_macro(b*YUV_YB + src[1]*YUV_YG + r*YUV_YR);           \
 719             r = scale_macro((r - y)*YUV_CR) + YUV_Cx_BIAS;                  \
 720             b = scale_macro((b - y)*YUV_CB) + YUV_Cx_BIAS;                  \
 721             dst[i] = cast_macro(y);                                         \
 722             dst[i+1] = cast_macro(r);                                       \
 723             dst[i+2] = cast_macro(b);                                       \
 724         }                                                                   \
 725     }                                                                       \
 726                                                                             \
 727     return CV_OK;                                                           \
 728 }
 729
 730
 731 CV_IMPL_BGRx2YCrCb( 8u, uchar, int, yuv_descale, CV_CAST_8U,
 732                     yuvYb, yuvYg, yuvYr, yuvCr, yuvCb, 128 )
 733
 734 CV_IMPL_BGRx2YCrCb( 16u, ushort, int, yuv_descale, CV_CAST_16U,
 735                     yuvYb, yuvYg, yuvYr, yuvCr, yuvCb, 32768 )
 736
 737 CV_IMPL_BGRx2YCrCb( 32f, float, float, CV_NOP, CV_NOP,
 738                     yuvYb_32f, yuvYg_32f, yuvYr_32f, yuvCr_32f, yuvCb_32f, 0.5f )
 739
 740
 741 #define CV_IMPL_YCrCb2BGRx( flavor, arrtype, worktype, prescale_macro,      \
 742     scale_macro, cast_macro, YUV_BCb, YUV_GCr, YUV_GCb, YUV_RCr, YUV_Cx_BIAS)\
 743 static CvStatus CV_STDCALL                                                  \
 744 icvYCrCb2BGRx_##flavor##_C3CnR( const arrtype* src, int srcstep,            \
 745                                 arrtype* dst, int dststep, CvSize size,     \
 746                                 int dst_cn, int blue_idx )                  \
 747 {                                                                           \
 748     int i;                                                                  \
 749     srcstep /= sizeof(src[0]);                                              \
 750     dststep /= sizeof(src[0]);                                              \
 751     dststep -= size.width*dst_cn;                                           \
 752     size.width *= 3;                                                        \
 753                                                                             \
 754     for( ; size.height--; src += srcstep, dst += dststep )                  \
 755     {                                                                       \
 756         for( i = 0; i < size.width; i += 3, dst += dst_cn )                 \
 757         {                                                                   \
 758             worktype Y = prescale_macro(src[i]),                            \
 759                      Cr = src[i+1] - YUV_Cx_BIAS,                           \
 760                      Cb = src[i+2] - YUV_Cx_BIAS;                           \
 761             worktype b, g, r;                                               \
 762             b = scale_macro( Y + YUV_BCb*Cb );                              \
 763             g = scale_macro( Y + YUV_GCr*Cr + YUV_GCb*Cb );                 \
 764             r = scale_macro( Y + YUV_RCr*Cr );                              \
 765                                                                             \
 766             dst[blue_idx] = cast_macro(b);                                  \
 767             dst[1] = cast_macro(g);                                         \
 768             dst[blue_idx^2] = cast_macro(r);                                \
 769             if( dst_cn == 4 )                                               \
 770                 dst[3] = 0;                                                 \
 771         }                                                                   \
 772     }                                                                       \
 773                                                                             \
 774     return CV_OK;                                                           \
 775 }
 776
 777
 778 CV_IMPL_YCrCb2BGRx( 8u, uchar, int, yuv_prescale, yuv_descale, CV_CAST_8U,
 779                     yuvBCb, yuvGCr, yuvGCb, yuvRCr, 128 )
 780
 781 CV_IMPL_YCrCb2BGRx( 16u, ushort, int, yuv_prescale, yuv_descale, CV_CAST_16U,
 782                     yuvBCb, yuvGCr, yuvGCb, yuvRCr, 32768 )
 783
 784 CV_IMPL_YCrCb2BGRx( 32f, float, float, CV_NOP, CV_NOP, CV_NOP,
 785                     yuvBCb_32f, yuvGCr_32f, yuvGCb_32f, yuvRCr_32f, 0.5f )
 786
 787
 788 /****************************************************************************************\
 789 *                                      RGB <-> XYZ                                       *
 790 \****************************************************************************************/
 791
 792 #define xyzXr_32f  0.412453f
 793 #define xyzXg_32f  0.357580f
 794 #define xyzXb_32f  0.180423f
 795
 796 #define xyzYr_32f  0.212671f
 797 #define xyzYg_32f  0.715160f
 798 #define xyzYb_32f  0.072169f
 799
 800 #define xyzZr_32f  0.019334f
 801 #define xyzZg_32f  0.119193f
 802 #define xyzZb_32f  0.950227f
 803
 804 #define xyzRx_32f  3.240479f
 805 #define xyzRy_32f  (-1.53715f)
 806 #define xyzRz_32f  (-0.498535f)
 807
 808 #define xyzGx_32f  (-0.969256f)
 809 #define xyzGy_32f  1.875991f
 810 #define xyzGz_32f  0.041556f
 811
 812 #define xyzBx_32f  0.055648f
 813 #define xyzBy_32f  (-0.204043f)
 814 #define xyzBz_32f  1.057311f
 815
 816 #define xyz_shift  10
 817 #define xyzXr_32s  fix(xyzXr_32f, xyz_shift )
 818 #define xyzXg_32s  fix(xyzXg_32f, xyz_shift )
 819 #define xyzXb_32s  fix(xyzXb_32f, xyz_shift )
 820
 821 #define xyzYr_32s  fix(xyzYr_32f, xyz_shift )
 822 #define xyzYg_32s  fix(xyzYg_32f, xyz_shift )
 823 #define xyzYb_32s  fix(xyzYb_32f, xyz_shift )
 824
 825 #define xyzZr_32s  fix(xyzZr_32f, xyz_shift )
 826 #define xyzZg_32s  fix(xyzZg_32f, xyz_shift )
 827 #define xyzZb_32s  fix(xyzZb_32f, xyz_shift )
 828
 829 #define xyzRx_32s  fix(3.240479f, xyz_shift )
 830 #define xyzRy_32s  -fix(1.53715f, xyz_shift )
 831 #define xyzRz_32s  -fix(0.498535f, xyz_shift )
 832
 833 #define xyzGx_32s  -fix(0.969256f, xyz_shift )
 834 #define xyzGy_32s  fix(1.875991f, xyz_shift )
 835 #define xyzGz_32s  fix(0.041556f, xyz_shift )
 836
 837 #define xyzBx_32s  fix(0.055648f, xyz_shift )
 838 #define xyzBy_32s  -fix(0.204043f, xyz_shift )
 839 #define xyzBz_32s  fix(1.057311f, xyz_shift )
 840
 841 #define xyz_descale(x) CV_DESCALE((x),xyz_shift)
 842
 843 #define CV_IMPL_BGRx2XYZ( flavor, arrtype, worktype,                        \
 844                           scale_macro, cast_macro, suffix )                 \
 845 static CvStatus CV_STDCALL                                                  \
 846 icvBGRx2XYZ_##flavor##_CnC3R( const arrtype* src, int srcstep,              \
 847                               arrtype* dst, int dststep, CvSize size,       \
 848                               int src_cn, int blue_idx )                    \
 849 {                                                                           \
 850     int i;                                                                  \
 851     worktype t, matrix[] =                                                  \
 852     {                                                                       \
 853         xyzXb##suffix, xyzXg##suffix, xyzXr##suffix,                        \
 854         xyzYb##suffix, xyzYg##suffix, xyzYr##suffix,                        \
 855         xyzZb##suffix, xyzZg##suffix, xyzZr##suffix                         \
 856     };                                                                      \
 857                                                                             \
 858     if( icvRGB2XYZ_##flavor##_C3R_p )                                       \
 859         return icvBGRx2ABC_IPP_##flavor##_CnC3R( src, srcstep,              \
 860             dst, dststep, size, src_cn, blue_idx,                           \
 861             icvRGB2XYZ_##flavor##_C3R_p );                                  \
 862                                                                             \
 863     srcstep /= sizeof(src[0]);                                              \
 864     dststep /= sizeof(dst[0]);                                              \
 865     srcstep -= size.width*src_cn;                                           \
 866     size.width *= 3;                                                        \
 867                                                                             \
 868     if( blue_idx )                                                          \
 869     {                                                                       \
 870         CV_SWAP( matrix[0], matrix[2], t );                                 \
 871         CV_SWAP( matrix[3], matrix[5], t );                                 \
 872         CV_SWAP( matrix[6], matrix[8], t );                                 \
 873     }                                                                       \
 874                                                                             \
 875     for( ; size.height--; src += srcstep, dst += dststep )                  \
 876     {                                                                       \
 877         for( i = 0; i < size.width; i += 3, src += src_cn )                 \
 878         {                                                                   \
 879             worktype x = scale_macro(src[0]*matrix[0] +                     \
 880                     src[1]*matrix[1] + src[2]*matrix[2]);                   \
 881             worktype y = scale_macro(src[0]*matrix[3] +                     \
 882                     src[1]*matrix[4] + src[2]*matrix[5]);                   \
 883             worktype z = scale_macro(src[0]*matrix[6] +                     \
 884                     src[1]*matrix[7] + src[2]*matrix[8]);                   \
 885                                                                             \
 886             dst[i] = (arrtype)(x);                                          \
 887             dst[i+1] = (arrtype)(y);                                        \
 888             dst[i+2] = cast_macro(z); /*sum of weights for z > 1*/          \
 889         }                                                                   \
 890     }                                                                       \
 891                                                                             \
 892     return CV_OK;                                                           \
 893 }
 894
 895
 896 CV_IMPL_BGRx2XYZ( 8u, uchar, int, xyz_descale, CV_CAST_8U, _32s )
 897 CV_IMPL_BGRx2XYZ( 16u, ushort, int, xyz_descale, CV_CAST_16U, _32s )
 898 CV_IMPL_BGRx2XYZ( 32f, float, float, CV_NOP, CV_NOP, _32f )
 899
 900
 901 #define CV_IMPL_XYZ2BGRx( flavor, arrtype, worktype, scale_macro,           \
 902                           cast_macro, suffix )                              \
 903 static CvStatus CV_STDCALL                                                  \
 904 icvXYZ2BGRx_##flavor##_C3CnR( const arrtype* src, int srcstep,              \
 905                               arrtype* dst, int dststep, CvSize size,       \
 906                               int dst_cn, int blue_idx )                    \
 907 {                                                                           \
 908     int i;                                                                  \
 909     worktype t, matrix[] =                                                  \
 910     {                                                                       \
 911         xyzBx##suffix, xyzBy##suffix, xyzBz##suffix,                        \
 912         xyzGx##suffix, xyzGy##suffix, xyzGz##suffix,                        \
 913         xyzRx##suffix, xyzRy##suffix, xyzRz##suffix                         \
 914     };                                                                      \
 915                                                                             \
 916     if( icvXYZ2RGB_##flavor##_C3R_p )                                       \
 917         return icvABC2BGRx_IPP_##flavor##_C3CnR( src, srcstep,              \
 918             dst, dststep, size, dst_cn, blue_idx,                           \
 919             icvXYZ2RGB_##flavor##_C3R_p );                                  \
 920                                                                             \
 921     srcstep /= sizeof(src[0]);                                              \
 922     dststep /= sizeof(dst[0]);                                              \
 923     dststep -= size.width*dst_cn;                                           \
 924     size.width *= 3;                                                        \
 925                                                                             \
 926     if( blue_idx )                                                          \
 927     {                                                                       \
 928         CV_SWAP( matrix[0], matrix[6], t );                                 \
 929         CV_SWAP( matrix[1], matrix[7], t );                                 \
 930         CV_SWAP( matrix[2], matrix[8], t );                                 \
 931     }                                                                       \
 932                                                                             \
 933     for( ; size.height--; src += srcstep, dst += dststep )                  \
 934     {                                                                       \
 935         for( i = 0; i < size.width; i += 3, dst += dst_cn )                 \
 936         {                                                                   \
 937             worktype b = scale_macro(src[i]*matrix[0] +                     \
 938                     src[i+1]*matrix[1] + src[i+2]*matrix[2]);               \
 939             worktype g = scale_macro(src[i]*matrix[3] +                     \
 940                     src[i+1]*matrix[4] + src[i+2]*matrix[5]);               \
 941             worktype r = scale_macro(src[i]*matrix[6] +                     \
 942                     src[i+1]*matrix[7] + src[i+2]*matrix[8]);               \
 943                                                                             \
 944             dst[0] = cast_macro(b);                                         \
 945             dst[1] = cast_macro(g);                                         \
 946             dst[2] = cast_macro(r);                                         \
 947                                                                             \
 948             if( dst_cn == 4 )                                               \
 949                 dst[3] = 0;                                                 \
 950         }                                                                   \
 951     }                                                                       \
 952                                                                             \
 953     return CV_OK;                                                           \
 954 }
 955
 956 CV_IMPL_XYZ2BGRx( 8u, uchar, int, xyz_descale, CV_CAST_8U, _32s )
 957 CV_IMPL_XYZ2BGRx( 16u, ushort, int, xyz_descale, CV_CAST_16U, _32s )
 958 CV_IMPL_XYZ2BGRx( 32f, float, float, CV_NOP, CV_NOP, _32f )
 959
 960
 961 /****************************************************************************************\
 962 *                          Non-linear Color Space Transformations                        *
 963 \****************************************************************************************/
 964
 965 // driver color space conversion function for 8u arrays that uses 32f function
 966 // with appropriate pre- and post-scaling.
 967 static CvStatus CV_STDCALL
 968 icvABC2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
 969                       CvSize size, int dst_cn, int blue_idx, CvColorCvtFunc2 cvtfunc_32f,
 970                      const float* pre_coeffs, int postscale )
 971 {
 972     int block_size = MIN(1 << 8, size.width);
 973     float* buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
 974     int i, di, k;
 975     CvStatus status = CV_OK;
 976
 977     dststep -= size.width*dst_cn;
 978
 979     for( ; size.height--; src += srcstep, dst += dststep )
 980     {
 981         for( i = 0; i < size.width; i += block_size )
 982         {
 983             const uchar* src1 = src + i*3;
 984             di = MIN(block_size, size.width - i);
 985
 986             for( k = 0; k < di*3; k += 3 )
 987             {
 988                 float a = CV_8TO32F(src1[k])*pre_coeffs[0] + pre_coeffs[1];
 989                 float b = CV_8TO32F(src1[k+1])*pre_coeffs[2] + pre_coeffs[3];
 990                 float c = CV_8TO32F(src1[k+2])*pre_coeffs[4] + pre_coeffs[5];
 991                 buffer[k] = a;
 992                 buffer[k+1] = b;
 993                 buffer[k+2] = c;
 994             }
 995
 996             status = cvtfunc_32f( buffer, 0, buffer, 0, cvSize(di,1), 3, blue_idx );
 997             if( status < 0 )
 998                 return status;
 999
1000             if( postscale )
1001             {
1002                 for( k = 0; k < di*3; k += 3, dst += dst_cn )
1003                 {
1004                     int b = cvRound(buffer[k]*255.);
1005                     int g = cvRound(buffer[k+1]*255.);
1006                     int r = cvRound(buffer[k+2]*255.);
1007
1008                     dst[0] = CV_CAST_8U(b);
1009                     dst[1] = CV_CAST_8U(g);
1010                     dst[2] = CV_CAST_8U(r);
1011                     if( dst_cn == 4 )
1012                         dst[3] = 0;
1013                 }
1014             }
1015             else
1016             {
1017                 for( k = 0; k < di*3; k += 3, dst += dst_cn )
1018                 {
1019                     int b = cvRound(buffer[k]);
1020                     int g = cvRound(buffer[k+1]);
1021                     int r = cvRound(buffer[k+2]);
1022
1023                     dst[0] = CV_CAST_8U(b);
1024                     dst[1] = CV_CAST_8U(g);
1025                     dst[2] = CV_CAST_8U(r);
1026                     if( dst_cn == 4 )
1027                         dst[3] = 0;
1028                 }
1029             }
1030         }
1031     }
1032
1033     return CV_OK;
1034 }
1035
1036
1037 // driver color space conversion function for 8u arrays that uses 32f function
1038 // with appropriate pre- and post-scaling.
1039 static CvStatus CV_STDCALL
1040 icvBGRx2ABC_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep,
1041                       CvSize size, int src_cn, int blue_idx, CvColorCvtFunc2 cvtfunc_32f,
1042                       int prescale, const float* post_coeffs )
1043 {
1044     int block_size = MIN(1 << 8, size.width);
1045     float* buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
1046     int i, di, k;
1047     CvStatus status = CV_OK;
1048
1049     srcstep -= size.width*src_cn;
1050
1051     for( ; size.height--; src += srcstep, dst += dststep )
1052     {
1053         for( i = 0; i < size.width; i += block_size )
1054         {
1055             uchar* dst1 = dst + i*3;
1056             di = MIN(block_size, size.width - i);
1057
1058             if( prescale )
1059             {
1060                 for( k = 0; k < di*3; k += 3, src += src_cn )
1061                 {
1062                     float b = CV_8TO32F(src[0])*0.0039215686274509803f;
1063                     float g = CV_8TO32F(src[1])*0.0039215686274509803f;
1064                     float r = CV_8TO32F(src[2])*0.0039215686274509803f;
1065
1066                     buffer[k] = b;
1067                     buffer[k+1] = g;
1068                     buffer[k+2] = r;
1069                 }
1070             }
1071             else
1072             {
1073                 for( k = 0; k < di*3; k += 3, src += src_cn )
1074                 {
1075                     float b = CV_8TO32F(src[0]);
1076                     float g = CV_8TO32F(src[1]);
1077                     float r = CV_8TO32F(src[2]);
1078
1079                     buffer[k] = b;
1080                     buffer[k+1] = g;
1081                     buffer[k+2] = r;
1082                 }
1083             }
1084
1085             status = cvtfunc_32f( buffer, 0, buffer, 0, cvSize(di,1), 3, blue_idx );
1086             if( status < 0 )
1087                 return status;
1088
1089             for( k = 0; k < di*3; k += 3 )
1090             {
1091                 int a = cvRound( buffer[k]*post_coeffs[0] + post_coeffs[1] );
1092                 int b = cvRound( buffer[k+1]*post_coeffs[2] + post_coeffs[3] );
1093                 int c = cvRound( buffer[k+2]*post_coeffs[4] + post_coeffs[5] );
1094                 dst1[k] = CV_CAST_8U(a);
1095                 dst1[k+1] = CV_CAST_8U(b);
1096                 dst1[k+2] = CV_CAST_8U(c);
1097             }
1098         }
1099     }
1100
1101     return CV_OK;
1102 }
1103
1104
1105 /****************************************************************************************\
1106 *                                      RGB <-> HSV                                       *
1107 \****************************************************************************************/
1108
1109 static const uchar icvHue255To180[] =
1110 {
1111       0,   1,   1,   2,   3,   4,   4,   5,   6,   6,   7,   8,   8,   9,  10,  11,
1112      11,  12,  13,  13,  14,  15,  16,  16,  17,  18,  18,  19,  20,  20,  21,  22,
1113      23,  23,  24,  25,  25,  26,  27,  28,  28,  29,  30,  30,  31,  32,  32,  33,
1114      34,  35,  35,  36,  37,  37,  38,  39,  40,  40,  41,  42,  42,  43,  44,  44,
1115      45,  46,  47,  47,  48,  49,  49,  50,  51,  52,  52,  53,  54,  54,  55,  56,
1116      56,  57,  58,  59,  59,  60,  61,  61,  62,  63,  64,  64,  65,  66,  66,  67,
1117      68,  68,  69,  70,  71,  71,  72,  73,  73,  74,  75,  76,  76,  77,  78,  78,
1118      79,  80,  80,  81,  82,  83,  83,  84,  85,  85,  86,  87,  88,  88,  89,  90,
1119      90,  91,  92,  92,  93,  94,  95,  95,  96,  97,  97,  98,  99, 100, 100, 101,
1120     102, 102, 103, 104, 104, 105, 106, 107, 107, 108, 109, 109, 110, 111, 112, 112,
1121     113, 114, 114, 115, 116, 116, 117, 118, 119, 119, 120, 121, 121, 122, 123, 124,
1122     124, 125, 126, 126, 127, 128, 128, 129, 130, 131, 131, 132, 133, 133, 134, 135,
1123     136, 136, 137, 138, 138, 139, 140, 140, 141, 142, 143, 143, 144, 145, 145, 146,
1124     147, 148, 148, 149, 150, 150, 151, 152, 152, 153, 154, 155, 155, 156, 157, 157,
1125     158, 159, 160, 160, 161, 162, 162, 163, 164, 164, 165, 166, 167, 167, 168, 169,
1126     169, 170, 171, 172, 172, 173, 174, 174, 175, 176, 176, 177, 178, 179, 179, 180
1127 };
1128
1129
1130 static const uchar icvHue180To255[] =
1131 {
1132       0,   1,   3,   4,   6,   7,   9,  10,  11,  13,  14,  16,  17,  18,  20,  21,
1133      23,  24,  26,  27,  28,  30,  31,  33,  34,  35,  37,  38,  40,  41,  43,  44,
1134      45,  47,  48,  50,  51,  52,  54,  55,  57,  58,  60,  61,  62,  64,  65,  67,
1135      68,  69,  71,  72,  74,  75,  77,  78,  79,  81,  82,  84,  85,  86,  88,  89,
1136      91,  92,  94,  95,  96,  98,  99, 101, 102, 103, 105, 106, 108, 109, 111, 112,
1137     113, 115, 116, 118, 119, 120, 122, 123, 125, 126, 128, 129, 130, 132, 133, 135,
1138     136, 137, 139, 140, 142, 143, 145, 146, 147, 149, 150, 152, 153, 154, 156, 157,
1139     159, 160, 162, 163, 164, 166, 167, 169, 170, 171, 173, 174, 176, 177, 179, 180,
1140     181, 183, 184, 186, 187, 188, 190, 191, 193, 194, 196, 197, 198, 200, 201, 203,
1141     204, 205, 207, 208, 210, 211, 213, 214, 215, 217, 218, 220, 221, 222, 224, 225,
1142     227, 228, 230, 231, 232, 234, 235, 237, 238, 239, 241, 242, 244, 245, 247, 248,
1143     249, 251, 252, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1144     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1145     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1146     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1147     255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
1148 };
1149
1150
1151 static CvStatus CV_STDCALL
1152 icvBGRx2HSV_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep,
1153                       CvSize size, int src_cn, int blue_idx )
1154 {
1155     const int hsv_shift = 12;
1156
1157     static const int div_table[] = {
1158         0, 1044480, 522240, 348160, 261120, 208896, 174080, 149211,
1159         130560, 116053, 104448, 94953, 87040, 80345, 74606, 69632,
1160         65280, 61440, 58027, 54973, 52224, 49737, 47476, 45412,
1161         43520, 41779, 40172, 38684, 37303, 36017, 34816, 33693,
1162         32640, 31651, 30720, 29842, 29013, 28229, 27486, 26782,
1163         26112, 25475, 24869, 24290, 23738, 23211, 22706, 22223,
1164         21760, 21316, 20890, 20480, 20086, 19707, 19342, 18991,
1165         18651, 18324, 18008, 17703, 17408, 17123, 16846, 16579,
1166         16320, 16069, 15825, 15589, 15360, 15137, 14921, 14711,
1167         14507, 14308, 14115, 13926, 13743, 13565, 13391, 13221,
1168         13056, 12895, 12738, 12584, 12434, 12288, 12145, 12006,
1169         11869, 11736, 11605, 11478, 11353, 11231, 11111, 10995,
1170         10880, 10768, 10658, 10550, 10445, 10341, 10240, 10141,
1171         10043, 9947, 9854, 9761, 9671, 9582, 9495, 9410,
1172         9326, 9243, 9162, 9082, 9004, 8927, 8852, 8777,
1173         8704, 8632, 8561, 8492, 8423, 8356, 8290, 8224,
1174         8160, 8097, 8034, 7973, 7913, 7853, 7795, 7737,
1175         7680, 7624, 7569, 7514, 7461, 7408, 7355, 7304,
1176         7253, 7203, 7154, 7105, 7057, 7010, 6963, 6917,
1177         6872, 6827, 6782, 6739, 6695, 6653, 6611, 6569,
1178         6528, 6487, 6447, 6408, 6369, 6330, 6292, 6254,
1179         6217, 6180, 6144, 6108, 6073, 6037, 6003, 5968,
1180         5935, 5901, 5868, 5835, 5803, 5771, 5739, 5708,
1181         5677, 5646, 5615, 5585, 5556, 5526, 5497, 5468,
1182         5440, 5412, 5384, 5356, 5329, 5302, 5275, 5249,
1183         5222, 5196, 5171, 5145, 5120, 5095, 5070, 5046,
1184         5022, 4998, 4974, 4950, 4927, 4904, 4881, 4858,
1185         4836, 4813, 4791, 4769, 4748, 4726, 4705, 4684,
1186         4663, 4642, 4622, 4601, 4581, 4561, 4541, 4522,
1187         4502, 4483, 4464, 4445, 4426, 4407, 4389, 4370,
1188         4352, 4334, 4316, 4298, 4281, 4263, 4246, 4229,
1189         4212, 4195, 4178, 4161, 4145, 4128, 4112, 4096
1190     };
1191
1192     int i;
1193     if( icvRGB2HSV_8u_C3R_p )
1194     {
1195         CvStatus status = icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size,
1196                                                 src_cn, blue_idx, icvRGB2HSV_8u_C3R_p );
1197         if( status >= 0 )
1198         {
1199             size.width *= 3;
1200             for( ; size.height--; dst += dststep )
1201             {
1202                 for( i = 0; i <= size.width - 12; i += 12 )
1203                 {
1204                     uchar t0 = icvHue255To180[dst[i]], t1 = icvHue255To180[dst[i+3]];
1205                     dst[i] = t0; dst[i+3] = t1;
1206                     t0 = icvHue255To180[dst[i+6]]; t1 = icvHue255To180[dst[i+9]];
1207                     dst[i+6] = t0; dst[i+9] = t1;
1208                 }
1209                 for( ; i < size.width; i += 3 )
1210                     dst[i] = icvHue255To180[dst[i]];
1211             }
1212         }
1213         return status;
1214     }
1215
1216     srcstep -= size.width*src_cn;
1217     size.width *= 3;
1218
1219     for( ; size.height--; src += srcstep, dst += dststep )
1220     {
1221         for( i = 0; i < size.width; i += 3, src += src_cn )
1222         {
1223             int b = (src)[blue_idx], g = (src)[1], r = (src)[2^blue_idx];
1224             int h, s, v = b;
1225             int vmin = b, diff;
1226             int vr, vg;
1227
1228             CV_CALC_MAX_8U( v, g );
1229             CV_CALC_MAX_8U( v, r );
1230             CV_CALC_MIN_8U( vmin, g );
1231             CV_CALC_MIN_8U( vmin, r );
1232
1233             diff = v - vmin;
1234             vr = v == r ? -1 : 0;
1235             vg = v == g ? -1 : 0;
1236
1237             s = diff * div_table[v] >> hsv_shift;
1238             h = (vr & (g - b)) +
1239                 (~vr & ((vg & (b - r + 2 * diff)) + ((~vg) & (r - g + 4 * diff))));
1240             h = ((h * div_table[diff] * 15 + (1 << (hsv_shift + 6))) >> (7 + hsv_shift))\
1241                 + (h < 0 ? 30*6 : 0);
1242
1243             dst[i] = (uchar)h;
1244             dst[i+1] = (uchar)s;
1245             dst[i+2] = (uchar)v;
1246         }
1247     }
1248
1249     return CV_OK;
1250 }
1251
1252
1253 static CvStatus CV_STDCALL
1254 icvBGRx2HSV_32f_CnC3R( const float* src, int srcstep,
1255                        float* dst, int dststep,
1256                        CvSize size, int src_cn, int blue_idx )
1257 {
1258     int i;
1259     srcstep /= sizeof(src[0]);
1260     dststep /= sizeof(dst[0]);
1261     srcstep -= size.width*src_cn;
1262     size.width *= 3;
1263
1264     for( ; size.height--; src += srcstep, dst += dststep )
1265     {
1266         for( i = 0; i < size.width; i += 3, src += src_cn )
1267         {
1268             float b = src[blue_idx], g = src[1], r = src[2^blue_idx];
1269             float h, s, v;
1270
1271             float vmin, diff;
1272
1273             v = vmin = r;
1274             if( v < g ) v = g;
1275             if( v < b ) v = b;
1276             if( vmin > g ) vmin = g;
1277             if( vmin > b ) vmin = b;
1278
1279             diff = v - vmin;
1280             s = diff/(float)(fabs(v) + FLT_EPSILON);
1281             diff = (float)(60./(diff + FLT_EPSILON));
1282             if( v == r )
1283                 h = (g - b)*diff;
1284             else if( v == g )
1285                 h = (b - r)*diff + 120.f;
1286             else
1287                 h = (r - g)*diff + 240.f;
1288
1289             if( h < 0 ) h += 360.f;
1290
1291             dst[i] = h;
1292             dst[i+1] = s;
1293             dst[i+2] = v;
1294         }
1295     }
1296
1297     return CV_OK;
1298 }
1299
1300
1301 static CvStatus CV_STDCALL
1302 icvHSV2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst,
1303                        int dststep, CvSize size, int dst_cn, int blue_idx )
1304 {
1305     int i;
1306     srcstep /= sizeof(src[0]);
1307     dststep /= sizeof(dst[0]);
1308     dststep -= size.width*dst_cn;
1309     size.width *= 3;
1310
1311     for( ; size.height--; src += srcstep, dst += dststep )
1312     {
1313         for( i = 0; i < size.width; i += 3, dst += dst_cn )
1314         {
1315             float h = src[i], s = src[i+1], v = src[i+2];
1316             float b, g, r;
1317
1318             if( s == 0 )
1319                 b = g = r = v;
1320             else
1321             {
1322                 static const int sector_data[][3]=
1323                     {{1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}};
1324                 float tab[4];
1325                 int sector;
1326                 h *= 0.016666666666666666f; // h /= 60;
1327                 if( h < 0 )
1328                     do h += 6; while( h < 0 );
1329                 else if( h >= 6 )
1330                     do h -= 6; while( h >= 6 );
1331                 sector = cvFloor(h);
1332                 h -= sector;
1333
1334                 tab[0] = v;
1335                 tab[1] = v*(1.f - s);
1336                 tab[2] = v*(1.f - s*h);
1337                 tab[3] = v*(1.f - s*(1.f - h));
1338
1339                 b = tab[sector_data[sector][0]];
1340                 g = tab[sector_data[sector][1]];
1341                 r = tab[sector_data[sector][2]];
1342             }
1343
1344             dst[blue_idx] = b;
1345             dst[1] = g;
1346             dst[blue_idx^2] = r;
1347             if( dst_cn == 4 )
1348                 dst[3] = 0;
1349         }
1350     }
1351
1352     return CV_OK;
1353 }
1354
1355
1356 static CvStatus CV_STDCALL
1357 icvHSV2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
1358                       CvSize size, int dst_cn, int blue_idx )
1359 {
1360     static const float pre_coeffs[] = { 2.f, 0.f, 0.0039215686274509803f, 0.f, 1.f, 0.f };
1361
1362     if( icvHSV2RGB_8u_C3R_p )
1363     {
1364         int block_size = MIN(1 << 14, size.width);
1365         uchar* buffer;
1366         int i, di, k;
1367         CvStatus status = CV_OK;
1368
1369         buffer = (uchar*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
1370         dststep -= size.width*dst_cn;
1371
1372         for( ; size.height--; src += srcstep, dst += dststep )
1373         {
1374             for( i = 0; i < size.width; i += block_size )
1375             {
1376                 const uchar* src1 = src + i*3;
1377                 di = MIN(block_size, size.width - i);
1378                 for( k = 0; k < di*3; k += 3 )
1379                 {
1380                     uchar h = icvHue180To255[src1[k]];
1381                     uchar s = src1[k+1];
1382                     uchar v = src1[k+2];
1383                     buffer[k] = h;
1384                     buffer[k+1] = s;
1385                     buffer[k+2] = v;
1386                 }
1387
1388                 status = icvHSV2RGB_8u_C3R_p( buffer, di*3,
1389                                 buffer, di*3, cvSize(di,1) );
1390                 if( status < 0 )
1391                     return status;
1392
1393                 for( k = 0; k < di*3; k += 3, dst += dst_cn )
1394                 {
1395                     uchar r = buffer[k];
1396                     uchar g = buffer[k+1];
1397                     uchar b = buffer[k+2];
1398                     dst[blue_idx] = b;
1399                     dst[1] = g;
1400                     dst[blue_idx^2] = r;
1401                     if( dst_cn == 4 )
1402                         dst[3] = 0;
1403                 }
1404             }
1405         }
1406
1407         return CV_OK;
1408     }
1409
1410     return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx,
1411                                  (CvColorCvtFunc2)icvHSV2BGRx_32f_C3CnR, pre_coeffs, 0 );
1412 }
1413
1414
1415 /****************************************************************************************\
1416 *                                     RGB <-> HLS                                        *
1417 \****************************************************************************************/
1418
1419 static CvStatus CV_STDCALL
1420 icvBGRx2HLS_32f_CnC3R( const float* src, int srcstep, float* dst, int dststep,
1421                        CvSize size, int src_cn, int blue_idx )
1422 {
1423     int i;
1424
1425     if( icvRGB2HLS_32f_C3R_p )
1426     {
1427         CvStatus status = icvBGRx2ABC_IPP_32f_CnC3R( src, srcstep, dst, dststep, size,
1428                                                      src_cn, blue_idx, icvRGB2HLS_32f_C3R_p );
1429         if( status >= 0 )
1430         {
1431             size.width *= 3;
1432             dststep /= sizeof(dst[0]);
1433
1434             for( ; size.height--; dst += dststep )
1435             {
1436                 for( i = 0; i <= size.width - 12; i += 12 )
1437                 {
1438                     float t0 = dst[i]*360.f, t1 = dst[i+3]*360.f;
1439                     dst[i] = t0; dst[i+3] = t1;
1440                     t0 = dst[i+6]*360.f; t1 = dst[i+9]*360.f;
1441                     dst[i+6] = t0; dst[i+9] = t1;
1442                 }
1443                 for( ; i < size.width; i += 3 )
1444                     dst[i] = dst[i]*360.f;
1445             }
1446         }
1447         return status;
1448     }
1449
1450     srcstep /= sizeof(src[0]);
1451     dststep /= sizeof(dst[0]);
1452     srcstep -= size.width*src_cn;
1453     size.width *= 3;
1454
1455     for( ; size.height--; src += srcstep, dst += dststep )
1456     {
1457         for( i = 0; i < size.width; i += 3, src += src_cn )
1458         {
1459             float b = src[blue_idx], g = src[1], r = src[2^blue_idx];
1460             float h = 0.f, s = 0.f, l;
1461             float vmin, vmax, diff;
1462
1463             vmax = vmin = r;
1464             if( vmax < g ) vmax = g;
1465             if( vmax < b ) vmax = b;
1466             if( vmin > g ) vmin = g;
1467             if( vmin > b ) vmin = b;
1468
1469             diff = vmax - vmin;
1470             l = (vmax + vmin)*0.5f;
1471
1472             if( diff > FLT_EPSILON )
1473             {
1474                 s = l < 0.5f ? diff/(vmax + vmin) : diff/(2 - vmax - vmin);
1475                 diff = 60.f/diff;
1476
1477                 if( vmax == r )
1478                     h = (g - b)*diff;
1479                 else if( vmax == g )
1480                     h = (b - r)*diff + 120.f;
1481                 else
1482                     h = (r - g)*diff + 240.f;
1483
1484                 if( h < 0.f ) h += 360.f;
1485             }
1486
1487             dst[i] = h;
1488             dst[i+1] = l;
1489             dst[i+2] = s;
1490         }
1491     }
1492
1493     return CV_OK;
1494 }
1495
1496
1497 static CvStatus CV_STDCALL
1498 icvHLS2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, int dststep,
1499                        CvSize size, int dst_cn, int blue_idx )
1500 {
1501     int i;
1502     srcstep /= sizeof(src[0]);
1503     dststep /= sizeof(dst[0]);
1504
1505     if( icvHLS2RGB_32f_C3R_p )
1506     {
1507         int block_size = MIN(1 << 10, size.width);
1508         float* buffer;
1509         int di, k;
1510         CvStatus status = CV_OK;
1511
1512         buffer = (float*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
1513         dststep -= size.width*dst_cn;
1514
1515         for( ; size.height--; src += srcstep, dst += dststep )
1516         {
1517             for( i = 0; i < size.width; i += block_size )
1518             {
1519                 const float* src1 = src + i*3;
1520                 di = MIN(block_size, size.width - i);
1521                 for( k = 0; k < di*3; k += 3 )
1522                 {
1523                     float h = src1[k]*0.0027777777777777779f; // /360.
1524                     float s = src1[k+1], v = src1[k+2];
1525                     buffer[k] = h; buffer[k+1] = s; buffer[k+2] = v;
1526                 }
1527
1528                 status = icvHLS2RGB_32f_C3R_p( buffer, di*3*sizeof(dst[0]),
1529                                 buffer, di*3*sizeof(dst[0]), cvSize(di,1) );
1530                 if( status < 0 )
1531                     return status;
1532
1533                 for( k = 0; k < di*3; k += 3, dst += dst_cn )
1534                 {
1535                     float r = buffer[k], g = buffer[k+1], b = buffer[k+2];
1536                     dst[blue_idx] = b; dst[1] = g; dst[blue_idx^2] = r;
1537                     if( dst_cn == 4 )
1538                         dst[3] = 0;
1539                 }
1540             }
1541         }
1542
1543         return CV_OK;
1544     }
1545
1546     dststep -= size.width*dst_cn;
1547     size.width *= 3;
1548
1549     for( ; size.height--; src += srcstep, dst += dststep )
1550     {
1551         for( i = 0; i < size.width; i += 3, dst += dst_cn )
1552         {
1553             float h = src[i], l = src[i+1], s = src[i+2];
1554             float b, g, r;
1555
1556             if( s == 0 )
1557                 b = g = r = l;
1558             else
1559             {
1560                 static const int sector_data[][3]=
1561                     {{1,3,0}, {1,0,2}, {3,0,1}, {0,2,1}, {0,1,3}, {2,1,0}};
1562                 float tab[4];
1563                 int sector;
1564
1565                 float p2 = l <= 0.5f ? l*(1 + s) : l + s - l*s;
1566                 float p1 = 2*l - p2;
1567
1568                 h *= 0.016666666666666666f; // h /= 60;
1569                 if( h < 0 )
1570                     do h += 6; while( h < 0 );
1571                 else if( h >= 6 )
1572                     do h -= 6; while( h >= 6 );
1573
1574                 assert( 0 <= h && h < 6 );
1575                 sector = cvFloor(h);
1576                 h -= sector;
1577
1578                 tab[0] = p2;
1579                 tab[1] = p1;
1580                 tab[2] = p1 + (p2 - p1)*(1-h);
1581                 tab[3] = p1 + (p2 - p1)*h;
1582
1583                 b = tab[sector_data[sector][0]];
1584                 g = tab[sector_data[sector][1]];
1585                 r = tab[sector_data[sector][2]];
1586             }
1587
1588             dst[blue_idx] = b;
1589             dst[1] = g;
1590             dst[blue_idx^2] = r;
1591             if( dst_cn == 4 )
1592                 dst[3] = 0;
1593         }
1594     }
1595
1596     return CV_OK;
1597 }
1598
1599 static CvStatus CV_STDCALL
1600 icvBGRx2HLS_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep,
1601                       CvSize size, int src_cn, int blue_idx )
1602 {
1603     static const float post_coeffs[] = { 0.5f, 0.f, 255.f, 0.f, 255.f, 0.f };
1604
1605     if( icvRGB2HLS_8u_C3R_p )
1606     {
1607         CvStatus status = icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size,
1608                                                     src_cn, blue_idx, icvRGB2HLS_8u_C3R_p );
1609         if( status >= 0 )
1610         {
1611             size.width *= 3;
1612             for( ; size.height--; dst += dststep )
1613             {
1614                 int i;
1615                 for( i = 0; i <= size.width - 12; i += 12 )
1616                 {
1617                     uchar t0 = icvHue255To180[dst[i]], t1 = icvHue255To180[dst[i+3]];
1618                     dst[i] = t0; dst[i+3] = t1;
1619                     t0 = icvHue255To180[dst[i+6]]; t1 = icvHue255To180[dst[i+9]];
1620                     dst[i+6] = t0; dst[i+9] = t1;
1621                 }
1622                 for( ; i < size.width; i += 3 )
1623                     dst[i] = icvHue255To180[dst[i]];
1624             }
1625         }
1626         return status;
1627     }
1628
1629     return icvBGRx2ABC_8u_CnC3R( src, srcstep, dst, dststep, size, src_cn, blue_idx,
1630                                  (CvColorCvtFunc2)icvBGRx2HLS_32f_CnC3R, 1, post_coeffs );
1631 }
1632
1633
1634 static CvStatus CV_STDCALL
1635 icvHLS2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
1636                       CvSize size, int dst_cn, int blue_idx )
1637 {
1638     static const float pre_coeffs[] = { 2.f, 0.f, 0.0039215686274509803f, 0.f,
1639                                         0.0039215686274509803f, 0.f };
1640
1641     if( icvHLS2RGB_8u_C3R_p )
1642     {
1643         int block_size = MIN(1 << 14, size.width);
1644         uchar* buffer;
1645         int i, di, k;
1646         CvStatus status = CV_OK;
1647
1648         buffer = (uchar*)cvStackAlloc( block_size*3*sizeof(buffer[0]) );
1649         dststep -= size.width*dst_cn;
1650
1651         for( ; size.height--; src += srcstep, dst += dststep )
1652         {
1653             for( i = 0; i < size.width; i += block_size )
1654             {
1655                 const uchar* src1 = src + i*3;
1656                 di = MIN(block_size, size.width - i);
1657                 for( k = 0; k < di*3; k += 3 )
1658                 {
1659                     uchar h = icvHue180To255[src1[k]];
1660                     uchar l = src1[k+1];
1661                     uchar s = src1[k+2];
1662                     buffer[k] = h;
1663                     buffer[k+1] = l;
1664                     buffer[k+2] = s;
1665                 }
1666
1667                 status = icvHLS2RGB_8u_C3R_p( buffer, di*3,
1668                                 buffer, di*3, cvSize(di,1) );
1669                 if( status < 0 )
1670                     return status;
1671
1672                 for( k = 0; k < di*3; k += 3, dst += dst_cn )
1673                 {
1674                     uchar r = buffer[k];
1675                     uchar g = buffer[k+1];
1676                     uchar b = buffer[k+2];
1677                     dst[blue_idx] = b;
1678                     dst[1] = g;
1679                     dst[blue_idx^2] = r;
1680                     if( dst_cn == 4 )
1681                         dst[3] = 0;
1682                 }
1683             }
1684         }
1685
1686         return CV_OK;
1687     }
1688
1689     return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx,
1690                                  (CvColorCvtFunc2)icvHLS2BGRx_32f_C3CnR, pre_coeffs, 1 );
1691 }
1692
1693
1694 /****************************************************************************************\
1695 *                                     RGB <-> L*a*b*                                     *
1696 \****************************************************************************************/
1697
1698 #define  labXr_32f  0.433953f /* = xyzXr_32f / 0.950456 */
1699 #define  labXg_32f  0.376219f /* = xyzXg_32f / 0.950456 */
1700 #define  labXb_32f  0.189828f /* = xyzXb_32f / 0.950456 */
1701
1702 #define  labYr_32f  0.212671f /* = xyzYr_32f */
1703 #define  labYg_32f  0.715160f /* = xyzYg_32f */
1704 #define  labYb_32f  0.072169f /* = xyzYb_32f */
1705
1706 #define  labZr_32f  0.017758f /* = xyzZr_32f / 1.088754 */
1707 #define  labZg_32f  0.109477f /* = xyzZg_32f / 1.088754 */
1708 #define  labZb_32f  0.872766f /* = xyzZb_32f / 1.088754 */
1709
1710 #define  labRx_32f  3.0799327f  /* = xyzRx_32f * 0.950456 */
1711 #define  labRy_32f  (-1.53715f) /* = xyzRy_32f */
1712 #define  labRz_32f  (-0.542782f)/* = xyzRz_32f * 1.088754 */
1713
1714 #define  labGx_32f  (-0.921235f)/* = xyzGx_32f * 0.950456 */
1715 #define  labGy_32f  1.875991f   /* = xyzGy_32f */
1716 #define  labGz_32f  0.04524426f /* = xyzGz_32f * 1.088754 */
1717
1718 #define  labBx_32f  0.0528909755f /* = xyzBx_32f * 0.950456 */
1719 #define  labBy_32f  (-0.204043f)  /* = xyzBy_32f */
1720 #define  labBz_32f  1.15115158f   /* = xyzBz_32f * 1.088754 */
1721
1722 #define  labT_32f   0.008856f
1723
1724 #define labT   fix(labT_32f*255,lab_shift)
1725
1726 #undef lab_shift
1727 #define lab_shift 10
1728 #define labXr  fix(labXr_32f,lab_shift)
1729 #define labXg  fix(labXg_32f,lab_shift)
1730 #define labXb  fix(labXb_32f,lab_shift)
1731
1732 #define labYr  fix(labYr_32f,lab_shift)
1733 #define labYg  fix(labYg_32f,lab_shift)
1734 #define labYb  fix(labYb_32f,lab_shift)
1735
1736 #define labZr  fix(labZr_32f,lab_shift)
1737 #define labZg  fix(labZg_32f,lab_shift)
1738 #define labZb  fix(labZb_32f,lab_shift)
1739
1740 #define labSmallScale_32f  7.787f
1741 #define labSmallShift_32f  0.13793103448275862f  /* 16/116 */
1742 #define labLScale_32f      116.f
1743 #define labLShift_32f      16.f
1744 #define labLScale2_32f     903.3f
1745
1746 #define labSmallScale fix(31.27 /* labSmallScale_32f*(1<<lab_shift)/255 */,lab_shift)
1747 #define labSmallShift fix(141.24138 /* labSmallScale_32f*(1<<lab) */,lab_shift)
1748 #define labLScale fix(295.8 /* labLScale_32f*255/100 */,lab_shift)
1749 #define labLShift fix(41779.2 /* labLShift_32f*1024*255/100 */,lab_shift)
1750 #define labLScale2 fix(labLScale2_32f*0.01,lab_shift)
1751
1752 /* 1024*(([0..511]./255)**(1./3)) */
1753 static ushort icvLabCubeRootTab[] = {
1754        0,  161,  203,  232,  256,  276,  293,  308,  322,  335,  347,  359,  369,  379,  389,  398,
1755      406,  415,  423,  430,  438,  445,  452,  459,  465,  472,  478,  484,  490,  496,  501,  507,
1756      512,  517,  523,  528,  533,  538,  542,  547,  552,  556,  561,  565,  570,  574,  578,  582,
1757      586,  590,  594,  598,  602,  606,  610,  614,  617,  621,  625,  628,  632,  635,  639,  642,
1758      645,  649,  652,  655,  659,  662,  665,  668,  671,  674,  677,  680,  684,  686,  689,  692,
1759      695,  698,  701,  704,  707,  710,  712,  715,  718,  720,  723,  726,  728,  731,  734,  736,
1760      739,  741,  744,  747,  749,  752,  754,  756,  759,  761,  764,  766,  769,  771,  773,  776,
1761      778,  780,  782,  785,  787,  789,  792,  794,  796,  798,  800,  803,  805,  807,  809,  811,
1762      813,  815,  818,  820,  822,  824,  826,  828,  830,  832,  834,  836,  838,  840,  842,  844,
1763      846,  848,  850,  852,  854,  856,  857,  859,  861,  863,  865,  867,  869,  871,  872,  874,
1764      876,  878,  880,  882,  883,  885,  887,  889,  891,  892,  894,  896,  898,  899,  901,  903,
1765      904,  906,  908,  910,  911,  913,  915,  916,  918,  920,  921,  923,  925,  926,  928,  929,
1766      931,  933,  934,  936,  938,  939,  941,  942,  944,  945,  947,  949,  950,  952,  953,  955,
1767      956,  958,  959,  961,  962,  964,  965,  967,  968,  970,  971,  973,  974,  976,  977,  979,
1768      980,  982,  983,  985,  986,  987,  989,  990,  992,  993,  995,  996,  997,  999, 1000, 1002,
1769     1003, 1004, 1006, 1007, 1009, 1010, 1011, 1013, 1014, 1015, 1017, 1018, 1019, 1021, 1022, 1024,
1770     1025, 1026, 1028, 1029, 1030, 1031, 1033, 1034, 1035, 1037, 1038, 1039, 1041, 1042, 1043, 1044,
1771     1046, 1047, 1048, 1050, 1051, 1052, 1053, 1055, 1056, 1057, 1058, 1060, 1061, 1062, 1063, 1065,
1772     1066, 1067, 1068, 1070, 1071, 1072, 1073, 1074, 1076, 1077, 1078, 1079, 1081, 1082, 1083, 1084,
1773     1085, 1086, 1088, 1089, 1090, 1091, 1092, 1094, 1095, 1096, 1097, 1098, 1099, 1101, 1102, 1103,
1774     1104, 1105, 1106, 1107, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1117, 1118, 1119, 1120, 1121,
1775     1122, 1123, 1124, 1125, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1138, 1139,
1776     1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1154, 1155, 1156,
1777     1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172,
1778     1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188,
1779     1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204,
1780     1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1215, 1216, 1217, 1218, 1219,
1781     1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1230, 1231, 1232, 1233, 1234,
1782     1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249,
1783     1250, 1251, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1259, 1260, 1261, 1262, 1263,
1784     1264, 1265, 1266, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1273, 1274, 1275, 1276, 1277,
1785     1278, 1279, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1285, 1286, 1287, 1288, 1289, 1290, 1291
1786 };
1787
1788
1789 static CvStatus CV_STDCALL
1790 icvBGRx2Lab_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep,
1791                       CvSize size, int src_cn, int blue_idx )
1792 {
1793     int i;
1794
1795     /*if( icvBGR2Lab_8u_C3R_p )
1796         return icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size,
1797                                          src_cn, blue_idx^2, icvBGR2Lab_8u_C3R_p );*/
1798
1799     srcstep -= size.width*src_cn;
1800     size.width *= 3;
1801
1802     for( ; size.height--; src += srcstep, dst += dststep )
1803     {
1804         for( i = 0; i < size.width; i += 3, src += src_cn )
1805         {
1806             int b = src[blue_idx], g = src[1], r = src[2^blue_idx];
1807             int x, y, z, f;
1808             int L, a;
1809
1810             x = b*labXb + g*labXg + r*labXr;
1811             y = b*labYb + g*labYg + r*labYr;
1812             z = b*labZb + g*labZg + r*labZr;
1813
1814             f = x > labT;
1815             x = CV_DESCALE( x, lab_shift );
1816
1817             if( f )
1818                 assert( (unsigned)x < 512 ), x = icvLabCubeRootTab[x];
1819             else
1820                 x = CV_DESCALE(x*labSmallScale + labSmallShift,lab_shift);
1821
1822             f = z > labT;
1823             z = CV_DESCALE( z, lab_shift );
1824
1825             if( f )
1826                 assert( (unsigned)z < 512 ), z = icvLabCubeRootTab[z];
1827             else
1828                 z = CV_DESCALE(z*labSmallScale + labSmallShift,lab_shift);
1829
1830             f = y > labT;
1831             y = CV_DESCALE( y, lab_shift );
1832
1833             if( f )
1834             {
1835                 assert( (unsigned)y < 512 ), y = icvLabCubeRootTab[y];
1836                 L = CV_DESCALE(y*labLScale - labLShift, 2*lab_shift );
1837             }
1838             else
1839             {
1840                 L = CV_DESCALE(y*labLScale2,lab_shift);
1841                 y = CV_DESCALE(y*labSmallScale + labSmallShift,lab_shift);
1842             }
1843
1844             a = CV_DESCALE( 500*(x - y), lab_shift ) + 128;
1845             b = CV_DESCALE( 200*(y - z), lab_shift ) + 128;
1846
1847             dst[i] = CV_CAST_8U(L);
1848             dst[i+1] = CV_CAST_8U(a);
1849             dst[i+2] = CV_CAST_8U(b);
1850         }
1851     }
1852
1853     return CV_OK;
1854 }
1855
1856
1857 static CvStatus CV_STDCALL
1858 icvBGRx2Lab_32f_CnC3R( const float* src, int srcstep, float* dst, int dststep,
1859                        CvSize size, int src_cn, int blue_idx )
1860 {
1861     int i;
1862     srcstep /= sizeof(src[0]);
1863     dststep /= sizeof(dst[0]);
1864     srcstep -= size.width*src_cn;
1865     size.width *= 3;
1866
1867     for( ; size.height--; src += srcstep, dst += dststep )
1868     {
1869         for( i = 0; i < size.width; i += 3, src += src_cn )
1870         {
1871             float b = src[blue_idx], g = src[1], r = src[2^blue_idx];
1872             float x, y, z;
1873             float L, a;
1874
1875             x = b*labXb_32f + g*labXg_32f + r*labXr_32f;
1876             y = b*labYb_32f + g*labYg_32f + r*labYr_32f;
1877             z = b*labZb_32f + g*labZg_32f + r*labZr_32f;
1878
1879             if( x > labT_32f )
1880                 x = cvCbrt(x);
1881             else
1882                 x = x*labSmallScale_32f + labSmallShift_32f;
1883
1884             if( z > labT_32f )
1885                 z = cvCbrt(z);
1886             else
1887                 z = z*labSmallScale_32f + labSmallShift_32f;
1888
1889             if( y > labT_32f )
1890             {
1891                 y = cvCbrt(y);
1892                 L = y*labLScale_32f - labLShift_32f;
1893             }
1894             else
1895             {
1896                 L = y*labLScale2_32f;
1897                 y = y*labSmallScale_32f + labSmallShift_32f;
1898             }
1899
1900             a = 500.f*(x - y);
1901             b = 200.f*(y - z);
1902
1903             dst[i] = L;
1904             dst[i+1] = a;
1905             dst[i+2] = b;
1906         }
1907     }
1908
1909     return CV_OK;
1910 }
1911
1912
1913 static CvStatus CV_STDCALL
1914 icvLab2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, int dststep,
1915                        CvSize size, int dst_cn, int blue_idx )
1916 {
1917     int i;
1918     srcstep /= sizeof(src[0]);
1919     dststep /= sizeof(dst[0]);
1920     dststep -= size.width*dst_cn;
1921     size.width *= 3;
1922
1923     for( ; size.height--; src += srcstep, dst += dststep )
1924     {
1925         for( i = 0; i < size.width; i += 3, dst += dst_cn )
1926         {
1927             float L = src[i], a = src[i+1], b = src[i+2];
1928             float x, y, z;
1929             float g, r;
1930
1931             L = (L + labLShift_32f)*(1.f/labLScale_32f);
1932             x = (L + a*0.002f);
1933             z = (L - b*0.005f);
1934             y = L*L*L;
1935             x = x*x*x;
1936             z = z*z*z;
1937
1938             b = x*labBx_32f + y*labBy_32f + z*labBz_32f;
1939             g = x*labGx_32f + y*labGy_32f + z*labGz_32f;
1940             r = x*labRx_32f + y*labRy_32f + z*labRz_32f;
1941
1942             dst[blue_idx] = b;
1943             dst[1] = g;
1944             dst[blue_idx^2] = r;
1945             if( dst_cn == 4 )
1946                 dst[3] = 0;
1947         }
1948     }
1949
1950     return CV_OK;
1951 }
1952
1953
1954 static CvStatus CV_STDCALL
1955 icvLab2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
1956                       CvSize size, int dst_cn, int blue_idx )
1957 {
1958     // L: [0..255] -> [0..100]
1959     // a: [0..255] -> [-128..127]
1960     // b: [0..255] -> [-128..127]
1961     static const float pre_coeffs[] = { 0.39215686274509809f, 0.f, 1.f, -128.f, 1.f, -128.f };
1962
1963     if( icvLab2BGR_8u_C3R_p )
1964         return icvABC2BGRx_IPP_8u_C3CnR( src, srcstep, dst, dststep, size,
1965                                          dst_cn, blue_idx^2, icvLab2BGR_8u_C3R_p );
1966
1967     return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx,
1968                                  (CvColorCvtFunc2)icvLab2BGRx_32f_C3CnR, pre_coeffs, 1 );
1969 }
1970
1971
1972 /****************************************************************************************\
1973 *                                     RGB <-> L*u*v*                                     *
1974 \****************************************************************************************/
1975
1976 #define luvUn_32f  0.19793943f
1977 #define luvVn_32f  0.46831096f
1978 #define luvYmin_32f  0.05882353f /* 15/255 */
1979
1980 static CvStatus CV_STDCALL
1981 icvBGRx2Luv_32f_CnC3R( const float* src, int srcstep, float* dst, int dststep,
1982                        CvSize size, int src_cn, int blue_idx )
1983 {
1984     int i;
1985
1986     /*if( icvRGB2Luv_32f_C3R_p )
1987         return icvBGRx2ABC_IPP_32f_CnC3R( src, srcstep, dst, dststep, size,
1988                                           src_cn, blue_idx, icvRGB2Luv_32f_C3R_p );*/
1989
1990     srcstep /= sizeof(src[0]);
1991     dststep /= sizeof(dst[0]);
1992     srcstep -= size.width*src_cn;
1993     size.width *= 3;
1994
1995     for( ; size.height--; src += srcstep, dst += dststep )
1996     {
1997         for( i = 0; i < size.width; i += 3, src += src_cn )
1998         {
1999             float b = src[blue_idx], g = src[1], r = src[2^blue_idx];
2000             float x, y, z;
2001             float L, u, v, t;
2002
2003             x = b*xyzXb_32f + g*xyzXg_32f + r*xyzXr_32f;
2004             y = b*xyzYb_32f + g*xyzYg_32f + r*xyzYr_32f;
2005             z = b*xyzZb_32f + g*xyzZg_32f + r*xyzZr_32f;
2006
2007             if( !x && !y && !z )
2008                 L = u = v = 0.f;
2009             else
2010             {
2011                 if( y > labT_32f )
2012                     L = labLScale_32f * cvCbrt(y) - labLShift_32f;
2013                 else
2014                     L = labLScale2_32f * y;
2015
2016                 t = 1.f / (x + 15 * y + 3 * z);
2017                 u = 4.0f * x * t;
2018                 v = 9.0f * y * t;
2019
2020                 u = 13*L*(u - luvUn_32f);
2021                 v = 13*L*(v - luvVn_32f);
2022             }
2023
2024             dst[i] = L;
2025             dst[i+1] = u;
2026             dst[i+2] = v;
2027         }
2028     }
2029
2030     return CV_OK;
2031 }
2032
2033
2034 static CvStatus CV_STDCALL
2035 icvLuv2BGRx_32f_C3CnR( const float* src, int srcstep, float* dst, int dststep,
2036                        CvSize size, int dst_cn, int blue_idx )
2037 {
2038     int i;
2039
2040     /*if( icvLuv2RGB_32f_C3R_p )
2041         return icvABC2BGRx_IPP_32f_C3CnR( src, srcstep, dst, dststep, size,
2042                                           dst_cn, blue_idx, icvLuv2RGB_32f_C3R_p );*/
2043
2044     srcstep /= sizeof(src[0]);
2045     dststep /= sizeof(dst[0]);
2046     dststep -= size.width*dst_cn;
2047     size.width *= 3;
2048
2049     for( ; size.height--; src += srcstep, dst += dststep )
2050     {
2051         for( i = 0; i < size.width; i += 3, dst += dst_cn )
2052         {
2053             float L = src[i], u = src[i+1], v = src[i+2];
2054             float x, y, z, t, u1, v1, b, g, r;
2055
2056             if( L >= 8 )
2057             {
2058                 t = (L + labLShift_32f) * (1.f/labLScale_32f);
2059                 y = t*t*t;
2060             }
2061             else
2062             {
2063                 y = L * (1.f/labLScale2_32f);
2064                 L = MAX( L, 0.001f );
2065             }
2066
2067             t = 1.f/(13.f * L);
2068             u1 = u*t + luvUn_32f;
2069             v1 = v*t + luvVn_32f;
2070             x = 2.25f * u1 * y / v1 ;
2071             z = (12 - 3 * u1 - 20 * v1) * y / (4 * v1);
2072
2073             b = xyzBx_32f*x + xyzBy_32f*y + xyzBz_32f*z;
2074             g = xyzGx_32f*x + xyzGy_32f*y + xyzGz_32f*z;
2075             r = xyzRx_32f*x + xyzRy_32f*y + xyzRz_32f*z;
2076
2077             dst[blue_idx] = b;
2078             dst[1] = g;
2079             dst[blue_idx^2] = r;
2080             if( dst_cn == 4 )
2081                 dst[3] = 0.f;
2082         }
2083     }
2084
2085     return CV_OK;
2086 }
2087
2088
2089 static CvStatus CV_STDCALL
2090 icvBGRx2Luv_8u_CnC3R( const uchar* src, int srcstep, uchar* dst, int dststep,
2091                       CvSize size, int src_cn, int blue_idx )
2092 {
2093     // L: [0..100] -> [0..255]
2094     // u: [-134..220] -> [0..255]
2095     // v: [-140..122] -> [0..255]
2096     //static const float post_coeffs[] = { 2.55f, 0.f, 1.f, 83.f, 1.f, 140.f };
2097     static const float post_coeffs[] = { 2.55f, 0.f, 0.72033898305084743f, 96.525423728813564f,
2098                                          0.99609375f, 139.453125f };
2099
2100     if( icvRGB2Luv_8u_C3R_p )
2101         return icvBGRx2ABC_IPP_8u_CnC3R( src, srcstep, dst, dststep, size,
2102                                          src_cn, blue_idx, icvRGB2Luv_8u_C3R_p );
2103
2104     return icvBGRx2ABC_8u_CnC3R( src, srcstep, dst, dststep, size, src_cn, blue_idx,
2105                                  (CvColorCvtFunc2)icvBGRx2Luv_32f_CnC3R, 1, post_coeffs );
2106 }
2107
2108
2109 static CvStatus CV_STDCALL
2110 icvLuv2BGRx_8u_C3CnR( const uchar* src, int srcstep, uchar* dst, int dststep,
2111                       CvSize size, int dst_cn, int blue_idx )
2112 {
2113     // L: [0..255] -> [0..100]
2114     // u: [0..255] -> [-134..220]
2115     // v: [0..255] -> [-140..122]
2116     static const float pre_coeffs[] = { 0.39215686274509809f, 0.f, 1.388235294117647f, -134.f,
2117                                         1.003921568627451f, -140.f };
2118
2119     if( icvLuv2RGB_8u_C3R_p )
2120         return icvABC2BGRx_IPP_8u_C3CnR( src, srcstep, dst, dststep, size,
2121                                          dst_cn, blue_idx, icvLuv2RGB_8u_C3R_p );
2122
2123     return icvABC2BGRx_8u_C3CnR( src, srcstep, dst, dststep, size, dst_cn, blue_idx,
2124                                  (CvColorCvtFunc2)icvLuv2BGRx_32f_C3CnR, pre_coeffs, 1 );
2125 }
2126
2127 /****************************************************************************************\
2128 *                            Bayer Pattern -> RGB conversion                             *
2129 \****************************************************************************************/
2130
2131 static CvStatus CV_STDCALL
2132 icvBayer2BGR_8u_C1C3R( const uchar* bayer0, int bayer_step,
2133                        uchar *dst0, int dst_step,
2134                        CvSize size, int code )
2135 {
2136     int blue = code == CV_BayerBG2BGR || code == CV_BayerGB2BGR ? -1 : 1;
2137     int start_with_green = code == CV_BayerGB2BGR || code == CV_BayerGR2BGR;
2138
2139     memset( dst0, 0, size.width*3*sizeof(dst0[0]) );
2140     memset( dst0 + (size.height - 1)*dst_step, 0, size.width*3*sizeof(dst0[0]) );
2141     dst0 += dst_step + 3 + 1;
2142     size.height -= 2;
2143     size.width -= 2;
2144
2145     for( ; size.height-- > 0; bayer0 += bayer_step, dst0 += dst_step )
2146     {
2147         int t0, t1;
2148         const uchar* bayer = bayer0;
2149         uchar* dst = dst0;
2150         const uchar* bayer_end = bayer + size.width;
2151
2152         dst[-4] = dst[-3] = dst[-2] = dst[size.width*3-1] =
2153             dst[size.width*3] = dst[size.width*3+1] = 0;
2154
2155         if( size.width <= 0 )
2156             continue;
2157
2158         if( start_with_green )
2159         {
2160             t0 = (bayer[1] + bayer[bayer_step*2+1] + 1) >> 1;
2161             t1 = (bayer[bayer_step] + bayer[bayer_step+2] + 1) >> 1;
2162             dst[-blue] = (uchar)t0;
2163             dst[0] = bayer[bayer_step+1];
2164             dst[blue] = (uchar)t1;
2165             bayer++;
2166             dst += 3;
2167         }
2168
2169         if( blue > 0 )
2170         {
2171             for( ; bayer <= bayer_end - 2; bayer += 2, dst += 6 )
2172             {
2173                 t0 = (bayer[0] + bayer[2] + bayer[bayer_step*2] +
2174                       bayer[bayer_step*2+2] + 2) >> 2;
2175                 t1 = (bayer[1] + bayer[bayer_step] +
2176                       bayer[bayer_step+2] + bayer[bayer_step*2+1]+2) >> 2;
2177                 dst[-1] = (uchar)t0;
2178                 dst[0] = (uchar)t1;
2179                 dst[1] = bayer[bayer_step+1];
2180
2181                 t0 = (bayer[2] + bayer[bayer_step*2+2] + 1) >> 1;
2182                 t1 = (bayer[bayer_step+1] + bayer[bayer_step+3] + 1) >> 1;
2183                 dst[2] = (uchar)t0;
2184                 dst[3] = bayer[bayer_step+2];
2185                 dst[4] = (uchar)t1;
2186             }
2187         }
2188         else
2189         {
2190             for( ; bayer <= bayer_end - 2; bayer += 2, dst += 6 )
2191             {
2192                 t0 = (bayer[0] + bayer[2] + bayer[bayer_step*2] +
2193                       bayer[bayer_step*2+2] + 2) >> 2;
2194                 t1 = (bayer[1] + bayer[bayer_step] +
2195                       bayer[bayer_step+2] + bayer[bayer_step*2+1]+2) >> 2;
2196                 dst[1] = (uchar)t0;
2197                 dst[0] = (uchar)t1;
2198                 dst[-1] = bayer[bayer_step+1];
2199
2200                 t0 = (bayer[2] + bayer[bayer_step*2+2] + 1) >> 1;
2201                 t1 = (bayer[bayer_step+1] + bayer[bayer_step+3] + 1) >> 1;
2202                 dst[4] = (uchar)t0;
2203                 dst[3] = bayer[bayer_step+2];
2204                 dst[2] = (uchar)t1;
2205             }
2206         }
2207
2208         if( bayer < bayer_end )
2209         {
2210             t0 = (bayer[0] + bayer[2] + bayer[bayer_step*2] +
2211                   bayer[bayer_step*2+2] + 2) >> 2;
2212             t1 = (bayer[1] + bayer[bayer_step] +
2213                   bayer[bayer_step+2] + bayer[bayer_step*2+1]+2) >> 2;
2214             dst[-blue] = (uchar)t0;
2215             dst[0] = (uchar)t1;
2216             dst[blue] = bayer[bayer_step+1];
2217             bayer++;
2218             dst += 3;
2219         }
2220
2221         blue = -blue;
2222         start_with_green = !start_with_green;
2223     }
2224
2225     return CV_OK;
2226 }
2227
2228
2229 /****************************************************************************************\
2230 *                                   The main function                                    *
2231 \****************************************************************************************/
2232
2233 CV_IMPL void
2234 cvCvtColor( const CvArr* srcarr, CvArr* dstarr, int code )
2235 {
2236     CV_FUNCNAME( "cvCvtColor" );
2237
2238     __BEGIN__;
2239
2240     CvMat srcstub, *src = (CvMat*)srcarr;
2241     CvMat dststub, *dst = (CvMat*)dstarr;
2242     CvSize size;
2243     int src_step, dst_step;
2244     int src_cn, dst_cn, depth;
2245     CvColorCvtFunc0 func0 = 0;
2246     CvColorCvtFunc1 func1 = 0;
2247     CvColorCvtFunc2 func2 = 0;
2248     CvColorCvtFunc3 func3 = 0;
2249     int param[] = { 0, 0, 0, 0 };
2250
2251     CV_CALL( src = cvGetMat( srcarr, &srcstub ));
2252     CV_CALL( dst = cvGetMat( dstarr, &dststub ));
2253
2254     if( !CV_ARE_SIZES_EQ( src, dst ))
2255         CV_ERROR( CV_StsUnmatchedSizes, "" );
2256
2257     if( !CV_ARE_DEPTHS_EQ( src, dst ))
2258         CV_ERROR( CV_StsUnmatchedFormats, "" );
2259
2260     depth = CV_MAT_DEPTH(src->type);
2261     if( depth != CV_8U && depth != CV_16U && depth != CV_32F )
2262         CV_ERROR( CV_StsUnsupportedFormat, "" );
2263
2264     src_cn = CV_MAT_CN( src->type );
2265     dst_cn = CV_MAT_CN( dst->type );
2266     size = cvGetMatSize( src );
2267     src_step = src->step;
2268     dst_step = dst->step;
2269
2270     if( CV_IS_MAT_CONT(src->type & dst->type) &&
2271         code != CV_BayerBG2BGR && code != CV_BayerGB2BGR &&
2272         code != CV_BayerRG2BGR && code != CV_BayerGR2BGR )
2273     {
2274         size.width *= size.height;
2275         size.height = 1;
2276         src_step = dst_step = CV_STUB_STEP;
2277     }
2278
2279     switch( code )
2280     {
2281     case CV_BGR2BGRA:
2282     case CV_RGB2BGRA:
2283         if( src_cn != 3 || dst_cn != 4 )
2284             CV_ERROR( CV_BadNumChannels,
2285             "Incorrect number of channels for this conversion code" );
2286
2287         func1 = depth == CV_8U ? (CvColorCvtFunc1)icvBGR2BGRx_8u_C3C4R :
2288                 depth == CV_16U ? (CvColorCvtFunc1)icvBGR2BGRx_16u_C3C4R :
2289                 depth == CV_32F ? (CvColorCvtFunc1)icvBGR2BGRx_32f_C3C4R : 0;
2290         param[0] = code == CV_BGR2BGRA ? 0 : 2; // blue_idx
2291         break;
2292
2293     case CV_BGRA2BGR:
2294     case CV_RGBA2BGR:
2295     case CV_RGB2BGR:
2296         if( (src_cn != 3 && src_cn != 4) || dst_cn != 3 )
2297             CV_ERROR( CV_BadNumChannels,
2298             "Incorrect number of channels for this conversion code" );
2299
2300         func2 = depth == CV_8U ? (CvColorCvtFunc2)icvBGRx2BGR_8u_CnC3R :
2301                 depth == CV_16U ? (CvColorCvtFunc2)icvBGRx2BGR_16u_CnC3R :
2302                 depth == CV_32F ? (CvColorCvtFunc2)icvBGRx2BGR_32f_CnC3R : 0;
2303         param[0] = src_cn;
2304         param[1] = code == CV_BGRA2BGR ? 0 : 2; // blue_idx
2305         break;
2306
2307     case CV_BGRA2RGBA:
2308         if( src_cn != 4 || dst_cn != 4 )
2309             CV_ERROR( CV_BadNumChannels,
2310             "Incorrect number of channels for this conversion code" );
2311
2312         func0 = depth == CV_8U ? (CvColorCvtFunc0)icvBGRA2RGBA_8u_C4R :
2313                 depth == CV_16U ? (CvColorCvtFunc0)icvBGRA2RGBA_16u_C4R :
2314                 depth == CV_32F ? (CvColorCvtFunc0)icvBGRA2RGBA_32f_C4R : 0;
2315         break;
2316
2317     case CV_BGR2BGR565:
2318     case CV_BGR2BGR555:
2319     case CV_RGB2BGR565:
2320     case CV_RGB2BGR555:
2321     case CV_BGRA2BGR565:
2322     case CV_BGRA2BGR555:
2323     case CV_RGBA2BGR565:
2324     case CV_RGBA2BGR555:
2325         if( (src_cn != 3 && src_cn != 4) || dst_cn != 2 )
2326             CV_ERROR( CV_BadNumChannels,
2327             "Incorrect number of channels for this conversion code" );
2328
2329         if( depth != CV_8U )
2330             CV_ERROR( CV_BadDepth,
2331             "Conversion to/from 16-bit packed RGB format "
2332             "is only possible for 8-bit images (8-bit grayscale, 888 BGR/RGB or 8888 BGRA/RGBA)" );
2333
2334         func3 = (CvColorCvtFunc3)icvBGRx2BGR5x5_8u_CnC2R;
2335         param[0] = src_cn;
2336         param[1] = code == CV_BGR2BGR565 || code == CV_BGR2BGR555 ||
2337                    code == CV_BGRA2BGR565 || code == CV_BGRA2BGR555 ? 0 : 2; // blue_idx
2338         param[2] = code == CV_BGR2BGR565 || code == CV_RGB2BGR565 ||
2339                    code == CV_BGRA2BGR565 || code == CV_RGBA2BGR565 ? 6 : 5; // green_bits
2340         break;
2341
2342     case CV_BGR5652BGR:
2343     case CV_BGR5552BGR:
2344     case CV_BGR5652RGB:
2345     case CV_BGR5552RGB:
2346     case CV_BGR5652BGRA:
2347     case CV_BGR5552BGRA:
2348     case CV_BGR5652RGBA:
2349     case CV_BGR5552RGBA:
2350         if( src_cn != 2 || (dst_cn != 3 && dst_cn != 4))
2351             CV_ERROR( CV_BadNumChannels,
2352             "Incorrect number of channels for this conversion code" );
2353
2354         if( depth != CV_8U )
2355             CV_ERROR( CV_BadDepth,
2356             "Conversion to/from 16-bit packed BGR format "
2357             "is only possible for 8-bit images (8-bit grayscale, 888 BGR/BGR or 8888 BGRA/BGRA)" );
2358
2359         func3 = (CvColorCvtFunc3)icvBGR5x52BGRx_8u_C2CnR;
2360         param[0] = dst_cn;
2361         param[1] = code == CV_BGR5652BGR || code == CV_BGR5552BGR ||
2362                    code == CV_BGR5652BGRA || code == CV_BGR5552BGRA ? 0 : 2; // blue_idx
2363         param[2] = code == CV_BGR5652BGR || code == CV_BGR5652RGB ||
2364                    code == CV_BGR5652BGRA || code == CV_BGR5652RGBA ? 6 : 5; // green_bits
2365         break;
2366
2367     case CV_BGR2GRAY:
2368     case CV_BGRA2GRAY:
2369     case CV_RGB2GRAY:
2370     case CV_RGBA2GRAY:
2371         if( (src_cn != 3 && src_cn != 4) || dst_cn != 1 )
2372             CV_ERROR( CV_BadNumChannels,
2373             "Incorrect number of channels for this conversion code" );
2374
2375         func2 = depth == CV_8U ? (CvColorCvtFunc2)icvBGRx2Gray_8u_CnC1R :
2376                 depth == CV_16U ? (CvColorCvtFunc2)icvBGRx2Gray_16u_CnC1R :
2377                 depth == CV_32F ? (CvColorCvtFunc2)icvBGRx2Gray_32f_CnC1R : 0;
2378
2379         param[0] = src_cn;
2380         param[1] = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2;
2381         break;
2382
2383     case CV_BGR5652GRAY:
2384     case CV_BGR5552GRAY:
2385         if( src_cn != 2 || dst_cn != 1 )
2386             CV_ERROR( CV_BadNumChannels,
2387             "Incorrect number of channels for this conversion code" );
2388
2389         if( depth != CV_8U )
2390             CV_ERROR( CV_BadDepth,
2391             "Conversion to/from 16-bit packed BGR format "
2392             "is only possible for 8-bit images (888 BGR/BGR or 8888 BGRA/BGRA)" );
2393
2394         func2 = (CvColorCvtFunc2)icvBGR5x52Gray_8u_C2C1R;
2395
2396         param[0] = code == CV_BGR5652GRAY ? 6 : 5; // green_bits
2397         break;
2398
2399     case CV_GRAY2BGR:
2400     case CV_GRAY2BGRA:
2401         if( src_cn != 1 || (dst_cn != 3 && dst_cn != 4))
2402             CV_ERROR( CV_BadNumChannels,
2403             "Incorrect number of channels for this conversion code" );
2404
2405         func1 = depth == CV_8U ? (CvColorCvtFunc1)icvGray2BGRx_8u_C1CnR :
2406                 depth == CV_16U ? (CvColorCvtFunc1)icvGray2BGRx_16u_C1CnR :
2407                 depth == CV_32F ? (CvColorCvtFunc1)icvGray2BGRx_32f_C1CnR : 0;
2408
2409         param[0] = dst_cn;
2410         break;
2411
2412     case CV_GRAY2BGR565:
2413     case CV_GRAY2BGR555:
2414         if( src_cn != 1 || dst_cn != 2 )
2415             CV_ERROR( CV_BadNumChannels,
2416             "Incorrect number of channels for this conversion code" );
2417
2418         if( depth != CV_8U )
2419             CV_ERROR( CV_BadDepth,
2420             "Conversion to/from 16-bit packed BGR format "
2421             "is only possible for 8-bit images (888 BGR/BGR or 8888 BGRA/BGRA)" );
2422
2423         func2 = (CvColorCvtFunc2)icvGray2BGR5x5_8u_C1C2R;
2424         param[0] = code == CV_GRAY2BGR565 ? 6 : 5; // green_bits
2425         break;
2426
2427     case CV_BGR2YCrCb:
2428     case CV_RGB2YCrCb:
2429     case CV_BGR2XYZ:
2430     case CV_RGB2XYZ:
2431     case CV_BGR2HSV:
2432     case CV_RGB2HSV:
2433     case CV_BGR2Lab:
2434     case CV_RGB2Lab:
2435     case CV_BGR2Luv:
2436     case CV_RGB2Luv:
2437     case CV_BGR2HLS:
2438     case CV_RGB2HLS:
2439         if( (src_cn != 3 && src_cn != 4) || dst_cn != 3 )
2440             CV_ERROR( CV_BadNumChannels,
2441             "Incorrect number of channels for this conversion code" );
2442
2443         if( depth == CV_8U )
2444             func2 = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? (CvColorCvtFunc2)icvBGRx2YCrCb_8u_CnC3R :
2445                     code == CV_BGR2XYZ || code == CV_RGB2XYZ ? (CvColorCvtFunc2)icvBGRx2XYZ_8u_CnC3R :
2446                     code == CV_BGR2HSV || code == CV_RGB2HSV ? (CvColorCvtFunc2)icvBGRx2HSV_8u_CnC3R :
2447                     code == CV_BGR2Lab || code == CV_RGB2Lab ? (CvColorCvtFunc2)icvBGRx2Lab_8u_CnC3R :
2448                     code == CV_BGR2Luv || code == CV_RGB2Luv ? (CvColorCvtFunc2)icvBGRx2Luv_8u_CnC3R :
2449                     code == CV_BGR2HLS || code == CV_RGB2HLS ? (CvColorCvtFunc2)icvBGRx2HLS_8u_CnC3R : 0;
2450         else if( depth == CV_16U )
2451             func2 = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? (CvColorCvtFunc2)icvBGRx2YCrCb_16u_CnC3R :
2452                     code == CV_BGR2XYZ || code == CV_RGB2XYZ ? (CvColorCvtFunc2)icvBGRx2XYZ_16u_CnC3R : 0;
2453         else if( depth == CV_32F )
2454             func2 = code == CV_BGR2YCrCb || code == CV_RGB2YCrCb ? (CvColorCvtFunc2)icvBGRx2YCrCb_32f_CnC3R :
2455                     code == CV_BGR2XYZ || code == CV_RGB2XYZ ? (CvColorCvtFunc2)icvBGRx2XYZ_32f_CnC3R :
2456                     code == CV_BGR2HSV || code == CV_RGB2HSV ? (CvColorCvtFunc2)icvBGRx2HSV_32f_CnC3R :
2457                     code == CV_BGR2Lab || code == CV_RGB2Lab ? (CvColorCvtFunc2)icvBGRx2Lab_32f_CnC3R :
2458                     code == CV_BGR2Luv || code == CV_RGB2Luv ? (CvColorCvtFunc2)icvBGRx2Luv_32f_CnC3R :
2459                     code == CV_BGR2HLS || code == CV_RGB2HLS ? (CvColorCvtFunc2)icvBGRx2HLS_32f_CnC3R : 0;
2460
2461         param[0] = src_cn;
2462         param[1] = code == CV_BGR2XYZ || code == CV_BGR2YCrCb || code == CV_BGR2HSV ||
2463                    code == CV_BGR2Lab || code == CV_BGR2Luv || code == CV_BGR2HLS ? 0 : 2;
2464         break;
2465
2466     case CV_YCrCb2BGR:
2467     case CV_YCrCb2RGB:
2468     case CV_XYZ2BGR:
2469     case CV_XYZ2RGB:
2470     case CV_HSV2BGR:
2471     case CV_HSV2RGB:
2472     case CV_Lab2BGR:
2473     case CV_Lab2RGB:
2474     case CV_Luv2BGR:
2475     case CV_Luv2RGB:
2476     case CV_HLS2BGR:
2477     case CV_HLS2RGB:
2478         if( src_cn != 3 || (dst_cn != 3 && dst_cn != 4) )
2479             CV_ERROR( CV_BadNumChannels,
2480             "Incorrect number of channels for this conversion code" );
2481
2482         if( depth == CV_8U )
2483             func2 = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? (CvColorCvtFunc2)icvYCrCb2BGRx_8u_C3CnR :
2484                     code == CV_XYZ2BGR || code == CV_XYZ2RGB ? (CvColorCvtFunc2)icvXYZ2BGRx_8u_C3CnR :
2485                     code == CV_HSV2BGR || code == CV_HSV2RGB ? (CvColorCvtFunc2)icvHSV2BGRx_8u_C3CnR :
2486                     code == CV_HLS2BGR || code == CV_HLS2RGB ? (CvColorCvtFunc2)icvHLS2BGRx_8u_C3CnR :
2487                     code == CV_Lab2BGR || code == CV_Lab2RGB ? (CvColorCvtFunc2)icvLab2BGRx_8u_C3CnR :
2488                     code == CV_Luv2BGR || code == CV_Luv2RGB ? (CvColorCvtFunc2)icvLuv2BGRx_8u_C3CnR : 0;
2489         else if( depth == CV_16U )
2490             func2 = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? (CvColorCvtFunc2)icvYCrCb2BGRx_16u_C3CnR :
2491                     code == CV_XYZ2BGR || code == CV_XYZ2RGB ? (CvColorCvtFunc2)icvXYZ2BGRx_16u_C3CnR : 0;
2492         else if( depth == CV_32F )
2493             func2 = code == CV_YCrCb2BGR || code == CV_YCrCb2RGB ? (CvColorCvtFunc2)icvYCrCb2BGRx_32f_C3CnR :
2494                     code == CV_XYZ2BGR || code == CV_XYZ2RGB ? (CvColorCvtFunc2)icvXYZ2BGRx_32f_C3CnR :
2495                     code == CV_HSV2BGR || code == CV_HSV2RGB ? (CvColorCvtFunc2)icvHSV2BGRx_32f_C3CnR :
2496                     code == CV_HLS2BGR || code == CV_HLS2RGB ? (CvColorCvtFunc2)icvHLS2BGRx_32f_C3CnR :
2497                     code == CV_Lab2BGR || code == CV_Lab2RGB ? (CvColorCvtFunc2)icvLab2BGRx_32f_C3CnR :
2498                     code == CV_Luv2BGR || code == CV_Luv2RGB ? (CvColorCvtFunc2)icvLuv2BGRx_32f_C3CnR : 0;
2499
2500         param[0] = dst_cn;
2501         param[1] = code == CV_XYZ2BGR || code == CV_YCrCb2BGR || code == CV_HSV2BGR ||
2502                    code == CV_Lab2BGR || code == CV_Luv2BGR || code == CV_HLS2BGR ? 0 : 2;
2503         break;
2504
2505     case CV_BayerBG2BGR:
2506     case CV_BayerGB2BGR:
2507     case CV_BayerRG2BGR:
2508     case CV_BayerGR2BGR:
2509         if( src_cn != 1 || dst_cn != 3 )
2510             CV_ERROR( CV_BadNumChannels,
2511             "Incorrect number of channels for this conversion code" );
2512
2513         if( depth != CV_8U )
2514             CV_ERROR( CV_BadDepth,
2515             "Bayer pattern can be converted only to 8-bit 3-channel BGR/RGB image" );
2516
2517         func1 = (CvColorCvtFunc1)icvBayer2BGR_8u_C1C3R;
2518         param[0] = code; // conversion code
2519         break;
2520     default:
2521         CV_ERROR( CV_StsBadFlag, "Unknown/unsupported color conversion code" );
2522     }
2523
2524     if( func0 )
2525     {
2526         IPPI_CALL( func0( src->data.ptr, src_step, dst->data.ptr, dst_step, size ));
2527     }
2528     else if( func1 )
2529     {
2530         IPPI_CALL( func1( src->data.ptr, src_step,
2531             dst->data.ptr, dst_step, size, param[0] ));
2532     }
2533     else if( func2 )
2534     {
2535         IPPI_CALL( func2( src->data.ptr, src_step,
2536             dst->data.ptr, dst_step, size, param[0], param[1] ));
2537     }
2538     else if( func3 )
2539     {
2540         IPPI_CALL( func3( src->data.ptr, src_step,
2541             dst->data.ptr, dst_step, size, param[0], param[1], param[2] ));
2542     }
2543     else
2544         CV_ERROR( CV_StsUnsupportedFormat, "The image format is not supported" );
2545
2546     __END__;
2547 }
2548
2549 /* End of file. */
2550
2551