FFmpeg
input.c
Go to the documentation of this file.
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 <stddef.h>
23 #include <stdint.h>
24 
25 #include "libavutil/attributes.h"
26 #include "libavutil/bswap.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/avassert.h"
29 #include "libavutil/intfloat.h"
30 #include "config.h"
31 #include "swscale_internal.h"
32 
33 #define input_pixel(pos) (is_be ? AV_RB16(pos) : AV_RL16(pos))
34 
35 #define IS_BE_LE 0
36 #define IS_BE_BE 1
37 #define IS_BE_ 0
38 /* ENDIAN_IDENTIFIER needs to be "BE", "LE" or "". The latter is intended
39  * for single-byte cases where the concept of endianness does not apply. */
40 #define IS_BE(ENDIAN_IDENTIFIER) IS_BE_ ## ENDIAN_IDENTIFIER
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
46 rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
47  enum AVPixelFormat origin, int32_t *rgb2yuv, int is_be)
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
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, int is_be)
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  unsigned int r_b = input_pixel(&src1[i*4+0]);
71  unsigned int g = input_pixel(&src1[i*4+1]);
72  unsigned 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
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, int is_be)
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  unsigned r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
90  unsigned g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
91  unsigned 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_EXT(pattern, BE_LE, origin, is_be) \
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, void *opq) \
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, is_be); \
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, void *opq) \
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, is_be); \
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, void *opq) \
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, is_be); \
125 }
126 #define RGB64FUNCS(pattern, endianness, base_fmt) \
127  RGB64FUNCS_EXT(pattern, endianness, base_fmt ## endianness, IS_BE(endianness))
128 
129 RGB64FUNCS(rgb, LE, AV_PIX_FMT_RGBA64)
130 RGB64FUNCS(rgb, BE, AV_PIX_FMT_RGBA64)
131 RGB64FUNCS(bgr, LE, AV_PIX_FMT_BGRA64)
132 RGB64FUNCS(bgr, BE, AV_PIX_FMT_BGRA64)
133 
134 static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
135  const uint16_t *src, int width,
136  enum AVPixelFormat origin,
137  int32_t *rgb2yuv, int is_be)
138 {
139  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
140  int i;
141  for (i = 0; i < width; i++) {
142  unsigned int r_b = input_pixel(&src[i * 3 + 0]);
143  unsigned int g = input_pixel(&src[i * 3 + 1]);
144  unsigned int b_r = input_pixel(&src[i * 3 + 2]);
145 
146  dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
147  }
148 }
149 
150 static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
151  uint16_t *dstV,
152  const uint16_t *src1,
153  const uint16_t *src2,
154  int width,
155  enum AVPixelFormat origin,
156  int32_t *rgb2yuv, int is_be)
157 {
158  int i;
159  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
160  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
161  av_assert1(src1 == src2);
162  for (i = 0; i < width; i++) {
163  unsigned r_b = input_pixel(&src1[i * 3 + 0]);
164  unsigned g = input_pixel(&src1[i * 3 + 1]);
165  unsigned b_r = input_pixel(&src1[i * 3 + 2]);
166 
167  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
168  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
169  }
170 }
171 
172 static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
173  uint16_t *dstV,
174  const uint16_t *src1,
175  const uint16_t *src2,
176  int width,
177  enum AVPixelFormat origin,
178  int32_t *rgb2yuv, int is_be)
179 {
180  int i;
181  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
182  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
183  av_assert1(src1 == src2);
184  for (i = 0; i < width; i++) {
185  unsigned r_b = (input_pixel(&src1[6 * i + 0]) +
186  input_pixel(&src1[6 * i + 3]) + 1) >> 1;
187  unsigned g = (input_pixel(&src1[6 * i + 1]) +
188  input_pixel(&src1[6 * i + 4]) + 1) >> 1;
189  unsigned b_r = (input_pixel(&src1[6 * i + 2]) +
190  input_pixel(&src1[6 * i + 5]) + 1) >> 1;
191 
192  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
193  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
194  }
195 }
196 
197 #undef r
198 #undef b
199 #undef input_pixel
200 
201 #define RGB48FUNCS_EXT(pattern, BE_LE, origin, is_be) \
202 static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst, \
203  const uint8_t *_src, \
204  const uint8_t *unused0, const uint8_t *unused1,\
205  int width, \
206  uint32_t *rgb2yuv, \
207  void *opq) \
208 { \
209  const uint16_t *src = (const uint16_t *)_src; \
210  uint16_t *dst = (uint16_t *)_dst; \
211  rgb48ToY_c_template(dst, src, width, origin, rgb2yuv, is_be); \
212 } \
213  \
214 static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, \
215  uint8_t *_dstV, \
216  const uint8_t *unused0, \
217  const uint8_t *_src1, \
218  const uint8_t *_src2, \
219  int width, \
220  uint32_t *rgb2yuv, \
221  void *opq) \
222 { \
223  const uint16_t *src1 = (const uint16_t *)_src1, \
224  *src2 = (const uint16_t *)_src2; \
225  uint16_t *dstU = (uint16_t *)_dstU, \
226  *dstV = (uint16_t *)_dstV; \
227  rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv, is_be); \
228 } \
229  \
230 static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, \
231  uint8_t *_dstV, \
232  const uint8_t *unused0, \
233  const uint8_t *_src1, \
234  const uint8_t *_src2, \
235  int width, \
236  uint32_t *rgb2yuv, \
237  void *opq) \
238 { \
239  const uint16_t *src1 = (const uint16_t *)_src1, \
240  *src2 = (const uint16_t *)_src2; \
241  uint16_t *dstU = (uint16_t *)_dstU, \
242  *dstV = (uint16_t *)_dstV; \
243  rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv, is_be); \
244 }
245 #define RGB48FUNCS(pattern, endianness, base_fmt) \
246  RGB48FUNCS_EXT(pattern, endianness, base_fmt ## endianness, IS_BE(endianness))
247 
248 RGB48FUNCS(rgb, LE, AV_PIX_FMT_RGB48)
249 RGB48FUNCS(rgb, BE, AV_PIX_FMT_RGB48)
250 RGB48FUNCS(bgr, LE, AV_PIX_FMT_BGR48)
251 RGB48FUNCS(bgr, BE, AV_PIX_FMT_BGR48)
252 
253 #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA || \
254  origin == AV_PIX_FMT_BGRA || \
255  origin == AV_PIX_FMT_ARGB || \
256  origin == AV_PIX_FMT_ABGR) \
257  ? AV_RN32A(&src[(i) * 4]) \
258  : ((origin == AV_PIX_FMT_X2RGB10LE || \
259  origin == AV_PIX_FMT_X2BGR10LE) \
260  ? AV_RL32(&src[(i) * 4]) \
261  : (is_be ? AV_RB16(&src[(i) * 2]) \
262  : AV_RL16(&src[(i) * 2]))))
263 
264 static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
265  const uint8_t *src,
266  int width,
267  enum AVPixelFormat origin,
268  int shr, int shg,
269  int shb, int shp,
270  int maskr, int maskg,
271  int maskb, int rsh,
272  int gsh, int bsh, int S,
273  int32_t *rgb2yuv, int is_be)
274 {
275  const int ry = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
276  const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
277  int i;
278 
279  for (i = 0; i < width; i++) {
280  int px = input_pixel(i) >> shp;
281  int b = (px & maskb) >> shb;
282  int g = (px & maskg) >> shg;
283  int r = (px & maskr) >> shr;
284 
285  dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
286  }
287 }
288 
289 static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
290  int16_t *dstV,
291  const uint8_t *src,
292  int width,
293  enum AVPixelFormat origin,
294  int shr, int shg,
295  int shb, int shp,
296  int maskr, int maskg,
297  int maskb, int rsh,
298  int gsh, int bsh, int S,
299  int32_t *rgb2yuv, int is_be)
300 {
301  const int ru = rgb2yuv[RU_IDX] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
302  rv = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << bsh);
303  const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
304  int i;
305 
306  for (i = 0; i < width; i++) {
307  int px = input_pixel(i) >> shp;
308  int b = (px & maskb) >> shb;
309  int g = (px & maskg) >> shg;
310  int r = (px & maskr) >> shr;
311 
312  dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
313  dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
314  }
315 }
316 
317 static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
318  int16_t *dstV,
319  const uint8_t *src,
320  int width,
321  enum AVPixelFormat origin,
322  int shr, int shg,
323  int shb, int shp,
324  int maskr, int maskg,
325  int maskb, int rsh,
326  int gsh, int bsh, int S,
327  int32_t *rgb2yuv, int is_be)
328 {
329  const int ru = rgb2yuv[RU_IDX] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
330  rv = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << bsh),
331  maskgx = ~(maskr | maskb);
332  const unsigned rnd = (256U<<(S)) + (1<<(S-6));
333  int i;
334 
335  maskr |= maskr << 1;
336  maskb |= maskb << 1;
337  maskg |= maskg << 1;
338  for (i = 0; i < width; i++) {
339  unsigned px0 = input_pixel(2 * i + 0) >> shp;
340  unsigned px1 = input_pixel(2 * i + 1) >> shp;
341  int b, r, g = (px0 & maskgx) + (px1 & maskgx);
342  int rb = px0 + px1 - g;
343 
344  b = (rb & maskb) >> shb;
345  if (shp ||
346  origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
347  origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
348  g >>= shg;
349  } else {
350  g = (g & maskg) >> shg;
351  }
352  r = (rb & maskr) >> shr;
353 
354  dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
355  dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
356  }
357 }
358 
359 #undef input_pixel
360 
361 #define RGB16_32FUNCS_EXT(fmt, name, shr, shg, shb, shp, maskr, \
362  maskg, maskb, rsh, gsh, bsh, S, is_be) \
363 static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, \
364  int width, uint32_t *tab, void *opq) \
365 { \
366  rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp, \
367  maskr, maskg, maskb, rsh, gsh, bsh, S, tab, is_be); \
368 } \
369  \
370 static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
371  const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy, \
372  int width, uint32_t *tab, void *opq) \
373 { \
374  rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
375  shr, shg, shb, shp, \
376  maskr, maskg, maskb, rsh, gsh, bsh, S, tab, is_be); \
377 } \
378  \
379 static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \
380  const uint8_t *unused0, const uint8_t *src, \
381  const uint8_t *dummy, \
382  int width, uint32_t *tab, void *opq) \
383 { \
384  rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
385  shr, shg, shb, shp, \
386  maskr, maskg, maskb, \
387  rsh, gsh, bsh, S, tab, is_be); \
388 }
389 
390 #define RGB16_32FUNCS(base_fmt, endianness, name, shr, shg, shb, shp, maskr, \
391  maskg, maskb, rsh, gsh, bsh, S) \
392  RGB16_32FUNCS_EXT(base_fmt ## endianness, name, shr, shg, shb, shp, maskr, \
393  maskg, maskb, rsh, gsh, bsh, S, IS_BE(endianness))
394 
395 RGB16_32FUNCS(AV_PIX_FMT_BGR32, , bgr32, 16, 0, 0, 0, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
396 RGB16_32FUNCS(AV_PIX_FMT_BGR32_1, , bgr321, 16, 0, 0, 8, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
397 RGB16_32FUNCS(AV_PIX_FMT_RGB32, , rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
398 RGB16_32FUNCS(AV_PIX_FMT_RGB32_1, , rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
399 RGB16_32FUNCS(AV_PIX_FMT_BGR565, LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
400 RGB16_32FUNCS(AV_PIX_FMT_BGR555, LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
401 RGB16_32FUNCS(AV_PIX_FMT_BGR444, LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
402 RGB16_32FUNCS(AV_PIX_FMT_RGB565, LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
403 RGB16_32FUNCS(AV_PIX_FMT_RGB555, LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
404 RGB16_32FUNCS(AV_PIX_FMT_RGB444, LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
405 RGB16_32FUNCS(AV_PIX_FMT_BGR565, BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
406 RGB16_32FUNCS(AV_PIX_FMT_BGR555, BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
407 RGB16_32FUNCS(AV_PIX_FMT_BGR444, BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
408 RGB16_32FUNCS(AV_PIX_FMT_RGB565, BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
409 RGB16_32FUNCS(AV_PIX_FMT_RGB555, BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
410 RGB16_32FUNCS(AV_PIX_FMT_RGB444, BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
411 RGB16_32FUNCS(AV_PIX_FMT_X2RGB10, LE, rgb30le, 16, 6, 0, 0, 0x3FF00000, 0xFFC00, 0x3FF, 0, 0, 4, RGB2YUV_SHIFT + 6)
412 RGB16_32FUNCS(AV_PIX_FMT_X2BGR10, LE, bgr30le, 0, 6, 16, 0, 0x3FF, 0xFFC00, 0x3FF00000, 4, 0, 0, RGB2YUV_SHIFT + 6)
413 
414 static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
415  const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
416  int width, uint32_t *rgb2yuv, void *opq)
417 {
418  uint16_t *dstU = (uint16_t *)_dstU;
419  uint16_t *dstV = (uint16_t *)_dstV;
420  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
421  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
422 
423  int i;
424  for (i = 0; i < width; i++) {
425  unsigned int g = gsrc[2*i] + gsrc[2*i+1];
426  unsigned int b = bsrc[2*i] + bsrc[2*i+1];
427  unsigned int r = rsrc[2*i] + rsrc[2*i+1];
428 
429  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
430  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
431  }
432 }
433 
434 static void rgba64leToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
435  const uint8_t *unused2, int width, uint32_t *unused, void *opq)
436 {
437  int16_t *dst = (int16_t *)_dst;
438  const uint16_t *src = (const uint16_t *)_src;
439  int i;
440  for (i = 0; i < width; i++)
441  dst[i] = AV_RL16(src + 4 * i + 3);
442 }
443 
444 static void rgba64beToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
445  const uint8_t *unused2, int width, uint32_t *unused, void *opq)
446 {
447  int16_t *dst = (int16_t *)_dst;
448  const uint16_t *src = (const uint16_t *)_src;
449  int i;
450  for (i = 0; i < width; i++)
451  dst[i] = AV_RB16(src + 4 * i + 3);
452 }
453 
454 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
455  const uint8_t *unused2, int width, uint32_t *unused, void *opq)
456 {
457  int16_t *dst = (int16_t *)_dst;
458  int i;
459  for (i=0; i<width; i++) {
460  dst[i]= src[4*i]<<6 | src[4*i]>>2;
461  }
462 }
463 
464 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
465  const uint8_t *unused2, int width, uint32_t *unused, void *opq)
466 {
467  int16_t *dst = (int16_t *)_dst;
468  int i;
469  for (i=0; i<width; i++) {
470  dst[i]= src[4*i+3]<<6 | src[4*i+3]>>2;
471  }
472 }
473 
474 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
475  const uint8_t *unused2, int width, uint32_t *pal, void *opq)
476 {
477  int16_t *dst = (int16_t *)_dst;
478  int i;
479  for (i=0; i<width; i++) {
480  int d= src[i];
481 
482  dst[i]= (pal[d] >> 24)<<6 | pal[d]>>26;
483  }
484 }
485 
486 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
487  const uint8_t *unused2, int width, uint32_t *pal, void *opq)
488 {
489  int16_t *dst = (int16_t *)_dst;
490  int i;
491  for (i = 0; i < width; i++) {
492  int d = src[i];
493 
494  dst[i] = (pal[d] & 0xFF)<<6;
495  }
496 }
497 
498 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
499  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
500  int width, uint32_t *pal, void *opq)
501 {
502  uint16_t *dstU = (uint16_t *)_dstU;
503  int16_t *dstV = (int16_t *)_dstV;
504  int i;
505  av_assert1(src1 == src2);
506  for (i = 0; i < width; i++) {
507  int p = pal[src1[i]];
508 
509  dstU[i] = (uint8_t)(p>> 8)<<6;
510  dstV[i] = (uint8_t)(p>>16)<<6;
511  }
512 }
513 
514 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
515  const uint8_t *unused2, int width, uint32_t *unused, void *opq)
516 {
517  int16_t *dst = (int16_t *)_dst;
518  int i, j;
519  width = (width + 7) >> 3;
520  for (i = 0; i < width; i++) {
521  int d = ~src[i];
522  for (j = 0; j < 8; j++)
523  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
524  }
525  if(width&7){
526  int d= ~src[i];
527  for (j = 0; j < (width&7); j++)
528  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
529  }
530 }
531 
532 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
533  const uint8_t *unused2, int width, uint32_t *unused, void *opq)
534 {
535  int16_t *dst = (int16_t *)_dst;
536  int i, j;
537  width = (width + 7) >> 3;
538  for (i = 0; i < width; i++) {
539  int d = src[i];
540  for (j = 0; j < 8; j++)
541  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
542  }
543  if(width&7){
544  int d = src[i];
545  for (j = 0; j < (width&7); j++)
546  dst[8*i+j] = ((d>>(7-j))&1) * 16383;
547  }
548 }
549 
550 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
551  uint32_t *unused, void *opq)
552 {
553  int i;
554  for (i = 0; i < width; i++)
555  dst[i] = src[2 * i];
556 }
557 
558 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
559  const uint8_t *src2, int width, uint32_t *unused, void *opq)
560 {
561  int i;
562  for (i = 0; i < width; i++) {
563  dstU[i] = src1[4 * i + 1];
564  dstV[i] = src1[4 * i + 3];
565  }
566  av_assert1(src1 == src2);
567 }
568 
569 static void yvy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
570  const uint8_t *src2, int width, uint32_t *unused, void *opq)
571 {
572  int i;
573  for (i = 0; i < width; i++) {
574  dstV[i] = src1[4 * i + 1];
575  dstU[i] = src1[4 * i + 3];
576  }
577  av_assert1(src1 == src2);
578 }
579 
580 #define y21xle_wrapper(bits, shift) \
581  static void y2 ## bits ## le_UV_c(uint8_t *dstU, uint8_t *dstV, \
582  const uint8_t *unused0, \
583  const uint8_t *src, \
584  const uint8_t *unused1, int width, \
585  uint32_t *unused2, void *opq) \
586  { \
587  int i; \
588  for (i = 0; i < width; i++) { \
589  AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 2) >> shift); \
590  AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6) >> shift); \
591  } \
592  } \
593  \
594  static void y2 ## bits ## le_Y_c(uint8_t *dst, const uint8_t *src, \
595  const uint8_t *unused0, \
596  const uint8_t *unused1, int width, \
597  uint32_t *unused2, void *opq) \
598  { \
599  int i; \
600  for (i = 0; i < width; i++) \
601  AV_WN16(dst + i * 2, AV_RL16(src + i * 4) >> shift); \
602  }
603 
604 y21xle_wrapper(10, 6)
605 y21xle_wrapper(12, 4)
606 y21xle_wrapper(16, 0)
607 
608 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
609  uint32_t *unused, void *opq)
610 {
611  int i;
612  const uint16_t *src = (const uint16_t *)_src;
613  uint16_t *dst = (uint16_t *)_dst;
614  for (i = 0; i < width; i++)
615  dst[i] = av_bswap16(src[i]);
616 }
617 
618 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
619  const uint8_t *_src2, int width, uint32_t *unused, void *opq)
620 {
621  int i;
622  const uint16_t *src1 = (const uint16_t *)_src1,
623  *src2 = (const uint16_t *)_src2;
624  uint16_t *dstU = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
625  for (i = 0; i < width; i++) {
626  dstU[i] = av_bswap16(src1[i]);
627  dstV[i] = av_bswap16(src2[i]);
628  }
629 }
630 
631 static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
632  uint32_t *unused, void *opq)
633 {
634  int i;
635  for (i = 0; i < width; i++)
636  AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
637 }
638 
639 static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
640  uint32_t *unused, void *opq)
641 {
642  int i;
643  for (i = 0; i < width; i++)
644  AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
645 }
646 
647 static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
648  uint32_t *unused, void *opq)
649 {
650  int i;
651  for (i = 0; i < width; i++)
652  AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
653 }
654 
655 static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
656  uint32_t *unused, void *opq)
657 {
658  int i;
659  for (i = 0; i < width; i++)
660  AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
661 }
662 
663 static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
664  uint32_t *unused2, void *opq)
665 {
666  int i;
667  for (i = 0; i < width; i++)
668  AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2));
669 }
670 
671 static void read_ayuv64be_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
672  uint32_t *unused2, void *opq)
673 {
674  int i;
675  for (i = 0; i < width; i++)
676  AV_WN16(dst + i * 2, AV_RB16(src + i * 8 + 2));
677 }
678 
679 static av_always_inline void ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width,
680  int u_offset, int v_offset)
681 {
682  int i;
683  for (i = 0; i < width; i++) {
684  AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + u_offset));
685  AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + v_offset));
686  }
687 }
688 
689 static av_always_inline void ayuv64be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width,
690  int u_offset, int v_offset)
691 {
692  int i;
693  for (i = 0; i < width; i++) {
694  AV_WN16(dstU + i * 2, AV_RB16(src + i * 8 + u_offset));
695  AV_WN16(dstV + i * 2, AV_RB16(src + i * 8 + v_offset));
696  }
697 }
698 
699 #define ayuv64_UV_funcs(pixfmt, U, V) \
700 static void read_ ## pixfmt ## le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, \
701  const uint8_t *unused1, int width, uint32_t *unused2, void *opq) \
702 { \
703  ayuv64le_UV_c(dstU, dstV, src, width, U, V); \
704 } \
705  \
706 static void read_ ## pixfmt ## be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, \
707  const uint8_t *unused1, int width, uint32_t *unused2, void *opq) \
708 { \
709  ayuv64be_UV_c(dstU, dstV, src, width, U, V); \
710 }
711 
712 ayuv64_UV_funcs(ayuv64, 4, 6)
713 ayuv64_UV_funcs(xv48, 0, 4)
714 
715 static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
716  uint32_t *unused2, void *opq)
717 {
718  int i;
719  for (i = 0; i < width; i++)
720  AV_WN16(dst + i * 2, AV_RL16(src + i * 8));
721 }
722 
723 static void read_ayuv64be_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
724  uint32_t *unused2, void *opq)
725 {
726  int i;
727  for (i = 0; i < width; i++)
728  AV_WN16(dst + i * 2, AV_RB16(src + i * 8));
729 }
730 
731 static void read_vuyx_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
732  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
733 {
734  int i;
735  for (i = 0; i < width; i++) {
736  dstU[i] = src[i * 4 + 1];
737  dstV[i] = src[i * 4];
738  }
739 }
740 
741 static void read_vuyx_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
742  uint32_t *unused2, void *opq)
743 {
744  int i;
745  for (i = 0; i < width; i++)
746  dst[i] = src[i * 4 + 2];
747 }
748 
749 static void read_vuya_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
750  uint32_t *unused2, void *opq)
751 {
752  int i;
753  for (i = 0; i < width; i++)
754  dst[i] = src[i * 4 + 3];
755 }
756 
757 static void read_ayuv_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
758  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
759 {
760  int i;
761  for (i = 0; i < width; i++) {
762  dstU[i] = src[i * 4 + 2];
763  dstV[i] = src[i * 4 + 3];
764  }
765 }
766 
767 static void read_ayuv_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
768  uint32_t *unused2, void *opq)
769 {
770  int i;
771  for (i = 0; i < width; i++)
772  dst[i] = src[i * 4 + 1];
773 }
774 
775 static void read_ayuv_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
776  uint32_t *unused2, void *opq)
777 {
778  int i;
779  for (i = 0; i < width; i++)
780  dst[i] = src[i * 4];
781 }
782 
783 static void read_uyva_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
784  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
785 {
786  int i;
787  for (i = 0; i < width; i++) {
788  dstU[i] = src[i * 4];
789  dstV[i] = src[i * 4 + 2];
790  }
791 }
792 
793 static void vyuToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
794  uint32_t *unused2, void *opq)
795 {
796  int i;
797  for (i = 0; i < width; i++)
798  dst[i] = src[i * 3 + 1];
799 }
800 
801 static void vyuToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
802  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
803 {
804  int i;
805  for (i = 0; i < width; i++) {
806  dstU[i] = src[i * 3 + 2];
807  dstV[i] = src[i * 3];
808  }
809 }
810 
811 static void read_v30xle_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
812  uint32_t *unused2, void *opq)
813 {
814  int i;
815  for (i = 0; i < width; i++)
816  AV_WN16(dst + i * 2, (AV_RL32(src + i * 4) >> 12) & 0x3FFu);
817 }
818 
819 
820 static void read_v30xle_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
821  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
822 {
823  int i;
824  for (i = 0; i < width; i++) {
825  unsigned int uv = AV_RL32(src + i * 4);
826  AV_WN16(dstU + i * 2, (uv >> 2) & 0x3FFu);
827  AV_WN16(dstV + i * 2, (uv >> 22) & 0x3FFu);
828  }
829 }
830 
831 static void read_xv30le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
832  uint32_t *unused2, void *opq)
833 {
834  int i;
835  for (i = 0; i < width; i++)
836  AV_WN16(dst + i * 2, (AV_RL32(src + i * 4) >> 10) & 0x3FFu);
837 }
838 
839 
840 static void read_xv30le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
841  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
842 {
843  int i;
844  for (i = 0; i < width; i++) {
845  AV_WN16(dstU + i * 2, AV_RL32(src + i * 4) & 0x3FFu);
846  AV_WN16(dstV + i * 2, (AV_RL32(src + i * 4) >> 20) & 0x3FFu);
847  }
848 }
849 
850 static void read_xv36le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
851  uint32_t *unused2, void *opq)
852 {
853  int i;
854  for (i = 0; i < width; i++)
855  AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2) >> 4);
856 }
857 
858 
859 static void read_xv36le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
860  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
861 {
862  int i;
863  for (i = 0; i < width; i++) {
864  AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 0) >> 4);
865  AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 4) >> 4);
866  }
867 }
868 
869 static void read_xv36be_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
870  uint32_t *unused2, void *opq)
871 {
872  int i;
873  for (i = 0; i < width; i++)
874  AV_WN16(dst + i * 2, AV_RB16(src + i * 8 + 2) >> 4);
875 }
876 
877 
878 static void read_xv36be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
879  const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
880 {
881  int i;
882  for (i = 0; i < width; i++) {
883  AV_WN16(dstU + i * 2, AV_RB16(src + i * 8 + 0) >> 4);
884  AV_WN16(dstV + i * 2, AV_RB16(src + i * 8 + 4) >> 4);
885  }
886 }
887 
888 /* This is almost identical to the previous, end exists only because
889  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
890 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
891  uint32_t *unused, void *opq)
892 {
893  int i;
894  for (i = 0; i < width; i++)
895  dst[i] = src[2 * i + 1];
896 }
897 
898 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
899  const uint8_t *src2, int width, uint32_t *unused, void *opq)
900 {
901  int i;
902  for (i = 0; i < width; i++) {
903  dstU[i] = src1[4 * i + 0];
904  dstV[i] = src1[4 * i + 2];
905  }
906  av_assert1(src1 == src2);
907 }
908 
909 static void uyyvyyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
910  int width, uint32_t *unused, void *opq)
911 {
912  for (int i = 0; i < width; i++)
913  dst[i] = src[3 * (i >> 1) + 1 + (i & 1)];
914 }
915 
916 static void uyyvyyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
917  const uint8_t *src2, int width, uint32_t *unused, void *opq)
918 {
919  for (int i = 0; i < width; i++) {
920  dstU[i] = src1[6 * i + 0];
921  dstV[i] = src1[6 * i + 3];
922  }
923  av_assert1(src1 == src2);
924 }
925 
926 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
927  const uint8_t *src, int width)
928 {
929  int i;
930  for (i = 0; i < width; i++) {
931  dst1[i] = src[2 * i + 0];
932  dst2[i] = src[2 * i + 1];
933  }
934 }
935 
936 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
937  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
938  int width, uint32_t *unused, void *opq)
939 {
940  nvXXtoUV_c(dstU, dstV, src1, width);
941 }
942 
943 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
944  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
945  int width, uint32_t *unused, void *opq)
946 {
947  nvXXtoUV_c(dstV, dstU, src1, width);
948 }
949 
950 #define p01x_uv_wrapper(fmt, shift) \
951  static void fmt ## LEToUV ## _c(uint8_t *dstU, \
952  uint8_t *dstV, \
953  const uint8_t *unused0, \
954  const uint8_t *src1, \
955  const uint8_t *src2, int width, \
956  uint32_t *unused, void *opq) \
957  { \
958  int i; \
959  for (i = 0; i < width; i++) { \
960  AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0) >> shift); \
961  AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2) >> shift); \
962  } \
963  } \
964  \
965  static void fmt ## BEToUV ## _c(uint8_t *dstU, \
966  uint8_t *dstV, \
967  const uint8_t *unused0, \
968  const uint8_t *src1, \
969  const uint8_t *src2, int width, \
970  uint32_t *unused, void *opq) \
971  { \
972  int i; \
973  for (i = 0; i < width; i++) { \
974  AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0) >> shift); \
975  AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2) >> shift); \
976  } \
977  }
978 
979 #define p01x_wrapper(fmt, shift) \
980  static void fmt ## LEToY ## _c(uint8_t *dst, \
981  const uint8_t *src, \
982  const uint8_t *unused1, \
983  const uint8_t *unused2, int width, \
984  uint32_t *unused, void *opq) \
985  { \
986  int i; \
987  for (i = 0; i < width; i++) { \
988  AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> shift); \
989  } \
990  } \
991  \
992  static void fmt ## BEToY ## _c(uint8_t *dst, \
993  const uint8_t *src, \
994  const uint8_t *unused1, \
995  const uint8_t *unused2, int width, \
996  uint32_t *unused, void *opq) \
997  { \
998  int i; \
999  for (i = 0; i < width; i++) { \
1000  AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> shift); \
1001  } \
1002  } \
1003  p01x_uv_wrapper(fmt, shift)
1004 
1005 p01x_wrapper(nv20, 0)
1006 p01x_wrapper(p010, 6)
1007 p01x_wrapper(p012, 4)
1008 p01x_uv_wrapper(p016, 0)
1009 
1010 #define shf16_uv_wrapper(shift) \
1011  static void shf16_ ## shift ## LEToUV_c(uint8_t *dstU, \
1012  uint8_t *dstV, \
1013  const uint8_t *unused0, \
1014  const uint8_t *src1, \
1015  const uint8_t *src2, int width, \
1016  uint32_t *unused, void *opq) \
1017  { \
1018  int i; \
1019  for (i = 0; i < width; i++) { \
1020  AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 2) >> (16 - shift)); \
1021  AV_WN16(dstV + i * 2, AV_RL16(src2 + i * 2) >> (16 - shift)); \
1022  } \
1023  } \
1024  \
1025  static void shf16_ ## shift ## BEToUV_c(uint8_t *dstU, \
1026  uint8_t *dstV, \
1027  const uint8_t *unused0, \
1028  const uint8_t *src1, \
1029  const uint8_t *src2, int width, \
1030  uint32_t *unused, void *opq) \
1031  { \
1032  int i; \
1033  for (i = 0; i < width; i++) { \
1034  AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 2) >> (16 - shift)); \
1035  AV_WN16(dstV + i * 2, AV_RB16(src2 + i * 2) >> (16 - shift)); \
1036  } \
1037  }
1038 
1039 #define shf16_wrapper(shift) \
1040  static void shf16_ ## shift ## LEToY_c(uint8_t *dst, \
1041  const uint8_t *src, \
1042  const uint8_t *unused1, \
1043  const uint8_t *unused2, int width, \
1044  uint32_t *unused, void *opq) \
1045  { \
1046  int i; \
1047  for (i = 0; i < width; i++) { \
1048  AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> (16 - shift)); \
1049  } \
1050  } \
1051  \
1052  static void shf16_ ## shift ## BEToY_c(uint8_t *dst, \
1053  const uint8_t *src, \
1054  const uint8_t *unused1, \
1055  const uint8_t *unused2, int width, \
1056  uint32_t *unused, void *opq) \
1057  { \
1058  int i; \
1059  for (i = 0; i < width; i++) { \
1060  AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> (16 - shift)); \
1061  } \
1062  } \
1063  shf16_uv_wrapper(shift)
1064 
1065 shf16_wrapper(10)
1066 shf16_wrapper(12)
1067 
1068 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
1069  int width, uint32_t *rgb2yuv, void *opq)
1070 {
1071  int16_t *dst = (int16_t *)_dst;
1072  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1073  int i;
1074  for (i = 0; i < width; i++) {
1075  int b = src[i * 3 + 0];
1076  int g = src[i * 3 + 1];
1077  int r = src[i * 3 + 2];
1078 
1079  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
1080  }
1081 }
1082 
1083 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1084  const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1085 {
1086  int16_t *dstU = (int16_t *)_dstU;
1087  int16_t *dstV = (int16_t *)_dstV;
1088  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1089  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1090  int i;
1091  for (i = 0; i < width; i++) {
1092  int b = src1[3 * i + 0];
1093  int g = src1[3 * i + 1];
1094  int r = src1[3 * i + 2];
1095 
1096  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1097  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1098  }
1099  av_assert1(src1 == src2);
1100 }
1101 
1102 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1103  const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1104 {
1105  int16_t *dstU = (int16_t *)_dstU;
1106  int16_t *dstV = (int16_t *)_dstV;
1107  int i;
1108  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1109  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1110  for (i = 0; i < width; i++) {
1111  int b = src1[6 * i + 0] + src1[6 * i + 3];
1112  int g = src1[6 * i + 1] + src1[6 * i + 4];
1113  int r = src1[6 * i + 2] + src1[6 * i + 5];
1114 
1115  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1116  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1117  }
1118  av_assert1(src1 == src2);
1119 }
1120 
1121 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
1122  uint32_t *rgb2yuv, void *opq)
1123 {
1124  int16_t *dst = (int16_t *)_dst;
1125  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1126  int i;
1127  for (i = 0; i < width; i++) {
1128  int r = src[i * 3 + 0];
1129  int g = src[i * 3 + 1];
1130  int b = src[i * 3 + 2];
1131 
1132  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
1133  }
1134 }
1135 
1136 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1137  const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1138 {
1139  int16_t *dstU = (int16_t *)_dstU;
1140  int16_t *dstV = (int16_t *)_dstV;
1141  int i;
1142  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1143  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1144  av_assert1(src1 == src2);
1145  for (i = 0; i < width; i++) {
1146  int r = src1[3 * i + 0];
1147  int g = src1[3 * i + 1];
1148  int b = src1[3 * i + 2];
1149 
1150  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1151  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
1152  }
1153 }
1154 
1155 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
1156  const uint8_t *src2, int width, uint32_t *rgb2yuv, void *opq)
1157 {
1158  int16_t *dstU = (int16_t *)_dstU;
1159  int16_t *dstV = (int16_t *)_dstV;
1160  int i;
1161  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1162  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1163  av_assert1(src1 == src2);
1164  for (i = 0; i < width; i++) {
1165  int r = src1[6 * i + 0] + src1[6 * i + 3];
1166  int g = src1[6 * i + 1] + src1[6 * i + 4];
1167  int b = src1[6 * i + 2] + src1[6 * i + 5];
1168 
1169  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1170  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
1171  }
1172 }
1173 
1174 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
1175 {
1176  uint16_t *dst = (uint16_t *)_dst;
1177  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1178  int i;
1179  for (i = 0; i < width; i++) {
1180  int g = src[0][i];
1181  int b = src[1][i];
1182  int r = src[2][i];
1183 
1184  dst[i] = (int)((unsigned)ry*r + (unsigned)gy*g + (unsigned)by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
1185  }
1186 }
1187 
1188 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused, void *opq)
1189 {
1190  uint16_t *dst = (uint16_t *)_dst;
1191  int i;
1192  for (i = 0; i < width; i++)
1193  dst[i] = src[3][i] << 6;
1194 }
1195 
1196 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
1197 {
1198  uint16_t *dstU = (uint16_t *)_dstU;
1199  uint16_t *dstV = (uint16_t *)_dstV;
1200  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1201  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1202  int i;
1203  for (i = 0; i < width; i++) {
1204  int g = src[0][i];
1205  int b = src[1][i];
1206  int r = src[2][i];
1207 
1208  dstU[i] = (int)((unsigned)ru*r + (unsigned)gu*g + (unsigned)bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
1209  dstV[i] = (int)((unsigned)rv*r + (unsigned)gv*g + (unsigned)bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
1210  }
1211 }
1212 
1213 #define rdpx(src) \
1214  (is_be ? AV_RB16(src) : AV_RL16(src))
1215 
1216 #define shifted_planar_rgb16_to_y(rdpx_shift) \
1217  static av_always_inline void planar_rgb16_s ## rdpx_shift ## _to_y(uint8_t *_dst, const uint8_t *_src[4], \
1218  int width, int bpc, int is_be, int32_t *rgb2yuv) \
1219  { \
1220  int i; \
1221  const uint16_t **src = (const uint16_t **)_src; \
1222  uint16_t *dst = (uint16_t *)_dst; \
1223  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX]; \
1224  int shift = bpc < 16 ? bpc : 14; \
1225  for (i = 0; i < width; i++) { \
1226  int g = rdpx(src[0] + i) >> (16 - rdpx_shift); \
1227  int b = rdpx(src[1] + i) >> (16 - rdpx_shift); \
1228  int r = rdpx(src[2] + i) >> (16 - rdpx_shift); \
1229  \
1230  dst[i] = (int)((unsigned)ry*r + (unsigned)gy*g + (unsigned)by*b + (16 << (RGB2YUV_SHIFT + bpc - 8)) \
1231  + (1 << (RGB2YUV_SHIFT + shift - 15))) >> (RGB2YUV_SHIFT + shift - 14); \
1232  } \
1233  }
1234 
1235 #define shifted_planar_rgb16_to_a(rdpx_shift) \
1236  static av_always_inline void planar_rgb16_s ## rdpx_shift ## _to_a(uint8_t *_dst, const uint8_t *_src[4], \
1237  int width, int bpc, int is_be, int32_t *rgb2yuv) \
1238  { \
1239  int i; \
1240  const uint16_t **src = (const uint16_t **)_src; \
1241  uint16_t *dst = (uint16_t *)_dst; \
1242  int shift = (bpc < 16 ? bpc : 14) + 16 - rdpx_shift; \
1243  \
1244  for (i = 0; i < width; i++) { \
1245  dst[i] = rdpx(src[3] + i) << (14 - shift); \
1246  } \
1247  } \
1248 
1249 #define shifted_planar_rgb16_to_uv(rdpx_shift) \
1250  static av_always_inline void planar_rgb16_s ## rdpx_shift ## _to_uv(uint8_t *_dstU, uint8_t *_dstV, \
1251  const uint8_t *_src[4], int width, \
1252  int bpc, int is_be, int32_t *rgb2yuv) \
1253  { \
1254  int i; \
1255  const uint16_t **src = (const uint16_t **)_src; \
1256  uint16_t *dstU = (uint16_t *)_dstU; \
1257  uint16_t *dstV = (uint16_t *)_dstV; \
1258  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX]; \
1259  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX]; \
1260  int shift = bpc < 16 ? bpc : 14; \
1261  for (i = 0; i < width; i++) { \
1262  int g = rdpx(src[0] + i) >> (16 - rdpx_shift); \
1263  int b = rdpx(src[1] + i) >> (16 - rdpx_shift); \
1264  int r = rdpx(src[2] + i) >> (16 - rdpx_shift); \
1265  \
1266  dstU[i] = (int)((unsigned)ru*r + (unsigned)gu*g + (unsigned)bu*b + (128 << (RGB2YUV_SHIFT + bpc - 8)) \
1267  + (1 << (RGB2YUV_SHIFT + shift - 15))) >> (RGB2YUV_SHIFT + shift - 14); \
1268  dstV[i] = (int)((unsigned)rv*r + (unsigned)gv*g + (unsigned)bv*b + (128 << (RGB2YUV_SHIFT + bpc - 8)) \
1269  + (1 << (RGB2YUV_SHIFT + shift - 15))) >> (RGB2YUV_SHIFT + shift - 14); \
1270  } \
1271  }
1272 
1273 #define shifted_planar_rgb16_to_y_uv(rdpx_shift) \
1274  shifted_planar_rgb16_to_y(rdpx_shift) \
1275  shifted_planar_rgb16_to_uv(rdpx_shift)
1276 
1277 #define shifted_planar_rgb16(rdpx_shift) \
1278  shifted_planar_rgb16_to_y_uv(rdpx_shift) \
1279  shifted_planar_rgb16_to_a(rdpx_shift)
1280 
1281 shifted_planar_rgb16(16)
1282 shifted_planar_rgb16_to_y_uv(12)
1283 shifted_planar_rgb16_to_y_uv(10)
1284 
1285 #undef rdpx
1286 
1287 #define rdpx(src) (is_be ? av_int2float(AV_RB32(src)): av_int2float(AV_RL32(src)))
1288 
1289 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)
1290 {
1291  int i;
1292  const float **src = (const float **)_src;
1293  uint16_t *dst = (uint16_t *)_dst;
1294 
1295  for (i = 0; i < width; i++) {
1296  dst[i] = lrintf(av_clipf(65535.0f * rdpx(src[3] + i), 0.0f, 65535.0f));
1297  }
1298 }
1299 
1300 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)
1301 {
1302  int i;
1303  const float **src = (const float **)_src;
1304  uint16_t *dstU = (uint16_t *)_dstU;
1305  uint16_t *dstV = (uint16_t *)_dstV;
1306  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1307  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1308 
1309  for (i = 0; i < width; i++) {
1310  int g = lrintf(av_clipf(65535.0f * rdpx(src[0] + i), 0.0f, 65535.0f));
1311  int b = lrintf(av_clipf(65535.0f * rdpx(src[1] + i), 0.0f, 65535.0f));
1312  int r = lrintf(av_clipf(65535.0f * rdpx(src[2] + i), 0.0f, 65535.0f));
1313 
1314  dstU[i] = (int)((unsigned)ru*r + (unsigned)gu*g + (unsigned)bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1315  dstV[i] = (int)((unsigned)rv*r + (unsigned)gv*g + (unsigned)bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1316  }
1317 }
1318 
1319 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)
1320 {
1321  int i;
1322  const float **src = (const float **)_src;
1323  uint16_t *dst = (uint16_t *)_dst;
1324 
1325  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1326 
1327  for (i = 0; i < width; i++) {
1328  int g = lrintf(av_clipf(65535.0f * rdpx(src[0] + i), 0.0f, 65535.0f));
1329  int b = lrintf(av_clipf(65535.0f * rdpx(src[1] + i), 0.0f, 65535.0f));
1330  int r = lrintf(av_clipf(65535.0f * rdpx(src[2] + i), 0.0f, 65535.0f));
1331 
1332  dst[i] = (int)((unsigned)ry*r + (unsigned)gy*g + (unsigned)by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1333  }
1334 }
1335 
1336 static av_always_inline void rgbf32_to_uv_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused1,
1337  const uint8_t *_src, const uint8_t *unused2,
1338  int width, int is_be, int32_t *rgb2yuv)
1339 {
1340  int i;
1341  const float *src = (const float *)_src;
1342  uint16_t *dstU = (uint16_t *)_dstU;
1343  uint16_t *dstV = (uint16_t *)_dstV;
1344  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1345  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1346 
1347  for (i = 0; i < width; i++) {
1348  int r = lrintf(av_clipf(65535.0f * rdpx(&src[3*i]), 0.0f, 65535.0f));
1349  int g = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 1]), 0.0f, 65535.0f));
1350  int b = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 2]), 0.0f, 65535.0f));
1351 
1352  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1353  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1354  }
1355 }
1356 
1357 static av_always_inline void rgbf32_to_uv_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused1,
1358  const uint8_t *_src, const uint8_t *unused2,
1359  int width, int is_be, int32_t *rgb2yuv)
1360 {
1361  const float *src = (const float *) _src;
1362  uint16_t *dstU = (uint16_t *) _dstU;
1363  uint16_t *dstV = (uint16_t *) _dstV;
1364  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1365  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1366 
1367  for (int i = 0; i < width; i++) {
1368  int r = (lrintf(av_clipf(65535.0f * rdpx(&src[6 * i + 0]), 0.0f, 65535.0f)) +
1369  lrintf(av_clipf(65535.0f * rdpx(&src[6 * i + 3]), 0.0f, 65535.0f))) >> 1;
1370  int g = (lrintf(av_clipf(65535.0f * rdpx(&src[6 * i + 1]), 0.0f, 65535.0f)) +
1371  lrintf(av_clipf(65535.0f * rdpx(&src[6 * i + 4]), 0.0f, 65535.0f))) >> 1;
1372  int b = (lrintf(av_clipf(65535.0f * rdpx(&src[6 * i + 2]), 0.0f, 65535.0f)) +
1373  lrintf(av_clipf(65535.0f * rdpx(&src[6 * i + 5]), 0.0f, 65535.0f))) >> 1;
1374 
1375  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1376  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1377  }
1378 }
1379 
1380 static av_always_inline void rgbf32_to_y_c(uint8_t *_dst, const uint8_t *_src,
1381  const uint8_t *unused1, const uint8_t *unused2,
1382  int width, int is_be, int32_t *rgb2yuv)
1383 {
1384  int i;
1385  const float *src = (const float *)_src;
1386  uint16_t *dst = (uint16_t *)_dst;
1387 
1388  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1389 
1390  for (i = 0; i < width; i++) {
1391  int r = lrintf(av_clipf(65535.0f * rdpx(&src[3*i]), 0.0f, 65535.0f));
1392  int g = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 1]), 0.0f, 65535.0f));
1393  int b = lrintf(av_clipf(65535.0f * rdpx(&src[3*i + 2]), 0.0f, 65535.0f));
1394 
1395  dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
1396  }
1397 }
1398 
1399 static av_always_inline void grayf32ToY16_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
1400  const uint8_t *unused2, int width, int is_be, uint32_t *unused)
1401 {
1402  int i;
1403  const float *src = (const float *)_src;
1404  uint16_t *dst = (uint16_t *)_dst;
1405 
1406  for (i = 0; i < width; ++i){
1407  dst[i] = lrintf(av_clipf(65535.0f * rdpx(src + i), 0.0f, 65535.0f));
1408  }
1409 }
1410 
1411 static av_always_inline void read_yaf32_gray_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
1412  const uint8_t *unused2, int width, int is_be, uint32_t *unused)
1413 {
1414  int i;
1415  const float *src = (const float *)_src;
1416  uint16_t *dst = (uint16_t *)_dst;
1417 
1418  for (i = 0; i < width; ++i)
1419  dst[i] = lrintf(av_clipf(65535.0f * rdpx(src + i*2), 0.0f, 65535.0f));
1420 }
1421 
1422 static av_always_inline void read_yaf32_alpha_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
1423  const uint8_t *unused2, int width, int is_be, uint32_t *unused)
1424 {
1425  int i;
1426  const float *src = (const float *)_src;
1427  uint16_t *dst = (uint16_t *)_dst;
1428 
1429  for (i = 0; i < width; ++i)
1430  dst[i] = lrintf(av_clipf(65535.0f * rdpx(src + i*2 + 1), 0.0f, 65535.0f));
1431 }
1432 
1433 #undef rdpx
1434 
1435 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian) \
1436 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1437  int w, int32_t *rgb2yuv, void *opq) \
1438 { \
1439  planar_rgb16_s16_to_y(dst, src, w, nbits, endian, rgb2yuv); \
1440 } \
1441 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1442  const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1443  void *opq) \
1444 { \
1445  planar_rgb16_s16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
1446 } \
1447 
1448 #define rgb9plus_planar_transparency_funcs(nbits) \
1449 static void planar_rgb##nbits##le_to_a(uint8_t *dst, const uint8_t *src[4], \
1450  int w, int32_t *rgb2yuv, \
1451  void *opq) \
1452 { \
1453  planar_rgb16_s16_to_a(dst, src, w, nbits, 0, rgb2yuv); \
1454 } \
1455 static void planar_rgb##nbits##be_to_a(uint8_t *dst, const uint8_t *src[4], \
1456  int w, int32_t *rgb2yuv, \
1457  void *opq) \
1458 { \
1459  planar_rgb16_s16_to_a(dst, src, w, nbits, 1, rgb2yuv); \
1460 }
1461 
1462 #define rgb9plus_msb_planar_funcs_endian(nbits, endian_name, endian) \
1463 static void msb_planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1464  int w, int32_t *rgb2yuv, void *opq) \
1465 { \
1466  planar_rgb16_s##nbits##_to_y(dst, src, w, nbits, endian, rgb2yuv); \
1467 } \
1468 static void msb_planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1469  const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1470  void *opq) \
1471 { \
1472  planar_rgb16_s##nbits##_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
1473 }
1474 
1475 #define rgb9plus_planar_funcs(nbits) \
1476  rgb9plus_planar_funcs_endian(nbits, le, 0) \
1477  rgb9plus_planar_funcs_endian(nbits, be, 1)
1478 
1479 #define rgb9plus_msb_planar_funcs(nbits) \
1480  rgb9plus_msb_planar_funcs_endian(nbits, le, 0) \
1481  rgb9plus_msb_planar_funcs_endian(nbits, be, 1)
1482 
1483 rgb9plus_planar_funcs(9)
1484 rgb9plus_planar_funcs(10)
1485 rgb9plus_planar_funcs(12)
1486 rgb9plus_planar_funcs(14)
1487 rgb9plus_planar_funcs(16)
1488 
1489 rgb9plus_planar_transparency_funcs(10)
1490 rgb9plus_planar_transparency_funcs(12)
1491 rgb9plus_planar_transparency_funcs(14)
1492 rgb9plus_planar_transparency_funcs(16)
1493 
1494 rgb9plus_msb_planar_funcs(10)
1495 rgb9plus_msb_planar_funcs(12)
1496 
1497 #define rgbf32_funcs_endian(endian_name, endian) \
1498 static void planar_rgbf32##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1499  int w, int32_t *rgb2yuv, void *opq) \
1500 { \
1501  planar_rgbf32_to_y(dst, src, w, endian, rgb2yuv); \
1502 } \
1503 static void planar_rgbf32##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1504  const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1505  void *opq) \
1506 { \
1507  planar_rgbf32_to_uv(dstU, dstV, src, w, endian, rgb2yuv); \
1508 } \
1509 static void planar_rgbf32##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4], \
1510  int w, int32_t *rgb2yuv, void *opq) \
1511 { \
1512  planar_rgbf32_to_a(dst, src, w, endian, rgb2yuv); \
1513 } \
1514 static void rgbf32##endian_name##_to_y_c(uint8_t *dst, const uint8_t *src, \
1515  const uint8_t *unused1, const uint8_t *unused2, \
1516  int w, uint32_t *rgb2yuv, void *opq) \
1517 { \
1518  rgbf32_to_y_c(dst, src, unused1, unused2, w, endian, rgb2yuv); \
1519 } \
1520 static void rgbf32##endian_name##_to_uv_c(uint8_t *dstU, uint8_t *dstV, \
1521  const uint8_t *unused1, \
1522  const uint8_t *src, const uint8_t *unused2, \
1523  int w, uint32_t *rgb2yuv, \
1524  void *opq) \
1525 { \
1526  rgbf32_to_uv_c(dstU, dstV, unused1, src, unused2, w, endian, rgb2yuv); \
1527 } \
1528 static void rgbf32##endian_name##_to_uv_half_c(uint8_t *dstU, uint8_t *dstV, \
1529  const uint8_t *unused1, \
1530  const uint8_t *src, const uint8_t *unused2, \
1531  int w, uint32_t *rgb2yuv, \
1532  void *opq) \
1533 { \
1534  rgbf32_to_uv_half_c(dstU, dstV, unused1, src, unused2, w, endian, rgb2yuv); \
1535 } \
1536 static void grayf32##endian_name##ToY16_c(uint8_t *dst, const uint8_t *src, \
1537  const uint8_t *unused1, const uint8_t *unused2, \
1538  int width, uint32_t *unused, void *opq) \
1539 { \
1540  grayf32ToY16_c(dst, src, unused1, unused2, width, endian, unused); \
1541 } \
1542 static void read_yaf32##endian_name##_gray_c(uint8_t *dst, const uint8_t *src, \
1543  const uint8_t *unused1, const uint8_t *unused2, \
1544  int width, uint32_t *unused, void *opq) \
1545 { \
1546  read_yaf32_gray_c(dst, src, unused1, unused2, width, endian, unused); \
1547 } \
1548 static void read_yaf32##endian_name##_alpha_c(uint8_t *dst, const uint8_t *src, \
1549  const uint8_t *unused1, const uint8_t *unused2, \
1550  int width, uint32_t *unused, void *opq) \
1551 { \
1552  read_yaf32_alpha_c(dst, src, unused1, unused2, width, endian, unused); \
1553 }
1554 
1555 rgbf32_funcs_endian(le, 0)
1556 rgbf32_funcs_endian(be, 1)
1557 
1558 #define rdpx(src) av_int2float(half2float(is_be ? AV_RB16(&src) : AV_RL16(&src), h2f_tbl))
1559 #define rdpx2(src) av_int2float(half2float(is_be ? AV_RB16(src) : AV_RL16(src), h2f_tbl))
1560 
1561 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)
1562 {
1563  int i;
1564 
1565  for (i = 0; i < width; i++) {
1566  AV_WN16(dst + 2*i, lrintf(av_clipf(65535.0f * rdpx2(src[3] + 2*i), 0.0f, 65535.0f)));
1567  }
1568 }
1569 
1570 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)
1571 {
1572  int i;
1573  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1574  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1575 
1576  for (i = 0; i < width; i++) {
1577  int g = lrintf(av_clipf(65535.0f * rdpx2(src[0] + 2*i), 0.0f, 65535.0f));
1578  int b = lrintf(av_clipf(65535.0f * rdpx2(src[1] + 2*i), 0.0f, 65535.0f));
1579  int r = lrintf(av_clipf(65535.0f * rdpx2(src[2] + 2*i), 0.0f, 65535.0f));
1580 
1581  AV_WN16(dstU + 2*i, (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1582  AV_WN16(dstV + 2*i, (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1583  }
1584 }
1585 
1586 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)
1587 {
1588  int i;
1589 
1590  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1591 
1592  for (i = 0; i < width; i++) {
1593  int g = lrintf(av_clipf(65535.0f * rdpx2(src[0] + 2*i), 0.0f, 65535.0f));
1594  int b = lrintf(av_clipf(65535.0f * rdpx2(src[1] + 2*i), 0.0f, 65535.0f));
1595  int r = lrintf(av_clipf(65535.0f * rdpx2(src[2] + 2*i), 0.0f, 65535.0f));
1596 
1597  AV_WN16(dst + 2*i, (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
1598  }
1599 }
1600 
1601 static av_always_inline void grayf16ToY16_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
1602  const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
1603 {
1604  int i;
1605 
1606  for (i = 0; i < width; ++i){
1607  AV_WN16(dst + 2*i, lrintf(av_clipf(65535.0f * rdpx2(src + 2*i), 0.0f, 65535.0f)));
1608  }
1609 }
1610 
1611 static av_always_inline void read_yaf16_gray_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
1612  const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
1613 {
1614  uint16_t *dst = (uint16_t *)_dst;
1615 
1616  for (int i = 0; i < width; i++)
1617  dst[i] = lrintf(av_clipf(65535.0f * rdpx2(src + 4*i), 0.0f, 65535.0f));
1618 }
1619 
1620 static av_always_inline void read_yaf16_alpha_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1,
1621  const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
1622 {
1623  uint16_t *dst = (uint16_t *)_dst;
1624 
1625  for (int i = 0; i < width; i++)
1626  dst[i] = lrintf(av_clipf(65535.0f * rdpx2(src + 4*i + 2), 0.0f, 65535.0f));
1627 }
1628 
1629 static av_always_inline void rgbaf16ToUV_half_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1630  const uint16_t *src, int width,
1631  int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1632 {
1633  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1634  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1635  int i;
1636  for (i = 0; i < width; i++) {
1637  int r = (lrintf(av_clipf(65535.0f * rdpx(src[i*8+0]), 0.0f, 65535.0f)) +
1638  lrintf(av_clipf(65535.0f * rdpx(src[i*8+4]), 0.0f, 65535.0f))) >> 1;
1639  int g = (lrintf(av_clipf(65535.0f * rdpx(src[i*8+1]), 0.0f, 65535.0f)) +
1640  lrintf(av_clipf(65535.0f * rdpx(src[i*8+5]), 0.0f, 65535.0f))) >> 1;
1641  int b = (lrintf(av_clipf(65535.0f * rdpx(src[i*8+2]), 0.0f, 65535.0f)) +
1642  lrintf(av_clipf(65535.0f * rdpx(src[i*8+6]), 0.0f, 65535.0f))) >> 1;
1643 
1644  dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1645  dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1646  }
1647 }
1648 
1649 static av_always_inline void rgbaf16ToUV_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1650  const uint16_t *src, int width,
1651  int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1652 {
1653  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1654  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1655  int i;
1656  for (i = 0; i < width; i++) {
1657  int r = lrintf(av_clipf(65535.0f * rdpx(src[i*4+0]), 0.0f, 65535.0f));
1658  int g = lrintf(av_clipf(65535.0f * rdpx(src[i*4+1]), 0.0f, 65535.0f));
1659  int b = lrintf(av_clipf(65535.0f * rdpx(src[i*4+2]), 0.0f, 65535.0f));
1660 
1661  dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1662  dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1663  }
1664 }
1665 
1666 static av_always_inline void rgbaf16ToY_endian(uint16_t *dst, const uint16_t *src, int is_be,
1667  int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1668 {
1669  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1670  int i;
1671  for (i = 0; i < width; i++) {
1672  int r = lrintf(av_clipf(65535.0f * rdpx(src[i*4+0]), 0.0f, 65535.0f));
1673  int g = lrintf(av_clipf(65535.0f * rdpx(src[i*4+1]), 0.0f, 65535.0f));
1674  int b = lrintf(av_clipf(65535.0f * rdpx(src[i*4+2]), 0.0f, 65535.0f));
1675 
1676  dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1677  }
1678 }
1679 
1680 static av_always_inline void rgbaf16ToA_endian(uint16_t *dst, const uint16_t *src, int is_be,
1681  int width, Half2FloatTables *h2f_tbl)
1682 {
1683  int i;
1684  for (i=0; i<width; i++) {
1685  dst[i] = lrintf(av_clipf(65535.0f * rdpx(src[i*4+3]), 0.0f, 65535.0f));
1686  }
1687 }
1688 
1689 static av_always_inline void rgbf16ToUV_half_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1690  const uint16_t *src, int width,
1691  int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1692 {
1693  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1694  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1695  int i;
1696  for (i = 0; i < width; i++) {
1697  int r = (lrintf(av_clipf(65535.0f * rdpx(src[i*6+0]), 0.0f, 65535.0f)) +
1698  lrintf(av_clipf(65535.0f * rdpx(src[i*6+3]), 0.0f, 65535.0f))) >> 1;
1699  int g = (lrintf(av_clipf(65535.0f * rdpx(src[i*6+1]), 0.0f, 65535.0f)) +
1700  lrintf(av_clipf(65535.0f * rdpx(src[i*6+4]), 0.0f, 65535.0f))) >> 1;
1701  int b = (lrintf(av_clipf(65535.0f * rdpx(src[i*6+2]), 0.0f, 65535.0f)) +
1702  lrintf(av_clipf(65535.0f * rdpx(src[i*6+5]), 0.0f, 65535.0f))) >> 1;
1703 
1704  dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1705  dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1706  }
1707 }
1708 
1709 static av_always_inline void rgbf16ToUV_endian(uint16_t *dstU, uint16_t *dstV, int is_be,
1710  const uint16_t *src, int width,
1711  int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1712 {
1713  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
1714  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
1715  int i;
1716  for (i = 0; i < width; i++) {
1717  int r = lrintf(av_clipf(65535.0f * rdpx(src[i*3+0]), 0.0f, 65535.0f));
1718  int g = lrintf(av_clipf(65535.0f * rdpx(src[i*3+1]), 0.0f, 65535.0f));
1719  int b = lrintf(av_clipf(65535.0f * rdpx(src[i*3+2]), 0.0f, 65535.0f));
1720 
1721  dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1722  dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1723  }
1724 }
1725 
1726 static av_always_inline void rgbf16ToY_endian(uint16_t *dst, const uint16_t *src, int is_be,
1727  int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
1728 {
1729  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
1730  int i;
1731  for (i = 0; i < width; i++) {
1732  int r = lrintf(av_clipf(65535.0f * rdpx(src[i*3+0]), 0.0f, 65535.0f));
1733  int g = lrintf(av_clipf(65535.0f * rdpx(src[i*3+1]), 0.0f, 65535.0f));
1734  int b = lrintf(av_clipf(65535.0f * rdpx(src[i*3+2]), 0.0f, 65535.0f));
1735 
1736  dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
1737  }
1738 }
1739 
1740 #undef rdpx
1741 
1742 #define rgbaf16_funcs_endian(endian_name, endian) \
1743 static void planar_rgbf16##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
1744  int w, int32_t *rgb2yuv, void *opq) \
1745 { \
1746  planar_rgbf16_to_y(dst, src, w, endian, rgb2yuv, opq); \
1747 } \
1748 static void planar_rgbf16##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
1749  const uint8_t *src[4], int w, int32_t *rgb2yuv, \
1750  void *opq) \
1751 { \
1752  planar_rgbf16_to_uv(dstU, dstV, src, w, endian, rgb2yuv, opq); \
1753 } \
1754 static void planar_rgbf16##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4], \
1755  int w, int32_t *rgb2yuv, void *opq) \
1756 { \
1757  planar_rgbf16_to_a(dst, src, w, endian, rgb2yuv, opq); \
1758 } \
1759 static void grayf16##endian_name##ToY16_c(uint8_t *dst, const uint8_t *src, \
1760  const uint8_t *unused1, const uint8_t *unused2, \
1761  int width, uint32_t *unused, void *opq) \
1762 { \
1763  grayf16ToY16_c(dst, src, unused1, unused2, width, endian, unused, opq); \
1764 } \
1765 static void read_yaf16##endian_name##_gray_c(uint8_t *dst, const uint8_t *src, \
1766  const uint8_t *unused1, const uint8_t *unused2, \
1767  int width, uint32_t *unused, void *opq) \
1768 { \
1769  read_yaf16_gray_c(dst, src, unused1, unused2, width, endian, unused, opq); \
1770 } \
1771 static void read_yaf16##endian_name##_alpha_c(uint8_t *dst, const uint8_t *src, \
1772  const uint8_t *unused1, const uint8_t *unused2, \
1773  int width, uint32_t *unused, void *opq) \
1774 { \
1775  read_yaf16_alpha_c(dst, src, unused1, unused2, width, endian, unused, opq); \
1776 } \
1777  \
1778 static void rgbaf16##endian_name##ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1779  const uint8_t *src1, const uint8_t *src2, \
1780  int width, uint32_t *_rgb2yuv, void *opq) \
1781 { \
1782  const uint16_t *src = (const uint16_t*)src1; \
1783  uint16_t *dstU = (uint16_t*)_dstU; \
1784  uint16_t *dstV = (uint16_t*)_dstV; \
1785  int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1786  av_assert1(src1==src2); \
1787  rgbaf16ToUV_half_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1788 } \
1789 static void rgbaf16##endian_name##ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1790  const uint8_t *src1, const uint8_t *src2, \
1791  int width, uint32_t *_rgb2yuv, void *opq) \
1792 { \
1793  const uint16_t *src = (const uint16_t*)src1; \
1794  uint16_t *dstU = (uint16_t*)_dstU; \
1795  uint16_t *dstV = (uint16_t*)_dstV; \
1796  int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1797  av_assert1(src1==src2); \
1798  rgbaf16ToUV_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1799 } \
1800 static void rgbaf16##endian_name##ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, \
1801  const uint8_t *unused1, int width, uint32_t *_rgb2yuv, void *opq) \
1802 { \
1803  const uint16_t *src = (const uint16_t*)_src; \
1804  uint16_t *dst = (uint16_t*)_dst; \
1805  int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1806  rgbaf16ToY_endian(dst, src, endian, width, rgb2yuv, opq); \
1807 } \
1808 static void rgbaf16##endian_name##ToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, \
1809  const uint8_t *unused1, int width, uint32_t *unused2, void *opq) \
1810 { \
1811  const uint16_t *src = (const uint16_t*)_src; \
1812  uint16_t *dst = (uint16_t*)_dst; \
1813  rgbaf16ToA_endian(dst, src, endian, width, opq); \
1814 } \
1815 static void rgbf16##endian_name##ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1816  const uint8_t *src1, const uint8_t *src2, \
1817  int width, uint32_t *_rgb2yuv, void *opq) \
1818 { \
1819  const uint16_t *src = (const uint16_t*)src1; \
1820  uint16_t *dstU = (uint16_t*)_dstU; \
1821  uint16_t *dstV = (uint16_t*)_dstV; \
1822  int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1823  av_assert1(src1==src2); \
1824  rgbf16ToUV_half_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1825 } \
1826 static void rgbf16##endian_name##ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused, \
1827  const uint8_t *src1, const uint8_t *src2, \
1828  int width, uint32_t *_rgb2yuv, void *opq) \
1829 { \
1830  const uint16_t *src = (const uint16_t*)src1; \
1831  uint16_t *dstU = (uint16_t*)_dstU; \
1832  uint16_t *dstV = (uint16_t*)_dstV; \
1833  int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1834  av_assert1(src1==src2); \
1835  rgbf16ToUV_endian(dstU, dstV, endian, src, width, rgb2yuv, opq); \
1836 } \
1837 static void rgbf16##endian_name##ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, \
1838  const uint8_t *unused1, int width, uint32_t *_rgb2yuv, void *opq) \
1839 { \
1840  const uint16_t *src = (const uint16_t*)_src; \
1841  uint16_t *dst = (uint16_t*)_dst; \
1842  int32_t *rgb2yuv = (int32_t*)_rgb2yuv; \
1843  rgbf16ToY_endian(dst, src, endian, width, rgb2yuv, opq); \
1844 } \
1845 
1846 rgbaf16_funcs_endian(le, 0)
1847 rgbaf16_funcs_endian(be, 1)
1848 
1849 av_cold void ff_sws_init_input_funcs(SwsInternal *c,
1850  planar1_YV12_fn *lumToYV12,
1851  planar1_YV12_fn *alpToYV12,
1852  planar2_YV12_fn *chrToYV12,
1853  planarX_YV12_fn *readLumPlanar,
1854  planarX_YV12_fn *readAlpPlanar,
1855  planarX2_YV12_fn *readChrPlanar)
1856 {
1857  enum AVPixelFormat srcFormat = c->opts.src_format;
1858 
1859  *chrToYV12 = NULL;
1860  switch (srcFormat) {
1861  case AV_PIX_FMT_YUYV422:
1862  *chrToYV12 = yuy2ToUV_c;
1863  break;
1864  case AV_PIX_FMT_YVYU422:
1865  *chrToYV12 = yvy2ToUV_c;
1866  break;
1867  case AV_PIX_FMT_UYVY422:
1868  *chrToYV12 = uyvyToUV_c;
1869  break;
1870  case AV_PIX_FMT_UYYVYY411:
1871  *chrToYV12 = uyyvyyToUV_c;
1872  break;
1873  case AV_PIX_FMT_VYU444:
1874  *chrToYV12 = vyuToUV_c;
1875  break;
1876  case AV_PIX_FMT_NV12:
1877  case AV_PIX_FMT_NV16:
1878  case AV_PIX_FMT_NV24:
1879  *chrToYV12 = nv12ToUV_c;
1880  break;
1881  case AV_PIX_FMT_NV21:
1882  case AV_PIX_FMT_NV42:
1883  *chrToYV12 = nv21ToUV_c;
1884  break;
1885  case AV_PIX_FMT_RGB8:
1886  case AV_PIX_FMT_BGR8:
1887  case AV_PIX_FMT_PAL8:
1888  case AV_PIX_FMT_BGR4_BYTE:
1889  case AV_PIX_FMT_RGB4_BYTE:
1890  *chrToYV12 = palToUV_c;
1891  break;
1892  case AV_PIX_FMT_GBRP9LE:
1893  *readChrPlanar = planar_rgb9le_to_uv;
1894  break;
1895  case AV_PIX_FMT_GBRAP10LE:
1896  case AV_PIX_FMT_GBRP10LE:
1897  *readChrPlanar = planar_rgb10le_to_uv;
1898  break;
1899  case AV_PIX_FMT_GBRAP12LE:
1900  case AV_PIX_FMT_GBRP12LE:
1901  *readChrPlanar = planar_rgb12le_to_uv;
1902  break;
1903  case AV_PIX_FMT_GBRAP14LE:
1904  case AV_PIX_FMT_GBRP14LE:
1905  *readChrPlanar = planar_rgb14le_to_uv;
1906  break;
1907  case AV_PIX_FMT_GBRAP16LE:
1908  case AV_PIX_FMT_GBRP16LE:
1909  *readChrPlanar = planar_rgb16le_to_uv;
1910  break;
1911  case AV_PIX_FMT_GBRAPF32LE:
1912  case AV_PIX_FMT_GBRPF32LE:
1913  *readChrPlanar = planar_rgbf32le_to_uv;
1914  break;
1915  case AV_PIX_FMT_GBRAPF16LE:
1916  case AV_PIX_FMT_GBRPF16LE:
1917  *readChrPlanar = planar_rgbf16le_to_uv;
1918  break;
1919  case AV_PIX_FMT_GBRP10MSBLE:
1920  *readChrPlanar = msb_planar_rgb10le_to_uv;
1921  break;
1922  case AV_PIX_FMT_GBRP12MSBLE:
1923  *readChrPlanar = msb_planar_rgb12le_to_uv;
1924  break;
1925  case AV_PIX_FMT_GBRP9BE:
1926  *readChrPlanar = planar_rgb9be_to_uv;
1927  break;
1928  case AV_PIX_FMT_GBRAP10BE:
1929  case AV_PIX_FMT_GBRP10BE:
1930  *readChrPlanar = planar_rgb10be_to_uv;
1931  break;
1932  case AV_PIX_FMT_GBRAP12BE:
1933  case AV_PIX_FMT_GBRP12BE:
1934  *readChrPlanar = planar_rgb12be_to_uv;
1935  break;
1936  case AV_PIX_FMT_GBRAP14BE:
1937  case AV_PIX_FMT_GBRP14BE:
1938  *readChrPlanar = planar_rgb14be_to_uv;
1939  break;
1940  case AV_PIX_FMT_GBRAP16BE:
1941  case AV_PIX_FMT_GBRP16BE:
1942  *readChrPlanar = planar_rgb16be_to_uv;
1943  break;
1944  case AV_PIX_FMT_GBRAPF32BE:
1945  case AV_PIX_FMT_GBRPF32BE:
1946  *readChrPlanar = planar_rgbf32be_to_uv;
1947  break;
1948  case AV_PIX_FMT_GBRAPF16BE:
1949  case AV_PIX_FMT_GBRPF16BE:
1950  *readChrPlanar = planar_rgbf16be_to_uv;
1951  break;
1952  case AV_PIX_FMT_GBRP10MSBBE:
1953  *readChrPlanar = msb_planar_rgb10be_to_uv;
1954  break;
1955  case AV_PIX_FMT_GBRP12MSBBE:
1956  *readChrPlanar = msb_planar_rgb12be_to_uv;
1957  break;
1958  case AV_PIX_FMT_GBRAP:
1959  case AV_PIX_FMT_GBRP:
1960  *readChrPlanar = planar_rgb_to_uv;
1961  break;
1962 #if HAVE_BIGENDIAN
1963  case AV_PIX_FMT_YUV420P9LE:
1964  case AV_PIX_FMT_YUV422P9LE:
1965  case AV_PIX_FMT_YUV444P9LE:
1966  case AV_PIX_FMT_YUV420P10LE:
1967  case AV_PIX_FMT_YUV422P10LE:
1968  case AV_PIX_FMT_YUV440P10LE:
1969  case AV_PIX_FMT_YUV444P10LE:
1970  case AV_PIX_FMT_YUV420P12LE:
1971  case AV_PIX_FMT_YUV422P12LE:
1972  case AV_PIX_FMT_YUV440P12LE:
1973  case AV_PIX_FMT_YUV444P12LE:
1974  case AV_PIX_FMT_YUV420P14LE:
1975  case AV_PIX_FMT_YUV422P14LE:
1976  case AV_PIX_FMT_YUV444P14LE:
1977  case AV_PIX_FMT_YUV420P16LE:
1978  case AV_PIX_FMT_YUV422P16LE:
1979  case AV_PIX_FMT_YUV444P16LE:
1980 
1981  case AV_PIX_FMT_YUVA420P9LE:
1982  case AV_PIX_FMT_YUVA422P9LE:
1983  case AV_PIX_FMT_YUVA444P9LE:
1984  case AV_PIX_FMT_YUVA420P10LE:
1985  case AV_PIX_FMT_YUVA422P10LE:
1986  case AV_PIX_FMT_YUVA444P10LE:
1987  case AV_PIX_FMT_YUVA422P12LE:
1988  case AV_PIX_FMT_YUVA444P12LE:
1989  case AV_PIX_FMT_YUVA420P16LE:
1990  case AV_PIX_FMT_YUVA422P16LE:
1991  case AV_PIX_FMT_YUVA444P16LE:
1992  *chrToYV12 = bswap16UV_c;
1993  break;
1994 #else
1995  case AV_PIX_FMT_YUV420P9BE:
1996  case AV_PIX_FMT_YUV422P9BE:
1997  case AV_PIX_FMT_YUV444P9BE:
1998  case AV_PIX_FMT_YUV420P10BE:
1999  case AV_PIX_FMT_YUV422P10BE:
2000  case AV_PIX_FMT_YUV440P10BE:
2001  case AV_PIX_FMT_YUV444P10BE:
2002  case AV_PIX_FMT_YUV420P12BE:
2003  case AV_PIX_FMT_YUV422P12BE:
2004  case AV_PIX_FMT_YUV440P12BE:
2005  case AV_PIX_FMT_YUV444P12BE:
2006  case AV_PIX_FMT_YUV420P14BE:
2007  case AV_PIX_FMT_YUV422P14BE:
2008  case AV_PIX_FMT_YUV444P14BE:
2009  case AV_PIX_FMT_YUV420P16BE:
2010  case AV_PIX_FMT_YUV422P16BE:
2011  case AV_PIX_FMT_YUV444P16BE:
2012 
2013  case AV_PIX_FMT_YUVA420P9BE:
2014  case AV_PIX_FMT_YUVA422P9BE:
2015  case AV_PIX_FMT_YUVA444P9BE:
2016  case AV_PIX_FMT_YUVA420P10BE:
2017  case AV_PIX_FMT_YUVA422P10BE:
2018  case AV_PIX_FMT_YUVA444P10BE:
2019  case AV_PIX_FMT_YUVA422P12BE:
2020  case AV_PIX_FMT_YUVA444P12BE:
2021  case AV_PIX_FMT_YUVA420P16BE:
2022  case AV_PIX_FMT_YUVA422P16BE:
2023  case AV_PIX_FMT_YUVA444P16BE:
2024  *chrToYV12 = bswap16UV_c;
2025  break;
2026 #endif
2027  case AV_PIX_FMT_YUV444P10MSBLE:
2028  *chrToYV12 = shf16_10LEToUV_c;
2029  break;
2030  case AV_PIX_FMT_YUV444P12MSBLE:
2031  *chrToYV12 = shf16_12LEToUV_c;
2032  break;
2033  case AV_PIX_FMT_YUV444P10MSBBE:
2034  *chrToYV12 = shf16_10BEToUV_c;
2035  break;
2036  case AV_PIX_FMT_YUV444P12MSBBE:
2037  *chrToYV12 = shf16_12BEToUV_c;
2038  break;
2039  case AV_PIX_FMT_VUYA:
2040  case AV_PIX_FMT_VUYX:
2041  *chrToYV12 = read_vuyx_UV_c;
2042  break;
2043  case AV_PIX_FMT_XV30LE:
2044  *chrToYV12 = read_xv30le_UV_c;
2045  break;
2046  case AV_PIX_FMT_V30XLE:
2047  *chrToYV12 = read_v30xle_UV_c;
2048  break;
2049  case AV_PIX_FMT_AYUV:
2050  *chrToYV12 = read_ayuv_UV_c;
2051  break;
2052  case AV_PIX_FMT_AYUV64LE:
2053  *chrToYV12 = read_ayuv64le_UV_c;
2054  break;
2055  case AV_PIX_FMT_AYUV64BE:
2056  *chrToYV12 = read_ayuv64be_UV_c;
2057  break;
2058  case AV_PIX_FMT_UYVA:
2059  *chrToYV12 = read_uyva_UV_c;
2060  break;
2061  case AV_PIX_FMT_XV36LE:
2062  *chrToYV12 = read_xv36le_UV_c;
2063  break;
2064  case AV_PIX_FMT_XV36BE:
2065  *chrToYV12 = read_xv36be_UV_c;
2066  break;
2067  case AV_PIX_FMT_XV48LE:
2068  *chrToYV12 = read_xv48le_UV_c;
2069  break;
2070  case AV_PIX_FMT_XV48BE:
2071  *chrToYV12 = read_xv48be_UV_c;
2072  break;
2073  case AV_PIX_FMT_NV20LE:
2074  *chrToYV12 = nv20LEToUV_c;
2075  break;
2076  case AV_PIX_FMT_P010LE:
2077  case AV_PIX_FMT_P210LE:
2078  case AV_PIX_FMT_P410LE:
2079  *chrToYV12 = p010LEToUV_c;
2080  break;
2081  case AV_PIX_FMT_NV20BE:
2082  *chrToYV12 = nv20BEToUV_c;
2083  break;
2084  case AV_PIX_FMT_P010BE:
2085  case AV_PIX_FMT_P210BE:
2086  case AV_PIX_FMT_P410BE:
2087  *chrToYV12 = p010BEToUV_c;
2088  break;
2089  case AV_PIX_FMT_P012LE:
2090  case AV_PIX_FMT_P212LE:
2091  case AV_PIX_FMT_P412LE:
2092  *chrToYV12 = p012LEToUV_c;
2093  break;
2094  case AV_PIX_FMT_P012BE:
2095  case AV_PIX_FMT_P212BE:
2096  case AV_PIX_FMT_P412BE:
2097  *chrToYV12 = p012BEToUV_c;
2098  break;
2099  case AV_PIX_FMT_P016LE:
2100  case AV_PIX_FMT_P216LE:
2101  case AV_PIX_FMT_P416LE:
2102  *chrToYV12 = p016LEToUV_c;
2103  break;
2104  case AV_PIX_FMT_P016BE:
2105  case AV_PIX_FMT_P216BE:
2106  case AV_PIX_FMT_P416BE:
2107  *chrToYV12 = p016BEToUV_c;
2108  break;
2109  case AV_PIX_FMT_Y210LE:
2110  *chrToYV12 = y210le_UV_c;
2111  break;
2112  case AV_PIX_FMT_Y212LE:
2113  *chrToYV12 = y212le_UV_c;
2114  break;
2115  case AV_PIX_FMT_Y216LE:
2116  *chrToYV12 = y216le_UV_c;
2117  break;
2118  case AV_PIX_FMT_RGBF32LE:
2119  *chrToYV12 = rgbf32le_to_uv_c;
2120  break;
2121  case AV_PIX_FMT_RGBF32BE:
2122  *chrToYV12 = rgbf32be_to_uv_c;
2123  break;
2124  }
2125  if (c->chrSrcHSubSample) {
2126  switch (srcFormat) {
2127  case AV_PIX_FMT_RGBA64BE:
2128  *chrToYV12 = rgb64BEToUV_half_c;
2129  break;
2130  case AV_PIX_FMT_RGBA64LE:
2131  *chrToYV12 = rgb64LEToUV_half_c;
2132  break;
2133  case AV_PIX_FMT_BGRA64BE:
2134  *chrToYV12 = bgr64BEToUV_half_c;
2135  break;
2136  case AV_PIX_FMT_BGRA64LE:
2137  *chrToYV12 = bgr64LEToUV_half_c;
2138  break;
2139  case AV_PIX_FMT_RGB48BE:
2140  *chrToYV12 = rgb48BEToUV_half_c;
2141  break;
2142  case AV_PIX_FMT_RGB48LE:
2143  *chrToYV12 = rgb48LEToUV_half_c;
2144  break;
2145  case AV_PIX_FMT_BGR48BE:
2146  *chrToYV12 = bgr48BEToUV_half_c;
2147  break;
2148  case AV_PIX_FMT_BGR48LE:
2149  *chrToYV12 = bgr48LEToUV_half_c;
2150  break;
2151  case AV_PIX_FMT_RGB32:
2152  *chrToYV12 = bgr32ToUV_half_c;
2153  break;
2154  case AV_PIX_FMT_RGB32_1:
2155  *chrToYV12 = bgr321ToUV_half_c;
2156  break;
2157  case AV_PIX_FMT_BGR24:
2158  *chrToYV12 = bgr24ToUV_half_c;
2159  break;
2160  case AV_PIX_FMT_BGR565LE:
2161  *chrToYV12 = bgr16leToUV_half_c;
2162  break;
2163  case AV_PIX_FMT_BGR565BE:
2164  *chrToYV12 = bgr16beToUV_half_c;
2165  break;
2166  case AV_PIX_FMT_BGR555LE:
2167  *chrToYV12 = bgr15leToUV_half_c;
2168  break;
2169  case AV_PIX_FMT_BGR555BE:
2170  *chrToYV12 = bgr15beToUV_half_c;
2171  break;
2172  case AV_PIX_FMT_GBRAP:
2173  case AV_PIX_FMT_GBRP:
2174  *chrToYV12 = gbr24pToUV_half_c;
2175  break;
2176  case AV_PIX_FMT_BGR444LE:
2177  *chrToYV12 = bgr12leToUV_half_c;
2178  break;
2179  case AV_PIX_FMT_BGR444BE:
2180  *chrToYV12 = bgr12beToUV_half_c;
2181  break;
2182  case AV_PIX_FMT_BGR32:
2183  *chrToYV12 = rgb32ToUV_half_c;
2184  break;
2185  case AV_PIX_FMT_BGR32_1:
2186  *chrToYV12 = rgb321ToUV_half_c;
2187  break;
2188  case AV_PIX_FMT_RGB24:
2189  *chrToYV12 = rgb24ToUV_half_c;
2190  break;
2191  case AV_PIX_FMT_RGB565LE:
2192  *chrToYV12 = rgb16leToUV_half_c;
2193  break;
2194  case AV_PIX_FMT_RGB565BE:
2195  *chrToYV12 = rgb16beToUV_half_c;
2196  break;
2197  case AV_PIX_FMT_RGB555LE:
2198  *chrToYV12 = rgb15leToUV_half_c;
2199  break;
2200  case AV_PIX_FMT_RGB555BE:
2201  *chrToYV12 = rgb15beToUV_half_c;
2202  break;
2203  case AV_PIX_FMT_RGB444LE:
2204  *chrToYV12 = rgb12leToUV_half_c;
2205  break;
2206  case AV_PIX_FMT_RGB444BE:
2207  *chrToYV12 = rgb12beToUV_half_c;
2208  break;
2209  case AV_PIX_FMT_X2RGB10LE:
2210  *chrToYV12 = rgb30leToUV_half_c;
2211  break;
2212  case AV_PIX_FMT_X2BGR10LE:
2213  *chrToYV12 = bgr30leToUV_half_c;
2214  break;
2215  case AV_PIX_FMT_RGBAF16BE:
2216  *chrToYV12 = rgbaf16beToUV_half_c;
2217  break;
2218  case AV_PIX_FMT_RGBAF16LE:
2219  *chrToYV12 = rgbaf16leToUV_half_c;
2220  break;
2221  case AV_PIX_FMT_RGBF16BE:
2222  *chrToYV12 = rgbf16beToUV_half_c;
2223  break;
2224  case AV_PIX_FMT_RGBF16LE:
2225  *chrToYV12 = rgbf16leToUV_half_c;
2226  break;
2227  case AV_PIX_FMT_RGBF32BE:
2228  *chrToYV12 = rgbf32be_to_uv_half_c;
2229  break;
2230  case AV_PIX_FMT_RGBF32LE:
2231  *chrToYV12 = rgbf32le_to_uv_half_c;
2232  break;
2233  }
2234  } else {
2235  switch (srcFormat) {
2236  case AV_PIX_FMT_RGBA64BE:
2237  *chrToYV12 = rgb64BEToUV_c;
2238  break;
2239  case AV_PIX_FMT_RGBA64LE:
2240  *chrToYV12 = rgb64LEToUV_c;
2241  break;
2242  case AV_PIX_FMT_BGRA64BE:
2243  *chrToYV12 = bgr64BEToUV_c;
2244  break;
2245  case AV_PIX_FMT_BGRA64LE:
2246  *chrToYV12 = bgr64LEToUV_c;
2247  break;
2248  case AV_PIX_FMT_RGB48BE:
2249  *chrToYV12 = rgb48BEToUV_c;
2250  break;
2251  case AV_PIX_FMT_RGB48LE:
2252  *chrToYV12 = rgb48LEToUV_c;
2253  break;
2254  case AV_PIX_FMT_BGR48BE:
2255  *chrToYV12 = bgr48BEToUV_c;
2256  break;
2257  case AV_PIX_FMT_BGR48LE:
2258  *chrToYV12 = bgr48LEToUV_c;
2259  break;
2260  case AV_PIX_FMT_RGB32:
2261  *chrToYV12 = bgr32ToUV_c;
2262  break;
2263  case AV_PIX_FMT_RGB32_1:
2264  *chrToYV12 = bgr321ToUV_c;
2265  break;
2266  case AV_PIX_FMT_BGR24:
2267  *chrToYV12 = bgr24ToUV_c;
2268  break;
2269  case AV_PIX_FMT_BGR565LE:
2270  *chrToYV12 = bgr16leToUV_c;
2271  break;
2272  case AV_PIX_FMT_BGR565BE:
2273  *chrToYV12 = bgr16beToUV_c;
2274  break;
2275  case AV_PIX_FMT_BGR555LE:
2276  *chrToYV12 = bgr15leToUV_c;
2277  break;
2278  case AV_PIX_FMT_BGR555BE:
2279  *chrToYV12 = bgr15beToUV_c;
2280  break;
2281  case AV_PIX_FMT_BGR444LE:
2282  *chrToYV12 = bgr12leToUV_c;
2283  break;
2284  case AV_PIX_FMT_BGR444BE:
2285  *chrToYV12 = bgr12beToUV_c;
2286  break;
2287  case AV_PIX_FMT_BGR32:
2288  *chrToYV12 = rgb32ToUV_c;
2289  break;
2290  case AV_PIX_FMT_BGR32_1:
2291  *chrToYV12 = rgb321ToUV_c;
2292  break;
2293  case AV_PIX_FMT_RGB24:
2294  *chrToYV12 = rgb24ToUV_c;
2295  break;
2296  case AV_PIX_FMT_RGB565LE:
2297  *chrToYV12 = rgb16leToUV_c;
2298  break;
2299  case AV_PIX_FMT_RGB565BE:
2300  *chrToYV12 = rgb16beToUV_c;
2301  break;
2302  case AV_PIX_FMT_RGB555LE:
2303  *chrToYV12 = rgb15leToUV_c;
2304  break;
2305  case AV_PIX_FMT_RGB555BE:
2306  *chrToYV12 = rgb15beToUV_c;
2307  break;
2308  case AV_PIX_FMT_RGB444LE:
2309  *chrToYV12 = rgb12leToUV_c;
2310  break;
2311  case AV_PIX_FMT_RGB444BE:
2312  *chrToYV12 = rgb12beToUV_c;
2313  break;
2314  case AV_PIX_FMT_X2RGB10LE:
2315  *chrToYV12 = rgb30leToUV_c;
2316  break;
2317  case AV_PIX_FMT_X2BGR10LE:
2318  *chrToYV12 = bgr30leToUV_c;
2319  break;
2320  case AV_PIX_FMT_RGBAF16BE:
2321  *chrToYV12 = rgbaf16beToUV_c;
2322  break;
2323  case AV_PIX_FMT_RGBAF16LE:
2324  *chrToYV12 = rgbaf16leToUV_c;
2325  break;
2326  case AV_PIX_FMT_RGBF16BE:
2327  *chrToYV12 = rgbf16beToUV_c;
2328  break;
2329  case AV_PIX_FMT_RGBF16LE:
2330  *chrToYV12 = rgbf16leToUV_c;
2331  break;
2332  }
2333  }
2334 
2335  *lumToYV12 = NULL;
2336  *alpToYV12 = NULL;
2337  switch (srcFormat) {
2338  case AV_PIX_FMT_GBRP9LE:
2339  *readLumPlanar = planar_rgb9le_to_y;
2340  break;
2341  case AV_PIX_FMT_GBRAP10LE:
2342  *readAlpPlanar = planar_rgb10le_to_a;
2343  av_fallthrough;
2344  case AV_PIX_FMT_GBRP10LE:
2345  *readLumPlanar = planar_rgb10le_to_y;
2346  break;
2347  case AV_PIX_FMT_GBRAP12LE:
2348  *readAlpPlanar = planar_rgb12le_to_a;
2349  av_fallthrough;
2350  case AV_PIX_FMT_GBRP12LE:
2351  *readLumPlanar = planar_rgb12le_to_y;
2352  break;
2353  case AV_PIX_FMT_GBRAP14LE:
2354  *readAlpPlanar = planar_rgb14le_to_a;
2355  av_fallthrough;
2356  case AV_PIX_FMT_GBRP14LE:
2357  *readLumPlanar = planar_rgb14le_to_y;
2358  break;
2359  case AV_PIX_FMT_GBRAP16LE:
2360  *readAlpPlanar = planar_rgb16le_to_a;
2361  av_fallthrough;
2362  case AV_PIX_FMT_GBRP16LE:
2363  *readLumPlanar = planar_rgb16le_to_y;
2364  break;
2365  case AV_PIX_FMT_GBRAPF32LE:
2366  *readAlpPlanar = planar_rgbf32le_to_a;
2367  av_fallthrough;
2368  case AV_PIX_FMT_GBRPF32LE:
2369  *readLumPlanar = planar_rgbf32le_to_y;
2370  break;
2371  case AV_PIX_FMT_GBRAPF16LE:
2372  *readAlpPlanar = planar_rgbf16le_to_a;
2373  av_fallthrough;
2374  case AV_PIX_FMT_GBRPF16LE:
2375  *readLumPlanar = planar_rgbf16le_to_y;
2376  break;
2377  case AV_PIX_FMT_GBRP10MSBLE:
2378  *readLumPlanar = msb_planar_rgb10le_to_y;
2379  break;
2380  case AV_PIX_FMT_GBRP12MSBLE:
2381  *readLumPlanar = msb_planar_rgb12le_to_y;
2382  break;
2383  case AV_PIX_FMT_GBRP9BE:
2384  *readLumPlanar = planar_rgb9be_to_y;
2385  break;
2386  case AV_PIX_FMT_GBRAP10BE:
2387  *readAlpPlanar = planar_rgb10be_to_a;
2388  av_fallthrough;
2389  case AV_PIX_FMT_GBRP10BE:
2390  *readLumPlanar = planar_rgb10be_to_y;
2391  break;
2392  case AV_PIX_FMT_GBRAP12BE:
2393  *readAlpPlanar = planar_rgb12be_to_a;
2394  av_fallthrough;
2395  case AV_PIX_FMT_GBRP12BE:
2396  *readLumPlanar = planar_rgb12be_to_y;
2397  break;
2398  case AV_PIX_FMT_GBRAP14BE:
2399  *readAlpPlanar = planar_rgb14be_to_a;
2400  av_fallthrough;
2401  case AV_PIX_FMT_GBRP14BE:
2402  *readLumPlanar = planar_rgb14be_to_y;
2403  break;
2404  case AV_PIX_FMT_GBRAP16BE:
2405  *readAlpPlanar = planar_rgb16be_to_a;
2406  av_fallthrough;
2407  case AV_PIX_FMT_GBRP16BE:
2408  *readLumPlanar = planar_rgb16be_to_y;
2409  break;
2410  case AV_PIX_FMT_GBRAPF32BE:
2411  *readAlpPlanar = planar_rgbf32be_to_a;
2412  av_fallthrough;
2413  case AV_PIX_FMT_GBRPF32BE:
2414  *readLumPlanar = planar_rgbf32be_to_y;
2415  break;
2416  case AV_PIX_FMT_GBRAPF16BE:
2417  *readAlpPlanar = planar_rgbf16be_to_a;
2418  av_fallthrough;
2419  case AV_PIX_FMT_GBRPF16BE:
2420  *readLumPlanar = planar_rgbf16be_to_y;
2421  break;
2422  case AV_PIX_FMT_GBRP10MSBBE:
2423  *readLumPlanar = msb_planar_rgb10be_to_y;
2424  break;
2425  case AV_PIX_FMT_GBRP12MSBBE:
2426  *readLumPlanar = msb_planar_rgb12be_to_y;
2427  break;
2428  case AV_PIX_FMT_GBRAP:
2429  *readAlpPlanar = planar_rgb_to_a;
2430  av_fallthrough;
2431  case AV_PIX_FMT_GBRP:
2432  *readLumPlanar = planar_rgb_to_y;
2433  break;
2434 #if HAVE_BIGENDIAN
2435  case AV_PIX_FMT_YUV420P9LE:
2436  case AV_PIX_FMT_YUV422P9LE:
2437  case AV_PIX_FMT_YUV444P9LE:
2438  case AV_PIX_FMT_YUV420P10LE:
2439  case AV_PIX_FMT_YUV422P10LE:
2440  case AV_PIX_FMT_YUV440P10LE:
2441  case AV_PIX_FMT_YUV444P10LE:
2442  case AV_PIX_FMT_YUV420P12LE:
2443  case AV_PIX_FMT_YUV422P12LE:
2444  case AV_PIX_FMT_YUV440P12LE:
2445  case AV_PIX_FMT_YUV444P12LE:
2446  case AV_PIX_FMT_YUV420P14LE:
2447  case AV_PIX_FMT_YUV422P14LE:
2448  case AV_PIX_FMT_YUV444P14LE:
2449  case AV_PIX_FMT_YUV420P16LE:
2450  case AV_PIX_FMT_YUV422P16LE:
2451  case AV_PIX_FMT_YUV444P16LE:
2452 
2453  case AV_PIX_FMT_GRAY9LE:
2454  case AV_PIX_FMT_GRAY10LE:
2455  case AV_PIX_FMT_GRAY12LE:
2456  case AV_PIX_FMT_GRAY14LE:
2457  case AV_PIX_FMT_GRAY16LE:
2458 
2459  case AV_PIX_FMT_P016LE:
2460  case AV_PIX_FMT_P216LE:
2461  case AV_PIX_FMT_P416LE:
2462  *lumToYV12 = bswap16Y_c;
2463  break;
2464  case AV_PIX_FMT_YUVA420P9LE:
2465  case AV_PIX_FMT_YUVA422P9LE:
2466  case AV_PIX_FMT_YUVA444P9LE:
2467  case AV_PIX_FMT_YUVA420P10LE:
2468  case AV_PIX_FMT_YUVA422P10LE:
2469  case AV_PIX_FMT_YUVA444P10LE:
2470  case AV_PIX_FMT_YUVA422P12LE:
2471  case AV_PIX_FMT_YUVA444P12LE:
2472  case AV_PIX_FMT_YUVA420P16LE:
2473  case AV_PIX_FMT_YUVA422P16LE:
2474  case AV_PIX_FMT_YUVA444P16LE:
2475  *lumToYV12 = bswap16Y_c;
2476  *alpToYV12 = bswap16Y_c;
2477  break;
2478 #else
2479  case AV_PIX_FMT_YUV420P9BE:
2480  case AV_PIX_FMT_YUV422P9BE:
2481  case AV_PIX_FMT_YUV444P9BE:
2482  case AV_PIX_FMT_YUV420P10BE:
2483  case AV_PIX_FMT_YUV422P10BE:
2484  case AV_PIX_FMT_YUV440P10BE:
2485  case AV_PIX_FMT_YUV444P10BE:
2486  case AV_PIX_FMT_YUV420P12BE:
2487  case AV_PIX_FMT_YUV422P12BE:
2488  case AV_PIX_FMT_YUV440P12BE:
2489  case AV_PIX_FMT_YUV444P12BE:
2490  case AV_PIX_FMT_YUV420P14BE:
2491  case AV_PIX_FMT_YUV422P14BE:
2492  case AV_PIX_FMT_YUV444P14BE:
2493  case AV_PIX_FMT_YUV420P16BE:
2494  case AV_PIX_FMT_YUV422P16BE:
2495  case AV_PIX_FMT_YUV444P16BE:
2496 
2497  case AV_PIX_FMT_GRAY9BE:
2498  case AV_PIX_FMT_GRAY10BE:
2499  case AV_PIX_FMT_GRAY12BE:
2500  case AV_PIX_FMT_GRAY14BE:
2501  case AV_PIX_FMT_GRAY16BE:
2502 
2503  case AV_PIX_FMT_P016BE:
2504  case AV_PIX_FMT_P216BE:
2505  case AV_PIX_FMT_P416BE:
2506  *lumToYV12 = bswap16Y_c;
2507  break;
2508  case AV_PIX_FMT_YUVA420P9BE:
2509  case AV_PIX_FMT_YUVA422P9BE:
2510  case AV_PIX_FMT_YUVA444P9BE:
2511  case AV_PIX_FMT_YUVA420P10BE:
2512  case AV_PIX_FMT_YUVA422P10BE:
2513  case AV_PIX_FMT_YUVA444P10BE:
2514  case AV_PIX_FMT_YUVA422P12BE:
2515  case AV_PIX_FMT_YUVA444P12BE:
2516  case AV_PIX_FMT_YUVA420P16BE:
2517  case AV_PIX_FMT_YUVA422P16BE:
2518  case AV_PIX_FMT_YUVA444P16BE:
2519  *lumToYV12 = bswap16Y_c;
2520  *alpToYV12 = bswap16Y_c;
2521  break;
2522 #endif
2523  case AV_PIX_FMT_YUV444P10MSBLE:
2524  *lumToYV12 = shf16_10LEToY_c;
2525  break;
2526  case AV_PIX_FMT_YUV444P12MSBLE:
2527  *lumToYV12 = shf16_12LEToY_c;
2528  break;
2529  case AV_PIX_FMT_YUV444P10MSBBE:
2530  *lumToYV12 = shf16_10BEToY_c;
2531  break;
2532  case AV_PIX_FMT_YUV444P12MSBBE:
2533  *lumToYV12 = shf16_12BEToY_c;
2534  break;
2535  case AV_PIX_FMT_YA16LE:
2536  *lumToYV12 = read_ya16le_gray_c;
2537  break;
2538  case AV_PIX_FMT_YA16BE:
2539  *lumToYV12 = read_ya16be_gray_c;
2540  break;
2541  case AV_PIX_FMT_YAF16LE:
2542  *lumToYV12 = read_yaf16le_gray_c;
2543  break;
2544  case AV_PIX_FMT_YAF16BE:
2545  *lumToYV12 = read_yaf16be_gray_c;
2546  break;
2547  case AV_PIX_FMT_VUYA:
2548  case AV_PIX_FMT_VUYX:
2549  *lumToYV12 = read_vuyx_Y_c;
2550  break;
2551  case AV_PIX_FMT_XV30LE:
2552  *lumToYV12 = read_xv30le_Y_c;
2553  break;
2554  case AV_PIX_FMT_V30XLE:
2555  *lumToYV12 = read_v30xle_Y_c;
2556  break;
2557  case AV_PIX_FMT_AYUV:
2558  case AV_PIX_FMT_UYVA:
2559  *lumToYV12 = read_ayuv_Y_c;
2560  break;
2561  case AV_PIX_FMT_AYUV64LE:
2562  case AV_PIX_FMT_XV48LE:
2563  *lumToYV12 = read_ayuv64le_Y_c;
2564  break;
2565  case AV_PIX_FMT_AYUV64BE:
2566  case AV_PIX_FMT_XV48BE:
2567  *lumToYV12 = read_ayuv64be_Y_c;
2568  break;
2569  case AV_PIX_FMT_XV36LE:
2570  *lumToYV12 = read_xv36le_Y_c;
2571  break;
2572  case AV_PIX_FMT_XV36BE:
2573  *lumToYV12 = read_xv36be_Y_c;
2574  break;
2575  case AV_PIX_FMT_YUYV422:
2576  case AV_PIX_FMT_YVYU422:
2577  case AV_PIX_FMT_YA8:
2578  *lumToYV12 = yuy2ToY_c;
2579  break;
2580  case AV_PIX_FMT_UYVY422:
2581  *lumToYV12 = uyvyToY_c;
2582  break;
2583  case AV_PIX_FMT_UYYVYY411:
2584  *lumToYV12 = uyyvyyToY_c;
2585  break;
2586  case AV_PIX_FMT_VYU444:
2587  *lumToYV12 = vyuToY_c;
2588  break;
2589  case AV_PIX_FMT_BGR24:
2590  *lumToYV12 = bgr24ToY_c;
2591  break;
2592  case AV_PIX_FMT_BGR565LE:
2593  *lumToYV12 = bgr16leToY_c;
2594  break;
2595  case AV_PIX_FMT_BGR565BE:
2596  *lumToYV12 = bgr16beToY_c;
2597  break;
2598  case AV_PIX_FMT_BGR555LE:
2599  *lumToYV12 = bgr15leToY_c;
2600  break;
2601  case AV_PIX_FMT_BGR555BE:
2602  *lumToYV12 = bgr15beToY_c;
2603  break;
2604  case AV_PIX_FMT_BGR444LE:
2605  *lumToYV12 = bgr12leToY_c;
2606  break;
2607  case AV_PIX_FMT_BGR444BE:
2608  *lumToYV12 = bgr12beToY_c;
2609  break;
2610  case AV_PIX_FMT_RGB24:
2611  *lumToYV12 = rgb24ToY_c;
2612  break;
2613  case AV_PIX_FMT_RGB565LE:
2614  *lumToYV12 = rgb16leToY_c;
2615  break;
2616  case AV_PIX_FMT_RGB565BE:
2617  *lumToYV12 = rgb16beToY_c;
2618  break;
2619  case AV_PIX_FMT_RGB555LE:
2620  *lumToYV12 = rgb15leToY_c;
2621  break;
2622  case AV_PIX_FMT_RGB555BE:
2623  *lumToYV12 = rgb15beToY_c;
2624  break;
2625  case AV_PIX_FMT_RGB444LE:
2626  *lumToYV12 = rgb12leToY_c;
2627  break;
2628  case AV_PIX_FMT_RGB444BE:
2629  *lumToYV12 = rgb12beToY_c;
2630  break;
2631  case AV_PIX_FMT_RGB8:
2632  case AV_PIX_FMT_BGR8:
2633  case AV_PIX_FMT_PAL8:
2634  case AV_PIX_FMT_BGR4_BYTE:
2635  case AV_PIX_FMT_RGB4_BYTE:
2636  *lumToYV12 = palToY_c;
2637  break;
2638  case AV_PIX_FMT_MONOBLACK:
2639  *lumToYV12 = monoblack2Y_c;
2640  break;
2641  case AV_PIX_FMT_MONOWHITE:
2642  *lumToYV12 = monowhite2Y_c;
2643  break;
2644  case AV_PIX_FMT_RGB32:
2645  *lumToYV12 = bgr32ToY_c;
2646  break;
2647  case AV_PIX_FMT_RGB32_1:
2648  *lumToYV12 = bgr321ToY_c;
2649  break;
2650  case AV_PIX_FMT_BGR32:
2651  *lumToYV12 = rgb32ToY_c;
2652  break;
2653  case AV_PIX_FMT_BGR32_1:
2654  *lumToYV12 = rgb321ToY_c;
2655  break;
2656  case AV_PIX_FMT_RGB48BE:
2657  *lumToYV12 = rgb48BEToY_c;
2658  break;
2659  case AV_PIX_FMT_RGB48LE:
2660  *lumToYV12 = rgb48LEToY_c;
2661  break;
2662  case AV_PIX_FMT_BGR48BE:
2663  *lumToYV12 = bgr48BEToY_c;
2664  break;
2665  case AV_PIX_FMT_BGR48LE:
2666  *lumToYV12 = bgr48LEToY_c;
2667  break;
2668  case AV_PIX_FMT_RGBA64BE:
2669  *lumToYV12 = rgb64BEToY_c;
2670  break;
2671  case AV_PIX_FMT_RGBA64LE:
2672  *lumToYV12 = rgb64LEToY_c;
2673  break;
2674  case AV_PIX_FMT_BGRA64BE:
2675  *lumToYV12 = bgr64BEToY_c;
2676  break;
2677  case AV_PIX_FMT_BGRA64LE:
2678  *lumToYV12 = bgr64LEToY_c;
2679  break;
2680  case AV_PIX_FMT_NV20LE:
2681  *lumToYV12 = nv20LEToY_c;
2682  break;
2683  case AV_PIX_FMT_P010LE:
2684  case AV_PIX_FMT_P210LE:
2685  case AV_PIX_FMT_P410LE:
2686  *lumToYV12 = p010LEToY_c;
2687  break;
2688  case AV_PIX_FMT_NV20BE:
2689  *lumToYV12 = nv20BEToY_c;
2690  break;
2691  case AV_PIX_FMT_P010BE:
2692  case AV_PIX_FMT_P210BE:
2693  case AV_PIX_FMT_P410BE:
2694  *lumToYV12 = p010BEToY_c;
2695  break;
2696  case AV_PIX_FMT_P012LE:
2697  case AV_PIX_FMT_P212LE:
2698  case AV_PIX_FMT_P412LE:
2699  *lumToYV12 = p012LEToY_c;
2700  break;
2701  case AV_PIX_FMT_P012BE:
2702  case AV_PIX_FMT_P212BE:
2703  case AV_PIX_FMT_P412BE:
2704  *lumToYV12 = p012BEToY_c;
2705  break;
2706  case AV_PIX_FMT_GRAYF32LE:
2707  *lumToYV12 = grayf32leToY16_c;
2708  break;
2709  case AV_PIX_FMT_GRAYF32BE:
2710  *lumToYV12 = grayf32beToY16_c;
2711  break;
2712  case AV_PIX_FMT_YAF32LE:
2713  *lumToYV12 = read_yaf32le_gray_c;
2714  break;
2715  case AV_PIX_FMT_YAF32BE:
2716  *lumToYV12 = read_yaf32be_gray_c;
2717  break;
2718  case AV_PIX_FMT_GRAYF16LE:
2719  *lumToYV12 = grayf16leToY16_c;
2720  break;
2721  case AV_PIX_FMT_GRAYF16BE:
2722  *lumToYV12 = grayf16beToY16_c;
2723  break;
2724  case AV_PIX_FMT_Y210LE:
2725  *lumToYV12 = y210le_Y_c;
2726  break;
2727  case AV_PIX_FMT_Y212LE:
2728  *lumToYV12 = y212le_Y_c;
2729  break;
2730  case AV_PIX_FMT_Y216LE:
2731  *lumToYV12 = y216le_Y_c;
2732  break;
2733  case AV_PIX_FMT_X2RGB10LE:
2734  *lumToYV12 = rgb30leToY_c;
2735  break;
2736  case AV_PIX_FMT_X2BGR10LE:
2737  *lumToYV12 = bgr30leToY_c;
2738  break;
2739  case AV_PIX_FMT_RGBAF16BE:
2740  *lumToYV12 = rgbaf16beToY_c;
2741  break;
2742  case AV_PIX_FMT_RGBAF16LE:
2743  *lumToYV12 = rgbaf16leToY_c;
2744  break;
2745  case AV_PIX_FMT_RGBF16BE:
2746  *lumToYV12 = rgbf16beToY_c;
2747  break;
2748  case AV_PIX_FMT_RGBF16LE:
2749  *lumToYV12 = rgbf16leToY_c;
2750  break;
2751  case AV_PIX_FMT_RGBF32LE:
2752  *lumToYV12 = rgbf32le_to_y_c;
2753  break;
2754  case AV_PIX_FMT_RGBF32BE:
2755  *lumToYV12 = rgbf32be_to_y_c;
2756  break;
2757  }
2758  if (c->needAlpha) {
2759  if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
2760  if (HAVE_BIGENDIAN == !isBE(srcFormat) && !*readAlpPlanar)
2761  *alpToYV12 = bswap16Y_c;
2762  }
2763  switch (srcFormat) {
2764  case AV_PIX_FMT_BGRA64LE:
2765  case AV_PIX_FMT_RGBA64LE: *alpToYV12 = rgba64leToA_c; break;
2766  case AV_PIX_FMT_BGRA64BE:
2767  case AV_PIX_FMT_RGBA64BE: *alpToYV12 = rgba64beToA_c; break;
2768  case AV_PIX_FMT_BGRA:
2769  case AV_PIX_FMT_RGBA:
2770  *alpToYV12 = rgbaToA_c;
2771  break;
2772  case AV_PIX_FMT_ABGR:
2773  case AV_PIX_FMT_ARGB:
2774  *alpToYV12 = abgrToA_c;
2775  break;
2776  case AV_PIX_FMT_RGBAF16BE:
2777  *alpToYV12 = rgbaf16beToA_c;
2778  break;
2779  case AV_PIX_FMT_RGBAF16LE:
2780  *alpToYV12 = rgbaf16leToA_c;
2781  break;
2782  case AV_PIX_FMT_YA8:
2783  *alpToYV12 = uyvyToY_c;
2784  break;
2785  case AV_PIX_FMT_YA16LE:
2786  *alpToYV12 = read_ya16le_alpha_c;
2787  break;
2788  case AV_PIX_FMT_YA16BE:
2789  *alpToYV12 = read_ya16be_alpha_c;
2790  break;
2791  case AV_PIX_FMT_YAF16LE:
2792  *alpToYV12 = read_yaf16le_alpha_c;
2793  break;
2794  case AV_PIX_FMT_YAF16BE:
2795  *alpToYV12 = read_yaf16be_alpha_c;
2796  break;
2797  case AV_PIX_FMT_YAF32LE:
2798  *alpToYV12 = read_yaf32le_alpha_c;
2799  break;
2800  case AV_PIX_FMT_YAF32BE:
2801  *alpToYV12 = read_yaf32be_alpha_c;
2802  break;
2803  case AV_PIX_FMT_VUYA:
2804  case AV_PIX_FMT_UYVA:
2805  *alpToYV12 = read_vuya_A_c;
2806  break;
2807  case AV_PIX_FMT_AYUV:
2808  *alpToYV12 = read_ayuv_A_c;
2809  break;
2810  case AV_PIX_FMT_AYUV64LE:
2811  *alpToYV12 = read_ayuv64le_A_c;
2812  break;
2813  case AV_PIX_FMT_AYUV64BE:
2814  *alpToYV12 = read_ayuv64be_A_c;
2815  break;
2816  case AV_PIX_FMT_PAL8 :
2817  *alpToYV12 = palToA_c;
2818  break;
2819  }
2820  }
2821 }
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
_dst
uint8_t * _dst
Definition: dsp.h:56
read_ayuv64be_Y_c
static void read_ayuv64be_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:671
read_xv30le_Y_c
static void read_xv30le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:831
AV_PIX_FMT_YUV420P9LE
@ AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:154
AV_PIX_FMT_XV30LE
@ AV_PIX_FMT_XV30LE
packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channe...
Definition: pixfmt.h:415
shf16_wrapper
#define shf16_wrapper(shift)
AV_PIX_FMT_GRAY10BE
@ AV_PIX_FMT_GRAY10BE
Y , 10bpp, big-endian.
Definition: pixfmt.h:320
read_ya16le_alpha_c
static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:639
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:146
bgr24ToUV_c
static void 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, void *opq)
Definition: input.c:1083
Half2FloatTables
Definition: half2float.h:27
AV_PIX_FMT_P416BE
@ AV_PIX_FMT_P416BE
interleaved chroma YUV 4:4:4, 48bpp, big-endian
Definition: pixfmt.h:398
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:204
read_v30xle_Y_c
static void read_v30xle_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:811
read_ayuv64be_A_c
static void read_ayuv64be_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:723
RGB64FUNCS
#define RGB64FUNCS(pattern, endianness, base_fmt)
Definition: input.c:126
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:513
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:136
AV_PIX_FMT_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:171
rgb9plus_msb_planar_funcs
#define rgb9plus_msb_planar_funcs(nbits)
Definition: input.c:1479
rgb64ToUV_c_template
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, int is_be)
Definition: input.c:61
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:169
AV_PIX_FMT_YUV422P14LE
@ AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:274
AV_PIX_FMT_YUV444P12MSBBE
@ AV_PIX_FMT_YUV444P12MSBBE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian
Definition: pixfmt.h:493
src1
const pixel * src1
Definition: h264pred_template.c:420
vyuToY_c
static void vyuToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:793
ayuv64be_UV_c
static av_always_inline void ayuv64be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width, int u_offset, int v_offset)
Definition: input.c:689
av_cold
#define av_cold
Definition: attributes.h:119
read_ya16be_gray_c
static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:647
AV_PIX_FMT_RGBF16LE
@ AV_PIX_FMT_RGBF16LE
IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., little-endian.
Definition: pixfmt.h:452
planar_rgb_to_y
static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
Definition: input.c:1174
rgbaf16ToUV_endian
static av_always_inline void rgbaf16ToUV_endian(uint16_t *dstU, uint16_t *dstV, int is_be, const uint16_t *src, int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
Definition: input.c:1649
rgbf32_to_uv_c
static av_always_inline void rgbf32_to_uv_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused1, const uint8_t *_src, const uint8_t *unused2, int width, int is_be, int32_t *rgb2yuv)
Definition: input.c:1336
AV_PIX_FMT_YUVA444P10BE
@ AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:185
RV_IDX
#define RV_IDX
Definition: swscale_internal.h:475
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
AV_PIX_FMT_YUV440P12BE
@ AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:301
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:344
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:472
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:341
monoblack2Y_c
static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:532
AV_PIX_FMT_P412BE
@ AV_PIX_FMT_P412BE
interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian
Definition: pixfmt.h:429
b
#define b
Definition: input.c:43
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:476
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:82
AV_PIX_FMT_P010BE
@ AV_PIX_FMT_P010BE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:308
rgb2yuv
static const char rgb2yuv[]
Definition: vf_scale_vulkan.c:86
BV_IDX
#define BV_IDX
Definition: swscale_internal.h:477
AV_PIX_FMT_YUV420P14BE
@ AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:269
AV_PIX_FMT_YUV420P16LE
@ AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:128
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:512
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:281
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
planar_rgbf32_to_uv
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)
Definition: input.c:1300
AV_PIX_FMT_YUVA444P9BE
@ AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:179
AV_PIX_FMT_YUV422P9BE
@ AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:163
rgbf16ToUV_endian
static av_always_inline void rgbf16ToUV_endian(uint16_t *dstU, uint16_t *dstV, int is_be, const uint16_t *src, int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
Definition: input.c:1709
planar_rgbf32_to_y
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)
Definition: input.c:1319
read_xv36be_Y_c
static void read_xv36be_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:869
intfloat.h
AV_PIX_FMT_GRAY10LE
@ AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:321
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:364
AV_PIX_FMT_GBRAP14BE
@ AV_PIX_FMT_GBRAP14BE
planar GBR 4:4:4:4 56bpp, big-endian
Definition: pixfmt.h:432
read_xv30le_UV_c
static void read_xv30le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:840
rgba64beToA_c
static void rgba64beToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:444
p01x_wrapper
#define p01x_wrapper(fmt, shift)
Definition: input.c:979
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:114
AV_PIX_FMT_RGBAF16LE
@ AV_PIX_FMT_RGBAF16LE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., little-endian.
Definition: pixfmt.h:404
_src
uint8_t ptrdiff_t const uint8_t * _src
Definition: dsp.h:56
AV_PIX_FMT_AYUV64LE
@ AV_PIX_FMT_AYUV64LE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:302
AV_PIX_FMT_YUV444P16LE
@ AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:132
AV_PIX_FMT_AYUV64BE
@ AV_PIX_FMT_AYUV64BE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:303
av_always_inline
#define av_always_inline
Definition: attributes.h:76
S
#define S(s, c, i)
Definition: flacdsp_template.c:46
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:311
AV_PIX_FMT_GRAY16BE
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:104
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:747
rgb
Definition: rpzaenc.c:60
input_pixel
#define input_pixel(pos)
Definition: input.c:253
ff_sws_init_input_funcs
void ff_sws_init_input_funcs(SwsInternal *c, planar1_YV12_fn *lumToYV12, planar1_YV12_fn *alpToYV12, planar2_YV12_fn *chrToYV12, planarX_YV12_fn *readLumPlanar, planarX_YV12_fn *readAlpPlanar, planarX2_YV12_fn *readChrPlanar)
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
AV_PIX_FMT_YUV420P12LE
@ AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:268
read_yaf32_alpha_c
static av_always_inline void read_yaf32_alpha_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, uint32_t *unused)
Definition: input.c:1422
AV_PIX_FMT_GRAY9LE
@ AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:339
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:761
AV_PIX_FMT_YUVA444P16BE
@ AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:191
rgbf32_funcs_endian
#define rgbf32_funcs_endian(endian_name, endian)
r
#define r
Definition: input.c:42
AV_PIX_FMT_YUV444P10BE
@ AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:161
AV_PIX_FMT_YUV420P10LE
@ AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:156
AV_PIX_FMT_VUYA
@ AV_PIX_FMT_VUYA
packed VUYA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), VUYAVUYA...
Definition: pixfmt.h:401
AV_PIX_FMT_YUV444P12LE
@ AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:276
grayf16ToY16_c
static av_always_inline void grayf16ToY16_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
Definition: input.c:1601
AV_PIX_FMT_YUV422P12BE
@ AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:271
AV_PIX_FMT_YUV444P14LE
@ AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:278
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
avassert.h
rgb16_32ToY_c_template
static av_always_inline void rgb16_32ToY_c_template(int16_t *dst, 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, int is_be)
Definition: input.c:264
read_yaf32_gray_c
static av_always_inline void read_yaf32_gray_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, uint32_t *unused)
Definition: input.c:1411
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
shifted_planar_rgb16_to_y_uv
#define shifted_planar_rgb16_to_y_uv(rdpx_shift)
Definition: input.c:1273
intreadwrite.h
AV_PIX_FMT_YUV444P10MSBBE
@ AV_PIX_FMT_YUV444P10MSBBE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, big-endian
Definition: pixfmt.h:491
rgba64leToA_c
static void rgba64leToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:434
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:172
bswap16UV_c
static void 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, void *opq)
Definition: input.c:618
AV_PIX_FMT_P416LE
@ AV_PIX_FMT_P416LE
interleaved chroma YUV 4:4:4, 48bpp, little-endian
Definition: pixfmt.h:399
AV_PIX_FMT_P210LE
@ AV_PIX_FMT_P210LE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:390
g
const char * g
Definition: vf_curves.c:128
read_ayuv64le_Y_c
static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:663
AV_PIX_FMT_NV20BE
@ AV_PIX_FMT_NV20BE
interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:200
rgbf32_to_y_c
static av_always_inline void rgbf32_to_y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, int32_t *rgb2yuv)
Definition: input.c:1380
rgbaf16ToA_endian
static av_always_inline void rgbaf16ToA_endian(uint16_t *dst, const uint16_t *src, int is_be, int width, Half2FloatTables *h2f_tbl)
Definition: input.c:1680
uyyvyyToY_c
static void uyyvyyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:909
AV_PIX_FMT_P016BE
@ AV_PIX_FMT_P016BE
like NV12, with 16bpp per component, big-endian
Definition: pixfmt.h:324
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:280
AV_PIX_FMT_YUVA420P16BE
@ AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:187
monowhite2Y_c
static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:514
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
AV_PIX_FMT_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:170
AV_PIX_FMT_GBRAPF16LE
@ AV_PIX_FMT_GBRAPF16LE
IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, little-endian.
Definition: pixfmt.h:469
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:470
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:514
p01x_uv_wrapper
#define p01x_uv_wrapper(fmt, shift)
Definition: input.c:950
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
AV_PIX_FMT_YUV444P10LE
@ AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:162
rgb48ToY_c_template
static av_always_inline void rgb48ToY_c_template(uint16_t *dst, const uint16_t *src, int width, enum AVPixelFormat origin, int32_t *rgb2yuv, int is_be)
Definition: input.c:134
AV_PIX_FMT_YUVA422P10LE
@ AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:184
AV_PIX_FMT_GBRP10MSBLE
@ AV_PIX_FMT_GBRP10MSBLE
planar GBR 4:4:4 30bpp, lowest bits zero, little-endian
Definition: pixfmt.h:496
abgrToA_c
static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:454
grayf32ToY16_c
static av_always_inline void grayf32ToY16_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, uint32_t *unused)
Definition: input.c:1399
AV_PIX_FMT_YUV444P9BE
@ AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:159
AV_PIX_FMT_YUV422P10BE
@ AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:157
b_r
#define b_r
read_xv36le_Y_c
static void read_xv36le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:850
AV_PIX_FMT_YUV422P16LE
@ AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:130
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:529
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:113
AV_PIX_FMT_Y216LE
@ AV_PIX_FMT_Y216LE
packed YUV 4:2:2 like YUYV422, 32bpp, little-endian
Definition: pixfmt.h:461
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:343
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:310
AV_PIX_FMT_P012LE
@ AV_PIX_FMT_P012LE
like NV12, with 12bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:408
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:530
NULL
#define NULL
Definition: coverity.c:32
read_ya16be_alpha_c
static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:655
rgbf16ToUV_half_endian
static av_always_inline void rgbf16ToUV_half_endian(uint16_t *dstU, uint16_t *dstV, int is_be, const uint16_t *src, int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
Definition: input.c:1689
AV_PIX_FMT_GBRAPF16BE
@ AV_PIX_FMT_GBRAPF16BE
IEEE-754 half precision planar GBRA 4:4:4:4, 64bpp, big-endian.
Definition: pixfmt.h:468
planarX_YV12_fn
void(* planarX_YV12_fn)(uint8_t *dst, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opaque)
Unscaled conversion of arbitrary planar data (e.g.
Definition: swscale_internal.h:326
rgb9plus_planar_transparency_funcs
#define rgb9plus_planar_transparency_funcs(nbits)
Definition: input.c:1448
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
AV_PIX_FMT_P210BE
@ AV_PIX_FMT_P210BE
interleaved chroma YUV 4:2:2, 20bpp, data in the high bits, big-endian
Definition: pixfmt.h:389
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:110
AV_PIX_FMT_YA16LE
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:210
planar_rgb_to_a
static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused, void *opq)
Definition: input.c:1188
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:83
AV_PIX_FMT_YUVA422P12LE
@ AV_PIX_FMT_YUVA422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:367
RGB48FUNCS
#define RGB48FUNCS(pattern, endianness, base_fmt)
Definition: input.c:245
ayuv64_UV_funcs
#define ayuv64_UV_funcs(pixfmt, U, V)
Definition: input.c:699
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
nv12ToUV_c
static void 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, void *opq)
Definition: input.c:936
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:118
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
read_vuyx_UV_c
static void read_vuyx_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:731
AV_PIX_FMT_YUVA444P12BE
@ AV_PIX_FMT_YUVA444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:368
planarX2_YV12_fn
void(* planarX2_YV12_fn)(uint8_t *dst, uint8_t *dst2, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opaque)
Definition: swscale_internal.h:329
AV_PIX_FMT_YUVA444P9LE
@ AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:180
AV_PIX_FMT_Y210LE
@ AV_PIX_FMT_Y210LE
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:382
yuy2ToUV_c
static void 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, void *opq)
Definition: input.c:558
AV_PIX_FMT_YUVA420P16LE
@ AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:188
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition: pixfmt.h:93
rgb16_32ToUV_c_template
static av_always_inline void 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, int is_be)
Definition: input.c:289
attributes.h
palToA_c
static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal, void *opq)
Definition: input.c:474
AV_PIX_FMT_YUV440P10LE
@ AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:298
av_clipf
av_clipf
Definition: af_crystalizer.c:122
palToUV_c
static void 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, void *opq)
Definition: input.c:498
read_v30xle_UV_c
static void read_v30xle_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:820
AV_PIX_FMT_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:119
AV_PIX_FMT_YUVA420P9LE
@ AV_PIX_FMT_YUVA420P9LE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian
Definition: pixfmt.h:176
AV_PIX_FMT_GBRP12MSBLE
@ AV_PIX_FMT_GBRP12MSBLE
planar GBR 4:4:4 36bpp, lowest bits zero, little-endian
Definition: pixfmt.h:498
read_ayuv_Y_c
static void read_ayuv_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:767
AV_PIX_FMT_YAF16BE
@ AV_PIX_FMT_YAF16BE
IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, big-endian.
Definition: pixfmt.h:485
planar2_YV12_fn
void(* planar2_YV12_fn)(uint8_t *dst, uint8_t *dst2, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opaque)
Unscaled conversion of chroma plane to YV12 for horizontal scaler.
Definition: swscale_internal.h:318
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
rgb48ToUV_half_c_template
static av_always_inline void 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, int is_be)
Definition: input.c:172
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_PIX_FMT_YUV420P14LE
@ AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:270
AV_PIX_FMT_YUV444P14BE
@ AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:277
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:92
AV_PIX_FMT_X2RGB10LE
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:384
AV_PIX_FMT_P212LE
@ AV_PIX_FMT_P212LE
interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, little-endian
Definition: pixfmt.h:427
AV_PIX_FMT_YUV420P9BE
@ AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:153
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:614
AV_PIX_FMT_YUV444P10MSBLE
@ AV_PIX_FMT_YUV444P10MSBLE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian
Definition: pixfmt.h:492
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:768
f
f
Definition: af_crystalizer.c:122
AV_PIX_FMT_RGBF32BE
@ AV_PIX_FMT_RGBF32BE
IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., big-endian.
Definition: pixfmt.h:420
read_ya16le_gray_c
static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:631
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
RY_IDX
#define RY_IDX
Definition: swscale_internal.h:469
AV_PIX_FMT_YUV440P12LE
@ AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:300
rgbf16ToY_endian
static av_always_inline void rgbf16ToY_endian(uint16_t *dst, const uint16_t *src, int is_be, int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
Definition: input.c:1726
AV_PIX_FMT_GBRP10MSBBE
@ AV_PIX_FMT_GBRP10MSBBE
planar GBR 4:4:4 30bpp, lowest bits zero, big-endian
Definition: pixfmt.h:495
rgbaf16_funcs_endian
#define rgbaf16_funcs_endian(endian_name, endian)
Definition: input.c:1742
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
AV_PIX_FMT_YUV420P12BE
@ AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:267
AV_PIX_FMT_YUV422P10LE
@ AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:158
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:137
rgb9plus_planar_funcs
#define rgb9plus_planar_funcs(nbits)
Definition: input.c:1475
AV_PIX_FMT_XV36BE
@ AV_PIX_FMT_XV36BE
packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian,...
Definition: pixfmt.h:417
AV_PIX_FMT_YUV422P14BE
@ AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:273
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:209
vyuToUV_c
static void vyuToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:801
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
AV_PIX_FMT_GRAY12LE
@ AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:319
planar1_YV12_fn
void(* planar1_YV12_fn)(uint8_t *dst, const uint8_t *src, const uint8_t *src2, const uint8_t *src3, int width, uint32_t *pal, void *opaque)
Unscaled conversion of luma/alpha plane to YV12 for horizontal scaler.
Definition: swscale_internal.h:311
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:532
rnd
#define rnd
Definition: checkasm.h:140
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:167
AV_PIX_FMT_YUV420P10BE
@ AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:155
AV_PIX_FMT_RGBAF16BE
@ AV_PIX_FMT_RGBAF16BE
IEEE-754 half precision packed RGBA 16:16:16:16, 64bpp, RGBARGBA..., big-endian.
Definition: pixfmt.h:403
AV_PIX_FMT_GBRP12MSBBE
@ AV_PIX_FMT_GBRP12MSBBE
planar GBR 4:4:4 36bpp, lowest bits zero, big-endian
Definition: pixfmt.h:497
rgb24ToUV_half_c
static void 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, void *opq)
Definition: input.c:1155
AV_PIX_FMT_NV16
@ AV_PIX_FMT_NV16
interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:198
palToY_c
static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal, void *opq)
Definition: input.c:486
shifted_planar_rgb16
#define shifted_planar_rgb16(rdpx_shift)
Definition: input.c:1277
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:139
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:511
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:314
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:117
AV_PIX_FMT_YAF32LE
@ AV_PIX_FMT_YAF32LE
IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, little-endian.
Definition: pixfmt.h:483
read_ayuv_UV_c
static void read_ayuv_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:757
AV_PIX_FMT_P012BE
@ AV_PIX_FMT_P012BE
like NV12, with 12bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:409
AV_PIX_FMT_P410LE
@ AV_PIX_FMT_P410LE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, little-endian
Definition: pixfmt.h:393
rgb24ToUV_c
static void 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, void *opq)
Definition: input.c:1136
y21xle_wrapper
#define y21xle_wrapper(bits, shift)
Definition: input.c:580
nvXXtoUV_c
static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2, const uint8_t *src, int width)
Definition: input.c:926
AV_PIX_FMT_YUVA420P10LE
@ AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:182
BY_IDX
#define BY_IDX
Definition: swscale_internal.h:471
AV_PIX_FMT_AYUV
@ AV_PIX_FMT_AYUV
packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV...
Definition: pixfmt.h:442
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:205
rgbaToA_c
static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:464
AV_PIX_FMT_YUVA422P10BE
@ AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:183
AV_PIX_FMT_UYVA
@ AV_PIX_FMT_UYVA
packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA...
Definition: pixfmt.h:444
AV_PIX_FMT_YUVA444P12LE
@ AV_PIX_FMT_YUVA444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), 12b alpha, little-endian
Definition: pixfmt.h:369
AV_PIX_FMT_YUVA422P9BE
@ AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:177
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:534
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:115
planar_rgbf16_to_uv
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)
Definition: input.c:1570
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:109
lrintf
#define lrintf(x)
Definition: libm_mips.h:72
ayuv64le_UV_c
static av_always_inline void ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src, int width, int u_offset, int v_offset)
Definition: input.c:679
nv21ToUV_c
static void 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, void *opq)
Definition: input.c:943
src2
const pixel * src2
Definition: h264pred_template.c:421
AV_PIX_FMT_GRAY9BE
@ AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:338
AV_PIX_FMT_NV24
@ AV_PIX_FMT_NV24
planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:371
read_yaf16_gray_c
static av_always_inline void read_yaf16_gray_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
Definition: input.c:1611
AV_PIX_FMT_BGR444
#define AV_PIX_FMT_BGR444
Definition: pixfmt.h:533
read_xv36le_UV_c
static void read_xv36le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:859
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
AV_PIX_FMT_YAF16LE
@ AV_PIX_FMT_YAF16LE
IEEE-754 half precision packed YA, 16 bits gray, 16 bits alpha, 32bpp, little-endian.
Definition: pixfmt.h:486
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:527
swscale_internal.h
AV_PIX_FMT_NV20LE
@ AV_PIX_FMT_NV20LE
interleaved chroma YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:199
rgb64ToY_c_template
static av_always_inline void rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width, enum AVPixelFormat origin, int32_t *rgb2yuv, int is_be)
Definition: input.c:46
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:613
gbr24pToUV_half_c
static void 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, void *opq)
Definition: input.c:414
read_vuya_A_c
static void read_vuya_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:749
AV_PIX_FMT_NV21
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:97
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:531
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AV_PIX_FMT_YUV444P16BE
@ AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:133
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:342
AV_PIX_FMT_NV42
@ AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:372
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:526
rdpx
#define rdpx(src)
Definition: input.c:1213
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:214
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
AV_PIX_FMT_GRAY12BE
@ AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:318
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:207
SwsInternal
Definition: swscale_internal.h:337
bswap.h
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
AV_PIX_FMT_Y212LE
@ AV_PIX_FMT_Y212LE
packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:412
rgb64ToUV_half_c_template
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, int is_be)
Definition: input.c:80
AV_PIX_FMT_P410BE
@ AV_PIX_FMT_P410BE
interleaved chroma YUV 4:4:4, 30bpp, data in the high bits, big-endian
Definition: pixfmt.h:392
AV_PIX_FMT_P016LE
@ AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:323
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:363
AV_PIX_FMT_GRAYF16BE
@ AV_PIX_FMT_GRAYF16BE
IEEE-754 half precision Y, 16bpp, big-endian.
Definition: pixfmt.h:471
AV_PIX_FMT_RGBF16BE
@ AV_PIX_FMT_RGBF16BE
IEEE-754 half precision packed RGB 16:16:16, 48bpp, RGBRGB..., big-endian.
Definition: pixfmt.h:451
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:279
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV444P12BE
@ AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:275
read_ayuv_A_c
static void read_ayuv_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:775
yuy2ToY_c
static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:550
rdpx2
#define rdpx2(src)
AV_PIX_FMT_XV48LE
@ AV_PIX_FMT_XV48LE
packed XVYU 4:4:4, 64bpp, little-endian, variant of Y416 where alpha channel is left undefined
Definition: pixfmt.h:464
AV_PIX_FMT_YUV444P9LE
@ AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:160
rgbf32_to_uv_half_c
static av_always_inline void rgbf32_to_uv_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused1, const uint8_t *_src, const uint8_t *unused2, int width, int is_be, int32_t *rgb2yuv)
Definition: input.c:1357
px
#define px
Definition: uops_tmpl.c:54
AV_PIX_FMT_P216LE
@ AV_PIX_FMT_P216LE
interleaved chroma YUV 4:2:2, 32bpp, little-endian
Definition: pixfmt.h:396
planar_rgbf16_to_y
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)
Definition: input.c:1586
AV_PIX_FMT_RGBF32LE
@ AV_PIX_FMT_RGBF32LE
IEEE-754 single precision packed RGB 32:32:32, 96bpp, RGBRGB..., little-endian.
Definition: pixfmt.h:421
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
uyvyToUV_c
static void 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, void *opq)
Definition: input.c:898
AV_PIX_FMT_YUVA420P10BE
@ AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:181
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:112
AV_PIX_FMT_YUV420P16BE
@ AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:129
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
rgb48ToUV_c_template
static av_always_inline void 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, int is_be)
Definition: input.c:150
AV_PIX_FMT_YUV422P16BE
@ AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:131
AV_PIX_FMT_P212BE
@ AV_PIX_FMT_P212BE
interleaved chroma YUV 4:2:2, 24bpp, data in the high bits, big-endian
Definition: pixfmt.h:426
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:105
AV_PIX_FMT_X2BGR10LE
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:386
AV_PIX_FMT_V30XLE
@ AV_PIX_FMT_V30XLE
packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian
Definition: pixfmt.h:449
AV_PIX_FMT_P010LE
@ AV_PIX_FMT_P010LE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:307
AV_PIX_FMT_XV48BE
@ AV_PIX_FMT_XV48BE
packed XVYU 4:4:4, 64bpp, big-endian, variant of Y416 where alpha channel is left undefined
Definition: pixfmt.h:463
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:474
uyyvyyToUV_c
static void uyyvyyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused, void *opq)
Definition: input.c:916
AV_PIX_FMT_YUVA444P10LE
@ AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:186
AV_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:120
AV_PIX_FMT_YAF32BE
@ AV_PIX_FMT_YAF32BE
IEEE-754 single precision packed YA, 32 bits gray, 32 bits alpha, 64bpp, big-endian.
Definition: pixfmt.h:482
AV_PIX_FMT_P216BE
@ AV_PIX_FMT_P216BE
interleaved chroma YUV 4:2:2, 32bpp, big-endian
Definition: pixfmt.h:395
AV_PIX_FMT_P412LE
@ AV_PIX_FMT_P412LE
interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian
Definition: pixfmt.h:430
AV_PIX_FMT_GRAY14LE
@ AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:361
AV_PIX_FMT_GRAYF16LE
@ AV_PIX_FMT_GRAYF16LE
IEEE-754 half precision Y, 16bpp, little-endian.
Definition: pixfmt.h:472
rgbaf16ToY_endian
static av_always_inline void rgbaf16ToY_endian(uint16_t *dst, const uint16_t *src, int is_be, int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
Definition: input.c:1666
uyvyToY_c
static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused, void *opq)
Definition: input.c:890
AV_PIX_FMT_XV36LE
@ AV_PIX_FMT_XV36LE
packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian,...
Definition: pixfmt.h:418
AV_PIX_FMT_GRAY14BE
@ AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
Definition: pixfmt.h:360
AV_PIX_FMT_YUVA422P16BE
@ AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:189
AV_PIX_FMT_YUV440P10BE
@ AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:299
RGB16_32FUNCS
#define RGB16_32FUNCS(base_fmt, endianness, name, shr, shg, shb, shp, maskr, maskg, maskb, rsh, gsh, bsh, S)
Definition: input.c:390
AV_PIX_FMT_YUV422P9LE
@ AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:164
AV_PIX_FMT_YUVA422P16LE
@ AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:190
rgb16_32ToUV_half_c_template
static av_always_inline void 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, int is_be)
Definition: input.c:317
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:282
int32_t
int32_t
Definition: audioconvert.c:56
AV_PIX_FMT_YUV444P12MSBLE
@ AV_PIX_FMT_YUV444P12MSBLE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), lowest bits zero, little-endian
Definition: pixfmt.h:494
planar_rgb_to_uv
static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv, void *opq)
Definition: input.c:1196
bgr24ToUV_half_c
static void 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, void *opq)
Definition: input.c:1102
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:313
r_b
#define r_b
yvy2ToUV_c
static void 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, void *opq)
Definition: input.c:569
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:473
AV_PIX_FMT_YUVA444P16LE
@ AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:192
width
#define width
Definition: dsp.h:89
AV_PIX_FMT_GBRPF16BE
@ AV_PIX_FMT_GBRPF16BE
IEEE-754 half precision planer GBR 4:4:4, 48bpp, big-endian.
Definition: pixfmt.h:466
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
Definition: pixfmt.h:406
AV_PIX_FMT_VYU444
@ AV_PIX_FMT_VYU444
packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU...
Definition: pixfmt.h:446
av_bswap16
#define av_bswap16
Definition: bswap.h:28
AV_PIX_FMT_YUVA422P12BE
@ AV_PIX_FMT_YUVA422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), 12b alpha, big-endian
Definition: pixfmt.h:366
rgbaf16ToUV_half_endian
static av_always_inline void rgbaf16ToUV_half_endian(uint16_t *dstU, uint16_t *dstV, int is_be, const uint16_t *src, int width, int32_t *rgb2yuv, Half2FloatTables *h2f_tbl)
Definition: input.c:1629
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:138
read_xv36be_UV_c
static void read_xv36be_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:878
AV_PIX_FMT_YUV422P12LE
@ AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:272
AV_PIX_FMT_YUVA420P9BE
@ AV_PIX_FMT_YUVA420P9BE
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:175
read_yaf16_alpha_c
static av_always_inline void read_yaf16_alpha_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, int is_be, uint32_t *unused, Half2FloatTables *h2f_tbl)
Definition: input.c:1620
read_vuyx_Y_c
static void read_vuyx_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:741
rgb24ToY_c
static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *rgb2yuv, void *opq)
Definition: input.c:1121
read_uyva_UV_c
static void read_uyva_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src, const uint8_t *unused1, int width, uint32_t *unused2, void *opq)
Definition: input.c:783
src
#define src
Definition: vp8dsp.c:248
AV_PIX_FMT_GBRAP14LE
@ AV_PIX_FMT_GBRAP14LE
planar GBR 4:4:4:4 56bpp, little-endian
Definition: pixfmt.h:433
AV_PIX_FMT_GBRPF16LE
@ AV_PIX_FMT_GBRPF16LE
IEEE-754 half precision planer GBR 4:4:4, 48bpp, little-endian.
Definition: pixfmt.h:467
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
AV_PIX_FMT_UYYVYY411
@ AV_PIX_FMT_UYYVYY411
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Definition: pixfmt.h:89
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
Definition: swscale_internal.h:478
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:145
AV_PIX_FMT_YUVA422P9LE
@ AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:178
AV_PIX_FMT_RGB444
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:528
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:368
Generated on Mon Jun 15 2026 19:23:49 for FFmpeg by   doxygen 1.8.17