FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups 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 
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 rgba64ToA_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] = src[4 * i + 3];
423 }
424 
425 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
426 {
427  int16_t *dst = (int16_t *)_dst;
428  int i;
429  for (i=0; i<width; i++) {
430  dst[i]= src[4*i]<<6;
431  }
432 }
433 
434 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
435 {
436  int16_t *dst = (int16_t *)_dst;
437  int i;
438  for (i=0; i<width; i++) {
439  dst[i]= src[4*i+3]<<6;
440  }
441 }
442 
443 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
444 {
445  int16_t *dst = (int16_t *)_dst;
446  int i;
447  for (i=0; i<width; i++) {
448  int d= src[i];
449 
450  dst[i]= (pal[d] >> 24)<<6;
451  }
452 }
453 
454 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
455 {
456  int16_t *dst = (int16_t *)_dst;
457  int i;
458  for (i = 0; i < width; i++) {
459  int d = src[i];
460 
461  dst[i] = (pal[d] & 0xFF)<<6;
462  }
463 }
464 
465 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
466  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
467  int width, uint32_t *pal)
468 {
469  uint16_t *dstU = (uint16_t *)_dstU;
470  int16_t *dstV = (int16_t *)_dstV;
471  int i;
472  av_assert1(src1 == src2);
473  for (i = 0; i < width; i++) {
474  int p = pal[src1[i]];
475 
476  dstU[i] = (uint8_t)(p>> 8)<<6;
477  dstV[i] = (uint8_t)(p>>16)<<6;
478  }
479 }
480 
481 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
482 {
483  int16_t *dst = (int16_t *)_dst;
484  int i, j;
485  width = (width + 7) >> 3;
486  for (i = 0; i < width; i++) {
487  int d = ~src[i];
488  for (j = 0; j < 8; j++)
489  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
490  }
491  if(width&7){
492  int d= ~src[i];
493  for (j = 0; j < (width&7); j++)
494  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
495  }
496 }
497 
498 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
499 {
500  int16_t *dst = (int16_t *)_dst;
501  int i, j;
502  width = (width + 7) >> 3;
503  for (i = 0; i < width; i++) {
504  int d = src[i];
505  for (j = 0; j < 8; j++)
506  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
507  }
508  if(width&7){
509  int d = src[i];
510  for (j = 0; j < (width&7); j++)
511  dst[8*i+j] = ((d>>(7-j))&1) * 16383;
512  }
513 }
514 
515 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
516  uint32_t *unused)
517 {
518  int i;
519  for (i = 0; i < width; i++)
520  dst[i] = src[2 * i];
521 }
522 
523 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
524  const uint8_t *src2, int width, uint32_t *unused)
525 {
526  int i;
527  for (i = 0; i < width; i++) {
528  dstU[i] = src1[4 * i + 1];
529  dstV[i] = src1[4 * i + 3];
530  }
531  av_assert1(src1 == src2);
532 }
533 
534 static void yvy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
535  const uint8_t *src2, int width, uint32_t *unused)
536 {
537  int i;
538  for (i = 0; i < width; i++) {
539  dstV[i] = src1[4 * i + 1];
540  dstU[i] = src1[4 * i + 3];
541  }
542  av_assert1(src1 == src2);
543 }
544 
545 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
546  uint32_t *unused)
547 {
548  int i;
549  const uint16_t *src = (const uint16_t *)_src;
550  uint16_t *dst = (uint16_t *)_dst;
551  for (i = 0; i < width; i++)
552  dst[i] = av_bswap16(src[i]);
553 }
554 
555 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
556  const uint8_t *_src2, int width, uint32_t *unused)
557 {
558  int i;
559  const uint16_t *src1 = (const uint16_t *)_src1,
560  *src2 = (const uint16_t *)_src2;
561  uint16_t *dstU = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
562  for (i = 0; i < width; i++) {
563  dstU[i] = av_bswap16(src1[i]);
564  dstV[i] = av_bswap16(src2[i]);
565  }
566 }
567 
568 /* This is almost identical to the previous, end exists only because
569  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
570 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
571  uint32_t *unused)
572 {
573  int i;
574  for (i = 0; i < width; i++)
575  dst[i] = src[2 * i + 1];
576 }
577 
578 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
579  const uint8_t *src2, int width, uint32_t *unused)
580 {
581  int i;
582  for (i = 0; i < width; i++) {
583  dstU[i] = src1[4 * i + 0];
584  dstV[i] = src1[4 * i + 2];
585  }
586  av_assert1(src1 == src2);
587 }
588 
589 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
590  const uint8_t *src, int width)
591 {
592  int i;
593  for (i = 0; i < width; i++) {
594  dst1[i] = src[2 * i + 0];
595  dst2[i] = src[2 * i + 1];
596  }
597 }
598 
599 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
600  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
601  int width, uint32_t *unused)
602 {
603  nvXXtoUV_c(dstU, dstV, src1, width);
604 }
605 
606 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
607  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
608  int width, uint32_t *unused)
609 {
610  nvXXtoUV_c(dstV, dstU, src1, width);
611 }
612 
613 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
614 
615 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
616  int width, uint32_t *rgb2yuv)
617 {
618  int16_t *dst = (int16_t *)_dst;
619  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
620  int i;
621  for (i = 0; i < width; i++) {
622  int b = src[i * 3 + 0];
623  int g = src[i * 3 + 1];
624  int r = src[i * 3 + 2];
625 
626  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
627  }
628 }
629 
630 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
631  const uint8_t *src2, int width, uint32_t *rgb2yuv)
632 {
633  int16_t *dstU = (int16_t *)_dstU;
634  int16_t *dstV = (int16_t *)_dstV;
635  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
636  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
637  int i;
638  for (i = 0; i < width; i++) {
639  int b = src1[3 * i + 0];
640  int g = src1[3 * i + 1];
641  int r = src1[3 * i + 2];
642 
643  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
644  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
645  }
646  av_assert1(src1 == src2);
647 }
648 
649 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
650  const uint8_t *src2, int width, uint32_t *rgb2yuv)
651 {
652  int16_t *dstU = (int16_t *)_dstU;
653  int16_t *dstV = (int16_t *)_dstV;
654  int i;
655  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
656  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
657  for (i = 0; i < width; i++) {
658  int b = src1[6 * i + 0] + src1[6 * i + 3];
659  int g = src1[6 * i + 1] + src1[6 * i + 4];
660  int r = src1[6 * i + 2] + src1[6 * i + 5];
661 
662  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
663  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
664  }
665  av_assert1(src1 == src2);
666 }
667 
668 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
669  uint32_t *rgb2yuv)
670 {
671  int16_t *dst = (int16_t *)_dst;
672  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
673  int i;
674  for (i = 0; i < width; i++) {
675  int r = src[i * 3 + 0];
676  int g = src[i * 3 + 1];
677  int b = src[i * 3 + 2];
678 
679  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
680  }
681 }
682 
683 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
684  const uint8_t *src2, int width, uint32_t *rgb2yuv)
685 {
686  int16_t *dstU = (int16_t *)_dstU;
687  int16_t *dstV = (int16_t *)_dstV;
688  int i;
689  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
690  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
691  av_assert1(src1 == src2);
692  for (i = 0; i < width; i++) {
693  int r = src1[3 * i + 0];
694  int g = src1[3 * i + 1];
695  int b = src1[3 * i + 2];
696 
697  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
698  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
699  }
700 }
701 
702 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
703  const uint8_t *src2, int width, uint32_t *rgb2yuv)
704 {
705  int16_t *dstU = (int16_t *)_dstU;
706  int16_t *dstV = (int16_t *)_dstV;
707  int i;
708  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
709  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
710  av_assert1(src1 == src2);
711  for (i = 0; i < width; i++) {
712  int r = src1[6 * i + 0] + src1[6 * i + 3];
713  int g = src1[6 * i + 1] + src1[6 * i + 4];
714  int b = src1[6 * i + 2] + src1[6 * i + 5];
715 
716  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
717  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
718  }
719 }
720 
721 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
722 {
723  uint16_t *dst = (uint16_t *)_dst;
724  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
725  int i;
726  for (i = 0; i < width; i++) {
727  int g = src[0][i];
728  int b = src[1][i];
729  int r = src[2][i];
730 
731  dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
732  }
733 }
734 
735 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
736 {
737  uint16_t *dst = (uint16_t *)_dst;
738  int i;
739  for (i = 0; i < width; i++)
740  dst[i] = src[3][i] << 6;
741 }
742 
743 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
744 {
745  uint16_t *dstU = (uint16_t *)_dstU;
746  uint16_t *dstV = (uint16_t *)_dstV;
747  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
748  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
749  int i;
750  for (i = 0; i < width; i++) {
751  int g = src[0][i];
752  int b = src[1][i];
753  int r = src[2][i];
754 
755  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
756  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
757  }
758 }
759 
760 #define rdpx(src) \
761  is_be ? AV_RB16(src) : AV_RL16(src)
762 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
763  int width, int bpc, int is_be, int32_t *rgb2yuv)
764 {
765  int i;
766  const uint16_t **src = (const uint16_t **)_src;
767  uint16_t *dst = (uint16_t *)_dst;
768  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
769  int shift = bpc < 16 ? bpc : 14;
770  for (i = 0; i < width; i++) {
771  int g = rdpx(src[0] + i);
772  int b = rdpx(src[1] + i);
773  int r = rdpx(src[2] + i);
774 
775  dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
776  }
777 }
778 
779 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
780  const uint8_t *_src[4], int width,
781  int bpc, int is_be, int32_t *rgb2yuv)
782 {
783  int i;
784  const uint16_t **src = (const uint16_t **)_src;
785  uint16_t *dstU = (uint16_t *)_dstU;
786  uint16_t *dstV = (uint16_t *)_dstV;
787  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
788  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
789  int shift = bpc < 16 ? bpc : 14;
790  for (i = 0; i < width; i++) {
791  int g = rdpx(src[0] + i);
792  int b = rdpx(src[1] + i);
793  int r = rdpx(src[2] + i);
794 
795  dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
796  dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
797  }
798 }
799 #undef rdpx
800 
801 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian) \
802 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
803  int w, int32_t *rgb2yuv) \
804 { \
805  planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv); \
806 } \
807 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
808  const uint8_t *src[4], int w, int32_t *rgb2yuv) \
809 { \
810  planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
811 } \
812 
813 #define rgb9plus_planar_funcs(nbits) \
814  rgb9plus_planar_funcs_endian(nbits, le, 0) \
815  rgb9plus_planar_funcs_endian(nbits, be, 1)
816 
817 rgb9plus_planar_funcs(9)
818 rgb9plus_planar_funcs(10)
819 rgb9plus_planar_funcs(12)
820 rgb9plus_planar_funcs(14)
821 rgb9plus_planar_funcs(16)
822 
823 av_cold void ff_sws_init_input_funcs(SwsContext *c)
824 {
825  enum AVPixelFormat srcFormat = c->srcFormat;
826 
827  c->chrToYV12 = NULL;
828  switch (srcFormat) {
829  case AV_PIX_FMT_YUYV422:
830  c->chrToYV12 = yuy2ToUV_c;
831  break;
832  case AV_PIX_FMT_YVYU422:
833  c->chrToYV12 = yvy2ToUV_c;
834  break;
835  case AV_PIX_FMT_UYVY422:
836  c->chrToYV12 = uyvyToUV_c;
837  break;
838  case AV_PIX_FMT_NV12:
839  c->chrToYV12 = nv12ToUV_c;
840  break;
841  case AV_PIX_FMT_NV21:
842  c->chrToYV12 = nv21ToUV_c;
843  break;
844  case AV_PIX_FMT_RGB8:
845  case AV_PIX_FMT_BGR8:
846  case AV_PIX_FMT_PAL8:
847  case AV_PIX_FMT_BGR4_BYTE:
848  case AV_PIX_FMT_RGB4_BYTE:
849  c->chrToYV12 = palToUV_c;
850  break;
851  case AV_PIX_FMT_GBRP9LE:
852  c->readChrPlanar = planar_rgb9le_to_uv;
853  break;
854  case AV_PIX_FMT_GBRP10LE:
855  c->readChrPlanar = planar_rgb10le_to_uv;
856  break;
857  case AV_PIX_FMT_GBRP12LE:
858  c->readChrPlanar = planar_rgb12le_to_uv;
859  break;
860  case AV_PIX_FMT_GBRP14LE:
861  c->readChrPlanar = planar_rgb14le_to_uv;
862  break;
863  case AV_PIX_FMT_GBRAP16LE:
864  case AV_PIX_FMT_GBRP16LE:
865  c->readChrPlanar = planar_rgb16le_to_uv;
866  break;
867  case AV_PIX_FMT_GBRP9BE:
868  c->readChrPlanar = planar_rgb9be_to_uv;
869  break;
870  case AV_PIX_FMT_GBRP10BE:
871  c->readChrPlanar = planar_rgb10be_to_uv;
872  break;
873  case AV_PIX_FMT_GBRP12BE:
874  c->readChrPlanar = planar_rgb12be_to_uv;
875  break;
876  case AV_PIX_FMT_GBRP14BE:
877  c->readChrPlanar = planar_rgb14be_to_uv;
878  break;
879  case AV_PIX_FMT_GBRAP16BE:
880  case AV_PIX_FMT_GBRP16BE:
881  c->readChrPlanar = planar_rgb16be_to_uv;
882  break;
883  case AV_PIX_FMT_GBRAP:
884  case AV_PIX_FMT_GBRP:
885  c->readChrPlanar = planar_rgb_to_uv;
886  break;
887 #if HAVE_BIGENDIAN
888  case AV_PIX_FMT_YUV444P9LE:
889  case AV_PIX_FMT_YUV422P9LE:
890  case AV_PIX_FMT_YUV420P9LE:
891  case AV_PIX_FMT_YUV422P10LE:
892  case AV_PIX_FMT_YUV444P10LE:
893  case AV_PIX_FMT_YUV420P10LE:
894  case AV_PIX_FMT_YUV422P12LE:
895  case AV_PIX_FMT_YUV444P12LE:
896  case AV_PIX_FMT_YUV420P12LE:
897  case AV_PIX_FMT_YUV422P14LE:
898  case AV_PIX_FMT_YUV444P14LE:
899  case AV_PIX_FMT_YUV420P14LE:
900  case AV_PIX_FMT_YUV420P16LE:
901  case AV_PIX_FMT_YUV422P16LE:
902  case AV_PIX_FMT_YUV444P16LE:
903 
904  case AV_PIX_FMT_YUVA444P9LE:
905  case AV_PIX_FMT_YUVA422P9LE:
906  case AV_PIX_FMT_YUVA420P9LE:
907  case AV_PIX_FMT_YUVA444P10LE:
908  case AV_PIX_FMT_YUVA422P10LE:
909  case AV_PIX_FMT_YUVA420P10LE:
910  case AV_PIX_FMT_YUVA420P16LE:
911  case AV_PIX_FMT_YUVA422P16LE:
912  case AV_PIX_FMT_YUVA444P16LE:
913  c->chrToYV12 = bswap16UV_c;
914  break;
915 #else
916  case AV_PIX_FMT_YUV444P9BE:
917  case AV_PIX_FMT_YUV422P9BE:
918  case AV_PIX_FMT_YUV420P9BE:
919  case AV_PIX_FMT_YUV444P10BE:
920  case AV_PIX_FMT_YUV422P10BE:
921  case AV_PIX_FMT_YUV420P10BE:
922  case AV_PIX_FMT_YUV444P12BE:
923  case AV_PIX_FMT_YUV422P12BE:
924  case AV_PIX_FMT_YUV420P12BE:
925  case AV_PIX_FMT_YUV444P14BE:
926  case AV_PIX_FMT_YUV422P14BE:
927  case AV_PIX_FMT_YUV420P14BE:
928  case AV_PIX_FMT_YUV420P16BE:
929  case AV_PIX_FMT_YUV422P16BE:
930  case AV_PIX_FMT_YUV444P16BE:
931 
932  case AV_PIX_FMT_YUVA444P9BE:
933  case AV_PIX_FMT_YUVA422P9BE:
934  case AV_PIX_FMT_YUVA420P9BE:
935  case AV_PIX_FMT_YUVA444P10BE:
936  case AV_PIX_FMT_YUVA422P10BE:
937  case AV_PIX_FMT_YUVA420P10BE:
938  case AV_PIX_FMT_YUVA420P16BE:
939  case AV_PIX_FMT_YUVA422P16BE:
940  case AV_PIX_FMT_YUVA444P16BE:
941  c->chrToYV12 = bswap16UV_c;
942  break;
943 #endif
944  }
945  if (c->chrSrcHSubSample) {
946  switch (srcFormat) {
947  case AV_PIX_FMT_RGBA64BE:
948  c->chrToYV12 = rgb64BEToUV_half_c;
949  break;
950  case AV_PIX_FMT_RGBA64LE:
951  c->chrToYV12 = rgb64LEToUV_half_c;
952  break;
953  case AV_PIX_FMT_BGRA64BE:
954  c->chrToYV12 = bgr64BEToUV_half_c;
955  break;
956  case AV_PIX_FMT_BGRA64LE:
957  c->chrToYV12 = bgr64LEToUV_half_c;
958  break;
959  case AV_PIX_FMT_RGB48BE:
960  c->chrToYV12 = rgb48BEToUV_half_c;
961  break;
962  case AV_PIX_FMT_RGB48LE:
963  c->chrToYV12 = rgb48LEToUV_half_c;
964  break;
965  case AV_PIX_FMT_BGR48BE:
966  c->chrToYV12 = bgr48BEToUV_half_c;
967  break;
968  case AV_PIX_FMT_BGR48LE:
969  c->chrToYV12 = bgr48LEToUV_half_c;
970  break;
971  case AV_PIX_FMT_RGB32:
972  c->chrToYV12 = bgr32ToUV_half_c;
973  break;
974  case AV_PIX_FMT_RGB32_1:
975  c->chrToYV12 = bgr321ToUV_half_c;
976  break;
977  case AV_PIX_FMT_BGR24:
978  c->chrToYV12 = bgr24ToUV_half_c;
979  break;
980  case AV_PIX_FMT_BGR565LE:
981  c->chrToYV12 = bgr16leToUV_half_c;
982  break;
983  case AV_PIX_FMT_BGR565BE:
984  c->chrToYV12 = bgr16beToUV_half_c;
985  break;
986  case AV_PIX_FMT_BGR555LE:
987  c->chrToYV12 = bgr15leToUV_half_c;
988  break;
989  case AV_PIX_FMT_BGR555BE:
990  c->chrToYV12 = bgr15beToUV_half_c;
991  break;
992  case AV_PIX_FMT_GBRAP:
993  case AV_PIX_FMT_GBRP:
994  c->chrToYV12 = gbr24pToUV_half_c;
995  break;
996  case AV_PIX_FMT_BGR444LE:
997  c->chrToYV12 = bgr12leToUV_half_c;
998  break;
999  case AV_PIX_FMT_BGR444BE:
1000  c->chrToYV12 = bgr12beToUV_half_c;
1001  break;
1002  case AV_PIX_FMT_BGR32:
1003  c->chrToYV12 = rgb32ToUV_half_c;
1004  break;
1005  case AV_PIX_FMT_BGR32_1:
1006  c->chrToYV12 = rgb321ToUV_half_c;
1007  break;
1008  case AV_PIX_FMT_RGB24:
1009  c->chrToYV12 = rgb24ToUV_half_c;
1010  break;
1011  case AV_PIX_FMT_RGB565LE:
1012  c->chrToYV12 = rgb16leToUV_half_c;
1013  break;
1014  case AV_PIX_FMT_RGB565BE:
1015  c->chrToYV12 = rgb16beToUV_half_c;
1016  break;
1017  case AV_PIX_FMT_RGB555LE:
1018  c->chrToYV12 = rgb15leToUV_half_c;
1019  break;
1020  case AV_PIX_FMT_RGB555BE:
1021  c->chrToYV12 = rgb15beToUV_half_c;
1022  break;
1023  case AV_PIX_FMT_RGB444LE:
1024  c->chrToYV12 = rgb12leToUV_half_c;
1025  break;
1026  case AV_PIX_FMT_RGB444BE:
1027  c->chrToYV12 = rgb12beToUV_half_c;
1028  break;
1029  }
1030  } else {
1031  switch (srcFormat) {
1032  case AV_PIX_FMT_RGBA64BE:
1033  c->chrToYV12 = rgb64BEToUV_c;
1034  break;
1035  case AV_PIX_FMT_RGBA64LE:
1036  c->chrToYV12 = rgb64LEToUV_c;
1037  break;
1038  case AV_PIX_FMT_BGRA64BE:
1039  c->chrToYV12 = bgr64BEToUV_c;
1040  break;
1041  case AV_PIX_FMT_BGRA64LE:
1042  c->chrToYV12 = bgr64LEToUV_c;
1043  break;
1044  case AV_PIX_FMT_RGB48BE:
1045  c->chrToYV12 = rgb48BEToUV_c;
1046  break;
1047  case AV_PIX_FMT_RGB48LE:
1048  c->chrToYV12 = rgb48LEToUV_c;
1049  break;
1050  case AV_PIX_FMT_BGR48BE:
1051  c->chrToYV12 = bgr48BEToUV_c;
1052  break;
1053  case AV_PIX_FMT_BGR48LE:
1054  c->chrToYV12 = bgr48LEToUV_c;
1055  break;
1056  case AV_PIX_FMT_RGB32:
1057  c->chrToYV12 = bgr32ToUV_c;
1058  break;
1059  case AV_PIX_FMT_RGB32_1:
1060  c->chrToYV12 = bgr321ToUV_c;
1061  break;
1062  case AV_PIX_FMT_BGR24:
1063  c->chrToYV12 = bgr24ToUV_c;
1064  break;
1065  case AV_PIX_FMT_BGR565LE:
1066  c->chrToYV12 = bgr16leToUV_c;
1067  break;
1068  case AV_PIX_FMT_BGR565BE:
1069  c->chrToYV12 = bgr16beToUV_c;
1070  break;
1071  case AV_PIX_FMT_BGR555LE:
1072  c->chrToYV12 = bgr15leToUV_c;
1073  break;
1074  case AV_PIX_FMT_BGR555BE:
1075  c->chrToYV12 = bgr15beToUV_c;
1076  break;
1077  case AV_PIX_FMT_BGR444LE:
1078  c->chrToYV12 = bgr12leToUV_c;
1079  break;
1080  case AV_PIX_FMT_BGR444BE:
1081  c->chrToYV12 = bgr12beToUV_c;
1082  break;
1083  case AV_PIX_FMT_BGR32:
1084  c->chrToYV12 = rgb32ToUV_c;
1085  break;
1086  case AV_PIX_FMT_BGR32_1:
1087  c->chrToYV12 = rgb321ToUV_c;
1088  break;
1089  case AV_PIX_FMT_RGB24:
1090  c->chrToYV12 = rgb24ToUV_c;
1091  break;
1092  case AV_PIX_FMT_RGB565LE:
1093  c->chrToYV12 = rgb16leToUV_c;
1094  break;
1095  case AV_PIX_FMT_RGB565BE:
1096  c->chrToYV12 = rgb16beToUV_c;
1097  break;
1098  case AV_PIX_FMT_RGB555LE:
1099  c->chrToYV12 = rgb15leToUV_c;
1100  break;
1101  case AV_PIX_FMT_RGB555BE:
1102  c->chrToYV12 = rgb15beToUV_c;
1103  break;
1104  case AV_PIX_FMT_RGB444LE:
1105  c->chrToYV12 = rgb12leToUV_c;
1106  break;
1107  case AV_PIX_FMT_RGB444BE:
1108  c->chrToYV12 = rgb12beToUV_c;
1109  break;
1110  }
1111  }
1112 
1113  c->lumToYV12 = NULL;
1114  c->alpToYV12 = NULL;
1115  switch (srcFormat) {
1116  case AV_PIX_FMT_GBRP9LE:
1117  c->readLumPlanar = planar_rgb9le_to_y;
1118  break;
1119  case AV_PIX_FMT_GBRP10LE:
1120  c->readLumPlanar = planar_rgb10le_to_y;
1121  break;
1122  case AV_PIX_FMT_GBRP12LE:
1123  c->readLumPlanar = planar_rgb12le_to_y;
1124  break;
1125  case AV_PIX_FMT_GBRP14LE:
1126  c->readLumPlanar = planar_rgb14le_to_y;
1127  break;
1128  case AV_PIX_FMT_GBRAP16LE:
1129  case AV_PIX_FMT_GBRP16LE:
1130  c->readLumPlanar = planar_rgb16le_to_y;
1131  break;
1132  case AV_PIX_FMT_GBRP9BE:
1133  c->readLumPlanar = planar_rgb9be_to_y;
1134  break;
1135  case AV_PIX_FMT_GBRP10BE:
1136  c->readLumPlanar = planar_rgb10be_to_y;
1137  break;
1138  case AV_PIX_FMT_GBRP12BE:
1139  c->readLumPlanar = planar_rgb12be_to_y;
1140  break;
1141  case AV_PIX_FMT_GBRP14BE:
1142  c->readLumPlanar = planar_rgb14be_to_y;
1143  break;
1144  case AV_PIX_FMT_GBRAP16BE:
1145  case AV_PIX_FMT_GBRP16BE:
1146  c->readLumPlanar = planar_rgb16be_to_y;
1147  break;
1148  case AV_PIX_FMT_GBRAP:
1149  c->readAlpPlanar = planar_rgb_to_a;
1150  case AV_PIX_FMT_GBRP:
1151  c->readLumPlanar = planar_rgb_to_y;
1152  break;
1153 #if HAVE_BIGENDIAN
1154  case AV_PIX_FMT_YUV444P9LE:
1155  case AV_PIX_FMT_YUV422P9LE:
1156  case AV_PIX_FMT_YUV420P9LE:
1157  case AV_PIX_FMT_YUV444P10LE:
1158  case AV_PIX_FMT_YUV422P10LE:
1159  case AV_PIX_FMT_YUV420P10LE:
1160  case AV_PIX_FMT_YUV444P12LE:
1161  case AV_PIX_FMT_YUV422P12LE:
1162  case AV_PIX_FMT_YUV420P12LE:
1163  case AV_PIX_FMT_YUV444P14LE:
1164  case AV_PIX_FMT_YUV422P14LE:
1165  case AV_PIX_FMT_YUV420P14LE:
1166  case AV_PIX_FMT_YUV420P16LE:
1167  case AV_PIX_FMT_YUV422P16LE:
1168  case AV_PIX_FMT_YUV444P16LE:
1169 
1170  case AV_PIX_FMT_GRAY16LE:
1171  c->lumToYV12 = bswap16Y_c;
1172  break;
1173  case AV_PIX_FMT_YUVA444P9LE:
1174  case AV_PIX_FMT_YUVA422P9LE:
1175  case AV_PIX_FMT_YUVA420P9LE:
1176  case AV_PIX_FMT_YUVA444P10LE:
1177  case AV_PIX_FMT_YUVA422P10LE:
1178  case AV_PIX_FMT_YUVA420P10LE:
1179  case AV_PIX_FMT_YUVA420P16LE:
1180  case AV_PIX_FMT_YUVA422P16LE:
1181  case AV_PIX_FMT_YUVA444P16LE:
1182  c->lumToYV12 = bswap16Y_c;
1183  c->alpToYV12 = bswap16Y_c;
1184  break;
1185 #else
1186  case AV_PIX_FMT_YUV444P9BE:
1187  case AV_PIX_FMT_YUV422P9BE:
1188  case AV_PIX_FMT_YUV420P9BE:
1189  case AV_PIX_FMT_YUV444P10BE:
1190  case AV_PIX_FMT_YUV422P10BE:
1191  case AV_PIX_FMT_YUV420P10BE:
1192  case AV_PIX_FMT_YUV444P12BE:
1193  case AV_PIX_FMT_YUV422P12BE:
1194  case AV_PIX_FMT_YUV420P12BE:
1195  case AV_PIX_FMT_YUV444P14BE:
1196  case AV_PIX_FMT_YUV422P14BE:
1197  case AV_PIX_FMT_YUV420P14BE:
1198  case AV_PIX_FMT_YUV420P16BE:
1199  case AV_PIX_FMT_YUV422P16BE:
1200  case AV_PIX_FMT_YUV444P16BE:
1201 
1202  case AV_PIX_FMT_GRAY16BE:
1203  c->lumToYV12 = bswap16Y_c;
1204  break;
1205  case AV_PIX_FMT_YUVA444P9BE:
1206  case AV_PIX_FMT_YUVA422P9BE:
1207  case AV_PIX_FMT_YUVA420P9BE:
1208  case AV_PIX_FMT_YUVA444P10BE:
1209  case AV_PIX_FMT_YUVA422P10BE:
1210  case AV_PIX_FMT_YUVA420P10BE:
1211  case AV_PIX_FMT_YUVA420P16BE:
1212  case AV_PIX_FMT_YUVA422P16BE:
1213  case AV_PIX_FMT_YUVA444P16BE:
1214  c->lumToYV12 = bswap16Y_c;
1215  c->alpToYV12 = bswap16Y_c;
1216  break;
1217 #endif
1218  case AV_PIX_FMT_YUYV422:
1219  case AV_PIX_FMT_YVYU422:
1220  case AV_PIX_FMT_Y400A:
1221  c->lumToYV12 = yuy2ToY_c;
1222  break;
1223  case AV_PIX_FMT_UYVY422:
1224  c->lumToYV12 = uyvyToY_c;
1225  break;
1226  case AV_PIX_FMT_BGR24:
1227  c->lumToYV12 = bgr24ToY_c;
1228  break;
1229  case AV_PIX_FMT_BGR565LE:
1230  c->lumToYV12 = bgr16leToY_c;
1231  break;
1232  case AV_PIX_FMT_BGR565BE:
1233  c->lumToYV12 = bgr16beToY_c;
1234  break;
1235  case AV_PIX_FMT_BGR555LE:
1236  c->lumToYV12 = bgr15leToY_c;
1237  break;
1238  case AV_PIX_FMT_BGR555BE:
1239  c->lumToYV12 = bgr15beToY_c;
1240  break;
1241  case AV_PIX_FMT_BGR444LE:
1242  c->lumToYV12 = bgr12leToY_c;
1243  break;
1244  case AV_PIX_FMT_BGR444BE:
1245  c->lumToYV12 = bgr12beToY_c;
1246  break;
1247  case AV_PIX_FMT_RGB24:
1248  c->lumToYV12 = rgb24ToY_c;
1249  break;
1250  case AV_PIX_FMT_RGB565LE:
1251  c->lumToYV12 = rgb16leToY_c;
1252  break;
1253  case AV_PIX_FMT_RGB565BE:
1254  c->lumToYV12 = rgb16beToY_c;
1255  break;
1256  case AV_PIX_FMT_RGB555LE:
1257  c->lumToYV12 = rgb15leToY_c;
1258  break;
1259  case AV_PIX_FMT_RGB555BE:
1260  c->lumToYV12 = rgb15beToY_c;
1261  break;
1262  case AV_PIX_FMT_RGB444LE:
1263  c->lumToYV12 = rgb12leToY_c;
1264  break;
1265  case AV_PIX_FMT_RGB444BE:
1266  c->lumToYV12 = rgb12beToY_c;
1267  break;
1268  case AV_PIX_FMT_RGB8:
1269  case AV_PIX_FMT_BGR8:
1270  case AV_PIX_FMT_PAL8:
1271  case AV_PIX_FMT_BGR4_BYTE:
1272  case AV_PIX_FMT_RGB4_BYTE:
1273  c->lumToYV12 = palToY_c;
1274  break;
1275  case AV_PIX_FMT_MONOBLACK:
1276  c->lumToYV12 = monoblack2Y_c;
1277  break;
1278  case AV_PIX_FMT_MONOWHITE:
1279  c->lumToYV12 = monowhite2Y_c;
1280  break;
1281  case AV_PIX_FMT_RGB32:
1282  c->lumToYV12 = bgr32ToY_c;
1283  break;
1284  case AV_PIX_FMT_RGB32_1:
1285  c->lumToYV12 = bgr321ToY_c;
1286  break;
1287  case AV_PIX_FMT_BGR32:
1288  c->lumToYV12 = rgb32ToY_c;
1289  break;
1290  case AV_PIX_FMT_BGR32_1:
1291  c->lumToYV12 = rgb321ToY_c;
1292  break;
1293  case AV_PIX_FMT_RGB48BE:
1294  c->lumToYV12 = rgb48BEToY_c;
1295  break;
1296  case AV_PIX_FMT_RGB48LE:
1297  c->lumToYV12 = rgb48LEToY_c;
1298  break;
1299  case AV_PIX_FMT_BGR48BE:
1300  c->lumToYV12 = bgr48BEToY_c;
1301  break;
1302  case AV_PIX_FMT_BGR48LE:
1303  c->lumToYV12 = bgr48LEToY_c;
1304  break;
1305  case AV_PIX_FMT_RGBA64BE:
1306  c->lumToYV12 = rgb64BEToY_c;
1307  break;
1308  case AV_PIX_FMT_RGBA64LE:
1309  c->lumToYV12 = rgb64LEToY_c;
1310  break;
1311  case AV_PIX_FMT_BGRA64BE:
1312  c->lumToYV12 = bgr64BEToY_c;
1313  break;
1314  case AV_PIX_FMT_BGRA64LE:
1315  c->lumToYV12 = bgr64LEToY_c;
1316  }
1317  if (c->alpPixBuf) {
1318  if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1319  if (HAVE_BIGENDIAN == !isBE(srcFormat))
1320  c->alpToYV12 = bswap16Y_c;
1321  }
1322  switch (srcFormat) {
1323  case AV_PIX_FMT_BGRA64LE:
1324  case AV_PIX_FMT_BGRA64BE:
1325  case AV_PIX_FMT_RGBA64LE:
1326  case AV_PIX_FMT_RGBA64BE: c->alpToYV12 = rgba64ToA_c; break;
1327  case AV_PIX_FMT_BGRA:
1328  case AV_PIX_FMT_RGBA:
1329  c->alpToYV12 = rgbaToA_c;
1330  break;
1331  case AV_PIX_FMT_ABGR:
1332  case AV_PIX_FMT_ARGB:
1333  c->alpToYV12 = abgrToA_c;
1334  break;
1335  case AV_PIX_FMT_Y400A:
1336  c->alpToYV12 = uyvyToY_c;
1337  break;
1338  case AV_PIX_FMT_PAL8 :
1339  c->alpToYV12 = palToA_c;
1340  break;
1341  }
1342  }
1343 }
Generated on Tue Jul 29 2014 19:21:26 for FFmpeg by   doxygen 1.8.2