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