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