libswscale/yuv2rgb_init.c

   1 #include "avutil.h"
   2 #include "swscale.h"
   3 #include "swscale_internal.h"
   4
   5 #define YTABLE_MIN 384
   6
   7 /**
   8  * YUV -> RGB conversion matrixes (inverse of table 6.9 in MPEG2 standard)
   9  *
  10  * An YUV -> RGB conversion matrix is in the form
  11  *              | 1  0 Rv |
  12  *              | 1 Gu Gv |
  13  *              | 1 Bu  0 |
  14  *
  15  * Inverse_Table_6_9 stores | Rv Bu Gv Gu | * 255/224*2^16.
  16  * \arg Maximum Rv value: 117570
  17  * \arg Maximum Bu value: 138420
  18  * \arg Maximum Gv + Gu value: 25642 + 53281 = 78923
  19  *
  20  * These values are needed to allocate table_{r, g, b}. If you modify
  21  * this table, please update allocate_tables() accordingly
  22  */
  23 const int32_t Inverse_Table_6_9[8][4] = {
  24     {0, 0, 0, 0}, /* no sequence_display_extension */
  25     {117500, 138420, -13985, -34933}, /* ITU-R Rec. 709 (1990) */
  26     {0, 0, 0, 0}, /* unspecified */
  27     {0, 0, 0, 0}, /* reserved */
  28     {104480, 132820, -24811, -53150}, /* FCC */
  29     {104570, 132210, -25642, -53281}, /* ITU-R Rec. 624-4 System B, G */
  30     {104570, 132210, -25642, -53281}, /* SMPTE 170M */
  31     {117570, 136230, -16892, -35552}  /* SMPTE 240M (1987) */
  32 };
  33
  34
  35 /**
  36  * Dithering matrixes (these are bayer ordered dither matrixes
  37  * with some manual changes by Michael)
  38  */
  39 const uint8_t  __attribute__((aligned(8))) dither_2x2_4[2][8]={
  40 {  1,   3,   1,   3,   1,   3,   1,   3, },
  41 {  2,   0,   2,   0,   2,   0,   2,   0, },
  42 };
  43
  44 const uint8_t  __attribute__((aligned(8))) dither_2x2_8[2][8]={
  45 {  6,   2,   6,   2,   6,   2,   6,   2, },
  46 {  0,   4,   0,   4,   0,   4,   0,   4, },
  47 };
  48
  49 const uint8_t  __attribute__((aligned(8))) dither_8x8_32[8][8]={
  50 { 17,   9,  23,  15,  16,   8,  22,  14, },
  51 {  5,  29,   3,  27,   4,  28,   2,  26, },
  52 { 21,  13,  19,  11,  20,  12,  18,  10, },
  53 {  0,  24,   6,  30,   1,  25,   7,  31, },
  54 { 16,   8,  22,  14,  17,   9,  23,  15, },
  55 {  4,  28,   2,  26,   5,  29,   3,  27, },
  56 { 20,  12,  18,  10,  21,  13,  19,  11, },
  57 {  1,  25,   7,  31,   0,  24,   6,  30, },
  58 };
  59
  60 #if 0
  61 const uint8_t  __attribute__((aligned(8))) dither_8x8_64[8][8]={
  62 {  0,  48,  12,  60,   3,  51,  15,  63, },
  63 { 32,  16,  44,  28,  35,  19,  47,  31, },
  64 {  8,  56,   4,  52,  11,  59,   7,  55, },
  65 { 40,  24,  36,  20,  43,  27,  39,  23, },
  66 {  2,  50,  14,  62,   1,  49,  13,  61, },
  67 { 34,  18,  46,  30,  33,  17,  45,  29, },
  68 { 10,  58,   6,  54,   9,  57,   5,  53, },
  69 { 42,  26,  38,  22,  41,  25,  37,  21, },
  70 };
  71 #endif
  72
  73 const uint8_t  __attribute__((aligned(8))) dither_8x8_73[8][8]={
  74 {  0,  55,  14,  68,   3,  58,  17,  72, },
  75 { 37,  18,  50,  32,  40,  22,  54,  35, },
  76 {  9,  64,   5,  59,  13,  67,   8,  63, },
  77 { 46,  27,  41,  23,  49,  31,  44,  26, },
  78 {  2,  57,  16,  71,   1,  56,  15,  70, },
  79 { 39,  21,  52,  34,  38,  19,  51,  33, },
  80 { 11,  66,   7,  62,  10,  65,   6,  60, },
  81 { 48,  30,  43,  25,  47,  29,  42,  24, },
  82 };
  83
  84 #if 0
  85 const uint8_t  __attribute__((aligned(8))) dither_8x8_128[8][8]={
  86 { 68,  36,  92,  60,  66,  34,  90,  58, },
  87 { 20, 116,  12, 108,  18, 114,  10, 106, },
  88 { 84,  52,  76,  44,  82,  50,  74,  42, },
  89 {  0,  96,  24, 120,   6, 102,  30, 126, },
  90 { 64,  32,  88,  56,  70,  38,  94,  62, },
  91 { 16, 112,   8, 104,  22, 118,  14, 110, },
  92 { 80,  48,  72,  40,  86,  54,  78,  46, },
  93 {  4, 100,  28, 124,   2,  98,  26, 122, },
  94 };
  95 #endif
  96
  97 #if 1
  98 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
  99 {117,  62, 158, 103, 113,  58, 155, 100, },
 100 { 34, 199,  21, 186,  31, 196,  17, 182, },
 101 {144,  89, 131,  76, 141,  86, 127,  72, },
 102 {  0, 165,  41, 206,  10, 175,  52, 217, },
 103 {110,  55, 151,  96, 120,  65, 162, 107, },
 104 { 28, 193,  14, 179,  38, 203,  24, 189, },
 105 {138,  83, 124,  69, 148,  93, 134,  79, },
 106 {  7, 172,  48, 213,   3, 168,  45, 210, },
 107 };
 108 #elif 1
 109 // tries to correct a gamma of 1.5
 110 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
 111 {  0, 143,  18, 200,   2, 156,  25, 215, },
 112 { 78,  28, 125,  64,  89,  36, 138,  74, },
 113 { 10, 180,   3, 161,  16, 195,   8, 175, },
 114 {109,  51,  93,  38, 121,  60, 105,  47, },
 115 {  1, 152,  23, 210,   0, 147,  20, 205, },
 116 { 85,  33, 134,  71,  81,  30, 130,  67, },
 117 { 14, 190,   6, 171,  12, 185,   5, 166, },
 118 {117,  57, 101,  44, 113,  54,  97,  41, },
 119 };
 120 #elif 1
 121 // tries to correct a gamma of 2.0
 122 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
 123 {  0, 124,   8, 193,   0, 140,  12, 213, },
 124 { 55,  14, 104,  42,  66,  19, 119,  52, },
 125 {  3, 168,   1, 145,   6, 187,   3, 162, },
 126 { 86,  31,  70,  21,  99,  39,  82,  28, },
 127 {  0, 134,  11, 206,   0, 129,   9, 200, },
 128 { 62,  17, 114,  48,  58,  16, 109,  45, },
 129 {  5, 181,   2, 157,   4, 175,   1, 151, },
 130 { 95,  36,  78,  26,  90,  34,  74,  24, },
 131 };
 132 #else
 133 // tries to correct a gamma of 2.5
 134 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
 135 {  0, 107,   3, 187,   0, 125,   6, 212, },
 136 { 39,   7,  86,  28,  49,  11, 102,  36, },
 137 {  1, 158,   0, 131,   3, 180,   1, 151, },
 138 { 68,  19,  52,  12,  81,  25,  64,  17, },
 139 {  0, 119,   5, 203,   0, 113,   4, 195, },
 140 { 45,   9,  96,  33,  42,   8,  91,  30, },
 141 {  2, 172,   1, 144,   2, 165,   0, 137, },
 142 { 77,  23,  60,  15,  72,  21,  56,  14, },
 143 };
 144 #endif
 145
 146 static int get_entry_size(int bpp)
 147 {
 148     switch(bpp) {
 149         case 32:
 150             return 4;
 151         case 16:
 152         case 15:
 153             return 2;
 154         case 24:
 155         case 8:
 156         case 4:
 157         case 1:
 158             return 1;
 159         default:
 160             return -1;
 161     }
 162 }
 163
 164 /**
 165  * Allocate table_r, table_g, and table_b
 166  *
 167  * For cache efficency reasons, these three tables are allocated
 168  * together, so that they are contiguous in memory
 169  *
 170  * table_r is indexed in the range
 171  *      [-128 * 117570 / 76309, 255 + 127 * 117570 / 76309] =
 172  *      [-197.21, 451.67] ---> [-198, 452]
 173  * table_b is indexed in the range
 174  *      [-128 * 138420 / 76309, 255 + 127 * 138420 / 76309] =
 175  *      [232.18, 485.37] ---> [-233, 486]
 176  * table_g is indexed in the range
 177  *      [-128 * 78923 / 76309, 255 + 127 * 78923 / 76309] =
 178  *      [-132.38, 386.35] ---> [-133, 387]
 179  *
 180  * Please look at the comments after Inverse_Table_6_9 to see where these
 181  * numbers are coming from.
 182  */
 183 static void *allocate_tables(uint8_t **table_r, uint8_t **table_g, uint8_t **table_b, int bpp)
 184 {
 185     uint8_t *table;
 186     int entry_size;
 187
 188     entry_size = get_entry_size(bpp);
 189
 190     /* First allocate the memory... */
 191     switch (bpp) {
 192         case 32:
 193         case 15:
 194         case 16:
 195         case 8:
 196         case 4:
 197             table = av_malloc((198 + 452 + 233 + 486 + 133 + 387) * entry_size);
 198             break;
 199         case 24:
 200             table = av_malloc(256 + 2 * 233);
 201             break;
 202         case 1:
 203             table = av_malloc (256 * 2);
 204             break;
 205         default:
 206             table = NULL;
 207     }
 208     if (table == NULL) {
 209         MSG_ERR("Cannot allocate memory for the YUV -> RGB tables!\n");
 210
 211         return NULL;
 212     }
 213
 214     /* ...and then, assign the table_* value */
 215     switch (bpp) {
 216         case 32:
 217         case 15:
 218         case 16:
 219         case 8:
 220         case 4:
 221             *table_r = table + 198 * entry_size;
 222             *table_b = table + (198 + 452 + 133 + 387 + 233) * entry_size;
 223             *table_g = table + (198 + 452 + 133) * entry_size;
 224             break;
 225         case 24:
 226             *table_r = *table_g = *table_b = table + 233;
 227             break;
 228         case 1:
 229             *table_g = table;
 230             *table_r = *table_b = NULL;
 231             break;
 232     }
 233
 234     return table;
 235 }
 236
 237 /**
 238  * Initialize the table_rV, table_gU[i], table_gV, and table_bU fields
 239  * in SwsContext
 240  *
 241  * @param inv_table the YUV -> RGB table (this is a line of Inverse_Table_6_9)
 242  * @param fullRange 0->MPEG YUV space 1->JPEG YUV space
 243 */
 244 int yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
 245 {
 246     int i;
 247     static uint8_t ytable[1024];
 248     int64_t cy, oy;
 249     int64_t crv, cbu, cgu, cgv;
 250     int entry_size = 0;
 251     uint8_t *table_r, *table_g, *table_b;
 252     int value;
 253
 254     if ((inv_table[0] == 0) || (inv_table[1] == 0) || (inv_table[2] == 0) || (inv_table[3] == 0)) {
 255         MSG_ERR("Invalid YUV ---> RGB table!\n");
 256
 257         return -1;
 258     }
 259     crv = inv_table[0];
 260     cbu = inv_table[1];
 261     cgu = inv_table[2];
 262     cgv = inv_table[3];
 263     if (fullRange) {
 264         cy = 1 << 16;
 265         oy = 0;
 266         crv= (crv*224) / 255;
 267         cbu= (cbu*224) / 255;
 268         cgu= (cgu*224) / 255;
 269         cgv= (cgv*224) / 255;
 270         //FIXME maybe its cleaner if the tables where based on full range (*244/255)
 271     } else {
 272         cy = ((1 << 16) * 255) / 219;
 273         oy= 16 << 16;
 274     }
 275
 276     cy = (cy *contrast             )>>16;
 277     crv= (crv*contrast * saturation)>>32;
 278     cbu= (cbu*contrast * saturation)>>32;
 279     cgu= (cgu*contrast * saturation)>>32;
 280     cgv= (cgv*contrast * saturation)>>32;
 281     oy -= 256*brightness;
 282
 283     for (i = 0; i < 1024; i++) {
 284         value = (cy*(((i - YTABLE_MIN)<<16) - oy) + (1<<31))>>32;
 285         ytable[i] = av_clip_uint8(value);
 286     }
 287
 288     entry_size = get_entry_size(fmt_depth(c->dstFormat));
 289     av_free(c->yuvTable);
 290     c->yuvTable = allocate_tables(&table_r, &table_g, &table_b, fmt_depth(c->dstFormat));
 291     if (c->yuvTable == NULL) {
 292         return -1;
 293     }
 294
 295     switch (fmt_depth(c->dstFormat)) {
 296         case 32:
 297             for (i = -198; i < 256 + 197; i++) {
 298                 value = ytable[i + YTABLE_MIN];
 299                 if (isBGR(c->dstFormat)) {
 300                     value <<= 16;
 301                 }
 302                 ((uint32_t *)table_r)[i] = value;
 303             }
 304             for (i = -133; i < 256 + 132; i++) {
 305                 ((uint32_t *)table_g)[i] = ytable[i + YTABLE_MIN] << 8;
 306             }
 307             for (i = -233; i < 256 + 232; i++) {
 308                 value = ytable[i + YTABLE_MIN];
 309                 if (!isBGR(c->dstFormat)) {
 310                     value <<= 16;
 311                 }
 312                 ((uint32_t *)table_b)[i] = value;
 313             }
 314             break;
 315
 316         case 24:
 317             for (i = -233; i < 256 + 232; i++) {
 318                 ((uint8_t * )table_b)[i] = ytable[i + YTABLE_MIN];
 319             }
 320             break;
 321
 322         case 15:
 323         case 16:
 324             for (i = -198; i < 256 + 197; i++) {
 325                 value = ytable[i + YTABLE_MIN] >> 3;
 326                 if (isBGR(c->dstFormat)) {
 327                     value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10);
 328                 }
 329                 ((uint16_t *)table_r)[i] = value;
 330             }
 331             for (i = -133; i < 256 + 132; i++) {
 332                 value = ytable[i + YTABLE_MIN];
 333                 value >>= ((fmt_depth(c->dstFormat) == 16) ? 2 : 3);
 334                 ((uint16_t *)table_g)[i] = value << 5;
 335             }
 336             for (i = -233; i < 256 + 232; i++) {
 337                 value = ytable[i + YTABLE_MIN] >> 3;
 338                 if (!isBGR(c->dstFormat)) {
 339                     value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10);
 340                 }
 341                 ((uint16_t *)table_b)[i] = value;
 342             }
 343             break;
 344         case 8:
 345             for (i = -198; i < 256 + 197; i++) {
 346                 value = (ytable[i + YTABLE_MIN - 16] + 18) / 36;
 347                 if (isBGR(c->dstFormat)) {
 348                     value <<= 5;
 349                 }
 350                 ((uint8_t *)table_r)[i] = value;
 351             }
 352             for (i = -133; i < 256 + 132; i++) {
 353                 value = (ytable[i + YTABLE_MIN - 16] + 18) / 36;
 354                 if (!isBGR(c->dstFormat)) {
 355                     value <<= 1;
 356                 }
 357                 ((uint8_t *)table_g)[i] = value << 2;
 358             }
 359             for (i = -233; i < 256 + 232; i++) {
 360                 value = (ytable[i + YTABLE_MIN - 37] + 43) / 85;
 361                 if (!isBGR(c->dstFormat)) {
 362                     value <<= 6;
 363                 }
 364                 ((uint8_t *)table_b)[i] = value;
 365             }
 366             break;
 367         case 4:
 368             for (i = -198; i < 256 + 197; i++) {
 369                 value = ytable[i + YTABLE_MIN - 110] >> 7;
 370                 if (isBGR(c->dstFormat)) {
 371                     value <<= 3;
 372                 }
 373                 ((uint8_t *)table_r)[i] = value;
 374             }
 375             for (i = -133; i < 256 + 132; i++) {
 376                 value = (ytable[i + YTABLE_MIN - 37]+ 43) / 85;
 377                 ((uint8_t *)table_g)[i] = value << 1;
 378             }
 379             for (i = -233; i < 256 + 232; i++) {
 380                 value = ytable[i + YTABLE_MIN - 110] >> 7;
 381                 if (!isBGR(c->dstFormat)) {
 382                     value <<= 3;
 383                 }
 384                 ((uint8_t *)table_b)[i] = value;
 385             }
 386             break;
 387         case 1:
 388             for (i = 0; i < 256 + 256; i++) {
 389                 value = ytable[i + YTABLE_MIN - 110] >> 7;
 390                 ((uint8_t *)table_g)[i] = value;
 391             }
 392             break;
 393         default:
 394             MSG_ERR("%ibpp not supported by yuv2rgb\n", fmt_depth(c->dstFormat));
 395             av_free(c->yuvTable);
 396             c->yuvTable = NULL;
 397
 398             return -1;
 399     }
 400
 401     for (i = 0; i < 256; i++) {
 402         c->table_rV[i] = table_r +
 403                          entry_size * ROUNDED_DIV(crv * (i - 128), 76309);
 404         c->table_gU[i] = table_g +
 405                          entry_size * ROUNDED_DIV(cgu * (i - 128), 76309);
 406         c->table_gV[i] = entry_size * ROUNDED_DIV(cgv * (i - 128), 76309);
 407         c->table_bU[i] = table_b +
 408                          entry_size * ROUNDED_DIV(cbu * (i - 128), 76309);
 409     }
 410
 411     return 0;
 412 }