Remove underscores before fcntl flags
[ffmpeg.git] / libswscale / yuv2rgb_init.c
1 /*
2  * This is a (failed) attempt to re-implement the initialization
3  * of the yuv2rgb conversion tables from scratch.
4  * Unfortunately, it is still derived from yuv2rgb.c, so the license
5  * header of that file applies:
6  *
7  * yuv2rgb.c, Software YUV to RGB coverter
8  *
9  *  Copyright (C) 1999, Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
10  *  All Rights Reserved.
11  *
12  *  Functions broken out from display_x11.c and several new modes
13  *  added by HÃ¥kan Hjort <d95hjort@dtek.chalmers.se>
14  *
15  *  15 & 16 bpp support by Franck Sicard <Franck.Sicard@solsoft.fr>
16  *
17  *  MMX/MMX2 template stuff (needed for fast movntq support),
18  *  1,4,8bpp support and context / deglobalize stuff
19  *  by Michael Niedermayer (michaelni@gmx.at)
20  *
21  *  This file is part of mpeg2dec, a free MPEG-2 video decoder
22  *
23  *  mpeg2dec is free software; you can redistribute it and/or modify
24  *  it under the terms of the GNU General Public License as published by
25  *  the Free Software Foundation; either version 2, or (at your option)
26  *  any later version.
27  *
28  *  mpeg2dec is distributed in the hope that it will be useful,
29  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
30  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
31  *  GNU General Public License for more details.
32  *
33  *  You should have received a copy of the GNU General Public License
34  *  along with mpeg2dec; if not, write to the Free Software
35  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
36  */
37
38 #include "avutil.h"
39 #include "swscale.h"
40 #include "swscale_internal.h"
41
42 #define YTABLE_MIN 384
43
44 /**
45  * YUV -> RGB conversion matrixes (inverse of table 6.9 in MPEG2 standard)
46  *
47  * An YUV -> RGB conversion matrix is in the form
48  *              | 1  0 Rv |
49  *              | 1 Gu Gv |
50  *              | 1 Bu  0 |
51  *
52  * Inverse_Table_6_9 stores | Rv Bu Gv Gu | * 255/224*2^16.
53  * \arg Maximum Rv value: 117570
54  * \arg Maximum Bu value: 138420
55  * \arg Maximum Gv + Gu value: 25642 + 53281 = 78923
56  *
57  * These values are needed to allocate table_{r, g, b}. If you modify
58  * this table, please update allocate_tables() accordingly
59  */
60 const int32_t Inverse_Table_6_9[8][4] = {
61     {0, 0, 0, 0}, /* no sequence_display_extension */
62     {117500, 138420, -13985, -34933}, /* ITU-R Rec. 709 (1990) */
63     {0, 0, 0, 0}, /* unspecified */
64     {0, 0, 0, 0}, /* reserved */
65     {104480, 132820, -24811, -53150}, /* FCC */
66     {104570, 132210, -25642, -53281}, /* ITU-R Rec. 624-4 System B, G */
67     {104570, 132210, -25642, -53281}, /* SMPTE 170M */
68     {117570, 136230, -16892, -35552}  /* SMPTE 240M (1987) */
69 };
70
71
72 /**
73  * Dithering matrixes (these are bayer ordered dither matrixes
74  * with some manual changes by Michael)
75  */
76 const uint8_t  __attribute__((aligned(8))) dither_2x2_4[2][8]={
77 {  1,   3,   1,   3,   1,   3,   1,   3, },
78 {  2,   0,   2,   0,   2,   0,   2,   0, },
79 };
80
81 const uint8_t  __attribute__((aligned(8))) dither_2x2_8[2][8]={
82 {  6,   2,   6,   2,   6,   2,   6,   2, },
83 {  0,   4,   0,   4,   0,   4,   0,   4, },
84 };
85
86 const uint8_t  __attribute__((aligned(8))) dither_8x8_32[8][8]={
87 { 17,   9,  23,  15,  16,   8,  22,  14, },
88 {  5,  29,   3,  27,   4,  28,   2,  26, },
89 { 21,  13,  19,  11,  20,  12,  18,  10, },
90 {  0,  24,   6,  30,   1,  25,   7,  31, },
91 { 16,   8,  22,  14,  17,   9,  23,  15, },
92 {  4,  28,   2,  26,   5,  29,   3,  27, },
93 { 20,  12,  18,  10,  21,  13,  19,  11, },
94 {  1,  25,   7,  31,   0,  24,   6,  30, },
95 };
96
97 #if 0
98 const uint8_t  __attribute__((aligned(8))) dither_8x8_64[8][8]={
99 {  0,  48,  12,  60,   3,  51,  15,  63, },
100 { 32,  16,  44,  28,  35,  19,  47,  31, },
101 {  8,  56,   4,  52,  11,  59,   7,  55, },
102 { 40,  24,  36,  20,  43,  27,  39,  23, },
103 {  2,  50,  14,  62,   1,  49,  13,  61, },
104 { 34,  18,  46,  30,  33,  17,  45,  29, },
105 { 10,  58,   6,  54,   9,  57,   5,  53, },
106 { 42,  26,  38,  22,  41,  25,  37,  21, },
107 };
108 #endif
109
110 const uint8_t  __attribute__((aligned(8))) dither_8x8_73[8][8]={
111 {  0,  55,  14,  68,   3,  58,  17,  72, },
112 { 37,  18,  50,  32,  40,  22,  54,  35, },
113 {  9,  64,   5,  59,  13,  67,   8,  63, },
114 { 46,  27,  41,  23,  49,  31,  44,  26, },
115 {  2,  57,  16,  71,   1,  56,  15,  70, },
116 { 39,  21,  52,  34,  38,  19,  51,  33, },
117 { 11,  66,   7,  62,  10,  65,   6,  60, },
118 { 48,  30,  43,  25,  47,  29,  42,  24, },
119 };
120
121 #if 0
122 const uint8_t  __attribute__((aligned(8))) dither_8x8_128[8][8]={
123 { 68,  36,  92,  60,  66,  34,  90,  58, },
124 { 20, 116,  12, 108,  18, 114,  10, 106, },
125 { 84,  52,  76,  44,  82,  50,  74,  42, },
126 {  0,  96,  24, 120,   6, 102,  30, 126, },
127 { 64,  32,  88,  56,  70,  38,  94,  62, },
128 { 16, 112,   8, 104,  22, 118,  14, 110, },
129 { 80,  48,  72,  40,  86,  54,  78,  46, },
130 {  4, 100,  28, 124,   2,  98,  26, 122, },
131 };
132 #endif
133
134 #if 1
135 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
136 {117,  62, 158, 103, 113,  58, 155, 100, },
137 { 34, 199,  21, 186,  31, 196,  17, 182, },
138 {144,  89, 131,  76, 141,  86, 127,  72, },
139 {  0, 165,  41, 206,  10, 175,  52, 217, },
140 {110,  55, 151,  96, 120,  65, 162, 107, },
141 { 28, 193,  14, 179,  38, 203,  24, 189, },
142 {138,  83, 124,  69, 148,  93, 134,  79, },
143 {  7, 172,  48, 213,   3, 168,  45, 210, },
144 };
145 #elif 1
146 // tries to correct a gamma of 1.5
147 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
148 {  0, 143,  18, 200,   2, 156,  25, 215, },
149 { 78,  28, 125,  64,  89,  36, 138,  74, },
150 { 10, 180,   3, 161,  16, 195,   8, 175, },
151 {109,  51,  93,  38, 121,  60, 105,  47, },
152 {  1, 152,  23, 210,   0, 147,  20, 205, },
153 { 85,  33, 134,  71,  81,  30, 130,  67, },
154 { 14, 190,   6, 171,  12, 185,   5, 166, },
155 {117,  57, 101,  44, 113,  54,  97,  41, },
156 };
157 #elif 1
158 // tries to correct a gamma of 2.0
159 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
160 {  0, 124,   8, 193,   0, 140,  12, 213, },
161 { 55,  14, 104,  42,  66,  19, 119,  52, },
162 {  3, 168,   1, 145,   6, 187,   3, 162, },
163 { 86,  31,  70,  21,  99,  39,  82,  28, },
164 {  0, 134,  11, 206,   0, 129,   9, 200, },
165 { 62,  17, 114,  48,  58,  16, 109,  45, },
166 {  5, 181,   2, 157,   4, 175,   1, 151, },
167 { 95,  36,  78,  26,  90,  34,  74,  24, },
168 };
169 #else
170 // tries to correct a gamma of 2.5
171 const uint8_t  __attribute__((aligned(8))) dither_8x8_220[8][8]={
172 {  0, 107,   3, 187,   0, 125,   6, 212, },
173 { 39,   7,  86,  28,  49,  11, 102,  36, },
174 {  1, 158,   0, 131,   3, 180,   1, 151, },
175 { 68,  19,  52,  12,  81,  25,  64,  17, },
176 {  0, 119,   5, 203,   0, 113,   4, 195, },
177 { 45,   9,  96,  33,  42,   8,  91,  30, },
178 {  2, 172,   1, 144,   2, 165,   0, 137, },
179 { 77,  23,  60,  15,  72,  21,  56,  14, },
180 };
181 #endif
182
183 static int get_entry_size(int bpp)
184 {
185     switch(bpp) {
186         case 32:
187             return 4;
188         case 16:
189         case 15:
190             return 2;
191         case 24:
192         case 8:
193         case 4:
194         case 1:
195             return 1;
196         default:
197             return -1;
198     }
199 }
200
201 /**
202  * Allocate table_r, table_g, and table_b
203  *
204  * For cache efficency reasons, these three tables are allocated
205  * together, so that they are contiguous in memory
206  *
207  * table_r is indexed in the range
208  *      [-128 * 117570 / 76309, 255 + 127 * 117570 / 76309] =
209  *      [-197.21, 451.67] ---> [-198, 452]
210  * table_b is indexed in the range
211  *      [-128 * 138420 / 76309, 255 + 127 * 138420 / 76309] =
212  *      [232.18, 485.37] ---> [-233, 486]
213  * table_g is indexed in the range
214  *      [-128 * 78923 / 76309, 255 + 127 * 78923 / 76309] =
215  *      [-132.38, 386.35] ---> [-133, 387]
216  *
217  * Please look at the comments after Inverse_Table_6_9 to see where these
218  * numbers are coming from.
219  */
220 static void *allocate_tables(uint8_t **table_r, uint8_t **table_g, uint8_t **table_b, int bpp)
221 {
222     uint8_t *table;
223     int entry_size;
224
225     entry_size = get_entry_size(bpp);
226
227     /* First allocate the memory... */
228     switch (bpp) {
229         case 32:
230         case 15:
231         case 16:
232         case 8:
233         case 4:
234             table = av_malloc((198 + 452 + 233 + 486 + 133 + 387) * entry_size);
235             break;
236         case 24:
237             table = av_malloc(256 + 2 * 233);
238             break;
239         case 1:
240             table = av_malloc (256 * 2);
241             break;
242         default:
243             table = NULL;
244     }
245     if (table == NULL) {
246         MSG_ERR("Cannot allocate memory for the YUV -> RGB tables!\n");
247
248         return NULL;
249     }
250
251     /* ...and then, assign the table_* value */
252     switch (bpp) {
253         case 32:
254         case 15:
255         case 16:
256         case 8:
257         case 4:
258             *table_r = table + 198 * entry_size;
259             *table_b = table + (198 + 452 + 133 + 387 + 233) * entry_size;
260             *table_g = table + (198 + 452 + 133) * entry_size;
261             break;
262         case 24:
263             *table_r = *table_g = *table_b = table + 233;
264             break;
265         case 1:
266             *table_g = table;
267             *table_r = *table_b = NULL;
268             break;
269     }
270
271     return table;
272 }
273
274 /**
275  * Initialize the table_rV, table_gU[i], table_gV, and table_bU fields
276  * in SwsContext
277  *
278  * @param inv_table the YUV -> RGB table (this is a line of Inverse_Table_6_9)
279  * @param fullRange 0->MPEG YUV space 1->JPEG YUV space
280 */
281 int yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
282 {
283     int i;
284     static uint8_t ytable[1024];
285     int64_t cy, oy;
286     int64_t crv, cbu, cgu, cgv;
287     int entry_size = 0;
288     uint8_t *table_r, *table_g, *table_b;
289     int value;
290
291     if ((inv_table[0] == 0) || (inv_table[1] == 0) || (inv_table[2] == 0) || (inv_table[3] == 0)) {
292         MSG_ERR("Invalid YUV ---> RGB table!\n");
293
294         return -1;
295     }
296     crv = inv_table[0];
297     cbu = inv_table[1];
298     cgu = inv_table[2];
299     cgv = inv_table[3];
300     if (fullRange) {
301         cy = 1 << 16;
302         oy = 0;
303         crv= (crv*224) / 255;
304         cbu= (cbu*224) / 255;
305         cgu= (cgu*224) / 255;
306         cgv= (cgv*224) / 255;
307         //FIXME maybe it is cleaner if the tables where based on full range (*244/255)
308     } else {
309         cy = ((1 << 16) * 255) / 219;
310         oy= 16 << 16;
311     }
312
313     cy = (cy *contrast             )>>16;
314     crv= (crv*contrast * saturation)>>32;
315     cbu= (cbu*contrast * saturation)>>32;
316     cgu= (cgu*contrast * saturation)>>32;
317     cgv= (cgv*contrast * saturation)>>32;
318     oy -= 256*brightness;
319
320     for (i = 0; i < 1024; i++) {
321         value = (cy*(((i - YTABLE_MIN)<<16) - oy) + (1<<31))>>32;
322         ytable[i] = av_clip_uint8(value);
323     }
324
325     entry_size = get_entry_size(fmt_depth(c->dstFormat));
326     av_free(c->yuvTable);
327     c->yuvTable = allocate_tables(&table_r, &table_g, &table_b, fmt_depth(c->dstFormat));
328     if (c->yuvTable == NULL) {
329         return -1;
330     }
331
332     switch (fmt_depth(c->dstFormat)) {
333         case 32:
334             for (i = -198; i < 256 + 197; i++) {
335                 value = ytable[i + YTABLE_MIN];
336                 if (isBGR(c->dstFormat)) {
337                     value <<= 16;
338                 }
339                 ((uint32_t *)table_r)[i] = value;
340             }
341             for (i = -133; i < 256 + 132; i++) {
342                 ((uint32_t *)table_g)[i] = ytable[i + YTABLE_MIN] << 8;
343             }
344             for (i = -233; i < 256 + 232; i++) {
345                 value = ytable[i + YTABLE_MIN];
346                 if (!isBGR(c->dstFormat)) {
347                     value <<= 16;
348                 }
349                 ((uint32_t *)table_b)[i] = value;
350             }
351             break;
352
353         case 24:
354             for (i = -233; i < 256 + 232; i++) {
355                 ((uint8_t * )table_b)[i] = ytable[i + YTABLE_MIN];
356             }
357             break;
358
359         case 15:
360         case 16:
361             for (i = -198; i < 256 + 197; i++) {
362                 value = ytable[i + YTABLE_MIN] >> 3;
363                 if (isBGR(c->dstFormat)) {
364                     value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10);
365                 }
366                 ((uint16_t *)table_r)[i] = value;
367             }
368             for (i = -133; i < 256 + 132; i++) {
369                 value = ytable[i + YTABLE_MIN];
370                 value >>= ((fmt_depth(c->dstFormat) == 16) ? 2 : 3);
371                 ((uint16_t *)table_g)[i] = value << 5;
372             }
373             for (i = -233; i < 256 + 232; i++) {
374                 value = ytable[i + YTABLE_MIN] >> 3;
375                 if (!isBGR(c->dstFormat)) {
376                     value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10);
377                 }
378                 ((uint16_t *)table_b)[i] = value;
379             }
380             break;
381         case 8:
382             for (i = -198; i < 256 + 197; i++) {
383                 value = (ytable[i + YTABLE_MIN - 16] + 18) / 36;
384                 if (isBGR(c->dstFormat)) {
385                     value <<= 5;
386                 }
387                 ((uint8_t *)table_r)[i] = value;
388             }
389             for (i = -133; i < 256 + 132; i++) {
390                 value = (ytable[i + YTABLE_MIN - 16] + 18) / 36;
391                 if (!isBGR(c->dstFormat)) {
392                     value <<= 1;
393                 }
394                 ((uint8_t *)table_g)[i] = value << 2;
395             }
396             for (i = -233; i < 256 + 232; i++) {
397                 value = (ytable[i + YTABLE_MIN - 37] + 43) / 85;
398                 if (!isBGR(c->dstFormat)) {
399                     value <<= 6;
400                 }
401                 ((uint8_t *)table_b)[i] = value;
402             }
403             break;
404         case 4:
405             for (i = -198; i < 256 + 197; i++) {
406                 value = ytable[i + YTABLE_MIN - 110] >> 7;
407                 if (isBGR(c->dstFormat)) {
408                     value <<= 3;
409                 }
410                 ((uint8_t *)table_r)[i] = value;
411             }
412             for (i = -133; i < 256 + 132; i++) {
413                 value = (ytable[i + YTABLE_MIN - 37]+ 43) / 85;
414                 ((uint8_t *)table_g)[i] = value << 1;
415             }
416             for (i = -233; i < 256 + 232; i++) {
417                 value = ytable[i + YTABLE_MIN - 110] >> 7;
418                 if (!isBGR(c->dstFormat)) {
419                     value <<= 3;
420                 }
421                 ((uint8_t *)table_b)[i] = value;
422             }
423             break;
424         case 1:
425             for (i = 0; i < 256 + 256; i++) {
426                 value = ytable[i + YTABLE_MIN - 110] >> 7;
427                 ((uint8_t *)table_g)[i] = value;
428             }
429             break;
430         default:
431             MSG_ERR("%ibpp not supported by yuv2rgb\n", fmt_depth(c->dstFormat));
432             av_free(c->yuvTable);
433             c->yuvTable = NULL;
434
435             return -1;
436     }
437
438     for (i = 0; i < 256; i++) {
439         c->table_rV[i] = table_r +
440                          entry_size * ROUNDED_DIV(crv * (i - 128), 76309);
441         c->table_gU[i] = table_g +
442                          entry_size * ROUNDED_DIV(cgu * (i - 128), 76309);
443         c->table_gV[i] = entry_size * ROUNDED_DIV(cgv * (i - 128), 76309);
444         c->table_bU[i] = table_b +
445                          entry_size * ROUNDED_DIV(cbu * (i - 128), 76309);
446     }
447
448     return 0;
449 }