Statistics
| Branch: | Revision:

ffmpeg / libswscale / yuv2rgb.c @ a959e247

History | View | Annotate | Download (21.5 KB)

1
/*
2
 * software YUV to RGB converter
3
 *
4
 * Copyright (C) 2009 Konstantin Shishkov
5
 *
6
 * 1,4,8bpp support and context / deglobalize stuff
7
 * by Michael Niedermayer (michaelni@gmx.at)
8
 *
9
 * This file is part of FFmpeg.
10
 *
11
 * FFmpeg is free software; you can redistribute it and/or
12
 * modify it under the terms of the GNU Lesser General Public
13
 * License as published by the Free Software Foundation; either
14
 * version 2.1 of the License, or (at your option) any later version.
15
 *
16
 * FFmpeg is distributed in the hope that it will be useful,
17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19
 * Lesser General Public License for more details.
20
 *
21
 * You should have received a copy of the GNU Lesser General Public
22
 * License along with FFmpeg; if not, write to the Free Software
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24
 */
25

    
26
#include <stdio.h>
27
#include <stdlib.h>
28
#include <inttypes.h>
29
#include <assert.h>
30

    
31
#include "config.h"
32
#include "rgb2rgb.h"
33
#include "swscale.h"
34
#include "swscale_internal.h"
35
#include "libavutil/x86_cpu.h"
36

    
37
extern const uint8_t dither_8x8_32[8][8];
38
extern const uint8_t dither_8x8_73[8][8];
39
extern const uint8_t dither_8x8_220[8][8];
40

    
41
const int32_t ff_yuv2rgb_coeffs[8][4] = {
42
    {117504, 138453, 13954, 34903}, /* no sequence_display_extension */
43
    {117504, 138453, 13954, 34903}, /* ITU-R Rec. 709 (1990) */
44
    {104597, 132201, 25675, 53279}, /* unspecified */
45
    {104597, 132201, 25675, 53279}, /* reserved */
46
    {104448, 132798, 24759, 53109}, /* FCC */
47
    {104597, 132201, 25675, 53279}, /* ITU-R Rec. 624-4 System B, G */
48
    {104597, 132201, 25675, 53279}, /* SMPTE 170M */
49
    {117579, 136230, 16907, 35559}  /* SMPTE 240M (1987) */
50
};
51

    
52
#define LOADCHROMA(i)                               \
53
    U = pu[i];                                      \
54
    V = pv[i];                                      \
55
    r = (void *)c->table_rV[V];                     \
56
    g = (void *)(c->table_gU[U] + c->table_gV[V]);  \
57
    b = (void *)c->table_bU[U];
58

    
59
#define PUTRGB(dst,src,i)            \
60
    Y = src[2*i];                    \
61
    dst[2*i  ] = r[Y] + g[Y] + b[Y]; \
62
    Y = src[2*i+1];                  \
63
    dst[2*i+1] = r[Y] + g[Y] + b[Y];
64

    
65
#define PUTRGB24(dst,src,i)                                  \
66
    Y = src[2*i];                                            \
67
    dst[6*i+0] = r[Y]; dst[6*i+1] = g[Y]; dst[6*i+2] = b[Y]; \
68
    Y = src[2*i+1];                                          \
69
    dst[6*i+3] = r[Y]; dst[6*i+4] = g[Y]; dst[6*i+5] = b[Y];
70

    
71
#define PUTBGR24(dst,src,i)                                  \
72
    Y = src[2*i];                                            \
73
    dst[6*i+0] = b[Y]; dst[6*i+1] = g[Y]; dst[6*i+2] = r[Y]; \
74
    Y = src[2*i+1];                                          \
75
    dst[6*i+3] = b[Y]; dst[6*i+4] = g[Y]; dst[6*i+5] = r[Y];
76

    
77
#define PUTRGBA(dst,ysrc,asrc,i,s)                      \
78
    Y = ysrc[2*i];                                      \
79
    dst[2*i  ] = r[Y] + g[Y] + b[Y] + (asrc[2*i  ]<<s); \
80
    Y = ysrc[2*i+1];                                    \
81
    dst[2*i+1] = r[Y] + g[Y] + b[Y] + (asrc[2*i+1]<<s);
82

    
83
#define PUTRGB48(dst,src,i)             \
84
    Y = src[2*i];                       \
85
    dst[12*i+ 0] = dst[12*i+ 1] = r[Y]; \
86
    dst[12*i+ 2] = dst[12*i+ 3] = g[Y]; \
87
    dst[12*i+ 4] = dst[12*i+ 5] = b[Y]; \
88
    Y = src[2*i+1];                     \
89
    dst[12*i+ 6] = dst[12*i+ 7] = r[Y]; \
90
    dst[12*i+ 8] = dst[12*i+ 9] = g[Y]; \
91
    dst[12*i+10] = dst[12*i+11] = b[Y];
92

    
93
#define YUV2RGBFUNC(func_name, dst_type, alpha) \
94
static int func_name(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY, \
95
                     int srcSliceH, uint8_t* dst[], int dstStride[]) \
96
{\
97
    int y;\
98
\
99
    if (!alpha && c->srcFormat == PIX_FMT_YUV422P) {\
100
        srcStride[1] *= 2;\
101
        srcStride[2] *= 2;\
102
    }\
103
    for (y=0; y<srcSliceH; y+=2) {\
104
        dst_type *dst_1 = (dst_type*)(dst[0] + (y+srcSliceY  )*dstStride[0]);\
105
        dst_type *dst_2 = (dst_type*)(dst[0] + (y+srcSliceY+1)*dstStride[0]);\
106
        dst_type av_unused *r, *b;\
107
        dst_type *g;\
108
        const uint8_t *py_1 = src[0] + y*srcStride[0];\
109
        const uint8_t *py_2 = py_1 + srcStride[0];\
110
        const uint8_t *pu = src[1] + (y>>1)*srcStride[1];\
111
        const uint8_t *pv = src[2] + (y>>1)*srcStride[2];\
112
        const uint8_t av_unused *pa_1, *pa_2;\
113
        unsigned int h_size = c->dstW>>3;\
114
        if (alpha) {\
115
            pa_1 = src[3] + y*srcStride[3];\
116
            pa_2 = pa_1 + srcStride[3];\
117
        }\
118
        while (h_size--) {\
119
            int av_unused U, V;\
120
            int Y;\
121

    
122
#define ENDYUV2RGBLINE(dst_delta)\
123
            pu += 4;\
124
            pv += 4;\
125
            py_1 += 8;\
126
            py_2 += 8;\
127
            dst_1 += dst_delta;\
128
            dst_2 += dst_delta;\
129
        }\
130
        if (c->dstW & 4) {\
131
            int av_unused Y, U, V;\
132

    
133
#define ENDYUV2RGBFUNC()\
134
        }\
135
    }\
136
    return srcSliceH;\
137
}
138

    
139
#define CLOSEYUV2RGBFUNC(dst_delta)\
140
    ENDYUV2RGBLINE(dst_delta)\
141
    ENDYUV2RGBFUNC()
142

    
143
YUV2RGBFUNC(yuv2rgb_c_48, uint8_t, 0)
144
    LOADCHROMA(0);
145
    PUTRGB48(dst_1,py_1,0);
146
    PUTRGB48(dst_2,py_2,0);
147

    
148
    LOADCHROMA(1);
149
    PUTRGB48(dst_2,py_2,1);
150
    PUTRGB48(dst_1,py_1,1);
151

    
152
    LOADCHROMA(2);
153
    PUTRGB48(dst_1,py_1,2);
154
    PUTRGB48(dst_2,py_2,2);
155

    
156
    LOADCHROMA(3);
157
    PUTRGB48(dst_2,py_2,3);
158
    PUTRGB48(dst_1,py_1,3);
159
ENDYUV2RGBLINE(48)
160
    LOADCHROMA(0);
161
    PUTRGB48(dst_1,py_1,0);
162
    PUTRGB48(dst_2,py_2,0);
163

    
164
    LOADCHROMA(1);
165
    PUTRGB48(dst_2,py_2,1);
166
    PUTRGB48(dst_1,py_1,1);
167
ENDYUV2RGBFUNC()
168

    
169
YUV2RGBFUNC(yuv2rgb_c_32, uint32_t, 0)
170
    LOADCHROMA(0);
171
    PUTRGB(dst_1,py_1,0);
172
    PUTRGB(dst_2,py_2,0);
173

    
174
    LOADCHROMA(1);
175
    PUTRGB(dst_2,py_2,1);
176
    PUTRGB(dst_1,py_1,1);
177

    
178
    LOADCHROMA(2);
179
    PUTRGB(dst_1,py_1,2);
180
    PUTRGB(dst_2,py_2,2);
181

    
182
    LOADCHROMA(3);
183
    PUTRGB(dst_2,py_2,3);
184
    PUTRGB(dst_1,py_1,3);
185
ENDYUV2RGBLINE(8)
186
    LOADCHROMA(0);
187
    PUTRGB(dst_1,py_1,0);
188
    PUTRGB(dst_2,py_2,0);
189

    
190
    LOADCHROMA(1);
191
    PUTRGB(dst_2,py_2,1);
192
    PUTRGB(dst_1,py_1,1);
193
ENDYUV2RGBFUNC()
194

    
195
YUV2RGBFUNC(yuva2rgba_c, uint32_t, 1)
196
    LOADCHROMA(0);
197
    PUTRGBA(dst_1,py_1,pa_1,0,24);
198
    PUTRGBA(dst_2,py_2,pa_2,0,24);
199

    
200
    LOADCHROMA(1);
201
    PUTRGBA(dst_2,py_2,pa_1,1,24);
202
    PUTRGBA(dst_1,py_1,pa_2,1,24);
203

    
204
    LOADCHROMA(2);
205
    PUTRGBA(dst_1,py_1,pa_1,2,24);
206
    PUTRGBA(dst_2,py_2,pa_2,2,24);
207

    
208
    LOADCHROMA(3);
209
    PUTRGBA(dst_2,py_2,pa_1,3,24);
210
    PUTRGBA(dst_1,py_1,pa_2,3,24);
211
    pa_1 += 8;\
212
    pa_2 += 8;\
213
ENDYUV2RGBLINE(8)
214
    LOADCHROMA(0);
215
    PUTRGBA(dst_1,py_1,pa_1,0,24);
216
    PUTRGBA(dst_2,py_2,pa_2,0,24);
217

    
218
    LOADCHROMA(1);
219
    PUTRGBA(dst_2,py_2,pa_1,1,24);
220
    PUTRGBA(dst_1,py_1,pa_2,1,24);
221
ENDYUV2RGBFUNC()
222

    
223
YUV2RGBFUNC(yuva2argb_c, uint32_t, 1)
224
    LOADCHROMA(0);
225
    PUTRGBA(dst_1,py_1,pa_1,0,0);
226
    PUTRGBA(dst_2,py_2,pa_2,0,0);
227

    
228
    LOADCHROMA(1);
229
    PUTRGBA(dst_2,py_2,pa_2,1,0);
230
    PUTRGBA(dst_1,py_1,pa_1,1,0);
231

    
232
    LOADCHROMA(2);
233
    PUTRGBA(dst_1,py_1,pa_1,2,0);
234
    PUTRGBA(dst_2,py_2,pa_2,2,0);
235

    
236
    LOADCHROMA(3);
237
    PUTRGBA(dst_2,py_2,pa_2,3,0);
238
    PUTRGBA(dst_1,py_1,pa_1,3,0);
239
    pa_1 += 8;\
240
    pa_2 += 8;\
241
ENDYUV2RGBLINE(8)
242
    LOADCHROMA(0);
243
    PUTRGBA(dst_1,py_1,pa_1,0,0);
244
    PUTRGBA(dst_2,py_2,pa_2,0,0);
245

    
246
    LOADCHROMA(1);
247
    PUTRGBA(dst_2,py_2,pa_2,1,0);
248
    PUTRGBA(dst_1,py_1,pa_1,1,0);
249
ENDYUV2RGBFUNC()
250

    
251
YUV2RGBFUNC(yuv2rgb_c_24_rgb, uint8_t, 0)
252
    LOADCHROMA(0);
253
    PUTRGB24(dst_1,py_1,0);
254
    PUTRGB24(dst_2,py_2,0);
255

    
256
    LOADCHROMA(1);
257
    PUTRGB24(dst_2,py_2,1);
258
    PUTRGB24(dst_1,py_1,1);
259

    
260
    LOADCHROMA(2);
261
    PUTRGB24(dst_1,py_1,2);
262
    PUTRGB24(dst_2,py_2,2);
263

    
264
    LOADCHROMA(3);
265
    PUTRGB24(dst_2,py_2,3);
266
    PUTRGB24(dst_1,py_1,3);
267
ENDYUV2RGBLINE(24)
268
    LOADCHROMA(0);
269
    PUTRGB24(dst_1,py_1,0);
270
    PUTRGB24(dst_2,py_2,0);
271

    
272
    LOADCHROMA(1);
273
    PUTRGB24(dst_2,py_2,1);
274
    PUTRGB24(dst_1,py_1,1);
275
ENDYUV2RGBFUNC()
276

    
277
// only trivial mods from yuv2rgb_c_24_rgb
278
YUV2RGBFUNC(yuv2rgb_c_24_bgr, uint8_t, 0)
279
    LOADCHROMA(0);
280
    PUTBGR24(dst_1,py_1,0);
281
    PUTBGR24(dst_2,py_2,0);
282

    
283
    LOADCHROMA(1);
284
    PUTBGR24(dst_2,py_2,1);
285
    PUTBGR24(dst_1,py_1,1);
286

    
287
    LOADCHROMA(2);
288
    PUTBGR24(dst_1,py_1,2);
289
    PUTBGR24(dst_2,py_2,2);
290

    
291
    LOADCHROMA(3);
292
    PUTBGR24(dst_2,py_2,3);
293
    PUTBGR24(dst_1,py_1,3);
294
ENDYUV2RGBLINE(24)
295
    LOADCHROMA(0);
296
    PUTBGR24(dst_1,py_1,0);
297
    PUTBGR24(dst_2,py_2,0);
298

    
299
    LOADCHROMA(1);
300
    PUTBGR24(dst_2,py_2,1);
301
    PUTBGR24(dst_1,py_1,1);
302
ENDYUV2RGBFUNC()
303

    
304
// This is exactly the same code as yuv2rgb_c_32 except for the types of
305
// r, g, b, dst_1, dst_2
306
YUV2RGBFUNC(yuv2rgb_c_16, uint16_t, 0)
307
    LOADCHROMA(0);
308
    PUTRGB(dst_1,py_1,0);
309
    PUTRGB(dst_2,py_2,0);
310

    
311
    LOADCHROMA(1);
312
    PUTRGB(dst_2,py_2,1);
313
    PUTRGB(dst_1,py_1,1);
314

    
315
    LOADCHROMA(2);
316
    PUTRGB(dst_1,py_1,2);
317
    PUTRGB(dst_2,py_2,2);
318

    
319
    LOADCHROMA(3);
320
    PUTRGB(dst_2,py_2,3);
321
    PUTRGB(dst_1,py_1,3);
322
CLOSEYUV2RGBFUNC(8)
323

    
324
// This is exactly the same code as yuv2rgb_c_32 except for the types of
325
// r, g, b, dst_1, dst_2
326
YUV2RGBFUNC(yuv2rgb_c_8, uint8_t, 0)
327
    LOADCHROMA(0);
328
    PUTRGB(dst_1,py_1,0);
329
    PUTRGB(dst_2,py_2,0);
330

    
331
    LOADCHROMA(1);
332
    PUTRGB(dst_2,py_2,1);
333
    PUTRGB(dst_1,py_1,1);
334

    
335
    LOADCHROMA(2);
336
    PUTRGB(dst_1,py_1,2);
337
    PUTRGB(dst_2,py_2,2);
338

    
339
    LOADCHROMA(3);
340
    PUTRGB(dst_2,py_2,3);
341
    PUTRGB(dst_1,py_1,3);
342
CLOSEYUV2RGBFUNC(8)
343

    
344
// r, g, b, dst_1, dst_2
345
YUV2RGBFUNC(yuv2rgb_c_8_ordered_dither, uint8_t, 0)
346
    const uint8_t *d32 = dither_8x8_32[y&7];
347
    const uint8_t *d64 = dither_8x8_73[y&7];
348
#define PUTRGB8(dst,src,i,o)                                    \
349
    Y = src[2*i];                                               \
350
    dst[2*i]   = r[Y+d32[0+o]] + g[Y+d32[0+o]] + b[Y+d64[0+o]]; \
351
    Y = src[2*i+1];                                             \
352
    dst[2*i+1] = r[Y+d32[1+o]] + g[Y+d32[1+o]] + b[Y+d64[1+o]];
353

    
354
    LOADCHROMA(0);
355
    PUTRGB8(dst_1,py_1,0,0);
356
    PUTRGB8(dst_2,py_2,0,0+8);
357

    
358
    LOADCHROMA(1);
359
    PUTRGB8(dst_2,py_2,1,2+8);
360
    PUTRGB8(dst_1,py_1,1,2);
361

    
362
    LOADCHROMA(2);
363
    PUTRGB8(dst_1,py_1,2,4);
364
    PUTRGB8(dst_2,py_2,2,4+8);
365

    
366
    LOADCHROMA(3);
367
    PUTRGB8(dst_2,py_2,3,6+8);
368
    PUTRGB8(dst_1,py_1,3,6);
369
CLOSEYUV2RGBFUNC(8)
370

    
371

    
372
// This is exactly the same code as yuv2rgb_c_32 except for the types of
373
// r, g, b, dst_1, dst_2
374
YUV2RGBFUNC(yuv2rgb_c_4, uint8_t, 0)
375
    int acc;
376
#define PUTRGB4(dst,src,i)          \
377
    Y = src[2*i];                   \
378
    acc = r[Y] + g[Y] + b[Y];       \
379
    Y = src[2*i+1];                 \
380
    acc |= (r[Y] + g[Y] + b[Y])<<4; \
381
    dst[i] = acc;
382

    
383
    LOADCHROMA(0);
384
    PUTRGB4(dst_1,py_1,0);
385
    PUTRGB4(dst_2,py_2,0);
386

    
387
    LOADCHROMA(1);
388
    PUTRGB4(dst_2,py_2,1);
389
    PUTRGB4(dst_1,py_1,1);
390

    
391
    LOADCHROMA(2);
392
    PUTRGB4(dst_1,py_1,2);
393
    PUTRGB4(dst_2,py_2,2);
394

    
395
    LOADCHROMA(3);
396
    PUTRGB4(dst_2,py_2,3);
397
    PUTRGB4(dst_1,py_1,3);
398
CLOSEYUV2RGBFUNC(4)
399

    
400
YUV2RGBFUNC(yuv2rgb_c_4_ordered_dither, uint8_t, 0)
401
    const uint8_t *d64 =  dither_8x8_73[y&7];
402
    const uint8_t *d128 = dither_8x8_220[y&7];
403
    int acc;
404

    
405
#define PUTRGB4D(dst,src,i,o)                                     \
406
    Y = src[2*i];                                                 \
407
    acc = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]];        \
408
    Y = src[2*i+1];                                               \
409
    acc |= (r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]])<<4;  \
410
    dst[i]= acc;
411

    
412
    LOADCHROMA(0);
413
    PUTRGB4D(dst_1,py_1,0,0);
414
    PUTRGB4D(dst_2,py_2,0,0+8);
415

    
416
    LOADCHROMA(1);
417
    PUTRGB4D(dst_2,py_2,1,2+8);
418
    PUTRGB4D(dst_1,py_1,1,2);
419

    
420
    LOADCHROMA(2);
421
    PUTRGB4D(dst_1,py_1,2,4);
422
    PUTRGB4D(dst_2,py_2,2,4+8);
423

    
424
    LOADCHROMA(3);
425
    PUTRGB4D(dst_2,py_2,3,6+8);
426
    PUTRGB4D(dst_1,py_1,3,6);
427
CLOSEYUV2RGBFUNC(4)
428

    
429
// This is exactly the same code as yuv2rgb_c_32 except for the types of
430
// r, g, b, dst_1, dst_2
431
YUV2RGBFUNC(yuv2rgb_c_4b, uint8_t, 0)
432
    LOADCHROMA(0);
433
    PUTRGB(dst_1,py_1,0);
434
    PUTRGB(dst_2,py_2,0);
435

    
436
    LOADCHROMA(1);
437
    PUTRGB(dst_2,py_2,1);
438
    PUTRGB(dst_1,py_1,1);
439

    
440
    LOADCHROMA(2);
441
    PUTRGB(dst_1,py_1,2);
442
    PUTRGB(dst_2,py_2,2);
443

    
444
    LOADCHROMA(3);
445
    PUTRGB(dst_2,py_2,3);
446
    PUTRGB(dst_1,py_1,3);
447
CLOSEYUV2RGBFUNC(8)
448

    
449
YUV2RGBFUNC(yuv2rgb_c_4b_ordered_dither, uint8_t, 0)
450
    const uint8_t *d64 =  dither_8x8_73[y&7];
451
    const uint8_t *d128 = dither_8x8_220[y&7];
452

    
453
#define PUTRGB4DB(dst,src,i,o)                                    \
454
    Y = src[2*i];                                                 \
455
    dst[2*i]   = r[Y+d128[0+o]] + g[Y+d64[0+o]] + b[Y+d128[0+o]]; \
456
    Y = src[2*i+1];                                               \
457
    dst[2*i+1] = r[Y+d128[1+o]] + g[Y+d64[1+o]] + b[Y+d128[1+o]];
458

    
459
    LOADCHROMA(0);
460
    PUTRGB4DB(dst_1,py_1,0,0);
461
    PUTRGB4DB(dst_2,py_2,0,0+8);
462

    
463
    LOADCHROMA(1);
464
    PUTRGB4DB(dst_2,py_2,1,2+8);
465
    PUTRGB4DB(dst_1,py_1,1,2);
466

    
467
    LOADCHROMA(2);
468
    PUTRGB4DB(dst_1,py_1,2,4);
469
    PUTRGB4DB(dst_2,py_2,2,4+8);
470

    
471
    LOADCHROMA(3);
472
    PUTRGB4DB(dst_2,py_2,3,6+8);
473
    PUTRGB4DB(dst_1,py_1,3,6);
474
CLOSEYUV2RGBFUNC(8)
475

    
476
YUV2RGBFUNC(yuv2rgb_c_1_ordered_dither, uint8_t, 0)
477
        const uint8_t *d128 = dither_8x8_220[y&7];
478
        char out_1 = 0, out_2 = 0;
479
        g= c->table_gU[128] + c->table_gV[128];
480

    
481
#define PUTRGB1(out,src,i,o)    \
482
    Y = src[2*i];               \
483
    out+= out + g[Y+d128[0+o]]; \
484
    Y = src[2*i+1];             \
485
    out+= out + g[Y+d128[1+o]];
486

    
487
    PUTRGB1(out_1,py_1,0,0);
488
    PUTRGB1(out_2,py_2,0,0+8);
489

    
490
    PUTRGB1(out_2,py_2,1,2+8);
491
    PUTRGB1(out_1,py_1,1,2);
492

    
493
    PUTRGB1(out_1,py_1,2,4);
494
    PUTRGB1(out_2,py_2,2,4+8);
495

    
496
    PUTRGB1(out_2,py_2,3,6+8);
497
    PUTRGB1(out_1,py_1,3,6);
498

    
499
    dst_1[0]= out_1;
500
    dst_2[0]= out_2;
501
CLOSEYUV2RGBFUNC(1)
502

    
503
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
504
{
505
    SwsFunc t = NULL;
506
#if (HAVE_MMX2 || HAVE_MMX) && CONFIG_GPL
507
     t = ff_yuv2rgb_init_mmx(c);
508
#endif
509
#if HAVE_VIS
510
    t = ff_yuv2rgb_init_vis(c);
511
#endif
512
#if CONFIG_MLIB
513
    t = ff_yuv2rgb_init_mlib(c);
514
#endif
515
#if HAVE_ALTIVEC
516
    if (c->flags & SWS_CPU_CAPS_ALTIVEC)
517
        t = ff_yuv2rgb_init_altivec(c);
518
#endif
519

    
520
#if ARCH_BFIN
521
    if (c->flags & SWS_CPU_CAPS_BFIN)
522
        t = ff_yuv2rgb_get_func_ptr_bfin(c);
523
#endif
524

    
525
    if (t)
526
        return t;
527

    
528
    av_log(c, AV_LOG_WARNING, "No accelerated colorspace conversion found.\n");
529

    
530
    switch (c->dstFormat) {
531
    case PIX_FMT_RGB48BE:
532
    case PIX_FMT_RGB48LE:    return yuv2rgb_c_48;
533
    case PIX_FMT_ARGB:
534
    case PIX_FMT_ABGR:       if (CONFIG_SWSCALE_ALPHA && c->srcFormat == PIX_FMT_YUVA420P) return yuva2argb_c;
535
    case PIX_FMT_RGBA:
536
    case PIX_FMT_BGRA:       return (CONFIG_SWSCALE_ALPHA && c->srcFormat == PIX_FMT_YUVA420P) ? yuva2rgba_c : yuv2rgb_c_32;
537
    case PIX_FMT_RGB24:      return yuv2rgb_c_24_rgb;
538
    case PIX_FMT_BGR24:      return yuv2rgb_c_24_bgr;
539
    case PIX_FMT_RGB565:
540
    case PIX_FMT_BGR565:
541
    case PIX_FMT_RGB555:
542
    case PIX_FMT_BGR555:     return yuv2rgb_c_16;
543
    case PIX_FMT_RGB8:
544
    case PIX_FMT_BGR8:       return yuv2rgb_c_8_ordered_dither;
545
    case PIX_FMT_RGB4:
546
    case PIX_FMT_BGR4:       return yuv2rgb_c_4_ordered_dither;
547
    case PIX_FMT_RGB4_BYTE:
548
    case PIX_FMT_BGR4_BYTE:  return yuv2rgb_c_4b_ordered_dither;
549
    case PIX_FMT_MONOBLACK:  return yuv2rgb_c_1_ordered_dither;
550
    default:
551
        assert(0);
552
    }
553
    return NULL;
554
}
555

    
556
static void fill_table(uint8_t* table[256], const int elemsize, const int inc, uint8_t *y_table)
557
{
558
    int i;
559
    int64_t cb = 0;
560

    
561
    y_table -= elemsize * (inc >> 9);
562

    
563
    for (i = 0; i < 256; i++) {
564
        table[i] = y_table + elemsize * (cb >> 16);
565
        cb += inc;
566
    }
567
}
568

    
569
static void fill_gv_table(int table[256], const int elemsize, const int inc)
570
{
571
    int i;
572
    int64_t cb = 0;
573
    int off = -(inc >> 9);
574

    
575
    for (i = 0; i < 256; i++) {
576
        table[i] = elemsize * (off + (cb >> 16));
577
        cb += inc;
578
    }
579
}
580

    
581
av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange,
582
                                     int brightness, int contrast, int saturation)
583
{
584
    const int isRgb =      c->dstFormat==PIX_FMT_RGB32
585
                        || c->dstFormat==PIX_FMT_RGB32_1
586
                        || c->dstFormat==PIX_FMT_BGR24
587
                        || c->dstFormat==PIX_FMT_RGB565
588
                        || c->dstFormat==PIX_FMT_RGB555
589
                        || c->dstFormat==PIX_FMT_RGB8
590
                        || c->dstFormat==PIX_FMT_RGB4
591
                        || c->dstFormat==PIX_FMT_RGB4_BYTE
592
                        || c->dstFormat==PIX_FMT_MONOBLACK;
593
    const int bpp = fmt_depth(c->dstFormat);
594
    uint8_t *y_table;
595
    uint16_t *y_table16;
596
    uint32_t *y_table32;
597
    int i, base, rbase, gbase, bbase, abase, needAlpha;
598
    const int yoffs = fullRange ? 384 : 326;
599

    
600
    int64_t crv =  inv_table[0];
601
    int64_t cbu =  inv_table[1];
602
    int64_t cgu = -inv_table[2];
603
    int64_t cgv = -inv_table[3];
604
    int64_t cy  = 1<<16;
605
    int64_t oy  = 0;
606

    
607
    int64_t yb = 0;
608

    
609
    if (!fullRange) {
610
        cy = (cy*255) / 219;
611
        oy = 16<<16;
612
    } else {
613
        crv = (crv*224) / 255;
614
        cbu = (cbu*224) / 255;
615
        cgu = (cgu*224) / 255;
616
        cgv = (cgv*224) / 255;
617
    }
618

    
619
    cy  = (cy *contrast             ) >> 16;
620
    crv = (crv*contrast * saturation) >> 32;
621
    cbu = (cbu*contrast * saturation) >> 32;
622
    cgu = (cgu*contrast * saturation) >> 32;
623
    cgv = (cgv*contrast * saturation) >> 32;
624
    oy -= 256*brightness;
625

    
626
    //scale coefficients by cy
627
    crv = ((crv << 16) + 0x8000) / cy;
628
    cbu = ((cbu << 16) + 0x8000) / cy;
629
    cgu = ((cgu << 16) + 0x8000) / cy;
630
    cgv = ((cgv << 16) + 0x8000) / cy;
631

    
632
    av_free(c->yuvTable);
633

    
634
    switch (bpp) {
635
    case 1:
636
        c->yuvTable = av_malloc(1024);
637
        y_table = c->yuvTable;
638
        yb = -(384<<16) - oy;
639
        for (i = 0; i < 1024-110; i++) {
640
            y_table[i+110] = av_clip_uint8((yb + 0x8000) >> 16) >> 7;
641
            yb += cy;
642
        }
643
        fill_table(c->table_gU, 1, cgu, y_table + yoffs);
644
        fill_gv_table(c->table_gV, 1, cgv);
645
        break;
646
    case 4:
647
    case 4|128:
648
        rbase = isRgb ? 3 : 0;
649
        gbase = 1;
650
        bbase = isRgb ? 0 : 3;
651
        c->yuvTable = av_malloc(1024*3);
652
        y_table = c->yuvTable;
653
        yb = -(384<<16) - oy;
654
        for (i = 0; i < 1024-110; i++) {
655
            int yval = av_clip_uint8((yb + 0x8000) >> 16);
656
            y_table[i+110     ] =  (yval >> 7)       << rbase;
657
            y_table[i+ 37+1024] = ((yval + 43) / 85) << gbase;
658
            y_table[i+110+2048] =  (yval >> 7)       << bbase;
659
            yb += cy;
660
        }
661
        fill_table(c->table_rV, 1, crv, y_table + yoffs);
662
        fill_table(c->table_gU, 1, cgu, y_table + yoffs + 1024);
663
        fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2048);
664
        fill_gv_table(c->table_gV, 1, cgv);
665
        break;
666
    case 8:
667
        rbase = isRgb ? 5 : 0;
668
        gbase = isRgb ? 2 : 3;
669
        bbase = isRgb ? 0 : 6;
670
        c->yuvTable = av_malloc(1024*3);
671
        y_table = c->yuvTable;
672
        yb = -(384<<16) - oy;
673
        for (i = 0; i < 1024-38; i++) {
674
            int yval = av_clip_uint8((yb + 0x8000) >> 16);
675
            y_table[i+16     ] = ((yval + 18) / 36) << rbase;
676
            y_table[i+16+1024] = ((yval + 18) / 36) << gbase;
677
            y_table[i+37+2048] = ((yval + 43) / 85) << bbase;
678
            yb += cy;
679
        }
680
        fill_table(c->table_rV, 1, crv, y_table + yoffs);
681
        fill_table(c->table_gU, 1, cgu, y_table + yoffs + 1024);
682
        fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2048);
683
        fill_gv_table(c->table_gV, 1, cgv);
684
        break;
685
    case 15:
686
    case 16:
687
        rbase = isRgb ? bpp - 5 : 0;
688
        gbase = 5;
689
        bbase = isRgb ? 0 : (bpp - 5);
690
        c->yuvTable = av_malloc(1024*3*2);
691
        y_table16 = c->yuvTable;
692
        yb = -(384<<16) - oy;
693
        for (i = 0; i < 1024; i++) {
694
            uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
695
            y_table16[i     ] = (yval >> 3)          << rbase;
696
            y_table16[i+1024] = (yval >> (18 - bpp)) << gbase;
697
            y_table16[i+2048] = (yval >> 3)          << bbase;
698
            yb += cy;
699
        }
700
        fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
701
        fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + 1024);
702
        fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2048);
703
        fill_gv_table(c->table_gV, 2, cgv);
704
        break;
705
    case 24:
706
    case 48:
707
        c->yuvTable = av_malloc(1024);
708
        y_table = c->yuvTable;
709
        yb = -(384<<16) - oy;
710
        for (i = 0; i < 1024; i++) {
711
            y_table[i] = av_clip_uint8((yb + 0x8000) >> 16);
712
            yb += cy;
713
        }
714
        fill_table(c->table_rV, 1, crv, y_table + yoffs);
715
        fill_table(c->table_gU, 1, cgu, y_table + yoffs);
716
        fill_table(c->table_bU, 1, cbu, y_table + yoffs);
717
        fill_gv_table(c->table_gV, 1, cgv);
718
        break;
719
    case 32:
720
        base = (c->dstFormat == PIX_FMT_RGB32_1 || c->dstFormat == PIX_FMT_BGR32_1) ? 8 : 0;
721
        rbase = base + (isRgb ? 16 : 0);
722
        gbase = base + 8;
723
        bbase = base + (isRgb ? 0 : 16);
724
        needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat);
725
        if (!needAlpha)
726
            abase = (base + 24) & 31;
727
        c->yuvTable = av_malloc(1024*3*4);
728
        y_table32 = c->yuvTable;
729
        yb = -(384<<16) - oy;
730
        for (i = 0; i < 1024; i++) {
731
            uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
732
            y_table32[i     ] = (yval << rbase) + (needAlpha ? 0 : (255 << abase));
733
            y_table32[i+1024] = yval << gbase;
734
            y_table32[i+2048] = yval << bbase;
735
            yb += cy;
736
        }
737
        fill_table(c->table_rV, 4, crv, y_table32 + yoffs);
738
        fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + 1024);
739
        fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2048);
740
        fill_gv_table(c->table_gV, 4, cgv);
741
        break;
742
    default:
743
        c->yuvTable = NULL;
744
        av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);
745
        return -1;
746
    }
747
    return 0;
748
}