swscale: fix warning about incompatible function pointer type
[libav.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 }