FFmpeg
Loading...
Searching...
No Matches
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 */
47const 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
61const 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
457YUV2RGBFUNC(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;
517ENDYUV2RGBFUNC()
518
519// YUV420
520YUV420FUNC(yuv2rgb_c_48, uint8_t, 0, 0, PUTRGB48, 48, 1)
521YUV420FUNC(yuv2rgb_c_bgr48, uint8_t, 0, 0, PUTBGR48, 48, 1)
522YUV420FUNC(yuv2rgb_c_32, uint32_t, 0, 0, PUTRGB, 8, 1)
523#if HAVE_BIGENDIAN
524YUV420FUNC(yuva2argb_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
525YUV420FUNC(yuva2rgba_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
526#else
527YUV420FUNC(yuva2rgba_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
528YUV420FUNC(yuva2argb_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
529#endif
530YUV420FUNC(yuv2rgb_c_24_rgb, uint8_t, 0, 0, PUTRGB24, 24, 1)
531YUV420FUNC(yuv2rgb_c_24_bgr, uint8_t, 0, 0, PUTBGR24, 24, 1)
532YUV420FUNC(yuv420p_gbrp_c, uint8_t, 0, 0, PUTGBRP, 8, 3)
533YUV420FUNC_DITHER(yuv2rgb_c_16_ordered_dither, uint16_t, LOADDITHER16, PUTRGB16, 8)
534YUV420FUNC_DITHER(yuv2rgb_c_15_ordered_dither, uint16_t, LOADDITHER15, PUTRGB15, 8)
535YUV420FUNC_DITHER(yuv2rgb_c_12_ordered_dither, uint16_t, LOADDITHER12, PUTRGB12, 8)
536YUV420FUNC_DITHER(yuv2rgb_c_8_ordered_dither, uint8_t, LOADDITHER8, PUTRGB8, 8)
537YUV420FUNC_DITHER(yuv2rgb_c_4_ordered_dither, uint8_t, LOADDITHER4D, PUTRGB4D, 4)
538YUV420FUNC_DITHER(yuv2rgb_c_4b_ordered_dither, uint8_t, LOADDITHER4DB, PUTRGB4DB, 8)
539
540// YUV422
541YUV422FUNC(yuv422p_rgb48_c, uint8_t, 0, 0, PUTRGB48, 48, 1)
542YUV422FUNC(yuv422p_bgr48_c, uint8_t, 0, 0, PUTBGR48, 48, 1)
543YUV422FUNC(yuv422p_rgb32_c, uint32_t, 0, 0, PUTRGB, 8, 1)
544#if HAVE_BIGENDIAN
545YUV422FUNC(yuva422p_argb_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
546YUV422FUNC(yuva422p_rgba_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
547#else
548YUV422FUNC(yuva422p_rgba_c, uint32_t, 1, 24, PUTRGBA, 8, 1)
549YUV422FUNC(yuva422p_argb_c, uint32_t, 1, 0, PUTRGBA, 8, 1)
550#endif
551YUV422FUNC(yuv422p_rgb24_c, uint8_t, 0, 0, PUTRGB24, 24, 1)
552YUV422FUNC(yuv422p_bgr24_c, uint8_t, 0, 0, PUTBGR24, 24, 1)
553YUV422FUNC(yuv422p_gbrp_c, uint8_t, 0, 0, PUTGBRP, 8, 3)
554YUV422FUNC_DITHER(yuv422p_bgr16, uint16_t, LOADDITHER16, PUTRGB16, 8)
555YUV422FUNC_DITHER(yuv422p_bgr15, uint16_t, LOADDITHER15, PUTRGB15, 8)
556YUV422FUNC_DITHER(yuv422p_bgr12, uint16_t, LOADDITHER12, PUTRGB12, 8)
557YUV422FUNC_DITHER(yuv422p_bgr8, uint8_t, LOADDITHER8, PUTRGB8, 8)
558YUV422FUNC_DITHER(yuv422p_bgr4, uint8_t, LOADDITHER4D, PUTRGB4D, 4)
559YUV422FUNC_DITHER(yuv422p_bgr4_byte, uint8_t, LOADDITHER4DB, PUTRGB4DB, 8)
560
561SwsFunc 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
680static 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
694static 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
705static 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
717av_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}
ff_yuv2rgb_init_aarch64
av_cold SwsFunc ff_yuv2rgb_init_aarch64(SwsInternal *c)
Definition swscale_unscaled.c:215
U
#define U(x)
Definition vpx_arith.h:37
int32_t
int32_t
Definition audioconvert.c:56
V
#define V
Definition avdct.c:32
Y
#define Y
Definition boxblur.h:37
bswap.h
byte swapping routines
i
#define i(width, name, range_min, range_max)
Definition cbs_h264.c:63
f
#define f(width, name)
Definition cbs_vp8.c:236
saturation
static IPT saturation(const CmsCtx *ctx, IPT ipt)
Definition cms.c:559
av_clip_uint8
#define av_clip_uint8
Definition common.h:106
av_clip_uintp2
#define av_clip_uintp2
Definition common.h:124
NULL
#define NULL
Definition coverity.c:32
int64_t
long long int64_t
Definition coverity.c:34
AVERROR
#define AVERROR(e)
Definition error.h:45
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
SWS_CS_DEFAULT
#define SWS_CS_DEFAULT
Definition swscale.h:464
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
r
#define r
Definition input.c:42
av_fallthrough
#define av_fallthrough
Definition attributes.h:67
av_unused
#define av_unused
Definition attributes.h:164
av_uninit
#define av_uninit(x)
Definition attributes.h:187
av_cold
#define av_cold
Definition attributes.h:117
FFMAX
#define FFMAX(a, b)
Definition macros.h:47
mem.h
Memory handling functions.
ff_dither_8x8_220
const uint8_t ff_dither_8x8_220[][8]
Definition output.c:85
inc
static int inc(int num, int period)
Definition perlin.c:34
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:3380
AV_PIX_FMT_BGR444
#define AV_PIX_FMT_BGR444
Definition pixfmt.h:539
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition pixfmt.h:75
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_PIX_FMT_BGR565BE
@ AV_PIX_FMT_BGR565BE
packed BGR 5:6:5, 16bpp, (msb) 5B 6G 5R(lsb), big-endian
Definition pixfmt.h:117
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
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition pixfmt.h:99
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
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition pixfmt.h:102
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_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
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition pixfmt.h:101
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_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition pixfmt.h:90
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_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_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_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition pixfmt.h:100
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
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_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_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_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
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_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
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
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_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition pixfmt.h:76
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition pixfmt.h:165
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_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_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
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_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition pixfmt.h:518
AV_PIX_FMT_BGR32_1
#define AV_PIX_FMT_BGR32_1
Definition pixfmt.h:520
AV_PIX_FMT_RGB444
#define AV_PIX_FMT_RGB444
Definition pixfmt.h:534
AV_PIX_FMT_NE
#define AV_PIX_FMT_NE(be, le)
Definition pixfmt.h:514
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition pixfmt.h:517
table
static const uint16_t table[]
Definition prosumer.c:203
av_bswap32
#define av_bswap32
Definition bswap.h:47
av_bswap16
#define av_bswap16
Definition bswap.h:28
swscale.h
external API header
ff_yuv2rgb_init_loongarch
av_cold SwsFunc ff_yuv2rgb_init_loongarch(SwsInternal *c)
Definition swscale_init_loongarch.c:104
swscale_internal.h
YUVRGB_TABLE_HEADROOM
#define YUVRGB_TABLE_HEADROOM
Definition swscale_internal.h:52
YUVRGB_TABLE_LUMA_HEADROOM
#define YUVRGB_TABLE_LUMA_HEADROOM
Definition swscale_internal.h:53
isPlanar
static av_always_inline int isPlanar(enum AVPixelFormat pix_fmt)
Definition swscale_internal.h:915
ff_yuv2rgb_get_func_ptr
SwsFunc ff_yuv2rgb_get_func_ptr(SwsInternal *c)
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
isALPHA
static av_always_inline int isALPHA(enum AVPixelFormat pix_fmt)
Definition swscale_internal.h:897
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_yuv2rgb_coeffs
const int32_t ff_yuv2rgb_coeffs[11][4]
Definition yuv2rgb.c:47
av_freep
#define av_freep(p)
Definition tableprint_vlc.h:35
av_log
#define av_log(a,...)
Definition tableprint_vlc.h:27
g
const char * g
Definition vf_curves.c:128
cb
static double cb(void *priv, double x, double y)
Definition vf_geq.c:247
base
uint8_t base
Definition vp3data.h:128
c
static double c[64]
Definition vsrc_mptestsrc.c:89
ff_yuv2rgb_init_x86
av_cold SwsFunc ff_yuv2rgb_init_x86(SwsInternal *c)
Definition yuv2rgb.c:241
out_2
char out_2
Definition yuv2rgb.c:459
LOADDITHER16
#define LOADDITHER16
Definition yuv2rgb.c:371
YUV422FUNC_DITHER
#define YUV422FUNC_DITHER(func_name, dst_type, LOADDITHER, PUTFUNC, dst_delta)
Definition yuv2rgb.c:320
PUTRGB12
#define PUTRGB12(l, i, o)
Definition yuv2rgb.c:403
PUTRGB1_OR00
#define PUTRGB1_OR00(out, src, i, o)
PUTRGB8
#define PUTRGB8(l, i, o)
Definition yuv2rgb.c:417
PUTRGB4D
#define PUTRGB4D(l, i, o)
Definition yuv2rgb.c:432
py_2
py_2
Definition yuv2rgb.c:484
PUTRGB15
#define PUTRGB15(l, i, o)
Definition yuv2rgb.c:390
PUTRGB1
#define PUTRGB1(out, src, i, o)
Definition yuv2rgb.c:462
PUTGBRP
#define PUTGBRP(l, i, abase)
Definition yuv2rgb.c:127
YUV422FUNC
#define YUV422FUNC(func_name, dst_type, alpha, abase, PUTFUNC, dst_delta, nb_dst_planes)
Definition yuv2rgb.c:238
ENDYUV2RGBFUNC
#define ENDYUV2RGBFUNC()
Definition yuv2rgb.c:201
LOADDITHER15
#define LOADDITHER15
Definition yuv2rgb.c:386
py_1
py_1
Definition yuv2rgb.c:483
PUTRGBA
#define PUTRGBA(l, i, abase)
Definition yuv2rgb.c:101
LOADDITHER4D
#define LOADDITHER4D
Definition yuv2rgb.c:427
LOADDITHER8
#define LOADDITHER8
Definition yuv2rgb.c:413
PUTRGB16
#define PUTRGB16(l, i, o)
Definition yuv2rgb.c:376
PUTRGB48
#define PUTRGB48(l, i, abase)
Definition yuv2rgb.c:107
YUV420FUNC
#define YUV420FUNC(func_name, dst_type, alpha, abase, PUTFUNC, dst_delta, nb_dst_planes)
Definition yuv2rgb.c:207
LOADDITHER4DB
#define LOADDITHER4DB
Definition yuv2rgb.c:443
ALLOC_YUV_TABLE
#define ALLOC_YUV_TABLE(x)
LOADDITHER12
#define LOADDITHER12
Definition yuv2rgb.c:400
dst_1
dst_1[0]
Definition yuv2rgb.c:480
d128
const uint8_t * d128
Definition yuv2rgb.c:458
PUTRGB4DB
#define PUTRGB4DB(l, i, o)
Definition yuv2rgb.c:447
out_1
char out_1
Definition yuv2rgb.c:459
YUV420FUNC_DITHER
#define YUV420FUNC_DITHER(func_name, dst_type, LOADDITHER, PUTFUNC, dst_delta)
Definition yuv2rgb.c:283
dst_2
dst_2[0]
Definition yuv2rgb.c:481
PUTBGR48
#define PUTBGR48(l, i, abase)
Definition yuv2rgb.c:117
YUV2RGBFUNC
#define YUV2RGBFUNC(func_name, dst_type, alpha, yuv422, nb_dst_planes)
Definition yuv2rgb.c:137
ff_yuv2rgb_init_ppc
av_cold SwsFunc ff_yuv2rgb_init_ppc(SwsInternal *c)
Definition yuv2rgb_altivec.c:567
PUTRGB
#define PUTRGB(dst, src)
Definition yuv2rgb_lsx.c:227
PUTBGR24
#define PUTBGR24(dst, src)
Definition yuv2rgb_lsx.c:217
PUTRGB24
#define PUTRGB24(dst, src)
Definition yuv2rgb_lsx.c:207
Generated on Sun Aug 23 2026 19:21:11 for FFmpeg by doxygen 1.13.2