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