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  av_fallthrough;
595  case AV_PIX_FMT_RGBA:
596  case AV_PIX_FMT_BGRA:
597  return (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format)) ? yuva422p_rgba_c : yuv422p_rgb32_c;
598  case AV_PIX_FMT_RGB24:
599  return yuv422p_rgb24_c;
600  case AV_PIX_FMT_BGR24:
601  return yuv422p_bgr24_c;
602  case AV_PIX_FMT_RGB565BE:
603  case AV_PIX_FMT_BGR565BE:
604  case AV_PIX_FMT_RGB565LE:
605  case AV_PIX_FMT_BGR565LE:
606  return yuv422p_bgr16;
607  case AV_PIX_FMT_RGB555BE:
608  case AV_PIX_FMT_BGR555BE:
609  case AV_PIX_FMT_RGB555LE:
610  case AV_PIX_FMT_BGR555LE:
611  return yuv422p_bgr15;
612  case AV_PIX_FMT_RGB444:
613  case AV_PIX_FMT_BGR444:
614  return yuv422p_bgr12;
615  case AV_PIX_FMT_RGB8:
616  case AV_PIX_FMT_BGR8:
617  return yuv422p_bgr8;
618  case AV_PIX_FMT_RGB4:
619  case AV_PIX_FMT_BGR4:
620  return yuv422p_bgr4;
621  case AV_PIX_FMT_RGB4_BYTE:
622  case AV_PIX_FMT_BGR4_BYTE:
623  return yuv422p_bgr4_byte;
624  case AV_PIX_FMT_MONOBLACK:
625  return yuv2rgb_c_1_ordered_dither;
626  case AV_PIX_FMT_GBRP:
627  return yuv422p_gbrp_c;
628  }
629  } else {
630  switch (c->opts.dst_format) {
631  case AV_PIX_FMT_BGR48BE:
632  case AV_PIX_FMT_BGR48LE:
633  return yuv2rgb_c_bgr48;
634  case AV_PIX_FMT_RGB48BE:
635  case AV_PIX_FMT_RGB48LE:
636  return yuv2rgb_c_48;
637  case AV_PIX_FMT_ARGB:
638  case AV_PIX_FMT_ABGR:
639  if (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format))
640  return yuva2argb_c;
641  av_fallthrough;
642  case AV_PIX_FMT_RGBA:
643  case AV_PIX_FMT_BGRA:
644  return (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format)) ? yuva2rgba_c : yuv2rgb_c_32;
645  case AV_PIX_FMT_RGB24:
646  return yuv2rgb_c_24_rgb;
647  case AV_PIX_FMT_BGR24:
648  return yuv2rgb_c_24_bgr;
649  case AV_PIX_FMT_RGB565BE:
650  case AV_PIX_FMT_BGR565BE:
651  case AV_PIX_FMT_RGB565LE:
652  case AV_PIX_FMT_BGR565LE:
653  return yuv2rgb_c_16_ordered_dither;
654  case AV_PIX_FMT_RGB555BE:
655  case AV_PIX_FMT_BGR555BE:
656  case AV_PIX_FMT_RGB555LE:
657  case AV_PIX_FMT_BGR555LE:
658  return yuv2rgb_c_15_ordered_dither;
659  case AV_PIX_FMT_RGB444:
660  case AV_PIX_FMT_BGR444:
661  return yuv2rgb_c_12_ordered_dither;
662  case AV_PIX_FMT_RGB8:
663  case AV_PIX_FMT_BGR8:
664  return yuv2rgb_c_8_ordered_dither;
665  case AV_PIX_FMT_RGB4:
666  case AV_PIX_FMT_BGR4:
667  return yuv2rgb_c_4_ordered_dither;
668  case AV_PIX_FMT_RGB4_BYTE:
669  case AV_PIX_FMT_BGR4_BYTE:
670  return yuv2rgb_c_4b_ordered_dither;
671  case AV_PIX_FMT_MONOBLACK:
672  return yuv2rgb_c_1_ordered_dither;
673  case AV_PIX_FMT_GBRP:
674  return yuv420p_gbrp_c;
675  }
676  }
677  return NULL;
678 }
679 
680 static void fill_table(uint8_t* table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize,
681  const int64_t inc, void *y_tab)
682 {
683  int i;
684  uint8_t *y_table = y_tab;
685 
686  y_table -= elemsize * (inc >> 9);
687 
688  for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
689  int64_t cb = av_clip_uint8(i-YUVRGB_TABLE_HEADROOM)*inc;
690  table[i] = y_table + elemsize * (cb >> 16);
691  }
692 }
693 
694 static void fill_gv_table(int table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize, const int64_t inc)
695 {
696  int i;
697  int off = -(inc >> 9);
698 
699  for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
700  int64_t cb = av_clip_uint8(i-YUVRGB_TABLE_HEADROOM)*inc;
701  table[i] = elemsize * (off + (cb >> 16));
702  }
703 }
704 
705 static uint16_t roundToInt16(int64_t f)
706 {
707  int r = (f + (1 << 15)) >> 16;
708 
709  if (r < -0x7FFF)
710  return 0x8000;
711  else if (r > 0x7FFF)
712  return 0x7FFF;
713  else
714  return r;
715 }
716 
717 av_cold int ff_yuv2rgb_c_init_tables(SwsInternal *c, const int inv_table[4],
718  int fullRange, int brightness,
719  int contrast, int saturation)
720 {
721  const int isRgb = c->opts.dst_format == AV_PIX_FMT_RGB32 ||
722  c->opts.dst_format == AV_PIX_FMT_RGB32_1 ||
723  c->opts.dst_format == AV_PIX_FMT_BGR24 ||
724  c->opts.dst_format == AV_PIX_FMT_RGB565BE ||
725  c->opts.dst_format == AV_PIX_FMT_RGB565LE ||
726  c->opts.dst_format == AV_PIX_FMT_RGB555BE ||
727  c->opts.dst_format == AV_PIX_FMT_RGB555LE ||
728  c->opts.dst_format == AV_PIX_FMT_RGB444BE ||
729  c->opts.dst_format == AV_PIX_FMT_RGB444LE ||
730  c->opts.dst_format == AV_PIX_FMT_X2RGB10BE ||
731  c->opts.dst_format == AV_PIX_FMT_X2RGB10LE ||
732  c->opts.dst_format == AV_PIX_FMT_RGB8 ||
733  c->opts.dst_format == AV_PIX_FMT_RGB4 ||
734  c->opts.dst_format == AV_PIX_FMT_RGB4_BYTE ||
735  c->opts.dst_format == AV_PIX_FMT_MONOBLACK;
736  const int isNotNe = c->opts.dst_format == AV_PIX_FMT_NE(RGB565LE, RGB565BE) ||
737  c->opts.dst_format == AV_PIX_FMT_NE(RGB555LE, RGB555BE) ||
738  c->opts.dst_format == AV_PIX_FMT_NE(RGB444LE, RGB444BE) ||
739  c->opts.dst_format == AV_PIX_FMT_NE(BGR565LE, BGR565BE) ||
740  c->opts.dst_format == AV_PIX_FMT_NE(BGR555LE, BGR555BE) ||
741  c->opts.dst_format == AV_PIX_FMT_NE(BGR444LE, BGR444BE) ||
742  c->opts.dst_format == AV_PIX_FMT_NE(X2RGB10LE, X2RGB10BE) ||
743  c->opts.dst_format == AV_PIX_FMT_NE(X2BGR10LE, X2BGR10BE);
744  const int bpp = c->dstFormatBpp;
745  uint8_t *y_table;
746  uint16_t *y_table16;
747  uint32_t *y_table32;
748  int i, base, rbase, gbase, bbase, av_uninit(abase), needAlpha;
749  const int yoffs = (fullRange ? 384 : 326) + YUVRGB_TABLE_LUMA_HEADROOM;
750  const int table_plane_size = 1024 + 2*YUVRGB_TABLE_LUMA_HEADROOM;
751 
752  int64_t crv = inv_table[0];
753  int64_t cbu = inv_table[1];
754  int64_t cgu = -inv_table[2];
755  int64_t cgv = -inv_table[3];
756  int64_t cy = 1 << 16;
757  int64_t oy = 0;
758  int64_t yb = 0;
759 
760  if (!fullRange) {
761  cy = (cy * 255) / 219;
762  oy = 16 << 16;
763  } else {
764  crv = (crv * 224) / 255;
765  cbu = (cbu * 224) / 255;
766  cgu = (cgu * 224) / 255;
767  cgv = (cgv * 224) / 255;
768  }
769 
770  cy = (cy * contrast) >> 16;
771  crv = (crv * contrast * saturation) >> 32;
772  cbu = (cbu * contrast * saturation) >> 32;
773  cgu = (cgu * contrast * saturation) >> 32;
774  cgv = (cgv * contrast * saturation) >> 32;
775  oy -= 256LL * brightness;
776 
777  c->uOffset = 0x0400040004000400LL;
778  c->vOffset = 0x0400040004000400LL;
779  c->yCoeff = roundToInt16(cy * (1 << 13)) * 0x0001000100010001ULL;
780  c->vrCoeff = roundToInt16(crv * (1 << 13)) * 0x0001000100010001ULL;
781  c->ubCoeff = roundToInt16(cbu * (1 << 13)) * 0x0001000100010001ULL;
782  c->vgCoeff = roundToInt16(cgv * (1 << 13)) * 0x0001000100010001ULL;
783  c->ugCoeff = roundToInt16(cgu * (1 << 13)) * 0x0001000100010001ULL;
784  c->yOffset = roundToInt16(oy * (1 << 3)) * 0x0001000100010001ULL;
785 
786  c->yuv2rgb_y_coeff = (int16_t)roundToInt16(cy * (1 << 13));
787  c->yuv2rgb_y_offset = (int16_t)roundToInt16(oy * (1 << 9));
788  c->yuv2rgb_v2r_coeff = (int16_t)roundToInt16(crv * (1 << 13));
789  c->yuv2rgb_v2g_coeff = (int16_t)roundToInt16(cgv * (1 << 13));
790  c->yuv2rgb_u2g_coeff = (int16_t)roundToInt16(cgu * (1 << 13));
791  c->yuv2rgb_u2b_coeff = (int16_t)roundToInt16(cbu * (1 << 13));
792 
793  //scale coefficients by cy
794  crv = ((crv * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
795  cbu = ((cbu * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
796  cgu = ((cgu * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
797  cgv = ((cgv * (1 << 16)) + 0x8000) / FFMAX(cy, 1);
798 
799  av_freep(&c->yuvTable);
800 
801 #define ALLOC_YUV_TABLE(x) \
802  c->yuvTable = av_malloc(x); \
803  if (!c->yuvTable) \
804  return AVERROR(ENOMEM);
805  switch (bpp) {
806  case 1:
807  ALLOC_YUV_TABLE(table_plane_size);
808  y_table = c->yuvTable;
809  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
810  for (i = 0; i < table_plane_size - 110; i++) {
811  y_table[i + 110] = av_clip_uint8((yb + 0x8000) >> 16) >> 7;
812  yb += cy;
813  }
814  fill_table(c->table_gU, 1, cgu, y_table + yoffs);
815  fill_gv_table(c->table_gV, 1, cgv);
816  break;
817  case 4:
818  case 4 | 128:
819  rbase = isRgb ? 3 : 0;
820  gbase = 1;
821  bbase = isRgb ? 0 : 3;
822  ALLOC_YUV_TABLE(table_plane_size * 3);
823  y_table = c->yuvTable;
824  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
825  for (i = 0; i < table_plane_size - 110; i++) {
826  int yval = av_clip_uint8((yb + 0x8000) >> 16);
827  y_table[i + 110] = (yval >> 7) << rbase;
828  y_table[i + 37 + table_plane_size] = ((yval + 43) / 85) << gbase;
829  y_table[i + 110 + 2*table_plane_size] = (yval >> 7) << bbase;
830  yb += cy;
831  }
832  fill_table(c->table_rV, 1, crv, y_table + yoffs);
833  fill_table(c->table_gU, 1, cgu, y_table + yoffs + table_plane_size);
834  fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2*table_plane_size);
835  fill_gv_table(c->table_gV, 1, cgv);
836  break;
837  case 8:
838  rbase = isRgb ? 5 : 0;
839  gbase = isRgb ? 2 : 3;
840  bbase = isRgb ? 0 : 6;
841  ALLOC_YUV_TABLE(table_plane_size * 3);
842  y_table = c->yuvTable;
843  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
844  for (i = 0; i < table_plane_size - 38; i++) {
845  int yval = av_clip_uint8((yb + 0x8000) >> 16);
846  y_table[i + 16] = ((yval + 18) / 36) << rbase;
847  y_table[i + 16 + table_plane_size] = ((yval + 18) / 36) << gbase;
848  y_table[i + 37 + 2*table_plane_size] = ((yval + 43) / 85) << bbase;
849  yb += cy;
850  }
851  fill_table(c->table_rV, 1, crv, y_table + yoffs);
852  fill_table(c->table_gU, 1, cgu, y_table + yoffs + table_plane_size);
853  fill_table(c->table_bU, 1, cbu, y_table + yoffs + 2*table_plane_size);
854  fill_gv_table(c->table_gV, 1, cgv);
855  break;
856  case 12:
857  rbase = isRgb ? 8 : 0;
858  gbase = 4;
859  bbase = isRgb ? 0 : 8;
860  ALLOC_YUV_TABLE(table_plane_size * 3 * 2);
861  y_table16 = c->yuvTable;
862  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
863  for (i = 0; i < table_plane_size; i++) {
864  uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
865  y_table16[i] = (yval >> 4) << rbase;
866  y_table16[i + table_plane_size] = (yval >> 4) << gbase;
867  y_table16[i + 2*table_plane_size] = (yval >> 4) << bbase;
868  yb += cy;
869  }
870  if (isNotNe)
871  for (i = 0; i < table_plane_size * 3; i++)
872  y_table16[i] = av_bswap16(y_table16[i]);
873  fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
874  fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + table_plane_size);
875  fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2*table_plane_size);
876  fill_gv_table(c->table_gV, 2, cgv);
877  break;
878  case 15:
879  case 16:
880  rbase = isRgb ? bpp - 5 : 0;
881  gbase = 5;
882  bbase = isRgb ? 0 : (bpp - 5);
883  ALLOC_YUV_TABLE(table_plane_size * 3 * 2);
884  y_table16 = c->yuvTable;
885  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
886  for (i = 0; i < table_plane_size; i++) {
887  uint8_t yval = av_clip_uint8((yb + 0x8000) >> 16);
888  y_table16[i] = (yval >> 3) << rbase;
889  y_table16[i + table_plane_size] = (yval >> (18 - bpp)) << gbase;
890  y_table16[i + 2*table_plane_size] = (yval >> 3) << bbase;
891  yb += cy;
892  }
893  if (isNotNe)
894  for (i = 0; i < table_plane_size * 3; i++)
895  y_table16[i] = av_bswap16(y_table16[i]);
896  fill_table(c->table_rV, 2, crv, y_table16 + yoffs);
897  fill_table(c->table_gU, 2, cgu, y_table16 + yoffs + table_plane_size);
898  fill_table(c->table_bU, 2, cbu, y_table16 + yoffs + 2*table_plane_size);
899  fill_gv_table(c->table_gV, 2, cgv);
900  break;
901  case 24:
902  case 48:
903  ALLOC_YUV_TABLE(table_plane_size);
904  y_table = c->yuvTable;
905  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
906  for (i = 0; i < table_plane_size; i++) {
907  y_table[i] = av_clip_uint8((yb + 0x8000) >> 16);
908  yb += cy;
909  }
910  fill_table(c->table_rV, 1, crv, y_table + yoffs);
911  fill_table(c->table_gU, 1, cgu, y_table + yoffs);
912  fill_table(c->table_bU, 1, cbu, y_table + yoffs);
913  fill_gv_table(c->table_gV, 1, cgv);
914  break;
915  case 30:
916  rbase = isRgb ? 20 : 0;
917  gbase = 10;
918  bbase = isRgb ? 0 : 20;
919  needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format);
920  if (!needAlpha)
921  abase = 30;
922  ALLOC_YUV_TABLE(table_plane_size * 3 * 4);
923  y_table32 = c->yuvTable;
924  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
925  for (i = 0; i < table_plane_size; i++) {
926  unsigned yval = av_clip_uintp2((yb + 0x8000) >> 14, 10);
927  y_table32[i]= (yval << rbase) + (needAlpha ? 0 : (255u << abase));
928  y_table32[i + table_plane_size] = yval << gbase;
929  y_table32[i + 2 * table_plane_size] = yval << bbase;
930  yb += cy;
931  }
932  if (isNotNe) {
933  for (i = 0; i < table_plane_size * 3; i++)
934  y_table32[i] = av_bswap32(y_table32[i]);
935  }
936  fill_table(c->table_rV, 4, crv, y_table32 + yoffs);
937  fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + table_plane_size);
938  fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2 * table_plane_size);
939  fill_gv_table(c->table_gV, 4, cgv);
940  break;
941  case 32:
942  case 64:
943  base = (c->opts.dst_format == AV_PIX_FMT_RGB32_1 ||
944  c->opts.dst_format == AV_PIX_FMT_BGR32_1) ? 8 : 0;
945  rbase = base + (isRgb ? 16 : 0);
946  gbase = base + 8;
947  bbase = base + (isRgb ? 0 : 16);
948  needAlpha = CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format);
949  if (!needAlpha)
950  abase = (base + 24) & 31;
951  ALLOC_YUV_TABLE(table_plane_size * 3 * 4);
952  y_table32 = c->yuvTable;
953  yb = -(384 << 16) - YUVRGB_TABLE_LUMA_HEADROOM*cy - oy;
954  for (i = 0; i < table_plane_size; i++) {
955  unsigned yval = av_clip_uint8((yb + 0x8000) >> 16);
956  y_table32[i] = (yval << rbase) +
957  (needAlpha ? 0 : (255u << abase));
958  y_table32[i + table_plane_size] = yval << gbase;
959  y_table32[i + 2*table_plane_size] = yval << bbase;
960  yb += cy;
961  }
962  fill_table(c->table_rV, 4, crv, y_table32 + yoffs);
963  fill_table(c->table_gU, 4, cgu, y_table32 + yoffs + table_plane_size);
964  fill_table(c->table_bU, 4, cbu, y_table32 + yoffs + 2*table_plane_size);
965  fill_gv_table(c->table_gV, 4, cgv);
966  break;
967  default:
968  if(!isPlanar(c->opts.dst_format) || bpp <= 24)
969  av_log(c, AV_LOG_ERROR, "%ibpp not supported by yuv2rgb\n", bpp);
970  return AVERROR(EINVAL);
971  }
972  return 0;
973 }
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
av_cold
#define av_cold
Definition: attributes.h:119
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
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)
av_unused
#define av_unused
Definition: attributes.h:164
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
LOADDITHER8
#define LOADDITHER8
Definition: yuv2rgb.c:413
YUVRGB_TABLE_HEADROOM
#define YUVRGB_TABLE_HEADROOM
Definition: swscale_internal.h:52
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
av_fallthrough
#define av_fallthrough
Definition: attributes.h:67
LOADDITHER4D
#define LOADDITHER4D
Definition: yuv2rgb.c:427
V
#define V
Definition: avdct.c:32
AV_PIX_FMT_BGR565LE
@ AV_PIX_FMT_BGR565LE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), little-endian
Definition: pixfmt.h:118
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_BGR555BE
@ AV_PIX_FMT_BGR555BE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:119
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_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:511
AV_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition: pixfmt.h:117
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:215
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_uninit
#define av_uninit(x)
Definition: attributes.h:187
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_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition: swscale.h:466
YUVRGB_TABLE_LUMA_HEADROOM
#define YUVRGB_TABLE_LUMA_HEADROOM
Definition: swscale_internal.h:53
PUTGBRP
#define PUTGBRP(l, i, abase)
Definition: yuv2rgb.c:127
SwsInternal
Definition: swscale_internal.h:337
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_PIX_FMT_BGR555LE
@ AV_PIX_FMT_BGR555LE
packed BGR 5:5:5, 16bpp, (msb)1X 5B 5G 5R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:120
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:99
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:916
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:898
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 Tue Jul 7 2026 19:24:32 for FFmpeg by   doxygen 1.8.17