FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 
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 
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] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
290  rv = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << 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 
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] * (1 << rsh), gu = rgb2yuv[GU_IDX] * (1 << gsh), bu = rgb2yuv[BU_IDX] * (1 << bsh),
318  rv = rgb2yuv[RV_IDX] * (1 << rsh), gv = rgb2yuv[GV_IDX] * (1 << gsh), bv = rgb2yuv[BV_IDX] * (1 << 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 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
683 
684 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
685  int width, uint32_t *rgb2yuv)
686 {
687  int16_t *dst = (int16_t *)_dst;
688  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
689  int i;
690  for (i = 0; i < width; i++) {
691  int b = src[i * 3 + 0];
692  int g = src[i * 3 + 1];
693  int r = src[i * 3 + 2];
694 
695  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
696  }
697 }
698 
699 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
700  const uint8_t *src2, int width, uint32_t *rgb2yuv)
701 {
702  int16_t *dstU = (int16_t *)_dstU;
703  int16_t *dstV = (int16_t *)_dstV;
704  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
705  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
706  int i;
707  for (i = 0; i < width; i++) {
708  int b = src1[3 * i + 0];
709  int g = src1[3 * i + 1];
710  int r = src1[3 * i + 2];
711 
712  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
713  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
714  }
715  av_assert1(src1 == src2);
716 }
717 
718 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
719  const uint8_t *src2, int width, uint32_t *rgb2yuv)
720 {
721  int16_t *dstU = (int16_t *)_dstU;
722  int16_t *dstV = (int16_t *)_dstV;
723  int i;
724  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
725  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
726  for (i = 0; i < width; i++) {
727  int b = src1[6 * i + 0] + src1[6 * i + 3];
728  int g = src1[6 * i + 1] + src1[6 * i + 4];
729  int r = src1[6 * i + 2] + src1[6 * i + 5];
730 
731  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
732  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
733  }
734  av_assert1(src1 == src2);
735 }
736 
737 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
738  uint32_t *rgb2yuv)
739 {
740  int16_t *dst = (int16_t *)_dst;
741  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
742  int i;
743  for (i = 0; i < width; i++) {
744  int r = src[i * 3 + 0];
745  int g = src[i * 3 + 1];
746  int b = src[i * 3 + 2];
747 
748  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
749  }
750 }
751 
752 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
753  const uint8_t *src2, int width, uint32_t *rgb2yuv)
754 {
755  int16_t *dstU = (int16_t *)_dstU;
756  int16_t *dstV = (int16_t *)_dstV;
757  int i;
758  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
759  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
760  av_assert1(src1 == src2);
761  for (i = 0; i < width; i++) {
762  int r = src1[3 * i + 0];
763  int g = src1[3 * i + 1];
764  int b = src1[3 * i + 2];
765 
766  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
767  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
768  }
769 }
770 
771 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
772  const uint8_t *src2, int width, uint32_t *rgb2yuv)
773 {
774  int16_t *dstU = (int16_t *)_dstU;
775  int16_t *dstV = (int16_t *)_dstV;
776  int i;
777  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
778  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
779  av_assert1(src1 == src2);
780  for (i = 0; i < width; i++) {
781  int r = src1[6 * i + 0] + src1[6 * i + 3];
782  int g = src1[6 * i + 1] + src1[6 * i + 4];
783  int b = src1[6 * i + 2] + src1[6 * i + 5];
784 
785  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
786  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
787  }
788 }
789 
790 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
791 {
792  uint16_t *dst = (uint16_t *)_dst;
793  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
794  int i;
795  for (i = 0; i < width; i++) {
796  int g = src[0][i];
797  int b = src[1][i];
798  int r = src[2][i];
799 
800  dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
801  }
802 }
803 
804 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
805 {
806  uint16_t *dst = (uint16_t *)_dst;
807  int i;
808  for (i = 0; i < width; i++)
809  dst[i] = src[3][i] << 6;
810 }
811 
812 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
813 {
814  uint16_t *dstU = (uint16_t *)_dstU;
815  uint16_t *dstV = (uint16_t *)_dstV;
816  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
817  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
818  int i;
819  for (i = 0; i < width; i++) {
820  int g = src[0][i];
821  int b = src[1][i];
822  int r = src[2][i];
823 
824  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
825  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
826  }
827 }
828 
829 #define rdpx(src) \
830  is_be ? AV_RB16(src) : AV_RL16(src)
831 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
832  int width, int bpc, int is_be, int32_t *rgb2yuv)
833 {
834  int i;
835  const uint16_t **src = (const uint16_t **)_src;
836  uint16_t *dst = (uint16_t *)_dst;
837  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
838  int shift = bpc < 16 ? bpc : 14;
839  for (i = 0; i < width; i++) {
840  int g = rdpx(src[0] + i);
841  int b = rdpx(src[1] + i);
842  int r = rdpx(src[2] + i);
843 
844  dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
845  }
846 }
847 
848 static av_always_inline void planar_rgb16_to_a(uint8_t *_dst, const uint8_t *_src[4],
849  int width, int bpc, int is_be, int32_t *rgb2yuv)
850 {
851  int i;
852  const uint16_t **src = (const uint16_t **)_src;
853  uint16_t *dst = (uint16_t *)_dst;
854  int shift = bpc < 16 ? bpc : 14;
855 
856  for (i = 0; i < width; i++) {
857  dst[i] = rdpx(src[3] + i) << (14 - shift);
858  }
859 }
860 
862  const uint8_t *_src[4], int width,
863  int bpc, int is_be, int32_t *rgb2yuv)
864 {
865  int i;
866  const uint16_t **src = (const uint16_t **)_src;
867  uint16_t *dstU = (uint16_t *)_dstU;
868  uint16_t *dstV = (uint16_t *)_dstV;
869  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
870  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
871  int shift = bpc < 16 ? bpc : 14;
872  for (i = 0; i < width; i++) {
873  int g = rdpx(src[0] + i);
874  int b = rdpx(src[1] + i);
875  int r = rdpx(src[2] + i);
876 
877  dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
878  dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
879  }
880 }
881 #undef rdpx
882 
883 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian) \
884 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
885  int w, int32_t *rgb2yuv) \
886 { \
887  planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv); \
888 } \
889 static void planar_rgb##nbits##endian_name##_to_a(uint8_t *dst, const uint8_t *src[4], \
890  int w, int32_t *rgb2yuv) \
891 { \
892  planar_rgb16_to_a(dst, src, w, nbits, endian, rgb2yuv); \
893 } \
894 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
895  const uint8_t *src[4], int w, int32_t *rgb2yuv) \
896 { \
897  planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
898 } \
899 
900 #define rgb9plus_planar_funcs(nbits) \
901  rgb9plus_planar_funcs_endian(nbits, le, 0) \
902  rgb9plus_planar_funcs_endian(nbits, be, 1)
903 
909 
911 {
912  enum AVPixelFormat srcFormat = c->srcFormat;
913 
914  c->chrToYV12 = NULL;
915  switch (srcFormat) {
916  case AV_PIX_FMT_YUYV422:
917  c->chrToYV12 = yuy2ToUV_c;
918  break;
919  case AV_PIX_FMT_YVYU422:
920  c->chrToYV12 = yvy2ToUV_c;
921  break;
922  case AV_PIX_FMT_UYVY422:
923  c->chrToYV12 = uyvyToUV_c;
924  break;
925  case AV_PIX_FMT_NV12:
926  c->chrToYV12 = nv12ToUV_c;
927  break;
928  case AV_PIX_FMT_NV21:
929  c->chrToYV12 = nv21ToUV_c;
930  break;
931  case AV_PIX_FMT_RGB8:
932  case AV_PIX_FMT_BGR8:
933  case AV_PIX_FMT_PAL8:
936  c->chrToYV12 = palToUV_c;
937  break;
938  case AV_PIX_FMT_GBRP9LE:
939  c->readChrPlanar = planar_rgb9le_to_uv;
940  break;
941  case AV_PIX_FMT_GBRP10LE:
942  c->readChrPlanar = planar_rgb10le_to_uv;
943  break;
944  case AV_PIX_FMT_GBRP12LE:
945  c->readChrPlanar = planar_rgb12le_to_uv;
946  break;
947  case AV_PIX_FMT_GBRP14LE:
948  c->readChrPlanar = planar_rgb14le_to_uv;
949  break;
951  case AV_PIX_FMT_GBRP16LE:
952  c->readChrPlanar = planar_rgb16le_to_uv;
953  break;
954  case AV_PIX_FMT_GBRP9BE:
955  c->readChrPlanar = planar_rgb9be_to_uv;
956  break;
957  case AV_PIX_FMT_GBRP10BE:
958  c->readChrPlanar = planar_rgb10be_to_uv;
959  break;
960  case AV_PIX_FMT_GBRP12BE:
961  c->readChrPlanar = planar_rgb12be_to_uv;
962  break;
963  case AV_PIX_FMT_GBRP14BE:
964  c->readChrPlanar = planar_rgb14be_to_uv;
965  break;
967  case AV_PIX_FMT_GBRP16BE:
968  c->readChrPlanar = planar_rgb16be_to_uv;
969  break;
970  case AV_PIX_FMT_GBRAP:
971  case AV_PIX_FMT_GBRP:
972  c->readChrPlanar = planar_rgb_to_uv;
973  break;
974 #if HAVE_BIGENDIAN
992 
1002  c->chrToYV12 = bswap16UV_c;
1003  break;
1004 #else
1005  case AV_PIX_FMT_YUV444P9BE:
1006  case AV_PIX_FMT_YUV422P9BE:
1007  case AV_PIX_FMT_YUV420P9BE:
1022 
1032  c->chrToYV12 = bswap16UV_c;
1033  break;
1034 #endif
1035  case AV_PIX_FMT_AYUV64LE:
1036  c->chrToYV12 = read_ayuv64le_UV_c;
1037  break;
1038  }
1039  if (c->chrSrcHSubSample) {
1040  switch (srcFormat) {
1041  case AV_PIX_FMT_RGBA64BE:
1042  c->chrToYV12 = rgb64BEToUV_half_c;
1043  break;
1044  case AV_PIX_FMT_RGBA64LE:
1045  c->chrToYV12 = rgb64LEToUV_half_c;
1046  break;
1047  case AV_PIX_FMT_BGRA64BE:
1048  c->chrToYV12 = bgr64BEToUV_half_c;
1049  break;
1050  case AV_PIX_FMT_BGRA64LE:
1051  c->chrToYV12 = bgr64LEToUV_half_c;
1052  break;
1053  case AV_PIX_FMT_RGB48BE:
1054  c->chrToYV12 = rgb48BEToUV_half_c;
1055  break;
1056  case AV_PIX_FMT_RGB48LE:
1057  c->chrToYV12 = rgb48LEToUV_half_c;
1058  break;
1059  case AV_PIX_FMT_BGR48BE:
1060  c->chrToYV12 = bgr48BEToUV_half_c;
1061  break;
1062  case AV_PIX_FMT_BGR48LE:
1063  c->chrToYV12 = bgr48LEToUV_half_c;
1064  break;
1065  case AV_PIX_FMT_RGB32:
1066  c->chrToYV12 = bgr32ToUV_half_c;
1067  break;
1068  case AV_PIX_FMT_RGB32_1:
1069  c->chrToYV12 = bgr321ToUV_half_c;
1070  break;
1071  case AV_PIX_FMT_BGR24:
1072  c->chrToYV12 = bgr24ToUV_half_c;
1073  break;
1074  case AV_PIX_FMT_BGR565LE:
1075  c->chrToYV12 = bgr16leToUV_half_c;
1076  break;
1077  case AV_PIX_FMT_BGR565BE:
1078  c->chrToYV12 = bgr16beToUV_half_c;
1079  break;
1080  case AV_PIX_FMT_BGR555LE:
1081  c->chrToYV12 = bgr15leToUV_half_c;
1082  break;
1083  case AV_PIX_FMT_BGR555BE:
1084  c->chrToYV12 = bgr15beToUV_half_c;
1085  break;
1086  case AV_PIX_FMT_GBRAP:
1087  case AV_PIX_FMT_GBRP:
1088  c->chrToYV12 = gbr24pToUV_half_c;
1089  break;
1090  case AV_PIX_FMT_BGR444LE:
1091  c->chrToYV12 = bgr12leToUV_half_c;
1092  break;
1093  case AV_PIX_FMT_BGR444BE:
1094  c->chrToYV12 = bgr12beToUV_half_c;
1095  break;
1096  case AV_PIX_FMT_BGR32:
1097  c->chrToYV12 = rgb32ToUV_half_c;
1098  break;
1099  case AV_PIX_FMT_BGR32_1:
1100  c->chrToYV12 = rgb321ToUV_half_c;
1101  break;
1102  case AV_PIX_FMT_RGB24:
1103  c->chrToYV12 = rgb24ToUV_half_c;
1104  break;
1105  case AV_PIX_FMT_RGB565LE:
1106  c->chrToYV12 = rgb16leToUV_half_c;
1107  break;
1108  case AV_PIX_FMT_RGB565BE:
1109  c->chrToYV12 = rgb16beToUV_half_c;
1110  break;
1111  case AV_PIX_FMT_RGB555LE:
1112  c->chrToYV12 = rgb15leToUV_half_c;
1113  break;
1114  case AV_PIX_FMT_RGB555BE:
1115  c->chrToYV12 = rgb15beToUV_half_c;
1116  break;
1117  case AV_PIX_FMT_RGB444LE:
1118  c->chrToYV12 = rgb12leToUV_half_c;
1119  break;
1120  case AV_PIX_FMT_RGB444BE:
1121  c->chrToYV12 = rgb12beToUV_half_c;
1122  break;
1123  }
1124  } else {
1125  switch (srcFormat) {
1126  case AV_PIX_FMT_RGBA64BE:
1127  c->chrToYV12 = rgb64BEToUV_c;
1128  break;
1129  case AV_PIX_FMT_RGBA64LE:
1130  c->chrToYV12 = rgb64LEToUV_c;
1131  break;
1132  case AV_PIX_FMT_BGRA64BE:
1133  c->chrToYV12 = bgr64BEToUV_c;
1134  break;
1135  case AV_PIX_FMT_BGRA64LE:
1136  c->chrToYV12 = bgr64LEToUV_c;
1137  break;
1138  case AV_PIX_FMT_RGB48BE:
1139  c->chrToYV12 = rgb48BEToUV_c;
1140  break;
1141  case AV_PIX_FMT_RGB48LE:
1142  c->chrToYV12 = rgb48LEToUV_c;
1143  break;
1144  case AV_PIX_FMT_BGR48BE:
1145  c->chrToYV12 = bgr48BEToUV_c;
1146  break;
1147  case AV_PIX_FMT_BGR48LE:
1148  c->chrToYV12 = bgr48LEToUV_c;
1149  break;
1150  case AV_PIX_FMT_RGB32:
1151  c->chrToYV12 = bgr32ToUV_c;
1152  break;
1153  case AV_PIX_FMT_RGB32_1:
1154  c->chrToYV12 = bgr321ToUV_c;
1155  break;
1156  case AV_PIX_FMT_BGR24:
1157  c->chrToYV12 = bgr24ToUV_c;
1158  break;
1159  case AV_PIX_FMT_BGR565LE:
1160  c->chrToYV12 = bgr16leToUV_c;
1161  break;
1162  case AV_PIX_FMT_BGR565BE:
1163  c->chrToYV12 = bgr16beToUV_c;
1164  break;
1165  case AV_PIX_FMT_BGR555LE:
1166  c->chrToYV12 = bgr15leToUV_c;
1167  break;
1168  case AV_PIX_FMT_BGR555BE:
1169  c->chrToYV12 = bgr15beToUV_c;
1170  break;
1171  case AV_PIX_FMT_BGR444LE:
1172  c->chrToYV12 = bgr12leToUV_c;
1173  break;
1174  case AV_PIX_FMT_BGR444BE:
1175  c->chrToYV12 = bgr12beToUV_c;
1176  break;
1177  case AV_PIX_FMT_BGR32:
1178  c->chrToYV12 = rgb32ToUV_c;
1179  break;
1180  case AV_PIX_FMT_BGR32_1:
1181  c->chrToYV12 = rgb321ToUV_c;
1182  break;
1183  case AV_PIX_FMT_RGB24:
1184  c->chrToYV12 = rgb24ToUV_c;
1185  break;
1186  case AV_PIX_FMT_RGB565LE:
1187  c->chrToYV12 = rgb16leToUV_c;
1188  break;
1189  case AV_PIX_FMT_RGB565BE:
1190  c->chrToYV12 = rgb16beToUV_c;
1191  break;
1192  case AV_PIX_FMT_RGB555LE:
1193  c->chrToYV12 = rgb15leToUV_c;
1194  break;
1195  case AV_PIX_FMT_RGB555BE:
1196  c->chrToYV12 = rgb15beToUV_c;
1197  break;
1198  case AV_PIX_FMT_RGB444LE:
1199  c->chrToYV12 = rgb12leToUV_c;
1200  break;
1201  case AV_PIX_FMT_RGB444BE:
1202  c->chrToYV12 = rgb12beToUV_c;
1203  break;
1204  }
1205  }
1206 
1207  c->lumToYV12 = NULL;
1208  c->alpToYV12 = NULL;
1209  switch (srcFormat) {
1210  case AV_PIX_FMT_GBRP9LE:
1211  c->readLumPlanar = planar_rgb9le_to_y;
1212  break;
1213  case AV_PIX_FMT_GBRP10LE:
1214  c->readLumPlanar = planar_rgb10le_to_y;
1215  break;
1216  case AV_PIX_FMT_GBRP12LE:
1217  c->readLumPlanar = planar_rgb12le_to_y;
1218  break;
1219  case AV_PIX_FMT_GBRP14LE:
1220  c->readLumPlanar = planar_rgb14le_to_y;
1221  break;
1222  case AV_PIX_FMT_GBRAP16LE:
1223  c->readAlpPlanar = planar_rgb16le_to_a;
1224  case AV_PIX_FMT_GBRP16LE:
1225  c->readLumPlanar = planar_rgb16le_to_y;
1226  break;
1227  case AV_PIX_FMT_GBRP9BE:
1228  c->readLumPlanar = planar_rgb9be_to_y;
1229  break;
1230  case AV_PIX_FMT_GBRP10BE:
1231  c->readLumPlanar = planar_rgb10be_to_y;
1232  break;
1233  case AV_PIX_FMT_GBRP12BE:
1234  c->readLumPlanar = planar_rgb12be_to_y;
1235  break;
1236  case AV_PIX_FMT_GBRP14BE:
1237  c->readLumPlanar = planar_rgb14be_to_y;
1238  break;
1239  case AV_PIX_FMT_GBRAP16BE:
1240  c->readAlpPlanar = planar_rgb16be_to_a;
1241  case AV_PIX_FMT_GBRP16BE:
1242  c->readLumPlanar = planar_rgb16be_to_y;
1243  break;
1244  case AV_PIX_FMT_GBRAP:
1245  c->readAlpPlanar = planar_rgb_to_a;
1246  case AV_PIX_FMT_GBRP:
1247  c->readLumPlanar = planar_rgb_to_y;
1248  break;
1249 #if HAVE_BIGENDIAN
1250  case AV_PIX_FMT_YUV444P9LE:
1251  case AV_PIX_FMT_YUV422P9LE:
1252  case AV_PIX_FMT_YUV420P9LE:
1267 
1268  case AV_PIX_FMT_GRAY16LE:
1269  c->lumToYV12 = bswap16Y_c;
1270  break;
1280  c->lumToYV12 = bswap16Y_c;
1281  c->alpToYV12 = bswap16Y_c;
1282  break;
1283 #else
1284  case AV_PIX_FMT_YUV444P9BE:
1285  case AV_PIX_FMT_YUV422P9BE:
1286  case AV_PIX_FMT_YUV420P9BE:
1301 
1302  case AV_PIX_FMT_GRAY16BE:
1303  c->lumToYV12 = bswap16Y_c;
1304  break;
1314  c->lumToYV12 = bswap16Y_c;
1315  c->alpToYV12 = bswap16Y_c;
1316  break;
1317 #endif
1318  case AV_PIX_FMT_YA16LE:
1319  c->lumToYV12 = read_ya16le_gray_c;
1320  break;
1321  case AV_PIX_FMT_YA16BE:
1322  c->lumToYV12 = read_ya16be_gray_c;
1323  break;
1324  case AV_PIX_FMT_AYUV64LE:
1325  c->lumToYV12 = read_ayuv64le_Y_c;
1326  break;
1327  case AV_PIX_FMT_YUYV422:
1328  case AV_PIX_FMT_YVYU422:
1329  case AV_PIX_FMT_YA8:
1330  c->lumToYV12 = yuy2ToY_c;
1331  break;
1332  case AV_PIX_FMT_UYVY422:
1333  c->lumToYV12 = uyvyToY_c;
1334  break;
1335  case AV_PIX_FMT_BGR24:
1336  c->lumToYV12 = bgr24ToY_c;
1337  break;
1338  case AV_PIX_FMT_BGR565LE:
1339  c->lumToYV12 = bgr16leToY_c;
1340  break;
1341  case AV_PIX_FMT_BGR565BE:
1342  c->lumToYV12 = bgr16beToY_c;
1343  break;
1344  case AV_PIX_FMT_BGR555LE:
1345  c->lumToYV12 = bgr15leToY_c;
1346  break;
1347  case AV_PIX_FMT_BGR555BE:
1348  c->lumToYV12 = bgr15beToY_c;
1349  break;
1350  case AV_PIX_FMT_BGR444LE:
1351  c->lumToYV12 = bgr12leToY_c;
1352  break;
1353  case AV_PIX_FMT_BGR444BE:
1354  c->lumToYV12 = bgr12beToY_c;
1355  break;
1356  case AV_PIX_FMT_RGB24:
1357  c->lumToYV12 = rgb24ToY_c;
1358  break;
1359  case AV_PIX_FMT_RGB565LE:
1360  c->lumToYV12 = rgb16leToY_c;
1361  break;
1362  case AV_PIX_FMT_RGB565BE:
1363  c->lumToYV12 = rgb16beToY_c;
1364  break;
1365  case AV_PIX_FMT_RGB555LE:
1366  c->lumToYV12 = rgb15leToY_c;
1367  break;
1368  case AV_PIX_FMT_RGB555BE:
1369  c->lumToYV12 = rgb15beToY_c;
1370  break;
1371  case AV_PIX_FMT_RGB444LE:
1372  c->lumToYV12 = rgb12leToY_c;
1373  break;
1374  case AV_PIX_FMT_RGB444BE:
1375  c->lumToYV12 = rgb12beToY_c;
1376  break;
1377  case AV_PIX_FMT_RGB8:
1378  case AV_PIX_FMT_BGR8:
1379  case AV_PIX_FMT_PAL8:
1380  case AV_PIX_FMT_BGR4_BYTE:
1381  case AV_PIX_FMT_RGB4_BYTE:
1382  c->lumToYV12 = palToY_c;
1383  break;
1384  case AV_PIX_FMT_MONOBLACK:
1385  c->lumToYV12 = monoblack2Y_c;
1386  break;
1387  case AV_PIX_FMT_MONOWHITE:
1388  c->lumToYV12 = monowhite2Y_c;
1389  break;
1390  case AV_PIX_FMT_RGB32:
1391  c->lumToYV12 = bgr32ToY_c;
1392  break;
1393  case AV_PIX_FMT_RGB32_1:
1394  c->lumToYV12 = bgr321ToY_c;
1395  break;
1396  case AV_PIX_FMT_BGR32:
1397  c->lumToYV12 = rgb32ToY_c;
1398  break;
1399  case AV_PIX_FMT_BGR32_1:
1400  c->lumToYV12 = rgb321ToY_c;
1401  break;
1402  case AV_PIX_FMT_RGB48BE:
1403  c->lumToYV12 = rgb48BEToY_c;
1404  break;
1405  case AV_PIX_FMT_RGB48LE:
1406  c->lumToYV12 = rgb48LEToY_c;
1407  break;
1408  case AV_PIX_FMT_BGR48BE:
1409  c->lumToYV12 = bgr48BEToY_c;
1410  break;
1411  case AV_PIX_FMT_BGR48LE:
1412  c->lumToYV12 = bgr48LEToY_c;
1413  break;
1414  case AV_PIX_FMT_RGBA64BE:
1415  c->lumToYV12 = rgb64BEToY_c;
1416  break;
1417  case AV_PIX_FMT_RGBA64LE:
1418  c->lumToYV12 = rgb64LEToY_c;
1419  break;
1420  case AV_PIX_FMT_BGRA64BE:
1421  c->lumToYV12 = bgr64BEToY_c;
1422  break;
1423  case AV_PIX_FMT_BGRA64LE:
1424  c->lumToYV12 = bgr64LEToY_c;
1425  }
1426  if (c->alpPixBuf) {
1427  if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1428  if (HAVE_BIGENDIAN == !isBE(srcFormat))
1429  c->alpToYV12 = bswap16Y_c;
1430  }
1431  switch (srcFormat) {
1432  case AV_PIX_FMT_BGRA64LE:
1433  case AV_PIX_FMT_RGBA64LE: c->alpToYV12 = rgba64leToA_c; break;
1434  case AV_PIX_FMT_BGRA64BE:
1435  case AV_PIX_FMT_RGBA64BE: c->alpToYV12 = rgba64beToA_c; break;
1436  case AV_PIX_FMT_BGRA:
1437  case AV_PIX_FMT_RGBA:
1438  c->alpToYV12 = rgbaToA_c;
1439  break;
1440  case AV_PIX_FMT_ABGR:
1441  case AV_PIX_FMT_ARGB:
1442  c->alpToYV12 = abgrToA_c;
1443  break;
1444  case AV_PIX_FMT_YA8:
1445  c->alpToYV12 = uyvyToY_c;
1446  break;
1447  case AV_PIX_FMT_YA16LE:
1448  c->alpToYV12 = read_ya16le_alpha_c;
1449  break;
1450  case AV_PIX_FMT_YA16BE:
1451  c->alpToYV12 = read_ya16be_alpha_c;
1452  break;
1453  case AV_PIX_FMT_AYUV64LE:
1454  c->alpToYV12 = read_ayuv64le_A_c;
1455  break;
1456  case AV_PIX_FMT_PAL8 :
1457  c->alpToYV12 = palToA_c;
1458  break;
1459  }
1460  }
1461 }
static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
Definition: input.c:804
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:87
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
#define NULL
Definition: coverity.c:32
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:182
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:323
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:297
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:684
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
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
static int shift(int a, int b)
Definition: sonic.c:82
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:290
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
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
#define RV_IDX
RGB2YUV_SHIFT RGB2YUV_SHIFT bgr15le
Definition: input.c:383
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:294
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:175
#define BV_IDX
8bit gray, 8bit alpha
Definition: pixfmt.h:159
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:278
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:69
#define rgb9plus_planar_funcs(nbits)
Definition: input.c:900
const char * g
Definition: vf_curves.c:108
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:178
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:295
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:192
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:121
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:277
#define GV_IDX
#define av_bswap16
Definition: bswap.h:31
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:219
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
external API header
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:812
#define AV_RL16
Definition: intreadwrite.h:42
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:124
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
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
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:300
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
Definition: pixfmt.h:172
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:156
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
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:299
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:144
#define r_b
void ff_sws_init_input_funcs(SwsContext *c)
#define b_r
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
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:119
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:91
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb12be
Definition: input.c:393
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian ...
Definition: pixfmt.h:209
#define RU_IDX
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:304
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:220
uint8_t
#define av_cold
Definition: attributes.h:74
8 bit with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:78
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:116
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:699
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb16le
Definition: input.c:385
#define b
Definition: input.c:41
bgr321
Definition: input.c:379
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:275
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:155
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:296
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:118
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:100
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:221
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:324
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:197
#define input_pixel(pos)
Definition: input.c:682
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:224
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
external API header
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
Definition: pixfmt.h:326
#define r
Definition: input.c:40
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
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:173
#define U(x)
Definition: vp56_arith.h:37
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:193
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:181
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:364
16bit gray, 16bit alpha (big-endian)
Definition: pixfmt.h:250
#define S(s, c, i)
#define AV_RB16
Definition: intreadwrite.h:53
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:149
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:101
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:212
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:177
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:95
simple assert() macros that are a bit more flexible than ISO C assert().
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:293
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:848
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
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
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:147
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
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:213
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:98
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:165
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:99
#define isNBPS(x)
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
Definition: pixfmt.h:214
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
as above, but U and V bytes are swapped
Definition: pixfmt.h:96
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
#define RGB2YUV_SHIFT
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb12le
Definition: input.c:387
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:94
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:771
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
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
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:718
int32_t
#define RY_IDX
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
Definition: pixfmt.h:218
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:246
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:831
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
Definition: pixfmt.h:210
float u
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:70
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
Definition: pixfmt.h:288
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:174
#define rgb48funcs(pattern, BE_LE, origin)
Definition: input.c:197
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
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:183
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:164
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:123
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
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:363
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
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
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:89
#define src1
Definition: h264pred.c:139
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:145
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
AVS_Value src
Definition: avisynth_c.h:482
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
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
RGB2YUV_SHIFT rgb321
Definition: input.c:381
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:195
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:222
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:361
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:68
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT bgr15be
Definition: input.c:389
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
Definition: pixfmt.h:325
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:302
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:223
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
Definition: pixfmt.h:225
Y , 16bpp, big-endian.
Definition: pixfmt.h:103
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
byte swapping routines
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:289
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:301
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
Definition: pixfmt.h:208
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:126
#define GY_IDX
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
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
Definition: pixfmt.h:217
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:120
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:158
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:179
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:148
static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
Definition: input.c:790
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
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:77
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:292
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:76
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:861
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:303
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:194
static double c[64]
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:115
#define rnd()
Definition: checkasm.h:43
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
Definition: pixfmt.h:146
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:92
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
Definition: pixfmt.h:215
RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT RGB2YUV_SHIFT rgb16be
Definition: input.c:391
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:737
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
#define rdpx(src)
Definition: input.c:829
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
Definition: pixfmt.h:298
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:362
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
Y , 16bpp, little-endian.
Definition: pixfmt.h:104
#define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr,maskg, maskb, rsh, gsh, bsh, S)
Definition: input.c:349
16bit gray, 16bit alpha (little-endian)
Definition: pixfmt.h:251
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
Definition: pixfmt.h:216
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:125
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
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:752
#define GU_IDX
#define AV_WN16(p, v)
Definition: intreadwrite.h:372
#define av_always_inline
Definition: attributes.h:37
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:198
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:157
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
#define HAVE_BIGENDIAN
Definition: config.h:186
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
Definition: pixfmt.h:211
#define BY_IDX
static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2, const uint8_t *src, int width)
Definition: input.c:658
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:305
AVPixelFormat
Pixel format.
Definition: pixfmt.h:65
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
Definition: pixfmt.h:287
#define rgb64funcs(pattern, BE_LE, origin)
Definition: input.c:96
static av_always_inline uint32_t rgb2yuv(const uint32_t *r2y, uint32_t c)
Definition: vf_hqx.c:58
#define BU_IDX
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
Definition: pixfmt.h:180
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:291
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:196
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:276
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
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:327
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
static int width
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
Definition: pixfmt.h:176