← Back to branch summary

~akirad/cinecutie/trunk

« back to all changes in this revision

Viewing changes to quicktime/ffmpeg/libswscale/yuv2rgb.c

  • Committer: Paolo Rampino
  • Date: 2010-03-06 18:08:30 UTC
  • Revision ID: git-v1:9d525e02347cedf5c7cbe9ecbf5d50b83c26f5e4
Updated ffmpeg, now open also flv with aac codecs

Show diffs side-by-side

added added

removed removed

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