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 <stdint.h>
23 #include <stdio.h>
24 #include <string.h>
25 
26 #include "libavutil/avutil.h"
27 #include "libavutil/bswap.h"
28 #include "libavutil/cpu.h"
29 #include "libavutil/intreadwrite.h"
30 #include "libavutil/mathematics.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavutil/avassert.h"
33 #include "config.h"
34 #include "rgb2rgb.h"
35 #include "swscale.h"
36 #include "swscale_internal.h"
37 
38 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
39 
40 #define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? b_r : r_b)
41 #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE || origin == AV_PIX_FMT_BGRA64BE || origin == AV_PIX_FMT_BGRA64LE) ? r_b : b_r)
42 
43 static av_always_inline void
44 rgb64ToY_c_template(uint16_t *dst, const uint16_t *src, int width,
45  enum AVPixelFormat origin, int32_t *rgb2yuv)
46 {
47  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
48  int i;
49  for (i = 0; i < width; i++) {
50  unsigned int r_b = input_pixel(&src[i*4+0]);
51  unsigned int g = input_pixel(&src[i*4+1]);
52  unsigned int b_r = input_pixel(&src[i*4+2]);
53 
54  dst[i] = (ry*r + gy*g + by*b + (0x2001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
55  }
56 }
57 
58 static av_always_inline void
59 rgb64ToUV_c_template(uint16_t *dstU, uint16_t *dstV,
60  const uint16_t *src1, const uint16_t *src2,
61  int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
62 {
63  int i;
64  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
65  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
66  av_assert1(src1==src2);
67  for (i = 0; i < width; i++) {
68  int r_b = input_pixel(&src1[i*4+0]);
69  int g = input_pixel(&src1[i*4+1]);
70  int b_r = input_pixel(&src1[i*4+2]);
71 
72  dstU[i] = (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
73  dstV[i] = (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
74  }
75 }
76 
77 static av_always_inline void
78 rgb64ToUV_half_c_template(uint16_t *dstU, uint16_t *dstV,
79  const uint16_t *src1, const uint16_t *src2,
80  int width, enum AVPixelFormat origin, int32_t *rgb2yuv)
81 {
82  int i;
83  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
84  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
85  av_assert1(src1==src2);
86  for (i = 0; i < width; i++) {
87  int r_b = (input_pixel(&src1[8 * i + 0]) + input_pixel(&src1[8 * i + 4]) + 1) >> 1;
88  int g = (input_pixel(&src1[8 * i + 1]) + input_pixel(&src1[8 * i + 5]) + 1) >> 1;
89  int b_r = (input_pixel(&src1[8 * i + 2]) + input_pixel(&src1[8 * i + 6]) + 1) >> 1;
90 
91  dstU[i]= (ru*r + gu*g + bu*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
92  dstV[i]= (rv*r + gv*g + bv*b + (0x10001<<(RGB2YUV_SHIFT-1))) >> RGB2YUV_SHIFT;
93  }
94 }
95 
96 #define rgb64funcs(pattern, BE_LE, origin) \
97 static void pattern ## 64 ## BE_LE ## ToY_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused0, const uint8_t *unused1,\
98  int width, uint32_t *rgb2yuv) \
99 { \
100  const uint16_t *src = (const uint16_t *) _src; \
101  uint16_t *dst = (uint16_t *) _dst; \
102  rgb64ToY_c_template(dst, src, width, origin, rgb2yuv); \
103 } \
104  \
105 static void pattern ## 64 ## BE_LE ## ToUV_c(uint8_t *_dstU, uint8_t *_dstV, \
106  const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
107  int width, uint32_t *rgb2yuv) \
108 { \
109  const uint16_t *src1 = (const uint16_t *) _src1, \
110  *src2 = (const uint16_t *) _src2; \
111  uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
112  rgb64ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
113 } \
114  \
115 static void pattern ## 64 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, \
116  const uint8_t *unused0, const uint8_t *_src1, const uint8_t *_src2, \
117  int width, uint32_t *rgb2yuv) \
118 { \
119  const uint16_t *src1 = (const uint16_t *) _src1, \
120  *src2 = (const uint16_t *) _src2; \
121  uint16_t *dstU = (uint16_t *) _dstU, *dstV = (uint16_t *) _dstV; \
122  rgb64ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
123 }
124 
125 rgb64funcs(rgb, LE, AV_PIX_FMT_RGBA64LE)
126 rgb64funcs(rgb, BE, AV_PIX_FMT_RGBA64BE)
127 rgb64funcs(bgr, LE, AV_PIX_FMT_BGRA64LE)
128 rgb64funcs(bgr, BE, AV_PIX_FMT_BGRA64BE)
129 
130 static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
131  const uint16_t *src, int width,
132  enum AVPixelFormat origin,
133  int32_t *rgb2yuv)
134 {
135  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
136  int i;
137  for (i = 0; i < width; i++) {
138  unsigned int r_b = input_pixel(&src[i * 3 + 0]);
139  unsigned int g = input_pixel(&src[i * 3 + 1]);
140  unsigned int b_r = input_pixel(&src[i * 3 + 2]);
141 
142  dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
143  }
144 }
145 
146 static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
147  uint16_t *dstV,
148  const uint16_t *src1,
149  const uint16_t *src2,
150  int width,
151  enum AVPixelFormat origin,
152  int32_t *rgb2yuv)
153 {
154  int i;
155  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
156  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
157  av_assert1(src1 == src2);
158  for (i = 0; i < width; i++) {
159  int r_b = input_pixel(&src1[i * 3 + 0]);
160  int g = input_pixel(&src1[i * 3 + 1]);
161  int b_r = input_pixel(&src1[i * 3 + 2]);
162 
163  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
164  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
165  }
166 }
167 
168 static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
169  uint16_t *dstV,
170  const uint16_t *src1,
171  const uint16_t *src2,
172  int width,
173  enum AVPixelFormat origin,
174  int32_t *rgb2yuv)
175 {
176  int i;
177  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
178  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
179  av_assert1(src1 == src2);
180  for (i = 0; i < width; i++) {
181  int r_b = (input_pixel(&src1[6 * i + 0]) +
182  input_pixel(&src1[6 * i + 3]) + 1) >> 1;
183  int g = (input_pixel(&src1[6 * i + 1]) +
184  input_pixel(&src1[6 * i + 4]) + 1) >> 1;
185  int b_r = (input_pixel(&src1[6 * i + 2]) +
186  input_pixel(&src1[6 * i + 5]) + 1) >> 1;
187 
188  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
189  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
190  }
191 }
192 
193 #undef r
194 #undef b
195 #undef input_pixel
196 
197 #define rgb48funcs(pattern, BE_LE, origin) \
198 static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst, \
199  const uint8_t *_src, \
200  const uint8_t *unused0, const uint8_t *unused1,\
201  int width, \
202  uint32_t *rgb2yuv) \
203 { \
204  const uint16_t *src = (const uint16_t *)_src; \
205  uint16_t *dst = (uint16_t *)_dst; \
206  rgb48ToY_c_template(dst, src, width, origin, rgb2yuv); \
207 } \
208  \
209 static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, \
210  uint8_t *_dstV, \
211  const uint8_t *unused0, \
212  const uint8_t *_src1, \
213  const uint8_t *_src2, \
214  int width, \
215  uint32_t *rgb2yuv) \
216 { \
217  const uint16_t *src1 = (const uint16_t *)_src1, \
218  *src2 = (const uint16_t *)_src2; \
219  uint16_t *dstU = (uint16_t *)_dstU, \
220  *dstV = (uint16_t *)_dstV; \
221  rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
222 } \
223  \
224 static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, \
225  uint8_t *_dstV, \
226  const uint8_t *unused0, \
227  const uint8_t *_src1, \
228  const uint8_t *_src2, \
229  int width, \
230  uint32_t *rgb2yuv) \
231 { \
232  const uint16_t *src1 = (const uint16_t *)_src1, \
233  *src2 = (const uint16_t *)_src2; \
234  uint16_t *dstU = (uint16_t *)_dstU, \
235  *dstV = (uint16_t *)_dstV; \
236  rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
237 }
238 
239 rgb48funcs(rgb, LE, AV_PIX_FMT_RGB48LE)
240 rgb48funcs(rgb, BE, AV_PIX_FMT_RGB48BE)
241 rgb48funcs(bgr, LE, AV_PIX_FMT_BGR48LE)
242 rgb48funcs(bgr, BE, AV_PIX_FMT_BGR48BE)
243 
244 #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA || \
245  origin == AV_PIX_FMT_BGRA || \
246  origin == AV_PIX_FMT_ARGB || \
247  origin == AV_PIX_FMT_ABGR) \
248  ? AV_RN32A(&src[(i) * 4]) \
249  : (isBE(origin) ? AV_RB16(&src[(i) * 2]) \
250  : AV_RL16(&src[(i) * 2])))
251 
252 static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
253  const uint8_t *src,
254  int width,
255  enum AVPixelFormat origin,
256  int shr, int shg,
257  int shb, int shp,
258  int maskr, int maskg,
259  int maskb, int rsh,
260  int gsh, int bsh, int S,
261  int32_t *rgb2yuv)
262 {
263  const int ry = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
264  const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
265  int i;
266 
267  for (i = 0; i < width; i++) {
268  int px = input_pixel(i) >> shp;
269  int b = (px & maskb) >> shb;
270  int g = (px & maskg) >> shg;
271  int r = (px & maskr) >> shr;
272 
273  dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
274  }
275 }
276 
277 static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
278  int16_t *dstV,
279  const uint8_t *src,
280  int width,
281  enum AVPixelFormat origin,
282  int shr, int shg,
283  int shb, int shp,
284  int maskr, int maskg,
285  int maskb, int rsh,
286  int gsh, int bsh, int S,
287  int32_t *rgb2yuv)
288 {
289  const int ru = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
290  rv = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh;
291  const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
292  int i;
293 
294  for (i = 0; i < width; i++) {
295  int px = input_pixel(i) >> shp;
296  int b = (px & maskb) >> shb;
297  int g = (px & maskg) >> shg;
298  int r = (px & maskr) >> shr;
299 
300  dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
301  dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
302  }
303 }
304 
305 static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
306  int16_t *dstV,
307  const uint8_t *src,
308  int width,
309  enum AVPixelFormat origin,
310  int shr, int shg,
311  int shb, int shp,
312  int maskr, int maskg,
313  int maskb, int rsh,
314  int gsh, int bsh, int S,
315  int32_t *rgb2yuv)
316 {
317  const int ru = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
318  rv = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh,
319  maskgx = ~(maskr | maskb);
320  const unsigned rnd = (256U<<(S)) + (1<<(S-6));
321  int i;
322 
323  maskr |= maskr << 1;
324  maskb |= maskb << 1;
325  maskg |= maskg << 1;
326  for (i = 0; i < width; i++) {
327  unsigned px0 = input_pixel(2 * i + 0) >> shp;
328  unsigned px1 = input_pixel(2 * i + 1) >> shp;
329  int b, r, g = (px0 & maskgx) + (px1 & maskgx);
330  int rb = px0 + px1 - g;
331 
332  b = (rb & maskb) >> shb;
333  if (shp ||
334  origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
335  origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
336  g >>= shg;
337  } else {
338  g = (g & maskg) >> shg;
339  }
340  r = (rb & maskr) >> shr;
341 
342  dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
343  dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
344  }
345 }
346 
347 #undef input_pixel
348 
349 #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr, \
350  maskg, maskb, rsh, gsh, bsh, S) \
351 static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, \
352  int width, uint32_t *tab) \
353 { \
354  rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp, \
355  maskr, maskg, maskb, rsh, gsh, bsh, S, tab); \
356 } \
357  \
358 static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
359  const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy, \
360  int width, uint32_t *tab) \
361 { \
362  rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
363  shr, shg, shb, shp, \
364  maskr, maskg, maskb, rsh, gsh, bsh, S, tab);\
365 } \
366  \
367 static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \
368  const uint8_t *unused0, const uint8_t *src, \
369  const uint8_t *dummy, \
370  int width, uint32_t *tab) \
371 { \
372  rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
373  shr, shg, shb, shp, \
374  maskr, maskg, maskb, \
375  rsh, gsh, bsh, S, tab); \
376 }
377 
378 rgb16_32_wrapper(AV_PIX_FMT_BGR32, bgr32, 16, 0, 0, 0, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
379 rgb16_32_wrapper(AV_PIX_FMT_BGR32_1, bgr321, 16, 0, 0, 8, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
380 rgb16_32_wrapper(AV_PIX_FMT_RGB32, rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
381 rgb16_32_wrapper(AV_PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
382 rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
383 rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
384 rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
385 rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
386 rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
387 rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
388 rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
389 rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
390 rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
391 rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
392 rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
393 rgb16_32_wrapper(AV_PIX_FMT_RGB444BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
394 
395 static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
396  const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
397  int width, uint32_t *rgb2yuv)
398 {
399  uint16_t *dstU = (uint16_t *)_dstU;
400  uint16_t *dstV = (uint16_t *)_dstV;
401  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
402  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
403 
404  int i;
405  for (i = 0; i < width; i++) {
406  unsigned int g = gsrc[2*i] + gsrc[2*i+1];
407  unsigned int b = bsrc[2*i] + bsrc[2*i+1];
408  unsigned int r = rsrc[2*i] + rsrc[2*i+1];
409 
410  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
411  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
412  }
413 }
414 
415 static void rgba64leToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
416  const uint8_t *unused2, int width, uint32_t *unused)
417 {
418  int16_t *dst = (int16_t *)_dst;
419  const uint16_t *src = (const uint16_t *)_src;
420  int i;
421  for (i = 0; i < width; i++)
422  dst[i] = AV_RL16(src + 4 * i + 3);
423 }
424 
425 static void rgba64beToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
426  const uint8_t *unused2, int width, uint32_t *unused)
427 {
428  int16_t *dst = (int16_t *)_dst;
429  const uint16_t *src = (const uint16_t *)_src;
430  int i;
431  for (i = 0; i < width; i++)
432  dst[i] = AV_RB16(src + 4 * i + 3);
433 }
434 
435 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
436 {
437  int16_t *dst = (int16_t *)_dst;
438  int i;
439  for (i=0; i<width; i++) {
440  dst[i]= src[4*i]<<6;
441  }
442 }
443 
444 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
445 {
446  int16_t *dst = (int16_t *)_dst;
447  int i;
448  for (i=0; i<width; i++) {
449  dst[i]= src[4*i+3]<<6;
450  }
451 }
452 
453 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
454 {
455  int16_t *dst = (int16_t *)_dst;
456  int i;
457  for (i=0; i<width; i++) {
458  int d= src[i];
459 
460  dst[i]= (pal[d] >> 24)<<6;
461  }
462 }
463 
464 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
465 {
466  int16_t *dst = (int16_t *)_dst;
467  int i;
468  for (i = 0; i < width; i++) {
469  int d = src[i];
470 
471  dst[i] = (pal[d] & 0xFF)<<6;
472  }
473 }
474 
475 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
476  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
477  int width, uint32_t *pal)
478 {
479  uint16_t *dstU = (uint16_t *)_dstU;
480  int16_t *dstV = (int16_t *)_dstV;
481  int i;
482  av_assert1(src1 == src2);
483  for (i = 0; i < width; i++) {
484  int p = pal[src1[i]];
485 
486  dstU[i] = (uint8_t)(p>> 8)<<6;
487  dstV[i] = (uint8_t)(p>>16)<<6;
488  }
489 }
490 
491 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
492 {
493  int16_t *dst = (int16_t *)_dst;
494  int i, j;
495  width = (width + 7) >> 3;
496  for (i = 0; i < width; i++) {
497  int d = ~src[i];
498  for (j = 0; j < 8; j++)
499  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
500  }
501  if(width&7){
502  int d= ~src[i];
503  for (j = 0; j < (width&7); j++)
504  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
505  }
506 }
507 
508 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
509 {
510  int16_t *dst = (int16_t *)_dst;
511  int i, j;
512  width = (width + 7) >> 3;
513  for (i = 0; i < width; i++) {
514  int d = src[i];
515  for (j = 0; j < 8; j++)
516  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
517  }
518  if(width&7){
519  int d = src[i];
520  for (j = 0; j < (width&7); j++)
521  dst[8*i+j] = ((d>>(7-j))&1) * 16383;
522  }
523 }
524 
525 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
526  uint32_t *unused)
527 {
528  int i;
529  for (i = 0; i < width; i++)
530  dst[i] = src[2 * i];
531 }
532 
533 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
534  const uint8_t *src2, int width, uint32_t *unused)
535 {
536  int i;
537  for (i = 0; i < width; i++) {
538  dstU[i] = src1[4 * i + 1];
539  dstV[i] = src1[4 * i + 3];
540  }
541  av_assert1(src1 == src2);
542 }
543 
544 static void yvy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
545  const uint8_t *src2, int width, uint32_t *unused)
546 {
547  int i;
548  for (i = 0; i < width; i++) {
549  dstV[i] = src1[4 * i + 1];
550  dstU[i] = src1[4 * i + 3];
551  }
552  av_assert1(src1 == src2);
553 }
554 
555 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
556  uint32_t *unused)
557 {
558  int i;
559  const uint16_t *src = (const uint16_t *)_src;
560  uint16_t *dst = (uint16_t *)_dst;
561  for (i = 0; i < width; i++)
562  dst[i] = av_bswap16(src[i]);
563 }
564 
565 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
566  const uint8_t *_src2, int width, uint32_t *unused)
567 {
568  int i;
569  const uint16_t *src1 = (const uint16_t *)_src1,
570  *src2 = (const uint16_t *)_src2;
571  uint16_t *dstU = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
572  for (i = 0; i < width; i++) {
573  dstU[i] = av_bswap16(src1[i]);
574  dstV[i] = av_bswap16(src2[i]);
575  }
576 }
577 
578 static void read_ya16le_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
579  uint32_t *unused)
580 {
581  int i;
582  for (i = 0; i < width; i++)
583  AV_WN16(dst + i * 2, AV_RL16(src + i * 4));
584 }
585 
586 static void read_ya16le_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
587  uint32_t *unused)
588 {
589  int i;
590  for (i = 0; i < width; i++)
591  AV_WN16(dst + i * 2, AV_RL16(src + i * 4 + 2));
592 }
593 
594 static void read_ya16be_gray_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
595  uint32_t *unused)
596 {
597  int i;
598  for (i = 0; i < width; i++)
599  AV_WN16(dst + i * 2, AV_RB16(src + i * 4));
600 }
601 
602 static void read_ya16be_alpha_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
603  uint32_t *unused)
604 {
605  int i;
606  for (i = 0; i < width; i++)
607  AV_WN16(dst + i * 2, AV_RB16(src + i * 4 + 2));
608 }
609 
610 static void read_ayuv64le_Y_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
611  uint32_t *unused2)
612 {
613  int i;
614  for (i = 0; i < width; i++)
615  AV_WN16(dst + i * 2, AV_RL16(src + i * 8 + 2));
616 }
617 
618 
619 static void read_ayuv64le_UV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src,
620  const uint8_t *unused1, int width, uint32_t *unused2)
621 {
622  int i;
623  for (i = 0; i < width; i++) {
624  AV_WN16(dstU + i * 2, AV_RL16(src + i * 8 + 4));
625  AV_WN16(dstV + i * 2, AV_RL16(src + i * 8 + 6));
626  }
627 }
628 
629 static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width,
630  uint32_t *unused2)
631 {
632  int i;
633  for (i = 0; i < width; i++)
634  AV_WN16(dst + i * 2, AV_RL16(src + i * 8));
635 }
636 
637 /* This is almost identical to the previous, end exists only because
638  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
639 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
640  uint32_t *unused)
641 {
642  int i;
643  for (i = 0; i < width; i++)
644  dst[i] = src[2 * i + 1];
645 }
646 
647 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
648  const uint8_t *src2, int width, uint32_t *unused)
649 {
650  int i;
651  for (i = 0; i < width; i++) {
652  dstU[i] = src1[4 * i + 0];
653  dstV[i] = src1[4 * i + 2];
654  }
655  av_assert1(src1 == src2);
656 }
657 
658 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
659  const uint8_t *src, int width)
660 {
661  int i;
662  for (i = 0; i < width; i++) {
663  dst1[i] = src[2 * i + 0];
664  dst2[i] = src[2 * i + 1];
665  }
666 }
667 
668 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
669  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
670  int width, uint32_t *unused)
671 {
672  nvXXtoUV_c(dstU, dstV, src1, width);
673 }
674 
675 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
676  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
677  int width, uint32_t *unused)
678 {
679  nvXXtoUV_c(dstV, dstU, src1, width);
680 }
681 
682 static void p010LEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
683  const uint8_t *unused2, int width, uint32_t *unused)
684 {
685  int i;
686  for (i = 0; i < width; i++) {
687  AV_WN16(dst + i * 2, AV_RL16(src + i * 2) >> 6);
688  }
689 }
690 
691 static void p010BEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1,
692  const uint8_t *unused2, int width, uint32_t *unused)
693 {
694  int i;
695  for (i = 0; i < width; i++) {
696  AV_WN16(dst + i * 2, AV_RB16(src + i * 2) >> 6);
697  }
698 }
699 
700 static void p010LEToUV_c(uint8_t *dstU, uint8_t *dstV,
701  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
702  int width, uint32_t *unused)
703 {
704  int i;
705  for (i = 0; i < width; i++) {
706  AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0) >> 6);
707  AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2) >> 6);
708  }
709 }
710 
711 static void p010BEToUV_c(uint8_t *dstU, uint8_t *dstV,
712  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
713  int width, uint32_t *unused)
714 {
715  int i;
716  for (i = 0; i < width; i++) {
717  AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0) >> 6);
718  AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2) >> 6);
719  }
720 }
721 
722 static void p016LEToUV_c(uint8_t *dstU, uint8_t *dstV,
723  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
724  int width, uint32_t *unused)
725 {
726  int i;
727  for (i = 0; i < width; i++) {
728  AV_WN16(dstU + i * 2, AV_RL16(src1 + i * 4 + 0));
729  AV_WN16(dstV + i * 2, AV_RL16(src1 + i * 4 + 2));
730  }
731 }
732 
733 static void p016BEToUV_c(uint8_t *dstU, uint8_t *dstV,
734  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
735  int width, uint32_t *unused)
736 {
737  int i;
738  for (i = 0; i < width; i++) {
739  AV_WN16(dstU + i * 2, AV_RB16(src1 + i * 4 + 0));
740  AV_WN16(dstV + i * 2, AV_RB16(src1 + i * 4 + 2));
741  }
742 }
743 
744 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
745 
746 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
747  int width, uint32_t *rgb2yuv)
748 {
749  int16_t *dst = (int16_t *)_dst;
750  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
751  int i;
752  for (i = 0; i < width; i++) {
753  int b = src[i * 3 + 0];
754  int g = src[i * 3 + 1];
755  int r = src[i * 3 + 2];
756 
757  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
758  }
759 }
760 
761 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
762  const uint8_t *src2, int width, uint32_t *rgb2yuv)
763 {
764  int16_t *dstU = (int16_t *)_dstU;
765  int16_t *dstV = (int16_t *)_dstV;
766  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
767  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
768  int i;
769  for (i = 0; i < width; i++) {
770  int b = src1[3 * i + 0];
771  int g = src1[3 * i + 1];
772  int r = src1[3 * i + 2];
773 
774  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
775  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
776  }
777  av_assert1(src1 == src2);
778 }
779 
780 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
781  const uint8_t *src2, int width, uint32_t *rgb2yuv)
782 {
783  int16_t *dstU = (int16_t *)_dstU;
784  int16_t *dstV = (int16_t *)_dstV;
785  int i;
786  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
787  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
788  for (i = 0; i < width; i++) {
789  int b = src1[6 * i + 0] + src1[6 * i + 3];
790  int g = src1[6 * i + 1] + src1[6 * i + 4];
791  int r = src1[6 * i + 2] + src1[6 * i + 5];
792 
793  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
794  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
795  }
796  av_assert1(src1 == src2);
797 }
798 
799 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
800  uint32_t *rgb2yuv)
801 {
802  int16_t *dst = (int16_t *)_dst;
803  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
804  int i;
805  for (i = 0; i < width; i++) {
806  int r = src[i * 3 + 0];
807  int g = src[i * 3 + 1];
808  int b = src[i * 3 + 2];
809 
810  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
811  }
812 }
813 
814 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
815  const uint8_t *src2, int width, uint32_t *rgb2yuv)
816 {
817  int16_t *dstU = (int16_t *)_dstU;
818  int16_t *dstV = (int16_t *)_dstV;
819  int i;
820  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
821  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
822  av_assert1(src1 == src2);
823  for (i = 0; i < width; i++) {
824  int r = src1[3 * i + 0];
825  int g = src1[3 * i + 1];
826  int b = src1[3 * i + 2];
827 
828  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
829  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
830  }
831 }
832 
833 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
834  const uint8_t *src2, int width, uint32_t *rgb2yuv)
835 {
836  int16_t *dstU = (int16_t *)_dstU;
837  int16_t *dstV = (int16_t *)_dstV;
838  int i;
839  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
840  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
841  av_assert1(src1 == src2);
842  for (i = 0; i < width; i++) {
843  int r = src1[6 * i + 0] + src1[6 * i + 3];
844  int g = src1[6 * i + 1] + src1[6 * i + 4];
845  int b = src1[6 * i + 2] + src1[6 * i + 5];
846 
847  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
848  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
849  }
850 }
851 
852 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
853 {
854  uint16_t *dst = (uint16_t *)_dst;
855  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
856  int i;
857  for (i = 0; i < width; i++) {
858  int g = src[0][i];
859  int b = src[1][i];
860  int r = src[2][i];
861 
862  dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
863  }
864 }
865 
866 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
867 {
868  uint16_t *dst = (uint16_t *)_dst;
869  int i;
870  for (i = 0; i < width; i++)
871  dst[i] = src[3][i] << 6;
872 }
873 
874 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
875 {
876  uint16_t *dstU = (uint16_t *)_dstU;
877  uint16_t *dstV = (uint16_t *)_dstV;
878  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
879  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
880  int i;
881  for (i = 0; i < width; i++) {
882  int g = src[0][i];
883  int b = src[1][i];
884  int r = src[2][i];
885 
886  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
887  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
888  }
889 }
890 
891 #define rdpx(src) \
892  is_be ? AV_RB16(src) : AV_RL16(src)
893 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
894  int width, int bpc, int is_be, int32_t *rgb2yuv)
895 {
896  int i;
897  const uint16_t **src = (const uint16_t **)_src;
898  uint16_t *dst = (uint16_t *)_dst;
899  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
900  int shift = bpc < 16 ? bpc : 14;
901  for (i = 0; i < width; i++) {
902  int g = rdpx(src[0] + i);
903  int b = rdpx(src[1] + i);
904  int r = rdpx(src[2] + i);
905 
906  dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
907  }
908 }
909 
910 static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
911  int width, int bpc, int is_be, int32_t *rgb2yuv)
912 {
913  int i;
914  const uint16_t **src = (const uint16_t **)_src;
915  uint16_t *dst = (uint16_t *)_dst;
916  int shift = bpc < 16 ? bpc : 14;
917 
918  for (i = 0; i < width; i++) {
919  dst[i] = rdpx(src[3] + i) << (14 - shift);
920  }
921 }
922 
923 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
924  const uint8_t *_src[4], int width,
925  int bpc, int is_be, int32_t *rgb2yuv)
926 {
927  int i;
928  const uint16_t **src = (const uint16_t **)_src;
929  uint16_t *dstU = (uint16_t *)_dstU;
930  uint16_t *dstV = (uint16_t *)_dstV;
931  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
932  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
933  int shift = bpc < 16 ? bpc : 14;
934  for (i = 0; i < width; i++) {
935  int g = rdpx(src[0] + i);
936  int b = rdpx(src[1] + i);
937  int r = rdpx(src[2] + i);
938 
939  dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
940  dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
941  }
942 }
943 #undef rdpx
944 
945 static av_always_inline void grayf32ToY16_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
946  const uint8_t *unused2, int width, uint32_t *unused)
947 {
948  int i;
949  const float *src = (const float *)_src;
950  uint16_t *dst = (uint16_t *)_dst;
951 
952  for (i = 0; i < width; ++i){
953  dst[i] = av_clip_uint16(lrintf(65535.0f * src[i]));
954  }
955 }
956 
957 static av_always_inline void grayf32ToY16_bswap_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
958  const uint8_t *unused2, int width, uint32_t *unused)
959 {
960  int i;
961  const uint32_t *src = (const uint32_t *)_src;
962  uint16_t *dst = (uint16_t *)_dst;
963 
964  for (i = 0; i < width; ++i){
965  dst[i] = av_clip_uint16(lrintf(65535.0f * av_int2float(av_bswap32(src[i]))));
966  }
967 }
968 
969 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian) \
970 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
971  int w, int32_t *rgb2yuv) \
972 { \
973  planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv); \
974 } \
975 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
976  const uint8_t *src[4], int w, int32_t *rgb2yuv) \
977 { \
978  planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
979 } \
980 
981 #define rgb9plus_planar_transparency_funcs(nbits) \
982 static void planar_rgb##nbits##le_to_a(uint8_t *dst, const uint8_t *src[4], \
983  int w, int32_t *rgb2yuv) \
984 { \
985  planar_rgb16_to_a(dst, src, w, nbits, 0, rgb2yuv); \
986 } \
987 static void planar_rgb##nbits##be_to_a(uint8_t *dst, const uint8_t *src[4], \
988  int w, int32_t *rgb2yuv) \
989 { \
990  planar_rgb16_to_a(dst, src, w, nbits, 1, rgb2yuv); \
991 }
992 
993 #define rgb9plus_planar_funcs(nbits) \
994  rgb9plus_planar_funcs_endian(nbits, le, 0) \
995  rgb9plus_planar_funcs_endian(nbits, be, 1)
996 
997 rgb9plus_planar_funcs(9)
998 rgb9plus_planar_funcs(10)
999 rgb9plus_planar_funcs(12)
1000 rgb9plus_planar_funcs(14)
1001 rgb9plus_planar_funcs(16)
1002 
1003 rgb9plus_planar_transparency_funcs(10)
1004 rgb9plus_planar_transparency_funcs(12)
1005 rgb9plus_planar_transparency_funcs(16)
1006 
1007 av_cold void ff_sws_init_input_funcs(SwsContext *c)
1008 {
1009  enum AVPixelFormat srcFormat = c->srcFormat;
1010 
1011  c->chrToYV12 = NULL;
1012  switch (srcFormat) {
1013  case AV_PIX_FMT_YUYV422:
1014  c->chrToYV12 = yuy2ToUV_c;
1015  break;
1016  case AV_PIX_FMT_YVYU422:
1017  c->chrToYV12 = yvy2ToUV_c;
1018  break;
1019  case AV_PIX_FMT_UYVY422:
1020  c->chrToYV12 = uyvyToUV_c;
1021  break;
1022  case AV_PIX_FMT_NV12:
1023  case AV_PIX_FMT_NV24:
1024  c->chrToYV12 = nv12ToUV_c;
1025  break;
1026  case AV_PIX_FMT_NV21:
1027  case AV_PIX_FMT_NV42:
1028  c->chrToYV12 = nv21ToUV_c;
1029  break;
1030  case AV_PIX_FMT_RGB8:
1031  case AV_PIX_FMT_BGR8:
1032  case AV_PIX_FMT_PAL8:
1033  case AV_PIX_FMT_BGR4_BYTE:
1034  case AV_PIX_FMT_RGB4_BYTE:
1035  c->chrToYV12 = palToUV_c;
1036  break;
1037  case AV_PIX_FMT_GBRP9LE:
1038  c->readChrPlanar = planar_rgb9le_to_uv;
1039  break;
1040  case AV_PIX_FMT_GBRAP10LE:
1041  case AV_PIX_FMT_GBRP10LE:
1042  c->readChrPlanar = planar_rgb10le_to_uv;
1043  break;
1044  case AV_PIX_FMT_GBRAP12LE:
1045  case AV_PIX_FMT_GBRP12LE:
1046  c->readChrPlanar = planar_rgb12le_to_uv;
1047  break;
1048  case AV_PIX_FMT_GBRP14LE:
1049  c->readChrPlanar = planar_rgb14le_to_uv;
1050  break;
1051  case AV_PIX_FMT_GBRAP16LE:
1052  case AV_PIX_FMT_GBRP16LE:
1053  c->readChrPlanar = planar_rgb16le_to_uv;
1054  break;
1055  case AV_PIX_FMT_GBRP9BE:
1056  c->readChrPlanar = planar_rgb9be_to_uv;
1057  break;
1058  case AV_PIX_FMT_GBRAP10BE:
1059  case AV_PIX_FMT_GBRP10BE:
1060  c->readChrPlanar = planar_rgb10be_to_uv;
1061  break;
1062  case AV_PIX_FMT_GBRAP12BE:
1063  case AV_PIX_FMT_GBRP12BE:
1064  c->readChrPlanar = planar_rgb12be_to_uv;
1065  break;
1066  case AV_PIX_FMT_GBRP14BE:
1067  c->readChrPlanar = planar_rgb14be_to_uv;
1068  break;
1069  case AV_PIX_FMT_GBRAP16BE:
1070  case AV_PIX_FMT_GBRP16BE:
1071  c->readChrPlanar = planar_rgb16be_to_uv;
1072  break;
1073  case AV_PIX_FMT_GBRAP:
1074  case AV_PIX_FMT_GBRP:
1075  c->readChrPlanar = planar_rgb_to_uv;
1076  break;
1077 #if HAVE_BIGENDIAN
1078  case AV_PIX_FMT_YUV420P9LE:
1079  case AV_PIX_FMT_YUV422P9LE:
1080  case AV_PIX_FMT_YUV444P9LE:
1081  case AV_PIX_FMT_YUV420P10LE:
1082  case AV_PIX_FMT_YUV422P10LE:
1083  case AV_PIX_FMT_YUV440P10LE:
1084  case AV_PIX_FMT_YUV444P10LE:
1085  case AV_PIX_FMT_YUV420P12LE:
1086  case AV_PIX_FMT_YUV422P12LE:
1087  case AV_PIX_FMT_YUV440P12LE:
1088  case AV_PIX_FMT_YUV444P12LE:
1089  case AV_PIX_FMT_YUV420P14LE:
1090  case AV_PIX_FMT_YUV422P14LE:
1091  case AV_PIX_FMT_YUV444P14LE:
1092  case AV_PIX_FMT_YUV420P16LE:
1093  case AV_PIX_FMT_YUV422P16LE:
1094  case AV_PIX_FMT_YUV444P16LE:
1095 
1096  case AV_PIX_FMT_YUVA420P9LE:
1097  case AV_PIX_FMT_YUVA422P9LE:
1098  case AV_PIX_FMT_YUVA444P9LE:
1099  case AV_PIX_FMT_YUVA420P10LE:
1100  case AV_PIX_FMT_YUVA422P10LE:
1101  case AV_PIX_FMT_YUVA444P10LE:
1102  case AV_PIX_FMT_YUVA422P12LE:
1103  case AV_PIX_FMT_YUVA444P12LE:
1104  case AV_PIX_FMT_YUVA420P16LE:
1105  case AV_PIX_FMT_YUVA422P16LE:
1106  case AV_PIX_FMT_YUVA444P16LE:
1107  c->chrToYV12 = bswap16UV_c;
1108  break;
1109 #else
1110  case AV_PIX_FMT_YUV420P9BE:
1111  case AV_PIX_FMT_YUV422P9BE:
1112  case AV_PIX_FMT_YUV444P9BE:
1113  case AV_PIX_FMT_YUV420P10BE:
1114  case AV_PIX_FMT_YUV422P10BE:
1115  case AV_PIX_FMT_YUV440P10BE:
1116  case AV_PIX_FMT_YUV444P10BE:
1117  case AV_PIX_FMT_YUV420P12BE:
1118  case AV_PIX_FMT_YUV422P12BE:
1119  case AV_PIX_FMT_YUV440P12BE:
1120  case AV_PIX_FMT_YUV444P12BE:
1121  case AV_PIX_FMT_YUV420P14BE:
1122  case AV_PIX_FMT_YUV422P14BE:
1123  case AV_PIX_FMT_YUV444P14BE:
1124  case AV_PIX_FMT_YUV420P16BE:
1125  case AV_PIX_FMT_YUV422P16BE:
1126  case AV_PIX_FMT_YUV444P16BE:
1127 
1128  case AV_PIX_FMT_YUVA420P9BE:
1129  case AV_PIX_FMT_YUVA422P9BE:
1130  case AV_PIX_FMT_YUVA444P9BE:
1131  case AV_PIX_FMT_YUVA420P10BE:
1132  case AV_PIX_FMT_YUVA422P10BE:
1133  case AV_PIX_FMT_YUVA444P10BE:
1134  case AV_PIX_FMT_YUVA422P12BE:
1135  case AV_PIX_FMT_YUVA444P12BE:
1136  case AV_PIX_FMT_YUVA420P16BE:
1137  case AV_PIX_FMT_YUVA422P16BE:
1138  case AV_PIX_FMT_YUVA444P16BE:
1139  c->chrToYV12 = bswap16UV_c;
1140  break;
1141 #endif
1142  case AV_PIX_FMT_AYUV64LE:
1143  c->chrToYV12 = read_ayuv64le_UV_c;
1144  break;
1145  case AV_PIX_FMT_P010LE:
1146  c->chrToYV12 = p010LEToUV_c;
1147  break;
1148  case AV_PIX_FMT_P010BE:
1149  c->chrToYV12 = p010BEToUV_c;
1150  break;
1151  case AV_PIX_FMT_P016LE:
1152  c->chrToYV12 = p016LEToUV_c;
1153  break;
1154  case AV_PIX_FMT_P016BE:
1155  c->chrToYV12 = p016BEToUV_c;
1156  break;
1157  }
1158  if (c->chrSrcHSubSample) {
1159  switch (srcFormat) {
1160  case AV_PIX_FMT_RGBA64BE:
1161  c->chrToYV12 = rgb64BEToUV_half_c;
1162  break;
1163  case AV_PIX_FMT_RGBA64LE:
1164  c->chrToYV12 = rgb64LEToUV_half_c;
1165  break;
1166  case AV_PIX_FMT_BGRA64BE:
1167  c->chrToYV12 = bgr64BEToUV_half_c;
1168  break;
1169  case AV_PIX_FMT_BGRA64LE:
1170  c->chrToYV12 = bgr64LEToUV_half_c;
1171  break;
1172  case AV_PIX_FMT_RGB48BE:
1173  c->chrToYV12 = rgb48BEToUV_half_c;
1174  break;
1175  case AV_PIX_FMT_RGB48LE:
1176  c->chrToYV12 = rgb48LEToUV_half_c;
1177  break;
1178  case AV_PIX_FMT_BGR48BE:
1179  c->chrToYV12 = bgr48BEToUV_half_c;
1180  break;
1181  case AV_PIX_FMT_BGR48LE:
1182  c->chrToYV12 = bgr48LEToUV_half_c;
1183  break;
1184  case AV_PIX_FMT_RGB32:
1185  c->chrToYV12 = bgr32ToUV_half_c;
1186  break;
1187  case AV_PIX_FMT_RGB32_1:
1188  c->chrToYV12 = bgr321ToUV_half_c;
1189  break;
1190  case AV_PIX_FMT_BGR24:
1191  c->chrToYV12 = bgr24ToUV_half_c;
1192  break;
1193  case AV_PIX_FMT_BGR565LE:
1194  c->chrToYV12 = bgr16leToUV_half_c;
1195  break;
1196  case AV_PIX_FMT_BGR565BE:
1197  c->chrToYV12 = bgr16beToUV_half_c;
1198  break;
1199  case AV_PIX_FMT_BGR555LE:
1200  c->chrToYV12 = bgr15leToUV_half_c;
1201  break;
1202  case AV_PIX_FMT_BGR555BE:
1203  c->chrToYV12 = bgr15beToUV_half_c;
1204  break;
1205  case AV_PIX_FMT_GBRAP:
1206  case AV_PIX_FMT_GBRP:
1207  c->chrToYV12 = gbr24pToUV_half_c;
1208  break;
1209  case AV_PIX_FMT_BGR444LE:
1210  c->chrToYV12 = bgr12leToUV_half_c;
1211  break;
1212  case AV_PIX_FMT_BGR444BE:
1213  c->chrToYV12 = bgr12beToUV_half_c;
1214  break;
1215  case AV_PIX_FMT_BGR32:
1216  c->chrToYV12 = rgb32ToUV_half_c;
1217  break;
1218  case AV_PIX_FMT_BGR32_1:
1219  c->chrToYV12 = rgb321ToUV_half_c;
1220  break;
1221  case AV_PIX_FMT_RGB24:
1222  c->chrToYV12 = rgb24ToUV_half_c;
1223  break;
1224  case AV_PIX_FMT_RGB565LE:
1225  c->chrToYV12 = rgb16leToUV_half_c;
1226  break;
1227  case AV_PIX_FMT_RGB565BE:
1228  c->chrToYV12 = rgb16beToUV_half_c;
1229  break;
1230  case AV_PIX_FMT_RGB555LE:
1231  c->chrToYV12 = rgb15leToUV_half_c;
1232  break;
1233  case AV_PIX_FMT_RGB555BE:
1234  c->chrToYV12 = rgb15beToUV_half_c;
1235  break;
1236  case AV_PIX_FMT_RGB444LE:
1237  c->chrToYV12 = rgb12leToUV_half_c;
1238  break;
1239  case AV_PIX_FMT_RGB444BE:
1240  c->chrToYV12 = rgb12beToUV_half_c;
1241  break;
1242  }
1243  } else {
1244  switch (srcFormat) {
1245  case AV_PIX_FMT_RGBA64BE:
1246  c->chrToYV12 = rgb64BEToUV_c;
1247  break;
1248  case AV_PIX_FMT_RGBA64LE:
1249  c->chrToYV12 = rgb64LEToUV_c;
1250  break;
1251  case AV_PIX_FMT_BGRA64BE:
1252  c->chrToYV12 = bgr64BEToUV_c;
1253  break;
1254  case AV_PIX_FMT_BGRA64LE:
1255  c->chrToYV12 = bgr64LEToUV_c;
1256  break;
1257  case AV_PIX_FMT_RGB48BE:
1258  c->chrToYV12 = rgb48BEToUV_c;
1259  break;
1260  case AV_PIX_FMT_RGB48LE:
1261  c->chrToYV12 = rgb48LEToUV_c;
1262  break;
1263  case AV_PIX_FMT_BGR48BE:
1264  c->chrToYV12 = bgr48BEToUV_c;
1265  break;
1266  case AV_PIX_FMT_BGR48LE:
1267  c->chrToYV12 = bgr48LEToUV_c;
1268  break;
1269  case AV_PIX_FMT_RGB32:
1270  c->chrToYV12 = bgr32ToUV_c;
1271  break;
1272  case AV_PIX_FMT_RGB32_1:
1273  c->chrToYV12 = bgr321ToUV_c;
1274  break;
1275  case AV_PIX_FMT_BGR24:
1276  c->chrToYV12 = bgr24ToUV_c;
1277  break;
1278  case AV_PIX_FMT_BGR565LE:
1279  c->chrToYV12 = bgr16leToUV_c;
1280  break;
1281  case AV_PIX_FMT_BGR565BE:
1282  c->chrToYV12 = bgr16beToUV_c;
1283  break;
1284  case AV_PIX_FMT_BGR555LE:
1285  c->chrToYV12 = bgr15leToUV_c;
1286  break;
1287  case AV_PIX_FMT_BGR555BE:
1288  c->chrToYV12 = bgr15beToUV_c;
1289  break;
1290  case AV_PIX_FMT_BGR444LE:
1291  c->chrToYV12 = bgr12leToUV_c;
1292  break;
1293  case AV_PIX_FMT_BGR444BE:
1294  c->chrToYV12 = bgr12beToUV_c;
1295  break;
1296  case AV_PIX_FMT_BGR32:
1297  c->chrToYV12 = rgb32ToUV_c;
1298  break;
1299  case AV_PIX_FMT_BGR32_1:
1300  c->chrToYV12 = rgb321ToUV_c;
1301  break;
1302  case AV_PIX_FMT_RGB24:
1303  c->chrToYV12 = rgb24ToUV_c;
1304  break;
1305  case AV_PIX_FMT_RGB565LE:
1306  c->chrToYV12 = rgb16leToUV_c;
1307  break;
1308  case AV_PIX_FMT_RGB565BE:
1309  c->chrToYV12 = rgb16beToUV_c;
1310  break;
1311  case AV_PIX_FMT_RGB555LE:
1312  c->chrToYV12 = rgb15leToUV_c;
1313  break;
1314  case AV_PIX_FMT_RGB555BE:
1315  c->chrToYV12 = rgb15beToUV_c;
1316  break;
1317  case AV_PIX_FMT_RGB444LE:
1318  c->chrToYV12 = rgb12leToUV_c;
1319  break;
1320  case AV_PIX_FMT_RGB444BE:
1321  c->chrToYV12 = rgb12beToUV_c;
1322  break;
1323  }
1324  }
1325 
1326  c->lumToYV12 = NULL;
1327  c->alpToYV12 = NULL;
1328  switch (srcFormat) {
1329  case AV_PIX_FMT_GBRP9LE:
1330  c->readLumPlanar = planar_rgb9le_to_y;
1331  break;
1332  case AV_PIX_FMT_GBRAP10LE:
1333  c->readAlpPlanar = planar_rgb10le_to_a;
1334  case AV_PIX_FMT_GBRP10LE:
1335  c->readLumPlanar = planar_rgb10le_to_y;
1336  break;
1337  case AV_PIX_FMT_GBRAP12LE:
1338  c->readAlpPlanar = planar_rgb12le_to_a;
1339  case AV_PIX_FMT_GBRP12LE:
1340  c->readLumPlanar = planar_rgb12le_to_y;
1341  break;
1342  case AV_PIX_FMT_GBRP14LE:
1343  c->readLumPlanar = planar_rgb14le_to_y;
1344  break;
1345  case AV_PIX_FMT_GBRAP16LE:
1346  c->readAlpPlanar = planar_rgb16le_to_a;
1347  case AV_PIX_FMT_GBRP16LE:
1348  c->readLumPlanar = planar_rgb16le_to_y;
1349  break;
1350  case AV_PIX_FMT_GBRP9BE:
1351  c->readLumPlanar = planar_rgb9be_to_y;
1352  break;
1353  case AV_PIX_FMT_GBRAP10BE:
1354  c->readAlpPlanar = planar_rgb10be_to_a;
1355  case AV_PIX_FMT_GBRP10BE:
1356  c->readLumPlanar = planar_rgb10be_to_y;
1357  break;
1358  case AV_PIX_FMT_GBRAP12BE:
1359  c->readAlpPlanar = planar_rgb12be_to_a;
1360  case AV_PIX_FMT_GBRP12BE:
1361  c->readLumPlanar = planar_rgb12be_to_y;
1362  break;
1363  case AV_PIX_FMT_GBRP14BE:
1364  c->readLumPlanar = planar_rgb14be_to_y;
1365  break;
1366  case AV_PIX_FMT_GBRAP16BE:
1367  c->readAlpPlanar = planar_rgb16be_to_a;
1368  case AV_PIX_FMT_GBRP16BE:
1369  c->readLumPlanar = planar_rgb16be_to_y;
1370  break;
1371  case AV_PIX_FMT_GBRAP:
1372  c->readAlpPlanar = planar_rgb_to_a;
1373  case AV_PIX_FMT_GBRP:
1374  c->readLumPlanar = planar_rgb_to_y;
1375  break;
1376 #if HAVE_BIGENDIAN
1377  case AV_PIX_FMT_YUV420P9LE:
1378  case AV_PIX_FMT_YUV422P9LE:
1379  case AV_PIX_FMT_YUV444P9LE:
1380  case AV_PIX_FMT_YUV420P10LE:
1381  case AV_PIX_FMT_YUV422P10LE:
1382  case AV_PIX_FMT_YUV440P10LE:
1383  case AV_PIX_FMT_YUV444P10LE:
1384  case AV_PIX_FMT_YUV420P12LE:
1385  case AV_PIX_FMT_YUV422P12LE:
1386  case AV_PIX_FMT_YUV440P12LE:
1387  case AV_PIX_FMT_YUV444P12LE:
1388  case AV_PIX_FMT_YUV420P14LE:
1389  case AV_PIX_FMT_YUV422P14LE:
1390  case AV_PIX_FMT_YUV444P14LE:
1391  case AV_PIX_FMT_YUV420P16LE:
1392  case AV_PIX_FMT_YUV422P16LE:
1393  case AV_PIX_FMT_YUV444P16LE:
1394 
1395  case AV_PIX_FMT_GRAY9LE:
1396  case AV_PIX_FMT_GRAY10LE:
1397  case AV_PIX_FMT_GRAY12LE:
1398  case AV_PIX_FMT_GRAY14LE:
1399  case AV_PIX_FMT_GRAY16LE:
1400 
1401  case AV_PIX_FMT_P016LE:
1402  c->lumToYV12 = bswap16Y_c;
1403  break;
1404  case AV_PIX_FMT_YUVA420P9LE:
1405  case AV_PIX_FMT_YUVA422P9LE:
1406  case AV_PIX_FMT_YUVA444P9LE:
1407  case AV_PIX_FMT_YUVA420P10LE:
1408  case AV_PIX_FMT_YUVA422P10LE:
1409  case AV_PIX_FMT_YUVA444P10LE:
1410  case AV_PIX_FMT_YUVA422P12LE:
1411  case AV_PIX_FMT_YUVA444P12LE:
1412  case AV_PIX_FMT_YUVA420P16LE:
1413  case AV_PIX_FMT_YUVA422P16LE:
1414  case AV_PIX_FMT_YUVA444P16LE:
1415  c->lumToYV12 = bswap16Y_c;
1416  c->alpToYV12 = bswap16Y_c;
1417  break;
1418 #else
1419  case AV_PIX_FMT_YUV420P9BE:
1420  case AV_PIX_FMT_YUV422P9BE:
1421  case AV_PIX_FMT_YUV444P9BE:
1422  case AV_PIX_FMT_YUV420P10BE:
1423  case AV_PIX_FMT_YUV422P10BE:
1424  case AV_PIX_FMT_YUV440P10BE:
1425  case AV_PIX_FMT_YUV444P10BE:
1426  case AV_PIX_FMT_YUV420P12BE:
1427  case AV_PIX_FMT_YUV422P12BE:
1428  case AV_PIX_FMT_YUV440P12BE:
1429  case AV_PIX_FMT_YUV444P12BE:
1430  case AV_PIX_FMT_YUV420P14BE:
1431  case AV_PIX_FMT_YUV422P14BE:
1432  case AV_PIX_FMT_YUV444P14BE:
1433  case AV_PIX_FMT_YUV420P16BE:
1434  case AV_PIX_FMT_YUV422P16BE:
1435  case AV_PIX_FMT_YUV444P16BE:
1436 
1437  case AV_PIX_FMT_GRAY9BE:
1438  case AV_PIX_FMT_GRAY10BE:
1439  case AV_PIX_FMT_GRAY12BE:
1440  case AV_PIX_FMT_GRAY14BE:
1441  case AV_PIX_FMT_GRAY16BE:
1442 
1443  case AV_PIX_FMT_P016BE:
1444  c->lumToYV12 = bswap16Y_c;
1445  break;
1446  case AV_PIX_FMT_YUVA420P9BE:
1447  case AV_PIX_FMT_YUVA422P9BE:
1448  case AV_PIX_FMT_YUVA444P9BE:
1449  case AV_PIX_FMT_YUVA420P10BE:
1450  case AV_PIX_FMT_YUVA422P10BE:
1451  case AV_PIX_FMT_YUVA444P10BE:
1452  case AV_PIX_FMT_YUVA422P12BE:
1453  case AV_PIX_FMT_YUVA444P12BE:
1454  case AV_PIX_FMT_YUVA420P16BE:
1455  case AV_PIX_FMT_YUVA422P16BE:
1456  case AV_PIX_FMT_YUVA444P16BE:
1457  c->lumToYV12 = bswap16Y_c;
1458  c->alpToYV12 = bswap16Y_c;
1459  break;
1460 #endif
1461  case AV_PIX_FMT_YA16LE:
1462  c->lumToYV12 = read_ya16le_gray_c;
1463  break;
1464  case AV_PIX_FMT_YA16BE:
1465  c->lumToYV12 = read_ya16be_gray_c;
1466  break;
1467  case AV_PIX_FMT_AYUV64LE:
1468  c->lumToYV12 = read_ayuv64le_Y_c;
1469  break;
1470  case AV_PIX_FMT_YUYV422:
1471  case AV_PIX_FMT_YVYU422:
1472  case AV_PIX_FMT_YA8:
1473  c->lumToYV12 = yuy2ToY_c;
1474  break;
1475  case AV_PIX_FMT_UYVY422:
1476  c->lumToYV12 = uyvyToY_c;
1477  break;
1478  case AV_PIX_FMT_BGR24:
1479  c->lumToYV12 = bgr24ToY_c;
1480  break;
1481  case AV_PIX_FMT_BGR565LE:
1482  c->lumToYV12 = bgr16leToY_c;
1483  break;
1484  case AV_PIX_FMT_BGR565BE:
1485  c->lumToYV12 = bgr16beToY_c;
1486  break;
1487  case AV_PIX_FMT_BGR555LE:
1488  c->lumToYV12 = bgr15leToY_c;
1489  break;
1490  case AV_PIX_FMT_BGR555BE:
1491  c->lumToYV12 = bgr15beToY_c;
1492  break;
1493  case AV_PIX_FMT_BGR444LE:
1494  c->lumToYV12 = bgr12leToY_c;
1495  break;
1496  case AV_PIX_FMT_BGR444BE:
1497  c->lumToYV12 = bgr12beToY_c;
1498  break;
1499  case AV_PIX_FMT_RGB24:
1500  c->lumToYV12 = rgb24ToY_c;
1501  break;
1502  case AV_PIX_FMT_RGB565LE:
1503  c->lumToYV12 = rgb16leToY_c;
1504  break;
1505  case AV_PIX_FMT_RGB565BE:
1506  c->lumToYV12 = rgb16beToY_c;
1507  break;
1508  case AV_PIX_FMT_RGB555LE:
1509  c->lumToYV12 = rgb15leToY_c;
1510  break;
1511  case AV_PIX_FMT_RGB555BE:
1512  c->lumToYV12 = rgb15beToY_c;
1513  break;
1514  case AV_PIX_FMT_RGB444LE:
1515  c->lumToYV12 = rgb12leToY_c;
1516  break;
1517  case AV_PIX_FMT_RGB444BE:
1518  c->lumToYV12 = rgb12beToY_c;
1519  break;
1520  case AV_PIX_FMT_RGB8:
1521  case AV_PIX_FMT_BGR8:
1522  case AV_PIX_FMT_PAL8:
1523  case AV_PIX_FMT_BGR4_BYTE:
1524  case AV_PIX_FMT_RGB4_BYTE:
1525  c->lumToYV12 = palToY_c;
1526  break;
1527  case AV_PIX_FMT_MONOBLACK:
1528  c->lumToYV12 = monoblack2Y_c;
1529  break;
1530  case AV_PIX_FMT_MONOWHITE:
1531  c->lumToYV12 = monowhite2Y_c;
1532  break;
1533  case AV_PIX_FMT_RGB32:
1534  c->lumToYV12 = bgr32ToY_c;
1535  break;
1536  case AV_PIX_FMT_RGB32_1:
1537  c->lumToYV12 = bgr321ToY_c;
1538  break;
1539  case AV_PIX_FMT_BGR32:
1540  c->lumToYV12 = rgb32ToY_c;
1541  break;
1542  case AV_PIX_FMT_BGR32_1:
1543  c->lumToYV12 = rgb321ToY_c;
1544  break;
1545  case AV_PIX_FMT_RGB48BE:
1546  c->lumToYV12 = rgb48BEToY_c;
1547  break;
1548  case AV_PIX_FMT_RGB48LE:
1549  c->lumToYV12 = rgb48LEToY_c;
1550  break;
1551  case AV_PIX_FMT_BGR48BE:
1552  c->lumToYV12 = bgr48BEToY_c;
1553  break;
1554  case AV_PIX_FMT_BGR48LE:
1555  c->lumToYV12 = bgr48LEToY_c;
1556  break;
1557  case AV_PIX_FMT_RGBA64BE:
1558  c->lumToYV12 = rgb64BEToY_c;
1559  break;
1560  case AV_PIX_FMT_RGBA64LE:
1561  c->lumToYV12 = rgb64LEToY_c;
1562  break;
1563  case AV_PIX_FMT_BGRA64BE:
1564  c->lumToYV12 = bgr64BEToY_c;
1565  break;
1566  case AV_PIX_FMT_BGRA64LE:
1567  c->lumToYV12 = bgr64LEToY_c;
1568  break;
1569  case AV_PIX_FMT_P010LE:
1570  c->lumToYV12 = p010LEToY_c;
1571  break;
1572  case AV_PIX_FMT_P010BE:
1573  c->lumToYV12 = p010BEToY_c;
1574  break;
1575  case AV_PIX_FMT_GRAYF32LE:
1576 #if HAVE_BIGENDIAN
1577  c->lumToYV12 = grayf32ToY16_bswap_c;
1578 #else
1579  c->lumToYV12 = grayf32ToY16_c;
1580 #endif
1581  break;
1582  case AV_PIX_FMT_GRAYF32BE:
1583 #if HAVE_BIGENDIAN
1584  c->lumToYV12 = grayf32ToY16_c;
1585 #else
1586  c->lumToYV12 = grayf32ToY16_bswap_c;
1587 #endif
1588  break;
1589  }
1590  if (c->needAlpha) {
1591  if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1592  if (HAVE_BIGENDIAN == !isBE(srcFormat) && !c->readAlpPlanar)
1593  c->alpToYV12 = bswap16Y_c;
1594  }
1595  switch (srcFormat) {
1596  case AV_PIX_FMT_BGRA64LE:
1597  case AV_PIX_FMT_RGBA64LE: c->alpToYV12 = rgba64leToA_c; break;
1598  case AV_PIX_FMT_BGRA64BE:
1599  case AV_PIX_FMT_RGBA64BE: c->alpToYV12 = rgba64beToA_c; break;
1600  case AV_PIX_FMT_BGRA:
1601  case AV_PIX_FMT_RGBA:
1602  c->alpToYV12 = rgbaToA_c;
1603  break;
1604  case AV_PIX_FMT_ABGR:
1605  case AV_PIX_FMT_ARGB:
1606  c->alpToYV12 = abgrToA_c;
1607  break;
1608  case AV_PIX_FMT_YA8:
1609  c->alpToYV12 = uyvyToY_c;
1610  break;
1611  case AV_PIX_FMT_YA16LE:
1612  c->alpToYV12 = read_ya16le_alpha_c;
1613  break;
1614  case AV_PIX_FMT_YA16BE:
1615  c->alpToYV12 = read_ya16be_alpha_c;
1616  break;
1617  case AV_PIX_FMT_AYUV64LE:
1618  c->alpToYV12 = read_ayuv64le_A_c;
1619  break;
1620  case AV_PIX_FMT_PAL8 :
1621  c->alpToYV12 = palToA_c;
1622  break;
1623  }
1624  }
1625 }
planar_rgb_to_a
static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
Definition: input.c:866
AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:81
AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:340
AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:291
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)
Definition: input.c:668
NULL
#define NULL
Definition: coverity.c:32
AV_PIX_FMT_YUV422P9BE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:166
AV_PIX_FMT_YUV440P10LE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:275
AV_PIX_FMT_YUV444P14BE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:252
bgr24ToY_c
static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *rgb2yuv)
Definition: input.c:746
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)
Definition: input.c:675
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)
Definition: input.c:533
shift
static int shift(int a, int b)
Definition: sonic.c:82
AV_PIX_FMT_YUV420P14LE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:245
p016BEToUV_c
static void p016BEToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
Definition: input.c:733
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)
Definition: input.c:647
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)
Definition: input.c:78
RV_IDX
#define RV_IDX
Definition: swscale_internal.h:412
bgr15le
RGB2YUV_SHIFT RGB2YUV_SHIFT bgr15le
Definition: input.c:383
AV_PIX_FMT_YUV422P14LE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:249
AV_PIX_FMT_YUV420P10LE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:159
BV_IDX
#define BV_IDX
Definition: swscale_internal.h:414
AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:143
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:208
rgb2yuv
static void fn() rgb2yuv(uint8_t *_yuv[3], const ptrdiff_t yuv_stride[3], int16_t *rgb[3], ptrdiff_t s, int w, int h, const int16_t rgb2yuv_coeffs[3][3][8], const int16_t yuv_offset[8])
Definition: colorspacedsp_template.c:130
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:346
AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
rgb9plus_planar_funcs
#define rgb9plus_planar_funcs(nbits)
Definition: input.c:993
g
const char * g
Definition: vf_curves.c:115
AV_PIX_FMT_YUV444P9BE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:162
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
AV_PIX_FMT_YUV444P12BE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:250
AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:108
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:207
GV_IDX
#define GV_IDX
Definition: swscale_internal.h:413
av_bswap16
#define av_bswap16
Definition: bswap.h:31
AV_PIX_FMT_YUVA444P10LE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:189
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:646
avutil.h
Convenience header that includes libavutil&#39;s core.
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)
Definition: input.c:874
AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:111
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)
Definition: input.c:610
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)
Definition: input.c:491
AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:255
AV_PIX_FMT_YUV420P9BE
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:156
AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:140
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)
Definition: input.c:602
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:87
src
#define src
Definition: vp8dsp.c:254
AV_PIX_FMT_GRAY12LE
Y , 12bpp, little-endian.
Definition: pixfmt.h:296
AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:254
AV_PIX_FMT_YUV420P16LE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:131
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:87
r_b
#define r_b
grayf32ToY16_bswap_c
static av_always_inline void grayf32ToY16_bswap_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
Definition: input.c:957
ff_sws_init_input_funcs
void ff_sws_init_input_funcs(SwsContext *c)
b_r
#define b_r
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)
Definition: input.c:525
AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
rgb12be
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb12be
Definition: input.c:393
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:179
RU_IDX
#define RU_IDX
Definition: swscale_internal.h:409
AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:216
AV_PIX_FMT_YUVA420P16BE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:190
p010LEToY_c
static void p010LEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
Definition: input.c:682
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:344
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
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:103
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)
Definition: input.c:761
f
#define f(width, name)
Definition: cbs_vp9.c:255
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
rgb16le
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb16le
Definition: input.c:385
bgr321
bgr321
Definition: input.c:379
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:205
AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:139
AV_PIX_FMT_YUV444P12LE
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:251
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
AV_PIX_FMT_YUVA420P16LE
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:191
p010BEToUV_c
static void p010BEToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
Definition: input.c:711
AV_PIX_FMT_YUV440P10BE
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:276
AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:174
AV_PIX_FMT_GRAY9LE
Y , 9bpp, little-endian.
Definition: pixfmt.h:316
input_pixel
#define input_pixel(pos)
Definition: input.c:744
AV_PIX_FMT_YUVA444P16BE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:194
lrintf
#define lrintf(x)
Definition: libm_mips.h:70
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)
Definition: input.c:639
AV_PIX_FMT_GRAY10LE
Y , 10bpp, little-endian.
Definition: pixfmt.h:298
swscale.h
external API header
AV_PIX_FMT_YUV440P12BE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:278
p010LEToUV_c
static void p010LEToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
Definition: input.c:700
r
#define r
Definition: input.c:40
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)
Definition: input.c:453
AV_PIX_FMT_YUV420P9LE
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:157
U
#define U(x)
Definition: vp56_arith.h:37
AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:170
AV_PIX_FMT_YUV444P10LE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:165
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:363
AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:212
S
#define S(s, c, i)
Definition: flacdsp_template.c:46
AV_PIX_FMT_P016BE
like NV12, with 16bpp per component, big-endian
Definition: pixfmt.h:301
AV_PIX_FMT_YUV444P16BE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:136
AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
AV_PIX_FMT_YUVA444P9BE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:182
AV_PIX_FMT_YUV422P10LE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:161
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:89
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
AV_PIX_FMT_YUV422P14BE
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:248
planar_rgb16_to_a
static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4], int width, int bpc, int is_be, int32_t *rgb2yuv)
Definition: input.c:910
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)
Definition: input.c:146
AV_PIX_FMT_P016LE
like NV12, with 16bpp per component, little-endian
Definition: pixfmt.h:300
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)
Definition: input.c:444
AV_PIX_FMT_YUV422P16BE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:134
AV_PIX_FMT_P010BE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, big-endian
Definition: pixfmt.h:285
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)
Definition: input.c:277
AV_PIX_FMT_YUVA444P9LE
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:183
AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
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:149
AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
AV_PIX_FMT_YUVA420P10BE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:184
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)
Definition: input.c:586
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:348
AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
Definition: pixfmt.h:90
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)
Definition: input.c:578
AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:287
RGB2YUV_SHIFT
#define RGB2YUV_SHIFT
b
#define b
Definition: input.c:41
AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:290
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
rgb12le
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb12le
Definition: input.c:387
AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
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)
Definition: input.c:833
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)
Definition: input.c:464
width
#define width
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)
Definition: input.c:168
p016LEToUV_c
static void p016LEToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2, int width, uint32_t *unused)
Definition: input.c:722
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)
Definition: input.c:780
int32_t
int32_t
Definition: audio_convert.c:194
RY_IDX
#define RY_IDX
Definition: swscale_internal.h:406
AV_PIX_FMT_YUVA444P10BE
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:188
AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:210
planar_rgb16_to_y
static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4], int width, int bpc, int is_be, int32_t *rgb2yuv)
Definition: input.c:893
AV_PIX_FMT_YUVA422P9BE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:180
AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_YUV420P12LE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:243
AV_PIX_FMT_YUV420P10BE
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:158
rgb48funcs
#define rgb48funcs(pattern, BE_LE, origin)
Definition: input.c:197
AV_PIX_FMT_P010LE
like NV12, with 10bpp per component, data in the high bits, zeros in the low bits, little-endian
Definition: pixfmt.h:284
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, uint32_t *unused)
Definition: input.c:945
swscale_internal.h
bswap16Y_c
static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
Definition: input.c:555
AV_PIX_FMT_YUV422P9LE
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:167
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:148
AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:110
AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:288
gbr24pToUV_half_c
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT static RGB2YUV_SHIFT 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)
Definition: input.c:395
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:362
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:660
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)
Definition: input.c:305
AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
src1
#define src1
Definition: h264pred.c:139
AV_PIX_FMT_YUV420P16BE
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:132
av_bswap32
#define av_bswap32
Definition: bswap.h:33
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)
Definition: input.c:565
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)
Definition: input.c:508
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)
Definition: input.c:59
rgb321
RGB2YUV_SHIFT rgb321
Definition: input.c:381
AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:172
AV_PIX_FMT_YUVA422P16BE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:192
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:360
AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
bgr15be
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT bgr15be
Definition: input.c:389
AV_PIX_FMT_YUV440P12LE
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:277
AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:257
AV_PIX_FMT_YUVA422P16LE
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:193
AV_PIX_FMT_YUVA444P16LE
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:195
AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
Definition: pixfmt.h:97
AV_PIX_FMT_NV42
as above, but U and V bytes are swapped
Definition: pixfmt.h:349
read_ayuv64le_UV_c
static void read_ayuv64le_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)
Definition: input.c:619
bswap.h
byte swapping routines
AV_PIX_FMT_YUV420P14BE
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:244
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:345
AV_PIX_FMT_GRAY9BE
Y , 9bpp, big-endian.
Definition: pixfmt.h:315
AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:256
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:178
AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:113
AV_PIX_FMT_GRAY14LE
Y , 14bpp, little-endian.
Definition: pixfmt.h:338
GY_IDX
#define GY_IDX
Definition: swscale_internal.h:407
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)
Definition: input.c:415
AV_PIX_FMT_YUVA422P10LE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:187
AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
AV_PIX_FMT_GRAY10BE
Y , 10bpp, big-endian.
Definition: pixfmt.h:297
AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:142
AV_PIX_FMT_YUV444P9LE
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:163
AV_PIX_FMT_YUV444P16LE
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:135
planar_rgb_to_y
static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
Definition: input.c:852
read_ayuv64le_A_c
static void read_ayuv64le_A_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused0, const uint8_t *unused1, int width, uint32_t *unused2)
Definition: input.c:629
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:76
AV_PIX_FMT_YUV422P12LE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:247
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:75
planar_rgb16_to_uv
static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src[4], int width, int bpc, int is_be, int32_t *rgb2yuv)
Definition: input.c:923
AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:171
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:102
rnd
#define rnd()
Definition: checkasm.h:105
AV_PIX_FMT_YUV422P16LE
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:133
AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
AV_PIX_FMT_YUVA420P10LE
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:185
rgb16be
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb16be
Definition: input.c:391
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)
Definition: input.c:799
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)
Definition: input.c:594
rdpx
#define rdpx(src)
Definition: input.c:891
AV_PIX_FMT_YUV444P14LE
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:253
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:361
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)
Definition: input.c:425
AV_PIX_FMT_GRAY14BE
Y , 14bpp, big-endian.
Definition: pixfmt.h:337
AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
rgb16_32_wrapper
#define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr,maskg, maskb, rsh, gsh, bsh, S)
Definition: input.c:349
AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:213
AV_PIX_FMT_YUVA422P10BE
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:186
AV_PIX_FMT_GRAY12BE
Y , 12bpp, big-endian.
Definition: pixfmt.h:295
p010BEToY_c
static void p010BEToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
Definition: input.c:691
AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:112
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)
Definition: input.c:475
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)
Definition: input.c:814
GU_IDX
#define GU_IDX
Definition: swscale_internal.h:410
AV_WN16
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
av_always_inline
#define av_always_inline
Definition: attributes.h:39
AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:175
AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:141
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)
Definition: input.c:44
AV_PIX_FMT_YUVA422P9LE
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:181
BY_IDX
#define BY_IDX
Definition: swscale_internal.h:408
nvXXtoUV_c
static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2, const uint8_t *src, int width)
Definition: input.c:658
AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:341
AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:217
rgb9plus_planar_transparency_funcs
#define rgb9plus_planar_transparency_funcs(nbits)
Definition: input.c:981
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AV_PIX_FMT_YUV420P12BE
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:242
rgb64funcs
#define rgb64funcs(pattern, BE_LE, origin)
Definition: input.c:96
BU_IDX
#define BU_IDX
Definition: swscale_internal.h:411
AV_PIX_FMT_YUV444P10BE
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:164
AV_PIX_FMT_YUV422P12BE
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:246
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:653
AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:173
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:206
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)
Definition: input.c:544
AV_PIX_FMT_AYUV64LE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:279
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)
Definition: input.c:435
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:343
AV_PIX_FMT_YUV422P10BE
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:160
Generated on Sun Sep 15 2019 19:21:39 for FFmpeg by   doxygen 1.8.11