sws: factorize rgb 9+ planar funcs declarations.
[ffmpeg.git] / libswscale / input.c
1 /*
2  * Copyright (C) 2001-2012 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include <assert.h>
22 #include <math.h>
23 #include <stdint.h>
24 #include <stdio.h>
25 #include <string.h>
26
27 #include "libavutil/avutil.h"
28 #include "libavutil/bswap.h"
29 #include "libavutil/cpu.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/avassert.h"
34 #include "config.h"
35 #include "rgb2rgb.h"
36 #include "swscale.h"
37 #include "swscale_internal.h"
38
39 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
40
41 #define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? b_r : r_b)
42 #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? r_b : b_r)
43
44 static av_always_inline void
45 rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
46                     enum AVPixelFormat origin, int32_t *rgb2yuv)
47 {
48     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
49     int i;
50     for (i = 0; i < width; i++) {
51         unsigned int r_b = input_pixel(&src[i*4+0]);
52         unsigned int   g = input_pixel(&src[i*4+1]);
53         unsigned int b_r = input_pixel(&src[i*4+2]);
54
55         dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
56     }
57 }
58
59 static av_always_inline void
60 rgb64ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
61                     const uint16_t *src1, const uint16_t *src2,
62                     int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
63 {
64     int i;
65     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
66     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
67     av_assert1(src1==src2);
68     for (i = 0; i < width; i++) {
69         int r_b = input_pixel(&src1[i*4+0]);
70         int   g = input_pixel(&src1[i*4+1]);
71         int b_r = input_pixel(&src1[i*4+2]);
72
73         dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
74         dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
75     }
76 }
77
78 static av_always_inline void
79 rgb64ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
80                           const uint16_t *src1, const uint16_t *src2,
81                           int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
82 {
83     int i;
84     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
85     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
86     av_assert1(src1==src2);
87     for (i = 0; i < width; i++) {
88         int r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
89         int   g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
90         int b_r = (input_pixel(&src1[8 * i + 2]) + input_pixel(&src1[8 * i + 6]) + 1) >> 1;
91
92         dstU[i]= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
93         dstV[i]= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
94     }
95 }
96
97 #define rgb64funcs(pattern, BE_LE, origin) \
98 static void pattern ## 64 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, const uint8_t *unused1,\
99                                     int width, uint32_t *rgb2yuv) \
100 { \
101     const uint16_t *src = (const uint16_t *) _src; \
102     uint16_t *dst = (uint16_t *) _dst; \
103     rgb64ToY_c_template(dst, src, width, origin, rgb2yuv); \
104 } \
105  \
106 static void pattern ## 64 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
107                                     const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
108                                     int width, uint32_t *rgb2yuv) \
109 { \
110     const uint16_t *src1 = (const uint16_t *) _src1, \
111                    *src2 = (const uint16_t *) _src2; \
112     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
113     rgb64ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
114 } \
115  \
116 static void pattern ## 64 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
117                                     const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
118                                     int width, uint32_t *rgb2yuv) \
119 { \
120     const uint16_t *src1 = (const uint16_t *) _src1, \
121                    *src2 = (const uint16_t *) _src2; \
122     uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
123     rgb64ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
124 }
125
126 rgb64funcs(rgb, LE, AV_PIX_FMT_RGBA64LE)
127 rgb64funcs(rgb, BE, AV_PIX_FMT_RGBA64BE)
128
129 static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
130                                                  const uint16_t *src, int width,
131                                                  enum AVPixelFormat origin,
132                                                  int32_t *rgb2yuv)
133 {
134     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
135     int i;
136     for (i = 0; i < width; i++) {
137         unsigned int r_b = input_pixel(&src[i * 3 + 0]);
138         unsigned int g   = input_pixel(&src[i * 3 + 1]);
139         unsigned int b_r = input_pixel(&src[i * 3 + 2]);
140
141         dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
142     }
143 }
144
145 static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
146                                                   uint16_t *dstV,
147                                                   const uint16_t *src1,
148                                                   const uint16_t *src2,
149                                                   int width,
150                                                   enum AVPixelFormat origin,
151                                                   int32_t *rgb2yuv)
152 {
153     int i;
154     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
155     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
156     av_assert1(src1 == src2);
157     for (i = 0; i < width; i++) {
158         int r_b = input_pixel(&src1[i * 3 + 0]);
159         int g   = input_pixel(&src1[i * 3 + 1]);
160         int b_r = input_pixel(&src1[i * 3 + 2]);
161
162         dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
163         dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
164     }
165 }
166
167 static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
168                                                        uint16_t *dstV,
169                                                        const uint16_t *src1,
170                                                        const uint16_t *src2,
171                                                        int width,
172                                                        enum AVPixelFormat origin,
173                                                        int32_t *rgb2yuv)
174 {
175     int i;
176     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
177     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
178     av_assert1(src1 == src2);
179     for (i = 0; i < width; i++) {
180         int r_b = (input_pixel(&src1[6 * i + 0]) +
181                    input_pixel(&src1[6 * i + 3]) + 1) >> 1;
182         int g   = (input_pixel(&src1[6 * i + 1]) +
183                    input_pixel(&src1[6 * i + 4]) + 1) >> 1;
184         int b_r = (input_pixel(&src1[6 * i + 2]) +
185                    input_pixel(&src1[6 * i + 5]) + 1) >> 1;
186
187         dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
188         dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
189     }
190 }
191
192 #undef r
193 #undef b
194 #undef input_pixel
195
196 #define rgb48funcs(pattern, BE_LE, origin)                              \
197 static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst,              \
198                                             const uint8_t *_src,        \
199                                             const uint8_t *unused0, const uint8_t *unused1,\
200                                             int width,                  \
201                                             uint32_t *rgb2yuv)          \
202 {                                                                       \
203     const uint16_t *src = (const uint16_t *)_src;                       \
204     uint16_t *dst       = (uint16_t *)_dst;                             \
205     rgb48ToY_c_template(dst, src, width, origin, rgb2yuv);              \
206 }                                                                       \
207                                                                         \
208 static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU,            \
209                                              uint8_t *_dstV,            \
210                                              const uint8_t *unused0,    \
211                                              const uint8_t *_src1,      \
212                                              const uint8_t *_src2,      \
213                                              int width,                 \
214                                              uint32_t *rgb2yuv)         \
215 {                                                                       \
216     const uint16_t *src1 = (const uint16_t *)_src1,                     \
217                    *src2 = (const uint16_t *)_src2;                     \
218     uint16_t *dstU = (uint16_t *)_dstU,                                 \
219              *dstV = (uint16_t *)_dstV;                                 \
220     rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);        \
221 }                                                                       \
222                                                                         \
223 static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU,       \
224                                                   uint8_t *_dstV,       \
225                                                   const uint8_t *unused0,    \
226                                                   const uint8_t *_src1, \
227                                                   const uint8_t *_src2, \
228                                                   int width,            \
229                                                   uint32_t *rgb2yuv)    \
230 {                                                                       \
231     const uint16_t *src1 = (const uint16_t *)_src1,                     \
232                    *src2 = (const uint16_t *)_src2;                     \
233     uint16_t *dstU = (uint16_t *)_dstU,                                 \
234              *dstV = (uint16_t *)_dstV;                                 \
235     rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv);   \
236 }
237
238 rgb48funcs(rgb, LE, AV_PIX_FMT_RGB48LE)
239 rgb48funcs(rgb, BE, AV_PIX_FMT_RGB48BE)
240 rgb48funcs(bgr, LE, AV_PIX_FMT_BGR48LE)
241 rgb48funcs(bgr, BE, AV_PIX_FMT_BGR48BE)
242
243 #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA ||                      \
244                          origin == AV_PIX_FMT_BGRA ||                      \
245                          origin == AV_PIX_FMT_ARGB ||                      \
246                          origin == AV_PIX_FMT_ABGR)                        \
247                         ? AV_RN32A(&src[(i) * 4])                       \
248                         : (isBE(origin) ? AV_RB16(&src[(i) * 2])        \
249                                         : AV_RL16(&src[(i) * 2])))
250
251 static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
252                                                     const uint8_t *src,
253                                                     int width,
254                                                     enum AVPixelFormat origin,
255                                                     int shr, int shg,
256                                                     int shb, int shp,
257                                                     int maskr, int maskg,
258                                                     int maskb, int rsh,
259                                                     int gsh, int bsh, int S,
260                                                     int32_t *rgb2yuv)
261 {
262     const int ry       = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
263     const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
264     int i;
265
266     for (i = 0; i < width; i++) {
267         int px = input_pixel(i) >> shp;
268         int b  = (px & maskb) >> shb;
269         int g  = (px & maskg) >> shg;
270         int r  = (px & maskr) >> shr;
271
272         dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
273     }
274 }
275
276 static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
277                                                      int16_t *dstV,
278                                                      const uint8_t *src,
279                                                      int width,
280                                                      enum AVPixelFormat origin,
281                                                      int shr, int shg,
282                                                      int shb, int shp,
283                                                      int maskr, int maskg,
284                                                      int maskb, int rsh,
285                                                      int gsh, int bsh, int S,
286                                                      int32_t *rgb2yuv)
287 {
288     const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
289               rv       = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh;
290     const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
291     int i;
292
293     for (i = 0; i < width; i++) {
294         int px = input_pixel(i) >> shp;
295         int b  = (px & maskb)   >> shb;
296         int g  = (px & maskg)   >> shg;
297         int r  = (px & maskr)   >> shr;
298
299         dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
300         dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
301     }
302 }
303
304 static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
305                                                           int16_t *dstV,
306                                                           const uint8_t *src,
307                                                           int width,
308                                                           enum AVPixelFormat origin,
309                                                           int shr, int shg,
310                                                           int shb, int shp,
311                                                           int maskr, int maskg,
312                                                           int maskb, int rsh,
313                                                           int gsh, int bsh, int S,
314                                                           int32_t *rgb2yuv)
315 {
316     const int ru       = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
317               rv       = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh,
318               maskgx   = ~(maskr | maskb);
319     const unsigned rnd = (256U<<(S)) + (1<<(S-6));
320     int i;
321
322     maskr |= maskr << 1;
323     maskb |= maskb << 1;
324     maskg |= maskg << 1;
325     for (i = 0; i < width; i++) {
326         int px0 = input_pixel(2 * i + 0) >> shp;
327         int px1 = input_pixel(2 * i + 1) >> shp;
328         int b, r, g = (px0 & maskgx) + (px1 & maskgx);
329         int rb = px0 + px1 - g;
330
331         b = (rb & maskb) >> shb;
332         if (shp ||
333             origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
334             origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
335             g >>= shg;
336         } else {
337             g = (g & maskg) >> shg;
338         }
339         r = (rb & maskr) >> shr;
340
341         dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
342         dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
343     }
344 }
345
346 #undef input_pixel
347
348 #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr,          \
349                          maskg, maskb, rsh, gsh, bsh, S)                \
350 static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,            \
351                           int width, uint32_t *tab)                     \
352 {                                                                       \
353     rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp,    \
354                            maskr, maskg, maskb, rsh, gsh, bsh, S, tab); \
355 }                                                                       \
356                                                                         \
357 static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV,                \
358                            const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy,    \
359                            int width, uint32_t *tab)                    \
360 {                                                                       \
361     rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt,                \
362                             shr, shg, shb, shp,                         \
363                             maskr, maskg, maskb, rsh, gsh, bsh, S, tab);\
364 }                                                                       \
365                                                                         \
366 static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV,           \
367                                 const uint8_t *unused0, const uint8_t *src,                     \
368                                 const uint8_t *dummy,                   \
369                                 int width, uint32_t *tab)               \
370 {                                                                       \
371     rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt,           \
372                                  shr, shg, shb, shp,                    \
373                                  maskr, maskg, maskb,                   \
374                                  rsh, gsh, bsh, S, tab);                \
375 }
376
377 rgb16_32_wrapper(AV_PIX_FMT_BGR32,    bgr32,  16, 0,  0, 0, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
378 rgb16_32_wrapper(AV_PIX_FMT_BGR32_1,  bgr321, 16, 0,  0, 8, 0xFF0000, 0xFF00,   0x00FF,  8, 0,  8, RGB2YUV_SHIFT + 8)
379 rgb16_32_wrapper(AV_PIX_FMT_RGB32,    rgb32,   0, 0, 16, 0,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
380 rgb16_32_wrapper(AV_PIX_FMT_RGB32_1,  rgb321,  0, 0, 16, 8,   0x00FF, 0xFF00, 0xFF0000,  8, 0,  8, RGB2YUV_SHIFT + 8)
381 rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
382 rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
383 rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
384 rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
385 rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
386 rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
387 rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0,  0, 0,   0x001F, 0x07E0,   0xF800, 11, 5,  0, RGB2YUV_SHIFT + 8)
388 rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0,  0, 0,   0x001F, 0x03E0,   0x7C00, 10, 5,  0, RGB2YUV_SHIFT + 7)
389 rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0,  0, 0,   0x000F, 0x00F0,   0x0F00,  8, 4,  0, RGB2YUV_SHIFT + 4)
390 rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0,  0, 0,   0xF800, 0x07E0,   0x001F,  0, 5, 11, RGB2YUV_SHIFT + 8)
391 rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0,  0, 0,   0x7C00, 0x03E0,   0x001F,  0, 5, 10, RGB2YUV_SHIFT + 7)
392 rgb16_32_wrapper(AV_PIX_FMT_RGB444BE, rgb12be, 0, 0,  0, 0,   0x0F00, 0x00F0,   0x000F,  0, 4,  8, RGB2YUV_SHIFT + 4)
393
394 static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
395                          const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
396                          int width, uint32_t *rgb2yuv)
397 {
398     uint16_t *dstU = (uint16_t *)_dstU;
399     uint16_t *dstV = (uint16_t *)_dstV;
400     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
401     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
402
403     int i;
404     for (i = 0; i < width; i++) {
405         unsigned int g   = gsrc[2*i] + gsrc[2*i+1];
406         unsigned int b   = bsrc[2*i] + bsrc[2*i+1];
407         unsigned int r   = rsrc[2*i] + rsrc[2*i+1];
408
409         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
410         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
411     }
412 }
413
414 static void rgba64ToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
415                         const uint8_t *unused2, int width, uint32_t *unused)
416 {
417     int16_t *dst = (int16_t *)_dst;
418     const uint16_t *src = (const uint16_t *)_src;
419     int i;
420     for (i = 0; i < width; i++)
421         dst[i] = src[4 * i + 3];
422 }
423
424 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
425 {
426     int16_t *dst = (int16_t *)_dst;
427     int i;
428     for (i=0; i<width; i++) {
429         dst[i]= src[4*i]<<6;
430     }
431 }
432
433 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
434 {
435     int16_t *dst = (int16_t *)_dst;
436     int i;
437     for (i=0; i<width; i++) {
438         dst[i]= src[4*i+3]<<6;
439     }
440 }
441
442 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
443 {
444     int16_t *dst = (int16_t *)_dst;
445     int i;
446     for (i=0; i<width; i++) {
447         int d= src[i];
448
449         dst[i]= (pal[d] >> 24)<<6;
450     }
451 }
452
453 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
454 {
455     int16_t *dst = (int16_t *)_dst;
456     int i;
457     for (i = 0; i < width; i++) {
458         int d = src[i];
459
460         dst[i] = (pal[d] & 0xFF)<<6;
461     }
462 }
463
464 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
465                            const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
466                       int width, uint32_t *pal)
467 {
468     uint16_t *dstU = (uint16_t *)_dstU;
469     int16_t *dstV = (int16_t *)_dstV;
470     int i;
471     av_assert1(src1 == src2);
472     for (i = 0; i < width; i++) {
473         int p = pal[src1[i]];
474
475         dstU[i] = (uint8_t)(p>> 8)<<6;
476         dstV[i] = (uint8_t)(p>>16)<<6;
477     }
478 }
479
480 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
481 {
482     int16_t *dst = (int16_t *)_dst;
483     int i, j;
484     width = (width + 7) >> 3;
485     for (i = 0; i < width; i++) {
486         int d = ~src[i];
487         for (j = 0; j < 8; j++)
488             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
489     }
490     if(width&7){
491         int d= ~src[i];
492         for (j = 0; j < (width&7); j++)
493             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
494     }
495 }
496
497 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
498 {
499     int16_t *dst = (int16_t *)_dst;
500     int i, j;
501     width = (width + 7) >> 3;
502     for (i = 0; i < width; i++) {
503         int d = src[i];
504         for (j = 0; j < 8; j++)
505             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
506     }
507     if(width&7){
508         int d = src[i];
509         for (j = 0; j < (width&7); j++)
510             dst[8*i+j] = ((d>>(7-j))&1) * 16383;
511     }
512 }
513
514 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
515                       uint32_t *unused)
516 {
517     int i;
518     for (i = 0; i < width; i++)
519         dst[i] = src[2 * i];
520 }
521
522 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
523                        const uint8_t *src2, int width, uint32_t *unused)
524 {
525     int i;
526     for (i = 0; i < width; i++) {
527         dstU[i] = src1[4 * i + 1];
528         dstV[i] = src1[4 * i + 3];
529     }
530     av_assert1(src1 == src2);
531 }
532
533 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2,  int width,
534                        uint32_t *unused)
535 {
536     int i;
537     const uint16_t *src = (const uint16_t *)_src;
538     uint16_t *dst       = (uint16_t *)_dst;
539     for (i = 0; i < width; i++)
540         dst[i] = av_bswap16(src[i]);
541 }
542
543 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
544                         const uint8_t *_src2, int width, uint32_t *unused)
545 {
546     int i;
547     const uint16_t *src1 = (const uint16_t *)_src1,
548     *src2                = (const uint16_t *)_src2;
549     uint16_t *dstU       = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
550     for (i = 0; i < width; i++) {
551         dstU[i] = av_bswap16(src1[i]);
552         dstV[i] = av_bswap16(src2[i]);
553     }
554 }
555
556 /* This is almost identical to the previous, end exists only because
557  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
558 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
559                       uint32_t *unused)
560 {
561     int i;
562     for (i = 0; i < width; i++)
563         dst[i] = src[2 * i + 1];
564 }
565
566 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
567                        const uint8_t *src2, int width, uint32_t *unused)
568 {
569     int i;
570     for (i = 0; i < width; i++) {
571         dstU[i] = src1[4 * i + 0];
572         dstV[i] = src1[4 * i + 2];
573     }
574     av_assert1(src1 == src2);
575 }
576
577 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
578                                         const uint8_t *src, int width)
579 {
580     int i;
581     for (i = 0; i < width; i++) {
582         dst1[i] = src[2 * i + 0];
583         dst2[i] = src[2 * i + 1];
584     }
585 }
586
587 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
588                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
589                        int width, uint32_t *unused)
590 {
591     nvXXtoUV_c(dstU, dstV, src1, width);
592 }
593
594 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
595                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
596                        int width, uint32_t *unused)
597 {
598     nvXXtoUV_c(dstV, dstU, src1, width);
599 }
600
601 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
602
603 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
604                        int width, uint32_t *rgb2yuv)
605 {
606     int16_t *dst = (int16_t *)_dst;
607     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
608     int i;
609     for (i = 0; i < width; i++) {
610         int b = src[i * 3 + 0];
611         int g = src[i * 3 + 1];
612         int r = src[i * 3 + 2];
613
614         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
615     }
616 }
617
618 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
619                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
620 {
621     int16_t *dstU = (int16_t *)_dstU;
622     int16_t *dstV = (int16_t *)_dstV;
623     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
624     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
625     int i;
626     for (i = 0; i < width; i++) {
627         int b = src1[3 * i + 0];
628         int g = src1[3 * i + 1];
629         int r = src1[3 * i + 2];
630
631         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
632         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
633     }
634     av_assert1(src1 == src2);
635 }
636
637 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
638                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
639 {
640     int16_t *dstU = (int16_t *)_dstU;
641     int16_t *dstV = (int16_t *)_dstV;
642     int i;
643     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
644     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
645     for (i = 0; i < width; i++) {
646         int b = src1[6 * i + 0] + src1[6 * i + 3];
647         int g = src1[6 * i + 1] + src1[6 * i + 4];
648         int r = src1[6 * i + 2] + src1[6 * i + 5];
649
650         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
651         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
652     }
653     av_assert1(src1 == src2);
654 }
655
656 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
657                        uint32_t *rgb2yuv)
658 {
659     int16_t *dst = (int16_t *)_dst;
660     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
661     int i;
662     for (i = 0; i < width; i++) {
663         int r = src[i * 3 + 0];
664         int g = src[i * 3 + 1];
665         int b = src[i * 3 + 2];
666
667         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
668     }
669 }
670
671 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
672                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
673 {
674     int16_t *dstU = (int16_t *)_dstU;
675     int16_t *dstV = (int16_t *)_dstV;
676     int i;
677     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
678     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
679     av_assert1(src1 == src2);
680     for (i = 0; i < width; i++) {
681         int r = src1[3 * i + 0];
682         int g = src1[3 * i + 1];
683         int b = src1[3 * i + 2];
684
685         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
686         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
687     }
688 }
689
690 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
691                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
692 {
693     int16_t *dstU = (int16_t *)_dstU;
694     int16_t *dstV = (int16_t *)_dstV;
695     int i;
696     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
697     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
698     av_assert1(src1 == src2);
699     for (i = 0; i < width; i++) {
700         int r = src1[6 * i + 0] + src1[6 * i + 3];
701         int g = src1[6 * i + 1] + src1[6 * i + 4];
702         int b = src1[6 * i + 2] + src1[6 * i + 5];
703
704         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
705         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
706     }
707 }
708
709 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
710 {
711     uint16_t *dst = (uint16_t *)_dst;
712     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
713     int i;
714     for (i = 0; i < width; i++) {
715         int g = src[0][i];
716         int b = src[1][i];
717         int r = src[2][i];
718
719         dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
720     }
721 }
722
723 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
724 {
725     uint16_t *dstU = (uint16_t *)_dstU;
726     uint16_t *dstV = (uint16_t *)_dstV;
727     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
728     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
729     int i;
730     for (i = 0; i < width; i++) {
731         int g = src[0][i];
732         int b = src[1][i];
733         int r = src[2][i];
734
735         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
736         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
737     }
738 }
739
740 #define rdpx(src) \
741     is_be ? AV_RB16(src) : AV_RL16(src)
742 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
743                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
744 {
745     int i;
746     const uint16_t **src = (const uint16_t **)_src;
747     uint16_t *dst        = (uint16_t *)_dst;
748     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
749     for (i = 0; i < width; i++) {
750         int g = rdpx(src[0] + i);
751         int b = rdpx(src[1] + i);
752         int r = rdpx(src[2] + i);
753
754         dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + bpc - 14));
755     }
756 }
757
758 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
759                                                 const uint8_t *_src[4], int width,
760                                                 int bpc, int is_be, int32_t *rgb2yuv)
761 {
762     int i;
763     const uint16_t **src = (const uint16_t **)_src;
764     uint16_t *dstU       = (uint16_t *)_dstU;
765     uint16_t *dstV       = (uint16_t *)_dstV;
766     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
767     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
768     for (i = 0; i < width; i++) {
769         int g = rdpx(src[0] + i);
770         int b = rdpx(src[1] + i);
771         int r = rdpx(src[2] + i);
772
773         dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + bpc - 14);
774         dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + bpc - 14);
775     }
776 }
777 #undef rdpx
778
779 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian)                                    \
780 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4],              \
781                                                   int w, int32_t *rgb2yuv)                          \
782 {                                                                                                   \
783     planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
784 }                                                                                                   \
785 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
786                                                    const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
787 {                                                                                                   \
788     planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
789 }                                                                                                   \
790
791 #define rgb9plus_planar_funcs(nbits)            \
792     rgb9plus_planar_funcs_endian(nbits, le, 0)  \
793     rgb9plus_planar_funcs_endian(nbits, be, 1)
794
795 rgb9plus_planar_funcs(9)
796 rgb9plus_planar_funcs(10)
797 rgb9plus_planar_funcs(12)
798 rgb9plus_planar_funcs(14)
799 rgb9plus_planar_funcs(16)
800
801 av_cold void ff_sws_init_input_funcs(SwsContext *c)
802 {
803     enum AVPixelFormat srcFormat = c->srcFormat;
804
805     c->chrToYV12 = NULL;
806     switch (srcFormat) {
807     case AV_PIX_FMT_YUYV422:
808         c->chrToYV12 = yuy2ToUV_c;
809         break;
810     case AV_PIX_FMT_UYVY422:
811         c->chrToYV12 = uyvyToUV_c;
812         break;
813     case AV_PIX_FMT_NV12:
814         c->chrToYV12 = nv12ToUV_c;
815         break;
816     case AV_PIX_FMT_NV21:
817         c->chrToYV12 = nv21ToUV_c;
818         break;
819     case AV_PIX_FMT_RGB8:
820     case AV_PIX_FMT_BGR8:
821     case AV_PIX_FMT_PAL8:
822     case AV_PIX_FMT_BGR4_BYTE:
823     case AV_PIX_FMT_RGB4_BYTE:
824         c->chrToYV12 = palToUV_c;
825         break;
826     case AV_PIX_FMT_GBRP9LE:
827         c->readChrPlanar = planar_rgb9le_to_uv;
828         break;
829     case AV_PIX_FMT_GBRP10LE:
830         c->readChrPlanar = planar_rgb10le_to_uv;
831         break;
832     case AV_PIX_FMT_GBRP12LE:
833         c->readChrPlanar = planar_rgb12le_to_uv;
834         break;
835     case AV_PIX_FMT_GBRP14LE:
836         c->readChrPlanar = planar_rgb14le_to_uv;
837         break;
838     case AV_PIX_FMT_GBRP16LE:
839         c->readChrPlanar = planar_rgb16le_to_uv;
840         break;
841     case AV_PIX_FMT_GBRP9BE:
842         c->readChrPlanar = planar_rgb9be_to_uv;
843         break;
844     case AV_PIX_FMT_GBRP10BE:
845         c->readChrPlanar = planar_rgb10be_to_uv;
846         break;
847     case AV_PIX_FMT_GBRP12BE:
848         c->readChrPlanar = planar_rgb12be_to_uv;
849         break;
850     case AV_PIX_FMT_GBRP14BE:
851         c->readChrPlanar = planar_rgb14be_to_uv;
852         break;
853     case AV_PIX_FMT_GBRP16BE:
854         c->readChrPlanar = planar_rgb16be_to_uv;
855         break;
856     case AV_PIX_FMT_GBRP:
857         c->readChrPlanar = planar_rgb_to_uv;
858         break;
859 #if HAVE_BIGENDIAN
860     case AV_PIX_FMT_YUV444P9LE:
861     case AV_PIX_FMT_YUV422P9LE:
862     case AV_PIX_FMT_YUV420P9LE:
863     case AV_PIX_FMT_YUV422P10LE:
864     case AV_PIX_FMT_YUV444P10LE:
865     case AV_PIX_FMT_YUV420P10LE:
866     case AV_PIX_FMT_YUV422P12LE:
867     case AV_PIX_FMT_YUV444P12LE:
868     case AV_PIX_FMT_YUV420P12LE:
869     case AV_PIX_FMT_YUV422P14LE:
870     case AV_PIX_FMT_YUV444P14LE:
871     case AV_PIX_FMT_YUV420P14LE:
872     case AV_PIX_FMT_YUV420P16LE:
873     case AV_PIX_FMT_YUV422P16LE:
874     case AV_PIX_FMT_YUV444P16LE:
875
876     case AV_PIX_FMT_YUVA444P9LE:
877     case AV_PIX_FMT_YUVA422P9LE:
878     case AV_PIX_FMT_YUVA420P9LE:
879     case AV_PIX_FMT_YUVA444P10LE:
880     case AV_PIX_FMT_YUVA422P10LE:
881     case AV_PIX_FMT_YUVA420P10LE:
882     case AV_PIX_FMT_YUVA420P16LE:
883     case AV_PIX_FMT_YUVA422P16LE:
884     case AV_PIX_FMT_YUVA444P16LE:
885         c->chrToYV12 = bswap16UV_c;
886         break;
887 #else
888     case AV_PIX_FMT_YUV444P9BE:
889     case AV_PIX_FMT_YUV422P9BE:
890     case AV_PIX_FMT_YUV420P9BE:
891     case AV_PIX_FMT_YUV444P10BE:
892     case AV_PIX_FMT_YUV422P10BE:
893     case AV_PIX_FMT_YUV420P10BE:
894     case AV_PIX_FMT_YUV444P12BE:
895     case AV_PIX_FMT_YUV422P12BE:
896     case AV_PIX_FMT_YUV420P12BE:
897     case AV_PIX_FMT_YUV444P14BE:
898     case AV_PIX_FMT_YUV422P14BE:
899     case AV_PIX_FMT_YUV420P14BE:
900     case AV_PIX_FMT_YUV420P16BE:
901     case AV_PIX_FMT_YUV422P16BE:
902     case AV_PIX_FMT_YUV444P16BE:
903
904     case AV_PIX_FMT_YUVA444P9BE:
905     case AV_PIX_FMT_YUVA422P9BE:
906     case AV_PIX_FMT_YUVA420P9BE:
907     case AV_PIX_FMT_YUVA444P10BE:
908     case AV_PIX_FMT_YUVA422P10BE:
909     case AV_PIX_FMT_YUVA420P10BE:
910     case AV_PIX_FMT_YUVA420P16BE:
911     case AV_PIX_FMT_YUVA422P16BE:
912     case AV_PIX_FMT_YUVA444P16BE:
913         c->chrToYV12 = bswap16UV_c;
914         break;
915 #endif
916     }
917     if (c->chrSrcHSubSample) {
918         switch (srcFormat) {
919         case AV_PIX_FMT_RGBA64BE:
920             c->chrToYV12 = rgb64BEToUV_half_c;
921             break;
922         case AV_PIX_FMT_RGBA64LE:
923             c->chrToYV12 = rgb64LEToUV_half_c;
924             break;
925         case AV_PIX_FMT_RGB48BE:
926             c->chrToYV12 = rgb48BEToUV_half_c;
927             break;
928         case AV_PIX_FMT_RGB48LE:
929             c->chrToYV12 = rgb48LEToUV_half_c;
930             break;
931         case AV_PIX_FMT_BGR48BE:
932             c->chrToYV12 = bgr48BEToUV_half_c;
933             break;
934         case AV_PIX_FMT_BGR48LE:
935             c->chrToYV12 = bgr48LEToUV_half_c;
936             break;
937         case AV_PIX_FMT_RGB32:
938             c->chrToYV12 = bgr32ToUV_half_c;
939             break;
940         case AV_PIX_FMT_RGB32_1:
941             c->chrToYV12 = bgr321ToUV_half_c;
942             break;
943         case AV_PIX_FMT_BGR24:
944             c->chrToYV12 = bgr24ToUV_half_c;
945             break;
946         case AV_PIX_FMT_BGR565LE:
947             c->chrToYV12 = bgr16leToUV_half_c;
948             break;
949         case AV_PIX_FMT_BGR565BE:
950             c->chrToYV12 = bgr16beToUV_half_c;
951             break;
952         case AV_PIX_FMT_BGR555LE:
953             c->chrToYV12 = bgr15leToUV_half_c;
954             break;
955         case AV_PIX_FMT_BGR555BE:
956             c->chrToYV12 = bgr15beToUV_half_c;
957             break;
958         case AV_PIX_FMT_GBR24P  :
959             c->chrToYV12 = gbr24pToUV_half_c;
960             break;
961         case AV_PIX_FMT_BGR444LE:
962             c->chrToYV12 = bgr12leToUV_half_c;
963             break;
964         case AV_PIX_FMT_BGR444BE:
965             c->chrToYV12 = bgr12beToUV_half_c;
966             break;
967         case AV_PIX_FMT_BGR32:
968             c->chrToYV12 = rgb32ToUV_half_c;
969             break;
970         case AV_PIX_FMT_BGR32_1:
971             c->chrToYV12 = rgb321ToUV_half_c;
972             break;
973         case AV_PIX_FMT_RGB24:
974             c->chrToYV12 = rgb24ToUV_half_c;
975             break;
976         case AV_PIX_FMT_RGB565LE:
977             c->chrToYV12 = rgb16leToUV_half_c;
978             break;
979         case AV_PIX_FMT_RGB565BE:
980             c->chrToYV12 = rgb16beToUV_half_c;
981             break;
982         case AV_PIX_FMT_RGB555LE:
983             c->chrToYV12 = rgb15leToUV_half_c;
984             break;
985         case AV_PIX_FMT_RGB555BE:
986             c->chrToYV12 = rgb15beToUV_half_c;
987             break;
988         case AV_PIX_FMT_RGB444LE:
989             c->chrToYV12 = rgb12leToUV_half_c;
990             break;
991         case AV_PIX_FMT_RGB444BE:
992             c->chrToYV12 = rgb12beToUV_half_c;
993             break;
994         }
995     } else {
996         switch (srcFormat) {
997         case AV_PIX_FMT_RGBA64BE:
998             c->chrToYV12 = rgb64BEToUV_c;
999             break;
1000         case AV_PIX_FMT_RGBA64LE:
1001             c->chrToYV12 = rgb64LEToUV_c;
1002             break;
1003         case AV_PIX_FMT_RGB48BE:
1004             c->chrToYV12 = rgb48BEToUV_c;
1005             break;
1006         case AV_PIX_FMT_RGB48LE:
1007             c->chrToYV12 = rgb48LEToUV_c;
1008             break;
1009         case AV_PIX_FMT_BGR48BE:
1010             c->chrToYV12 = bgr48BEToUV_c;
1011             break;
1012         case AV_PIX_FMT_BGR48LE:
1013             c->chrToYV12 = bgr48LEToUV_c;
1014             break;
1015         case AV_PIX_FMT_RGB32:
1016             c->chrToYV12 = bgr32ToUV_c;
1017             break;
1018         case AV_PIX_FMT_RGB32_1:
1019             c->chrToYV12 = bgr321ToUV_c;
1020             break;
1021         case AV_PIX_FMT_BGR24:
1022             c->chrToYV12 = bgr24ToUV_c;
1023             break;
1024         case AV_PIX_FMT_BGR565LE:
1025             c->chrToYV12 = bgr16leToUV_c;
1026             break;
1027         case AV_PIX_FMT_BGR565BE:
1028             c->chrToYV12 = bgr16beToUV_c;
1029             break;
1030         case AV_PIX_FMT_BGR555LE:
1031             c->chrToYV12 = bgr15leToUV_c;
1032             break;
1033         case AV_PIX_FMT_BGR555BE:
1034             c->chrToYV12 = bgr15beToUV_c;
1035             break;
1036         case AV_PIX_FMT_BGR444LE:
1037             c->chrToYV12 = bgr12leToUV_c;
1038             break;
1039         case AV_PIX_FMT_BGR444BE:
1040             c->chrToYV12 = bgr12beToUV_c;
1041             break;
1042         case AV_PIX_FMT_BGR32:
1043             c->chrToYV12 = rgb32ToUV_c;
1044             break;
1045         case AV_PIX_FMT_BGR32_1:
1046             c->chrToYV12 = rgb321ToUV_c;
1047             break;
1048         case AV_PIX_FMT_RGB24:
1049             c->chrToYV12 = rgb24ToUV_c;
1050             break;
1051         case AV_PIX_FMT_RGB565LE:
1052             c->chrToYV12 = rgb16leToUV_c;
1053             break;
1054         case AV_PIX_FMT_RGB565BE:
1055             c->chrToYV12 = rgb16beToUV_c;
1056             break;
1057         case AV_PIX_FMT_RGB555LE:
1058             c->chrToYV12 = rgb15leToUV_c;
1059             break;
1060         case AV_PIX_FMT_RGB555BE:
1061             c->chrToYV12 = rgb15beToUV_c;
1062             break;
1063         case AV_PIX_FMT_RGB444LE:
1064             c->chrToYV12 = rgb12leToUV_c;
1065             break;
1066         case AV_PIX_FMT_RGB444BE:
1067             c->chrToYV12 = rgb12beToUV_c;
1068             break;
1069         }
1070     }
1071
1072     c->lumToYV12 = NULL;
1073     c->alpToYV12 = NULL;
1074     switch (srcFormat) {
1075     case AV_PIX_FMT_GBRP9LE:
1076         c->readLumPlanar = planar_rgb9le_to_y;
1077         break;
1078     case AV_PIX_FMT_GBRP10LE:
1079         c->readLumPlanar = planar_rgb10le_to_y;
1080         break;
1081     case AV_PIX_FMT_GBRP12LE:
1082         c->readLumPlanar = planar_rgb12le_to_y;
1083         break;
1084     case AV_PIX_FMT_GBRP14LE:
1085         c->readLumPlanar = planar_rgb14le_to_y;
1086         break;
1087     case AV_PIX_FMT_GBRP16LE:
1088         c->readLumPlanar = planar_rgb16le_to_y;
1089         break;
1090     case AV_PIX_FMT_GBRP9BE:
1091         c->readLumPlanar = planar_rgb9be_to_y;
1092         break;
1093     case AV_PIX_FMT_GBRP10BE:
1094         c->readLumPlanar = planar_rgb10be_to_y;
1095         break;
1096     case AV_PIX_FMT_GBRP12BE:
1097         c->readLumPlanar = planar_rgb12be_to_y;
1098         break;
1099     case AV_PIX_FMT_GBRP14BE:
1100         c->readLumPlanar = planar_rgb14be_to_y;
1101         break;
1102     case AV_PIX_FMT_GBRP16BE:
1103         c->readLumPlanar = planar_rgb16be_to_y;
1104         break;
1105     case AV_PIX_FMT_GBRP:
1106         c->readLumPlanar = planar_rgb_to_y;
1107         break;
1108 #if HAVE_BIGENDIAN
1109     case AV_PIX_FMT_YUV444P9LE:
1110     case AV_PIX_FMT_YUV422P9LE:
1111     case AV_PIX_FMT_YUV420P9LE:
1112     case AV_PIX_FMT_YUV444P10LE:
1113     case AV_PIX_FMT_YUV422P10LE:
1114     case AV_PIX_FMT_YUV420P10LE:
1115     case AV_PIX_FMT_YUV444P12LE:
1116     case AV_PIX_FMT_YUV422P12LE:
1117     case AV_PIX_FMT_YUV420P12LE:
1118     case AV_PIX_FMT_YUV444P14LE:
1119     case AV_PIX_FMT_YUV422P14LE:
1120     case AV_PIX_FMT_YUV420P14LE:
1121     case AV_PIX_FMT_YUV420P16LE:
1122     case AV_PIX_FMT_YUV422P16LE:
1123     case AV_PIX_FMT_YUV444P16LE:
1124
1125     case AV_PIX_FMT_GRAY16LE:
1126         c->lumToYV12 = bswap16Y_c;
1127         break;
1128     case AV_PIX_FMT_YUVA444P9LE:
1129     case AV_PIX_FMT_YUVA422P9LE:
1130     case AV_PIX_FMT_YUVA420P9LE:
1131     case AV_PIX_FMT_YUVA444P10LE:
1132     case AV_PIX_FMT_YUVA422P10LE:
1133     case AV_PIX_FMT_YUVA420P10LE:
1134     case AV_PIX_FMT_YUVA420P16LE:
1135     case AV_PIX_FMT_YUVA422P16LE:
1136     case AV_PIX_FMT_YUVA444P16LE:
1137         c->lumToYV12 = bswap16Y_c;
1138         c->alpToYV12 = bswap16Y_c;
1139         break;
1140 #else
1141     case AV_PIX_FMT_YUV444P9BE:
1142     case AV_PIX_FMT_YUV422P9BE:
1143     case AV_PIX_FMT_YUV420P9BE:
1144     case AV_PIX_FMT_YUV444P10BE:
1145     case AV_PIX_FMT_YUV422P10BE:
1146     case AV_PIX_FMT_YUV420P10BE:
1147     case AV_PIX_FMT_YUV444P12BE:
1148     case AV_PIX_FMT_YUV422P12BE:
1149     case AV_PIX_FMT_YUV420P12BE:
1150     case AV_PIX_FMT_YUV444P14BE:
1151     case AV_PIX_FMT_YUV422P14BE:
1152     case AV_PIX_FMT_YUV420P14BE:
1153     case AV_PIX_FMT_YUV420P16BE:
1154     case AV_PIX_FMT_YUV422P16BE:
1155     case AV_PIX_FMT_YUV444P16BE:
1156
1157     case AV_PIX_FMT_GRAY16BE:
1158         c->lumToYV12 = bswap16Y_c;
1159         break;
1160     case AV_PIX_FMT_YUVA444P9BE:
1161     case AV_PIX_FMT_YUVA422P9BE:
1162     case AV_PIX_FMT_YUVA420P9BE:
1163     case AV_PIX_FMT_YUVA444P10BE:
1164     case AV_PIX_FMT_YUVA422P10BE:
1165     case AV_PIX_FMT_YUVA420P10BE:
1166     case AV_PIX_FMT_YUVA420P16BE:
1167     case AV_PIX_FMT_YUVA422P16BE:
1168     case AV_PIX_FMT_YUVA444P16BE:
1169         c->lumToYV12 = bswap16Y_c;
1170         c->alpToYV12 = bswap16Y_c;
1171         break;
1172 #endif
1173     case AV_PIX_FMT_YUYV422:
1174     case AV_PIX_FMT_Y400A:
1175         c->lumToYV12 = yuy2ToY_c;
1176         break;
1177     case AV_PIX_FMT_UYVY422:
1178         c->lumToYV12 = uyvyToY_c;
1179         break;
1180     case AV_PIX_FMT_BGR24:
1181         c->lumToYV12 = bgr24ToY_c;
1182         break;
1183     case AV_PIX_FMT_BGR565LE:
1184         c->lumToYV12 = bgr16leToY_c;
1185         break;
1186     case AV_PIX_FMT_BGR565BE:
1187         c->lumToYV12 = bgr16beToY_c;
1188         break;
1189     case AV_PIX_FMT_BGR555LE:
1190         c->lumToYV12 = bgr15leToY_c;
1191         break;
1192     case AV_PIX_FMT_BGR555BE:
1193         c->lumToYV12 = bgr15beToY_c;
1194         break;
1195     case AV_PIX_FMT_BGR444LE:
1196         c->lumToYV12 = bgr12leToY_c;
1197         break;
1198     case AV_PIX_FMT_BGR444BE:
1199         c->lumToYV12 = bgr12beToY_c;
1200         break;
1201     case AV_PIX_FMT_RGB24:
1202         c->lumToYV12 = rgb24ToY_c;
1203         break;
1204     case AV_PIX_FMT_RGB565LE:
1205         c->lumToYV12 = rgb16leToY_c;
1206         break;
1207     case AV_PIX_FMT_RGB565BE:
1208         c->lumToYV12 = rgb16beToY_c;
1209         break;
1210     case AV_PIX_FMT_RGB555LE:
1211         c->lumToYV12 = rgb15leToY_c;
1212         break;
1213     case AV_PIX_FMT_RGB555BE:
1214         c->lumToYV12 = rgb15beToY_c;
1215         break;
1216     case AV_PIX_FMT_RGB444LE:
1217         c->lumToYV12 = rgb12leToY_c;
1218         break;
1219     case AV_PIX_FMT_RGB444BE:
1220         c->lumToYV12 = rgb12beToY_c;
1221         break;
1222     case AV_PIX_FMT_RGB8:
1223     case AV_PIX_FMT_BGR8:
1224     case AV_PIX_FMT_PAL8:
1225     case AV_PIX_FMT_BGR4_BYTE:
1226     case AV_PIX_FMT_RGB4_BYTE:
1227         c->lumToYV12 = palToY_c;
1228         break;
1229     case AV_PIX_FMT_MONOBLACK:
1230         c->lumToYV12 = monoblack2Y_c;
1231         break;
1232     case AV_PIX_FMT_MONOWHITE:
1233         c->lumToYV12 = monowhite2Y_c;
1234         break;
1235     case AV_PIX_FMT_RGB32:
1236         c->lumToYV12 = bgr32ToY_c;
1237         break;
1238     case AV_PIX_FMT_RGB32_1:
1239         c->lumToYV12 = bgr321ToY_c;
1240         break;
1241     case AV_PIX_FMT_BGR32:
1242         c->lumToYV12 = rgb32ToY_c;
1243         break;
1244     case AV_PIX_FMT_BGR32_1:
1245         c->lumToYV12 = rgb321ToY_c;
1246         break;
1247     case AV_PIX_FMT_RGB48BE:
1248         c->lumToYV12 = rgb48BEToY_c;
1249         break;
1250     case AV_PIX_FMT_RGB48LE:
1251         c->lumToYV12 = rgb48LEToY_c;
1252         break;
1253     case AV_PIX_FMT_BGR48BE:
1254         c->lumToYV12 = bgr48BEToY_c;
1255         break;
1256     case AV_PIX_FMT_BGR48LE:
1257         c->lumToYV12 = bgr48LEToY_c;
1258         break;
1259     case AV_PIX_FMT_RGBA64BE:
1260         c->lumToYV12 = rgb64BEToY_c;
1261         break;
1262     case AV_PIX_FMT_RGBA64LE:
1263         c->lumToYV12 = rgb64LEToY_c;
1264         break;
1265     }
1266     if (c->alpPixBuf) {
1267         if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1268             if (HAVE_BIGENDIAN == !isBE(srcFormat))
1269                 c->alpToYV12 = bswap16Y_c;
1270         }
1271         switch (srcFormat) {
1272         case AV_PIX_FMT_RGBA64LE:
1273         case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64ToA_c; break;
1274         case AV_PIX_FMT_BGRA:
1275         case AV_PIX_FMT_RGBA:
1276             c->alpToYV12 = rgbaToA_c;
1277             break;
1278         case AV_PIX_FMT_ABGR:
1279         case AV_PIX_FMT_ARGB:
1280             c->alpToYV12 = abgrToA_c;
1281             break;
1282         case AV_PIX_FMT_Y400A:
1283             c->alpToYV12 = uyvyToY_c;
1284             break;
1285         case AV_PIX_FMT_PAL8 :
1286             c->alpToYV12 = palToA_c;
1287             break;
1288         }
1289     }
1290 }