libswscale/yuv2rgb.c

   1 /*
   2  * yuv2rgb.c, Software YUV to RGB converter
   3  *
   4  *  Copyright (C) 1999, Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
   5  *
   6  *  Functions broken out from display_x11.c and several new modes
   7  *  added by Håkan Hjort <d95hjort@dtek.chalmers.se>
   8  *
   9  *  15 & 16 bpp support by Franck Sicard <Franck.Sicard@solsoft.fr>
  10  *
  11  *  MMX/MMX2 template stuff (needed for fast movntq support),
  12  *  1,4,8bpp support and context / deglobalize stuff
  13  *  by Michael Niedermayer (michaelni@gmx.at)
  14  *
  15  *  This file is part of mpeg2dec, a free MPEG-2 video decoder
  16  *
  17  *  mpeg2dec is free software; you can redistribute it and/or modify
  18  *  it under the terms of the GNU General Public License as published by
  19  *  the Free Software Foundation; either version 2, or (at your option)
  20  *  any later version.
  21  *
  22  *  mpeg2dec is distributed in the hope that it will be useful,
  23  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  *  GNU General Public License for more details.
  26  *
  27  *  You should have received a copy of the GNU General Public License
  28  *  along with mpeg2dec; if not, write to the Free Software
  29  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  30  */
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <inttypes.h>
  35 #include <assert.h>
  36
  37 #include "config.h"
  38 #include "rgb2rgb.h"
  39 #include "swscale.h"
  40 #include "swscale_internal.h"
  41
  42 #define DITHER1XBPP // only for MMX
  43
  44 extern const uint8_t dither_8x8_32[8][8];
  45 extern const uint8_t dither_8x8_73[8][8];
  46 extern const uint8_t dither_8x8_220[8][8];
  47
  48 #if HAVE_MMX
  49
  50 /* hope these constant values are cache line aligned */
  51 DECLARE_ASM_CONST(8, uint64_t, mmx_00ffw)   = 0x00ff00ff00ff00ffULL;
  52 DECLARE_ASM_CONST(8, uint64_t, mmx_redmask) = 0xf8f8f8f8f8f8f8f8ULL;
  53 DECLARE_ASM_CONST(8, uint64_t, mmx_grnmask) = 0xfcfcfcfcfcfcfcfcULL;
  54
  55 //MMX versions
  56 #undef RENAME
  57 #undef HAVE_MMX2
  58 #undef HAVE_AMD3DNOW
  59 #define HAVE_MMX2 0
  60 #define HAVE_AMD3DNOW 0
  61 #define RENAME(a) a ## _MMX
  62 #include "yuv2rgb_template.c"
  63
  64 //MMX2 versions
  65 #undef RENAME
  66 #undef HAVE_MMX2
  67 #define HAVE_MMX2 1
  68 #define RENAME(a) a ## _MMX2
  69 #include "yuv2rgb_template.c"
  70
  71 #endif /* HAVE_MMX */
  72
  73 const int32_t Inverse_Table_6_9[8][4] = {
  74     {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
  75     {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
  76     {104597, 132201, 25675, 53279}, /* unspecified */
  77     {104597, 132201, 25675, 53279}, /* reserved */
  78     {104448, 132798, 24759, 53109}, /* FCC */
  79     {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
  80     {104597, 132201, 25675, 53279}, /* SMPTE 170M */
  81     {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
  82 };
  83
  84 #define RGB(i)                                      \
  85     U = pu[i];                                      \
  86     V = pv[i];                                      \
  87     r = (void *)c->table_rV[V];                     \
  88     g = (void *)(c->table_gU[U] + c->table_gV[V]);  \
  89     b = (void *)c->table_bU[U];
  90
  91 #define DST1(i)                         \
  92     Y = py_1[2*i];                      \
  93     dst_1[2*i] = r[Y] + g[Y] + b[Y];    \
  94     Y = py_1[2*i+1];                    \
  95     dst_1[2*i+1] = r[Y] + g[Y] + b[Y];
  96
  97 #define DST2(i)                         \
  98     Y = py_2[2*i];                      \
  99     dst_2[2*i] = r[Y] + g[Y] + b[Y];    \
 100     Y = py_2[2*i+1];                    \
 101     dst_2[2*i+1] = r[Y] + g[Y] + b[Y];
 102
 103 #define DST1RGB(i)                                                \
 104     Y = py_1[2*i];                                                \
 105     dst_1[6*i] = r[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = b[Y];  \
 106     Y = py_1[2*i+1];                                              \
 107     dst_1[6*i+3] = r[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = b[Y];
 108
 109 #define DST2RGB(i)                                                \
 110     Y = py_2[2*i];                                                \
 111     dst_2[6*i] = r[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = b[Y];  \
 112     Y = py_2[2*i+1];                                              \
 113     dst_2[6*i+3] = r[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = b[Y];
 114
 115 #define DST1BGR(i)                                                \
 116     Y = py_1[2*i];                                                \
 117     dst_1[6*i] = b[Y]; dst_1[6*i+1] = g[Y]; dst_1[6*i+2] = r[Y];  \
 118     Y = py_1[2*i+1];                                              \
 119     dst_1[6*i+3] = b[Y]; dst_1[6*i+4] = g[Y]; dst_1[6*i+5] = r[Y];
 120
 121 #define DST2BGR(i)                                                \
 122     Y = py_2[2*i];                                                \
 123     dst_2[6*i] = b[Y]; dst_2[6*i+1] = g[Y]; dst_2[6*i+2] = r[Y];  \
 124     Y = py_2[2*i+1];                                              \
 125     dst_2[6*i+3] = b[Y]; dst_2[6*i+4] = g[Y]; dst_2[6*i+5] = r[Y];
 126
 127 #define PROLOG(func_name, dst_type) \
 128 static int func_name(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY, \
 129                      int srcSliceH, uint8_t* dst[], int dstStride[]){\
 130     int y;\
 131 \
 132     if (c->srcFormat == PIX_FMT_YUV422P){\
 133         srcStride[1] *= 2;\
 134         srcStride[2] *= 2;\
 135     }\
 136     for (y=0; y<srcSliceH; y+=2){\
 137         dst_type *dst_1= (dst_type*)(dst[0] + (y+srcSliceY  )*dstStride[0]);\
 138         dst_type *dst_2= (dst_type*)(dst[0] + (y+srcSliceY+1)*dstStride[0]);\
 139         dst_type av_unused *r, *b;\
 140         dst_type *g;\
 141         uint8_t *py_1= src[0] + y*srcStride[0];\
 142         uint8_t *py_2= py_1 + srcStride[0];\
 143         uint8_t *pu= src[1] + (y>>1)*srcStride[1];\
 144         uint8_t *pv= src[2] + (y>>1)*srcStride[2];\
 145         unsigned int h_size= c->dstW>>3;\
 146         while (h_size--) {\
 147             int av_unused U, V;\
 148             int Y;\
 149
 150 #define EPILOG1(dst_delta)\
 151             pu += 4;\
 152             pv += 4;\
 153             py_1 += 8;\
 154             py_2 += 8;\
 155             dst_1 += dst_delta;\
 156             dst_2 += dst_delta;\
 157         }\
 158         if (c->dstW & 4) {\
 159             int av_unused Y, U, V;\
 160
 161 #define EPILOG2()\
 162         }\
 163     }\
 164     return srcSliceH;\
 165 }
 166
 167 #define EPILOG(dst_delta)\
 168     EPILOG1(dst_delta)\
 169     EPILOG2()
 170
 171 PROLOG(yuv2rgb_c_32, uint32_t)
 172     RGB(0);
 173     DST1(0);
 174     DST2(0);
 175
 176     RGB(1);
 177     DST2(1);
 178     DST1(1);
 179
 180     RGB(2);
 181     DST1(2);
 182     DST2(2);
 183
 184     RGB(3);
 185     DST2(3);
 186     DST1(3);
 187 EPILOG1(8)
 188     RGB(0);
 189     DST1(0);
 190     DST2(0);
 191
 192     RGB(1);
 193     DST2(1);
 194     DST1(1);
 195 EPILOG2()
 196
 197 PROLOG(yuv2rgb_c_24_rgb, uint8_t)
 198     RGB(0);
 199     DST1RGB(0);
 200     DST2RGB(0);
 201
 202     RGB(1);
 203     DST2RGB(1);
 204     DST1RGB(1);
 205
 206     RGB(2);
 207     DST1RGB(2);
 208     DST2RGB(2);
 209
 210     RGB(3);
 211     DST2RGB(3);
 212     DST1RGB(3);
 213 EPILOG1(24)
 214     RGB(0);
 215     DST1RGB(0);
 216     DST2RGB(0);
 217
 218     RGB(1);
 219     DST2RGB(1);
 220     DST1RGB(1);
 221 EPILOG2()
 222
 223 // only trivial mods from yuv2rgb_c_24_rgb
 224 PROLOG(yuv2rgb_c_24_bgr, uint8_t)
 225     RGB(0);
 226     DST1BGR(0);
 227     DST2BGR(0);
 228
 229     RGB(1);
 230     DST2BGR(1);
 231     DST1BGR(1);
 232
 233     RGB(2);
 234     DST1BGR(2);
 235     DST2BGR(2);
 236
 237     RGB(3);
 238     DST2BGR(3);
 239     DST1BGR(3);
 240 EPILOG1(24)
 241     RGB(0);
 242     DST1BGR(0);
 243     DST2BGR(0);
 244
 245     RGB(1);
 246     DST2BGR(1);
 247     DST1BGR(1);
 248 EPILOG2()
 249
 250 // This is exactly the same code as yuv2rgb_c_32 except for the types of
 251 // r, g, b, dst_1, dst_2
 252 PROLOG(yuv2rgb_c_16, uint16_t)
 253     RGB(0);
 254     DST1(0);
 255     DST2(0);
 256
 257     RGB(1);
 258     DST2(1);
 259     DST1(1);
 260
 261     RGB(2);
 262     DST1(2);
 263     DST2(2);
 264
 265     RGB(3);
 266     DST2(3);
 267     DST1(3);
 268 EPILOG(8)
 269
 270 // This is exactly the same code as yuv2rgb_c_32 except for the types of
 271 // r, g, b, dst_1, dst_2
 272 PROLOG(yuv2rgb_c_8, uint8_t)
 273     RGB(0);
 274     DST1(0);
 275     DST2(0);
 276
 277     RGB(1);
 278     DST2(1);
 279     DST1(1);
 280
 281     RGB(2);
 282     DST1(2);
 283     DST2(2);
 284
 285     RGB(3);
 286     DST2(3);
 287     DST1(3);
 288 EPILOG(8)
 289
 290 // r, g, b, dst_1, dst_2
 291 PROLOG(yuv2rgb_c_8_ordered_dither, uint8_t)
 292     const uint8_t *d32= dither_8x8_32[y&7];
 293     const uint8_t *d64= dither_8x8_73[y&7];
 294 #define DST1bpp8(i,o)                                               \
 295     Y = py_1[2*i];                                                  \
 296     dst_1[2*i]   = r[Y+d32[0+o]] + g[Y+d32[0+o]] + b[Y+d64[0+o]];   \
 297     Y = py_1[2*i+1];                                                \
 298     dst_1[2*i+1] = r[Y+d32[1+o]] + g[Y+d32[1+o]] + b[Y+d64[1+o]];
 299
 300 #define DST2bpp8(i,o)                                               \
 301     Y = py_2[2*i];                                                  \
 302     dst_2[2*i]   =  r[Y+d32[8+o]] + g[Y+d32[8+o]] + b[Y+d64[8+o]];  \
 303     Y = py_2[2*i+1];                                                \
 304     dst_2[2*i+1] =  r[Y+d32[9+o]] + g[Y+d32[9+o]] + b[Y+d64[9+o]];
 305
 306
 307     RGB(0);
 308     DST1bpp8(0,0);
 309     DST2bpp8(0,0);
 310
 311     RGB(1);
 312     DST2bpp8(1,2);
 313     DST1bpp8(1,2);
 314
 315     RGB(2);
 316     DST1bpp8(2,4);
 317     DST2bpp8(2,4);
 318
 319     RGB(3);
 320     DST2bpp8(3,6);
 321     DST1bpp8(3,6);
 322 EPILOG(8)
 323
 324
 325 // This is exactly the same code as yuv2rgb_c_32 except for the types of
 326 // r, g, b, dst_1, dst_2
 327 PROLOG(yuv2rgb_c_4, uint8_t)
 328     int acc;
 329 #define DST1_4(i)                   \
 330     Y = py_1[2*i];                  \
 331     acc = r[Y] + g[Y] + b[Y];       \
 332     Y = py_1[2*i+1];                \
 333     acc |= (r[Y] + g[Y] + b[Y])<<4; \
 334     dst_1[i] = acc;
 335
 336 #define DST2_4(i)                   \
 337     Y = py_2[2*i];                  \
 338     acc = r[Y] + g[Y] + b[Y];       \
 339     Y = py_2[2*i+1];                \
 340     acc |= (r[Y] + g[Y] + b[Y])<<4; \
 341     dst_2[i] = acc;
 342
 343     RGB(0);
 344     DST1_4(0);
 345     DST2_4(0);
 346
 347     RGB(1);
 348     DST2_4(1);
 349     DST1_4(1);
 350
 351     RGB(2);
 352     DST1_4(2);
 353     DST2_4(2);
 354
 355     RGB(3);
 356     DST2_4(3);
 357     DST1_4(3);
 358 EPILOG(4)
 359
 360 PROLOG(yuv2rgb_c_4_ordered_dither, uint8_t)
 361     const uint8_t *d64= dither_8x8_73[y&7];
 362     const uint8_t *d128=dither_8x8_220[y&7];
 363     int acc;
 364
 365 #define DST1bpp4(i,o)                                             \
 366     Y = py_1[2*i];                                                \
 367     acc = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];        \
 368     Y = py_1[2*i+1];                                              \
 369     acc |= (r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]])<<4;  \
 370     dst_1[i]= acc;
 371
 372 #define DST2bpp4(i,o)                                             \
 373     Y = py_2[2*i];                                                \
 374     acc =  r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]];       \
 375     Y = py_2[2*i+1];                                              \
 376     acc |=  (r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]])<<4; \
 377     dst_2[i]= acc;
 378
 379
 380     RGB(0);
 381     DST1bpp4(0,0);
 382     DST2bpp4(0,0);
 383
 384     RGB(1);
 385     DST2bpp4(1,2);
 386     DST1bpp4(1,2);
 387
 388     RGB(2);
 389     DST1bpp4(2,4);
 390     DST2bpp4(2,4);
 391
 392     RGB(3);
 393     DST2bpp4(3,6);
 394     DST1bpp4(3,6);
 395 EPILOG(4)
 396
 397 // This is exactly the same code as yuv2rgb_c_32 except for the types of
 398 // r, g, b, dst_1, dst_2
 399 PROLOG(yuv2rgb_c_4b, uint8_t)
 400     RGB(0);
 401     DST1(0);
 402     DST2(0);
 403
 404     RGB(1);
 405     DST2(1);
 406     DST1(1);
 407
 408     RGB(2);
 409     DST1(2);
 410     DST2(2);
 411
 412     RGB(3);
 413     DST2(3);
 414     DST1(3);
 415 EPILOG(8)
 416
 417 PROLOG(yuv2rgb_c_4b_ordered_dither, uint8_t)
 418     const uint8_t *d64= dither_8x8_73[y&7];
 419     const uint8_t *d128=dither_8x8_220[y&7];
 420
 421 #define DST1bpp4b(i,o)                                                \
 422     Y = py_1[2*i];                                                    \
 423     dst_1[2*i]   = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];   \
 424     Y = py_1[2*i+1];                                                  \
 425     dst_1[2*i+1] = r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]];
 426
 427 #define DST2bpp4b(i,o)                                                \
 428     Y = py_2[2*i];                                                    \
 429     dst_2[2*i]   =  r[Y+d128[8+o]] + g[Y+d64[8+o]] + b[Y+d128[8+o]];  \
 430     Y = py_2[2*i+1];                                                  \
 431     dst_2[2*i+1] =  r[Y+d128[9+o]] + g[Y+d64[9+o]] + b[Y+d128[9+o]];
 432
 433
 434     RGB(0);
 435     DST1bpp4b(0,0);
 436     DST2bpp4b(0,0);
 437
 438     RGB(1);
 439     DST2bpp4b(1,2);
 440     DST1bpp4b(1,2);
 441
 442     RGB(2);
 443     DST1bpp4b(2,4);
 444     DST2bpp4b(2,4);
 445
 446     RGB(3);
 447     DST2bpp4b(3,6);
 448     DST1bpp4b(3,6);
 449 EPILOG(8)
 450
 451 PROLOG(yuv2rgb_c_1_ordered_dither, uint8_t)
 452         const uint8_t *d128=dither_8x8_220[y&7];
 453         char out_1=0, out_2=0;
 454         g= c->table_gU[128] + c->table_gV[128];
 455
 456 #define DST1bpp1(i,o)               \
 457     Y = py_1[2*i];                  \
 458     out_1+= out_1 + g[Y+d128[0+o]]; \
 459     Y = py_1[2*i+1];                \
 460     out_1+= out_1 + g[Y+d128[1+o]];
 461
 462 #define DST2bpp1(i,o)               \
 463     Y = py_2[2*i];                  \
 464     out_2+= out_2 + g[Y+d128[8+o]]; \
 465     Y = py_2[2*i+1];                \
 466     out_2+= out_2 + g[Y+d128[9+o]];
 467
 468     DST1bpp1(0,0);
 469     DST2bpp1(0,0);
 470
 471     DST2bpp1(1,2);
 472     DST1bpp1(1,2);
 473
 474     DST1bpp1(2,4);
 475     DST2bpp1(2,4);
 476
 477     DST2bpp1(3,6);
 478     DST1bpp1(3,6);
 479
 480     dst_1[0]= out_1;
 481     dst_2[0]= out_2;
 482 EPILOG(1)
 483
 484 SwsFunc yuv2rgb_get_func_ptr (SwsContext *c)
 485 {
 486 #if HAVE_MMX2 || HAVE_MMX
 487     if (c->flags & SWS_CPU_CAPS_MMX2){
 488         switch(c->dstFormat){
 489         case PIX_FMT_RGB32:  return yuv420_rgb32_MMX2;
 490         case PIX_FMT_BGR24:  return yuv420_rgb24_MMX2;
 491         case PIX_FMT_RGB565: return yuv420_rgb16_MMX2;
 492         case PIX_FMT_RGB555: return yuv420_rgb15_MMX2;
 493         }
 494     }
 495     if (c->flags & SWS_CPU_CAPS_MMX){
 496         switch(c->dstFormat){
 497         case PIX_FMT_RGB32:  return yuv420_rgb32_MMX;
 498         case PIX_FMT_BGR24:  return yuv420_rgb24_MMX;
 499         case PIX_FMT_RGB565: return yuv420_rgb16_MMX;
 500         case PIX_FMT_RGB555: return yuv420_rgb15_MMX;
 501         }
 502     }
 503 #endif
 504 #if HAVE_VIS
 505     {
 506         SwsFunc t= yuv2rgb_init_vis(c);
 507         if (t) return t;
 508     }
 509 #endif
 510 #if CONFIG_MLIB
 511     {
 512         SwsFunc t= yuv2rgb_init_mlib(c);
 513         if (t) return t;
 514     }
 515 #endif
 516 #if HAVE_ALTIVEC
 517     if (c->flags & SWS_CPU_CAPS_ALTIVEC)
 518     {
 519         SwsFunc t = yuv2rgb_init_altivec(c);
 520         if (t) return t;
 521     }
 522 #endif
 523
 524 #if ARCH_BFIN
 525     if (c->flags & SWS_CPU_CAPS_BFIN)
 526     {
 527         SwsFunc t = ff_bfin_yuv2rgb_get_func_ptr (c);
 528         if (t) return t;
 529     }
 530 #endif
 531
 532     av_log(c, AV_LOG_WARNING, "No accelerated colorspace conversion found.\n");
 533
 534     switch(c->dstFormat){
 535     case PIX_FMT_BGR32_1:
 536     case PIX_FMT_RGB32_1:
 537     case PIX_FMT_BGR32:
 538     case PIX_FMT_RGB32: return yuv2rgb_c_32;
 539     case PIX_FMT_RGB24: return yuv2rgb_c_24_rgb;
 540     case PIX_FMT_BGR24: return yuv2rgb_c_24_bgr;
 541     case PIX_FMT_RGB565:
 542     case PIX_FMT_BGR565:
 543     case PIX_FMT_RGB555:
 544     case PIX_FMT_BGR555: return yuv2rgb_c_16;
 545     case PIX_FMT_RGB8:
 546     case PIX_FMT_BGR8:  return yuv2rgb_c_8_ordered_dither;
 547     case PIX_FMT_RGB4:
 548     case PIX_FMT_BGR4:  return yuv2rgb_c_4_ordered_dither;
 549     case PIX_FMT_RGB4_BYTE:
 550     case PIX_FMT_BGR4_BYTE:  return yuv2rgb_c_4b_ordered_dither;
 551     case PIX_FMT_MONOBLACK:  return yuv2rgb_c_1_ordered_dither;
 552     default:
 553         assert(0);
 554     }
 555     return NULL;
 556 }
 557
 558 static int div_round (int dividend, int divisor)
 559 {
 560     if (dividend > 0)
 561         return (dividend + (divisor>>1)) / divisor;
 562     else
 563         return -((-dividend + (divisor>>1)) / divisor);
 564 }
 565
 566 int yuv2rgb_c_init_tables (SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
 567 {
 568     const int isRgb =      c->dstFormat==PIX_FMT_RGB32
 569                         || c->dstFormat==PIX_FMT_RGB32_1
 570                         || c->dstFormat==PIX_FMT_BGR24
 571                         || c->dstFormat==PIX_FMT_RGB565
 572                         || c->dstFormat==PIX_FMT_RGB555
 573                         || c->dstFormat==PIX_FMT_RGB8
 574                         || c->dstFormat==PIX_FMT_RGB4
 575                         || c->dstFormat==PIX_FMT_RGB4_BYTE
 576                         || c->dstFormat==PIX_FMT_MONOBLACK;
 577     const int bpp = fmt_depth(c->dstFormat);
 578     int i, base;
 579     uint8_t table_Y[1024];
 580     uint32_t *table_32 = 0;
 581     uint16_t *table_16 = 0;
 582     uint8_t *table_8 = 0;
 583     uint8_t *table_332 = 0;
 584     uint8_t *table_121 = 0;
 585     uint8_t *table_1 = 0;
 586     int entry_size = 0;
 587     void *table_r = 0, *table_g = 0, *table_b = 0;
 588     void *table_start;
 589
 590     int64_t crv =  inv_table[0];
 591     int64_t cbu =  inv_table[1];
 592     int64_t cgu = -inv_table[2];
 593     int64_t cgv = -inv_table[3];
 594     int64_t cy  = 1<<16;
 595     int64_t oy  = 0;
 596
 597 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv);
 598     if (!fullRange){
 599         cy= (cy*255) / 219;
 600         oy= 16<<16;
 601     }else{
 602         crv= (crv*224) / 255;
 603         cbu= (cbu*224) / 255;
 604         cgu= (cgu*224) / 255;
 605         cgv= (cgv*224) / 255;
 606     }
 607
 608     cy = (cy *contrast             )>>16;
 609     crv= (crv*contrast * saturation)>>32;
 610     cbu= (cbu*contrast * saturation)>>32;
 611     cgu= (cgu*contrast * saturation)>>32;
 612     cgv= (cgv*contrast * saturation)>>32;
 613 //printf("%lld %lld %lld %lld %lld\n", cy, crv, cbu, cgu, cgv);
 614     oy -= 256*brightness;
 615
 616     for (i = 0; i < 1024; i++) {
 617         int j;
 618
 619         j= (cy*(((i - 384)<<16) - oy) + (1<<31))>>32;
 620         j = (j < 0) ? 0 : ((j > 255) ? 255 : j);
 621         table_Y[i] = j;
 622     }
 623
 624     switch (bpp) {
 625     case 32:
 626         table_start= table_32 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint32_t));
 627         base= (c->dstFormat == PIX_FMT_RGB32_1 || c->dstFormat == PIX_FMT_BGR32_1) ? 8 : 0;
 628
 629         entry_size = sizeof (uint32_t);
 630         table_r = table_32 + 197;
 631         table_b = table_32 + 197 + 685;
 632         table_g = table_32 + 197 + 2*682;
 633
 634         for (i = -197; i < 256+197; i++)
 635             ((uint32_t *)table_r)[i] = table_Y[i+384] << ((isRgb ? 16 : 0) + base);
 636         for (i = -132; i < 256+132; i++)
 637             ((uint32_t *)table_g)[i] = table_Y[i+384] << (8                + base);
 638         for (i = -232; i < 256+232; i++)
 639             ((uint32_t *)table_b)[i] = table_Y[i+384] << ((isRgb ? 0 : 16) + base);
 640         break;
 641
 642     case 24:
 643         table_start= table_8 = av_malloc ((256 + 2*232) * sizeof (uint8_t));
 644
 645         entry_size = sizeof (uint8_t);
 646         table_r = table_g = table_b = table_8 + 232;
 647
 648         for (i = -232; i < 256+232; i++)
 649             ((uint8_t * )table_b)[i] = table_Y[i+384];
 650         break;
 651
 652     case 15:
 653     case 16:
 654         table_start= table_16 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint16_t));
 655
 656         entry_size = sizeof (uint16_t);
 657         table_r = table_16 + 197;
 658         table_b = table_16 + 197 + 685;
 659         table_g = table_16 + 197 + 2*682;
 660
 661         for (i = -197; i < 256+197; i++) {
 662             int j = table_Y[i+384] >> 3;
 663
 664             if (isRgb)
 665                 j <<= ((bpp==16) ? 11 : 10);
 666
 667             ((uint16_t *)table_r)[i] = j;
 668         }
 669         for (i = -132; i < 256+132; i++) {
 670             int j = table_Y[i+384] >> ((bpp==16) ? 2 : 3);
 671
 672             ((uint16_t *)table_g)[i] = j << 5;
 673         }
 674         for (i = -232; i < 256+232; i++) {
 675             int j = table_Y[i+384] >> 3;
 676
 677             if (!isRgb)
 678                 j <<= ((bpp==16) ? 11 : 10);
 679
 680             ((uint16_t *)table_b)[i] = j;
 681         }
 682         break;
 683
 684     case 8:
 685         table_start= table_332 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
 686
 687         entry_size = sizeof (uint8_t);
 688         table_r = table_332 + 197;
 689         table_b = table_332 + 197 + 685;
 690         table_g = table_332 + 197 + 2*682;
 691
 692         for (i = -197; i < 256+197; i++) {
 693             int j = (table_Y[i+384 - 16] + 18)/36;
 694
 695             if (isRgb)
 696                 j <<= 5;
 697
 698             ((uint8_t *)table_r)[i] = j;
 699         }
 700         for (i = -132; i < 256+132; i++) {
 701             int j = (table_Y[i+384 - 16] + 18)/36;
 702
 703             if (!isRgb)
 704                 j <<= 1;
 705
 706             ((uint8_t *)table_g)[i] = j << 2;
 707         }
 708         for (i = -232; i < 256+232; i++) {
 709             int j = (table_Y[i+384 - 37] + 43)/85;
 710
 711             if (!isRgb)
 712                 j <<= 6;
 713
 714             ((uint8_t *)table_b)[i] = j;
 715         }
 716         break;
 717     case 4:
 718     case 4|128:
 719         table_start= table_121 = av_malloc ((197 + 2*682 + 256 + 132) * sizeof (uint8_t));
 720
 721         entry_size = sizeof (uint8_t);
 722         table_r = table_121 + 197;
 723         table_b = table_121 + 197 + 685;
 724         table_g = table_121 + 197 + 2*682;
 725
 726         for (i = -197; i < 256+197; i++) {
 727             int j = table_Y[i+384 - 110] >> 7;
 728
 729             if (isRgb)
 730                 j <<= 3;
 731
 732             ((uint8_t *)table_r)[i] = j;
 733         }
 734         for (i = -132; i < 256+132; i++) {
 735             int j = (table_Y[i+384 - 37]+ 43)/85;
 736
 737             ((uint8_t *)table_g)[i] = j << 1;
 738         }
 739         for (i = -232; i < 256+232; i++) {
 740             int j =table_Y[i+384 - 110] >> 7;
 741
 742             if (!isRgb)
 743                 j <<= 3;
 744
 745             ((uint8_t *)table_b)[i] = j;
 746         }
 747         break;
 748
 749     case 1:
 750         table_start= table_1 = av_malloc (256*2 * sizeof (uint8_t));
 751
 752         entry_size = sizeof (uint8_t);
 753         table_g = table_1;
 754         table_r = table_b = NULL;
 755
 756         for (i = 0; i < 256+256; i++) {
 757             int j = table_Y[i + 384 - 110]>>7;
 758
 759             ((uint8_t *)table_g)[i] = j;
 760         }
 761         break;
 762
 763     default:
 764         table_start= NULL;
 765         av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);
 766         //free mem?
 767         return -1;
 768     }
 769
 770     for (i = 0; i < 256; i++) {
 771         c->table_rV[i] = (uint8_t *)table_r + entry_size * div_round (crv * (i-128), cy);
 772         c->table_gU[i] = (uint8_t *)table_g + entry_size * div_round (cgu * (i-128), cy);
 773         c->table_gV[i] = entry_size * div_round (cgv * (i-128), cy);
 774         c->table_bU[i] = (uint8_t *)table_b + entry_size * div_round (cbu * (i-128), cy);
 775     }
 776
 777     av_free(c->yuvTable);
 778     c->yuvTable= table_start;
 779     return 0;
 780 }