?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libavformat/hls: Be more restrictive on mpegts extensions
[FFMpeg-mirror.git] / libswscale / input.c
blobd6b319f25f74f814e638cd08a258c03c32a704fb
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
25 #include "libavutil/bswap.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/avassert.h"
28 #include "config.h"
29 #include "swscale_internal.h"
30
31 #define input_pixel(pos) (is_be ? AV_RB16(pos) : AV_RL16(pos))
32
33 #define IS_BE_LE 0
34 #define IS_BE_BE 1
35 #define IS_BE_ 0
36 /* ENDIAN_IDENTIFIER needs to be "BE", "LE" or "". The latter is intended
37 * for single-byte cases where the concept of endianness does not apply. */
38 #define IS_BE(ENDIAN_IDENTIFIER) IS_BE_ ## ENDIAN_IDENTIFIER
39
40 #define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? b_r : r_b)
41 #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? r_b : b_r)
42
43 static av_always_inline void
44 rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
45 enum AVPixelFormat origin, int32_t *rgb2yuv, int is_be)
46 {
47 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
48 int i;
49 for (i = 0; i < width; i++) {
50 unsigned int r_b = input_pixel(&src[i*4+0]);
51 unsigned int g = input_pixel(&src[i*4+1]);
52 unsigned int b_r = input_pixel(&src[i*4+2]);
53
54 dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
55 }
56 }
57
58 static av_always_inline void
59 rgb64ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
60 const uint16_t *src1, const uint16_t *src2,
61 int width, enum AVPixelFormat origin, int32_t *rgb2yuv, int is_be)
62 {
63 int i;
64 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
65 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
66 av_assert1(src1==src2);
67 for (i = 0; i < width; i++) {
68 unsigned int r_b = input_pixel(&src1[i*4+0]);
69 unsigned int g = input_pixel(&src1[i*4+1]);
70 unsigned int b_r = input_pixel(&src1[i*4+2]);
71
72 dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
73 dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
74 }
75 }
76
77 static av_always_inline void
78 rgb64ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
79 const uint16_t *src1, const uint16_t *src2,
80 int width, enum AVPixelFormat origin, int32_t *rgb2yuv, int is_be)
81 {
82 int i;
83 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
84 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
85 av_assert1(src1==src2);
86 for (i = 0; i < width; i++) {
87 unsigned r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
88 unsigned g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
89 unsigned b_r = (input_pixel(&src1[8 * i + 2]) + input_pixel(&src1[8 * i + 6]) + 1) >> 1;
90
91 dstU[i]= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
92 dstV[i]= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
93 }
94 }
95
96 #define RGB64FUNCS_EXT(pattern, BE_LE, origin, is_be) \
97 static void pattern ## 64 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, const uint8_t *unused1,\
98 int width, uint32_t *rgb2yuv, void *opq) \
99 { \
100 const uint16_t *src = (const uint16_t *) _src; \
101 uint16_t *dst = (uint16_t *) _dst; \
102 rgb64ToY_c_template(dst, src, width, origin, rgb2yuv, is_be); \
103 } \
104 \
105 static void pattern ## 64 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
106 const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
107 int width, uint32_t *rgb2yuv, void *opq) \
108 { \
109 const uint16_t *src1 = (const uint16_t *) _src1, \
110 *src2 = (const uint16_t *) _src2; \
111 uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
112 rgb64ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv, is_be); \
113 } \
114 \
115 static void pattern ## 64 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
116 const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
117 int width, uint32_t *rgb2yuv, void *opq) \
118 { \
119 const uint16_t *src1 = (const uint16_t *) _src1, \
120 *src2 = (const uint16_t *) _src2; \
121 uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
122 rgb64ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv, is_be); \
123 }
124 #define RGB64FUNCS(pattern, endianness, base_fmt) \
125 RGB64FUNCS_EXT(pattern, endianness, base_fmt ## endianness, IS_BE(endianness))
126
127 RGB64FUNCS(rgb, LE, AV_PIX_FMT_RGBA64)
128 RGB64FUNCS(rgb, BE, AV_PIX_FMT_RGBA64)
129 RGB64FUNCS(bgr, LE, AV_PIX_FMT_BGRA64)
130 RGB64FUNCS(bgr, BE, AV_PIX_FMT_BGRA64)
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, int is_be)
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
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, int is_be)
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 unsigned r_b = input_pixel(&src1[i * 3 + 0]);
162 unsigned g = input_pixel(&src1[i * 3 + 1]);
163 unsigned 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
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, int is_be)
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 unsigned r_b = (input_pixel(&src1[6 * i + 0]) +
184 input_pixel(&src1[6 * i + 3]) + 1) >> 1;
185 unsigned g = (input_pixel(&src1[6 * i + 1]) +
186 input_pixel(&src1[6 * i + 4]) + 1) >> 1;
187 unsigned 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_EXT(pattern, BE_LE, origin, is_be) \
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 void *opq) \
206 { \
207 const uint16_t *src = (const uint16_t *)_src; \
208 uint16_t *dst = (uint16_t *)_dst; \
209 rgb48ToY_c_template(dst, src, width, origin, rgb2yuv, is_be); \
210 } \
211 \
212 static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, \
213 uint8_t *_dstV, \
214 const uint8_t *unused0, \
215 const uint8_t *_src1, \
216 const uint8_t *_src2, \
217 int width, \
218 uint32_t *rgb2yuv, \
219 void *opq) \
220 { \
221 const uint16_t *src1 = (const uint16_t *)_src1, \
222 *src2 = (const uint16_t *)_src2; \
223 uint16_t *dstU = (uint16_t *)_dstU, \
224 *dstV = (uint16_t *)_dstV; \
225 rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv, is_be); \
226 } \
227 \
228 static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, \
229 uint8_t *_dstV, \
230 const uint8_t *unused0, \
231 const uint8_t *_src1, \
232 const uint8_t *_src2, \
233 int width, \
234 uint32_t *rgb2yuv, \
235 void *opq) \
236 { \
237 const uint16_t *src1 = (const uint16_t *)_src1, \
238 *src2 = (const uint16_t *)_src2; \
239 uint16_t *dstU = (uint16_t *)_dstU, \
240 *dstV = (uint16_t *)_dstV; \
241 rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv, is_be); \
242 }
243 #define RGB48FUNCS(pattern, endianness, base_fmt) \
244 RGB48FUNCS_EXT(pattern, endianness, base_fmt ## endianness, IS_BE(endianness))
245
246 RGB48FUNCS(rgb, LE, AV_PIX_FMT_RGB48)
247 RGB48FUNCS(rgb, BE, AV_PIX_FMT_RGB48)
248 RGB48FUNCS(bgr, LE, AV_PIX_FMT_BGR48)
249 RGB48FUNCS(bgr, BE, AV_PIX_FMT_BGR48)
250
251 #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA || \
252 origin == AV_PIX_FMT_BGRA || \
253 origin == AV_PIX_FMT_ARGB || \
254 origin == AV_PIX_FMT_ABGR) \
255 ? AV_RN32A(&src[(i) * 4]) \
256 : ((origin == AV_PIX_FMT_X2RGB10LE || \
257 origin == AV_PIX_FMT_X2BGR10LE) \
258 ? AV_RL32(&src[(i) * 4]) \
259 : (is_be ? AV_RB16(&src[(i) * 2]) \
260 : AV_RL16(&src[(i) * 2]))))
261
262 static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
263 const uint8_t *src,
264 int width,
265 enum AVPixelFormat origin,
266 int shr, int shg,
267 int shb, int shp,
268 int maskr, int maskg,
269 int maskb, int rsh,
270 int gsh, int bsh, int S,
271 int32_t *rgb2yuv, int is_be)
272 {
273 const int ry = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
274 const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
275 int i;
276
277 for (i = 0; i < width; i++) {
278 int px = input_pixel(i) >> shp;
279 int b = (px & maskb) >> shb;
280 int g = (px & maskg) >> shg;
281 int r = (px & maskr) >> shr;
282
283 dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
284 }
285 }
286
287 static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
288 int16_t *dstV,
289 const uint8_t *src,
290 int width,
291 enum AVPixelFormat origin,
292 int shr, int shg,
293 int shb, int shp,
294 int maskr, int maskg,
295 int maskb, int rsh,
296 int gsh, int bsh, int S,
297 int32_t *rgb2yuv, int is_be)
298 {
299 const int ru = rgb2yuv[RU_IDX] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
300 rv = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << bsh);
301 const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
302 int i;
303
304 for (i = 0; i < width; i++) {
305 int px = input_pixel(i) >> shp;
306 int b = (px & maskb) >> shb;
307 int g = (px & maskg) >> shg;
308 int r = (px & maskr) >> shr;
309
310 dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
311 dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
312 }
313 }
314
315 static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
316 int16_t *dstV,
317 const uint8_t *src,
318 int width,
319 enum AVPixelFormat origin,
320 int shr, int shg,
321 int shb, int shp,
322 int maskr, int maskg,
323 int maskb, int rsh,
324 int gsh, int bsh, int S,
325 int32_t *rgb2yuv, int is_be)
326 {
327 const int ru = rgb2yuv[RU_IDX] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
328 rv = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << bsh),
329 maskgx = ~(maskr | maskb);
330 const unsigned rnd = (256U<<(S)) + (1<<(S-6));
331 int i;
332
333 maskr |= maskr << 1;
334 maskb |= maskb << 1;
335 maskg |= maskg << 1;
336 for (i = 0; i < width; i++) {
337 unsigned px0 = input_pixel(2 * i + 0) >> shp;
338 unsigned px1 = input_pixel(2 * i + 1) >> shp;
339 int b, r, g = (px0 & maskgx) + (px1 & maskgx);
340 int rb = px0 + px1 - g;
341
342 b = (rb & maskb) >> shb;
343 if (shp ||
344 origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
345 origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
346 g >>= shg;
347 } else {
348 g = (g & maskg) >> shg;
349 }
350 r = (rb & maskr) >> shr;
351
352 dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
353 dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
354 }
355 }
356
357 #undef input_pixel
358
359 #define RGB16_32FUNCS_EXT(fmt, name, shr, shg, shb, shp, maskr, \
360 maskg, maskb, rsh, gsh, bsh, S, is_be) \
361 static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, \
362 int width, uint32_t *tab, void *opq) \
363 { \
364 rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp, \
365 maskr, maskg, maskb, rsh, gsh, bsh, S, tab, is_be); \
366 } \
367 \
368 static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
369 const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy, \
370 int width, uint32_t *tab, void *opq) \
371 { \
372 rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
373 shr, shg, shb, shp, \
374 maskr, maskg, maskb, rsh, gsh, bsh, S, tab, is_be); \
375 } \
376 \
377 static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \
378 const uint8_t *unused0, const uint8_t *src, \
379 const uint8_t *dummy, \
380 int width, uint32_t *tab, void *opq) \
381 { \
382 rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
383 shr, shg, shb, shp, \
384 maskr, maskg, maskb, \
385 rsh, gsh, bsh, S, tab, is_be); \
386 }
387
388 #define RGB16_32FUNCS(base_fmt, endianness, name, shr, shg, shb, shp, maskr, \
389 maskg, maskb, rsh, gsh, bsh, S) \
390 RGB16_32FUNCS_EXT(base_fmt ## endianness, name, shr, shg, shb, shp, maskr, \
391 maskg, maskb, rsh, gsh, bsh, S, IS_BE(endianness))
392
393 RGB16_32FUNCS(AV_PIX_FMT_BGR32, , bgr32, 16, 0, 0, 0, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
394 RGB16_32FUNCS(AV_PIX_FMT_BGR32_1, , bgr321, 16, 0, 0, 8, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
395 RGB16_32FUNCS(AV_PIX_FMT_RGB32, , rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
396 RGB16_32FUNCS(AV_PIX_FMT_RGB32_1, , rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
397 RGB16_32FUNCS(AV_PIX_FMT_BGR565, LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
398 RGB16_32FUNCS(AV_PIX_FMT_BGR555, LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
399 RGB16_32FUNCS(AV_PIX_FMT_BGR444, LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
400 RGB16_32FUNCS(AV_PIX_FMT_RGB565, LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
401 RGB16_32FUNCS(AV_PIX_FMT_RGB555, LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
402 RGB16_32FUNCS(AV_PIX_FMT_RGB444, LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
403 RGB16_32FUNCS(AV_PIX_FMT_BGR565, BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
404 RGB16_32FUNCS(AV_PIX_FMT_BGR555, BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
405 RGB16_32FUNCS(AV_PIX_FMT_BGR444, BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
406 RGB16_32FUNCS(AV_PIX_FMT_RGB565, BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
407 RGB16_32FUNCS(AV_PIX_FMT_RGB555, BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
408 RGB16_32FUNCS(AV_PIX_FMT_RGB444, BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
409 RGB16_32FUNCS(AV_PIX_FMT_X2RGB10, LE, rgb30le, 16, 6, 0, 0, 0x3FF00000, 0xFFC00, 0x3FF, 0, 0, 4, RGB2YUV_SHIFT + 6)
410 RGB16_32FUNCS(AV_PIX_FMT_X2BGR10, LE, bgr30le, 0, 6, 16, 0, 0x3FF, 0xFFC00, 0x3FF00000, 4, 0, 0, RGB2YUV_SHIFT + 6)
411
412 static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
413 const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
414 int width, uint32_t *rgb2yuv, void *opq)
415 {
416 uint16_t *dstU = (uint16_t *)_dstU;
417 uint16_t *dstV = (uint16_t *)_dstV;
418 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
419 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
420
421 int i;
422 for (i = 0; i < width; i++) {
423 unsigned int g = gsrc[2*i] + gsrc[2*i+1];
424 unsigned int b = bsrc[2*i] + bsrc[2*i+1];
425 unsigned int r = rsrc[2*i] + rsrc[2*i+1];
426
427 dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
428 dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
429 }
430 }
431
432 static void rgba64leToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
433 const uint8_t *unused2, int width, uint32_t *unused, void *opq)
434 {
435 int16_t *dst = (int16_t *)_dst;
436 const uint16_t *src = (const uint16_t *)_src;
437 int i;
438 for (i = 0; i < width; i++)
439 dst[i] = AV_RL16(src + 4 * i + 3);
440 }
441
442 static void rgba64beToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
443 const uint8_t *unused2, int width, uint32_t *unused, void *opq)
444 {
445 int16_t *dst = (int16_t *)_dst;
446 const uint16_t *src = (const uint16_t *)_src;
447 int i;
448 for (i = 0; i < width; i++)
449 dst[i] = AV_RB16(src + 4 * i + 3);
450 }
451
452 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
453 const uint8_t *unused2, int width, uint32_t *unused, void *opq)
454 {
455 int16_t *dst = (int16_t *)_dst;
456 int i;
457 for (i=0; i<width; i++) {
458 dst[i]= src[4*i]<<6 | src[4*i]>>2;
459 }
460 }
461
462 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
463 const uint8_t *unused2, int width, uint32_t *unused, void *opq)
464 {
465 int16_t *dst = (int16_t *)_dst;
466 int i;
467 for (i=0; i<width; i++) {
468 dst[i]= src[4*i+3]<<6 | src[4*i+3]>>2;
469 }
470 }
471
472 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
473 const uint8_t *unused2, int width, uint32_t *pal, void *opq)
474 {
475 int16_t *dst = (int16_t *)_dst;
476 int i;
477 for (i=0; i<width; i++) {
478 int d= src[i];
479
480 dst[i]= (pal[d] >> 24)<<6 | pal[d]>>26;
481 }
482 }
483
484 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
485 const uint8_t *unused2, int width, uint32_t *pal, void *opq)
486 {
487 int16_t *dst = (int16_t *)_dst;
488 int i;
489 for (i = 0; i < width; i++) {
490 int d = src[i];
491
492 dst[i] = (pal[d] & 0xFF)<<6;
493 }
494 }
495
496 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
497 const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
498 int width, uint32_t *pal, void *opq)
499 {
500 uint16_t *dstU = (uint16_t *)_dstU;
501 int16_t *dstV = (int16_t *)_dstV;
502 int i;
503 av_assert1(src1 == src2);
504 for (i = 0; i < width; i++) {
505 int p = pal[src1[i]];
506
507 dstU[i] = (uint8_t)(p>> 8)<<6;
508 dstV[i] = (uint8_t)(p>>16)<<6;
509 }
510 }
511
512 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
513 const uint8_t *unused2, int width, uint32_t *unused, void *opq)
514 {
515 int16_t *dst = (int16_t *)_dst;
516 int i, j;
517 width = (width + 7) >> 3;
518 for (i = 0; i < width; i++) {
519 int d = ~src[i];
520 for (j = 0; j < 8; j++)
521 dst[8*i+j]= ((d>>(7-j))&1) * 16383;
522 }
523 if(width&7){
524 int d= ~src[i];
525 for (j = 0; j < (width&7); j++)
526 dst[8*i+j]= ((d>>(7-j))&1) * 16383;
527 }
528 }
529
530 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
531 const uint8_t *unused2, int width, uint32_t *unused, void *opq)
532 {
533 int16_t *dst = (int16_t *)_dst;
534 int i, j;
535 width = (width + 7) >> 3;
536 for (i = 0; i < width; i++) {
537 int d = src[i];
538 for (j = 0; j < 8; j++)
539 dst[8*i+j]= ((d>>(7-j))&1) * 16383;
540 }
541 if(width&7){
542 int d = src[i];
543 for (j = 0; j < (width&7); j++)
544 dst[8*i+j] = ((d>>(7-j))&1) * 16383;
545 }
546 }
547
548 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
549 uint32_t *unused, void *opq)
550 {
551 int i;
552 for (i = 0; i < width; i++)
553 dst[i] = src[2 * i];
554 }
555
556 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
557 const uint8_t *src2, int width, uint32_t *unused, void *opq)
558 {
559 int i;
560 for (i = 0; i < width; i++) {
561 dstU[i] = src1[4 * i + 1];
562 dstV[i] = src1[4 * i + 3];
563 }
564 av_assert1(src1 == src2);
565 }
566
567 static void yvy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
568 const uint8_t *src2, int width, uint32_t *unused, void *opq)
569 {
570 int i;
571 for (i = 0; i < width; i++) {
572 dstV[i] = src1[4 * i + 1];
573 dstU[i] = src1[4 * i + 3];
574 }
575 av_assert1(src1 == src2);
576 }
577
578 #define y21xle_wrapper(bits, shift) \
579 static void y2 ## bits ## le_UV_c(uint8_t *dstU, uint8_t *dstV, \
580 const uint8_t *unused0, \
581 const uint8_t *src, \
582 const uint8_t *unused1, int width, \
583 uint32_t *unused2, void *opq) \
584 { \
585 int i; \
586 for (i = 0; i < width; i++) { \
587 AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 2) >> shift); \
588 AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6) >> shift); \
589 } \
590 } \
591 \
592 static void y2 ## bits ## le_Y_c(uint8_t *dst, const uint8_t *src, \
593 const uint8_t *unused0, \
594 const uint8_t *unused1, int width, \
595 uint32_t *unused2, void *opq) \
596 { \
597 int i; \
598 for (i = 0; i < width; i++) \
599 AV_WN16(dst + i * 2, AV_RL16(src + i * 4) >> shift); \
600 }
601
602 y21xle_wrapper(10, 6)
603 y21xle_wrapper(12, 4)
604 y21xle_wrapper(16, 0)
605
606 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
607 uint32_t *unused, void *opq)
608 {
609 int i;
610 const uint16_t *src = (const uint16_t *)_src;
611 uint16_t *dst = (uint16_t *)_dst;
612 for (i = 0; i < width; i++)
613 dst[i] = av_bswap16(src[i]);
614 }
615
616 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
617 const uint8_t *_src2, int width, uint32_t *unused, void *opq)
618 {
619 int i;
620 const uint16_t *src1 = (const uint16_t *)_src1,
621 *src2 = (const uint16_t *)_src2;
622 uint16_t *dstU = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
623 for (i = 0; i < width; i++) {
624 dstU[i] = av_bswap16(src1[i]);
625 dstV[i] = av_bswap16(src2[i]);
626 }
627 }
628
629 static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
630 uint32_t *unused, void *opq)
631 {
632 int i;
633 for (i = 0; i < width; i++)
634 AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
635 }
636
637 static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
638 uint32_t *unused, void *opq)
639 {
640 int i;
641 for (i = 0; i < width; i++)
642 AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
643 }
644
645 static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
646 uint32_t *unused, void *opq)
647 {
648 int i;
649 for (i = 0; i < width; i++)
650 AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
651 }
652
653 static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
654 uint32_t *unused, void *opq)
655 {
656 int i;
657 for (i = 0; i < width; i++)
658 AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
659 }
660
661 static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
662 uint32_t *unused2, void *opq)
663 {
664 int i;
665 for (i = 0; i < width; i++)
666 AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2));
667 }
668
669 static void read_ayuv64be_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
670 uint32_t *unused2, void *opq)
671 {
672 int i;
673 for (i = 0; i < width; i++)
674 AV_WN16(dst + i * 2, AV_RB16(src + i * 8 + 2));
675 }
676
677 static av_always_inline void ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width,
678 int u_offset, int v_offset)
679 {
680 int i;
681 for (i = 0; i < width; i++) {
682 AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + u_offset));
683 AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + v_offset));
684 }
685 }
686
687 static av_always_inline void ayuv64be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width,
688 int u_offset, int v_offset)
689 {
690 int i;
691 for (i = 0; i < width; i++) {
692 AV_WN16(dstU + i * 2, AV_RB16(src + i * 8 + u_offset));
693 AV_WN16(dstV + i * 2, AV_RB16(src + i * 8 + v_offset));
694 }
695 }
696
697 #define ayuv64_UV_funcs(pixfmt, U, V) \
698 static void read_ ## pixfmt ## le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, \
699 const uint8_t *unused1, int width, uint32_t *unused2, void *opq) \
700 { \
701 ayuv64le_UV_c(dstU, dstV, src, width, U, V); \
702 } \
703 \
704 static void read_ ## pixfmt ## be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, \
705 const uint8_t *unused1, int width, uint32_t *unused2, void *opq) \
706 { \
707 ayuv64be_UV_c(dstU, dstV, src, width, U, V); \
708 }
709
710 ayuv64_UV_funcs(ayuv64, 4, 6)
711 ayuv64_UV_funcs(xv48, 0, 4)
712
713 static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
714 uint32_t *unused2, void *opq)
715 {
716 int i;
717 for (i = 0; i < width; i++)
718 AV_WN16(dst + i * 2, AV_RL16(src + i * 8));
719 }
720
721 static void read_ayuv64be_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
722 uint32_t *unused2, void *opq)
723 {
724 int i;
725 for (i = 0; i < width; i++)
726 AV_WN16(dst + i * 2, AV_RB16(src + i * 8));
727 }
728
729 static void read_vuyx_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
730 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
731 {
732 int i;
733 for (i = 0; i < width; i++) {
734 dstU[i] = src[i * 4 + 1];
735 dstV[i] = src[i * 4];
736 }
737 }
738
739 static void read_vuyx_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
740 uint32_t *unused2, void *opq)
741 {
742 int i;
743 for (i = 0; i < width; i++)
744 dst[i] = src[i * 4 + 2];
745 }
746
747 static void read_vuya_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
748 uint32_t *unused2, void *opq)
749 {
750 int i;
751 for (i = 0; i < width; i++)
752 dst[i] = src[i * 4 + 3];
753 }
754
755 static void read_ayuv_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
756 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
757 {
758 int i;
759 for (i = 0; i < width; i++) {
760 dstU[i] = src[i * 4 + 2];
761 dstV[i] = src[i * 4 + 3];
762 }
763 }
764
765 static void read_ayuv_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
766 uint32_t *unused2, void *opq)
767 {
768 int i;
769 for (i = 0; i < width; i++)
770 dst[i] = src[i * 4 + 1];
771 }
772
773 static void read_ayuv_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
774 uint32_t *unused2, void *opq)
775 {
776 int i;
777 for (i = 0; i < width; i++)
778 dst[i] = src[i * 4];
779 }
780
781 static void read_uyva_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
782 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
783 {
784 int i;
785 for (i = 0; i < width; i++) {
786 dstU[i] = src[i * 4];
787 dstV[i] = src[i * 4 + 2];
788 }
789 }
790
791 static void vyuToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
792 uint32_t *unused2, void *opq)
793 {
794 int i;
795 for (i = 0; i < width; i++)
796 dst[i] = src[i * 3 + 1];
797 }
798
799 static void vyuToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
800 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
801 {
802 int i;
803 for (i = 0; i < width; i++) {
804 dstU[i] = src[i * 3 + 2];
805 dstV[i] = src[i * 3];
806 }
807 }
808
809 static void read_v30xle_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
810 uint32_t *unused2, void *opq)
811 {
812 int i;
813 for (i = 0; i < width; i++)
814 AV_WN16(dst + i * 2, (AV_RL32(src + i * 4) >> 12) & 0x3FFu);
815 }
816
817
818 static void read_v30xle_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
819 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
820 {
821 int i;
822 for (i = 0; i < width; i++) {
823 unsigned int uv = AV_RL32(src + i * 4);
824 AV_WN16(dstU + i * 2, (uv >> 2) & 0x3FFu);
825 AV_WN16(dstV + i * 2, (uv >> 22) & 0x3FFu);
826 }
827 }
828
829 static void read_xv30le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
830 uint32_t *unused2, void *opq)
831 {
832 int i;
833 for (i = 0; i < width; i++)
834 AV_WN16(dst + i * 2, (AV_RL32(src + i * 4) >> 10) & 0x3FFu);
835 }
836
837
838 static void read_xv30le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
839 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
840 {
841 int i;
842 for (i = 0; i < width; i++) {
843 AV_WN16(dstU + i * 2, AV_RL32(src + i * 4) & 0x3FFu);
844 AV_WN16(dstV + i * 2, (AV_RL32(src + i * 4) >> 20) & 0x3FFu);
845 }
846 }
847
848 static void read_xv36le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
849 uint32_t *unused2, void *opq)
850 {
851 int i;
852 for (i = 0; i < width; i++)
853 AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2) >> 4);
854 }
855
856
857 static void read_xv36le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
858 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
859 {
860 int i;
861 for (i = 0; i < width; i++) {
862 AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 0) >> 4);
863 AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 4) >> 4);
864 }
865 }
866
867 static void read_xv36be_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
868 uint32_t *unused2, void *opq)
869 {
870 int i;
871 for (i = 0; i < width; i++)
872 AV_WN16(dst + i * 2, AV_RB16(src + i * 8 + 2) >> 4);
873 }
874
875
876 static void read_xv36be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
877 const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
878 {
879 int i;
880 for (i = 0; i < width; i++) {
881 AV_WN16(dstU + i * 2, AV_RB16(src + i * 8 + 0) >> 4);
882 AV_WN16(dstV + i * 2, AV_RB16(src + i * 8 + 4) >> 4);
883 }
884 }
885
886 /* This is almost identical to the previous, end exists only because
887 * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
888 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
889 uint32_t *unused, void *opq)
890 {
891 int i;
892 for (i = 0; i < width; i++)
893 dst[i] = src[2 * i + 1];
894 }
895
896 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
897 const uint8_t *src2, int width, uint32_t *unused, void *opq)
898 {
899 int i;
900 for (i = 0; i < width; i++) {
901 dstU[i] = src1[4 * i + 0];
902 dstV[i] = src1[4 * i + 2];
903 }
904 av_assert1(src1 == src2);
905 }
906
907 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
908 const uint8_t *src, int width)
909 {
910 int i;
911 for (i = 0; i < width; i++) {
912 dst1[i] = src[2 * i + 0];
913 dst2[i] = src[2 * i + 1];
914 }
915 }
916
917 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
918 const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
919 int width, uint32_t *unused, void *opq)
920 {
921 nvXXtoUV_c(dstU, dstV, src1, width);
922 }
923
924 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
925 const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
926 int width, uint32_t *unused, void *opq)
927 {
928 nvXXtoUV_c(dstV, dstU, src1, width);
929 }
930
931 #define p01x_uv_wrapper(bits, shift) \
932 static void p0 ## bits ## LEToUV_c(uint8_t *dstU, uint8_t *dstV, \
933 const uint8_t *unused0, \
934 const uint8_t *src1, \
935 const uint8_t *src2, int width, \
936 uint32_t *unused, void *opq) \
937 { \
938 int i; \
939 for (i = 0; i < width; i++) { \
940 AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0) >> shift); \
941 AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2) >> shift); \
942 } \
943 } \
944 \
945 static void p0 ## bits ## BEToUV_c(uint8_t *dstU, uint8_t *dstV, \
946 const uint8_t *unused0, \
947 const uint8_t *src1, \
948 const uint8_t *src2, int width, \
949 uint32_t *unused, void *opq) \
950 { \
951 int i; \
952 for (i = 0; i < width; i++) { \
953 AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0) >> shift); \
954 AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2) >> shift); \
955 } \
956 }
957
958 #define p01x_wrapper(bits, shift) \
959 static void p0 ## bits ## LEToY_c(uint8_t *dst, const uint8_t *src, \
960 const uint8_t *unused1, \
961 const uint8_t *unused2, int width, \
962 uint32_t *unused, void *opq) \
963 { \
964 int i; \
965 for (i = 0; i < width; i++) { \
966 AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> shift); \
967 } \
968 } \
969 \
970 static void p0 ## bits ## BEToY_c(uint8_t *dst, const uint8_t *src, \
971 const uint8_t *unused1, \
972 const uint8_t *unused2, int width, \
973 uint32_t *unused, void *opq) \
974 { \
975 int i; \
976 for (i = 0; i < width; i++) { \
977 AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> shift); \
978 } \
979 } \
980 p01x_uv_wrapper(bits, shift)
981
982 p01x_wrapper(10, 6)
983 p01x_wrapper(12, 4)
984 p01x_uv_wrapper(16, 0)
985
986 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
987 int width, uint32_t *rgb2yuv, void *opq)
988 {
989 int16_t *dst = (int16_t *)_dst;
990 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
991 int i;
992 for (i = 0; i < width; i++) {
993 int b = src[i * 3 + 0];
994 int g = src[i * 3 + 1];
995 int r = src[i * 3 + 2];
996
997 dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
998 }
999 }
1000
1001 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1002 const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1003 {
1004 int16_t *dstU = (int16_t *)_dstU;
1005 int16_t *dstV = (int16_t *)_dstV;
1006 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1007 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1008 int i;
1009 for (i = 0; i < width; i++) {
1010 int b = src1[3 * i + 0];
1011 int g = src1[3 * i + 1];
1012 int r = src1[3 * i + 2];
1013
1014 dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1015 dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1016 }
1017 av_assert1(src1 == src2);
1018 }
1019
1020 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1021 const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1022 {
1023 int16_t *dstU = (int16_t *)_dstU;
1024 int16_t *dstV = (int16_t *)_dstV;
1025 int i;
1026 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1027 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1028 for (i = 0; i < width; i++) {
1029 int b = src1[6 * i + 0] + src1[6 * i + 3];
1030 int g = src1[6 * i + 1] + src1[6 * i + 4];
1031 int r = src1[6 * i + 2] + src1[6 * i + 5];
1032
1033 dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1034 dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1035 }
1036 av_assert1(src1 == src2);
1037 }
1038
1039 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
1040 uint32_t *rgb2yuv, void *opq)
1041 {
1042 int16_t *dst = (int16_t *)_dst;
1043 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1044 int i;
1045 for (i = 0; i < width; i++) {
1046 int r = src[i * 3 + 0];
1047 int g = src[i * 3 + 1];
1048 int b = src[i * 3 + 2];
1049
1050 dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
1051 }
1052 }
1053
1054 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1055 const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1056 {
1057 int16_t *dstU = (int16_t *)_dstU;
1058 int16_t *dstV = (int16_t *)_dstV;
1059 int i;
1060 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1061 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1062 av_assert1(src1 == src2);
1063 for (i = 0; i < width; i++) {
1064 int r = src1[3 * i + 0];
1065 int g = src1[3 * i + 1];
1066 int b = src1[3 * i + 2];
1067
1068 dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1069 dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1070 }
1071 }
1072
1073 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1074 const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1075 {
1076 int16_t *dstU = (int16_t *)_dstU;
1077 int16_t *dstV = (int16_t *)_dstV;
1078 int i;
1079 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1080 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1081 av_assert1(src1 == src2);
1082 for (i = 0; i < width; i++) {
1083 int r = src1[6 * i + 0] + src1[6 * i + 3];
1084 int g = src1[6 * i + 1] + src1[6 * i + 4];
1085 int b = src1[6 * i + 2] + src1[6 * i + 5];
1086
1087 dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1088 dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1089 }
1090 }
1091
1092 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
1093 {
1094 uint16_t *dst = (uint16_t *)_dst;
1095 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1096 int i;
1097 for (i = 0; i < width; i++) {
1098 int g = src[0][i];
1099 int b = src[1][i];
1100 int r = src[2][i];
1101
1102 dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
1103 }
1104 }
1105
1106 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused, void *opq)
1107 {
1108 uint16_t *dst = (uint16_t *)_dst;
1109 int i;
1110 for (i = 0; i < width; i++)
1111 dst[i] = src[3][i] << 6;
1112 }
1113
1114 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
1115 {
1116 uint16_t *dstU = (uint16_t *)_dstU;
1117 uint16_t *dstV = (uint16_t *)_dstV;
1118 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1119 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1120 int i;
1121 for (i = 0; i < width; i++) {
1122 int g = src[0][i];
1123 int b = src[1][i];
1124 int r = src[2][i];
1125
1126 dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
1127 dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
1128 }
1129 }
1130
1131 #define rdpx(src) \
1132 (is_be ? AV_RB16(src) : AV_RL16(src))
1133 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
1134 int width, int bpc, int is_be, int32_t *rgb2yuv)
1135 {
1136 int i;
1137 const uint16_t **src = (const uint16_t **)_src;
1138 uint16_t *dst = (uint16_t *)_dst;
1139 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1140 int shift = bpc < 16 ? bpc : 14;
1141 for (i = 0; i < width; i++) {
1142 int g = rdpx(src[0] + i);
1143 int b = rdpx(src[1] + i);
1144 int r = rdpx(src[2] + i);
1145
1146 dst[i] = (ry*r + gy*g + by*b + (16 << (RGB2YUV_SHIFT + bpc - 8)) + (1 << (RGB2YUV_SHIFT + shift - 15))) >> (RGB2YUV_SHIFT + shift - 14);
1147 }
1148 }
1149
1150 static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
1151 int width, int bpc, int is_be, int32_t *rgb2yuv)
1152 {
1153 int i;
1154 const uint16_t **src = (const uint16_t **)_src;
1155 uint16_t *dst = (uint16_t *)_dst;
1156 int shift = bpc < 16 ? bpc : 14;
1157
1158 for (i = 0; i < width; i++) {
1159 dst[i] = rdpx(src[3] + i) << (14 - shift);
1160 }
1161 }
1162
1163 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
1164 const uint8_t *_src[4], int width,
1165 int bpc, int is_be, int32_t *rgb2yuv)
1166 {
1167 int i;
1168 const uint16_t **src = (const uint16_t **)_src;
1169 uint16_t *dstU = (uint16_t *)_dstU;
1170 uint16_t *dstV = (uint16_t *)_dstV;
1171 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1172 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1173 int shift = bpc < 16 ? bpc : 14;
1174 for (i = 0; i < width; i++) {
1175 int g = rdpx(src[0] + i);
1176 int b = rdpx(src[1] + i);
1177 int r = rdpx(src[2] + i);
1178
1179 dstU[i] = (ru*r + gu*g + bu*b + (128 << (RGB2YUV_SHIFT + bpc - 8)) + (1 << (RGB2YUV_SHIFT + shift - 15))) >> (RGB2YUV_SHIFT + shift - 14);
1180 dstV[i] = (rv*r + gv*g + bv*b + (128 << (RGB2YUV_SHIFT + bpc - 8)) + (1 << (RGB2YUV_SHIFT + shift - 15))) >> (RGB2YUV_SHIFT + shift - 14);
1181 }
1182 }
1183 #undef rdpx
1184
1185 #define rdpx(src) (is_be ? av_int2float(AV_RB32(src)): av_int2float(AV_RL32(src)))
1186
1187 static av_always_inline void planar_rgbf32_to_a(uint8_t *_dst, const uint8_t *_src[4], int width, int is_be, int32_t *rgb2yuv)
1188 {
1189 int i;
1190 const float **src = (const float **)_src;
1191 uint16_t *dst = (uint16_t *)_dst;
1192
1193 for (i = 0; i < width; i++) {
1194 dst[i] = lrintf(av_clipf(65535.0f * rdpx(src[3] + i), 0.0f, 65535.0f));
1195 }
1196 }
1197
1198 static av_always_inline void planar_rgbf32_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src[4], int width, int is_be, int32_t *rgb2yuv)
1199 {
1200 int i;
1201 const float **src = (const float **)_src;
1202 uint16_t *dstU = (uint16_t *)_dstU;
1203 uint16_t *dstV = (uint16_t *)_dstV;
1204 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1205 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1206
1207 for (i = 0; i < width; i++) {
1208 int g = lrintf(av_clipf(65535.0f * rdpx(src[0] + i), 0.0f, 65535.0f));
1209 int b = lrintf(av_clipf(65535.0f * rdpx(src[1] + i), 0.0f, 65535.0f));
1210 int r = lrintf(av_clipf(65535.0f * rdpx(src[2] + i), 0.0f, 65535.0f));
1211
1212 dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1213 dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1214 }
1215 }
1216
1217 static av_always_inline void planar_rgbf32_to_y(uint8_t *_dst, const uint8_t *_src[4], int width, int is_be, int32_t *rgb2yuv)
1218 {
1219 int i;
1220 const float **src = (const float **)_src;
1221 uint16_t *dst = (uint16_t *)_dst;
1222
1223 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1224
1225 for (i = 0; i < width; i++) {
1226 int g = lrintf(av_clipf(65535.0f * rdpx(src[0] + i), 0.0f, 65535.0f));
1227 int b = lrintf(av_clipf(65535.0f * rdpx(src[1] + i), 0.0f, 65535.0f));
1228 int r = lrintf(av_clipf(65535.0f * rdpx(src[2] + i), 0.0f, 65535.0f));
1229
1230 dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1231 }
1232 }
1233
1234 static av_always_inline void rgbf32_to_uv_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused1,
1235 const uint8_t *_src, const uint8_t *unused2,
1236 int width, int is_be, int32_t *rgb2yuv)
1237 {
1238 int i;
1239 const float *src = (const float *)_src;
1240 uint16_t *dstU = (uint16_t *)_dstU;
1241 uint16_t *dstV = (uint16_t *)_dstV;
1242 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1243 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1244
1245 for (i = 0; i < width; i++) {
1246 int r = lrintf(av_clipf(65535.0f * rdpx(&src[3*i]), 0.0f, 65535.0f));
1247 int g = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 1]), 0.0f, 65535.0f));
1248 int b = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 2]), 0.0f, 65535.0f));
1249
1250 dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1251 dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1252 }
1253 }
1254
1255 static av_always_inline void rgbf32_to_y_c(uint8_t *_dst, const uint8_t *_src,
1256 const uint8_t *unused1, const uint8_t *unused2,
1257 int width, int is_be, int32_t *rgb2yuv)
1258 {
1259 int i;
1260 const float *src = (const float *)_src;
1261 uint16_t *dst = (uint16_t *)_dst;
1262
1263 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1264
1265 for (i = 0; i < width; i++) {
1266 int r = lrintf(av_clipf(65535.0f * rdpx(&src[3*i]), 0.0f, 65535.0f));
1267 int g = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 1]), 0.0f, 65535.0f));
1268 int b = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 2]), 0.0f, 65535.0f));
1269
1270 dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1271 }
1272 }
1273
1274 static av_always_inline void grayf32ToY16_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
1275 const uint8_t *unused2, int width, int is_be, uint32_t *unused)
1276 {
1277 int i;
1278 const float *src = (const float *)_src;
1279 uint16_t *dst = (uint16_t *)_dst;
1280
1281 for (i = 0; i < width; ++i){
1282 dst[i] = lrintf(av_clipf(65535.0f * rdpx(src + i), 0.0f, 65535.0f));
1283 }
1284 }
1285
1286 #undef rdpx
1287
1288 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian) \
1289 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1290 int w, int32_t *rgb2yuv, void *opq) \
1291 { \
1292 planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv); \
1293 } \
1294 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1295 const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1296 void *opq) \
1297 { \
1298 planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
1299 } \
1300
1301 #define rgb9plus_planar_transparency_funcs(nbits) \
1302 static void planar_rgb##nbits##le_to_a(uint8_t *dst, const uint8_t *src[4], \
1303 int w, int32_t *rgb2yuv, \
1304 void *opq) \
1305 { \
1306 planar_rgb16_to_a(dst, src, w, nbits, 0, rgb2yuv); \
1307 } \
1308 static void planar_rgb##nbits##be_to_a(uint8_t *dst, const uint8_t *src[4], \
1309 int w, int32_t *rgb2yuv, \
1310 void *opq) \
1311 { \
1312 planar_rgb16_to_a(dst, src, w, nbits, 1, rgb2yuv); \
1313 }
1314
1315 #define rgb9plus_planar_funcs(nbits) \
1316 rgb9plus_planar_funcs_endian(nbits, le, 0) \
1317 rgb9plus_planar_funcs_endian(nbits, be, 1)
1318
1319 rgb9plus_planar_funcs(9)
1320 rgb9plus_planar_funcs(10)
1321 rgb9plus_planar_funcs(12)
1322 rgb9plus_planar_funcs(14)
1323 rgb9plus_planar_funcs(16)
1324
1325 rgb9plus_planar_transparency_funcs(10)
1326 rgb9plus_planar_transparency_funcs(12)
1327 rgb9plus_planar_transparency_funcs(14)
1328 rgb9plus_planar_transparency_funcs(16)
1329
1330 #define rgbf32_funcs_endian(endian_name, endian) \
1331 static void planar_rgbf32##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1332 int w, int32_t *rgb2yuv, void *opq) \
1333 { \
1334 planar_rgbf32_to_y(dst, src, w, endian, rgb2yuv); \
1335 } \
1336 static void planar_rgbf32##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1337 const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1338 void *opq) \
1339 { \
1340 planar_rgbf32_to_uv(dstU, dstV, src, w, endian, rgb2yuv); \
1341 } \
1342 static void planar_rgbf32##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4], \
1343 int w, int32_t *rgb2yuv, void *opq) \
1344 { \
1345 planar_rgbf32_to_a(dst, src, w, endian, rgb2yuv); \
1346 } \
1347 static void rgbf32##endian_name##_to_y_c(uint8_t *dst, const uint8_t *src, \
1348 const uint8_t *unused1, const uint8_t *unused2, \
1349 int w, uint32_t *rgb2yuv, void *opq) \
1350 { \
1351 rgbf32_to_y_c(dst, src, unused1, unused2, w, endian, rgb2yuv); \
1352 } \
1353 static void rgbf32##endian_name##_to_uv_c(uint8_t *dstU, uint8_t *dstV, \
1354 const uint8_t *unused1, \
1355 const uint8_t *src, const uint8_t *unused2, \
1356 int w, uint32_t *rgb2yuv, \
1357 void *opq) \
1358 { \
1359 rgbf32_to_uv_c(dstU, dstV, unused1, src, unused2, w, endian, rgb2yuv); \
1360 } \
1361 static void grayf32##endian_name##ToY16_c(uint8_t *dst, const uint8_t *src, \
1362 const uint8_t *unused1, const uint8_t *unused2, \
1363 int width, uint32_t *unused, void *opq) \
1364 { \
1365 grayf32ToY16_c(dst, src, unused1, unused2, width, endian, unused); \
1366 }
1367
1368 rgbf32_funcs_endian(le, 0)
1369 rgbf32_funcs_endian(be, 1)
1370
1371 #define rdpx(src) av_int2float(half2float(is_be ? AV_RB16(&src) : AV_RL16(&src), h2f_tbl))
1372 #define rdpx2(src) av_int2float(half2float(is_be ? AV_RB16(src) : AV_RL16(src), h2f_tbl))
1373
1374 static av_always_inline void planar_rgbf16_to_a(uint8_t *dst, const uint8_t *src[4], int width, int is_be, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1375 {
1376 int i;
1377
1378 for (i = 0; i < width; i++) {
1379 AV_WN16(dst + 2*i, lrintf(av_clipf(65535.0f * rdpx2(src[3] + 2*i), 0.0f, 65535.0f)));
1380 }
1381 }
1382
1383 static av_always_inline void planar_rgbf16_to_uv(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width, int is_be, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1384 {
1385 int i;
1386 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1387 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1388
1389 for (i = 0; i < width; i++) {
1390 int g = lrintf(av_clipf(65535.0f * rdpx2(src[0] + 2*i), 0.0f, 65535.0f));
1391 int b = lrintf(av_clipf(65535.0f * rdpx2(src[1] + 2*i), 0.0f, 65535.0f));
1392 int r = lrintf(av_clipf(65535.0f * rdpx2(src[2] + 2*i), 0.0f, 65535.0f));
1393
1394 AV_WN16(dstU + 2*i, (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1395 AV_WN16(dstV + 2*i, (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1396 }
1397 }
1398
1399 static av_always_inline void planar_rgbf16_to_y(uint8_t *dst, const uint8_t *src[4], int width, int is_be, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1400 {
1401 int i;
1402
1403 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1404
1405 for (i = 0; i < width; i++) {
1406 int g = lrintf(av_clipf(65535.0f * rdpx2(src[0] + 2*i), 0.0f, 65535.0f));
1407 int b = lrintf(av_clipf(65535.0f * rdpx2(src[1] + 2*i), 0.0f, 65535.0f));
1408 int r = lrintf(av_clipf(65535.0f * rdpx2(src[2] + 2*i), 0.0f, 65535.0f));
1409
1410 AV_WN16(dst + 2*i, (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1411 }
1412 }
1413
1414 static av_always_inline void grayf16ToY16_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
1415 const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
1416 {
1417 int i;
1418
1419 for (i = 0; i < width; ++i){
1420 AV_WN16(dst + 2*i, lrintf(av_clipf(65535.0f * rdpx2(src + 2*i), 0.0f, 65535.0f)));
1421 }
1422 }
1423
1424 static av_always_inline void rgbaf16ToUV_half_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1425 const uint16_t *src, int width,
1426 int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1427 {
1428 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1429 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1430 int i;
1431 for (i = 0; i < width; i++) {
1432 int r = (lrintf(av_clipf(65535.0f * rdpx(src[i*8+0]), 0.0f, 65535.0f)) +
1433 lrintf(av_clipf(65535.0f * rdpx(src[i*8+4]), 0.0f, 65535.0f))) >> 1;
1434 int g = (lrintf(av_clipf(65535.0f * rdpx(src[i*8+1]), 0.0f, 65535.0f)) +
1435 lrintf(av_clipf(65535.0f * rdpx(src[i*8+5]), 0.0f, 65535.0f))) >> 1;
1436 int b = (lrintf(av_clipf(65535.0f * rdpx(src[i*8+2]), 0.0f, 65535.0f)) +
1437 lrintf(av_clipf(65535.0f * rdpx(src[i*8+6]), 0.0f, 65535.0f))) >> 1;
1438
1439 dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1440 dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1441 }
1442 }
1443
1444 static av_always_inline void rgbaf16ToUV_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1445 const uint16_t *src, int width,
1446 int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1447 {
1448 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1449 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1450 int i;
1451 for (i = 0; i < width; i++) {
1452 int r = lrintf(av_clipf(65535.0f * rdpx(src[i*4+0]), 0.0f, 65535.0f));
1453 int g = lrintf(av_clipf(65535.0f * rdpx(src[i*4+1]), 0.0f, 65535.0f));
1454 int b = lrintf(av_clipf(65535.0f * rdpx(src[i*4+2]), 0.0f, 65535.0f));
1455
1456 dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1457 dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1458 }
1459 }
1460
1461 static av_always_inline void rgbaf16ToY_endian(uint16_t *dst, const uint16_t *src, int is_be,
1462 int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1463 {
1464 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1465 int i;
1466 for (i = 0; i < width; i++) {
1467 int r = lrintf(av_clipf(65535.0f * rdpx(src[i*4+0]), 0.0f, 65535.0f));
1468 int g = lrintf(av_clipf(65535.0f * rdpx(src[i*4+1]), 0.0f, 65535.0f));
1469 int b = lrintf(av_clipf(65535.0f * rdpx(src[i*4+2]), 0.0f, 65535.0f));
1470
1471 dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1472 }
1473 }
1474
1475 static av_always_inline void rgbaf16ToA_endian(uint16_t *dst, const uint16_t *src, int is_be,
1476 int width, Half2FloatTables *h2f_tbl)
1477 {
1478 int i;
1479 for (i=0; i<width; i++) {
1480 dst[i] = lrintf(av_clipf(65535.0f * rdpx(src[i*4+3]), 0.0f, 65535.0f));
1481 }
1482 }
1483
1484 static av_always_inline void rgbf16ToUV_half_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1485 const uint16_t *src, int width,
1486 int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1487 {
1488 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1489 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1490 int i;
1491 for (i = 0; i < width; i++) {
1492 int r = (lrintf(av_clipf(65535.0f * rdpx(src[i*6+0]), 0.0f, 65535.0f)) +
1493 lrintf(av_clipf(65535.0f * rdpx(src[i*6+3]), 0.0f, 65535.0f))) >> 1;
1494 int g = (lrintf(av_clipf(65535.0f * rdpx(src[i*6+1]), 0.0f, 65535.0f)) +
1495 lrintf(av_clipf(65535.0f * rdpx(src[i*6+4]), 0.0f, 65535.0f))) >> 1;
1496 int b = (lrintf(av_clipf(65535.0f * rdpx(src[i*6+2]), 0.0f, 65535.0f)) +
1497 lrintf(av_clipf(65535.0f * rdpx(src[i*6+5]), 0.0f, 65535.0f))) >> 1;
1498
1499 dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1500 dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1501 }
1502 }
1503
1504 static av_always_inline void rgbf16ToUV_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1505 const uint16_t *src, int width,
1506 int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1507 {
1508 int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1509 int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1510 int i;
1511 for (i = 0; i < width; i++) {
1512 int r = lrintf(av_clipf(65535.0f * rdpx(src[i*3+0]), 0.0f, 65535.0f));
1513 int g = lrintf(av_clipf(65535.0f * rdpx(src[i*3+1]), 0.0f, 65535.0f));
1514 int b = lrintf(av_clipf(65535.0f * rdpx(src[i*3+2]), 0.0f, 65535.0f));
1515
1516 dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1517 dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1518 }
1519 }
1520
1521 static av_always_inline void rgbf16ToY_endian(uint16_t *dst, const uint16_t *src, int is_be,
1522 int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1523 {
1524 int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1525 int i;
1526 for (i = 0; i < width; i++) {
1527 int r = lrintf(av_clipf(65535.0f * rdpx(src[i*3+0]), 0.0f, 65535.0f));
1528 int g = lrintf(av_clipf(65535.0f * rdpx(src[i*3+1]), 0.0f, 65535.0f));
1529 int b = lrintf(av_clipf(65535.0f * rdpx(src[i*3+2]), 0.0f, 65535.0f));
1530
1531 dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1532 }
1533 }
1534
1535 #undef rdpx
1536
1537 #define rgbaf16_funcs_endian(endian_name, endian) \
1538 static void planar_rgbf16##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1539 int w, int32_t *rgb2yuv, void *opq) \
1540 { \
1541 planar_rgbf16_to_y(dst, src, w, endian, rgb2yuv, opq); \
1542 } \
1543 static void planar_rgbf16##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1544 const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1545 void *opq) \
1546 { \
1547 planar_rgbf16_to_uv(dstU, dstV, src, w, endian, rgb2yuv, opq); \
1548 } \
1549 static void planar_rgbf16##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4], \
1550 int w, int32_t *rgb2yuv, void *opq) \
1551 { \
1552 planar_rgbf16_to_a(dst, src, w, endian, rgb2yuv, opq); \
1553 } \
1554 static void grayf16##endian_name##ToY16_c(uint8_t *dst, const uint8_t *src, \
1555 const uint8_t *unused1, const uint8_t *unused2, \
1556 int width, uint32_t *unused, void *opq) \
1557 { \
1558 grayf16ToY16_c(dst, src, unused1, unused2, width, endian, unused, opq); \
1559 } \
1560 static void rgbaf16##endian_name##ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1561 const uint8_t *src1, const uint8_t *src2, \
1562 int width, uint32_t *_rgb2yuv, void *opq) \
1563 { \
1564 const uint16_t *src = (const uint16_t*)src1; \
1565 uint16_t *dstU = (uint16_t*)_dstU; \
1566 uint16_t *dstV = (uint16_t*)_dstV; \
1567 int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1568 av_assert1(src1==src2); \
1569 rgbaf16ToUV_half_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1570 } \
1571 static void rgbaf16##endian_name##ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1572 const uint8_t *src1, const uint8_t *src2, \
1573 int width, uint32_t *_rgb2yuv, void *opq) \
1574 { \
1575 const uint16_t *src = (const uint16_t*)src1; \
1576 uint16_t *dstU = (uint16_t*)_dstU; \
1577 uint16_t *dstV = (uint16_t*)_dstV; \
1578 int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1579 av_assert1(src1==src2); \
1580 rgbaf16ToUV_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1581 } \
1582 static void rgbaf16##endian_name##ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, \
1583 const uint8_t *unused1, int width, uint32_t *_rgb2yuv, void *opq) \
1584 { \
1585 const uint16_t *src = (const uint16_t*)_src; \
1586 uint16_t *dst = (uint16_t*)_dst; \
1587 int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1588 rgbaf16ToY_endian(dst, src, endian, width, rgb2yuv, opq); \
1589 } \
1590 static void rgbaf16##endian_name##ToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, \
1591 const uint8_t *unused1, int width, uint32_t *unused2, void *opq) \
1592 { \
1593 const uint16_t *src = (const uint16_t*)_src; \
1594 uint16_t *dst = (uint16_t*)_dst; \
1595 rgbaf16ToA_endian(dst, src, endian, width, opq); \
1596 } \
1597 static void rgbf16##endian_name##ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1598 const uint8_t *src1, const uint8_t *src2, \
1599 int width, uint32_t *_rgb2yuv, void *opq) \
1600 { \
1601 const uint16_t *src = (const uint16_t*)src1; \
1602 uint16_t *dstU = (uint16_t*)_dstU; \
1603 uint16_t *dstV = (uint16_t*)_dstV; \
1604 int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1605 av_assert1(src1==src2); \
1606 rgbf16ToUV_half_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1607 } \
1608 static void rgbf16##endian_name##ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1609 const uint8_t *src1, const uint8_t *src2, \
1610 int width, uint32_t *_rgb2yuv, void *opq) \
1611 { \
1612 const uint16_t *src = (const uint16_t*)src1; \
1613 uint16_t *dstU = (uint16_t*)_dstU; \
1614 uint16_t *dstV = (uint16_t*)_dstV; \
1615 int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1616 av_assert1(src1==src2); \
1617 rgbf16ToUV_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1618 } \
1619 static void rgbf16##endian_name##ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, \
1620 const uint8_t *unused1, int width, uint32_t *_rgb2yuv, void *opq) \
1621 { \
1622 const uint16_t *src = (const uint16_t*)_src; \
1623 uint16_t *dst = (uint16_t*)_dst; \
1624 int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1625 rgbf16ToY_endian(dst, src, endian, width, rgb2yuv, opq); \
1626 } \
1627
1628 rgbaf16_funcs_endian(le, 0)
1629 rgbaf16_funcs_endian(be, 1)
1630
1631 av_cold void ff_sws_init_input_funcs(SwsInternal *c,
1632 planar1_YV12_fn *lumToYV12,
1633 planar1_YV12_fn *alpToYV12,
1634 planar2_YV12_fn *chrToYV12,
1635 planarX_YV12_fn *readLumPlanar,
1636 planarX_YV12_fn *readAlpPlanar,
1637 planarX2_YV12_fn *readChrPlanar)
1638 {
1639 enum AVPixelFormat srcFormat = c->opts.src_format;
1640
1641 *chrToYV12 = NULL;
1642 switch (srcFormat) {
1643 case AV_PIX_FMT_YUYV422:
1644 *chrToYV12 = yuy2ToUV_c;
1645 break;
1646 case AV_PIX_FMT_YVYU422:
1647 *chrToYV12 = yvy2ToUV_c;
1648 break;
1649 case AV_PIX_FMT_UYVY422:
1650 *chrToYV12 = uyvyToUV_c;
1651 break;
1652 case AV_PIX_FMT_VYU444:
1653 *chrToYV12 = vyuToUV_c;
1654 break;
1655 case AV_PIX_FMT_NV12:
1656 case AV_PIX_FMT_NV16:
1657 case AV_PIX_FMT_NV24:
1658 *chrToYV12 = nv12ToUV_c;
1659 break;
1660 case AV_PIX_FMT_NV21:
1661 case AV_PIX_FMT_NV42:
1662 *chrToYV12 = nv21ToUV_c;
1663 break;
1664 case AV_PIX_FMT_RGB8:
1665 case AV_PIX_FMT_BGR8:
1666 case AV_PIX_FMT_PAL8:
1667 case AV_PIX_FMT_BGR4_BYTE:
1668 case AV_PIX_FMT_RGB4_BYTE:
1669 *chrToYV12 = palToUV_c;
1670 break;
1671 case AV_PIX_FMT_GBRP9LE:
1672 *readChrPlanar = planar_rgb9le_to_uv;
1673 break;
1674 case AV_PIX_FMT_GBRAP10LE:
1675 case AV_PIX_FMT_GBRP10LE:
1676 *readChrPlanar = planar_rgb10le_to_uv;
1677 break;
1678 case AV_PIX_FMT_GBRAP12LE:
1679 case AV_PIX_FMT_GBRP12LE:
1680 *readChrPlanar = planar_rgb12le_to_uv;
1681 break;
1682 case AV_PIX_FMT_GBRAP14LE:
1683 case AV_PIX_FMT_GBRP14LE:
1684 *readChrPlanar = planar_rgb14le_to_uv;
1685 break;
1686 case AV_PIX_FMT_GBRAP16LE:
1687 case AV_PIX_FMT_GBRP16LE:
1688 *readChrPlanar = planar_rgb16le_to_uv;
1689 break;
1690 case AV_PIX_FMT_GBRAPF32LE:
1691 case AV_PIX_FMT_GBRPF32LE:
1692 *readChrPlanar = planar_rgbf32le_to_uv;
1693 break;
1694 case AV_PIX_FMT_GBRAPF16LE:
1695 case AV_PIX_FMT_GBRPF16LE:
1696 *readChrPlanar = planar_rgbf16le_to_uv;
1697 break;
1698 case AV_PIX_FMT_GBRP9BE:
1699 *readChrPlanar = planar_rgb9be_to_uv;
1700 break;
1701 case AV_PIX_FMT_GBRAP10BE:
1702 case AV_PIX_FMT_GBRP10BE:
1703 *readChrPlanar = planar_rgb10be_to_uv;
1704 break;
1705 case AV_PIX_FMT_GBRAP12BE:
1706 case AV_PIX_FMT_GBRP12BE:
1707 *readChrPlanar = planar_rgb12be_to_uv;
1708 break;
1709 case AV_PIX_FMT_GBRAP14BE:
1710 case AV_PIX_FMT_GBRP14BE:
1711 *readChrPlanar = planar_rgb14be_to_uv;
1712 break;
1713 case AV_PIX_FMT_GBRAP16BE:
1714 case AV_PIX_FMT_GBRP16BE:
1715 *readChrPlanar = planar_rgb16be_to_uv;
1716 break;
1717 case AV_PIX_FMT_GBRAPF32BE:
1718 case AV_PIX_FMT_GBRPF32BE:
1719 *readChrPlanar = planar_rgbf32be_to_uv;
1720 break;
1721 case AV_PIX_FMT_GBRAPF16BE:
1722 case AV_PIX_FMT_GBRPF16BE:
1723 *readChrPlanar = planar_rgbf16be_to_uv;
1724 break;
1725 case AV_PIX_FMT_GBRAP:
1726 case AV_PIX_FMT_GBRP:
1727 *readChrPlanar = planar_rgb_to_uv;
1728 break;
1729 #if HAVE_BIGENDIAN
1730 case AV_PIX_FMT_YUV420P9LE:
1731 case AV_PIX_FMT_YUV422P9LE:
1732 case AV_PIX_FMT_YUV444P9LE:
1733 case AV_PIX_FMT_YUV420P10LE:
1734 case AV_PIX_FMT_YUV422P10LE:
1735 case AV_PIX_FMT_YUV440P10LE:
1736 case AV_PIX_FMT_YUV444P10LE:
1737 case AV_PIX_FMT_YUV420P12LE:
1738 case AV_PIX_FMT_YUV422P12LE:
1739 case AV_PIX_FMT_YUV440P12LE:
1740 case AV_PIX_FMT_YUV444P12LE:
1741 case AV_PIX_FMT_YUV420P14LE:
1742 case AV_PIX_FMT_YUV422P14LE:
1743 case AV_PIX_FMT_YUV444P14LE:
1744 case AV_PIX_FMT_YUV420P16LE:
1745 case AV_PIX_FMT_YUV422P16LE:
1746 case AV_PIX_FMT_YUV444P16LE:
1747
1748 case AV_PIX_FMT_YUVA420P9LE:
1749 case AV_PIX_FMT_YUVA422P9LE:
1750 case AV_PIX_FMT_YUVA444P9LE:
1751 case AV_PIX_FMT_YUVA420P10LE:
1752 case AV_PIX_FMT_YUVA422P10LE:
1753 case AV_PIX_FMT_YUVA444P10LE:
1754 case AV_PIX_FMT_YUVA422P12LE:
1755 case AV_PIX_FMT_YUVA444P12LE:
1756 case AV_PIX_FMT_YUVA420P16LE:
1757 case AV_PIX_FMT_YUVA422P16LE:
1758 case AV_PIX_FMT_YUVA444P16LE:
1759 *chrToYV12 = bswap16UV_c;
1760 break;
1761 #else
1762 case AV_PIX_FMT_YUV420P9BE:
1763 case AV_PIX_FMT_YUV422P9BE:
1764 case AV_PIX_FMT_YUV444P9BE:
1765 case AV_PIX_FMT_YUV420P10BE:
1766 case AV_PIX_FMT_YUV422P10BE:
1767 case AV_PIX_FMT_YUV440P10BE:
1768 case AV_PIX_FMT_YUV444P10BE:
1769 case AV_PIX_FMT_YUV420P12BE:
1770 case AV_PIX_FMT_YUV422P12BE:
1771 case AV_PIX_FMT_YUV440P12BE:
1772 case AV_PIX_FMT_YUV444P12BE:
1773 case AV_PIX_FMT_YUV420P14BE:
1774 case AV_PIX_FMT_YUV422P14BE:
1775 case AV_PIX_FMT_YUV444P14BE:
1776 case AV_PIX_FMT_YUV420P16BE:
1777 case AV_PIX_FMT_YUV422P16BE:
1778 case AV_PIX_FMT_YUV444P16BE:
1779
1780 case AV_PIX_FMT_YUVA420P9BE:
1781 case AV_PIX_FMT_YUVA422P9BE:
1782 case AV_PIX_FMT_YUVA444P9BE:
1783 case AV_PIX_FMT_YUVA420P10BE:
1784 case AV_PIX_FMT_YUVA422P10BE:
1785 case AV_PIX_FMT_YUVA444P10BE:
1786 case AV_PIX_FMT_YUVA422P12BE:
1787 case AV_PIX_FMT_YUVA444P12BE:
1788 case AV_PIX_FMT_YUVA420P16BE:
1789 case AV_PIX_FMT_YUVA422P16BE:
1790 case AV_PIX_FMT_YUVA444P16BE:
1791 *chrToYV12 = bswap16UV_c;
1792 break;
1793 #endif
1794 case AV_PIX_FMT_VUYA:
1795 case AV_PIX_FMT_VUYX:
1796 *chrToYV12 = read_vuyx_UV_c;
1797 break;
1798 case AV_PIX_FMT_XV30LE:
1799 *chrToYV12 = read_xv30le_UV_c;
1800 break;
1801 case AV_PIX_FMT_V30XLE:
1802 *chrToYV12 = read_v30xle_UV_c;
1803 break;
1804 case AV_PIX_FMT_AYUV:
1805 *chrToYV12 = read_ayuv_UV_c;
1806 break;
1807 case AV_PIX_FMT_AYUV64LE:
1808 *chrToYV12 = read_ayuv64le_UV_c;
1809 break;
1810 case AV_PIX_FMT_AYUV64BE:
1811 *chrToYV12 = read_ayuv64be_UV_c;
1812 break;
1813 case AV_PIX_FMT_UYVA:
1814 *chrToYV12 = read_uyva_UV_c;
1815 break;
1816 case AV_PIX_FMT_XV36LE:
1817 *chrToYV12 = read_xv36le_UV_c;
1818 break;
1819 case AV_PIX_FMT_XV36BE:
1820 *chrToYV12 = read_xv36be_UV_c;
1821 break;
1822 case AV_PIX_FMT_XV48LE:
1823 *chrToYV12 = read_xv48le_UV_c;
1824 break;
1825 case AV_PIX_FMT_XV48BE:
1826 *chrToYV12 = read_xv48be_UV_c;
1827 break;
1828 case AV_PIX_FMT_P010LE:
1829 case AV_PIX_FMT_P210LE:
1830 case AV_PIX_FMT_P410LE:
1831 *chrToYV12 = p010LEToUV_c;
1832 break;
1833 case AV_PIX_FMT_P010BE:
1834 case AV_PIX_FMT_P210BE:
1835 case AV_PIX_FMT_P410BE:
1836 *chrToYV12 = p010BEToUV_c;
1837 break;
1838 case AV_PIX_FMT_P012LE:
1839 case AV_PIX_FMT_P212LE:
1840 case AV_PIX_FMT_P412LE:
1841 *chrToYV12 = p012LEToUV_c;
1842 break;
1843 case AV_PIX_FMT_P012BE:
1844 case AV_PIX_FMT_P212BE:
1845 case AV_PIX_FMT_P412BE:
1846 *chrToYV12 = p012BEToUV_c;
1847 break;
1848 case AV_PIX_FMT_P016LE:
1849 case AV_PIX_FMT_P216LE:
1850 case AV_PIX_FMT_P416LE:
1851 *chrToYV12 = p016LEToUV_c;
1852 break;
1853 case AV_PIX_FMT_P016BE:
1854 case AV_PIX_FMT_P216BE:
1855 case AV_PIX_FMT_P416BE:
1856 *chrToYV12 = p016BEToUV_c;
1857 break;
1858 case AV_PIX_FMT_Y210LE:
1859 *chrToYV12 = y210le_UV_c;
1860 break;
1861 case AV_PIX_FMT_Y212LE:
1862 *chrToYV12 = y212le_UV_c;
1863 break;
1864 case AV_PIX_FMT_Y216LE:
1865 *chrToYV12 = y216le_UV_c;
1866 break;
1867 case AV_PIX_FMT_RGBF32LE:
1868 *chrToYV12 = rgbf32le_to_uv_c;
1869 break;
1870 case AV_PIX_FMT_RGBF32BE:
1871 *chrToYV12 = rgbf32be_to_uv_c;
1872 break;
1873 }
1874 if (c->chrSrcHSubSample) {
1875 switch (srcFormat) {
1876 case AV_PIX_FMT_RGBA64BE:
1877 *chrToYV12 = rgb64BEToUV_half_c;
1878 break;
1879 case AV_PIX_FMT_RGBA64LE:
1880 *chrToYV12 = rgb64LEToUV_half_c;
1881 break;
1882 case AV_PIX_FMT_BGRA64BE:
1883 *chrToYV12 = bgr64BEToUV_half_c;
1884 break;
1885 case AV_PIX_FMT_BGRA64LE:
1886 *chrToYV12 = bgr64LEToUV_half_c;
1887 break;
1888 case AV_PIX_FMT_RGB48BE:
1889 *chrToYV12 = rgb48BEToUV_half_c;
1890 break;
1891 case AV_PIX_FMT_RGB48LE:
1892 *chrToYV12 = rgb48LEToUV_half_c;
1893 break;
1894 case AV_PIX_FMT_BGR48BE:
1895 *chrToYV12 = bgr48BEToUV_half_c;
1896 break;
1897 case AV_PIX_FMT_BGR48LE:
1898 *chrToYV12 = bgr48LEToUV_half_c;
1899 break;
1900 case AV_PIX_FMT_RGB32:
1901 *chrToYV12 = bgr32ToUV_half_c;
1902 break;
1903 case AV_PIX_FMT_RGB32_1:
1904 *chrToYV12 = bgr321ToUV_half_c;
1905 break;
1906 case AV_PIX_FMT_BGR24:
1907 *chrToYV12 = bgr24ToUV_half_c;
1908 break;
1909 case AV_PIX_FMT_BGR565LE:
1910 *chrToYV12 = bgr16leToUV_half_c;
1911 break;
1912 case AV_PIX_FMT_BGR565BE:
1913 *chrToYV12 = bgr16beToUV_half_c;
1914 break;
1915 case AV_PIX_FMT_BGR555LE:
1916 *chrToYV12 = bgr15leToUV_half_c;
1917 break;
1918 case AV_PIX_FMT_BGR555BE:
1919 *chrToYV12 = bgr15beToUV_half_c;
1920 break;
1921 case AV_PIX_FMT_GBRAP:
1922 case AV_PIX_FMT_GBRP:
1923 *chrToYV12 = gbr24pToUV_half_c;
1924 break;
1925 case AV_PIX_FMT_BGR444LE:
1926 *chrToYV12 = bgr12leToUV_half_c;
1927 break;
1928 case AV_PIX_FMT_BGR444BE:
1929 *chrToYV12 = bgr12beToUV_half_c;
1930 break;
1931 case AV_PIX_FMT_BGR32:
1932 *chrToYV12 = rgb32ToUV_half_c;
1933 break;
1934 case AV_PIX_FMT_BGR32_1:
1935 *chrToYV12 = rgb321ToUV_half_c;
1936 break;
1937 case AV_PIX_FMT_RGB24:
1938 *chrToYV12 = rgb24ToUV_half_c;
1939 break;
1940 case AV_PIX_FMT_RGB565LE:
1941 *chrToYV12 = rgb16leToUV_half_c;
1942 break;
1943 case AV_PIX_FMT_RGB565BE:
1944 *chrToYV12 = rgb16beToUV_half_c;
1945 break;
1946 case AV_PIX_FMT_RGB555LE:
1947 *chrToYV12 = rgb15leToUV_half_c;
1948 break;
1949 case AV_PIX_FMT_RGB555BE:
1950 *chrToYV12 = rgb15beToUV_half_c;
1951 break;
1952 case AV_PIX_FMT_RGB444LE:
1953 *chrToYV12 = rgb12leToUV_half_c;
1954 break;
1955 case AV_PIX_FMT_RGB444BE:
1956 *chrToYV12 = rgb12beToUV_half_c;
1957 break;
1958 case AV_PIX_FMT_X2RGB10LE:
1959 *chrToYV12 = rgb30leToUV_half_c;
1960 break;
1961 case AV_PIX_FMT_X2BGR10LE:
1962 *chrToYV12 = bgr30leToUV_half_c;
1963 break;
1964 case AV_PIX_FMT_RGBAF16BE:
1965 *chrToYV12 = rgbaf16beToUV_half_c;
1966 break;
1967 case AV_PIX_FMT_RGBAF16LE:
1968 *chrToYV12 = rgbaf16leToUV_half_c;
1969 break;
1970 case AV_PIX_FMT_RGBF16BE:
1971 *chrToYV12 = rgbf16beToUV_half_c;
1972 break;
1973 case AV_PIX_FMT_RGBF16LE:
1974 *chrToYV12 = rgbf16leToUV_half_c;
1975 break;
1976 }
1977 } else {
1978 switch (srcFormat) {
1979 case AV_PIX_FMT_RGBA64BE:
1980 *chrToYV12 = rgb64BEToUV_c;
1981 break;
1982 case AV_PIX_FMT_RGBA64LE:
1983 *chrToYV12 = rgb64LEToUV_c;
1984 break;
1985 case AV_PIX_FMT_BGRA64BE:
1986 *chrToYV12 = bgr64BEToUV_c;
1987 break;
1988 case AV_PIX_FMT_BGRA64LE:
1989 *chrToYV12 = bgr64LEToUV_c;
1990 break;
1991 case AV_PIX_FMT_RGB48BE:
1992 *chrToYV12 = rgb48BEToUV_c;
1993 break;
1994 case AV_PIX_FMT_RGB48LE:
1995 *chrToYV12 = rgb48LEToUV_c;
1996 break;
1997 case AV_PIX_FMT_BGR48BE:
1998 *chrToYV12 = bgr48BEToUV_c;
1999 break;
2000 case AV_PIX_FMT_BGR48LE:
2001 *chrToYV12 = bgr48LEToUV_c;
2002 break;
2003 case AV_PIX_FMT_RGB32:
2004 *chrToYV12 = bgr32ToUV_c;
2005 break;
2006 case AV_PIX_FMT_RGB32_1:
2007 *chrToYV12 = bgr321ToUV_c;
2008 break;
2009 case AV_PIX_FMT_BGR24:
2010 *chrToYV12 = bgr24ToUV_c;
2011 break;
2012 case AV_PIX_FMT_BGR565LE:
2013 *chrToYV12 = bgr16leToUV_c;
2014 break;
2015 case AV_PIX_FMT_BGR565BE:
2016 *chrToYV12 = bgr16beToUV_c;
2017 break;
2018 case AV_PIX_FMT_BGR555LE:
2019 *chrToYV12 = bgr15leToUV_c;
2020 break;
2021 case AV_PIX_FMT_BGR555BE:
2022 *chrToYV12 = bgr15beToUV_c;
2023 break;
2024 case AV_PIX_FMT_BGR444LE:
2025 *chrToYV12 = bgr12leToUV_c;
2026 break;
2027 case AV_PIX_FMT_BGR444BE:
2028 *chrToYV12 = bgr12beToUV_c;
2029 break;
2030 case AV_PIX_FMT_BGR32:
2031 *chrToYV12 = rgb32ToUV_c;
2032 break;
2033 case AV_PIX_FMT_BGR32_1:
2034 *chrToYV12 = rgb321ToUV_c;
2035 break;
2036 case AV_PIX_FMT_RGB24:
2037 *chrToYV12 = rgb24ToUV_c;
2038 break;
2039 case AV_PIX_FMT_RGB565LE:
2040 *chrToYV12 = rgb16leToUV_c;
2041 break;
2042 case AV_PIX_FMT_RGB565BE:
2043 *chrToYV12 = rgb16beToUV_c;
2044 break;
2045 case AV_PIX_FMT_RGB555LE:
2046 *chrToYV12 = rgb15leToUV_c;
2047 break;
2048 case AV_PIX_FMT_RGB555BE:
2049 *chrToYV12 = rgb15beToUV_c;
2050 break;
2051 case AV_PIX_FMT_RGB444LE:
2052 *chrToYV12 = rgb12leToUV_c;
2053 break;
2054 case AV_PIX_FMT_RGB444BE:
2055 *chrToYV12 = rgb12beToUV_c;
2056 break;
2057 case AV_PIX_FMT_X2RGB10LE:
2058 *chrToYV12 = rgb30leToUV_c;
2059 break;
2060 case AV_PIX_FMT_X2BGR10LE:
2061 *chrToYV12 = bgr30leToUV_c;
2062 break;
2063 case AV_PIX_FMT_RGBAF16BE:
2064 *chrToYV12 = rgbaf16beToUV_c;
2065 break;
2066 case AV_PIX_FMT_RGBAF16LE:
2067 *chrToYV12 = rgbaf16leToUV_c;
2068 break;
2069 case AV_PIX_FMT_RGBF16BE:
2070 *chrToYV12 = rgbf16beToUV_c;
2071 break;
2072 case AV_PIX_FMT_RGBF16LE:
2073 *chrToYV12 = rgbf16leToUV_c;
2074 break;
2075 }
2076 }
2077
2078 *lumToYV12 = NULL;
2079 *alpToYV12 = NULL;
2080 switch (srcFormat) {
2081 case AV_PIX_FMT_GBRP9LE:
2082 *readLumPlanar = planar_rgb9le_to_y;
2083 break;
2084 case AV_PIX_FMT_GBRAP10LE:
2085 *readAlpPlanar = planar_rgb10le_to_a;
2086 case AV_PIX_FMT_GBRP10LE:
2087 *readLumPlanar = planar_rgb10le_to_y;
2088 break;
2089 case AV_PIX_FMT_GBRAP12LE:
2090 *readAlpPlanar = planar_rgb12le_to_a;
2091 case AV_PIX_FMT_GBRP12LE:
2092 *readLumPlanar = planar_rgb12le_to_y;
2093 break;
2094 case AV_PIX_FMT_GBRAP14LE:
2095 *readAlpPlanar = planar_rgb14le_to_a;
2096 case AV_PIX_FMT_GBRP14LE:
2097 *readLumPlanar = planar_rgb14le_to_y;
2098 break;
2099 case AV_PIX_FMT_GBRAP16LE:
2100 *readAlpPlanar = planar_rgb16le_to_a;
2101 case AV_PIX_FMT_GBRP16LE:
2102 *readLumPlanar = planar_rgb16le_to_y;
2103 break;
2104 case AV_PIX_FMT_GBRAPF32LE:
2105 *readAlpPlanar = planar_rgbf32le_to_a;
2106 case AV_PIX_FMT_GBRPF32LE:
2107 *readLumPlanar = planar_rgbf32le_to_y;
2108 break;
2109 case AV_PIX_FMT_GBRAPF16LE:
2110 *readAlpPlanar = planar_rgbf16le_to_a;
2111 case AV_PIX_FMT_GBRPF16LE:
2112 *readLumPlanar = planar_rgbf16le_to_y;
2113 break;
2114 case AV_PIX_FMT_GBRP9BE:
2115 *readLumPlanar = planar_rgb9be_to_y;
2116 break;
2117 case AV_PIX_FMT_GBRAP10BE:
2118 *readAlpPlanar = planar_rgb10be_to_a;
2119 case AV_PIX_FMT_GBRP10BE:
2120 *readLumPlanar = planar_rgb10be_to_y;
2121 break;
2122 case AV_PIX_FMT_GBRAP12BE:
2123 *readAlpPlanar = planar_rgb12be_to_a;
2124 case AV_PIX_FMT_GBRP12BE:
2125 *readLumPlanar = planar_rgb12be_to_y;
2126 break;
2127 case AV_PIX_FMT_GBRAP14BE:
2128 *readAlpPlanar = planar_rgb14be_to_a;
2129 case AV_PIX_FMT_GBRP14BE:
2130 *readLumPlanar = planar_rgb14be_to_y;
2131 break;
2132 case AV_PIX_FMT_GBRAP16BE:
2133 *readAlpPlanar = planar_rgb16be_to_a;
2134 case AV_PIX_FMT_GBRP16BE:
2135 *readLumPlanar = planar_rgb16be_to_y;
2136 break;
2137 case AV_PIX_FMT_GBRAPF32BE:
2138 *readAlpPlanar = planar_rgbf32be_to_a;
2139 case AV_PIX_FMT_GBRPF32BE:
2140 *readLumPlanar = planar_rgbf32be_to_y;
2141 break;
2142 case AV_PIX_FMT_GBRAPF16BE:
2143 *readAlpPlanar = planar_rgbf16be_to_a;
2144 case AV_PIX_FMT_GBRPF16BE:
2145 *readLumPlanar = planar_rgbf16be_to_y;
2146 break;
2147 case AV_PIX_FMT_GBRAP:
2148 *readAlpPlanar = planar_rgb_to_a;
2149 case AV_PIX_FMT_GBRP:
2150 *readLumPlanar = planar_rgb_to_y;
2151 break;
2152 #if HAVE_BIGENDIAN
2153 case AV_PIX_FMT_YUV420P9LE:
2154 case AV_PIX_FMT_YUV422P9LE:
2155 case AV_PIX_FMT_YUV444P9LE:
2156 case AV_PIX_FMT_YUV420P10LE:
2157 case AV_PIX_FMT_YUV422P10LE:
2158 case AV_PIX_FMT_YUV440P10LE:
2159 case AV_PIX_FMT_YUV444P10LE:
2160 case AV_PIX_FMT_YUV420P12LE:
2161 case AV_PIX_FMT_YUV422P12LE:
2162 case AV_PIX_FMT_YUV440P12LE:
2163 case AV_PIX_FMT_YUV444P12LE:
2164 case AV_PIX_FMT_YUV420P14LE:
2165 case AV_PIX_FMT_YUV422P14LE:
2166 case AV_PIX_FMT_YUV444P14LE:
2167 case AV_PIX_FMT_YUV420P16LE:
2168 case AV_PIX_FMT_YUV422P16LE:
2169 case AV_PIX_FMT_YUV444P16LE:
2170
2171 case AV_PIX_FMT_GRAY9LE:
2172 case AV_PIX_FMT_GRAY10LE:
2173 case AV_PIX_FMT_GRAY12LE:
2174 case AV_PIX_FMT_GRAY14LE:
2175 case AV_PIX_FMT_GRAY16LE:
2176
2177 case AV_PIX_FMT_P016LE:
2178 case AV_PIX_FMT_P216LE:
2179 case AV_PIX_FMT_P416LE:
2180 *lumToYV12 = bswap16Y_c;
2181 break;
2182 case AV_PIX_FMT_YUVA420P9LE:
2183 case AV_PIX_FMT_YUVA422P9LE:
2184 case AV_PIX_FMT_YUVA444P9LE:
2185 case AV_PIX_FMT_YUVA420P10LE:
2186 case AV_PIX_FMT_YUVA422P10LE:
2187 case AV_PIX_FMT_YUVA444P10LE:
2188 case AV_PIX_FMT_YUVA422P12LE:
2189 case AV_PIX_FMT_YUVA444P12LE:
2190 case AV_PIX_FMT_YUVA420P16LE:
2191 case AV_PIX_FMT_YUVA422P16LE:
2192 case AV_PIX_FMT_YUVA444P16LE:
2193 *lumToYV12 = bswap16Y_c;
2194 *alpToYV12 = bswap16Y_c;
2195 break;
2196 #else
2197 case AV_PIX_FMT_YUV420P9BE:
2198 case AV_PIX_FMT_YUV422P9BE:
2199 case AV_PIX_FMT_YUV444P9BE:
2200 case AV_PIX_FMT_YUV420P10BE:
2201 case AV_PIX_FMT_YUV422P10BE:
2202 case AV_PIX_FMT_YUV440P10BE:
2203 case AV_PIX_FMT_YUV444P10BE:
2204 case AV_PIX_FMT_YUV420P12BE:
2205 case AV_PIX_FMT_YUV422P12BE:
2206 case AV_PIX_FMT_YUV440P12BE:
2207 case AV_PIX_FMT_YUV444P12BE:
2208 case AV_PIX_FMT_YUV420P14BE:
2209 case AV_PIX_FMT_YUV422P14BE:
2210 case AV_PIX_FMT_YUV444P14BE:
2211 case AV_PIX_FMT_YUV420P16BE:
2212 case AV_PIX_FMT_YUV422P16BE:
2213 case AV_PIX_FMT_YUV444P16BE:
2214
2215 case AV_PIX_FMT_GRAY9BE:
2216 case AV_PIX_FMT_GRAY10BE:
2217 case AV_PIX_FMT_GRAY12BE:
2218 case AV_PIX_FMT_GRAY14BE:
2219 case AV_PIX_FMT_GRAY16BE:
2220
2221 case AV_PIX_FMT_P016BE:
2222 case AV_PIX_FMT_P216BE:
2223 case AV_PIX_FMT_P416BE:
2224 *lumToYV12 = bswap16Y_c;
2225 break;
2226 case AV_PIX_FMT_YUVA420P9BE:
2227 case AV_PIX_FMT_YUVA422P9BE:
2228 case AV_PIX_FMT_YUVA444P9BE:
2229 case AV_PIX_FMT_YUVA420P10BE:
2230 case AV_PIX_FMT_YUVA422P10BE:
2231 case AV_PIX_FMT_YUVA444P10BE:
2232 case AV_PIX_FMT_YUVA422P12BE:
2233 case AV_PIX_FMT_YUVA444P12BE:
2234 case AV_PIX_FMT_YUVA420P16BE:
2235 case AV_PIX_FMT_YUVA422P16BE:
2236 case AV_PIX_FMT_YUVA444P16BE:
2237 *lumToYV12 = bswap16Y_c;
2238 *alpToYV12 = bswap16Y_c;
2239 break;
2240 #endif
2241 case AV_PIX_FMT_YA16LE:
2242 *lumToYV12 = read_ya16le_gray_c;
2243 break;
2244 case AV_PIX_FMT_YA16BE:
2245 *lumToYV12 = read_ya16be_gray_c;
2246 break;
2247 case AV_PIX_FMT_VUYA:
2248 case AV_PIX_FMT_VUYX:
2249 *lumToYV12 = read_vuyx_Y_c;
2250 break;
2251 case AV_PIX_FMT_XV30LE:
2252 *lumToYV12 = read_xv30le_Y_c;
2253 break;
2254 case AV_PIX_FMT_V30XLE:
2255 *lumToYV12 = read_v30xle_Y_c;
2256 break;
2257 case AV_PIX_FMT_AYUV:
2258 case AV_PIX_FMT_UYVA:
2259 *lumToYV12 = read_ayuv_Y_c;
2260 break;
2261 case AV_PIX_FMT_AYUV64LE:
2262 case AV_PIX_FMT_XV48LE:
2263 *lumToYV12 = read_ayuv64le_Y_c;
2264 break;
2265 case AV_PIX_FMT_AYUV64BE:
2266 case AV_PIX_FMT_XV48BE:
2267 *lumToYV12 = read_ayuv64be_Y_c;
2268 break;
2269 case AV_PIX_FMT_XV36LE:
2270 *lumToYV12 = read_xv36le_Y_c;
2271 break;
2272 case AV_PIX_FMT_XV36BE:
2273 *lumToYV12 = read_xv36be_Y_c;
2274 break;
2275 case AV_PIX_FMT_YUYV422:
2276 case AV_PIX_FMT_YVYU422:
2277 case AV_PIX_FMT_YA8:
2278 *lumToYV12 = yuy2ToY_c;
2279 break;
2280 case AV_PIX_FMT_UYVY422:
2281 *lumToYV12 = uyvyToY_c;
2282 break;
2283 case AV_PIX_FMT_VYU444:
2284 *lumToYV12 = vyuToY_c;
2285 break;
2286 case AV_PIX_FMT_BGR24:
2287 *lumToYV12 = bgr24ToY_c;
2288 break;
2289 case AV_PIX_FMT_BGR565LE:
2290 *lumToYV12 = bgr16leToY_c;
2291 break;
2292 case AV_PIX_FMT_BGR565BE:
2293 *lumToYV12 = bgr16beToY_c;
2294 break;
2295 case AV_PIX_FMT_BGR555LE:
2296 *lumToYV12 = bgr15leToY_c;
2297 break;
2298 case AV_PIX_FMT_BGR555BE:
2299 *lumToYV12 = bgr15beToY_c;
2300 break;
2301 case AV_PIX_FMT_BGR444LE:
2302 *lumToYV12 = bgr12leToY_c;
2303 break;
2304 case AV_PIX_FMT_BGR444BE:
2305 *lumToYV12 = bgr12beToY_c;
2306 break;
2307 case AV_PIX_FMT_RGB24:
2308 *lumToYV12 = rgb24ToY_c;
2309 break;
2310 case AV_PIX_FMT_RGB565LE:
2311 *lumToYV12 = rgb16leToY_c;
2312 break;
2313 case AV_PIX_FMT_RGB565BE:
2314 *lumToYV12 = rgb16beToY_c;
2315 break;
2316 case AV_PIX_FMT_RGB555LE:
2317 *lumToYV12 = rgb15leToY_c;
2318 break;
2319 case AV_PIX_FMT_RGB555BE:
2320 *lumToYV12 = rgb15beToY_c;
2321 break;
2322 case AV_PIX_FMT_RGB444LE:
2323 *lumToYV12 = rgb12leToY_c;
2324 break;
2325 case AV_PIX_FMT_RGB444BE:
2326 *lumToYV12 = rgb12beToY_c;
2327 break;
2328 case AV_PIX_FMT_RGB8:
2329 case AV_PIX_FMT_BGR8:
2330 case AV_PIX_FMT_PAL8:
2331 case AV_PIX_FMT_BGR4_BYTE:
2332 case AV_PIX_FMT_RGB4_BYTE:
2333 *lumToYV12 = palToY_c;
2334 break;
2335 case AV_PIX_FMT_MONOBLACK:
2336 *lumToYV12 = monoblack2Y_c;
2337 break;
2338 case AV_PIX_FMT_MONOWHITE:
2339 *lumToYV12 = monowhite2Y_c;
2340 break;
2341 case AV_PIX_FMT_RGB32:
2342 *lumToYV12 = bgr32ToY_c;
2343 break;
2344 case AV_PIX_FMT_RGB32_1:
2345 *lumToYV12 = bgr321ToY_c;
2346 break;
2347 case AV_PIX_FMT_BGR32:
2348 *lumToYV12 = rgb32ToY_c;
2349 break;
2350 case AV_PIX_FMT_BGR32_1:
2351 *lumToYV12 = rgb321ToY_c;
2352 break;
2353 case AV_PIX_FMT_RGB48BE:
2354 *lumToYV12 = rgb48BEToY_c;
2355 break;
2356 case AV_PIX_FMT_RGB48LE:
2357 *lumToYV12 = rgb48LEToY_c;
2358 break;
2359 case AV_PIX_FMT_BGR48BE:
2360 *lumToYV12 = bgr48BEToY_c;
2361 break;
2362 case AV_PIX_FMT_BGR48LE:
2363 *lumToYV12 = bgr48LEToY_c;
2364 break;
2365 case AV_PIX_FMT_RGBA64BE:
2366 *lumToYV12 = rgb64BEToY_c;
2367 break;
2368 case AV_PIX_FMT_RGBA64LE:
2369 *lumToYV12 = rgb64LEToY_c;
2370 break;
2371 case AV_PIX_FMT_BGRA64BE:
2372 *lumToYV12 = bgr64BEToY_c;
2373 break;
2374 case AV_PIX_FMT_BGRA64LE:
2375 *lumToYV12 = bgr64LEToY_c;
2376 break;
2377 case AV_PIX_FMT_P010LE:
2378 case AV_PIX_FMT_P210LE:
2379 case AV_PIX_FMT_P410LE:
2380 *lumToYV12 = p010LEToY_c;
2381 break;
2382 case AV_PIX_FMT_P010BE:
2383 case AV_PIX_FMT_P210BE:
2384 case AV_PIX_FMT_P410BE:
2385 *lumToYV12 = p010BEToY_c;
2386 break;
2387 case AV_PIX_FMT_P012LE:
2388 case AV_PIX_FMT_P212LE:
2389 case AV_PIX_FMT_P412LE:
2390 *lumToYV12 = p012LEToY_c;
2391 break;
2392 case AV_PIX_FMT_P012BE:
2393 case AV_PIX_FMT_P212BE:
2394 case AV_PIX_FMT_P412BE:
2395 *lumToYV12 = p012BEToY_c;
2396 break;
2397 case AV_PIX_FMT_GRAYF32LE:
2398 *lumToYV12 = grayf32leToY16_c;
2399 break;
2400 case AV_PIX_FMT_GRAYF32BE:
2401 *lumToYV12 = grayf32beToY16_c;
2402 break;
2403 case AV_PIX_FMT_GRAYF16LE:
2404 *lumToYV12 = grayf16leToY16_c;
2405 break;
2406 case AV_PIX_FMT_GRAYF16BE:
2407 *lumToYV12 = grayf16beToY16_c;
2408 break;
2409 case AV_PIX_FMT_Y210LE:
2410 *lumToYV12 = y210le_Y_c;
2411 break;
2412 case AV_PIX_FMT_Y212LE:
2413 *lumToYV12 = y212le_Y_c;
2414 break;
2415 case AV_PIX_FMT_Y216LE:
2416 *lumToYV12 = y216le_Y_c;
2417 break;
2418 case AV_PIX_FMT_X2RGB10LE:
2419 *lumToYV12 = rgb30leToY_c;
2420 break;
2421 case AV_PIX_FMT_X2BGR10LE:
2422 *lumToYV12 = bgr30leToY_c;
2423 break;
2424 case AV_PIX_FMT_RGBAF16BE:
2425 *lumToYV12 = rgbaf16beToY_c;
2426 break;
2427 case AV_PIX_FMT_RGBAF16LE:
2428 *lumToYV12 = rgbaf16leToY_c;
2429 break;
2430 case AV_PIX_FMT_RGBF16BE:
2431 *lumToYV12 = rgbf16beToY_c;
2432 break;
2433 case AV_PIX_FMT_RGBF16LE:
2434 *lumToYV12 = rgbf16leToY_c;
2435 break;
2436 case AV_PIX_FMT_RGBF32LE:
2437 *lumToYV12 = rgbf32le_to_y_c;
2438 break;
2439 case AV_PIX_FMT_RGBF32BE:
2440 *lumToYV12 = rgbf32be_to_y_c;
2441 break;
2442 }
2443 if (c->needAlpha) {
2444 if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
2445 if (HAVE_BIGENDIAN == !isBE(srcFormat) && !*readAlpPlanar)
2446 *alpToYV12 = bswap16Y_c;
2447 }
2448 switch (srcFormat) {
2449 case AV_PIX_FMT_BGRA64LE:
2450 case AV_PIX_FMT_RGBA64LE: *alpToYV12 = rgba64leToA_c; break;
2451 case AV_PIX_FMT_BGRA64BE:
2452 case AV_PIX_FMT_RGBA64BE: *alpToYV12 = rgba64beToA_c; break;
2453 case AV_PIX_FMT_BGRA:
2454 case AV_PIX_FMT_RGBA:
2455 *alpToYV12 = rgbaToA_c;
2456 break;
2457 case AV_PIX_FMT_ABGR:
2458 case AV_PIX_FMT_ARGB:
2459 *alpToYV12 = abgrToA_c;
2460 break;
2461 case AV_PIX_FMT_RGBAF16BE:
2462 *alpToYV12 = rgbaf16beToA_c;
2463 break;
2464 case AV_PIX_FMT_RGBAF16LE:
2465 *alpToYV12 = rgbaf16leToA_c;
2466 break;
2467 case AV_PIX_FMT_YA8:
2468 *alpToYV12 = uyvyToY_c;
2469 break;
2470 case AV_PIX_FMT_YA16LE:
2471 *alpToYV12 = read_ya16le_alpha_c;
2472 break;
2473 case AV_PIX_FMT_YA16BE:
2474 *alpToYV12 = read_ya16be_alpha_c;
2475 break;
2476 case AV_PIX_FMT_VUYA:
2477 case AV_PIX_FMT_UYVA:
2478 *alpToYV12 = read_vuya_A_c;
2479 break;
2480 case AV_PIX_FMT_AYUV:
2481 *alpToYV12 = read_ayuv_A_c;
2482 break;
2483 case AV_PIX_FMT_AYUV64LE:
2484 *alpToYV12 = read_ayuv64le_A_c;
2485 break;
2486 case AV_PIX_FMT_AYUV64BE:
2487 *alpToYV12 = read_ayuv64be_A_c;
2488 break;
2489 case AV_PIX_FMT_PAL8 :
2490 *alpToYV12 = palToA_c;
2491 break;
2492 }
2493 }
2494 }
Mirror of the official FFMpeg Git repo