input.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2003 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of Libav.
5  *
6  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <assert.h>
22 #include <math.h>
23 #include <stdint.h>
24 #include <stdio.h>
25 #include <string.h>
26 
27 #include "libavutil/avutil.h"
28 #include "libavutil/bswap.h"
29 #include "libavutil/cpu.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mathematics.h"
32 #include "libavutil/pixdesc.h"
33 #include "config.h"
34 #include "rgb2rgb.h"
35 #include "swscale.h"
36 #include "swscale_internal.h"
37 
38 #define RGB2YUV_SHIFT 15
39 #define BY ((int)(0.114 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
40 #define BV (-(int)(0.081 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
41 #define BU ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
42 #define GY ((int)(0.587 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
43 #define GV (-(int)(0.419 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
44 #define GU (-(int)(0.331 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
45 #define RY ((int)(0.299 * 219 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
46 #define RV ((int)(0.500 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
47 #define RU (-(int)(0.169 * 224 / 255 * (1 << RGB2YUV_SHIFT) + 0.5))
48 
49 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
50 
51 #define r ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? b_r : r_b)
52 #define b ((origin == AV_PIX_FMT_BGR48BE || origin == AV_PIX_FMT_BGR48LE) ? r_b : b_r)
53 
54 static av_always_inline void rgb48ToY_c_template(uint16_t *dst,
55  const uint16_t *src, int width,
56  enum AVPixelFormat origin)
57 {
58  int i;
59  for (i = 0; i < width; i++) {
60  unsigned int r_b = input_pixel(&src[i * 3 + 0]);
61  unsigned int g = input_pixel(&src[i * 3 + 1]);
62  unsigned int b_r = input_pixel(&src[i * 3 + 2]);
63 
64  dst[i] = (RY * r + GY * g + BY * b + (0x2001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
65  }
66 }
67 
68 static av_always_inline void rgb48ToUV_c_template(uint16_t *dstU,
69  uint16_t *dstV,
70  const uint16_t *src1,
71  const uint16_t *src2,
72  int width,
73  enum AVPixelFormat origin)
74 {
75  int i;
76  assert(src1 == src2);
77  for (i = 0; i < width; i++) {
78  int r_b = input_pixel(&src1[i * 3 + 0]);
79  int g = input_pixel(&src1[i * 3 + 1]);
80  int b_r = input_pixel(&src1[i * 3 + 2]);
81 
82  dstU[i] = (RU * r + GU * g + BU * b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
83  dstV[i] = (RV * r + GV * g + BV * b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
84  }
85 }
86 
87 static av_always_inline void rgb48ToUV_half_c_template(uint16_t *dstU,
88  uint16_t *dstV,
89  const uint16_t *src1,
90  const uint16_t *src2,
91  int width,
92  enum AVPixelFormat origin)
93 {
94  int i;
95  assert(src1 == src2);
96  for (i = 0; i < width; i++) {
97  int r_b = (input_pixel(&src1[6 * i + 0]) +
98  input_pixel(&src1[6 * i + 3]) + 1) >> 1;
99  int g = (input_pixel(&src1[6 * i + 1]) +
100  input_pixel(&src1[6 * i + 4]) + 1) >> 1;
101  int b_r = (input_pixel(&src1[6 * i + 2]) +
102  input_pixel(&src1[6 * i + 5]) + 1) >> 1;
103 
104  dstU[i] = (RU * r + GU * g + BU * b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
105  dstV[i] = (RV * r + GV * g + BV * b + (0x10001 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
106  }
107 }
108 
109 #undef r
110 #undef b
111 #undef input_pixel
112 
113 #define rgb48funcs(pattern, BE_LE, origin) \
114 static void pattern ## 48 ## BE_LE ## ToY_c(uint8_t *_dst, \
115  const uint8_t *_src, \
116  int width, \
117  uint32_t *unused) \
118 { \
119  const uint16_t *src = (const uint16_t *)_src; \
120  uint16_t *dst = (uint16_t *)_dst; \
121  rgb48ToY_c_template(dst, src, width, origin); \
122 } \
123  \
124 static void pattern ## 48 ## BE_LE ## ToUV_c(uint8_t *_dstU, \
125  uint8_t *_dstV, \
126  const uint8_t *_src1, \
127  const uint8_t *_src2, \
128  int width, \
129  uint32_t *unused) \
130 { \
131  const uint16_t *src1 = (const uint16_t *)_src1, \
132  *src2 = (const uint16_t *)_src2; \
133  uint16_t *dstU = (uint16_t *)_dstU, \
134  *dstV = (uint16_t *)_dstV; \
135  rgb48ToUV_c_template(dstU, dstV, src1, src2, width, origin); \
136 } \
137  \
138 static void pattern ## 48 ## BE_LE ## ToUV_half_c(uint8_t *_dstU, \
139  uint8_t *_dstV, \
140  const uint8_t *_src1, \
141  const uint8_t *_src2, \
142  int width, \
143  uint32_t *unused) \
144 { \
145  const uint16_t *src1 = (const uint16_t *)_src1, \
146  *src2 = (const uint16_t *)_src2; \
147  uint16_t *dstU = (uint16_t *)_dstU, \
148  *dstV = (uint16_t *)_dstV; \
149  rgb48ToUV_half_c_template(dstU, dstV, src1, src2, width, origin); \
150 }
151 
156 
157 #define input_pixel(i) ((origin == AV_PIX_FMT_RGBA || \
158  origin == AV_PIX_FMT_BGRA || \
159  origin == AV_PIX_FMT_ARGB || \
160  origin == AV_PIX_FMT_ABGR) \
161  ? AV_RN32A(&src[(i) * 4]) \
162  : (isBE(origin) ? AV_RB16(&src[(i) * 2]) \
163  : AV_RL16(&src[(i) * 2])))
164 
165 static av_always_inline void rgb16_32ToY_c_template(uint8_t *dst,
166  const uint8_t *src,
167  int width,
168  enum AVPixelFormat origin,
169  int shr, int shg,
170  int shb, int shp,
171  int maskr, int maskg,
172  int maskb, int rsh,
173  int gsh, int bsh, int S)
174 {
175  const int ry = RY << rsh, gy = GY << gsh, by = BY << bsh;
176  const unsigned rnd = 33u << (S - 1);
177  int i;
178 
179  for (i = 0; i < width; i++) {
180  int px = input_pixel(i) >> shp;
181  int b = (px & maskb) >> shb;
182  int g = (px & maskg) >> shg;
183  int r = (px & maskr) >> shr;
184 
185  dst[i] = (ry * r + gy * g + by * b + rnd) >> S;
186  }
187 }
188 
190  uint8_t *dstV,
191  const uint8_t *src,
192  int width,
193  enum AVPixelFormat origin,
194  int shr, int shg,
195  int shb, int shp,
196  int maskr, int maskg,
197  int maskb, int rsh,
198  int gsh, int bsh, int S)
199 {
200  const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh,
201  rv = RV << rsh, gv = GV << gsh, bv = BV << bsh;
202  const unsigned rnd = 257u << (S - 1);
203  int i;
204 
205  for (i = 0; i < width; i++) {
206  int px = input_pixel(i) >> shp;
207  int b = (px & maskb) >> shb;
208  int g = (px & maskg) >> shg;
209  int r = (px & maskr) >> shr;
210 
211  dstU[i] = (ru * r + gu * g + bu * b + rnd) >> S;
212  dstV[i] = (rv * r + gv * g + bv * b + rnd) >> S;
213  }
214 }
215 
217  uint8_t *dstV,
218  const uint8_t *src,
219  int width,
220  enum AVPixelFormat origin,
221  int shr, int shg,
222  int shb, int shp,
223  int maskr, int maskg,
224  int maskb, int rsh,
225  int gsh, int bsh, int S)
226 {
227  const int ru = RU << rsh, gu = GU << gsh, bu = BU << bsh,
228  rv = RV << rsh, gv = GV << gsh, bv = BV << bsh,
229  maskgx = ~(maskr | maskb);
230  const unsigned rnd = 257u << S;
231  int i;
232 
233  maskr |= maskr << 1;
234  maskb |= maskb << 1;
235  maskg |= maskg << 1;
236  for (i = 0; i < width; i++) {
237  int px0 = input_pixel(2 * i + 0) >> shp;
238  int px1 = input_pixel(2 * i + 1) >> shp;
239  int b, r, g = (px0 & maskgx) + (px1 & maskgx);
240  int rb = px0 + px1 - g;
241 
242  b = (rb & maskb) >> shb;
243  if (shp ||
244  origin == AV_PIX_FMT_BGR565LE || origin == AV_PIX_FMT_BGR565BE ||
245  origin == AV_PIX_FMT_RGB565LE || origin == AV_PIX_FMT_RGB565BE) {
246  g >>= shg;
247  } else {
248  g = (g & maskg) >> shg;
249  }
250  r = (rb & maskr) >> shr;
251 
252  dstU[i] = (ru * r + gu * g + bu * b + rnd) >> (S + 1);
253  dstV[i] = (rv * r + gv * g + bv * b + rnd) >> (S + 1);
254  }
255 }
256 
257 #undef input_pixel
258 
259 #define rgb16_32_wrapper(fmt, name, shr, shg, shb, shp, maskr, \
260  maskg, maskb, rsh, gsh, bsh, S) \
261 static void name ## ToY_c(uint8_t *dst, const uint8_t *src, \
262  int width, uint32_t *unused) \
263 { \
264  rgb16_32ToY_c_template(dst, src, width, fmt, shr, shg, shb, shp, \
265  maskr, maskg, maskb, rsh, gsh, bsh, S); \
266 } \
267  \
268 static void name ## ToUV_c(uint8_t *dstU, uint8_t *dstV, \
269  const uint8_t *src, const uint8_t *dummy, \
270  int width, uint32_t *unused) \
271 { \
272  rgb16_32ToUV_c_template(dstU, dstV, src, width, fmt, \
273  shr, shg, shb, shp, \
274  maskr, maskg, maskb, rsh, gsh, bsh, S); \
275 } \
276  \
277 static void name ## ToUV_half_c(uint8_t *dstU, uint8_t *dstV, \
278  const uint8_t *src, \
279  const uint8_t *dummy, \
280  int width, uint32_t *unused) \
281 { \
282  rgb16_32ToUV_half_c_template(dstU, dstV, src, width, fmt, \
283  shr, shg, shb, shp, \
284  maskr, maskg, maskb, \
285  rsh, gsh, bsh, S); \
286 }
287 
288 rgb16_32_wrapper(AV_PIX_FMT_BGR32, bgr32, 16, 0, 0, 0, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
289 rgb16_32_wrapper(AV_PIX_FMT_BGR32_1, bgr321, 16, 0, 0, 8, 0xFF0000, 0xFF00, 0x00FF, 8, 0, 8, RGB2YUV_SHIFT + 8)
290 rgb16_32_wrapper(AV_PIX_FMT_RGB32, rgb32, 0, 0, 16, 0, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
291 rgb16_32_wrapper(AV_PIX_FMT_RGB32_1, rgb321, 0, 0, 16, 8, 0x00FF, 0xFF00, 0xFF0000, 8, 0, 8, RGB2YUV_SHIFT + 8)
292 rgb16_32_wrapper(AV_PIX_FMT_BGR565LE, bgr16le, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
293 rgb16_32_wrapper(AV_PIX_FMT_BGR555LE, bgr15le, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
294 rgb16_32_wrapper(AV_PIX_FMT_BGR444LE, bgr12le, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
295 rgb16_32_wrapper(AV_PIX_FMT_RGB565LE, rgb16le, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
296 rgb16_32_wrapper(AV_PIX_FMT_RGB555LE, rgb15le, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
297 rgb16_32_wrapper(AV_PIX_FMT_RGB444LE, rgb12le, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
298 rgb16_32_wrapper(AV_PIX_FMT_BGR565BE, bgr16be, 0, 0, 0, 0, 0x001F, 0x07E0, 0xF800, 11, 5, 0, RGB2YUV_SHIFT + 8)
299 rgb16_32_wrapper(AV_PIX_FMT_BGR555BE, bgr15be, 0, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, 10, 5, 0, RGB2YUV_SHIFT + 7)
300 rgb16_32_wrapper(AV_PIX_FMT_BGR444BE, bgr12be, 0, 0, 0, 0, 0x000F, 0x00F0, 0x0F00, 8, 4, 0, RGB2YUV_SHIFT + 4)
301 rgb16_32_wrapper(AV_PIX_FMT_RGB565BE, rgb16be, 0, 0, 0, 0, 0xF800, 0x07E0, 0x001F, 0, 5, 11, RGB2YUV_SHIFT + 8)
302 rgb16_32_wrapper(AV_PIX_FMT_RGB555BE, rgb15be, 0, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, 0, 5, 10, RGB2YUV_SHIFT + 7)
303 rgb16_32_wrapper(AV_PIX_FMT_RGB444BE, rgb12be, 0, 0, 0, 0, 0x0F00, 0x00F0, 0x000F, 0, 4, 8, RGB2YUV_SHIFT + 4)
304 
305 static void abgrToA_c(uint8_t *dst, const uint8_t *src, int width,
306  uint32_t *unused)
307 {
308  int i;
309  for (i = 0; i < width; i++)
310  dst[i] = src[4 * i];
311 }
312 
313 static void rgbaToA_c(uint8_t *dst, const uint8_t *src, int width,
314  uint32_t *unused)
315 {
316  int i;
317  for (i = 0; i < width; i++)
318  dst[i] = src[4 * i + 3];
319 }
320 
321 static void palToY_c(uint8_t *dst, const uint8_t *src, int width, uint32_t *pal)
322 {
323  int i;
324  for (i = 0; i < width; i++) {
325  int d = src[i];
326 
327  dst[i] = pal[d] & 0xFF;
328  }
329 }
330 
331 static void palToUV_c(uint8_t *dstU, uint8_t *dstV,
332  const uint8_t *src1, const uint8_t *src2,
333  int width, uint32_t *pal)
334 {
335  int i;
336  assert(src1 == src2);
337  for (i = 0; i < width; i++) {
338  int p = pal[src1[i]];
339 
340  dstU[i] = p >> 8;
341  dstV[i] = p >> 16;
342  }
343 }
344 
345 static void monowhite2Y_c(uint8_t *dst, const uint8_t *src,
346  int width, uint32_t *unused)
347 {
348  int i, j;
349  width = (width + 7) >> 3;
350  for (i = 0; i < width; i++) {
351  int d = ~src[i];
352  for (j = 0; j < 8; j++)
353  dst[8 * i + j] = ((d >> (7 - j)) & 1) * 255;
354  }
355 }
356 
357 static void monoblack2Y_c(uint8_t *dst, const uint8_t *src,
358  int width, uint32_t *unused)
359 {
360  int i, j;
361  width = (width + 7) >> 3;
362  for (i = 0; i < width; i++) {
363  int d = src[i];
364  for (j = 0; j < 8; j++)
365  dst[8 * i + j] = ((d >> (7 - j)) & 1) * 255;
366  }
367 }
368 
369 static void yuy2ToY_c(uint8_t *dst, const uint8_t *src, int width,
370  uint32_t *unused)
371 {
372  int i;
373  for (i = 0; i < width; i++)
374  dst[i] = src[2 * i];
375 }
376 
377 static void yuy2ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
378  const uint8_t *src2, int width, uint32_t *unused)
379 {
380  int i;
381  for (i = 0; i < width; i++) {
382  dstU[i] = src1[4 * i + 1];
383  dstV[i] = src1[4 * i + 3];
384  }
385  assert(src1 == src2);
386 }
387 
388 static void bswap16Y_c(uint8_t *_dst, const uint8_t *_src, int width,
389  uint32_t *unused)
390 {
391  int i;
392  const uint16_t *src = (const uint16_t *)_src;
393  uint16_t *dst = (uint16_t *)_dst;
394  for (i = 0; i < width; i++)
395  dst[i] = av_bswap16(src[i]);
396 }
397 
398 static void bswap16UV_c(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *_src1,
399  const uint8_t *_src2, int width, uint32_t *unused)
400 {
401  int i;
402  const uint16_t *src1 = (const uint16_t *)_src1,
403  *src2 = (const uint16_t *)_src2;
404  uint16_t *dstU = (uint16_t *)_dstU, *dstV = (uint16_t *)_dstV;
405  for (i = 0; i < width; i++) {
406  dstU[i] = av_bswap16(src1[i]);
407  dstV[i] = av_bswap16(src2[i]);
408  }
409 }
410 
411 /* This is almost identical to the previous, end exists only because
412  * yuy2ToY/UV)(dst, src + 1, ...) would have 100% unaligned accesses. */
413 static void uyvyToY_c(uint8_t *dst, const uint8_t *src, int width,
414  uint32_t *unused)
415 {
416  int i;
417  for (i = 0; i < width; i++)
418  dst[i] = src[2 * i + 1];
419 }
420 
421 static void uyvyToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
422  const uint8_t *src2, int width, uint32_t *unused)
423 {
424  int i;
425  for (i = 0; i < width; i++) {
426  dstU[i] = src1[4 * i + 0];
427  dstV[i] = src1[4 * i + 2];
428  }
429  assert(src1 == src2);
430 }
431 
432 static av_always_inline void nvXXtoUV_c(uint8_t *dst1, uint8_t *dst2,
433  const uint8_t *src, int width)
434 {
435  int i;
436  for (i = 0; i < width; i++) {
437  dst1[i] = src[2 * i + 0];
438  dst2[i] = src[2 * i + 1];
439  }
440 }
441 
442 static void nv12ToUV_c(uint8_t *dstU, uint8_t *dstV,
443  const uint8_t *src1, const uint8_t *src2,
444  int width, uint32_t *unused)
445 {
446  nvXXtoUV_c(dstU, dstV, src1, width);
447 }
448 
449 static void nv21ToUV_c(uint8_t *dstU, uint8_t *dstV,
450  const uint8_t *src1, const uint8_t *src2,
451  int width, uint32_t *unused)
452 {
453  nvXXtoUV_c(dstV, dstU, src1, width);
454 }
455 
456 #define input_pixel(pos) (isBE(origin) ? AV_RB16(pos) : AV_RL16(pos))
457 
458 static void bgr24ToY_c(uint8_t *dst, const uint8_t *src,
459  int width, uint32_t *unused)
460 {
461  int i;
462  for (i = 0; i < width; i++) {
463  int b = src[i * 3 + 0];
464  int g = src[i * 3 + 1];
465  int r = src[i * 3 + 2];
466 
467  dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
468  }
469 }
470 
471 static void bgr24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
472  const uint8_t *src2, int width, uint32_t *unused)
473 {
474  int i;
475  for (i = 0; i < width; i++) {
476  int b = src1[3 * i + 0];
477  int g = src1[3 * i + 1];
478  int r = src1[3 * i + 2];
479 
480  dstU[i] = (RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
481  dstV[i] = (RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
482  }
483  assert(src1 == src2);
484 }
485 
486 static void bgr24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
487  const uint8_t *src2, int width, uint32_t *unused)
488 {
489  int i;
490  for (i = 0; i < width; i++) {
491  int b = src1[6 * i + 0] + src1[6 * i + 3];
492  int g = src1[6 * i + 1] + src1[6 * i + 4];
493  int r = src1[6 * i + 2] + src1[6 * i + 5];
494 
495  dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
496  dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
497  }
498  assert(src1 == src2);
499 }
500 
501 static void rgb24ToY_c(uint8_t *dst, const uint8_t *src, int width,
502  uint32_t *unused)
503 {
504  int i;
505  for (i = 0; i < width; i++) {
506  int r = src[i * 3 + 0];
507  int g = src[i * 3 + 1];
508  int b = src[i * 3 + 2];
509 
510  dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
511  }
512 }
513 
514 static void rgb24ToUV_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
515  const uint8_t *src2, int width, uint32_t *unused)
516 {
517  int i;
518  assert(src1 == src2);
519  for (i = 0; i < width; i++) {
520  int r = src1[3 * i + 0];
521  int g = src1[3 * i + 1];
522  int b = src1[3 * i + 2];
523 
524  dstU[i] = (RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
525  dstV[i] = (RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
526  }
527 }
528 
529 static void rgb24ToUV_half_c(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1,
530  const uint8_t *src2, int width, uint32_t *unused)
531 {
532  int i;
533  assert(src1 == src2);
534  for (i = 0; i < width; i++) {
535  int r = src1[6 * i + 0] + src1[6 * i + 3];
536  int g = src1[6 * i + 1] + src1[6 * i + 4];
537  int b = src1[6 * i + 2] + src1[6 * i + 5];
538 
539  dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
540  dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
541  }
542 }
543 
544 static void planar_rgb_to_y(uint8_t *dst, const uint8_t *src[4], int width)
545 {
546  int i;
547  for (i = 0; i < width; i++) {
548  int g = src[0][i];
549  int b = src[1][i];
550  int r = src[2][i];
551 
552  dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
553  }
554 }
555 
556 static void planar_rgb_to_uv(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width)
557 {
558  int i;
559  for (i = 0; i < width; i++) {
560  int g = src[0][i];
561  int b = src[1][i];
562  int r = src[2][i];
563 
564  dstU[i] = (RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
565  dstV[i] = (RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
566  }
567 }
568 
569 #define rdpx(src) \
570  is_be ? AV_RB16(src) : AV_RL16(src)
571 static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
572  int width, int bpc, int is_be)
573 {
574  int i;
575  const uint16_t **src = (const uint16_t **)_src;
576  uint16_t *dst = (uint16_t *)_dst;
577  for (i = 0; i < width; i++) {
578  int g = rdpx(src[0] + i);
579  int b = rdpx(src[1] + i);
580  int r = rdpx(src[2] + i);
581 
582  dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> RGB2YUV_SHIFT);
583  }
584 }
585 
586 static void planar_rgb9le_to_y(uint8_t *dst, const uint8_t *src[4], int w)
587 {
588  planar_rgb16_to_y(dst, src, w, 9, 0);
589 }
590 
591 static void planar_rgb9be_to_y(uint8_t *dst, const uint8_t *src[4], int w)
592 {
593  planar_rgb16_to_y(dst, src, w, 9, 1);
594 }
595 
596 static void planar_rgb10le_to_y(uint8_t *dst, const uint8_t *src[4], int w)
597 {
598  planar_rgb16_to_y(dst, src, w, 10, 0);
599 }
600 
601 static void planar_rgb10be_to_y(uint8_t *dst, const uint8_t *src[4], int w)
602 {
603  planar_rgb16_to_y(dst, src, w, 10, 1);
604 }
605 
606 static void planar_rgb16le_to_y(uint8_t *dst, const uint8_t *src[4], int w)
607 {
608  planar_rgb16_to_y(dst, src, w, 16, 0);
609 }
610 
611 static void planar_rgb16be_to_y(uint8_t *dst, const uint8_t *src[4], int w)
612 {
613  planar_rgb16_to_y(dst, src, w, 16, 1);
614 }
615 
617  const uint8_t *_src[4], int width,
618  int bpc, int is_be)
619 {
620  int i;
621  const uint16_t **src = (const uint16_t **)_src;
622  uint16_t *dstU = (uint16_t *)_dstU;
623  uint16_t *dstV = (uint16_t *)_dstV;
624  for (i = 0; i < width; i++) {
625  int g = rdpx(src[0] + i);
626  int b = rdpx(src[1] + i);
627  int r = rdpx(src[2] + i);
628 
629  dstU[i] = (RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> RGB2YUV_SHIFT;
630  dstV[i] = (RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> RGB2YUV_SHIFT;
631  }
632 }
633 #undef rdpx
634 
635 static void planar_rgb9le_to_uv(uint8_t *dstU, uint8_t *dstV,
636  const uint8_t *src[4], int w)
637 {
638  planar_rgb16_to_uv(dstU, dstV, src, w, 9, 0);
639 }
640 
641 static void planar_rgb9be_to_uv(uint8_t *dstU, uint8_t *dstV,
642  const uint8_t *src[4], int w)
643 {
644  planar_rgb16_to_uv(dstU, dstV, src, w, 9, 1);
645 }
646 
647 static void planar_rgb10le_to_uv(uint8_t *dstU, uint8_t *dstV,
648  const uint8_t *src[4], int w)
649 {
650  planar_rgb16_to_uv(dstU, dstV, src, w, 10, 0);
651 }
652 
653 static void planar_rgb10be_to_uv(uint8_t *dstU, uint8_t *dstV,
654  const uint8_t *src[4], int w)
655 {
656  planar_rgb16_to_uv(dstU, dstV, src, w, 10, 1);
657 }
658 
659 static void planar_rgb16le_to_uv(uint8_t *dstU, uint8_t *dstV,
660  const uint8_t *src[4], int w)
661 {
662  planar_rgb16_to_uv(dstU, dstV, src, w, 16, 0);
663 }
664 
665 static void planar_rgb16be_to_uv(uint8_t *dstU, uint8_t *dstV,
666  const uint8_t *src[4], int w)
667 {
668  planar_rgb16_to_uv(dstU, dstV, src, w, 16, 1);
669 }
670 
672 {
673  enum AVPixelFormat srcFormat = c->srcFormat;
674 
675  c->chrToYV12 = NULL;
676  switch (srcFormat) {
677  case AV_PIX_FMT_YUYV422:
678  c->chrToYV12 = yuy2ToUV_c;
679  break;
680  case AV_PIX_FMT_UYVY422:
681  c->chrToYV12 = uyvyToUV_c;
682  break;
683  case AV_PIX_FMT_NV12:
684  c->chrToYV12 = nv12ToUV_c;
685  break;
686  case AV_PIX_FMT_NV21:
687  c->chrToYV12 = nv21ToUV_c;
688  break;
689  case AV_PIX_FMT_RGB8:
690  case AV_PIX_FMT_BGR8:
691  case AV_PIX_FMT_PAL8:
694  c->chrToYV12 = palToUV_c;
695  break;
696  case AV_PIX_FMT_GBRP9LE:
698  break;
699  case AV_PIX_FMT_GBRP10LE:
701  break;
702  case AV_PIX_FMT_GBRP16LE:
704  break;
705  case AV_PIX_FMT_GBRP9BE:
707  break;
708  case AV_PIX_FMT_GBRP10BE:
710  break;
711  case AV_PIX_FMT_GBRP16BE:
713  break;
714  case AV_PIX_FMT_GBRP:
716  break;
717 #if HAVE_BIGENDIAN
736  c->chrToYV12 = bswap16UV_c;
737  break;
738 #else
757  c->chrToYV12 = bswap16UV_c;
758  break;
759 #endif
760  }
761  if (c->chrSrcHSubSample) {
762  switch (srcFormat) {
763  case AV_PIX_FMT_RGB48BE:
764  c->chrToYV12 = rgb48BEToUV_half_c;
765  break;
766  case AV_PIX_FMT_RGB48LE:
767  c->chrToYV12 = rgb48LEToUV_half_c;
768  break;
769  case AV_PIX_FMT_BGR48BE:
770  c->chrToYV12 = bgr48BEToUV_half_c;
771  break;
772  case AV_PIX_FMT_BGR48LE:
773  c->chrToYV12 = bgr48LEToUV_half_c;
774  break;
775  case AV_PIX_FMT_RGB32:
776  c->chrToYV12 = bgr32ToUV_half_c;
777  break;
778  case AV_PIX_FMT_RGB32_1:
779  c->chrToYV12 = bgr321ToUV_half_c;
780  break;
781  case AV_PIX_FMT_BGR24:
783  break;
784  case AV_PIX_FMT_BGR565LE:
785  c->chrToYV12 = bgr16leToUV_half_c;
786  break;
787  case AV_PIX_FMT_BGR565BE:
788  c->chrToYV12 = bgr16beToUV_half_c;
789  break;
790  case AV_PIX_FMT_BGR555LE:
791  c->chrToYV12 = bgr15leToUV_half_c;
792  break;
793  case AV_PIX_FMT_BGR555BE:
794  c->chrToYV12 = bgr15beToUV_half_c;
795  break;
796  case AV_PIX_FMT_BGR444LE:
797  c->chrToYV12 = bgr12leToUV_half_c;
798  break;
799  case AV_PIX_FMT_BGR444BE:
800  c->chrToYV12 = bgr12beToUV_half_c;
801  break;
802  case AV_PIX_FMT_BGR32:
803  c->chrToYV12 = rgb32ToUV_half_c;
804  break;
805  case AV_PIX_FMT_BGR32_1:
806  c->chrToYV12 = rgb321ToUV_half_c;
807  break;
808  case AV_PIX_FMT_RGB24:
810  break;
811  case AV_PIX_FMT_RGB565LE:
812  c->chrToYV12 = rgb16leToUV_half_c;
813  break;
814  case AV_PIX_FMT_RGB565BE:
815  c->chrToYV12 = rgb16beToUV_half_c;
816  break;
817  case AV_PIX_FMT_RGB555LE:
818  c->chrToYV12 = rgb15leToUV_half_c;
819  break;
820  case AV_PIX_FMT_RGB555BE:
821  c->chrToYV12 = rgb15beToUV_half_c;
822  break;
823  case AV_PIX_FMT_RGB444LE:
824  c->chrToYV12 = rgb12leToUV_half_c;
825  break;
826  case AV_PIX_FMT_RGB444BE:
827  c->chrToYV12 = rgb12beToUV_half_c;
828  break;
829  }
830  } else {
831  switch (srcFormat) {
832  case AV_PIX_FMT_RGB48BE:
833  c->chrToYV12 = rgb48BEToUV_c;
834  break;
835  case AV_PIX_FMT_RGB48LE:
836  c->chrToYV12 = rgb48LEToUV_c;
837  break;
838  case AV_PIX_FMT_BGR48BE:
839  c->chrToYV12 = bgr48BEToUV_c;
840  break;
841  case AV_PIX_FMT_BGR48LE:
842  c->chrToYV12 = bgr48LEToUV_c;
843  break;
844  case AV_PIX_FMT_RGB32:
845  c->chrToYV12 = bgr32ToUV_c;
846  break;
847  case AV_PIX_FMT_RGB32_1:
848  c->chrToYV12 = bgr321ToUV_c;
849  break;
850  case AV_PIX_FMT_BGR24:
851  c->chrToYV12 = bgr24ToUV_c;
852  break;
853  case AV_PIX_FMT_BGR565LE:
854  c->chrToYV12 = bgr16leToUV_c;
855  break;
856  case AV_PIX_FMT_BGR565BE:
857  c->chrToYV12 = bgr16beToUV_c;
858  break;
859  case AV_PIX_FMT_BGR555LE:
860  c->chrToYV12 = bgr15leToUV_c;
861  break;
862  case AV_PIX_FMT_BGR555BE:
863  c->chrToYV12 = bgr15beToUV_c;
864  break;
865  case AV_PIX_FMT_BGR444LE:
866  c->chrToYV12 = bgr12leToUV_c;
867  break;
868  case AV_PIX_FMT_BGR444BE:
869  c->chrToYV12 = bgr12beToUV_c;
870  break;
871  case AV_PIX_FMT_BGR32:
872  c->chrToYV12 = rgb32ToUV_c;
873  break;
874  case AV_PIX_FMT_BGR32_1:
875  c->chrToYV12 = rgb321ToUV_c;
876  break;
877  case AV_PIX_FMT_RGB24:
878  c->chrToYV12 = rgb24ToUV_c;
879  break;
880  case AV_PIX_FMT_RGB565LE:
881  c->chrToYV12 = rgb16leToUV_c;
882  break;
883  case AV_PIX_FMT_RGB565BE:
884  c->chrToYV12 = rgb16beToUV_c;
885  break;
886  case AV_PIX_FMT_RGB555LE:
887  c->chrToYV12 = rgb15leToUV_c;
888  break;
889  case AV_PIX_FMT_RGB555BE:
890  c->chrToYV12 = rgb15beToUV_c;
891  break;
892  case AV_PIX_FMT_RGB444LE:
893  c->chrToYV12 = rgb12leToUV_c;
894  break;
895  case AV_PIX_FMT_RGB444BE:
896  c->chrToYV12 = rgb12beToUV_c;
897  break;
898  }
899  }
900 
901  c->lumToYV12 = NULL;
902  c->alpToYV12 = NULL;
903  switch (srcFormat) {
904  case AV_PIX_FMT_GBRP9LE:
906  break;
907  case AV_PIX_FMT_GBRP10LE:
909  break;
910  case AV_PIX_FMT_GBRP16LE:
912  break;
913  case AV_PIX_FMT_GBRP9BE:
915  break;
916  case AV_PIX_FMT_GBRP10BE:
918  break;
919  case AV_PIX_FMT_GBRP16BE:
921  break;
922  case AV_PIX_FMT_GBRP:
924  break;
925 #if HAVE_BIGENDIAN
935  case AV_PIX_FMT_GRAY16LE:
936  c->lumToYV12 = bswap16Y_c;
937  break;
947  c->lumToYV12 = bswap16Y_c;
948  c->alpToYV12 = bswap16Y_c;
949  break;
950 #else
960  case AV_PIX_FMT_GRAY16BE:
961  c->lumToYV12 = bswap16Y_c;
962  break;
972  c->lumToYV12 = bswap16Y_c;
973  c->alpToYV12 = bswap16Y_c;
974  break;
975 #endif
976  case AV_PIX_FMT_YUYV422:
977  case AV_PIX_FMT_Y400A:
978  c->lumToYV12 = yuy2ToY_c;
979  break;
980  case AV_PIX_FMT_UYVY422:
981  c->lumToYV12 = uyvyToY_c;
982  break;
983  case AV_PIX_FMT_BGR24:
984  c->lumToYV12 = bgr24ToY_c;
985  break;
986  case AV_PIX_FMT_BGR565LE:
987  c->lumToYV12 = bgr16leToY_c;
988  break;
989  case AV_PIX_FMT_BGR565BE:
990  c->lumToYV12 = bgr16beToY_c;
991  break;
992  case AV_PIX_FMT_BGR555LE:
993  c->lumToYV12 = bgr15leToY_c;
994  break;
995  case AV_PIX_FMT_BGR555BE:
996  c->lumToYV12 = bgr15beToY_c;
997  break;
998  case AV_PIX_FMT_BGR444LE:
999  c->lumToYV12 = bgr12leToY_c;
1000  break;
1001  case AV_PIX_FMT_BGR444BE:
1002  c->lumToYV12 = bgr12beToY_c;
1003  break;
1004  case AV_PIX_FMT_RGB24:
1005  c->lumToYV12 = rgb24ToY_c;
1006  break;
1007  case AV_PIX_FMT_RGB565LE:
1008  c->lumToYV12 = rgb16leToY_c;
1009  break;
1010  case AV_PIX_FMT_RGB565BE:
1011  c->lumToYV12 = rgb16beToY_c;
1012  break;
1013  case AV_PIX_FMT_RGB555LE:
1014  c->lumToYV12 = rgb15leToY_c;
1015  break;
1016  case AV_PIX_FMT_RGB555BE:
1017  c->lumToYV12 = rgb15beToY_c;
1018  break;
1019  case AV_PIX_FMT_RGB444LE:
1020  c->lumToYV12 = rgb12leToY_c;
1021  break;
1022  case AV_PIX_FMT_RGB444BE:
1023  c->lumToYV12 = rgb12beToY_c;
1024  break;
1025  case AV_PIX_FMT_RGB8:
1026  case AV_PIX_FMT_BGR8:
1027  case AV_PIX_FMT_PAL8:
1028  case AV_PIX_FMT_BGR4_BYTE:
1029  case AV_PIX_FMT_RGB4_BYTE:
1030  c->lumToYV12 = palToY_c;
1031  break;
1032  case AV_PIX_FMT_MONOBLACK:
1033  c->lumToYV12 = monoblack2Y_c;
1034  break;
1035  case AV_PIX_FMT_MONOWHITE:
1036  c->lumToYV12 = monowhite2Y_c;
1037  break;
1038  case AV_PIX_FMT_RGB32:
1039  c->lumToYV12 = bgr32ToY_c;
1040  break;
1041  case AV_PIX_FMT_RGB32_1:
1042  c->lumToYV12 = bgr321ToY_c;
1043  break;
1044  case AV_PIX_FMT_BGR32:
1045  c->lumToYV12 = rgb32ToY_c;
1046  break;
1047  case AV_PIX_FMT_BGR32_1:
1048  c->lumToYV12 = rgb321ToY_c;
1049  break;
1050  case AV_PIX_FMT_RGB48BE:
1051  c->lumToYV12 = rgb48BEToY_c;
1052  break;
1053  case AV_PIX_FMT_RGB48LE:
1054  c->lumToYV12 = rgb48LEToY_c;
1055  break;
1056  case AV_PIX_FMT_BGR48BE:
1057  c->lumToYV12 = bgr48BEToY_c;
1058  break;
1059  case AV_PIX_FMT_BGR48LE:
1060  c->lumToYV12 = bgr48LEToY_c;
1061  break;
1062  }
1063  if (c->alpPixBuf) {
1064  switch (srcFormat) {
1065  case AV_PIX_FMT_BGRA:
1066  case AV_PIX_FMT_RGBA:
1067  c->alpToYV12 = rgbaToA_c;
1068  break;
1069  case AV_PIX_FMT_ABGR:
1070  case AV_PIX_FMT_ARGB:
1071  c->alpToYV12 = abgrToA_c;
1072  break;
1073  case AV_PIX_FMT_Y400A:
1074  c->alpToYV12 = uyvyToY_c;
1075  break;
1076  }
1077  }
1078 }