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