Statistics
| Branch: | Revision:

ffmpeg / libswscale / yuv2rgb_init.c @ adcec46a

History | View | Annotate | Download (12.9 KB)

1 9bde778e Luca Abeni
#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
    } else {
267
        cy = ((1 << 16) * 255) / 219;
268
        oy= 16 << 16;
269
    }
270
271
    cy = (cy *contrast             )>>16;
272
    crv= (crv*contrast * saturation)>>32;
273
    cbu= (cbu*contrast * saturation)>>32;
274
    cgu= (cgu*contrast * saturation)>>32;
275
    cgv= (cgv*contrast * saturation)>>32;
276
    oy -= 256*brightness;
277
278
    for (i = 0; i < 1024; i++) {
279
        value = (cy*(((i - YTABLE_MIN)<<16) - oy) + (1<<31))>>32;
280 adcec46a Reimar Döffinger
        ytable[i] = av_clip_uint8(value);
281 9bde778e Luca Abeni
    }
282
283
    entry_size = get_entry_size(fmt_depth(c->dstFormat));
284
    av_free(c->yuvTable);
285
    c->yuvTable = allocate_tables(&table_r, &table_g, &table_b, fmt_depth(c->dstFormat));
286
    if (c->yuvTable == NULL) {
287
        return -1;
288
    }
289
290
    switch (fmt_depth(c->dstFormat)) {
291
        case 32:
292
            for (i = -198; i < 256 + 197; i++) {
293
                value = ytable[i + YTABLE_MIN];
294
                if (isBGR(c->dstFormat)) {
295
                    value <<= 16;
296
                }
297
                ((uint32_t *)table_r)[i] = value;
298
            }
299
            for (i = -133; i < 256 + 132; i++) {
300
                ((uint32_t *)table_g)[i] = ytable[i + YTABLE_MIN] << 8;
301
            }
302
            for (i = -233; i < 256 + 232; i++) {
303
                value = ytable[i + YTABLE_MIN];
304
                if (!isBGR(c->dstFormat)) {
305
                    value <<= 16;
306
                }
307
                ((uint32_t *)table_b)[i] = value;
308
            }
309
            break;
310
311
        case 24:
312
            for (i = -233; i < 256 + 232; i++) {
313
                ((uint8_t * )table_b)[i] = ytable[i + YTABLE_MIN];
314
            }
315
            break;
316
317
        case 15:
318
        case 16:
319
            for (i = -198; i < 256 + 197; i++) {
320
                value = ytable[i + YTABLE_MIN] >> 3;
321
                if (isBGR(c->dstFormat)) {
322
                    value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10);
323
                }
324
                ((uint16_t *)table_r)[i] = value;
325
            }
326
            for (i = -133; i < 256 + 132; i++) {
327
                value = ytable[i + YTABLE_MIN];
328
                value >>= ((fmt_depth(c->dstFormat) == 16) ? 2 : 3);
329
                ((uint16_t *)table_g)[i] = value << 5;
330
            }
331
            for (i = -233; i < 256 + 232; i++) {
332
                value = ytable[i + YTABLE_MIN] >> 3;
333
                if (!isBGR(c->dstFormat)) {
334
                    value <<= ((fmt_depth(c->dstFormat) == 16) ? 11 : 10);
335
                }
336
                ((uint16_t *)table_b)[i] = value;
337
            }
338
            break;
339
        case 8:
340
            for (i = -198; i < 256 + 197; i++) {
341
                value = (ytable[i + YTABLE_MIN - 16] + 18) / 36;
342
                if (isBGR(c->dstFormat)) {
343
                    value <<= 5;
344
                }
345
                ((uint8_t *)table_r)[i] = value;
346
            }
347
            for (i = -133; i < 256 + 132; i++) {
348
                value = (ytable[i + YTABLE_MIN - 16] + 18) / 36;
349
                if (!isBGR(c->dstFormat)) {
350
                    value <<= 1;
351
                }
352
                ((uint8_t *)table_g)[i] = value << 2;
353
            }
354
            for (i = -233; i < 256 + 232; i++) {
355
                value = (ytable[i + YTABLE_MIN - 37] + 43) / 85;
356
                if (!isBGR(c->dstFormat)) {
357
                    value <<= 6;
358
                }
359
                ((uint8_t *)table_b)[i] = value;
360
            }
361
            break;
362
        case 4:
363
            for (i = -198; i < 256 + 197; i++) {
364
                value = ytable[i + YTABLE_MIN - 110] >> 7;
365
                if (isBGR(c->dstFormat)) {
366
                    value <<= 3;
367
                }
368
                ((uint8_t *)table_r)[i] = value;
369
            }
370
            for (i = -133; i < 256 + 132; i++) {
371
                value = (ytable[i + YTABLE_MIN - 37]+ 43) / 85;
372
                ((uint8_t *)table_g)[i] = value << 1;
373
            }
374
            for (i = -233; i < 256 + 232; i++) {
375
                value = ytable[i + YTABLE_MIN - 110] >> 7;
376
                if (!isBGR(c->dstFormat)) {
377
                    value <<= 3;
378
                }
379
                ((uint8_t *)table_b)[i] = value;
380
            }
381
            break;
382
        case 1:
383
            for (i = 0; i < 256 + 256; i++) {
384
                value = ytable[i + YTABLE_MIN - 110] >> 7;
385
                ((uint8_t *)table_g)[i] = value;
386
            }
387
            break;
388
        default:
389
            MSG_ERR("%ibpp not supported by yuv2rgb\n", fmt_depth(c->dstFormat));
390
            av_free(c->yuvTable);
391
            c->yuvTable = NULL;
392
393
            return -1;
394
    }
395
396
    for (i = 0; i < 256; i++) {
397
        c->table_rV[i] = table_r +
398
                         entry_size * ROUNDED_DIV(crv * (i - 128), 76309);
399
        c->table_gU[i] = table_g +
400
                         entry_size * ROUNDED_DIV(cgu * (i - 128), 76309);
401
        c->table_gV[i] = entry_size * ROUNDED_DIV(cgv * (i - 128), 76309);
402
        c->table_bU[i] = table_b +
403
                         entry_size * ROUNDED_DIV(cbu * (i - 128), 76309);
404
    }
405
406
    return 0;
407
}