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 <stddef.h>
27 #include <stdint.h>
28 
29 #include "libavutil/bswap.h"
30 #include "libavutil/mem.h"
31 #include "config.h"
32 #include "swscale.h"
33 #include "swscale_internal.h"
34 #include "libavutil/pixdesc.h"
35 
36 /* Color space conversion coefficients for YCbCr -> RGB mapping.
37  *
38  * Entries are {crv, cbu, cgu, cgv}
39  *
40  * crv = (255 / 224) * 65536 * (1 - cr) / 0.5
41  * cbu = (255 / 224) * 65536 * (1 - cb) / 0.5
42  * cgu = (255 / 224) * 65536 * (cb / cg) * (1 - cb) / 0.5
43  * cgv = (255 / 224) * 65536 * (cr / cg) * (1 - cr) / 0.5
44  *
45  * where Y = cr * R + cg * G + cb * B and cr + cg + cb = 1.
46  */
47 const int32_t ff_yuv2rgb_coeffs[11][4] = {
48  { 104597, 132201, 25675, 53279 }, /* no sequence_display_extension */
49  { 117489, 138438, 13975, 34925 }, /* ITU-R Rec. 709 (1990) */
50  { 104597, 132201, 25675, 53279 }, /* unspecified */
51  { 104597, 132201, 25675, 53279 }, /* reserved */
52  { 104448, 132798, 24759, 53109 }, /* FCC */
53  { 104597, 132201, 25675, 53279 }, /* ITU-R Rec. 624-4 System B, G */
54  { 104597, 132201, 25675, 53279 }, /* SMPTE 170M */
55  { 117579, 136230, 16907, 35559 }, /* SMPTE 240M (1987) */
56  { 0 }, /* YCgCo */
57  { 110013, 140363, 12277, 42626 }, /* Bt-2020-NCL */
58  { 110013, 140363, 12277, 42626 }, /* Bt-2020-CL */
59 };
60 
61 const int *sws_getCoefficients(int colorspace)
62 {
63  if (colorspace > 10 || colorspace < 0 || colorspace == 8)
64  colorspace = SWS_CS_DEFAULT;
65  return ff_yuv2rgb_coeffs[colorspace];
66 }
67 
68 #define LOADCHROMA(l, i) \
69  U = pu_##l[i]; \
70  V = pv_##l[i]; \
71  r = (void *)c->table_rV[V+YUVRGB_TABLE_HEADROOM]; \
72  g = (void *)(c->table_gU[U+YUVRGB_TABLE_HEADROOM] + c->table_gV[V+YUVRGB_TABLE_HEADROOM]); \
73  b = (void *)c->table_bU[U+YUVRGB_TABLE_HEADROOM];
74 
75 #define PUTRGB(l, i, abase) \
76  Y = py_##l[2 * i]; \
77  dst_##l[2 * i] = r[Y] + g[Y] + b[Y]; \
78  Y = py_##l[2 * i + 1]; \
79  dst_##l[2 * i + 1] = r[Y] + g[Y] + b[Y];
80 
81 #define PUTRGB24(l, i, abase) \
82  Y = py_##l[2 * i]; \
83  dst_##l[6 * i + 0] = r[Y]; \
84  dst_##l[6 * i + 1] = g[Y]; \
85  dst_##l[6 * i + 2] = b[Y]; \
86  Y = py_##l[2 * i + 1]; \
87  dst_##l[6 * i + 3] = r[Y]; \
88  dst_##l[6 * i + 4] = g[Y]; \
89  dst_##l[6 * i + 5] = b[Y];
90 
91 #define PUTBGR24(l, i, abase) \
92  Y = py_##l[2 * i]; \
93  dst_##l[6 * i + 0] = b[Y]; \
94  dst_##l[6 * i + 1] = g[Y]; \
95  dst_##l[6 * i + 2] = r[Y]; \
96  Y = py_##l[2 * i + 1]; \
97  dst_##l[6 * i + 3] = b[Y]; \
98  dst_##l[6 * i + 4] = g[Y]; \
99  dst_##l[6 * i + 5] = r[Y];
100 
101 #define PUTRGBA(l, i, abase) \
102  Y = py_##l[2 * i]; \
103  dst_##l[2 * i] = r[Y] + g[Y] + b[Y] + ((uint32_t)(pa_##l[2 * i]) << abase); \
104  Y = py_##l[2 * i + 1]; \
105  dst_##l[2 * i + 1] = r[Y] + g[Y] + b[Y] + ((uint32_t)(pa_##l[2 * i + 1]) << abase);
106 
107 #define PUTRGB48(l, i, abase) \
108  Y = py_##l[ 2 * i]; \
109  dst_##l[12 * i + 0] = dst_##l[12 * i + 1] = r[Y]; \
110  dst_##l[12 * i + 2] = dst_##l[12 * i + 3] = g[Y]; \
111  dst_##l[12 * i + 4] = dst_##l[12 * i + 5] = b[Y]; \
112  Y = py_##l[ 2 * i + 1]; \
113  dst_##l[12 * i + 6] = dst_##l[12 * i + 7] = r[Y]; \
114  dst_##l[12 * i + 8] = dst_##l[12 * i + 9] = g[Y]; \
115  dst_##l[12 * i + 10] = dst_##l[12 * i + 11] = b[Y];
116 
117 #define PUTBGR48(l, i, abase) \
118  Y = py_##l[2 * i]; \
119  dst_##l[12 * i + 0] = dst_##l[12 * i + 1] = b[Y]; \
120  dst_##l[12 * i + 2] = dst_##l[12 * i + 3] = g[Y]; \
121  dst_##l[12 * i + 4] = dst_##l[12 * i + 5] = r[Y]; \
122  Y = py_##l[2 * i + 1]; \
123  dst_##l[12 * i + 6] = dst_##l[12 * i + 7] = b[Y]; \
124  dst_##l[12 * i + 8] = dst_##l[12 * i + 9] = g[Y]; \
125  dst_##l[12 * i + 10] = dst_##l[12 * i + 11] = r[Y];
126 
127 #define PUTGBRP(l, i, abase) \
128  Y = py_##l[2 * i]; \
129  dst_##l [2 * i + 0] = g[Y]; \
130  dst1_##l[2 * i + 0] = b[Y]; \
131  dst2_##l[2 * i + 0] = r[Y]; \
132  Y = py_##l[2 * i + 1]; \
133  dst_##l [2 * i + 1] = g[Y]; \
134  dst1_##l[2 * i + 1] = b[Y]; \
135  dst2_##l[2 * i + 1] = r[Y];
136 
137 #define YUV2RGBFUNC(func_name, dst_type, alpha, yuv422, nb_dst_planes) \
138  static int func_name(SwsInternal *c, const uint8_t *const src[], \
139  const int srcStride[], int srcSliceY, int srcSliceH, \
140  uint8_t *const dst[], const int dstStride[]) \
141  { \
142  int y; \
143  \
144  for (y = 0; y < srcSliceH; y += 2) { \
145  int yd = y + srcSliceY; \
146  dst_type *dst_1 = \
147  (dst_type *)(dst[0] + (yd) * dstStride[0]); \
148  dst_type *dst_2 = \
149  (dst_type *)(dst[0] + (yd + 1) * dstStride[0]); \
150  av_unused dst_type *dst1_1, *dst1_2, *dst2_1, *dst2_2; \
151  av_unused dst_type *r, *g, *b; \
152  const uint8_t *py_1 = src[0] + y * srcStride[0]; \
153  const uint8_t *py_2 = py_1 + srcStride[0]; \
154  av_unused const uint8_t *pu_1 = src[1] + (y >> !yuv422) * srcStride[1]; \
155  av_unused const uint8_t *pv_1 = src[2] + (y >> !yuv422) * srcStride[2]; \
156  av_unused const uint8_t *pu_2, *pv_2; \
157  av_unused const uint8_t *pa_1, *pa_2; \
158  unsigned int h_size = c->opts.dst_w >> 3; \
159  if (nb_dst_planes > 1) { \
160  dst1_1 = (dst_type *)(dst[1] + (yd) * dstStride[1]); \
161  dst1_2 = (dst_type *)(dst[1] + (yd + 1) * dstStride[1]); \
162  dst2_1 = (dst_type *)(dst[2] + (yd) * dstStride[2]); \
163  dst2_2 = (dst_type *)(dst[2] + (yd + 1) * dstStride[2]); \
164  } \
165  if (yuv422) { \
166  pu_2 = pu_1 + srcStride[1]; \
167  pv_2 = pv_1 + srcStride[2]; \
168  } \
169  if (alpha) { \
170  pa_1 = src[3] + y * srcStride[3]; \
171  pa_2 = pa_1 + srcStride[3]; \
172  } \
173  while (h_size--) { \
174  av_unused int U, V, Y; \
175 
176 #define ENDYUV2RGBLINE(dst_delta, ss, alpha, yuv422, nb_dst_planes) \
177  pu_1 += 4 >> ss; \
178  pv_1 += 4 >> ss; \
179  if (yuv422) { \
180  pu_2 += 4 >> ss; \
181  pv_2 += 4 >> ss; \
182  } \
183  py_1 += 8 >> ss; \
184  py_2 += 8 >> ss; \
185  if (alpha) { \
186  pa_1 += 8 >> ss; \
187  pa_2 += 8 >> ss; \
188  } \
189  dst_1 += dst_delta >> ss; \
190  dst_2 += dst_delta >> ss; \
191  if (nb_dst_planes > 1) { \
192  dst1_1 += dst_delta >> ss; \
193  dst1_2 += dst_delta >> ss; \
194  dst2_1 += dst_delta >> ss; \
195  dst2_2 += dst_delta >> ss; \
196  } \
197  } \
198  if (c->opts.dst_w & (4 >> ss)) { \
199  av_unused int Y, U, V; \
200 
201 #define ENDYUV2RGBFUNC() \
202  } \
203  } \
204  return srcSliceH; \
205  }
206 
207 #define YUV420FUNC(func_name, dst_type, alpha, abase, PUTFUNC, dst_delta, nb_dst_planes) \
208  YUV2RGBFUNC(func_name, dst_type, alpha, 0, nb_dst_planes) \
209  LOADCHROMA(1, 0); \
210  PUTFUNC(1, 0, abase); \
211  PUTFUNC(2, 0, abase); \
212  \
213  LOADCHROMA(1, 1); \
214  PUTFUNC(2, 1, abase); \
215  PUTFUNC(1, 1, abase); \
216  \
217  LOADCHROMA(1, 2); \
218  PUTFUNC(1, 2, abase); \
219  PUTFUNC(2, 2, abase); \
220  \
221  LOADCHROMA(1, 3); \
222  PUTFUNC(2, 3, abase); \
223  PUTFUNC(1, 3, abase); \
224  ENDYUV2RGBLINE(dst_delta, 0, alpha, 0, nb_dst_planes) \
225  LOADCHROMA(1, 0); \
226  PUTFUNC(1, 0, abase); \
227  PUTFUNC(2, 0, abase); \
228  \
229  LOADCHROMA(1, 1); \
230  PUTFUNC(2, 1, abase); \
231  PUTFUNC(1, 1, abase); \
232  ENDYUV2RGBLINE(dst_delta, 1, alpha, 0, nb_dst_planes) \
233  LOADCHROMA(1, 0); \
234  PUTFUNC(1, 0, abase); \
235  PUTFUNC(2, 0, abase); \
236  ENDYUV2RGBFUNC()
237 
238 #define YUV422FUNC(func_name, dst_type, alpha, abase, PUTFUNC, dst_delta, nb_dst_planes) \
239  YUV2RGBFUNC(func_name, dst_type, alpha, 1, nb_dst_planes) \
240  LOADCHROMA(1, 0); \
241  PUTFUNC(1, 0, abase); \
242  \
243  LOADCHROMA(2, 0); \
244  PUTFUNC(2, 0, abase); \
245  \
246  LOADCHROMA(2, 1); \
247  PUTFUNC(2, 1, abase); \
248  \
249  LOADCHROMA(1, 1); \
250  PUTFUNC(1, 1, abase); \
251  \
252  LOADCHROMA(1, 2); \
253  PUTFUNC(1, 2, abase); \
254  \
255  LOADCHROMA(2, 2); \
256  PUTFUNC(2, 2, abase); \
257  \
258  LOADCHROMA(2, 3); \
259  PUTFUNC(2, 3, abase); \
260  \
261  LOADCHROMA(1, 3); \
262  PUTFUNC(1, 3, abase); \
263  ENDYUV2RGBLINE(dst_delta, 0, alpha, 1, nb_dst_planes) \
264  LOADCHROMA(1, 0); \
265  PUTFUNC(1, 0, abase); \
266  \
267  LOADCHROMA(2, 0); \
268  PUTFUNC(2, 0, abase); \
269  \
270  LOADCHROMA(2, 1); \
271  PUTFUNC(2, 1, abase); \
272  \
273  LOADCHROMA(1, 1); \
274  PUTFUNC(1, 1, abase); \
275  ENDYUV2RGBLINE(dst_delta, 1, alpha, 1, nb_dst_planes) \
276  LOADCHROMA(1, 0); \
277  PUTFUNC(1, 0, abase); \
278  \
279  LOADCHROMA(2, 0); \
280  PUTFUNC(2, 0, abase); \
281  ENDYUV2RGBFUNC()
282 
283 #define YUV420FUNC_DITHER(func_name, dst_type, LOADDITHER, PUTFUNC, dst_delta) \
284  YUV2RGBFUNC(func_name, dst_type, 0, 0, 1) \
285  LOADDITHER \
286  \
287  LOADCHROMA(1, 0); \
288  PUTFUNC(1, 0, 0); \
289  PUTFUNC(2, 0, 0 + 8); \
290  \
291  LOADCHROMA(1, 1); \
292  PUTFUNC(2, 1, 2 + 8); \
293  PUTFUNC(1, 1, 2); \
294  \
295  LOADCHROMA(1, 2); \
296  PUTFUNC(1, 2, 4); \
297  PUTFUNC(2, 2, 4 + 8); \
298  \
299  LOADCHROMA(1, 3); \
300  PUTFUNC(2, 3, 6 + 8); \
301  PUTFUNC(1, 3, 6); \
302  ENDYUV2RGBLINE(dst_delta, 0, 0, 0, 1) \
303  LOADDITHER \
304  \
305  LOADCHROMA(1, 0); \
306  PUTFUNC(1, 0, 0); \
307  PUTFUNC(2, 0, 0 + 8); \
308  \
309  LOADCHROMA(1, 1); \
310  PUTFUNC(2, 1, 2 + 8); \
311  PUTFUNC(1, 1, 2); \
312  ENDYUV2RGBLINE(dst_delta, 1, 0, 0, 1) \
313  LOADDITHER \
314  \
315  LOADCHROMA(1, 0); \
316  PUTFUNC(1, 0, 0); \
317  PUTFUNC(2, 0, 0 + 8); \
318  ENDYUV2RGBFUNC()
319 
320 #define YUV422FUNC_DITHER(func_name, dst_type, LOADDITHER, PUTFUNC, dst_delta) \
321  YUV2RGBFUNC(func_name, dst_type, 0, 1, 1) \
322  LOADDITHER \
323  \
324  LOADCHROMA(1, 0); \
325  PUTFUNC(1, 0, 0); \
326  \
327  LOADCHROMA(2, 0); \
328  PUTFUNC(2, 0, 0 + 8); \
329  \
330  LOADCHROMA(2, 1); \
331  PUTFUNC(2, 1, 2 + 8); \
332  \
333  LOADCHROMA(1, 1); \
334  PUTFUNC(1, 1, 2); \
335  \
336  LOADCHROMA(1, 2); \
337  PUTFUNC(1, 2, 4); \
338  \
339  LOADCHROMA(2, 2); \
340  PUTFUNC(2, 2, 4 + 8); \
341  \
342  LOADCHROMA(2, 3); \
343  PUTFUNC(2, 3, 6 + 8); \
344  \
345  LOADCHROMA(1, 3); \
346  PUTFUNC(1, 3, 6); \
347  ENDYUV2RGBLINE(dst_delta, 0, 0, 1, 1) \
348  LOADDITHER \
349  \
350  LOADCHROMA(1, 0); \
351  PUTFUNC(1, 0, 0); \
352  \
353  LOADCHROMA(2, 0); \
354  PUTFUNC(2, 0, 0 + 8); \
355  \
356  LOADCHROMA(2, 1); \
357  PUTFUNC(2, 1, 2 + 8); \
358  \
359  LOADCHROMA(1, 1); \
360  PUTFUNC(1, 1, 2); \
361  ENDYUV2RGBLINE(dst_delta, 1, 0, 1, 1) \
362  LOADDITHER \
363  \
364  LOADCHROMA(1, 0); \
365  PUTFUNC(1, 0, 0); \
366  \
367  LOADCHROMA(2, 0); \
368  PUTFUNC(2, 0, 0 + 8); \
369  ENDYUV2RGBFUNC()
370 
371 #define LOADDITHER16 \
372  const uint8_t *d16 = ff_dither_2x2_8[y & 1]; \
373  const uint8_t *e16 = ff_dither_2x2_4[y & 1]; \
374  const uint8_t *f16 = ff_dither_2x2_8[(y & 1)^1];
375 
376 #define PUTRGB16(l, i, o) \
377  Y = py_##l[2 * i]; \
378  dst_##l[2 * i] = r[Y + d16[0 + o]] + \
379  g[Y + e16[0 + o]] + \
380  b[Y + f16[0 + o]]; \
381  Y = py_##l[2 * i + 1]; \
382  dst_##l[2 * i + 1] = r[Y + d16[1 + o]] + \
383  g[Y + e16[1 + o]] + \
384  b[Y + f16[1 + o]];
385 
386 #define LOADDITHER15 \
387  const uint8_t *d16 = ff_dither_2x2_8[y & 1]; \
388  const uint8_t *e16 = ff_dither_2x2_8[(y & 1)^1];
389 
390 #define PUTRGB15(l, i, o) \
391  Y = py_##l[2 * i]; \
392  dst_##l[2 * i] = r[Y + d16[0 + o]] + \
393  g[Y + d16[1 + o]] + \
394  b[Y + e16[0 + o]]; \
395  Y = py_##l[2 * i + 1]; \
396  dst_##l[2 * i + 1] = r[Y + d16[1 + o]] + \
397  g[Y + d16[0 + o]] + \
398  b[Y + e16[1 + o]];
399 
400 #define LOADDITHER12 \
401  const uint8_t *d16 = ff_dither_4x4_16[y & 3];
402 
403 #define PUTRGB12(l, i, o) \
404  Y = py_##l[2 * i]; \
405  dst_##l[2 * i] = r[Y + d16[0 + o]] + \
406  g[Y + d16[0 + o]] + \
407  b[Y + d16[0 + o]]; \
408  Y = py_##l[2 * i + 1]; \
409  dst_##l[2 * i + 1] = r[Y + d16[1 + o]] + \
410  g[Y + d16[1 + o]] + \
411  b[Y + d16[1 + o]];
412 
413 #define LOADDITHER8 \
414  const uint8_t *d32 = ff_dither_8x8_32[yd & 7]; \
415  const uint8_t *d64 = ff_dither_8x8_73[yd & 7];
416 
417 #define PUTRGB8(l, i, o) \
418  Y = py_##l[2 * i]; \
419  dst_##l[2 * i] = r[Y + d32[0 + o]] + \
420  g[Y + d32[0 + o]] + \
421  b[Y + d64[0 + o]]; \
422  Y = py_##l[2 * i + 1]; \
423  dst_##l[2 * i + 1] = r[Y + d32[1 + o]] + \
424  g[Y + d32[1 + o]] + \
425  b[Y + d64[1 + o]];
426 
427 #define LOADDITHER4D \
428  const uint8_t * d64 = ff_dither_8x8_73[yd & 7]; \
429  const uint8_t *d128 = ff_dither_8x8_220[yd & 7]; \
430  int acc;
431 
432 #define PUTRGB4D(l, i, o) \
433  Y = py_##l[2 * i]; \
434  acc = r[Y + d128[0 + o]] + \
435  g[Y + d64[0 + o]] + \
436  b[Y + d128[0 + o]]; \
437  Y = py_##l[2 * i + 1]; \
438  acc |= (r[Y + d128[1 + o]] + \
439  g[Y + d64[1 + o]] + \
440  b[Y + d128[1 + o]]) << 4; \
441  dst_##l[i] = acc;
442 
443 #define LOADDITHER4DB \
444  const uint8_t *d64 = ff_dither_8x8_73[yd & 7]; \
445  const uint8_t *d128 = ff_dither_8x8_220[yd & 7];
446 
447 #define PUTRGB4DB(l, i, o) \
448  Y = py_##l[2 * i]; \
449  dst_##l[2 * i] = r[Y + d128[0 + o]] + \
450  g[Y + d64[0 + o]] + \
451  b[Y + d128[0 + o]]; \
452  Y = py_##l[2 * i + 1]; \
453  dst_##l[2 * i + 1] = r[Y + d128[1 + o]] + \
454  g[Y + d64[1 + o]] + \
455  b[Y + d128[1 + o]];
456 
457 YUV2RGBFUNC(yuv2rgb_c_1_ordered_dither, uint8_t, 0, 0, 1)
458  const uint8_t *d128 = ff_dither_8x8_220[yd & 7];
459  char out_1 = 0, out_2 = 0;
460  g = c->table_gU[128 + YUVRGB_TABLE_HEADROOM] + c->table_gV[128 + YUVRGB_TABLE_HEADROOM];
461 
462 #define PUTRGB1(out, src, i, o) \
463  Y = src[2 * i]; \
464  out += out + g[Y + d128[0 + o]]; \
465  Y = src[2 * i + 1]; \
466  out += out + g[Y + d128[1 + o]];
467 
468  PUTRGB1(out_1, py_1, 0, 0);
469  PUTRGB1(out_2, py_2, 0, 0 + 8);
470 
471  PUTRGB1(out_2, py_2, 1, 2 + 8);
472  PUTRGB1(out_1, py_1, 1, 2);
473 
474  PUTRGB1(out_1, py_1, 2, 4);
475  PUTRGB1(out_2, py_2, 2, 4 + 8);
476 
477  PUTRGB1(out_2, py_2, 3, 6 + 8);
478  PUTRGB1(out_1, py_1, 3, 6);
479 
480  dst_1[0] = out_1;
481  dst_2[0] = out_2;
482 
483  py_1 += 8;
484  py_2 += 8;
485  dst_1 += 1;
486  dst_2 += 1;
487  }
488  if (c->opts.dst_w & 7) {
489  av_unused int Y, U, V;
490  int pixels_left = c->opts.dst_w & 7;
491  const uint8_t *d128 = ff_dither_8x8_220[yd & 7];
492  char out_1 = 0, out_2 = 0;
493  g = c->table_gU[128 + YUVRGB_TABLE_HEADROOM] + c->table_gV[128 + YUVRGB_TABLE_HEADROOM];
494 
495 #define PUTRGB1_OR00(out, src, i, o) \
496  if (pixels_left) { \
497  PUTRGB1(out, src, i, o) \
498  pixels_left--; \
499  } else { \
500  out <<= 2; \
501  }
502 
503  PUTRGB1_OR00(out_1, py_1, 0, 0);
504  PUTRGB1_OR00(out_2, py_2, 0, 0 + 8);
505 
506  PUTRGB1_OR00(out_2, py_2, 1, 2 + 8);
507  PUTRGB1_OR00(out_1, py_1, 1, 2);
508 
509  PUTRGB1_OR00(out_1, py_1, 2, 4);
510  PUTRGB1_OR00(out_2, py_2, 2, 4 + 8);
511 
512  PUTRGB1_OR00(out_2, py_2, 3, 6 + 8);
513  PUTRGB1_OR00(out_1, py_1, 3, 6);
514 
515  dst_1[0] = out_1;
516  dst_2[0] = out_2;
517 ENDYUV2RGBFUNC()
518 
519 // YUV420
520 YUV420FUNC(yuv2rgb_c_48, uint8_t, 0, 0, PUTRGB48, 48, 1)
521 YUV420FUNC(yuv2rgb_c_bgr48, uint8_t, 0, 0, PUTBGR48, 48, 1)
522 YUV420FUNC(yuv2rgb_c_32, uint32_t, 0, 0, PUTRGB, 8, 1)
523 #if HAVE_BIGENDIAN
524 YUV420FUNC(yuva2argb_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
525 YUV420FUNC(yuva2rgba_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
526 #else
527 YUV420FUNC(yuva2rgba_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
528 YUV420FUNC(yuva2argb_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
529 #endif
530 YUV420FUNC(yuv2rgb_c_24_rgb, uint8_t, 0, 0, PUTRGB24, 24, 1)
531 YUV420FUNC(yuv2rgb_c_24_bgr, uint8_t, 0, 0, PUTBGR24, 24, 1)
532 YUV420FUNC(yuv420p_gbrp_c, uint8_t, 0, 0, PUTGBRP, 8, 3)
533 YUV420FUNC_DITHER(yuv2rgb_c_16_ordered_dither, uint16_t, LOADDITHER16, PUTRGB16, 8)
534 YUV420FUNC_DITHER(yuv2rgb_c_15_ordered_dither, uint16_t, LOADDITHER15, PUTRGB15, 8)
535 YUV420FUNC_DITHER(yuv2rgb_c_12_ordered_dither, uint16_t, LOADDITHER12, PUTRGB12, 8)
536 YUV420FUNC_DITHER(yuv2rgb_c_8_ordered_dither, uint8_t, LOADDITHER8, PUTRGB8, 8)
537 YUV420FUNC_DITHER(yuv2rgb_c_4_ordered_dither, uint8_t, LOADDITHER4D, PUTRGB4D, 4)
538 YUV420FUNC_DITHER(yuv2rgb_c_4b_ordered_dither, uint8_t, LOADDITHER4DB, PUTRGB4DB, 8)
539 
540 // YUV422
541 YUV422FUNC(yuv422p_rgb48_c, uint8_t, 0, 0, PUTRGB48, 48, 1)
542 YUV422FUNC(yuv422p_bgr48_c, uint8_t, 0, 0, PUTBGR48, 48, 1)
543 YUV422FUNC(yuv422p_rgb32_c, uint32_t, 0, 0, PUTRGB, 8, 1)
544 #if HAVE_BIGENDIAN
545 YUV422FUNC(yuva422p_argb_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
546 YUV422FUNC(yuva422p_rgba_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
547 #else
548 YUV422FUNC(yuva422p_rgba_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
549 YUV422FUNC(yuva422p_argb_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
550 #endif
551 YUV422FUNC(yuv422p_rgb24_c, uint8_t, 0, 0, PUTRGB24, 24, 1)
552 YUV422FUNC(yuv422p_bgr24_c, uint8_t, 0, 0, PUTBGR24, 24, 1)
553 YUV422FUNC(yuv422p_gbrp_c, uint8_t, 0, 0, PUTGBRP, 8, 3)
554 YUV422FUNC_DITHER(yuv422p_bgr16, uint16_t, LOADDITHER16, PUTRGB16, 8)
555 YUV422FUNC_DITHER(yuv422p_bgr15, uint16_t, LOADDITHER15, PUTRGB15, 8)
556 YUV422FUNC_DITHER(yuv422p_bgr12, uint16_t, LOADDITHER12, PUTRGB12, 8)
557 YUV422FUNC_DITHER(yuv422p_bgr8, uint8_t, LOADDITHER8, PUTRGB8, 8)
558 YUV422FUNC_DITHER(yuv422p_bgr4, uint8_t, LOADDITHER4D, PUTRGB4D, 4)
559 YUV422FUNC_DITHER(yuv422p_bgr4_byte, uint8_t, LOADDITHER4DB, PUTRGB4DB, 8)
560 
561 SwsFunc ff_yuv2rgb_get_func_ptr(SwsInternal *c)
562 {
563  SwsFunc t = NULL;
564 
565 #if ARCH_PPC
566  t = ff_yuv2rgb_init_ppc(c);
567 #elif ARCH_X86
568  t = ff_yuv2rgb_init_x86(c);
569 #elif ARCH_LOONGARCH64
570  t = ff_yuv2rgb_init_loongarch(c);
571 #elif ARCH_AARCH64
572  t = ff_yuv2rgb_init_aarch64(c);
573 #endif
574 
575  if (t)
576  return t;
577 
578  av_log(c, AV_LOG_WARNING,
579  "No accelerated colorspace conversion found from %s to %s.\n",
580  av_get_pix_fmt_name(c->opts.src_format), av_get_pix_fmt_name(c->opts.dst_format));
581 
582  if (c->opts.src_format == AV_PIX_FMT_YUV422P) {
583  switch (c->opts.dst_format) {
584  case AV_PIX_FMT_BGR48BE:
585  case AV_PIX_FMT_BGR48LE:
586  return yuv422p_bgr48_c;
587  case AV_PIX_FMT_RGB48BE:
588  case AV_PIX_FMT_RGB48LE:
589  return yuv422p_rgb48_c;
590  case AV_PIX_FMT_ARGB:
591  case AV_PIX_FMT_ABGR:
592  if (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format))
593  return yuva422p_argb_c;
594  case AV_PIX_FMT_RGBA:
595  case AV_PIX_FMT_BGRA:
596  return (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format)) ? yuva422p_rgba_c : yuv422p_rgb32_c;
597  case AV_PIX_FMT_RGB24:
598  return yuv422p_rgb24_c;
599  case AV_PIX_FMT_BGR24:
600  return yuv422p_bgr24_c;
601  case AV_PIX_FMT_RGB565:
602  case AV_PIX_FMT_BGR565:
603  return yuv422p_bgr16;
604  case AV_PIX_FMT_RGB555:
605  case AV_PIX_FMT_BGR555:
606  return yuv422p_bgr15;
607  case AV_PIX_FMT_RGB444:
608  case AV_PIX_FMT_BGR444:
609  return yuv422p_bgr12;
610  case AV_PIX_FMT_RGB8:
611  case AV_PIX_FMT_BGR8:
612  return yuv422p_bgr8;
613  case AV_PIX_FMT_RGB4:
614  case AV_PIX_FMT_BGR4:
615  return yuv422p_bgr4;
616  case AV_PIX_FMT_RGB4_BYTE:
617  case AV_PIX_FMT_BGR4_BYTE:
618  return yuv422p_bgr4_byte;
619  case AV_PIX_FMT_MONOBLACK:
620  return yuv2rgb_c_1_ordered_dither;
621  case AV_PIX_FMT_GBRP:
622  return yuv422p_gbrp_c;
623  }
624  } else {
625  switch (c->opts.dst_format) {
626  case AV_PIX_FMT_BGR48BE:
627  case AV_PIX_FMT_BGR48LE:
628  return yuv2rgb_c_bgr48;
629  case AV_PIX_FMT_RGB48BE:
630  case AV_PIX_FMT_RGB48LE:
631  return yuv2rgb_c_48;
632  case AV_PIX_FMT_ARGB:
633  case AV_PIX_FMT_ABGR:
634  if (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format))
635  return yuva2argb_c;
636  case AV_PIX_FMT_RGBA:
637  case AV_PIX_FMT_BGRA:
638  return (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format)) ? yuva2rgba_c : yuv2rgb_c_32;
639  case AV_PIX_FMT_RGB24:
640  return yuv2rgb_c_24_rgb;
641  case AV_PIX_FMT_BGR24:
642  return yuv2rgb_c_24_bgr;
643  case AV_PIX_FMT_RGB565:
644  case AV_PIX_FMT_BGR565:
645  return yuv2rgb_c_16_ordered_dither;
646  case AV_PIX_FMT_RGB555:
647  case AV_PIX_FMT_BGR555:
648  return yuv2rgb_c_15_ordered_dither;
649  case AV_PIX_FMT_RGB444:
650  case AV_PIX_FMT_BGR444:
651  return yuv2rgb_c_12_ordered_dither;
652  case AV_PIX_FMT_RGB8:
653  case AV_PIX_FMT_BGR8:
654  return yuv2rgb_c_8_ordered_dither;
655  case AV_PIX_FMT_RGB4:
656  case AV_PIX_FMT_BGR4:
657  return yuv2rgb_c_4_ordered_dither;
658  case AV_PIX_FMT_RGB4_BYTE:
659  case AV_PIX_FMT_BGR4_BYTE:
660  return yuv2rgb_c_4b_ordered_dither;
661  case AV_PIX_FMT_MONOBLACK:
662  return yuv2rgb_c_1_ordered_dither;
663  case AV_PIX_FMT_GBRP:
664  return yuv420p_gbrp_c;
665  }
666  }
667  return NULL;
668 }
669 
670 static void fill_table(uint8_t* table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize,
671  const int64_t inc, void *y_tab)
672 {
673  int i;
674  uint8_t *y_table = y_tab;
675 
676  y_table -= elemsize * (inc >> 9);
677 
678  for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
679  int64_t cb = av_clip_uint8(i-YUVRGB_TABLE_HEADROOM)*inc;
680  table[i] = y_table + elemsize * (cb >> 16);
681  }
682 }
683 
684 static void fill_gv_table(int table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize, const int64_t inc)
685 {
686  int i;
687  int off = -(inc >> 9);
688 
689  for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
690  int64_t cb = av_clip_uint8(i-YUVRGB_TABLE_HEADROOM)*inc;
691  table[i] = elemsize * (off + (cb >> 16));
692  }
693 }
694 
695 static uint16_t roundToInt16(int64_t f)
696 {
697  int r = (f + (1 << 15)) >> 16;
698 
699  if (r < -0x7FFF)
700  return 0x8000;
701  else if (r > 0x7FFF)
702  return 0x7FFF;
703  else
704  return r;
705 }
706 
707 av_cold int ff_yuv2rgb_c_init_tables(SwsInternal *c, const int inv_table[4],
708  int fullRange, int brightness,
709  int contrast, int saturation)
710 {
711  const int isRgb = c->opts.dst_format == AV_PIX_FMT_RGB32 ||
712  c->opts.dst_format == AV_PIX_FMT_RGB32_1 ||
713  c->opts.dst_format == AV_PIX_FMT_BGR24 ||
714  c->opts.dst_format == AV_PIX_FMT_RGB565BE ||
715  c->opts.dst_format == AV_PIX_FMT_RGB565LE ||
716  c->opts.dst_format == AV_PIX_FMT_RGB555BE ||
717  c->opts.dst_format == AV_PIX_FMT_RGB555LE ||
718  c->opts.dst_format == AV_PIX_FMT_RGB444BE ||
719  c->opts.dst_format == AV_PIX_FMT_RGB444LE ||
720  c->opts.dst_format == AV_PIX_FMT_X2RGB10BE ||
721  c->opts.dst_format == AV_PIX_FMT_X2RGB10LE ||
722  c->opts.dst_format == AV_PIX_FMT_RGB8 ||
723  c->opts.dst_format == AV_PIX_FMT_RGB4 ||
724  c->opts.dst_format == AV_PIX_FMT_RGB4_BYTE ||
725  c->opts.dst_format == AV_PIX_FMT_MONOBLACK;
726  const int isNotNe = c->opts.dst_format == AV_PIX_FMT_NE(RGB565LE, RGB565BE) ||
727  c->opts.dst_format == AV_PIX_FMT_NE(RGB555LE, RGB555BE) ||
728  c->opts.dst_format == AV_PIX_FMT_NE(RGB444LE, RGB444BE) ||
729  c->opts.dst_format == AV_PIX_FMT_NE(BGR565LE, BGR565BE) ||
730  c->opts.dst_format == AV_PIX_FMT_NE(BGR555LE, BGR555BE) ||
731  c->opts.dst_format == AV_PIX_FMT_NE(BGR444LE, BGR444BE) ||
732  c->opts.dst_format == AV_PIX_FMT_NE(X2RGB10LE, X2RGB10BE) ||
733  c->opts.dst_format == AV_PIX_FMT_NE(X2BGR10LE, X2BGR10BE);
734  const int bpp = c->dstFormatBpp;
735  uint8_t *y_table;
736  uint16_t *y_table16;
737  uint32_t *y_table32;
738  int i, base, rbase, gbase, bbase, av_uninit(abase), needAlpha;
739  const int yoffs = (fullRange ? 384 : 326) + YUVRGB_TABLE_LUMA_HEADROOM;
740  const int table_plane_size = 1024 + 2*YUVRGB_TABLE_LUMA_HEADROOM;
741 
742  int64_t crv = inv_table[0];
743  int64_t cbu = inv_table[1];
744  int64_t cgu = -inv_table[2];
745  int64_t cgv = -inv_table[3];
746  int64_t cy = 1 << 16;
747  int64_t oy = 0;
748  int64_t yb = 0;
749 
750  if (!fullRange) {
751  cy = (cy * 255) / 219;
752  oy = 16 << 16;
753  } else {
754  crv = (crv * 224) / 255;
755  cbu = (cbu * 224) / 255;
756  cgu = (cgu * 224) / 255;
757  cgv = (cgv * 224) / 255;
758  }
759 
760  cy = (cy * contrast) >> 16;
761  crv = (crv * contrast * saturation) >> 32;
762  cbu = (cbu * contrast * saturation) >> 32;
763  cgu = (cgu * contrast * saturation) >> 32;
764  cgv = (cgv * contrast * saturation) >> 32;
765  oy -= 256LL * brightness;
766 
767  c->uOffset = 0x0400040004000400LL;
768  c->vOffset = 0x0400040004000400LL;
769  c->yCoeff = roundToInt16(cy * (1 << 13)) * 0x0001000100010001ULL;
770  c->vrCoeff = roundToInt16(crv * (1 << 13)) * 0x0001000100010001ULL;
771  c->ubCoeff = roundToInt16(cbu * (1 << 13)) * 0x0001000100010001ULL;
772  c->vgCoeff = roundToInt16(cgv * (1 << 13)) * 0x0001000100010001ULL;
773  c->ugCoeff = roundToInt16(cgu * (1 << 13)) * 0x0001000100010001ULL;
774  c->yOffset = roundToInt16(oy * (1 << 3)) * 0x0001000100010001ULL;
775 
776  c->yuv2rgb_y_coeff = (int16_t)roundToInt16(cy * (1 << 13));
777  c->yuv2rgb_y_offset = (int16_t)roundToInt16(oy * (1 << 9));
778  c->yuv2rgb_v2r_coeff = (int16_t)roundToInt16(crv * (1 << 13));
779  c->yuv2rgb_v2g_coeff = (int16_t)roundToInt16(cgv * (1 << 13));
780  c->yuv2rgb_u2g_coeff = (int16_t)roundToInt16(cgu * (1 << 13));
781  c->yuv2rgb_u2b_coeff = (int16_t)roundToInt16(cbu * (1 << 13));
782 
783  //scale coefficients by cy
784  crv = ((crv * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
785  cbu = ((cbu * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
786  cgu = ((cgu * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
787  cgv = ((cgv * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
788 
789  av_freep(&c->yuvTable);
790 
791 #define ALLOC_YUV_TABLE(x) \
792  c->yuvTable = av_malloc(x); \
793  if (!c->yuvTable) \
794  return AVERROR(ENOMEM);
795  switch (bpp) {
796  case 1:
797  ALLOC_YUV_TABLE(table_plane_size);
798  y_table = c->yuvTable;
799  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
800  for (i = 0; i < table_plane_size - 110; i++) {
801  y_table[i + 110] = av_clip_uint8((yb + 0x8000) >> 16) >> 7;
802  yb += cy;
803  }
804  fill_table(c->table_gU, 1, cgu, y_table + yoffs);
805  fill_gv_table(c->table_gV, 1, cgv);
806  break;
807  case 4:
808  case 4 | 128:
809  rbase = isRgb ? 3 : 0;
810  gbase = 1;
811  bbase = isRgb ? 0 : 3;
812  ALLOC_YUV_TABLE(table_plane_size * 3);
813  y_table = c->yuvTable;
814  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
815  for (i = 0; i < table_plane_size - 110; i++) {
816  int yval = av_clip_uint8((yb + 0x8000) >> 16);
817  y_table[i + 110] = (yval >> 7) << rbase;
818  y_table[i + 37 + table_plane_size] = ((yval + 43) / 85) << gbase;
819  y_table[i + 110 + 2*table_plane_size] = (yval >> 7) << bbase;
820  yb += cy;
821  }
822  fill_table(c->table_rV, 1, crv, y_table + yoffs);
823  fill_table(c->table_gU, 1, cgu, y_table + yoffs + table_plane_size);
824  fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2*table_plane_size);
825  fill_gv_table(c->table_gV, 1, cgv);
826  break;
827  case 8:
828  rbase = isRgb ? 5 : 0;
829  gbase = isRgb ? 2 : 3;
830  bbase = isRgb ? 0 : 6;
831  ALLOC_YUV_TABLE(table_plane_size * 3);
832  y_table = c->yuvTable;
833  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
834  for (i = 0; i < table_plane_size - 38; i++) {
835  int yval = av_clip_uint8((yb + 0x8000) >> 16);
836  y_table[i + 16] = ((yval + 18) / 36) << rbase;
837  y_table[i + 16 + table_plane_size] = ((yval + 18) / 36) << gbase;
838  y_table[i + 37 + 2*table_plane_size] = ((yval + 43) / 85) << bbase;
839  yb += cy;
840  }
841  fill_table(c->table_rV, 1, crv, y_table + yoffs);
842  fill_table(c->table_gU, 1, cgu, y_table + yoffs + table_plane_size);
843  fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2*table_plane_size);
844  fill_gv_table(c->table_gV, 1, cgv);
845  break;
846  case 12:
847  rbase = isRgb ? 8 : 0;
848  gbase = 4;
849  bbase = isRgb ? 0 : 8;
850  ALLOC_YUV_TABLE(table_plane_size * 3 * 2);
851  y_table16 = c->yuvTable;
852  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
853  for (i = 0; i < table_plane_size; i++) {
854  uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
855  y_table16[i] = (yval >> 4) << rbase;
856  y_table16[i + table_plane_size] = (yval >> 4) << gbase;
857  y_table16[i + 2*table_plane_size] = (yval >> 4) << bbase;
858  yb += cy;
859  }
860  if (isNotNe)
861  for (i = 0; i < table_plane_size * 3; i++)
862  y_table16[i] = av_bswap16(y_table16[i]);
863  fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
864  fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + table_plane_size);
865  fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2*table_plane_size);
866  fill_gv_table(c->table_gV, 2, cgv);
867  break;
868  case 15:
869  case 16:
870  rbase = isRgb ? bpp - 5 : 0;
871  gbase = 5;
872  bbase = isRgb ? 0 : (bpp - 5);
873  ALLOC_YUV_TABLE(table_plane_size * 3 * 2);
874  y_table16 = c->yuvTable;
875  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
876  for (i = 0; i < table_plane_size; i++) {
877  uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
878  y_table16[i] = (yval >> 3) << rbase;
879  y_table16[i + table_plane_size] = (yval >> (18 - bpp)) << gbase;
880  y_table16[i + 2*table_plane_size] = (yval >> 3) << bbase;
881  yb += cy;
882  }
883  if (isNotNe)
884  for (i = 0; i < table_plane_size * 3; i++)
885  y_table16[i] = av_bswap16(y_table16[i]);
886  fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
887  fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + table_plane_size);
888  fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2*table_plane_size);
889  fill_gv_table(c->table_gV, 2, cgv);
890  break;
891  case 24:
892  case 48:
893  ALLOC_YUV_TABLE(table_plane_size);
894  y_table = c->yuvTable;
895  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
896  for (i = 0; i < table_plane_size; i++) {
897  y_table[i] = av_clip_uint8((yb + 0x8000) >> 16);
898  yb += cy;
899  }
900  fill_table(c->table_rV, 1, crv, y_table + yoffs);
901  fill_table(c->table_gU, 1, cgu, y_table + yoffs);
902  fill_table(c->table_bU, 1, cbu, y_table + yoffs);
903  fill_gv_table(c->table_gV, 1, cgv);
904  break;
905  case 30:
906  rbase = isRgb ? 20 : 0;
907  gbase = 10;
908  bbase = isRgb ? 0 : 20;
909  needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format);
910  if (!needAlpha)
911  abase = 30;
912  ALLOC_YUV_TABLE(table_plane_size * 3 * 4);
913  y_table32 = c->yuvTable;
914  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
915  for (i = 0; i < table_plane_size; i++) {
916  unsigned yval = av_clip_uintp2((yb + 0x8000) >> 14, 10);
917  y_table32[i]= (yval << rbase) + (needAlpha ? 0 : (255u << abase));
918  y_table32[i + table_plane_size] = yval << gbase;
919  y_table32[i + 2 * table_plane_size] = yval << bbase;
920  yb += cy;
921  }
922  if (isNotNe) {
923  for (i = 0; i < table_plane_size * 3; i++)
924  y_table32[i] = av_bswap32(y_table32[i]);
925  }
926  fill_table(c->table_rV, 4, crv, y_table32 + yoffs);
927  fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + table_plane_size);
928  fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2 * table_plane_size);
929  fill_gv_table(c->table_gV, 4, cgv);
930  break;
931  case 32:
932  case 64:
933  base = (c->opts.dst_format == AV_PIX_FMT_RGB32_1 ||
934  c->opts.dst_format == AV_PIX_FMT_BGR32_1) ? 8 : 0;
935  rbase = base + (isRgb ? 16 : 0);
936  gbase = base + 8;
937  bbase = base + (isRgb ? 0 : 16);
938  needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format);
939  if (!needAlpha)
940  abase = (base + 24) & 31;
941  ALLOC_YUV_TABLE(table_plane_size * 3 * 4);
942  y_table32 = c->yuvTable;
943  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
944  for (i = 0; i < table_plane_size; i++) {
945  unsigned yval = av_clip_uint8((yb + 0x8000) >> 16);
946  y_table32[i] = (yval << rbase) +
947  (needAlpha ? 0 : (255u << abase));
948  y_table32[i + table_plane_size] = yval << gbase;
949  y_table32[i + 2*table_plane_size] = yval << bbase;
950  yb += cy;
951  }
952  fill_table(c->table_rV, 4, crv, y_table32 + yoffs);
953  fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + table_plane_size);
954  fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2*table_plane_size);
955  fill_gv_table(c->table_gV, 4, cgv);
956  break;
957  default:
958  if(!isPlanar(c->opts.dst_format) || bpp <= 24)
959  av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);
960  return AVERROR(EINVAL);
961  }
962  return 0;
963 }
PUTRGB1
#define PUTRGB1(out, src, i, o)
Definition: yuv2rgb.c:462
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_PIX_FMT_BGR48LE
@ AV_PIX_FMT_BGR48LE
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:146
r
const char * r
Definition: vf_curves.c:127
AVERROR
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
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:247
AV_PIX_FMT_RGB444LE
@ AV_PIX_FMT_RGB444LE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:136
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
out_2
char out_2
Definition: yuv2rgb.c:459
saturation
static IPT saturation(const CmsCtx *ctx, IPT ipt)
Definition: cms.c:559
int64_t
long long int64_t
Definition: coverity.c:34
PUTRGBA
#define PUTRGBA(l, i, abase)
Definition: yuv2rgb.c:101
YUV420FUNC
#define YUV420FUNC(func_name, dst_type, alpha, abase, PUTFUNC, dst_delta, nb_dst_planes)
Definition: yuv2rgb.c:207
av_unused
#define av_unused
Definition: attributes.h:151
pixdesc.h
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:68
table
static const uint16_t table[]
Definition: prosumer.c:203
ff_yuv2rgb_init_x86
av_cold SwsFunc ff_yuv2rgb_init_x86(SwsInternal *c)
Definition: yuv2rgb.c:241
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:512
base
uint8_t base
Definition: vp3data.h:128
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:114
PUTRGB1_OR00
#define PUTRGB1_OR00(out, src, i, o)
ENDYUV2RGBFUNC
#define ENDYUV2RGBFUNC()
Definition: yuv2rgb.c:201
PUTRGB4D
#define PUTRGB4D(l, i, o)
Definition: yuv2rgb.c:432
ALLOC_YUV_TABLE
#define ALLOC_YUV_TABLE(x)
PUTBGR24
#define PUTBGR24(l, i, abase)
Definition: yuv2rgb.c:91
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
PUTRGB16
#define PUTRGB16(l, i, o)
Definition: yuv2rgb.c:376
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
LOADDITHER8
#define LOADDITHER8
Definition: yuv2rgb.c:413
YUVRGB_TABLE_HEADROOM
#define YUVRGB_TABLE_HEADROOM
Definition: swscale_internal.h:51
ff_yuv2rgb_c_init_tables
int ff_yuv2rgb_c_init_tables(SwsInternal *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation)
ff_dither_8x8_220
const uint8_t ff_dither_8x8_220[][8]
Definition: output.c:85
LOADDITHER12
#define LOADDITHER12
Definition: yuv2rgb.c:400
AV_PIX_FMT_RGB4
@ AV_PIX_FMT_RGB4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1R 2G 1B(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:94
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition: pixfmt.h:514
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
ff_yuv2rgb_init_ppc
av_cold SwsFunc ff_yuv2rgb_init_ppc(SwsInternal *c)
Definition: yuv2rgb_altivec.c:567
ff_yuv2rgb_coeffs
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition: yuv2rgb.c:47
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:113
NULL
#define NULL
Definition: coverity.c:32
PUTRGB12
#define PUTRGB12(l, i, o)
Definition: yuv2rgb.c:403
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
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:110
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:83
LOADDITHER4D
#define LOADDITHER4D
Definition: yuv2rgb.c:427
V
#define V
Definition: avdct.c:32
AV_PIX_FMT_RGB8
@ AV_PIX_FMT_RGB8
packed RGB 3:3:2, 8bpp, (msb)3R 3G 2B(lsb)
Definition: pixfmt.h:93
AV_PIX_FMT_BGR4
@ AV_PIX_FMT_BGR4
packed RGB 1:2:1 bitstream, 4bpp, (msb)1B 2G 1R(lsb), a byte contains two pixels, the first pixel in ...
Definition: pixfmt.h:91
dst_2
dst_2[0]
Definition: yuv2rgb.c:481
YUV420FUNC_DITHER
#define YUV420FUNC_DITHER(func_name, dst_type, LOADDITHER, PUTFUNC, dst_delta)
Definition: yuv2rgb.c:283
AV_PIX_FMT_NE
#define AV_PIX_FMT_NE(be, le)
Definition: pixfmt.h:508
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
py_1
py_1
Definition: yuv2rgb.c:483
c
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
inc
static int inc(int num, int period)
Definition: perlin.c:34
AV_PIX_FMT_BGR4_BYTE
@ AV_PIX_FMT_BGR4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1B 2G 1R(lsb)
Definition: pixfmt.h:92
AV_PIX_FMT_X2RGB10LE
@ AV_PIX_FMT_X2RGB10LE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:384
PUTRGB24
#define PUTRGB24(l, i, abase)
Definition: yuv2rgb.c:81
f
f
Definition: af_crystalizer.c:122
PUTRGB8
#define PUTRGB8(l, i, o)
Definition: yuv2rgb.c:417
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
LOADDITHER15
#define LOADDITHER15
Definition: yuv2rgb.c:386
g
g
Definition: yuv2rgb.c:460
av_bswap32
#define av_bswap32
Definition: bswap.h:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
AV_PIX_FMT_RGB444BE
@ AV_PIX_FMT_RGB444BE
packed RGB 4:4:4, 16bpp, (msb)4X 4R 4G 4B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:137
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:532
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:511
PUTBGR48
#define PUTBGR48(l, i, abase)
Definition: yuv2rgb.c:117
PUTRGB15
#define PUTRGB15(l, i, o)
Definition: yuv2rgb.c:390
Y
#define Y
Definition: boxblur.h:37
ff_yuv2rgb_init_loongarch
av_cold SwsFunc ff_yuv2rgb_init_loongarch(SwsInternal *c)
Definition: swscale_init_loongarch.c:110
PUTRGB4DB
#define PUTRGB4DB(l, i, o)
Definition: yuv2rgb.c:447
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
LOADDITHER16
#define LOADDITHER16
Definition: yuv2rgb.c:371
ff_yuv2rgb_init_aarch64
av_cold SwsFunc ff_yuv2rgb_init_aarch64(SwsInternal *c)
Definition: swscale_unscaled.c:271
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:115
AV_PIX_FMT_RGB48BE
@ AV_PIX_FMT_RGB48BE
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:109
YUV422FUNC
#define YUV422FUNC(func_name, dst_type, alpha, abase, PUTFUNC, dst_delta, nb_dst_planes)
Definition: yuv2rgb.c:238
YUV422FUNC_DITHER
#define YUV422FUNC_DITHER(func_name, dst_type, LOADDITHER, PUTFUNC, dst_delta)
Definition: yuv2rgb.c:320
PUTRGB48
#define PUTRGB48(l, i, abase)
Definition: yuv2rgb.c:107
AV_PIX_FMT_BGR444
#define AV_PIX_FMT_BGR444
Definition: pixfmt.h:533
YUV2RGBFUNC
#define YUV2RGBFUNC(func_name, dst_type, alpha, yuv422, nb_dst_planes)
Definition: yuv2rgb.c:137
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:527
swscale_internal.h
AV_PIX_FMT_X2RGB10BE
@ AV_PIX_FMT_X2RGB10BE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:385
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:531
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:526
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:393
YUVRGB_TABLE_LUMA_HEADROOM
#define YUVRGB_TABLE_LUMA_HEADROOM
Definition: swscale_internal.h:52
PUTGBRP
#define PUTGBRP(l, i, abase)
Definition: yuv2rgb.c:127
av_uninit
#define av_uninit(x)
Definition: attributes.h:174
SwsInternal
Definition: swscale_internal.h:334
bswap.h
py_2
py_2
Definition: yuv2rgb.c:484
U
#define U(x)
Definition: vpx_arith.h:37
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
AV_PIX_FMT_RGB565BE
@ AV_PIX_FMT_RGB565BE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian
Definition: pixfmt.h:112
ff_yuv2rgb_get_func_ptr
SwsFunc ff_yuv2rgb_get_func_ptr(SwsInternal *c)
LOADDITHER4DB
#define LOADDITHER4DB
Definition: yuv2rgb.c:443
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
dst_1
dst_1[0]
Definition: yuv2rgb.c:480
mem.h
sws_getCoefficients
const int * sws_getCoefficients(int colorspace)
Return a pointer to yuv<->rgb coefficients for the given colorspace suitable for sws_setColorspaceDet...
Definition: yuv2rgb.c:61
PUTRGB
#define PUTRGB(l, i, abase)
Definition: yuv2rgb.c:75
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
SwsFunc
int(* SwsFunc)(SwsInternal *c, const uint8_t *const src[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
Definition: swscale_internal.h:96
int32_t
int32_t
Definition: audioconvert.c:56
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
out_1
char out_1
Definition: yuv2rgb.c:459
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:909
d128
const uint8_t * d128
Definition: yuv2rgb.c:458
av_bswap16
#define av_bswap16
Definition: bswap.h:28
swscale.h
av_get_pix_fmt_name
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:3376
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:891
AV_PIX_FMT_BGR48BE
@ AV_PIX_FMT_BGR48BE
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:145
AV_PIX_FMT_RGB444
#define AV_PIX_FMT_RGB444
Definition: pixfmt.h:528
Generated on Wed Mar 4 2026 19:23:40 for FFmpeg by   doxygen 1.8.17