swscale/yuv2rgb: Fix width % 4 != 0 with bgr4_byte/rgb4_byte
[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 rgba64ToA_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] = src[4 * i + 3];
423 }
424
425 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
426 {
427     int16_t *dst = (int16_t *)_dst;
428     int i;
429     for (i=0; i<width; i++) {
430         dst[i]= src[4*i]<<6;
431     }
432 }
433
434 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
435 {
436     int16_t *dst = (int16_t *)_dst;
437     int i;
438     for (i=0; i<width; i++) {
439         dst[i]= src[4*i+3]<<6;
440     }
441 }
442
443 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
444 {
445     int16_t *dst = (int16_t *)_dst;
446     int i;
447     for (i=0; i<width; i++) {
448         int d= src[i];
449
450         dst[i]= (pal[d] >> 24)<<6;
451     }
452 }
453
454 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
455 {
456     int16_t *dst = (int16_t *)_dst;
457     int i;
458     for (i = 0; i < width; i++) {
459         int d = src[i];
460
461         dst[i] = (pal[d] & 0xFF)<<6;
462     }
463 }
464
465 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
466                            const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
467                       int width, uint32_t *pal)
468 {
469     uint16_t *dstU = (uint16_t *)_dstU;
470     int16_t *dstV = (int16_t *)_dstV;
471     int i;
472     av_assert1(src1 == src2);
473     for (i = 0; i < width; i++) {
474         int p = pal[src1[i]];
475
476         dstU[i] = (uint8_t)(p>> 8)<<6;
477         dstV[i] = (uint8_t)(p>>16)<<6;
478     }
479 }
480
481 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
482 {
483     int16_t *dst = (int16_t *)_dst;
484     int i, j;
485     width = (width + 7) >> 3;
486     for (i = 0; i < width; i++) {
487         int d = ~src[i];
488         for (j = 0; j < 8; j++)
489             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
490     }
491     if(width&7){
492         int d= ~src[i];
493         for (j = 0; j < (width&7); j++)
494             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
495     }
496 }
497
498 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width, uint32_t *unused)
499 {
500     int16_t *dst = (int16_t *)_dst;
501     int i, j;
502     width = (width + 7) >> 3;
503     for (i = 0; i < width; i++) {
504         int d = src[i];
505         for (j = 0; j < 8; j++)
506             dst[8*i+j]= ((d>>(7-j))&1) * 16383;
507     }
508     if(width&7){
509         int d = src[i];
510         for (j = 0; j < (width&7); j++)
511             dst[8*i+j] = ((d>>(7-j))&1) * 16383;
512     }
513 }
514
515 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,  int width,
516                       uint32_t *unused)
517 {
518     int i;
519     for (i = 0; i < width; i++)
520         dst[i] = src[2 * i];
521 }
522
523 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
524                        const uint8_t *src2, int width, uint32_t *unused)
525 {
526     int i;
527     for (i = 0; i < width; i++) {
528         dstU[i] = src1[4 * i + 1];
529         dstV[i] = src1[4 * i + 3];
530     }
531     av_assert1(src1 == src2);
532 }
533
534 static void yvy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
535                        const uint8_t *src2, int width, uint32_t *unused)
536 {
537     int i;
538     for (i = 0; i < width; i++) {
539         dstV[i] = src1[4 * i + 1];
540         dstU[i] = src1[4 * i + 3];
541     }
542     av_assert1(src1 == src2);
543 }
544
545 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
546                        uint32_t *unused)
547 {
548     int i;
549     const uint16_t *src = (const uint16_t *)_src;
550     uint16_t *dst       = (uint16_t *)_dst;
551     for (i = 0; i < width; i++)
552         dst[i] = av_bswap16(src[i]);
553 }
554
555 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
556                         const uint8_t *_src2, int width, uint32_t *unused)
557 {
558     int i;
559     const uint16_t *src1 = (const uint16_t *)_src1,
560     *src2                = (const uint16_t *)_src2;
561     uint16_t *dstU       = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
562     for (i = 0; i < width; i++) {
563         dstU[i] = av_bswap16(src1[i]);
564         dstV[i] = av_bswap16(src2[i]);
565     }
566 }
567
568 static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
569                                uint32_t *unused)
570 {
571     int i;
572     for (i = 0; i < width; i++)
573         AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
574 }
575
576 static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
577                                 uint32_t *unused)
578 {
579     int i;
580     for (i = 0; i < width; i++)
581         AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
582 }
583
584 static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
585                                uint32_t *unused)
586 {
587     int i;
588     for (i = 0; i < width; i++)
589         AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
590 }
591
592 static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
593                                 uint32_t *unused)
594 {
595     int i;
596     for (i = 0; i < width; i++)
597         AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
598 }
599
600 /* This is almost identical to the previous, end exists only because
601  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
602 static void uyvyToY_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         dst[i] = src[2 * i + 1];
608 }
609
610 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
611                        const uint8_t *src2, int width, uint32_t *unused)
612 {
613     int i;
614     for (i = 0; i < width; i++) {
615         dstU[i] = src1[4 * i + 0];
616         dstV[i] = src1[4 * i + 2];
617     }
618     av_assert1(src1 == src2);
619 }
620
621 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
622                                         const uint8_t *src, int width)
623 {
624     int i;
625     for (i = 0; i < width; i++) {
626         dst1[i] = src[2 * i + 0];
627         dst2[i] = src[2 * i + 1];
628     }
629 }
630
631 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
632                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
633                        int width, uint32_t *unused)
634 {
635     nvXXtoUV_c(dstU, dstV, src1, width);
636 }
637
638 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
639                        const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
640                        int width, uint32_t *unused)
641 {
642     nvXXtoUV_c(dstV, dstU, src1, width);
643 }
644
645 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
646
647 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
648                        int width, uint32_t *rgb2yuv)
649 {
650     int16_t *dst = (int16_t *)_dst;
651     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
652     int i;
653     for (i = 0; i < width; i++) {
654         int b = src[i * 3 + 0];
655         int g = src[i * 3 + 1];
656         int r = src[i * 3 + 2];
657
658         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
659     }
660 }
661
662 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
663                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
664 {
665     int16_t *dstU = (int16_t *)_dstU;
666     int16_t *dstV = (int16_t *)_dstV;
667     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
668     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
669     int i;
670     for (i = 0; i < width; i++) {
671         int b = src1[3 * i + 0];
672         int g = src1[3 * i + 1];
673         int r = src1[3 * i + 2];
674
675         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
676         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
677     }
678     av_assert1(src1 == src2);
679 }
680
681 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
682                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
683 {
684     int16_t *dstU = (int16_t *)_dstU;
685     int16_t *dstV = (int16_t *)_dstV;
686     int i;
687     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
688     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
689     for (i = 0; i < width; i++) {
690         int b = src1[6 * i + 0] + src1[6 * i + 3];
691         int g = src1[6 * i + 1] + src1[6 * i + 4];
692         int r = src1[6 * i + 2] + src1[6 * i + 5];
693
694         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
695         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
696     }
697     av_assert1(src1 == src2);
698 }
699
700 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
701                        uint32_t *rgb2yuv)
702 {
703     int16_t *dst = (int16_t *)_dst;
704     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
705     int i;
706     for (i = 0; i < width; i++) {
707         int r = src[i * 3 + 0];
708         int g = src[i * 3 + 1];
709         int b = src[i * 3 + 2];
710
711         dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
712     }
713 }
714
715 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
716                         const uint8_t *src2, int width, uint32_t *rgb2yuv)
717 {
718     int16_t *dstU = (int16_t *)_dstU;
719     int16_t *dstV = (int16_t *)_dstV;
720     int i;
721     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
722     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
723     av_assert1(src1 == src2);
724     for (i = 0; i < width; i++) {
725         int r = src1[3 * i + 0];
726         int g = src1[3 * i + 1];
727         int b = src1[3 * i + 2];
728
729         dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
730         dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
731     }
732 }
733
734 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
735                              const uint8_t *src2, int width, uint32_t *rgb2yuv)
736 {
737     int16_t *dstU = (int16_t *)_dstU;
738     int16_t *dstV = (int16_t *)_dstV;
739     int i;
740     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
741     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
742     av_assert1(src1 == src2);
743     for (i = 0; i < width; i++) {
744         int r = src1[6 * i + 0] + src1[6 * i + 3];
745         int g = src1[6 * i + 1] + src1[6 * i + 4];
746         int b = src1[6 * i + 2] + src1[6 * i + 5];
747
748         dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
749         dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
750     }
751 }
752
753 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
754 {
755     uint16_t *dst = (uint16_t *)_dst;
756     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
757     int i;
758     for (i = 0; i < width; i++) {
759         int g = src[0][i];
760         int b = src[1][i];
761         int r = src[2][i];
762
763         dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
764     }
765 }
766
767 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
768 {
769     uint16_t *dst = (uint16_t *)_dst;
770     int i;
771     for (i = 0; i < width; i++)
772         dst[i] = src[3][i] << 6;
773 }
774
775 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
776 {
777     uint16_t *dstU = (uint16_t *)_dstU;
778     uint16_t *dstV = (uint16_t *)_dstV;
779     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
780     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
781     int i;
782     for (i = 0; i < width; i++) {
783         int g = src[0][i];
784         int b = src[1][i];
785         int r = src[2][i];
786
787         dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
788         dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
789     }
790 }
791
792 #define rdpx(src) \
793     is_be ? AV_RB16(src) : AV_RL16(src)
794 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
795                                                int width, int bpc, int is_be, int32_t *rgb2yuv)
796 {
797     int i;
798     const uint16_t **src = (const uint16_t **)_src;
799     uint16_t *dst        = (uint16_t *)_dst;
800     int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
801     int shift = bpc < 16 ? bpc : 14;
802     for (i = 0; i < width; i++) {
803         int g = rdpx(src[0] + i);
804         int b = rdpx(src[1] + i);
805         int r = rdpx(src[2] + i);
806
807         dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
808     }
809 }
810
811 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
812                                                 const uint8_t *_src[4], int width,
813                                                 int bpc, int is_be, int32_t *rgb2yuv)
814 {
815     int i;
816     const uint16_t **src = (const uint16_t **)_src;
817     uint16_t *dstU       = (uint16_t *)_dstU;
818     uint16_t *dstV       = (uint16_t *)_dstV;
819     int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
820     int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
821     int shift = bpc < 16 ? bpc : 14;
822     for (i = 0; i < width; i++) {
823         int g = rdpx(src[0] + i);
824         int b = rdpx(src[1] + i);
825         int r = rdpx(src[2] + i);
826
827         dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
828         dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
829     }
830 }
831 #undef rdpx
832
833 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian)                                    \
834 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4],              \
835                                                   int w, int32_t *rgb2yuv)                          \
836 {                                                                                                   \
837     planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv);                                         \
838 }                                                                                                   \
839 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV,                    \
840                                                    const uint8_t *src[4], int w, int32_t *rgb2yuv)  \
841 {                                                                                                   \
842     planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv);                                 \
843 }                                                                                                   \
844
845 #define rgb9plus_planar_funcs(nbits)            \
846     rgb9plus_planar_funcs_endian(nbits, le, 0)  \
847     rgb9plus_planar_funcs_endian(nbits, be, 1)
848
849 rgb9plus_planar_funcs(9)
850 rgb9plus_planar_funcs(10)
851 rgb9plus_planar_funcs(12)
852 rgb9plus_planar_funcs(14)
853 rgb9plus_planar_funcs(16)
854
855 av_cold void ff_sws_init_input_funcs(SwsContext *c)
856 {
857     enum AVPixelFormat srcFormat = c->srcFormat;
858
859     c->chrToYV12 = NULL;
860     switch (srcFormat) {
861     case AV_PIX_FMT_YUYV422:
862         c->chrToYV12 = yuy2ToUV_c;
863         break;
864     case AV_PIX_FMT_YVYU422:
865         c->chrToYV12 = yvy2ToUV_c;
866         break;
867     case AV_PIX_FMT_UYVY422:
868         c->chrToYV12 = uyvyToUV_c;
869         break;
870     case AV_PIX_FMT_NV12:
871         c->chrToYV12 = nv12ToUV_c;
872         break;
873     case AV_PIX_FMT_NV21:
874         c->chrToYV12 = nv21ToUV_c;
875         break;
876     case AV_PIX_FMT_RGB8:
877     case AV_PIX_FMT_BGR8:
878     case AV_PIX_FMT_PAL8:
879     case AV_PIX_FMT_BGR4_BYTE:
880     case AV_PIX_FMT_RGB4_BYTE:
881         c->chrToYV12 = palToUV_c;
882         break;
883     case AV_PIX_FMT_GBRP9LE:
884         c->readChrPlanar = planar_rgb9le_to_uv;
885         break;
886     case AV_PIX_FMT_GBRP10LE:
887         c->readChrPlanar = planar_rgb10le_to_uv;
888         break;
889     case AV_PIX_FMT_GBRP12LE:
890         c->readChrPlanar = planar_rgb12le_to_uv;
891         break;
892     case AV_PIX_FMT_GBRP14LE:
893         c->readChrPlanar = planar_rgb14le_to_uv;
894         break;
895     case AV_PIX_FMT_GBRAP16LE:
896     case AV_PIX_FMT_GBRP16LE:
897         c->readChrPlanar = planar_rgb16le_to_uv;
898         break;
899     case AV_PIX_FMT_GBRP9BE:
900         c->readChrPlanar = planar_rgb9be_to_uv;
901         break;
902     case AV_PIX_FMT_GBRP10BE:
903         c->readChrPlanar = planar_rgb10be_to_uv;
904         break;
905     case AV_PIX_FMT_GBRP12BE:
906         c->readChrPlanar = planar_rgb12be_to_uv;
907         break;
908     case AV_PIX_FMT_GBRP14BE:
909         c->readChrPlanar = planar_rgb14be_to_uv;
910         break;
911     case AV_PIX_FMT_GBRAP16BE:
912     case AV_PIX_FMT_GBRP16BE:
913         c->readChrPlanar = planar_rgb16be_to_uv;
914         break;
915     case AV_PIX_FMT_GBRAP:
916     case AV_PIX_FMT_GBRP:
917         c->readChrPlanar = planar_rgb_to_uv;
918         break;
919 #if HAVE_BIGENDIAN
920     case AV_PIX_FMT_YUV444P9LE:
921     case AV_PIX_FMT_YUV422P9LE:
922     case AV_PIX_FMT_YUV420P9LE:
923     case AV_PIX_FMT_YUV422P10LE:
924     case AV_PIX_FMT_YUV444P10LE:
925     case AV_PIX_FMT_YUV420P10LE:
926     case AV_PIX_FMT_YUV422P12LE:
927     case AV_PIX_FMT_YUV444P12LE:
928     case AV_PIX_FMT_YUV420P12LE:
929     case AV_PIX_FMT_YUV422P14LE:
930     case AV_PIX_FMT_YUV444P14LE:
931     case AV_PIX_FMT_YUV420P14LE:
932     case AV_PIX_FMT_YUV420P16LE:
933     case AV_PIX_FMT_YUV422P16LE:
934     case AV_PIX_FMT_YUV444P16LE:
935
936     case AV_PIX_FMT_YUVA444P9LE:
937     case AV_PIX_FMT_YUVA422P9LE:
938     case AV_PIX_FMT_YUVA420P9LE:
939     case AV_PIX_FMT_YUVA444P10LE:
940     case AV_PIX_FMT_YUVA422P10LE:
941     case AV_PIX_FMT_YUVA420P10LE:
942     case AV_PIX_FMT_YUVA420P16LE:
943     case AV_PIX_FMT_YUVA422P16LE:
944     case AV_PIX_FMT_YUVA444P16LE:
945         c->chrToYV12 = bswap16UV_c;
946         break;
947 #else
948     case AV_PIX_FMT_YUV444P9BE:
949     case AV_PIX_FMT_YUV422P9BE:
950     case AV_PIX_FMT_YUV420P9BE:
951     case AV_PIX_FMT_YUV444P10BE:
952     case AV_PIX_FMT_YUV422P10BE:
953     case AV_PIX_FMT_YUV420P10BE:
954     case AV_PIX_FMT_YUV444P12BE:
955     case AV_PIX_FMT_YUV422P12BE:
956     case AV_PIX_FMT_YUV420P12BE:
957     case AV_PIX_FMT_YUV444P14BE:
958     case AV_PIX_FMT_YUV422P14BE:
959     case AV_PIX_FMT_YUV420P14BE:
960     case AV_PIX_FMT_YUV420P16BE:
961     case AV_PIX_FMT_YUV422P16BE:
962     case AV_PIX_FMT_YUV444P16BE:
963
964     case AV_PIX_FMT_YUVA444P9BE:
965     case AV_PIX_FMT_YUVA422P9BE:
966     case AV_PIX_FMT_YUVA420P9BE:
967     case AV_PIX_FMT_YUVA444P10BE:
968     case AV_PIX_FMT_YUVA422P10BE:
969     case AV_PIX_FMT_YUVA420P10BE:
970     case AV_PIX_FMT_YUVA420P16BE:
971     case AV_PIX_FMT_YUVA422P16BE:
972     case AV_PIX_FMT_YUVA444P16BE:
973         c->chrToYV12 = bswap16UV_c;
974         break;
975 #endif
976     }
977     if (c->chrSrcHSubSample) {
978         switch (srcFormat) {
979         case AV_PIX_FMT_RGBA64BE:
980             c->chrToYV12 = rgb64BEToUV_half_c;
981             break;
982         case AV_PIX_FMT_RGBA64LE:
983             c->chrToYV12 = rgb64LEToUV_half_c;
984             break;
985         case AV_PIX_FMT_BGRA64BE:
986             c->chrToYV12 = bgr64BEToUV_half_c;
987             break;
988         case AV_PIX_FMT_BGRA64LE:
989             c->chrToYV12 = bgr64LEToUV_half_c;
990             break;
991         case AV_PIX_FMT_RGB48BE:
992             c->chrToYV12 = rgb48BEToUV_half_c;
993             break;
994         case AV_PIX_FMT_RGB48LE:
995             c->chrToYV12 = rgb48LEToUV_half_c;
996             break;
997         case AV_PIX_FMT_BGR48BE:
998             c->chrToYV12 = bgr48BEToUV_half_c;
999             break;
1000         case AV_PIX_FMT_BGR48LE:
1001             c->chrToYV12 = bgr48LEToUV_half_c;
1002             break;
1003         case AV_PIX_FMT_RGB32:
1004             c->chrToYV12 = bgr32ToUV_half_c;
1005             break;
1006         case AV_PIX_FMT_RGB32_1:
1007             c->chrToYV12 = bgr321ToUV_half_c;
1008             break;
1009         case AV_PIX_FMT_BGR24:
1010             c->chrToYV12 = bgr24ToUV_half_c;
1011             break;
1012         case AV_PIX_FMT_BGR565LE:
1013             c->chrToYV12 = bgr16leToUV_half_c;
1014             break;
1015         case AV_PIX_FMT_BGR565BE:
1016             c->chrToYV12 = bgr16beToUV_half_c;
1017             break;
1018         case AV_PIX_FMT_BGR555LE:
1019             c->chrToYV12 = bgr15leToUV_half_c;
1020             break;
1021         case AV_PIX_FMT_BGR555BE:
1022             c->chrToYV12 = bgr15beToUV_half_c;
1023             break;
1024         case AV_PIX_FMT_GBRAP:
1025         case AV_PIX_FMT_GBRP:
1026             c->chrToYV12 = gbr24pToUV_half_c;
1027             break;
1028         case AV_PIX_FMT_BGR444LE:
1029             c->chrToYV12 = bgr12leToUV_half_c;
1030             break;
1031         case AV_PIX_FMT_BGR444BE:
1032             c->chrToYV12 = bgr12beToUV_half_c;
1033             break;
1034         case AV_PIX_FMT_BGR32:
1035             c->chrToYV12 = rgb32ToUV_half_c;
1036             break;
1037         case AV_PIX_FMT_BGR32_1:
1038             c->chrToYV12 = rgb321ToUV_half_c;
1039             break;
1040         case AV_PIX_FMT_RGB24:
1041             c->chrToYV12 = rgb24ToUV_half_c;
1042             break;
1043         case AV_PIX_FMT_RGB565LE:
1044             c->chrToYV12 = rgb16leToUV_half_c;
1045             break;
1046         case AV_PIX_FMT_RGB565BE:
1047             c->chrToYV12 = rgb16beToUV_half_c;
1048             break;
1049         case AV_PIX_FMT_RGB555LE:
1050             c->chrToYV12 = rgb15leToUV_half_c;
1051             break;
1052         case AV_PIX_FMT_RGB555BE:
1053             c->chrToYV12 = rgb15beToUV_half_c;
1054             break;
1055         case AV_PIX_FMT_RGB444LE:
1056             c->chrToYV12 = rgb12leToUV_half_c;
1057             break;
1058         case AV_PIX_FMT_RGB444BE:
1059             c->chrToYV12 = rgb12beToUV_half_c;
1060             break;
1061         }
1062     } else {
1063         switch (srcFormat) {
1064         case AV_PIX_FMT_RGBA64BE:
1065             c->chrToYV12 = rgb64BEToUV_c;
1066             break;
1067         case AV_PIX_FMT_RGBA64LE:
1068             c->chrToYV12 = rgb64LEToUV_c;
1069             break;
1070         case AV_PIX_FMT_BGRA64BE:
1071             c->chrToYV12 = bgr64BEToUV_c;
1072             break;
1073         case AV_PIX_FMT_BGRA64LE:
1074             c->chrToYV12 = bgr64LEToUV_c;
1075             break;
1076         case AV_PIX_FMT_RGB48BE:
1077             c->chrToYV12 = rgb48BEToUV_c;
1078             break;
1079         case AV_PIX_FMT_RGB48LE:
1080             c->chrToYV12 = rgb48LEToUV_c;
1081             break;
1082         case AV_PIX_FMT_BGR48BE:
1083             c->chrToYV12 = bgr48BEToUV_c;
1084             break;
1085         case AV_PIX_FMT_BGR48LE:
1086             c->chrToYV12 = bgr48LEToUV_c;
1087             break;
1088         case AV_PIX_FMT_RGB32:
1089             c->chrToYV12 = bgr32ToUV_c;
1090             break;
1091         case AV_PIX_FMT_RGB32_1:
1092             c->chrToYV12 = bgr321ToUV_c;
1093             break;
1094         case AV_PIX_FMT_BGR24:
1095             c->chrToYV12 = bgr24ToUV_c;
1096             break;
1097         case AV_PIX_FMT_BGR565LE:
1098             c->chrToYV12 = bgr16leToUV_c;
1099             break;
1100         case AV_PIX_FMT_BGR565BE:
1101             c->chrToYV12 = bgr16beToUV_c;
1102             break;
1103         case AV_PIX_FMT_BGR555LE:
1104             c->chrToYV12 = bgr15leToUV_c;
1105             break;
1106         case AV_PIX_FMT_BGR555BE:
1107             c->chrToYV12 = bgr15beToUV_c;
1108             break;
1109         case AV_PIX_FMT_BGR444LE:
1110             c->chrToYV12 = bgr12leToUV_c;
1111             break;
1112         case AV_PIX_FMT_BGR444BE:
1113             c->chrToYV12 = bgr12beToUV_c;
1114             break;
1115         case AV_PIX_FMT_BGR32:
1116             c->chrToYV12 = rgb32ToUV_c;
1117             break;
1118         case AV_PIX_FMT_BGR32_1:
1119             c->chrToYV12 = rgb321ToUV_c;
1120             break;
1121         case AV_PIX_FMT_RGB24:
1122             c->chrToYV12 = rgb24ToUV_c;
1123             break;
1124         case AV_PIX_FMT_RGB565LE:
1125             c->chrToYV12 = rgb16leToUV_c;
1126             break;
1127         case AV_PIX_FMT_RGB565BE:
1128             c->chrToYV12 = rgb16beToUV_c;
1129             break;
1130         case AV_PIX_FMT_RGB555LE:
1131             c->chrToYV12 = rgb15leToUV_c;
1132             break;
1133         case AV_PIX_FMT_RGB555BE:
1134             c->chrToYV12 = rgb15beToUV_c;
1135             break;
1136         case AV_PIX_FMT_RGB444LE:
1137             c->chrToYV12 = rgb12leToUV_c;
1138             break;
1139         case AV_PIX_FMT_RGB444BE:
1140             c->chrToYV12 = rgb12beToUV_c;
1141             break;
1142         }
1143     }
1144
1145     c->lumToYV12 = NULL;
1146     c->alpToYV12 = NULL;
1147     switch (srcFormat) {
1148     case AV_PIX_FMT_GBRP9LE:
1149         c->readLumPlanar = planar_rgb9le_to_y;
1150         break;
1151     case AV_PIX_FMT_GBRP10LE:
1152         c->readLumPlanar = planar_rgb10le_to_y;
1153         break;
1154     case AV_PIX_FMT_GBRP12LE:
1155         c->readLumPlanar = planar_rgb12le_to_y;
1156         break;
1157     case AV_PIX_FMT_GBRP14LE:
1158         c->readLumPlanar = planar_rgb14le_to_y;
1159         break;
1160     case AV_PIX_FMT_GBRAP16LE:
1161     case AV_PIX_FMT_GBRP16LE:
1162         c->readLumPlanar = planar_rgb16le_to_y;
1163         break;
1164     case AV_PIX_FMT_GBRP9BE:
1165         c->readLumPlanar = planar_rgb9be_to_y;
1166         break;
1167     case AV_PIX_FMT_GBRP10BE:
1168         c->readLumPlanar = planar_rgb10be_to_y;
1169         break;
1170     case AV_PIX_FMT_GBRP12BE:
1171         c->readLumPlanar = planar_rgb12be_to_y;
1172         break;
1173     case AV_PIX_FMT_GBRP14BE:
1174         c->readLumPlanar = planar_rgb14be_to_y;
1175         break;
1176     case AV_PIX_FMT_GBRAP16BE:
1177     case AV_PIX_FMT_GBRP16BE:
1178         c->readLumPlanar = planar_rgb16be_to_y;
1179         break;
1180     case AV_PIX_FMT_GBRAP:
1181         c->readAlpPlanar = planar_rgb_to_a;
1182     case AV_PIX_FMT_GBRP:
1183         c->readLumPlanar = planar_rgb_to_y;
1184         break;
1185 #if HAVE_BIGENDIAN
1186     case AV_PIX_FMT_YUV444P9LE:
1187     case AV_PIX_FMT_YUV422P9LE:
1188     case AV_PIX_FMT_YUV420P9LE:
1189     case AV_PIX_FMT_YUV444P10LE:
1190     case AV_PIX_FMT_YUV422P10LE:
1191     case AV_PIX_FMT_YUV420P10LE:
1192     case AV_PIX_FMT_YUV444P12LE:
1193     case AV_PIX_FMT_YUV422P12LE:
1194     case AV_PIX_FMT_YUV420P12LE:
1195     case AV_PIX_FMT_YUV444P14LE:
1196     case AV_PIX_FMT_YUV422P14LE:
1197     case AV_PIX_FMT_YUV420P14LE:
1198     case AV_PIX_FMT_YUV420P16LE:
1199     case AV_PIX_FMT_YUV422P16LE:
1200     case AV_PIX_FMT_YUV444P16LE:
1201
1202     case AV_PIX_FMT_GRAY16LE:
1203         c->lumToYV12 = bswap16Y_c;
1204         break;
1205     case AV_PIX_FMT_YUVA444P9LE:
1206     case AV_PIX_FMT_YUVA422P9LE:
1207     case AV_PIX_FMT_YUVA420P9LE:
1208     case AV_PIX_FMT_YUVA444P10LE:
1209     case AV_PIX_FMT_YUVA422P10LE:
1210     case AV_PIX_FMT_YUVA420P10LE:
1211     case AV_PIX_FMT_YUVA420P16LE:
1212     case AV_PIX_FMT_YUVA422P16LE:
1213     case AV_PIX_FMT_YUVA444P16LE:
1214         c->lumToYV12 = bswap16Y_c;
1215         c->alpToYV12 = bswap16Y_c;
1216         break;
1217 #else
1218     case AV_PIX_FMT_YUV444P9BE:
1219     case AV_PIX_FMT_YUV422P9BE:
1220     case AV_PIX_FMT_YUV420P9BE:
1221     case AV_PIX_FMT_YUV444P10BE:
1222     case AV_PIX_FMT_YUV422P10BE:
1223     case AV_PIX_FMT_YUV420P10BE:
1224     case AV_PIX_FMT_YUV444P12BE:
1225     case AV_PIX_FMT_YUV422P12BE:
1226     case AV_PIX_FMT_YUV420P12BE:
1227     case AV_PIX_FMT_YUV444P14BE:
1228     case AV_PIX_FMT_YUV422P14BE:
1229     case AV_PIX_FMT_YUV420P14BE:
1230     case AV_PIX_FMT_YUV420P16BE:
1231     case AV_PIX_FMT_YUV422P16BE:
1232     case AV_PIX_FMT_YUV444P16BE:
1233
1234     case AV_PIX_FMT_GRAY16BE:
1235         c->lumToYV12 = bswap16Y_c;
1236         break;
1237     case AV_PIX_FMT_YUVA444P9BE:
1238     case AV_PIX_FMT_YUVA422P9BE:
1239     case AV_PIX_FMT_YUVA420P9BE:
1240     case AV_PIX_FMT_YUVA444P10BE:
1241     case AV_PIX_FMT_YUVA422P10BE:
1242     case AV_PIX_FMT_YUVA420P10BE:
1243     case AV_PIX_FMT_YUVA420P16BE:
1244     case AV_PIX_FMT_YUVA422P16BE:
1245     case AV_PIX_FMT_YUVA444P16BE:
1246         c->lumToYV12 = bswap16Y_c;
1247         c->alpToYV12 = bswap16Y_c;
1248         break;
1249 #endif
1250     case AV_PIX_FMT_YA16LE:
1251         c->lumToYV12 = read_ya16le_gray_c;
1252         c->alpToYV12 = read_ya16le_alpha_c;
1253         break;
1254     case AV_PIX_FMT_YA16BE:
1255         c->lumToYV12 = read_ya16be_gray_c;
1256         c->alpToYV12 = read_ya16be_alpha_c;
1257         break;
1258     case AV_PIX_FMT_YUYV422:
1259     case AV_PIX_FMT_YVYU422:
1260     case AV_PIX_FMT_YA8:
1261         c->lumToYV12 = yuy2ToY_c;
1262         break;
1263     case AV_PIX_FMT_UYVY422:
1264         c->lumToYV12 = uyvyToY_c;
1265         break;
1266     case AV_PIX_FMT_BGR24:
1267         c->lumToYV12 = bgr24ToY_c;
1268         break;
1269     case AV_PIX_FMT_BGR565LE:
1270         c->lumToYV12 = bgr16leToY_c;
1271         break;
1272     case AV_PIX_FMT_BGR565BE:
1273         c->lumToYV12 = bgr16beToY_c;
1274         break;
1275     case AV_PIX_FMT_BGR555LE:
1276         c->lumToYV12 = bgr15leToY_c;
1277         break;
1278     case AV_PIX_FMT_BGR555BE:
1279         c->lumToYV12 = bgr15beToY_c;
1280         break;
1281     case AV_PIX_FMT_BGR444LE:
1282         c->lumToYV12 = bgr12leToY_c;
1283         break;
1284     case AV_PIX_FMT_BGR444BE:
1285         c->lumToYV12 = bgr12beToY_c;
1286         break;
1287     case AV_PIX_FMT_RGB24:
1288         c->lumToYV12 = rgb24ToY_c;
1289         break;
1290     case AV_PIX_FMT_RGB565LE:
1291         c->lumToYV12 = rgb16leToY_c;
1292         break;
1293     case AV_PIX_FMT_RGB565BE:
1294         c->lumToYV12 = rgb16beToY_c;
1295         break;
1296     case AV_PIX_FMT_RGB555LE:
1297         c->lumToYV12 = rgb15leToY_c;
1298         break;
1299     case AV_PIX_FMT_RGB555BE:
1300         c->lumToYV12 = rgb15beToY_c;
1301         break;
1302     case AV_PIX_FMT_RGB444LE:
1303         c->lumToYV12 = rgb12leToY_c;
1304         break;
1305     case AV_PIX_FMT_RGB444BE:
1306         c->lumToYV12 = rgb12beToY_c;
1307         break;
1308     case AV_PIX_FMT_RGB8:
1309     case AV_PIX_FMT_BGR8:
1310     case AV_PIX_FMT_PAL8:
1311     case AV_PIX_FMT_BGR4_BYTE:
1312     case AV_PIX_FMT_RGB4_BYTE:
1313         c->lumToYV12 = palToY_c;
1314         break;
1315     case AV_PIX_FMT_MONOBLACK:
1316         c->lumToYV12 = monoblack2Y_c;
1317         break;
1318     case AV_PIX_FMT_MONOWHITE:
1319         c->lumToYV12 = monowhite2Y_c;
1320         break;
1321     case AV_PIX_FMT_RGB32:
1322         c->lumToYV12 = bgr32ToY_c;
1323         break;
1324     case AV_PIX_FMT_RGB32_1:
1325         c->lumToYV12 = bgr321ToY_c;
1326         break;
1327     case AV_PIX_FMT_BGR32:
1328         c->lumToYV12 = rgb32ToY_c;
1329         break;
1330     case AV_PIX_FMT_BGR32_1:
1331         c->lumToYV12 = rgb321ToY_c;
1332         break;
1333     case AV_PIX_FMT_RGB48BE:
1334         c->lumToYV12 = rgb48BEToY_c;
1335         break;
1336     case AV_PIX_FMT_RGB48LE:
1337         c->lumToYV12 = rgb48LEToY_c;
1338         break;
1339     case AV_PIX_FMT_BGR48BE:
1340         c->lumToYV12 = bgr48BEToY_c;
1341         break;
1342     case AV_PIX_FMT_BGR48LE:
1343         c->lumToYV12 = bgr48LEToY_c;
1344         break;
1345     case AV_PIX_FMT_RGBA64BE:
1346         c->lumToYV12 = rgb64BEToY_c;
1347         break;
1348     case AV_PIX_FMT_RGBA64LE:
1349         c->lumToYV12 = rgb64LEToY_c;
1350         break;
1351     case AV_PIX_FMT_BGRA64BE:
1352         c->lumToYV12 = bgr64BEToY_c;
1353         break;
1354     case AV_PIX_FMT_BGRA64LE:
1355         c->lumToYV12 = bgr64LEToY_c;
1356     }
1357     if (c->alpPixBuf) {
1358         if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1359             if (HAVE_BIGENDIAN == !isBE(srcFormat))
1360                 c->alpToYV12 = bswap16Y_c;
1361         }
1362         switch (srcFormat) {
1363         case AV_PIX_FMT_BGRA64LE:
1364         case AV_PIX_FMT_BGRA64BE:
1365         case AV_PIX_FMT_RGBA64LE:
1366         case AV_PIX_FMT_RGBA64BE:  c->alpToYV12 = rgba64ToA_c; break;
1367         case AV_PIX_FMT_BGRA:
1368         case AV_PIX_FMT_RGBA:
1369             c->alpToYV12 = rgbaToA_c;
1370             break;
1371         case AV_PIX_FMT_ABGR:
1372         case AV_PIX_FMT_ARGB:
1373             c->alpToYV12 = abgrToA_c;
1374             break;
1375         case AV_PIX_FMT_YA8:
1376             c->alpToYV12 = uyvyToY_c;
1377             break;
1378         case AV_PIX_FMT_PAL8 :
1379             c->alpToYV12 = palToA_c;
1380             break;
1381         }
1382     }
1383 }