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