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) ? b_r : r_b)
41 #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? 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 
128 static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
129  const uint16_t *src, int width,
130  enum AVPixelFormat origin,
131  int32_t *rgb2yuv)
132 {
133  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
134  int i;
135  for (i = 0; i < width; i++) {
136  unsigned int r_b = input_pixel(&src[i * 3 + 0]);
137  unsigned int g = input_pixel(&src[i * 3 + 1]);
138  unsigned int b_r = input_pixel(&src[i * 3 + 2]);
139 
140  dst[i] = (ry*r + gy*g + by*b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
141  }
142 }
143 
144 static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
145  uint16_t *dstV,
146  const uint16_t *src1,
147  const uint16_t *src2,
148  int width,
149  enum AVPixelFormat origin,
150  int32_t *rgb2yuv)
151 {
152  int i;
153  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
154  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
155  av_assert1(src1 == src2);
156  for (i = 0; i < width; i++) {
157  int r_b = input_pixel(&src1[i * 3 + 0]);
158  int g = input_pixel(&src1[i * 3 + 1]);
159  int b_r = input_pixel(&src1[i * 3 + 2]);
160 
161  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
162  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
163  }
164 }
165 
166 static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
167  uint16_t *dstV,
168  const uint16_t *src1,
169  const uint16_t *src2,
170  int width,
171  enum AVPixelFormat origin,
172  int32_t *rgb2yuv)
173 {
174  int i;
175  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
176  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
177  av_assert1(src1 == src2);
178  for (i = 0; i < width; i++) {
179  int r_b = (input_pixel(&src1[6 * i + 0]) +
180  input_pixel(&src1[6 * i + 3]) + 1) >> 1;
181  int g = (input_pixel(&src1[6 * i + 1]) +
182  input_pixel(&src1[6 * i + 4]) + 1) >> 1;
183  int b_r = (input_pixel(&src1[6 * i + 2]) +
184  input_pixel(&src1[6 * i + 5]) + 1) >> 1;
185 
186  dstU[i] = (ru*r + gu*g + bu*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
187  dstV[i] = (rv*r + gv*g + bv*b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
188  }
189 }
190 
191 #undef r
192 #undef b
193 #undef input_pixel
194 
195 #define rgb48funcs(pattern, BE_LE, origin) \
196 static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst, \
197  const uint8_t *_src, \
198  const uint8_t *unused0, const uint8_t *unused1,\
199  int width, \
200  uint32_t *rgb2yuv) \
201 { \
202  const uint16_t *src = (const uint16_t *)_src; \
203  uint16_t *dst = (uint16_t *)_dst; \
204  rgb48ToY_c_template(dst, src, width, origin, rgb2yuv); \
205 } \
206  \
207 static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, \
208  uint8_t *_dstV, \
209  const uint8_t *unused0, \
210  const uint8_t *_src1, \
211  const uint8_t *_src2, \
212  int width, \
213  uint32_t *rgb2yuv) \
214 { \
215  const uint16_t *src1 = (const uint16_t *)_src1, \
216  *src2 = (const uint16_t *)_src2; \
217  uint16_t *dstU = (uint16_t *)_dstU, \
218  *dstV = (uint16_t *)_dstV; \
219  rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
220 } \
221  \
222 static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, \
223  uint8_t *_dstV, \
224  const uint8_t *unused0, \
225  const uint8_t *_src1, \
226  const uint8_t *_src2, \
227  int width, \
228  uint32_t *rgb2yuv) \
229 { \
230  const uint16_t *src1 = (const uint16_t *)_src1, \
231  *src2 = (const uint16_t *)_src2; \
232  uint16_t *dstU = (uint16_t *)_dstU, \
233  *dstV = (uint16_t *)_dstV; \
234  rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin, rgb2yuv); \
235 }
236 
237 rgb48funcs(rgb, LE, AV_PIX_FMT_RGB48LE)
238 rgb48funcs(rgb, BE, AV_PIX_FMT_RGB48BE)
239 rgb48funcs(bgr, LE, AV_PIX_FMT_BGR48LE)
240 rgb48funcs(bgr, BE, AV_PIX_FMT_BGR48BE)
241 
242 #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA || \
243  origin == AV_PIX_FMT_BGRA || \
244  origin == AV_PIX_FMT_ARGB || \
245  origin == AV_PIX_FMT_ABGR) \
246  ? AV_RN32A(&src[(i) * 4]) \
247  : (isBE(origin) ? AV_RB16(&src[(i) * 2]) \
248  : AV_RL16(&src[(i) * 2])))
249 
250 static av_always_inline void rgb16_32ToY_c_template(int16_t *dst,
251  const uint8_t *src,
252  int width,
253  enum AVPixelFormat origin,
254  int shr, int shg,
255  int shb, int shp,
256  int maskr, int maskg,
257  int maskb, int rsh,
258  int gsh, int bsh, int S,
259  int32_t *rgb2yuv)
260 {
261  const int ry = rgb2yuv[RY_IDX]<<rsh, gy = rgb2yuv[GY_IDX]<<gsh, by = rgb2yuv[BY_IDX]<<bsh;
262  const unsigned rnd = (32<<((S)-1)) + (1<<(S-7));
263  int i;
264 
265  for (i = 0; i < width; i++) {
266  int px = input_pixel(i) >> shp;
267  int b = (px & maskb) >> shb;
268  int g = (px & maskg) >> shg;
269  int r = (px & maskr) >> shr;
270 
271  dst[i] = (ry * r + gy * g + by * b + rnd) >> ((S)-6);
272  }
273 }
274 
275 static av_always_inline void rgb16_32ToUV_c_template(int16_t *dstU,
276  int16_t *dstV,
277  const uint8_t *src,
278  int width,
279  enum AVPixelFormat origin,
280  int shr, int shg,
281  int shb, int shp,
282  int maskr, int maskg,
283  int maskb, int rsh,
284  int gsh, int bsh, int S,
285  int32_t *rgb2yuv)
286 {
287  const int ru = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
288  rv = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh;
289  const unsigned rnd = (256u<<((S)-1)) + (1<<(S-7));
290  int i;
291 
292  for (i = 0; i < width; i++) {
293  int px = input_pixel(i) >> shp;
294  int b = (px & maskb) >> shb;
295  int g = (px & maskg) >> shg;
296  int r = (px & maskr) >> shr;
297 
298  dstU[i] = (ru * r + gu * g + bu * b + rnd) >> ((S)-6);
299  dstV[i] = (rv * r + gv * g + bv * b + rnd) >> ((S)-6);
300  }
301 }
302 
303 static av_always_inline void rgb16_32ToUV_half_c_template(int16_t *dstU,
304  int16_t *dstV,
305  const uint8_t *src,
306  int width,
307  enum AVPixelFormat origin,
308  int shr, int shg,
309  int shb, int shp,
310  int maskr, int maskg,
311  int maskb, int rsh,
312  int gsh, int bsh, int S,
313  int32_t *rgb2yuv)
314 {
315  const int ru = rgb2yuv[RU_IDX] << rsh, gu = rgb2yuv[GU_IDX] << gsh, bu = rgb2yuv[BU_IDX] << bsh,
316  rv = rgb2yuv[RV_IDX] << rsh, gv = rgb2yuv[GV_IDX] << gsh, bv = rgb2yuv[BV_IDX] << bsh,
317  maskgx = ~(maskr | maskb);
318  const unsigned rnd = (256U<<(S)) + (1<<(S-6));
319  int i;
320 
321  maskr |= maskr << 1;
322  maskb |= maskb << 1;
323  maskg |= maskg << 1;
324  for (i = 0; i < width; i++) {
325  int px0 = input_pixel(2 * i + 0) >> shp;
326  int px1 = input_pixel(2 * i + 1) >> shp;
327  int b, r, g = (px0 & maskgx) + (px1 & maskgx);
328  int rb = px0 + px1 - g;
329 
330  b = (rb & maskb) >> shb;
331  if (shp ||
332  origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
333  origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
334  g >>= shg;
335  } else {
336  g = (g & maskg) >> shg;
337  }
338  r = (rb & maskr) >> shr;
339 
340  dstU[i] = (ru * r + gu * g + bu * b + (unsigned)rnd) >> ((S)-6+1);
341  dstV[i] = (rv * r + gv * g + bv * b + (unsigned)rnd) >> ((S)-6+1);
342  }
343 }
344 
345 #undef input_pixel
346 
347 #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr, \
348  maskg, maskb, rsh, gsh, bsh, S) \
349 static void name ## ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, \
350  int width, uint32_t *tab) \
351 { \
352  rgb16_32ToY_c_template((int16_t*)dst, src, width, fmt, shr, shg, shb, shp, \
353  maskr, maskg, maskb, rsh, gsh, bsh, S, tab); \
354 } \
355  \
356 static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
357  const uint8_t *unused0, const uint8_t *src, const uint8_t *dummy, \
358  int width, uint32_t *tab) \
359 { \
360  rgb16_32ToUV_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
361  shr, shg, shb, shp, \
362  maskr, maskg, maskb, rsh, gsh, bsh, S, tab);\
363 } \
364  \
365 static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \
366  const uint8_t *unused0, const uint8_t *src, \
367  const uint8_t *dummy, \
368  int width, uint32_t *tab) \
369 { \
370  rgb16_32ToUV_half_c_template((int16_t*)dstU, (int16_t*)dstV, src, width, fmt, \
371  shr, shg, shb, shp, \
372  maskr, maskg, maskb, \
373  rsh, gsh, bsh, S, tab); \
374 }
375 
376 rgb16_32_wrapper(AV_PIX_FMT_BGR32, bgr32, 16, 0, 0, 0, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
377 rgb16_32_wrapper(AV_PIX_FMT_BGR32_1, bgr321, 16, 0, 0, 8, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
378 rgb16_32_wrapper(AV_PIX_FMT_RGB32, rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
379 rgb16_32_wrapper(AV_PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
380 rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
381 rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
382 rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
383 rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
384 rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
385 rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
386 rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
387 rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
388 rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
389 rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
390 rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
391 rgb16_32_wrapper(AV_PIX_FMT_RGB444BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
392 
393 static void gbr24pToUV_half_c(uint8_t *_dstU, uint8_t *_dstV,
394  const uint8_t *gsrc, const uint8_t *bsrc, const uint8_t *rsrc,
395  int width, uint32_t *rgb2yuv)
396 {
397  uint16_t *dstU = (uint16_t *)_dstU;
398  uint16_t *dstV = (uint16_t *)_dstV;
399  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
400  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
401 
402  int i;
403  for (i = 0; i < width; i++) {
404  unsigned int g = gsrc[2*i] + gsrc[2*i+1];
405  unsigned int b = bsrc[2*i] + bsrc[2*i+1];
406  unsigned int r = rsrc[2*i] + rsrc[2*i+1];
407 
408  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
409  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-6))) >> (RGB2YUV_SHIFT-6+1);
410  }
411 }
412 
413 static void rgba64ToA_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1,
414  const uint8_t *unused2, int width, uint32_t *unused)
415 {
416  int16_t *dst = (int16_t *)_dst;
417  const uint16_t *src = (const uint16_t *)_src;
418  int i;
419  for (i = 0; i < width; i++)
420  dst[i] = src[4 * i + 3];
421 }
422 
423 static void abgrToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
424 {
425  int16_t *dst = (int16_t *)_dst;
426  int i;
427  for (i=0; i<width; i++) {
428  dst[i]= src[4*i]<<6;
429  }
430 }
431 
432 static void rgbaToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
433 {
434  int16_t *dst = (int16_t *)_dst;
435  int i;
436  for (i=0; i<width; i++) {
437  dst[i]= src[4*i+3]<<6;
438  }
439 }
440 
441 static void palToA_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
442 {
443  int16_t *dst = (int16_t *)_dst;
444  int i;
445  for (i=0; i<width; i++) {
446  int d= src[i];
447 
448  dst[i]= (pal[d] >> 24)<<6;
449  }
450 }
451 
452 static void palToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *pal)
453 {
454  int16_t *dst = (int16_t *)_dst;
455  int i;
456  for (i = 0; i < width; i++) {
457  int d = src[i];
458 
459  dst[i] = (pal[d] & 0xFF)<<6;
460  }
461 }
462 
463 static void palToUV_c(uint8_t *_dstU, uint8_t *_dstV,
464  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
465  int width, uint32_t *pal)
466 {
467  uint16_t *dstU = (uint16_t *)_dstU;
468  int16_t *dstV = (int16_t *)_dstV;
469  int i;
470  av_assert1(src1 == src2);
471  for (i = 0; i < width; i++) {
472  int p = pal[src1[i]];
473 
474  dstU[i] = (uint8_t)(p>> 8)<<6;
475  dstV[i] = (uint8_t)(p>>16)<<6;
476  }
477 }
478 
479 static void monowhite2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
480 {
481  int16_t *dst = (int16_t *)_dst;
482  int i, j;
483  width = (width + 7) >> 3;
484  for (i = 0; i < width; i++) {
485  int d = ~src[i];
486  for (j = 0; j < 8; j++)
487  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
488  }
489  if(width&7){
490  int d= ~src[i];
491  for (j = 0; j < (width&7); j++)
492  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
493  }
494 }
495 
496 static void monoblack2Y_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width, uint32_t *unused)
497 {
498  int16_t *dst = (int16_t *)_dst;
499  int i, j;
500  width = (width + 7) >> 3;
501  for (i = 0; i < width; i++) {
502  int d = src[i];
503  for (j = 0; j < 8; j++)
504  dst[8*i+j]= ((d>>(7-j))&1) * 16383;
505  }
506  if(width&7){
507  int d = src[i];
508  for (j = 0; j < (width&7); j++)
509  dst[8*i+j] = ((d>>(7-j))&1) * 16383;
510  }
511 }
512 
513 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
514  uint32_t *unused)
515 {
516  int i;
517  for (i = 0; i < width; i++)
518  dst[i] = src[2 * i];
519 }
520 
521 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *unused0, const uint8_t *src1,
522  const uint8_t *src2, int width, uint32_t *unused)
523 {
524  int i;
525  for (i = 0; i < width; i++) {
526  dstU[i] = src1[4 * i + 1];
527  dstV[i] = src1[4 * i + 3];
528  }
529  av_assert1(src1 == src2);
530 }
531 
532 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, const uint8_t *unused1, const uint8_t *unused2, int width,
533  uint32_t *unused)
534 {
535  int i;
536  const uint16_t *src = (const uint16_t *)_src;
537  uint16_t *dst = (uint16_t *)_dst;
538  for (i = 0; i < width; i++)
539  dst[i] = av_bswap16(src[i]);
540 }
541 
542 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *_src1,
543  const uint8_t *_src2, int width, uint32_t *unused)
544 {
545  int i;
546  const uint16_t *src1 = (const uint16_t *)_src1,
547  *src2 = (const uint16_t *)_src2;
548  uint16_t *dstU = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
549  for (i = 0; i < width; i++) {
550  dstU[i] = av_bswap16(src1[i]);
551  dstV[i] = av_bswap16(src2[i]);
552  }
553 }
554 
555 /* This is almost identical to the previous, end exists only because
556  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
557 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
558  uint32_t *unused)
559 {
560  int i;
561  for (i = 0; i < width; i++)
562  dst[i] = src[2 * i + 1];
563 }
564 
565 static void uyvyToUV_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  for (i = 0; i < width; i++) {
570  dstU[i] = src1[4 * i + 0];
571  dstV[i] = src1[4 * i + 2];
572  }
573  av_assert1(src1 == src2);
574 }
575 
576 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
577  const uint8_t *src, int width)
578 {
579  int i;
580  for (i = 0; i < width; i++) {
581  dst1[i] = src[2 * i + 0];
582  dst2[i] = src[2 * i + 1];
583  }
584 }
585 
586 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
587  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
588  int width, uint32_t *unused)
589 {
590  nvXXtoUV_c(dstU, dstV, src1, width);
591 }
592 
593 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
594  const uint8_t *unused0, const uint8_t *src1, const uint8_t *src2,
595  int width, uint32_t *unused)
596 {
597  nvXXtoUV_c(dstV, dstU, src1, width);
598 }
599 
600 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
601 
602 static void bgr24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2,
603  int width, uint32_t *rgb2yuv)
604 {
605  int16_t *dst = (int16_t *)_dst;
606  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
607  int i;
608  for (i = 0; i < width; i++) {
609  int b = src[i * 3 + 0];
610  int g = src[i * 3 + 1];
611  int r = src[i * 3 + 2];
612 
613  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
614  }
615 }
616 
617 static void bgr24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
618  const uint8_t *src2, int width, uint32_t *rgb2yuv)
619 {
620  int16_t *dstU = (int16_t *)_dstU;
621  int16_t *dstV = (int16_t *)_dstV;
622  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
623  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
624  int i;
625  for (i = 0; i < width; i++) {
626  int b = src1[3 * i + 0];
627  int g = src1[3 * i + 1];
628  int r = src1[3 * i + 2];
629 
630  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
631  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
632  }
633  av_assert1(src1 == src2);
634 }
635 
636 static void bgr24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
637  const uint8_t *src2, int width, uint32_t *rgb2yuv)
638 {
639  int16_t *dstU = (int16_t *)_dstU;
640  int16_t *dstV = (int16_t *)_dstV;
641  int i;
642  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
643  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
644  for (i = 0; i < width; i++) {
645  int b = src1[6 * i + 0] + src1[6 * i + 3];
646  int g = src1[6 * i + 1] + src1[6 * i + 4];
647  int r = src1[6 * i + 2] + src1[6 * i + 5];
648 
649  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
650  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
651  }
652  av_assert1(src1 == src2);
653 }
654 
655 static void rgb24ToY_c(uint8_t *_dst, const uint8_t *src, const uint8_t *unused1, const uint8_t *unused2, int width,
656  uint32_t *rgb2yuv)
657 {
658  int16_t *dst = (int16_t *)_dst;
659  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
660  int i;
661  for (i = 0; i < width; i++) {
662  int r = src[i * 3 + 0];
663  int g = src[i * 3 + 1];
664  int b = src[i * 3 + 2];
665 
666  dst[i] = ((ry*r + gy*g + by*b + (32<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6));
667  }
668 }
669 
670 static void rgb24ToUV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
671  const uint8_t *src2, int width, uint32_t *rgb2yuv)
672 {
673  int16_t *dstU = (int16_t *)_dstU;
674  int16_t *dstV = (int16_t *)_dstV;
675  int i;
676  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
677  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
678  av_assert1(src1 == src2);
679  for (i = 0; i < width; i++) {
680  int r = src1[3 * i + 0];
681  int g = src1[3 * i + 1];
682  int b = src1[3 * i + 2];
683 
684  dstU[i] = (ru*r + gu*g + bu*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
685  dstV[i] = (rv*r + gv*g + bv*b + (256<<(RGB2YUV_SHIFT-1)) + (1<<(RGB2YUV_SHIFT-7)))>>(RGB2YUV_SHIFT-6);
686  }
687 }
688 
689 static void rgb24ToUV_half_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *unused0, const uint8_t *src1,
690  const uint8_t *src2, int width, uint32_t *rgb2yuv)
691 {
692  int16_t *dstU = (int16_t *)_dstU;
693  int16_t *dstV = (int16_t *)_dstV;
694  int i;
695  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
696  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
697  av_assert1(src1 == src2);
698  for (i = 0; i < width; i++) {
699  int r = src1[6 * i + 0] + src1[6 * i + 3];
700  int g = src1[6 * i + 1] + src1[6 * i + 4];
701  int b = src1[6 * i + 2] + src1[6 * i + 5];
702 
703  dstU[i] = (ru*r + gu*g + bu*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
704  dstV[i] = (rv*r + gv*g + bv*b + (256<<RGB2YUV_SHIFT) + (1<<(RGB2YUV_SHIFT-6)))>>(RGB2YUV_SHIFT-5);
705  }
706 }
707 
708 static void planar_rgb_to_y(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *rgb2yuv)
709 {
710  uint16_t *dst = (uint16_t *)_dst;
711  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
712  int i;
713  for (i = 0; i < width; i++) {
714  int g = src[0][i];
715  int b = src[1][i];
716  int r = src[2][i];
717 
718  dst[i] = (ry*r + gy*g + by*b + (0x801<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
719  }
720 }
721 
722 static void planar_rgb_to_a(uint8_t *_dst, const uint8_t *src[4], int width, int32_t *unused)
723 {
724  uint16_t *dst = (uint16_t *)_dst;
725  int i;
726  for (i = 0; i < width; i++)
727  dst[i] = src[3][i] << 6;
728 }
729 
730 static void planar_rgb_to_uv(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4], int width, int32_t *rgb2yuv)
731 {
732  uint16_t *dstU = (uint16_t *)_dstU;
733  uint16_t *dstV = (uint16_t *)_dstV;
734  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
735  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
736  int i;
737  for (i = 0; i < width; i++) {
738  int g = src[0][i];
739  int b = src[1][i];
740  int r = src[2][i];
741 
742  dstU[i] = (ru*r + gu*g + bu*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
743  dstV[i] = (rv*r + gv*g + bv*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
744  }
745 }
746 
747 #define rdpx(src) \
748  is_be ? AV_RB16(src) : AV_RL16(src)
749 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
750  int width, int bpc, int is_be, int32_t *rgb2yuv)
751 {
752  int i;
753  const uint16_t **src = (const uint16_t **)_src;
754  uint16_t *dst = (uint16_t *)_dst;
755  int32_t ry = rgb2yuv[RY_IDX], gy = rgb2yuv[GY_IDX], by = rgb2yuv[BY_IDX];
756  int shift = bpc < 16 ? bpc : 14;
757  for (i = 0; i < width; i++) {
758  int g = rdpx(src[0] + i);
759  int b = rdpx(src[1] + i);
760  int r = rdpx(src[2] + i);
761 
762  dst[i] = ((ry*r + gy*g + by*b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14));
763  }
764 }
765 
766 static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
767  const uint8_t *_src[4], int width,
768  int bpc, int is_be, int32_t *rgb2yuv)
769 {
770  int i;
771  const uint16_t **src = (const uint16_t **)_src;
772  uint16_t *dstU = (uint16_t *)_dstU;
773  uint16_t *dstV = (uint16_t *)_dstV;
774  int32_t ru = rgb2yuv[RU_IDX], gu = rgb2yuv[GU_IDX], bu = rgb2yuv[BU_IDX];
775  int32_t rv = rgb2yuv[RV_IDX], gv = rgb2yuv[GV_IDX], bv = rgb2yuv[BV_IDX];
776  int shift = bpc < 16 ? bpc : 14;
777  for (i = 0; i < width; i++) {
778  int g = rdpx(src[0] + i);
779  int b = rdpx(src[1] + i);
780  int r = rdpx(src[2] + i);
781 
782  dstU[i] = (ru*r + gu*g + bu*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
783  dstV[i] = (rv*r + gv*g + bv*b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> (RGB2YUV_SHIFT + shift - 14);
784  }
785 }
786 #undef rdpx
787 
788 #define rgb9plus_planar_funcs_endian(nbits, endian_name, endian) \
789 static void planar_rgb##nbits##endian_name##_to_y(uint8_t *dst, const uint8_t *src[4], \
790  int w, int32_t *rgb2yuv) \
791 { \
792  planar_rgb16_to_y(dst, src, w, nbits, endian, rgb2yuv); \
793 } \
794 static void planar_rgb##nbits##endian_name##_to_uv(uint8_t *dstU, uint8_t *dstV, \
795  const uint8_t *src[4], int w, int32_t *rgb2yuv) \
796 { \
797  planar_rgb16_to_uv(dstU, dstV, src, w, nbits, endian, rgb2yuv); \
798 } \
799 
800 #define rgb9plus_planar_funcs(nbits) \
801  rgb9plus_planar_funcs_endian(nbits, le, 0) \
802  rgb9plus_planar_funcs_endian(nbits, be, 1)
803 
804 rgb9plus_planar_funcs(9)
805 rgb9plus_planar_funcs(10)
806 rgb9plus_planar_funcs(12)
807 rgb9plus_planar_funcs(14)
808 rgb9plus_planar_funcs(16)
809 
810 av_cold void ff_sws_init_input_funcs(SwsContext *c)
811 {
812  enum AVPixelFormat srcFormat = c->srcFormat;
813 
814  c->chrToYV12 = NULL;
815  switch (srcFormat) {
816  case AV_PIX_FMT_YUYV422:
817  c->chrToYV12 = yuy2ToUV_c;
818  break;
819  case AV_PIX_FMT_UYVY422:
820  c->chrToYV12 = uyvyToUV_c;
821  break;
822  case AV_PIX_FMT_NV12:
823  c->chrToYV12 = nv12ToUV_c;
824  break;
825  case AV_PIX_FMT_NV21:
826  c->chrToYV12 = nv21ToUV_c;
827  break;
828  case AV_PIX_FMT_RGB8:
829  case AV_PIX_FMT_BGR8:
830  case AV_PIX_FMT_PAL8:
831  case AV_PIX_FMT_BGR4_BYTE:
832  case AV_PIX_FMT_RGB4_BYTE:
833  c->chrToYV12 = palToUV_c;
834  break;
835  case AV_PIX_FMT_GBRP9LE:
836  c->readChrPlanar = planar_rgb9le_to_uv;
837  break;
838  case AV_PIX_FMT_GBRP10LE:
839  c->readChrPlanar = planar_rgb10le_to_uv;
840  break;
841  case AV_PIX_FMT_GBRP12LE:
842  c->readChrPlanar = planar_rgb12le_to_uv;
843  break;
844  case AV_PIX_FMT_GBRP14LE:
845  c->readChrPlanar = planar_rgb14le_to_uv;
846  break;
847  case AV_PIX_FMT_GBRAP16LE:
848  case AV_PIX_FMT_GBRP16LE:
849  c->readChrPlanar = planar_rgb16le_to_uv;
850  break;
851  case AV_PIX_FMT_GBRP9BE:
852  c->readChrPlanar = planar_rgb9be_to_uv;
853  break;
854  case AV_PIX_FMT_GBRP10BE:
855  c->readChrPlanar = planar_rgb10be_to_uv;
856  break;
857  case AV_PIX_FMT_GBRP12BE:
858  c->readChrPlanar = planar_rgb12be_to_uv;
859  break;
860  case AV_PIX_FMT_GBRP14BE:
861  c->readChrPlanar = planar_rgb14be_to_uv;
862  break;
863  case AV_PIX_FMT_GBRAP16BE:
864  case AV_PIX_FMT_GBRP16BE:
865  c->readChrPlanar = planar_rgb16be_to_uv;
866  break;
867  case AV_PIX_FMT_GBRAP:
868  case AV_PIX_FMT_GBRP:
869  c->readChrPlanar = planar_rgb_to_uv;
870  break;
871 #if HAVE_BIGENDIAN
872  case AV_PIX_FMT_YUV444P9LE:
873  case AV_PIX_FMT_YUV422P9LE:
874  case AV_PIX_FMT_YUV420P9LE:
875  case AV_PIX_FMT_YUV422P10LE:
876  case AV_PIX_FMT_YUV444P10LE:
877  case AV_PIX_FMT_YUV420P10LE:
878  case AV_PIX_FMT_YUV422P12LE:
879  case AV_PIX_FMT_YUV444P12LE:
880  case AV_PIX_FMT_YUV420P12LE:
881  case AV_PIX_FMT_YUV422P14LE:
882  case AV_PIX_FMT_YUV444P14LE:
883  case AV_PIX_FMT_YUV420P14LE:
884  case AV_PIX_FMT_YUV420P16LE:
885  case AV_PIX_FMT_YUV422P16LE:
886  case AV_PIX_FMT_YUV444P16LE:
887 
888  case AV_PIX_FMT_YUVA444P9LE:
889  case AV_PIX_FMT_YUVA422P9LE:
890  case AV_PIX_FMT_YUVA420P9LE:
891  case AV_PIX_FMT_YUVA444P10LE:
892  case AV_PIX_FMT_YUVA422P10LE:
893  case AV_PIX_FMT_YUVA420P10LE:
894  case AV_PIX_FMT_YUVA420P16LE:
895  case AV_PIX_FMT_YUVA422P16LE:
896  case AV_PIX_FMT_YUVA444P16LE:
897  c->chrToYV12 = bswap16UV_c;
898  break;
899 #else
900  case AV_PIX_FMT_YUV444P9BE:
901  case AV_PIX_FMT_YUV422P9BE:
902  case AV_PIX_FMT_YUV420P9BE:
903  case AV_PIX_FMT_YUV444P10BE:
904  case AV_PIX_FMT_YUV422P10BE:
905  case AV_PIX_FMT_YUV420P10BE:
906  case AV_PIX_FMT_YUV444P12BE:
907  case AV_PIX_FMT_YUV422P12BE:
908  case AV_PIX_FMT_YUV420P12BE:
909  case AV_PIX_FMT_YUV444P14BE:
910  case AV_PIX_FMT_YUV422P14BE:
911  case AV_PIX_FMT_YUV420P14BE:
912  case AV_PIX_FMT_YUV420P16BE:
913  case AV_PIX_FMT_YUV422P16BE:
914  case AV_PIX_FMT_YUV444P16BE:
915 
916  case AV_PIX_FMT_YUVA444P9BE:
917  case AV_PIX_FMT_YUVA422P9BE:
918  case AV_PIX_FMT_YUVA420P9BE:
919  case AV_PIX_FMT_YUVA444P10BE:
920  case AV_PIX_FMT_YUVA422P10BE:
921  case AV_PIX_FMT_YUVA420P10BE:
922  case AV_PIX_FMT_YUVA420P16BE:
923  case AV_PIX_FMT_YUVA422P16BE:
924  case AV_PIX_FMT_YUVA444P16BE:
925  c->chrToYV12 = bswap16UV_c;
926  break;
927 #endif
928  }
929  if (c->chrSrcHSubSample) {
930  switch (srcFormat) {
931  case AV_PIX_FMT_RGBA64BE:
932  c->chrToYV12 = rgb64BEToUV_half_c;
933  break;
934  case AV_PIX_FMT_RGBA64LE:
935  c->chrToYV12 = rgb64LEToUV_half_c;
936  break;
937  case AV_PIX_FMT_RGB48BE:
938  c->chrToYV12 = rgb48BEToUV_half_c;
939  break;
940  case AV_PIX_FMT_RGB48LE:
941  c->chrToYV12 = rgb48LEToUV_half_c;
942  break;
943  case AV_PIX_FMT_BGR48BE:
944  c->chrToYV12 = bgr48BEToUV_half_c;
945  break;
946  case AV_PIX_FMT_BGR48LE:
947  c->chrToYV12 = bgr48LEToUV_half_c;
948  break;
949  case AV_PIX_FMT_RGB32:
950  c->chrToYV12 = bgr32ToUV_half_c;
951  break;
952  case AV_PIX_FMT_RGB32_1:
953  c->chrToYV12 = bgr321ToUV_half_c;
954  break;
955  case AV_PIX_FMT_BGR24:
956  c->chrToYV12 = bgr24ToUV_half_c;
957  break;
958  case AV_PIX_FMT_BGR565LE:
959  c->chrToYV12 = bgr16leToUV_half_c;
960  break;
961  case AV_PIX_FMT_BGR565BE:
962  c->chrToYV12 = bgr16beToUV_half_c;
963  break;
964  case AV_PIX_FMT_BGR555LE:
965  c->chrToYV12 = bgr15leToUV_half_c;
966  break;
967  case AV_PIX_FMT_BGR555BE:
968  c->chrToYV12 = bgr15beToUV_half_c;
969  break;
970  case AV_PIX_FMT_GBRAP:
971  case AV_PIX_FMT_GBRP:
972  c->chrToYV12 = gbr24pToUV_half_c;
973  break;
974  case AV_PIX_FMT_BGR444LE:
975  c->chrToYV12 = bgr12leToUV_half_c;
976  break;
977  case AV_PIX_FMT_BGR444BE:
978  c->chrToYV12 = bgr12beToUV_half_c;
979  break;
980  case AV_PIX_FMT_BGR32:
981  c->chrToYV12 = rgb32ToUV_half_c;
982  break;
983  case AV_PIX_FMT_BGR32_1:
984  c->chrToYV12 = rgb321ToUV_half_c;
985  break;
986  case AV_PIX_FMT_RGB24:
987  c->chrToYV12 = rgb24ToUV_half_c;
988  break;
989  case AV_PIX_FMT_RGB565LE:
990  c->chrToYV12 = rgb16leToUV_half_c;
991  break;
992  case AV_PIX_FMT_RGB565BE:
993  c->chrToYV12 = rgb16beToUV_half_c;
994  break;
995  case AV_PIX_FMT_RGB555LE:
996  c->chrToYV12 = rgb15leToUV_half_c;
997  break;
998  case AV_PIX_FMT_RGB555BE:
999  c->chrToYV12 = rgb15beToUV_half_c;
1000  break;
1001  case AV_PIX_FMT_RGB444LE:
1002  c->chrToYV12 = rgb12leToUV_half_c;
1003  break;
1004  case AV_PIX_FMT_RGB444BE:
1005  c->chrToYV12 = rgb12beToUV_half_c;
1006  break;
1007  }
1008  } else {
1009  switch (srcFormat) {
1010  case AV_PIX_FMT_RGBA64BE:
1011  c->chrToYV12 = rgb64BEToUV_c;
1012  break;
1013  case AV_PIX_FMT_RGBA64LE:
1014  c->chrToYV12 = rgb64LEToUV_c;
1015  break;
1016  case AV_PIX_FMT_RGB48BE:
1017  c->chrToYV12 = rgb48BEToUV_c;
1018  break;
1019  case AV_PIX_FMT_RGB48LE:
1020  c->chrToYV12 = rgb48LEToUV_c;
1021  break;
1022  case AV_PIX_FMT_BGR48BE:
1023  c->chrToYV12 = bgr48BEToUV_c;
1024  break;
1025  case AV_PIX_FMT_BGR48LE:
1026  c->chrToYV12 = bgr48LEToUV_c;
1027  break;
1028  case AV_PIX_FMT_RGB32:
1029  c->chrToYV12 = bgr32ToUV_c;
1030  break;
1031  case AV_PIX_FMT_RGB32_1:
1032  c->chrToYV12 = bgr321ToUV_c;
1033  break;
1034  case AV_PIX_FMT_BGR24:
1035  c->chrToYV12 = bgr24ToUV_c;
1036  break;
1037  case AV_PIX_FMT_BGR565LE:
1038  c->chrToYV12 = bgr16leToUV_c;
1039  break;
1040  case AV_PIX_FMT_BGR565BE:
1041  c->chrToYV12 = bgr16beToUV_c;
1042  break;
1043  case AV_PIX_FMT_BGR555LE:
1044  c->chrToYV12 = bgr15leToUV_c;
1045  break;
1046  case AV_PIX_FMT_BGR555BE:
1047  c->chrToYV12 = bgr15beToUV_c;
1048  break;
1049  case AV_PIX_FMT_BGR444LE:
1050  c->chrToYV12 = bgr12leToUV_c;
1051  break;
1052  case AV_PIX_FMT_BGR444BE:
1053  c->chrToYV12 = bgr12beToUV_c;
1054  break;
1055  case AV_PIX_FMT_BGR32:
1056  c->chrToYV12 = rgb32ToUV_c;
1057  break;
1058  case AV_PIX_FMT_BGR32_1:
1059  c->chrToYV12 = rgb321ToUV_c;
1060  break;
1061  case AV_PIX_FMT_RGB24:
1062  c->chrToYV12 = rgb24ToUV_c;
1063  break;
1064  case AV_PIX_FMT_RGB565LE:
1065  c->chrToYV12 = rgb16leToUV_c;
1066  break;
1067  case AV_PIX_FMT_RGB565BE:
1068  c->chrToYV12 = rgb16beToUV_c;
1069  break;
1070  case AV_PIX_FMT_RGB555LE:
1071  c->chrToYV12 = rgb15leToUV_c;
1072  break;
1073  case AV_PIX_FMT_RGB555BE:
1074  c->chrToYV12 = rgb15beToUV_c;
1075  break;
1076  case AV_PIX_FMT_RGB444LE:
1077  c->chrToYV12 = rgb12leToUV_c;
1078  break;
1079  case AV_PIX_FMT_RGB444BE:
1080  c->chrToYV12 = rgb12beToUV_c;
1081  break;
1082  }
1083  }
1084 
1085  c->lumToYV12 = NULL;
1086  c->alpToYV12 = NULL;
1087  switch (srcFormat) {
1088  case AV_PIX_FMT_GBRP9LE:
1089  c->readLumPlanar = planar_rgb9le_to_y;
1090  break;
1091  case AV_PIX_FMT_GBRP10LE:
1092  c->readLumPlanar = planar_rgb10le_to_y;
1093  break;
1094  case AV_PIX_FMT_GBRP12LE:
1095  c->readLumPlanar = planar_rgb12le_to_y;
1096  break;
1097  case AV_PIX_FMT_GBRP14LE:
1098  c->readLumPlanar = planar_rgb14le_to_y;
1099  break;
1100  case AV_PIX_FMT_GBRAP16LE:
1101  case AV_PIX_FMT_GBRP16LE:
1102  c->readLumPlanar = planar_rgb16le_to_y;
1103  break;
1104  case AV_PIX_FMT_GBRP9BE:
1105  c->readLumPlanar = planar_rgb9be_to_y;
1106  break;
1107  case AV_PIX_FMT_GBRP10BE:
1108  c->readLumPlanar = planar_rgb10be_to_y;
1109  break;
1110  case AV_PIX_FMT_GBRP12BE:
1111  c->readLumPlanar = planar_rgb12be_to_y;
1112  break;
1113  case AV_PIX_FMT_GBRP14BE:
1114  c->readLumPlanar = planar_rgb14be_to_y;
1115  break;
1116  case AV_PIX_FMT_GBRAP16BE:
1117  case AV_PIX_FMT_GBRP16BE:
1118  c->readLumPlanar = planar_rgb16be_to_y;
1119  break;
1120  case AV_PIX_FMT_GBRAP:
1121  c->readAlpPlanar = planar_rgb_to_a;
1122  case AV_PIX_FMT_GBRP:
1123  c->readLumPlanar = planar_rgb_to_y;
1124  break;
1125 #if HAVE_BIGENDIAN
1126  case AV_PIX_FMT_YUV444P9LE:
1127  case AV_PIX_FMT_YUV422P9LE:
1128  case AV_PIX_FMT_YUV420P9LE:
1129  case AV_PIX_FMT_YUV444P10LE:
1130  case AV_PIX_FMT_YUV422P10LE:
1131  case AV_PIX_FMT_YUV420P10LE:
1132  case AV_PIX_FMT_YUV444P12LE:
1133  case AV_PIX_FMT_YUV422P12LE:
1134  case AV_PIX_FMT_YUV420P12LE:
1135  case AV_PIX_FMT_YUV444P14LE:
1136  case AV_PIX_FMT_YUV422P14LE:
1137  case AV_PIX_FMT_YUV420P14LE:
1138  case AV_PIX_FMT_YUV420P16LE:
1139  case AV_PIX_FMT_YUV422P16LE:
1140  case AV_PIX_FMT_YUV444P16LE:
1141 
1142  case AV_PIX_FMT_GRAY16LE:
1143  c->lumToYV12 = bswap16Y_c;
1144  break;
1145  case AV_PIX_FMT_YUVA444P9LE:
1146  case AV_PIX_FMT_YUVA422P9LE:
1147  case AV_PIX_FMT_YUVA420P9LE:
1148  case AV_PIX_FMT_YUVA444P10LE:
1149  case AV_PIX_FMT_YUVA422P10LE:
1150  case AV_PIX_FMT_YUVA420P10LE:
1151  case AV_PIX_FMT_YUVA420P16LE:
1152  case AV_PIX_FMT_YUVA422P16LE:
1153  case AV_PIX_FMT_YUVA444P16LE:
1154  c->lumToYV12 = bswap16Y_c;
1155  c->alpToYV12 = bswap16Y_c;
1156  break;
1157 #else
1158  case AV_PIX_FMT_YUV444P9BE:
1159  case AV_PIX_FMT_YUV422P9BE:
1160  case AV_PIX_FMT_YUV420P9BE:
1161  case AV_PIX_FMT_YUV444P10BE:
1162  case AV_PIX_FMT_YUV422P10BE:
1163  case AV_PIX_FMT_YUV420P10BE:
1164  case AV_PIX_FMT_YUV444P12BE:
1165  case AV_PIX_FMT_YUV422P12BE:
1166  case AV_PIX_FMT_YUV420P12BE:
1167  case AV_PIX_FMT_YUV444P14BE:
1168  case AV_PIX_FMT_YUV422P14BE:
1169  case AV_PIX_FMT_YUV420P14BE:
1170  case AV_PIX_FMT_YUV420P16BE:
1171  case AV_PIX_FMT_YUV422P16BE:
1172  case AV_PIX_FMT_YUV444P16BE:
1173 
1174  case AV_PIX_FMT_GRAY16BE:
1175  c->lumToYV12 = bswap16Y_c;
1176  break;
1177  case AV_PIX_FMT_YUVA444P9BE:
1178  case AV_PIX_FMT_YUVA422P9BE:
1179  case AV_PIX_FMT_YUVA420P9BE:
1180  case AV_PIX_FMT_YUVA444P10BE:
1181  case AV_PIX_FMT_YUVA422P10BE:
1182  case AV_PIX_FMT_YUVA420P10BE:
1183  case AV_PIX_FMT_YUVA420P16BE:
1184  case AV_PIX_FMT_YUVA422P16BE:
1185  case AV_PIX_FMT_YUVA444P16BE:
1186  c->lumToYV12 = bswap16Y_c;
1187  c->alpToYV12 = bswap16Y_c;
1188  break;
1189 #endif
1190  case AV_PIX_FMT_YUYV422:
1191  case AV_PIX_FMT_Y400A:
1192  c->lumToYV12 = yuy2ToY_c;
1193  break;
1194  case AV_PIX_FMT_UYVY422:
1195  c->lumToYV12 = uyvyToY_c;
1196  break;
1197  case AV_PIX_FMT_BGR24:
1198  c->lumToYV12 = bgr24ToY_c;
1199  break;
1200  case AV_PIX_FMT_BGR565LE:
1201  c->lumToYV12 = bgr16leToY_c;
1202  break;
1203  case AV_PIX_FMT_BGR565BE:
1204  c->lumToYV12 = bgr16beToY_c;
1205  break;
1206  case AV_PIX_FMT_BGR555LE:
1207  c->lumToYV12 = bgr15leToY_c;
1208  break;
1209  case AV_PIX_FMT_BGR555BE:
1210  c->lumToYV12 = bgr15beToY_c;
1211  break;
1212  case AV_PIX_FMT_BGR444LE:
1213  c->lumToYV12 = bgr12leToY_c;
1214  break;
1215  case AV_PIX_FMT_BGR444BE:
1216  c->lumToYV12 = bgr12beToY_c;
1217  break;
1218  case AV_PIX_FMT_RGB24:
1219  c->lumToYV12 = rgb24ToY_c;
1220  break;
1221  case AV_PIX_FMT_RGB565LE:
1222  c->lumToYV12 = rgb16leToY_c;
1223  break;
1224  case AV_PIX_FMT_RGB565BE:
1225  c->lumToYV12 = rgb16beToY_c;
1226  break;
1227  case AV_PIX_FMT_RGB555LE:
1228  c->lumToYV12 = rgb15leToY_c;
1229  break;
1230  case AV_PIX_FMT_RGB555BE:
1231  c->lumToYV12 = rgb15beToY_c;
1232  break;
1233  case AV_PIX_FMT_RGB444LE:
1234  c->lumToYV12 = rgb12leToY_c;
1235  break;
1236  case AV_PIX_FMT_RGB444BE:
1237  c->lumToYV12 = rgb12beToY_c;
1238  break;
1239  case AV_PIX_FMT_RGB8:
1240  case AV_PIX_FMT_BGR8:
1241  case AV_PIX_FMT_PAL8:
1242  case AV_PIX_FMT_BGR4_BYTE:
1243  case AV_PIX_FMT_RGB4_BYTE:
1244  c->lumToYV12 = palToY_c;
1245  break;
1246  case AV_PIX_FMT_MONOBLACK:
1247  c->lumToYV12 = monoblack2Y_c;
1248  break;
1249  case AV_PIX_FMT_MONOWHITE:
1250  c->lumToYV12 = monowhite2Y_c;
1251  break;
1252  case AV_PIX_FMT_RGB32:
1253  c->lumToYV12 = bgr32ToY_c;
1254  break;
1255  case AV_PIX_FMT_RGB32_1:
1256  c->lumToYV12 = bgr321ToY_c;
1257  break;
1258  case AV_PIX_FMT_BGR32:
1259  c->lumToYV12 = rgb32ToY_c;
1260  break;
1261  case AV_PIX_FMT_BGR32_1:
1262  c->lumToYV12 = rgb321ToY_c;
1263  break;
1264  case AV_PIX_FMT_RGB48BE:
1265  c->lumToYV12 = rgb48BEToY_c;
1266  break;
1267  case AV_PIX_FMT_RGB48LE:
1268  c->lumToYV12 = rgb48LEToY_c;
1269  break;
1270  case AV_PIX_FMT_BGR48BE:
1271  c->lumToYV12 = bgr48BEToY_c;
1272  break;
1273  case AV_PIX_FMT_BGR48LE:
1274  c->lumToYV12 = bgr48LEToY_c;
1275  break;
1276  case AV_PIX_FMT_RGBA64BE:
1277  c->lumToYV12 = rgb64BEToY_c;
1278  break;
1279  case AV_PIX_FMT_RGBA64LE:
1280  c->lumToYV12 = rgb64LEToY_c;
1281  break;
1282  }
1283  if (c->alpPixBuf) {
1284  if (is16BPS(srcFormat) || isNBPS(srcFormat)) {
1285  if (HAVE_BIGENDIAN == !isBE(srcFormat))
1286  c->alpToYV12 = bswap16Y_c;
1287  }
1288  switch (srcFormat) {
1289  case AV_PIX_FMT_RGBA64LE:
1290  case AV_PIX_FMT_RGBA64BE: c->alpToYV12 = rgba64ToA_c; break;
1291  case AV_PIX_FMT_BGRA:
1292  case AV_PIX_FMT_RGBA:
1293  c->alpToYV12 = rgbaToA_c;
1294  break;
1295  case AV_PIX_FMT_ABGR:
1296  case AV_PIX_FMT_ARGB:
1297  c->alpToYV12 = abgrToA_c;
1298  break;
1299  case AV_PIX_FMT_Y400A:
1300  c->alpToYV12 = uyvyToY_c;
1301  break;
1302  case AV_PIX_FMT_PAL8 :
1303  c->alpToYV12 = palToA_c;
1304  break;
1305  }
1306  }
1307 }
Generated on Mon Dec 9 2013 19:21:16 for FFmpeg by   doxygen 1.8.2