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