FFmpeg
yuv2rgb.c
Go to the documentation of this file.
1 /*
2  * software YUV to RGB converter
3  *
4  * Copyright (C) 2009 Konstantin Shishkov
5  *
6  * 1,4,8bpp support and context / deglobalize stuff
7  * by Michael Niedermayer (michaelni@gmx.at)
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <inttypes.h>
29 
30 #include "libavutil/cpu.h"
31 #include "libavutil/bswap.h"
32 #include "config.h"
33 #include "rgb2rgb.h"
34 #include "swscale.h"
35 #include "swscale_internal.h"
36 #include "libavutil/pixdesc.h"
37 
38 /* Color space conversion coefficients for YCbCr -> RGB mapping.
39  *
40  * Entries are {crv, cbu, cgu, cgv}
41  *
42  * crv = (255 / 224) * 65536 * (1 - cr) / 0.5
43  * cbu = (255 / 224) * 65536 * (1 - cb) / 0.5
44  * cgu = (255 / 224) * 65536 * (cb / cg) * (1 - cb) / 0.5
45  * cgv = (255 / 224) * 65536 * (cr / cg) * (1 - cr) / 0.5
46  *
47  * where Y = cr * R + cg * G + cb * B and cr + cg + cb = 1.
48  */
49 const int32_t ff_yuv2rgb_coeffs[11][4] = {
50  { 117489, 138438, 13975, 34925 }, /* no sequence_display_extension */
51  { 117489, 138438, 13975, 34925 }, /* ITU-R Rec. 709 (1990) */
52  { 104597, 132201, 25675, 53279 }, /* unspecified */
53  { 104597, 132201, 25675, 53279 }, /* reserved */
54  { 104448, 132798, 24759, 53109 }, /* FCC */
55  { 104597, 132201, 25675, 53279 }, /* ITU-R Rec. 624-4 System B, G */
56  { 104597, 132201, 25675, 53279 }, /* SMPTE 170M */
57  { 117579, 136230, 16907, 35559 }, /* SMPTE 240M (1987) */
58  { 0 }, /* YCgCo */
59  { 110013, 140363, 12277, 42626 }, /* Bt-2020-NCL */
60  { 110013, 140363, 12277, 42626 }, /* Bt-2020-CL */
61 };
62 
63 const int *sws_getCoefficients(int colorspace)
64 {
65  if (colorspace > 10 || colorspace < 0 || colorspace == 8)
66  colorspace = SWS_CS_DEFAULT;
67  return ff_yuv2rgb_coeffs[colorspace];
68 }
69 
70 #define LOADCHROMA(i) \
71  U = pu[i]; \
72  V = pv[i]; \
73  r = (void *)c->table_rV[V+YUVRGB_TABLE_HEADROOM]; \
74  g = (void *)(c->table_gU[U+YUVRGB_TABLE_HEADROOM] + c->table_gV[V+YUVRGB_TABLE_HEADROOM]); \
75  b = (void *)c->table_bU[U+YUVRGB_TABLE_HEADROOM];
76 
77 #define PUTRGB(dst, src, i) \
78  Y = src[2 * i]; \
79  dst[2 * i] = r[Y] + g[Y] + b[Y]; \
80  Y = src[2 * i + 1]; \
81  dst[2 * i + 1] = r[Y] + g[Y] + b[Y];
82 
83 #define PUTRGB24(dst, src, i) \
84  Y = src[2 * i]; \
85  dst[6 * i + 0] = r[Y]; \
86  dst[6 * i + 1] = g[Y]; \
87  dst[6 * i + 2] = b[Y]; \
88  Y = src[2 * i + 1]; \
89  dst[6 * i + 3] = r[Y]; \
90  dst[6 * i + 4] = g[Y]; \
91  dst[6 * i + 5] = b[Y];
92 
93 #define PUTBGR24(dst, src, i) \
94  Y = src[2 * i]; \
95  dst[6 * i + 0] = b[Y]; \
96  dst[6 * i + 1] = g[Y]; \
97  dst[6 * i + 2] = r[Y]; \
98  Y = src[2 * i + 1]; \
99  dst[6 * i + 3] = b[Y]; \
100  dst[6 * i + 4] = g[Y]; \
101  dst[6 * i + 5] = r[Y];
102 
103 #define PUTRGBA(dst, ysrc, asrc, i, s) \
104  Y = ysrc[2 * i]; \
105  dst[2 * i] = r[Y] + g[Y] + b[Y] + (asrc[2 * i] << s); \
106  Y = ysrc[2 * i + 1]; \
107  dst[2 * i + 1] = r[Y] + g[Y] + b[Y] + (asrc[2 * i + 1] << s);
108 
109 #define PUTRGB48(dst, src, i) \
110  Y = src[ 2 * i]; \
111  dst[12 * i + 0] = dst[12 * i + 1] = r[Y]; \
112  dst[12 * i + 2] = dst[12 * i + 3] = g[Y]; \
113  dst[12 * i + 4] = dst[12 * i + 5] = b[Y]; \
114  Y = src[ 2 * i + 1]; \
115  dst[12 * i + 6] = dst[12 * i + 7] = r[Y]; \
116  dst[12 * i + 8] = dst[12 * i + 9] = g[Y]; \
117  dst[12 * i + 10] = dst[12 * i + 11] = b[Y];
118 
119 #define PUTBGR48(dst, src, i) \
120  Y = src[2 * i]; \
121  dst[12 * i + 0] = dst[12 * i + 1] = b[Y]; \
122  dst[12 * i + 2] = dst[12 * i + 3] = g[Y]; \
123  dst[12 * i + 4] = dst[12 * i + 5] = r[Y]; \
124  Y = src[2 * i + 1]; \
125  dst[12 * i + 6] = dst[12 * i + 7] = b[Y]; \
126  dst[12 * i + 8] = dst[12 * i + 9] = g[Y]; \
127  dst[12 * i + 10] = dst[12 * i + 11] = r[Y];
128 
129 #define YUV2RGBFUNC(func_name, dst_type, alpha) \
130  static int func_name(SwsContext *c, const uint8_t *src[], \
131  int srcStride[], int srcSliceY, int srcSliceH, \
132  uint8_t *dst[], int dstStride[]) \
133  { \
134  int y; \
135  \
136  if (!alpha && c->srcFormat == AV_PIX_FMT_YUV422P) { \
137  srcStride[1] *= 2; \
138  srcStride[2] *= 2; \
139  } \
140  for (y = 0; y < srcSliceH; y += 2) { \
141  dst_type *dst_1 = \
142  (dst_type *)(dst[0] + (y + srcSliceY) * dstStride[0]); \
143  dst_type *dst_2 = \
144  (dst_type *)(dst[0] + (y + srcSliceY + 1) * dstStride[0]); \
145  dst_type av_unused *r, *g, *b; \
146  const uint8_t *py_1 = src[0] + y * srcStride[0]; \
147  const uint8_t *py_2 = py_1 + srcStride[0]; \
148  const uint8_t *pu = src[1] + (y >> 1) * srcStride[1]; \
149  const uint8_t *pv = src[2] + (y >> 1) * srcStride[2]; \
150  const uint8_t av_unused *pa_1, *pa_2; \
151  unsigned int h_size = c->dstW >> 3; \
152  if (alpha) { \
153  pa_1 = src[3] + y * srcStride[3]; \
154  pa_2 = pa_1 + srcStride[3]; \
155  } \
156  while (h_size--) { \
157  int av_unused U, V, Y; \
158 
159 #define ENDYUV2RGBLINE(dst_delta, ss) \
160  pu += 4 >> ss; \
161  pv += 4 >> ss; \
162  py_1 += 8 >> ss; \
163  py_2 += 8 >> ss; \
164  dst_1 += dst_delta >> ss; \
165  dst_2 += dst_delta >> ss; \
166  } \
167  if (c->dstW & (4 >> ss)) { \
168  int av_unused Y, U, V; \
169 
170 #define ENDYUV2RGBFUNC() \
171  } \
172  } \
173  return srcSliceH; \
174  }
175 
176 #define CLOSEYUV2RGBFUNC(dst_delta) \
177  ENDYUV2RGBLINE(dst_delta, 0) \
178  ENDYUV2RGBFUNC()
179 
180 YUV2RGBFUNC(yuv2rgb_c_48, uint8_t, 0)
181  LOADCHROMA(0);
182  PUTRGB48(dst_1, py_1, 0);
183  PUTRGB48(dst_2, py_2, 0);
184 
185  LOADCHROMA(1);
186  PUTRGB48(dst_2, py_2, 1);
187  PUTRGB48(dst_1, py_1, 1);
188 
189  LOADCHROMA(2);
190  PUTRGB48(dst_1, py_1, 2);
191  PUTRGB48(dst_2, py_2, 2);
192 
193  LOADCHROMA(3);
194  PUTRGB48(dst_2, py_2, 3);
195  PUTRGB48(dst_1, py_1, 3);
196 ENDYUV2RGBLINE(48, 0)
197  LOADCHROMA(0);
198  PUTRGB48(dst_1, py_1, 0);
199  PUTRGB48(dst_2, py_2, 0);
200 
201  LOADCHROMA(1);
202  PUTRGB48(dst_2, py_2, 1);
203  PUTRGB48(dst_1, py_1, 1);
204 ENDYUV2RGBLINE(48, 1)
205  LOADCHROMA(0);
206  PUTRGB48(dst_1, py_1, 0);
207  PUTRGB48(dst_2, py_2, 0);
209 
210 YUV2RGBFUNC(yuv2rgb_c_bgr48, uint8_t, 0)
211  LOADCHROMA(0);
212  PUTBGR48(dst_1, py_1, 0);
213  PUTBGR48(dst_2, py_2, 0);
214 
215  LOADCHROMA(1);
216  PUTBGR48(dst_2, py_2, 1);
217  PUTBGR48(dst_1, py_1, 1);
218 
219  LOADCHROMA(2);
220  PUTBGR48(dst_1, py_1, 2);
221  PUTBGR48(dst_2, py_2, 2);
222 
223  LOADCHROMA(3);
224  PUTBGR48(dst_2, py_2, 3);
225  PUTBGR48(dst_1, py_1, 3);
226 ENDYUV2RGBLINE(48, 0)
227  LOADCHROMA(0);
228  PUTBGR48(dst_1, py_1, 0);
229  PUTBGR48(dst_2, py_2, 0);
230 
231  LOADCHROMA(1);
232  PUTBGR48(dst_2, py_2, 1);
233  PUTBGR48(dst_1, py_1, 1);
234 ENDYUV2RGBLINE(48, 1)
235  LOADCHROMA(0);
236  PUTBGR48(dst_1, py_1, 0);
237  PUTBGR48(dst_2, py_2, 0);
239 
240 YUV2RGBFUNC(yuv2rgb_c_32, uint32_t, 0)
241  LOADCHROMA(0);
242  PUTRGB(dst_1, py_1, 0);
243  PUTRGB(dst_2, py_2, 0);
244 
245  LOADCHROMA(1);
246  PUTRGB(dst_2, py_2, 1);
247  PUTRGB(dst_1, py_1, 1);
248 
249  LOADCHROMA(2);
250  PUTRGB(dst_1, py_1, 2);
251  PUTRGB(dst_2, py_2, 2);
252 
253  LOADCHROMA(3);
254  PUTRGB(dst_2, py_2, 3);
255  PUTRGB(dst_1, py_1, 3);
256 ENDYUV2RGBLINE(8, 0)
257  LOADCHROMA(0);
258  PUTRGB(dst_1, py_1, 0);
259  PUTRGB(dst_2, py_2, 0);
260 
261  LOADCHROMA(1);
262  PUTRGB(dst_2, py_2, 1);
263  PUTRGB(dst_1, py_1, 1);
264 ENDYUV2RGBLINE(8, 1)
265  LOADCHROMA(0);
266  PUTRGB(dst_1, py_1, 0);
267  PUTRGB(dst_2, py_2, 0);
269 
270 #if HAVE_BIGENDIAN
271 YUV2RGBFUNC(yuva2argb_c, uint32_t, 1)
272 #else
273 YUV2RGBFUNC(yuva2rgba_c, uint32_t, 1)
274 #endif
275  LOADCHROMA(0);
276  PUTRGBA(dst_1, py_1, pa_1, 0, 24);
277  PUTRGBA(dst_2, py_2, pa_2, 0, 24);
278 
279  LOADCHROMA(1);
280  PUTRGBA(dst_2, py_2, pa_2, 1, 24);
281  PUTRGBA(dst_1, py_1, pa_1, 1, 24);
282 
283  LOADCHROMA(2);
284  PUTRGBA(dst_1, py_1, pa_1, 2, 24);
285  PUTRGBA(dst_2, py_2, pa_2, 2, 24);
286 
287  LOADCHROMA(3);
288  PUTRGBA(dst_2, py_2, pa_2, 3, 24);
289  PUTRGBA(dst_1, py_1, pa_1, 3, 24);
290  pa_1 += 8;
291  pa_2 += 8;
292 ENDYUV2RGBLINE(8, 0)
293  LOADCHROMA(0);
294  PUTRGBA(dst_1, py_1, pa_1, 0, 24);
295  PUTRGBA(dst_2, py_2, pa_2, 0, 24);
296 
297  LOADCHROMA(1);
298  PUTRGBA(dst_2, py_2, pa_2, 1, 24);
299  PUTRGBA(dst_1, py_1, pa_1, 1, 24);
300  pa_1 += 4;
301  pa_2 += 4;
302 ENDYUV2RGBLINE(8, 1)
303  LOADCHROMA(0);
304  PUTRGBA(dst_1, py_1, pa_1, 0, 24);
305  PUTRGBA(dst_2, py_2, pa_2, 0, 24);
307 
308 #if HAVE_BIGENDIAN
309 YUV2RGBFUNC(yuva2rgba_c, uint32_t, 1)
310 #else
311 YUV2RGBFUNC(yuva2argb_c, uint32_t, 1)
312 #endif
313  LOADCHROMA(0);
314  PUTRGBA(dst_1, py_1, pa_1, 0, 0);
315  PUTRGBA(dst_2, py_2, pa_2, 0, 0);
316 
317  LOADCHROMA(1);
318  PUTRGBA(dst_2, py_2, pa_2, 1, 0);
319  PUTRGBA(dst_1, py_1, pa_1, 1, 0);
320 
321  LOADCHROMA(2);
322  PUTRGBA(dst_1, py_1, pa_1, 2, 0);
323  PUTRGBA(dst_2, py_2, pa_2, 2, 0);
324 
325  LOADCHROMA(3);
326  PUTRGBA(dst_2, py_2, pa_2, 3, 0);
327  PUTRGBA(dst_1, py_1, pa_1, 3, 0);
328  pa_1 += 8;
329  pa_2 += 8;
330 ENDYUV2RGBLINE(8, 0)
331  LOADCHROMA(0);
332  PUTRGBA(dst_1, py_1, pa_1, 0, 0);
333  PUTRGBA(dst_2, py_2, pa_2, 0, 0);
334 
335  LOADCHROMA(1);
336  PUTRGBA(dst_2, py_2, pa_2, 1, 0);
337  PUTRGBA(dst_1, py_1, pa_1, 1, 0);
338  pa_1 += 4;
339  pa_2 += 4;
340 ENDYUV2RGBLINE(8, 1)
341  LOADCHROMA(0);
342  PUTRGBA(dst_1, py_1, pa_1, 0, 0);
343  PUTRGBA(dst_2, py_2, pa_2, 0, 0);
345 
346 YUV2RGBFUNC(yuv2rgb_c_24_rgb, uint8_t, 0)
347  LOADCHROMA(0);
348  PUTRGB24(dst_1, py_1, 0);
349  PUTRGB24(dst_2, py_2, 0);
350 
351  LOADCHROMA(1);
352  PUTRGB24(dst_2, py_2, 1);
353  PUTRGB24(dst_1, py_1, 1);
354 
355  LOADCHROMA(2);
356  PUTRGB24(dst_1, py_1, 2);
357  PUTRGB24(dst_2, py_2, 2);
358 
359  LOADCHROMA(3);
360  PUTRGB24(dst_2, py_2, 3);
361  PUTRGB24(dst_1, py_1, 3);
362 ENDYUV2RGBLINE(24, 0)
363  LOADCHROMA(0);
364  PUTRGB24(dst_1, py_1, 0);
365  PUTRGB24(dst_2, py_2, 0);
366 
367  LOADCHROMA(1);
368  PUTRGB24(dst_2, py_2, 1);
369  PUTRGB24(dst_1, py_1, 1);
370 ENDYUV2RGBLINE(24, 1)
371  LOADCHROMA(0);
372  PUTRGB24(dst_1, py_1, 0);
373  PUTRGB24(dst_2, py_2, 0);
375 
376 // only trivial mods from yuv2rgb_c_24_rgb
377 YUV2RGBFUNC(yuv2rgb_c_24_bgr, uint8_t, 0)
378  LOADCHROMA(0);
379  PUTBGR24(dst_1, py_1, 0);
380  PUTBGR24(dst_2, py_2, 0);
381 
382  LOADCHROMA(1);
383  PUTBGR24(dst_2, py_2, 1);
384  PUTBGR24(dst_1, py_1, 1);
385 
386  LOADCHROMA(2);
387  PUTBGR24(dst_1, py_1, 2);
388  PUTBGR24(dst_2, py_2, 2);
389 
390  LOADCHROMA(3);
391  PUTBGR24(dst_2, py_2, 3);
392  PUTBGR24(dst_1, py_1, 3);
393 ENDYUV2RGBLINE(24, 0)
394  LOADCHROMA(0);
395  PUTBGR24(dst_1, py_1, 0);
396  PUTBGR24(dst_2, py_2, 0);
397 
398  LOADCHROMA(1);
399  PUTBGR24(dst_2, py_2, 1);
400  PUTBGR24(dst_1, py_1, 1);
401 ENDYUV2RGBLINE(24, 1)
402  LOADCHROMA(0);
403  PUTBGR24(dst_1, py_1, 0);
404  PUTBGR24(dst_2, py_2, 0);
406 
407 YUV2RGBFUNC(yuv2rgb_c_16_ordered_dither, uint16_t, 0)
408  const uint8_t *d16 = ff_dither_2x2_8[y & 1];
409  const uint8_t *e16 = ff_dither_2x2_4[y & 1];
410  const uint8_t *f16 = ff_dither_2x2_8[(y & 1)^1];
411 
412 #define PUTRGB16(dst, src, i, o) \
413  Y = src[2 * i]; \
414  dst[2 * i] = r[Y + d16[0 + o]] + \
415  g[Y + e16[0 + o]] + \
416  b[Y + f16[0 + o]]; \
417  Y = src[2 * i + 1]; \
418  dst[2 * i + 1] = r[Y + d16[1 + o]] + \
419  g[Y + e16[1 + o]] + \
420  b[Y + f16[1 + o]];
421  LOADCHROMA(0);
422  PUTRGB16(dst_1, py_1, 0, 0);
423  PUTRGB16(dst_2, py_2, 0, 0 + 8);
424 
425  LOADCHROMA(1);
426  PUTRGB16(dst_2, py_2, 1, 2 + 8);
427  PUTRGB16(dst_1, py_1, 1, 2);
428 
429  LOADCHROMA(2);
430  PUTRGB16(dst_1, py_1, 2, 4);
431  PUTRGB16(dst_2, py_2, 2, 4 + 8);
432 
433  LOADCHROMA(3);
434  PUTRGB16(dst_2, py_2, 3, 6 + 8);
435  PUTRGB16(dst_1, py_1, 3, 6);
437 
438 YUV2RGBFUNC(yuv2rgb_c_15_ordered_dither, uint16_t, 0)
439  const uint8_t *d16 = ff_dither_2x2_8[y & 1];
440  const uint8_t *e16 = ff_dither_2x2_8[(y & 1)^1];
441 
442 #define PUTRGB15(dst, src, i, o) \
443  Y = src[2 * i]; \
444  dst[2 * i] = r[Y + d16[0 + o]] + \
445  g[Y + d16[1 + o]] + \
446  b[Y + e16[0 + o]]; \
447  Y = src[2 * i + 1]; \
448  dst[2 * i + 1] = r[Y + d16[1 + o]] + \
449  g[Y + d16[0 + o]] + \
450  b[Y + e16[1 + o]];
451  LOADCHROMA(0);
452  PUTRGB15(dst_1, py_1, 0, 0);
453  PUTRGB15(dst_2, py_2, 0, 0 + 8);
454 
455  LOADCHROMA(1);
456  PUTRGB15(dst_2, py_2, 1, 2 + 8);
457  PUTRGB15(dst_1, py_1, 1, 2);
458 
459  LOADCHROMA(2);
460  PUTRGB15(dst_1, py_1, 2, 4);
461  PUTRGB15(dst_2, py_2, 2, 4 + 8);
462 
463  LOADCHROMA(3);
464  PUTRGB15(dst_2, py_2, 3, 6 + 8);
465  PUTRGB15(dst_1, py_1, 3, 6);
467 
468 // r, g, b, dst_1, dst_2
469 YUV2RGBFUNC(yuv2rgb_c_12_ordered_dither, uint16_t, 0)
470  const uint8_t *d16 = ff_dither_4x4_16[y & 3];
471 
472 #define PUTRGB12(dst, src, i, o) \
473  Y = src[2 * i]; \
474  dst[2 * i] = r[Y + d16[0 + o]] + \
475  g[Y + d16[0 + o]] + \
476  b[Y + d16[0 + o]]; \
477  Y = src[2 * i + 1]; \
478  dst[2 * i + 1] = r[Y + d16[1 + o]] + \
479  g[Y + d16[1 + o]] + \
480  b[Y + d16[1 + o]];
481 
482  LOADCHROMA(0);
483  PUTRGB12(dst_1, py_1, 0, 0);
484  PUTRGB12(dst_2, py_2, 0, 0 + 8);
485 
486  LOADCHROMA(1);
487  PUTRGB12(dst_2, py_2, 1, 2 + 8);
488  PUTRGB12(dst_1, py_1, 1, 2);
489 
490  LOADCHROMA(2);
491  PUTRGB12(dst_1, py_1, 2, 4);
492  PUTRGB12(dst_2, py_2, 2, 4 + 8);
493 
494  LOADCHROMA(3);
495  PUTRGB12(dst_2, py_2, 3, 6 + 8);
496  PUTRGB12(dst_1, py_1, 3, 6);
498 
499 // r, g, b, dst_1, dst_2
500 YUV2RGBFUNC(yuv2rgb_c_8_ordered_dither, uint8_t, 0)
501  const uint8_t *d32 = ff_dither_8x8_32[y & 7];
502  const uint8_t *d64 = ff_dither_8x8_73[y & 7];
503 
504 #define PUTRGB8(dst, src, i, o) \
505  Y = src[2 * i]; \
506  dst[2 * i] = r[Y + d32[0 + o]] + \
507  g[Y + d32[0 + o]] + \
508  b[Y + d64[0 + o]]; \
509  Y = src[2 * i + 1]; \
510  dst[2 * i + 1] = r[Y + d32[1 + o]] + \
511  g[Y + d32[1 + o]] + \
512  b[Y + d64[1 + o]];
513 
514  LOADCHROMA(0);
515  PUTRGB8(dst_1, py_1, 0, 0);
516  PUTRGB8(dst_2, py_2, 0, 0 + 8);
517 
518  LOADCHROMA(1);
519  PUTRGB8(dst_2, py_2, 1, 2 + 8);
520  PUTRGB8(dst_1, py_1, 1, 2);
521 
522  LOADCHROMA(2);
523  PUTRGB8(dst_1, py_1, 2, 4);
524  PUTRGB8(dst_2, py_2, 2, 4 + 8);
525 
526  LOADCHROMA(3);
527  PUTRGB8(dst_2, py_2, 3, 6 + 8);
528  PUTRGB8(dst_1, py_1, 3, 6);
529 
530 ENDYUV2RGBLINE(8, 0)
531  const uint8_t *d32 = ff_dither_8x8_32[y & 7];
532  const uint8_t *d64 = ff_dither_8x8_73[y & 7];
533  LOADCHROMA(0);
534  PUTRGB8(dst_1, py_1, 0, 0);
535  PUTRGB8(dst_2, py_2, 0, 0 + 8);
536 
537  LOADCHROMA(1);
538  PUTRGB8(dst_2, py_2, 1, 2 + 8);
539  PUTRGB8(dst_1, py_1, 1, 2);
540 
541 ENDYUV2RGBLINE(8, 1)
542  const uint8_t *d32 = ff_dither_8x8_32[y & 7];
543  const uint8_t *d64 = ff_dither_8x8_73[y & 7];
544  LOADCHROMA(0);
545  PUTRGB8(dst_1, py_1, 0, 0);
546  PUTRGB8(dst_2, py_2, 0, 0 + 8);
547 
549 
550 
551 YUV2RGBFUNC(yuv2rgb_c_4_ordered_dither, uint8_t, 0)
552  const uint8_t * d64 = ff_dither_8x8_73[y & 7];
553  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
554  int acc;
555 
556 #define PUTRGB4D(dst, src, i, o) \
557  Y = src[2 * i]; \
558  acc = r[Y + d128[0 + o]] + \
559  g[Y + d64[0 + o]] + \
560  b[Y + d128[0 + o]]; \
561  Y = src[2 * i + 1]; \
562  acc |= (r[Y + d128[1 + o]] + \
563  g[Y + d64[1 + o]] + \
564  b[Y + d128[1 + o]]) << 4; \
565  dst[i] = acc;
566 
567  LOADCHROMA(0);
568  PUTRGB4D(dst_1, py_1, 0, 0);
569  PUTRGB4D(dst_2, py_2, 0, 0 + 8);
570 
571  LOADCHROMA(1);
572  PUTRGB4D(dst_2, py_2, 1, 2 + 8);
573  PUTRGB4D(dst_1, py_1, 1, 2);
574 
575  LOADCHROMA(2);
576  PUTRGB4D(dst_1, py_1, 2, 4);
577  PUTRGB4D(dst_2, py_2, 2, 4 + 8);
578 
579  LOADCHROMA(3);
580  PUTRGB4D(dst_2, py_2, 3, 6 + 8);
581  PUTRGB4D(dst_1, py_1, 3, 6);
582 
583 ENDYUV2RGBLINE(4, 0)
584  const uint8_t * d64 = ff_dither_8x8_73[y & 7];
585  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
586  int acc;
587  LOADCHROMA(0);
588  PUTRGB4D(dst_1, py_1, 0, 0);
589  PUTRGB4D(dst_2, py_2, 0, 0 + 8);
590 
591  LOADCHROMA(1);
592  PUTRGB4D(dst_2, py_2, 1, 2 + 8);
593  PUTRGB4D(dst_1, py_1, 1, 2);
594 
595 ENDYUV2RGBLINE(4, 1)
596  const uint8_t * d64 = ff_dither_8x8_73[y & 7];
597  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
598  int acc;
599  LOADCHROMA(0);
600  PUTRGB4D(dst_1, py_1, 0, 0);
601  PUTRGB4D(dst_2, py_2, 0, 0 + 8);
603 
604 YUV2RGBFUNC(yuv2rgb_c_4b_ordered_dither, uint8_t, 0)
605  const uint8_t *d64 = ff_dither_8x8_73[y & 7];
606  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
607 
608 #define PUTRGB4DB(dst, src, i, o) \
609  Y = src[2 * i]; \
610  dst[2 * i] = r[Y + d128[0 + o]] + \
611  g[Y + d64[0 + o]] + \
612  b[Y + d128[0 + o]]; \
613  Y = src[2 * i + 1]; \
614  dst[2 * i + 1] = r[Y + d128[1 + o]] + \
615  g[Y + d64[1 + o]] + \
616  b[Y + d128[1 + o]];
617 
618  LOADCHROMA(0);
619  PUTRGB4DB(dst_1, py_1, 0, 0);
620  PUTRGB4DB(dst_2, py_2, 0, 0 + 8);
621 
622  LOADCHROMA(1);
623  PUTRGB4DB(dst_2, py_2, 1, 2 + 8);
624  PUTRGB4DB(dst_1, py_1, 1, 2);
625 
626  LOADCHROMA(2);
627  PUTRGB4DB(dst_1, py_1, 2, 4);
628  PUTRGB4DB(dst_2, py_2, 2, 4 + 8);
629 
630  LOADCHROMA(3);
631  PUTRGB4DB(dst_2, py_2, 3, 6 + 8);
632  PUTRGB4DB(dst_1, py_1, 3, 6);
633 ENDYUV2RGBLINE(8, 0)
634  const uint8_t *d64 = ff_dither_8x8_73[y & 7];
635  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
636  LOADCHROMA(0);
637  PUTRGB4DB(dst_1, py_1, 0, 0);
638  PUTRGB4DB(dst_2, py_2, 0, 0 + 8);
639 
640  LOADCHROMA(1);
641  PUTRGB4DB(dst_2, py_2, 1, 2 + 8);
642  PUTRGB4DB(dst_1, py_1, 1, 2);
643 ENDYUV2RGBLINE(8, 1)
644  const uint8_t *d64 = ff_dither_8x8_73[y & 7];
645  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
646  LOADCHROMA(0);
647  PUTRGB4DB(dst_1, py_1, 0, 0);
648  PUTRGB4DB(dst_2, py_2, 0, 0 + 8);
650 
651 YUV2RGBFUNC(yuv2rgb_c_1_ordered_dither, uint8_t, 0)
652  const uint8_t *d128 = ff_dither_8x8_220[y & 7];
653  char out_1 = 0, out_2 = 0;
654  g = c->table_gU[128 + YUVRGB_TABLE_HEADROOM] + c->table_gV[128 + YUVRGB_TABLE_HEADROOM];
655 
656 #define PUTRGB1(out, src, i, o) \
657  Y = src[2 * i]; \
658  out += out + g[Y + d128[0 + o]]; \
659  Y = src[2 * i + 1]; \
660  out += out + g[Y + d128[1 + o]];
661 
662  PUTRGB1(out_1, py_1, 0, 0);
663  PUTRGB1(out_2, py_2, 0, 0 + 8);
664 
665  PUTRGB1(out_2, py_2, 1, 2 + 8);
666  PUTRGB1(out_1, py_1, 1, 2);
667 
668  PUTRGB1(out_1, py_1, 2, 4);
669  PUTRGB1(out_2, py_2, 2, 4 + 8);
670 
671  PUTRGB1(out_2, py_2, 3, 6 + 8);
672  PUTRGB1(out_1, py_1, 3, 6);
673 
674  dst_1[0] = out_1;
675  dst_2[0] = out_2;
677 
679 {
680  SwsFunc t = NULL;
681 
682  if (ARCH_PPC)
683  t = ff_yuv2rgb_init_ppc(c);
684  if (ARCH_X86)
685  t = ff_yuv2rgb_init_x86(c);
686 
687  if (t)
688  return t;
689 
691  "No accelerated colorspace conversion found from %s to %s.\n",
692  av_get_pix_fmt_name(c->srcFormat), av_get_pix_fmt_name(c->dstFormat));
693 
694  switch (c->dstFormat) {
695  case AV_PIX_FMT_BGR48BE:
696  case AV_PIX_FMT_BGR48LE:
697  return yuv2rgb_c_bgr48;
698  case AV_PIX_FMT_RGB48BE:
699  case AV_PIX_FMT_RGB48LE:
700  return yuv2rgb_c_48;
701  case AV_PIX_FMT_ARGB:
702  case AV_PIX_FMT_ABGR:
703  if (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat))
704  return yuva2argb_c;
705  case AV_PIX_FMT_RGBA:
706  case AV_PIX_FMT_BGRA:
707  return (CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat)) ? yuva2rgba_c : yuv2rgb_c_32;
708  case AV_PIX_FMT_RGB24:
709  return yuv2rgb_c_24_rgb;
710  case AV_PIX_FMT_BGR24:
711  return yuv2rgb_c_24_bgr;
712  case AV_PIX_FMT_RGB565:
713  case AV_PIX_FMT_BGR565:
714  return yuv2rgb_c_16_ordered_dither;
715  case AV_PIX_FMT_RGB555:
716  case AV_PIX_FMT_BGR555:
717  return yuv2rgb_c_15_ordered_dither;
718  case AV_PIX_FMT_RGB444:
719  case AV_PIX_FMT_BGR444:
720  return yuv2rgb_c_12_ordered_dither;
721  case AV_PIX_FMT_RGB8:
722  case AV_PIX_FMT_BGR8:
723  return yuv2rgb_c_8_ordered_dither;
724  case AV_PIX_FMT_RGB4:
725  case AV_PIX_FMT_BGR4:
726  return yuv2rgb_c_4_ordered_dither;
729  return yuv2rgb_c_4b_ordered_dither;
731  return yuv2rgb_c_1_ordered_dither;
732  }
733  return NULL;
734 }
735 
736 static void fill_table(uint8_t* table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize,
737  const int64_t inc, void *y_tab)
738 {
739  int i;
740  uint8_t *y_table = y_tab;
741 
742  y_table -= elemsize * (inc >> 9);
743 
744  for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
745  int64_t cb = av_clip_uint8(i-YUVRGB_TABLE_HEADROOM)*inc;
746  table[i] = y_table + elemsize * (cb >> 16);
747  }
748 }
749 
750 static void fill_gv_table(int table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize, const int64_t inc)
751 {
752  int i;
753  int off = -(inc >> 9);
754 
755  for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
756  int64_t cb = av_clip_uint8(i-YUVRGB_TABLE_HEADROOM)*inc;
757  table[i] = elemsize * (off + (cb >> 16));
758  }
759 }
760 
761 static uint16_t roundToInt16(int64_t f)
762 {
763  int r = (f + (1 << 15)) >> 16;
764 
765  if (r < -0x7FFF)
766  return 0x8000;
767  else if (r > 0x7FFF)
768  return 0x7FFF;
769  else
770  return r;
771 }
772 
773 av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4],
774  int fullRange, int brightness,
775  int contrast, int saturation)
776 {
777  const int isRgb = c->dstFormat == AV_PIX_FMT_RGB32 ||
779  c->dstFormat == AV_PIX_FMT_BGR24 ||
786  c->dstFormat == AV_PIX_FMT_RGB8 ||
787  c->dstFormat == AV_PIX_FMT_RGB4 ||
790  const int isNotNe = c->dstFormat == AV_PIX_FMT_NE(RGB565LE, RGB565BE) ||
791  c->dstFormat == AV_PIX_FMT_NE(RGB555LE, RGB555BE) ||
792  c->dstFormat == AV_PIX_FMT_NE(RGB444LE, RGB444BE) ||
793  c->dstFormat == AV_PIX_FMT_NE(BGR565LE, BGR565BE) ||
794  c->dstFormat == AV_PIX_FMT_NE(BGR555LE, BGR555BE) ||
795  c->dstFormat == AV_PIX_FMT_NE(BGR444LE, BGR444BE);
796  const int bpp = c->dstFormatBpp;
797  uint8_t *y_table;
798  uint16_t *y_table16;
799  uint32_t *y_table32;
800  int i, base, rbase, gbase, bbase, av_uninit(abase), needAlpha;
801  const int yoffs = (fullRange ? 384 : 326) + YUVRGB_TABLE_LUMA_HEADROOM;
802  const int table_plane_size = 1024 + 2*YUVRGB_TABLE_LUMA_HEADROOM;
803 
804  int64_t crv = inv_table[0];
805  int64_t cbu = inv_table[1];
806  int64_t cgu = -inv_table[2];
807  int64_t cgv = -inv_table[3];
808  int64_t cy = 1 << 16;
809  int64_t oy = 0;
810  int64_t yb = 0;
811 
812  if (!fullRange) {
813  cy = (cy * 255) / 219;
814  oy = 16 << 16;
815  } else {
816  crv = (crv * 224) / 255;
817  cbu = (cbu * 224) / 255;
818  cgu = (cgu * 224) / 255;
819  cgv = (cgv * 224) / 255;
820  }
821 
822  cy = (cy * contrast) >> 16;
823  crv = (crv * contrast * saturation) >> 32;
824  cbu = (cbu * contrast * saturation) >> 32;
825  cgu = (cgu * contrast * saturation) >> 32;
826  cgv = (cgv * contrast * saturation) >> 32;
827  oy -= 256 * brightness;
828 
829  c->uOffset = 0x0400040004000400LL;
830  c->vOffset = 0x0400040004000400LL;
831  c->yCoeff = roundToInt16(cy * (1 << 13)) * 0x0001000100010001ULL;
832  c->vrCoeff = roundToInt16(crv * (1 << 13)) * 0x0001000100010001ULL;
833  c->ubCoeff = roundToInt16(cbu * (1 << 13)) * 0x0001000100010001ULL;
834  c->vgCoeff = roundToInt16(cgv * (1 << 13)) * 0x0001000100010001ULL;
835  c->ugCoeff = roundToInt16(cgu * (1 << 13)) * 0x0001000100010001ULL;
836  c->yOffset = roundToInt16(oy * (1 << 3)) * 0x0001000100010001ULL;
837 
838  c->yuv2rgb_y_coeff = (int16_t)roundToInt16(cy * (1 << 13));
839  c->yuv2rgb_y_offset = (int16_t)roundToInt16(oy * (1 << 9));
840  c->yuv2rgb_v2r_coeff = (int16_t)roundToInt16(crv * (1 << 13));
841  c->yuv2rgb_v2g_coeff = (int16_t)roundToInt16(cgv * (1 << 13));
842  c->yuv2rgb_u2g_coeff = (int16_t)roundToInt16(cgu * (1 << 13));
843  c->yuv2rgb_u2b_coeff = (int16_t)roundToInt16(cbu * (1 << 13));
844 
845  //scale coefficients by cy
846  crv = ((crv * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
847  cbu = ((cbu * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
848  cgu = ((cgu * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
849  cgv = ((cgv * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
850 
851  av_freep(&c->yuvTable);
852 
853 #define ALLOC_YUV_TABLE(x) \
854  c->yuvTable = av_malloc(x); \
855  if (!c->yuvTable) \
856  return AVERROR(ENOMEM);
857  switch (bpp) {
858  case 1:
859  ALLOC_YUV_TABLE(table_plane_size);
860  y_table = c->yuvTable;
861  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
862  for (i = 0; i < table_plane_size - 110; i++) {
863  y_table[i + 110] = av_clip_uint8((yb + 0x8000) >> 16) >> 7;
864  yb += cy;
865  }
866  fill_table(c->table_gU, 1, cgu, y_table + yoffs);
867  fill_gv_table(c->table_gV, 1, cgv);
868  break;
869  case 4:
870  case 4 | 128:
871  rbase = isRgb ? 3 : 0;
872  gbase = 1;
873  bbase = isRgb ? 0 : 3;
874  ALLOC_YUV_TABLE(table_plane_size * 3);
875  y_table = c->yuvTable;
876  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
877  for (i = 0; i < table_plane_size - 110; i++) {
878  int yval = av_clip_uint8((yb + 0x8000) >> 16);
879  y_table[i + 110] = (yval >> 7) << rbase;
880  y_table[i + 37 + table_plane_size] = ((yval + 43) / 85) << gbase;
881  y_table[i + 110 + 2*table_plane_size] = (yval >> 7) << bbase;
882  yb += cy;
883  }
884  fill_table(c->table_rV, 1, crv, y_table + yoffs);
885  fill_table(c->table_gU, 1, cgu, y_table + yoffs + table_plane_size);
886  fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2*table_plane_size);
887  fill_gv_table(c->table_gV, 1, cgv);
888  break;
889  case 8:
890  rbase = isRgb ? 5 : 0;
891  gbase = isRgb ? 2 : 3;
892  bbase = isRgb ? 0 : 6;
893  ALLOC_YUV_TABLE(table_plane_size * 3);
894  y_table = c->yuvTable;
895  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
896  for (i = 0; i < table_plane_size - 38; i++) {
897  int yval = av_clip_uint8((yb + 0x8000) >> 16);
898  y_table[i + 16] = ((yval + 18) / 36) << rbase;
899  y_table[i + 16 + table_plane_size] = ((yval + 18) / 36) << gbase;
900  y_table[i + 37 + 2*table_plane_size] = ((yval + 43) / 85) << bbase;
901  yb += cy;
902  }
903  fill_table(c->table_rV, 1, crv, y_table + yoffs);
904  fill_table(c->table_gU, 1, cgu, y_table + yoffs + table_plane_size);
905  fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2*table_plane_size);
906  fill_gv_table(c->table_gV, 1, cgv);
907  break;
908  case 12:
909  rbase = isRgb ? 8 : 0;
910  gbase = 4;
911  bbase = isRgb ? 0 : 8;
912  ALLOC_YUV_TABLE(table_plane_size * 3 * 2);
913  y_table16 = c->yuvTable;
914  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
915  for (i = 0; i < table_plane_size; i++) {
916  uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
917  y_table16[i] = (yval >> 4) << rbase;
918  y_table16[i + table_plane_size] = (yval >> 4) << gbase;
919  y_table16[i + 2*table_plane_size] = (yval >> 4) << bbase;
920  yb += cy;
921  }
922  if (isNotNe)
923  for (i = 0; i < table_plane_size * 3; i++)
924  y_table16[i] = av_bswap16(y_table16[i]);
925  fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
926  fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + table_plane_size);
927  fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2*table_plane_size);
928  fill_gv_table(c->table_gV, 2, cgv);
929  break;
930  case 15:
931  case 16:
932  rbase = isRgb ? bpp - 5 : 0;
933  gbase = 5;
934  bbase = isRgb ? 0 : (bpp - 5);
935  ALLOC_YUV_TABLE(table_plane_size * 3 * 2);
936  y_table16 = c->yuvTable;
937  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
938  for (i = 0; i < table_plane_size; i++) {
939  uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
940  y_table16[i] = (yval >> 3) << rbase;
941  y_table16[i + table_plane_size] = (yval >> (18 - bpp)) << gbase;
942  y_table16[i + 2*table_plane_size] = (yval >> 3) << bbase;
943  yb += cy;
944  }
945  if (isNotNe)
946  for (i = 0; i < table_plane_size * 3; i++)
947  y_table16[i] = av_bswap16(y_table16[i]);
948  fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
949  fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + table_plane_size);
950  fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2*table_plane_size);
951  fill_gv_table(c->table_gV, 2, cgv);
952  break;
953  case 24:
954  case 48:
955  ALLOC_YUV_TABLE(table_plane_size);
956  y_table = c->yuvTable;
957  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
958  for (i = 0; i < table_plane_size; i++) {
959  y_table[i] = av_clip_uint8((yb + 0x8000) >> 16);
960  yb += cy;
961  }
962  fill_table(c->table_rV, 1, crv, y_table + yoffs);
963  fill_table(c->table_gU, 1, cgu, y_table + yoffs);
964  fill_table(c->table_bU, 1, cbu, y_table + yoffs);
965  fill_gv_table(c->table_gV, 1, cgv);
966  break;
967  case 32:
968  case 64:
969  base = (c->dstFormat == AV_PIX_FMT_RGB32_1 ||
970  c->dstFormat == AV_PIX_FMT_BGR32_1) ? 8 : 0;
971  rbase = base + (isRgb ? 16 : 0);
972  gbase = base + 8;
973  bbase = base + (isRgb ? 0 : 16);
974  needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->srcFormat);
975  if (!needAlpha)
976  abase = (base + 24) & 31;
977  ALLOC_YUV_TABLE(table_plane_size * 3 * 4);
978  y_table32 = c->yuvTable;
979  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
980  for (i = 0; i < table_plane_size; i++) {
981  unsigned yval = av_clip_uint8((yb + 0x8000) >> 16);
982  y_table32[i] = (yval << rbase) +
983  (needAlpha ? 0 : (255u << abase));
984  y_table32[i + table_plane_size] = yval << gbase;
985  y_table32[i + 2*table_plane_size] = yval << bbase;
986  yb += cy;
987  }
988  fill_table(c->table_rV, 4, crv, y_table32 + yoffs);
989  fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + table_plane_size);
990  fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2*table_plane_size);
991  fill_gv_table(c->table_gV, 4, cgv);
992  break;
993  default:
994  if(!isPlanar(c->dstFormat) || bpp <= 24)
995  av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);
996  return AVERROR(EINVAL);
997  }
998  return 0;
999 }
uint64_t vrCoeff
dst_1[0]
Definition: yuv2rgb.c:674
#define NULL
Definition: coverity.c:32
char out_2
Definition: yuv2rgb.c:653
#define YUVRGB_TABLE_HEADROOM
pa_1
Definition: yuv2rgb.c:290
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:84
const uint8_t * e16
Definition: yuv2rgb.c:409
int acc
Definition: yuv2rgb.c:554
const uint8_t ff_dither_2x2_8[][8]
Definition: output.c:45
av_cold SwsFunc ff_yuv2rgb_init_x86(SwsContext *c)
Definition: yuv2rgb.c:72
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:108
uint8_t * table_bU[256+2 *YUVRGB_TABLE_HEADROOM]
#define av_bswap16
Definition: bswap.h:31
int dstFormatBpp
Number of bits per pixel of the destination pixel format.
#define ALLOC_YUV_TABLE(x)
#define PUTRGB15(dst, src, i, o)
Definition: yuv2rgb.c:442
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:140
#define PUTBGR24(dst, src, i)
Definition: yuv2rgb.c:93
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:376
const uint8_t ff_dither_8x8_220[][8]
Definition: output.c:84
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:87
uint64_t ubCoeff
uint8_t base
Definition: vp3data.h:202
static void fill_table(uint8_t *table[256+2 *YUVRGB_TABLE_HEADROOM], const int elemsize, const int64_t inc, void *y_tab)
Definition: yuv2rgb.c:736
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:85
const uint8_t ff_dither_8x8_32[][8]
Definition: output.c:59
#define PUTRGB(dst, src, i)
Definition: yuv2rgb.c:77
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:112
const uint8_t ff_dither_2x2_4[][8]
Definition: output.c:39
uint8_t
#define av_cold
Definition: attributes.h:82
const uint8_t ff_dither_4x4_16[][8]
Definition: output.c:51
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
#define f(width, name)
Definition: cbs_vp9.c:255
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static void fill_gv_table(int table[256+2 *YUVRGB_TABLE_HEADROOM], const int elemsize, const int64_t inc)
Definition: yuv2rgb.c:750
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:139
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:105
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:94
#define PUTRGB16(dst, src, i, o)
Definition: yuv2rgb.c:412
uint64_t yOffset
external API header
enum AVPixelFormat dstFormat
Destination pixel format.
#define isALPHA(x)
Definition: swscale.c:51
uint8_t * table_gU[256+2 *YUVRGB_TABLE_HEADROOM]
#define PUTRGBA(dst, ysrc, asrc, i, s)
Definition: yuv2rgb.c:103
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:363
#define AV_PIX_FMT_NE(be, le)
Definition: pixfmt.h:357
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:49
#define PUTBGR48(dst, src, i)
Definition: yuv2rgb.c:119
const uint8_t * d64
Definition: yuv2rgb.c:502
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
const char * r
Definition: vf_curves.c:114
g
Definition: yuv2rgb.c:654
#define YUVRGB_TABLE_LUMA_HEADROOM
#define ENDYUV2RGBFUNC()
Definition: yuv2rgb.c:170
uint64_t ugCoeff
#define SWS_CS_DEFAULT
Definition: swscale.h:95
#define FFMAX(a, b)
Definition: common.h:94
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:92
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:149
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
#define YUV2RGBFUNC(func_name, dst_type, alpha)
Definition: yuv2rgb.c:129
static uint16_t roundToInt16(int64_t f)
Definition: yuv2rgb.c:761
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:88
uint64_t vgCoeff
uint64_t uOffset
int32_t
int table_gV[256+2 *YUVRGB_TABLE_HEADROOM]
const int * sws_getCoefficients(int colorspace)
Return a pointer to yuv<->rgb coefficients for the given colorspace suitable for sws_setColorspaceDet...
Definition: yuv2rgb.c:63
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
uint8_t * table_rV[256+2 *YUVRGB_TABLE_HEADROOM]
#define PUTRGB4D(dst, src, i, o)
Definition: yuv2rgb.c:556
packed RGB 16:16:16, 48bpp, 16B, 16G, 16R, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:148
av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
Definition: yuv2rgb.c:773
int(* SwsFunc)(struct SwsContext *context, const uint8_t *src[], int srcStride[], int srcSliceY, int srcSliceH, uint8_t *dst[], int dstStride[])
const uint8_t * d16
Definition: yuv2rgb.c:408
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:380
const uint8_t * f16
Definition: yuv2rgb.c:410
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
#define CLOSEYUV2RGBFUNC(dst_delta)
Definition: yuv2rgb.c:176
SwsFunc ff_yuv2rgb_get_func_ptr(SwsContext *c)
Definition: yuv2rgb.c:678
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
#define PUTRGB12(dst, src, i, o)
Definition: yuv2rgb.c:472
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:360
const uint8_t ff_dither_8x8_73[][8]
Definition: output.c:71
byte swapping routines
const uint8_t * d32
Definition: yuv2rgb.c:501
#define ENDYUV2RGBLINE(dst_delta, ss)
Definition: yuv2rgb.c:159
pa_2
Definition: yuv2rgb.c:291
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:379
av_cold SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c)
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
#define PUTRGB48(dst, src, i)
Definition: yuv2rgb.c:109
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:76
#define PUTRGB4DB(dst, src, i, o)
Definition: yuv2rgb.c:608
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
Definition: pixfmt.h:102
#define PUTRGB8(dst, src, i, o)
Definition: yuv2rgb.c:504
#define AV_PIX_FMT_BGR444
Definition: pixfmt.h:381
enum AVPixelFormat srcFormat
Source pixel format.
const uint8_t * d128
Definition: yuv2rgb.c:553
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
Definition: pixfmt.h:86
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:375
#define PUTRGB1(out, src, i, o)
Definition: yuv2rgb.c:656
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:361
char out_1
Definition: yuv2rgb.c:653
uint64_t yCoeff
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:374
#define LOADCHROMA(i)
Definition: yuv2rgb.c:70
#define av_uninit(x)
Definition: attributes.h:148
#define av_freep(p)
dst_2[0]
Definition: yuv2rgb.c:675
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2438
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint64_t vOffset
#define PUTRGB24(dst, src, i)
Definition: yuv2rgb.c:83