FFmpeg
output.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2001-2012 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <math.h>
22 #include <stddef.h>
23 #include <stdint.h>
24 #include <string.h>
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/avutil.h"
28 #include "libavutil/avassert.h"
29 #include "libavutil/bswap.h"
30 #include "libavutil/intfloat.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/pixdesc.h"
35 #include "config.h"
36 #include "rgb2rgb.h"
37 #include "swscale.h"
38 #include "swscale_internal.h"
39 
40 DECLARE_ALIGNED(8, const uint8_t, ff_dither_2x2_4)[][8] = {
41 { 1, 3, 1, 3, 1, 3, 1, 3, },
42 { 2, 0, 2, 0, 2, 0, 2, 0, },
43 { 1, 3, 1, 3, 1, 3, 1, 3, },
44 };
45 
46 DECLARE_ALIGNED(8, const uint8_t, ff_dither_2x2_8)[][8] = {
47 { 6, 2, 6, 2, 6, 2, 6, 2, },
48 { 0, 4, 0, 4, 0, 4, 0, 4, },
49 { 6, 2, 6, 2, 6, 2, 6, 2, },
50 };
51 
52 DECLARE_ALIGNED(8, const uint8_t, ff_dither_4x4_16)[][8] = {
53 { 8, 4, 11, 7, 8, 4, 11, 7, },
54 { 2, 14, 1, 13, 2, 14, 1, 13, },
55 { 10, 6, 9, 5, 10, 6, 9, 5, },
56 { 0, 12, 3, 15, 0, 12, 3, 15, },
57 { 8, 4, 11, 7, 8, 4, 11, 7, },
58 };
59 
60 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_32)[][8] = {
61 { 17, 9, 23, 15, 16, 8, 22, 14, },
62 { 5, 29, 3, 27, 4, 28, 2, 26, },
63 { 21, 13, 19, 11, 20, 12, 18, 10, },
64 { 0, 24, 6, 30, 1, 25, 7, 31, },
65 { 16, 8, 22, 14, 17, 9, 23, 15, },
66 { 4, 28, 2, 26, 5, 29, 3, 27, },
67 { 20, 12, 18, 10, 21, 13, 19, 11, },
68 { 1, 25, 7, 31, 0, 24, 6, 30, },
69 { 17, 9, 23, 15, 16, 8, 22, 14, },
70 };
71 
72 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_73)[][8] = {
73 { 0, 55, 14, 68, 3, 58, 17, 72, },
74 { 37, 18, 50, 32, 40, 22, 54, 35, },
75 { 9, 64, 5, 59, 13, 67, 8, 63, },
76 { 46, 27, 41, 23, 49, 31, 44, 26, },
77 { 2, 57, 16, 71, 1, 56, 15, 70, },
78 { 39, 21, 52, 34, 38, 19, 51, 33, },
79 { 11, 66, 7, 62, 10, 65, 6, 60, },
80 { 48, 30, 43, 25, 47, 29, 42, 24, },
81 { 0, 55, 14, 68, 3, 58, 17, 72, },
82 };
83 
84 #if 1
85 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_220)[][8] = {
86 {117, 62, 158, 103, 113, 58, 155, 100, },
87 { 34, 199, 21, 186, 31, 196, 17, 182, },
88 {144, 89, 131, 76, 141, 86, 127, 72, },
89 { 0, 165, 41, 206, 10, 175, 52, 217, },
90 {110, 55, 151, 96, 120, 65, 162, 107, },
91 { 28, 193, 14, 179, 38, 203, 24, 189, },
92 {138, 83, 124, 69, 148, 93, 134, 79, },
93 { 7, 172, 48, 213, 3, 168, 45, 210, },
94 {117, 62, 158, 103, 113, 58, 155, 100, },
95 };
96 #elif 1
97 // tries to correct a gamma of 1.5
98 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_220)[][8] = {
99 { 0, 143, 18, 200, 2, 156, 25, 215, },
100 { 78, 28, 125, 64, 89, 36, 138, 74, },
101 { 10, 180, 3, 161, 16, 195, 8, 175, },
102 {109, 51, 93, 38, 121, 60, 105, 47, },
103 { 1, 152, 23, 210, 0, 147, 20, 205, },
104 { 85, 33, 134, 71, 81, 30, 130, 67, },
105 { 14, 190, 6, 171, 12, 185, 5, 166, },
106 {117, 57, 101, 44, 113, 54, 97, 41, },
107 { 0, 143, 18, 200, 2, 156, 25, 215, },
108 };
109 #elif 1
110 // tries to correct a gamma of 2.0
111 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_220)[][8] = {
112 { 0, 124, 8, 193, 0, 140, 12, 213, },
113 { 55, 14, 104, 42, 66, 19, 119, 52, },
114 { 3, 168, 1, 145, 6, 187, 3, 162, },
115 { 86, 31, 70, 21, 99, 39, 82, 28, },
116 { 0, 134, 11, 206, 0, 129, 9, 200, },
117 { 62, 17, 114, 48, 58, 16, 109, 45, },
118 { 5, 181, 2, 157, 4, 175, 1, 151, },
119 { 95, 36, 78, 26, 90, 34, 74, 24, },
120 { 0, 124, 8, 193, 0, 140, 12, 213, },
121 };
122 #else
123 // tries to correct a gamma of 2.5
124 DECLARE_ALIGNED(8, const uint8_t, ff_dither_8x8_220)[][8] = {
125 { 0, 107, 3, 187, 0, 125, 6, 212, },
126 { 39, 7, 86, 28, 49, 11, 102, 36, },
127 { 1, 158, 0, 131, 3, 180, 1, 151, },
128 { 68, 19, 52, 12, 81, 25, 64, 17, },
129 { 0, 119, 5, 203, 0, 113, 4, 195, },
130 { 45, 9, 96, 33, 42, 8, 91, 30, },
131 { 2, 172, 1, 144, 2, 165, 0, 137, },
132 { 77, 23, 60, 15, 72, 21, 56, 14, },
133 { 0, 107, 3, 187, 0, 125, 6, 212, },
134 };
135 #endif
136 
137 #define IS_BE_LE 0
138 #define IS_BE_BE 1
139 /* ENDIAN_IDENTIFIER needs to be "BE" or "LE". */
140 #define IS_BE(ENDIAN_IDENTIFIER) IS_BE_ ## ENDIAN_IDENTIFIER
141 
142 #define output_pixel(pos, val, bias, signedness) \
143  if (big_endian) { \
144  AV_WB16(pos, bias + av_clip_ ## signedness ## 16(val >> shift)); \
145  } else { \
146  AV_WL16(pos, bias + av_clip_ ## signedness ## 16(val >> shift)); \
147  }
148 
149 static av_always_inline void
150 yuv2plane1_16_c_template(const int32_t *src, uint16_t *dest, int dstW,
151  int big_endian, int output_bits)
152 {
153  int i;
154  int shift = 3;
155  av_assert0(output_bits == 16);
156 
157  for (i = 0; i < dstW; i++) {
158  int val = src[i] + (1 << (shift - 1));
159  output_pixel(&dest[i], val, 0, uint);
160  }
161 }
162 
163 static av_always_inline void
164 yuv2planeX_16_c_template(const int16_t *filter, int filterSize,
165  const int32_t **src, uint16_t *dest, int dstW,
166  int big_endian, int output_bits)
167 {
168  int i;
169  int shift = 15;
170  av_assert0(output_bits == 16);
171 
172  for (i = 0; i < dstW; i++) {
173  int val = 1 << (shift - 1);
174  int j;
175 
176  /* range of val is [0,0x7FFFFFFF], so 31 bits, but with lanczos/spline
177  * filters (or anything with negative coeffs, the range can be slightly
178  * wider in both directions. To account for this overflow, we subtract
179  * a constant so it always fits in the signed range (assuming a
180  * reasonable filterSize), and re-add that at the end. */
181  val -= 0x40000000;
182  for (j = 0; j < filterSize; j++)
183  val += src[j][i] * (unsigned)filter[j];
184 
185  output_pixel(&dest[i], val, 0x8000, int);
186  }
187 }
188 
189 static av_always_inline void
190 yuv2nv12cX_16_c_template(int big_endian, const uint8_t *chrDither,
191  const int16_t *chrFilter, int chrFilterSize,
192  const int16_t **chrUSrc, const int16_t **chrVSrc,
193  uint8_t *dest8, int chrDstW, int output_bits)
194 {
195  uint16_t *dest = (uint16_t*)dest8;
196  const int32_t **uSrc = (const int32_t **)chrUSrc;
197  const int32_t **vSrc = (const int32_t **)chrVSrc;
198  int shift = 15;
199  int i, j;
200  av_assert0(output_bits == 16);
201 
202  for (i = 0; i < chrDstW; i++) {
203  int u = 1 << (shift - 1);
204  int v = 1 << (shift - 1);
205 
206  /* See yuv2planeX_16_c_template for details. */
207  u -= 0x40000000;
208  v -= 0x40000000;
209  for (j = 0; j < chrFilterSize; j++) {
210  u += uSrc[j][i] * (unsigned)chrFilter[j];
211  v += vSrc[j][i] * (unsigned)chrFilter[j];
212  }
213 
214  output_pixel(&dest[2*i] , u, 0x8000, int);
215  output_pixel(&dest[2*i+1], v, 0x8000, int);
216  }
217 }
218 
219 static av_always_inline void
220 yuv2plane1_float_c_template(const int32_t *src, float *dest, int dstW)
221 {
222  static const int big_endian = HAVE_BIGENDIAN;
223  static const int shift = 3;
224  static const float float_mult = 1.0f / 65535.0f;
225  int i, val;
226  uint16_t val_uint;
227 
228  for (i = 0; i < dstW; ++i){
229  val = src[i] + (1 << (shift - 1));
230  output_pixel(&val_uint, val, 0, uint);
231  dest[i] = float_mult * (float)val_uint;
232  }
233 }
234 
235 static av_always_inline void
236 yuv2plane1_float_bswap_c_template(const int32_t *src, uint32_t *dest, int dstW)
237 {
238  static const int big_endian = HAVE_BIGENDIAN;
239  static const int shift = 3;
240  static const float float_mult = 1.0f / 65535.0f;
241  int i, val;
242  uint16_t val_uint;
243 
244  for (i = 0; i < dstW; ++i){
245  val = src[i] + (1 << (shift - 1));
246  output_pixel(&val_uint, val, 0, uint);
247  dest[i] = av_bswap32(av_float2int(float_mult * (float)val_uint));
248  }
249 }
250 
251 static av_always_inline void
252 yuv2planeX_float_c_template(const int16_t *filter, int filterSize, const int32_t **src,
253  float *dest, int dstW)
254 {
255  static const int big_endian = HAVE_BIGENDIAN;
256  static const int shift = 15;
257  static const float float_mult = 1.0f / 65535.0f;
258  int i, j, val;
259  uint16_t val_uint;
260 
261  for (i = 0; i < dstW; ++i){
262  val = (1 << (shift - 1)) - 0x40000000;
263  for (j = 0; j < filterSize; ++j){
264  val += src[j][i] * (unsigned)filter[j];
265  }
266  output_pixel(&val_uint, val, 0x8000, int);
267  dest[i] = float_mult * (float)val_uint;
268  }
269 }
270 
271 static av_always_inline void
272 yuv2planeX_float_bswap_c_template(const int16_t *filter, int filterSize, const int32_t **src,
273  uint32_t *dest, int dstW)
274 {
275  static const int big_endian = HAVE_BIGENDIAN;
276  static const int shift = 15;
277  static const float float_mult = 1.0f / 65535.0f;
278  int i, j, val;
279  uint16_t val_uint;
280 
281  for (i = 0; i < dstW; ++i){
282  val = (1 << (shift - 1)) - 0x40000000;
283  for (j = 0; j < filterSize; ++j){
284  val += src[j][i] * (unsigned)filter[j];
285  }
286  output_pixel(&val_uint, val, 0x8000, int);
287  dest[i] = av_bswap32(av_float2int(float_mult * (float)val_uint));
288  }
289 }
290 
291 #define yuv2plane1_float(template, dest_type, BE_LE) \
292 static void yuv2plane1_float ## BE_LE ## _c(const int16_t *src, uint8_t *dest, int dstW, \
293  const uint8_t *dither, int offset) \
294 { \
295  template((const int32_t *)src, (dest_type *)dest, dstW); \
296 }
297 
298 #define yuv2planeX_float(template, dest_type, BE_LE) \
299 static void yuv2planeX_float ## BE_LE ## _c(const int16_t *filter, int filterSize, \
300  const int16_t **src, uint8_t *dest, int dstW, \
301  const uint8_t *dither, int offset) \
302 { \
303  template(filter, filterSize, (const int32_t **)src, (dest_type *)dest, dstW); \
304 }
305 
306 #if HAVE_BIGENDIAN
307 yuv2plane1_float(yuv2plane1_float_c_template, float, BE)
308 yuv2plane1_float(yuv2plane1_float_bswap_c_template, uint32_t, LE)
309 yuv2planeX_float(yuv2planeX_float_c_template, float, BE)
310 yuv2planeX_float(yuv2planeX_float_bswap_c_template, uint32_t, LE)
311 #else
312 yuv2plane1_float(yuv2plane1_float_c_template, float, LE)
313 yuv2plane1_float(yuv2plane1_float_bswap_c_template, uint32_t, BE)
314 yuv2planeX_float(yuv2planeX_float_c_template, float, LE)
315 yuv2planeX_float(yuv2planeX_float_bswap_c_template, uint32_t, BE)
316 #endif
317 
318 #undef output_pixel
319 
320 #define output_pixel(pos, val) \
321  if (big_endian) { \
322  AV_WB16(pos, av_clip_uintp2(val >> shift, output_bits)); \
323  } else { \
324  AV_WL16(pos, av_clip_uintp2(val >> shift, output_bits)); \
325  }
326 
327 static av_always_inline void
328 yuv2plane1_10_c_template(const int16_t *src, uint16_t *dest, int dstW,
329  int big_endian, int output_bits)
330 {
331  int i;
332  int shift = 15 - output_bits;
333 
334  for (i = 0; i < dstW; i++) {
335  int val = src[i] + (1 << (shift - 1));
336  output_pixel(&dest[i], val);
337  }
338 }
339 
340 static av_always_inline void
341 yuv2planeX_10_c_template(const int16_t *filter, int filterSize,
342  const int16_t **src, uint16_t *dest, int dstW,
343  int big_endian, int output_bits)
344 {
345  int i;
346  int shift = 11 + 16 - output_bits;
347 
348  for (i = 0; i < dstW; i++) {
349  int val = 1 << (shift - 1);
350  int j;
351 
352  for (j = 0; j < filterSize; j++)
353  val += src[j][i] * filter[j];
354 
355  output_pixel(&dest[i], val);
356  }
357 }
358 
359 #undef output_pixel
360 
361 #define yuv2NBPS(bits, BE_LE, is_be, template_size, typeX_t) \
362 static void yuv2plane1_ ## bits ## BE_LE ## _c(const int16_t *src, \
363  uint8_t *dest, int dstW, \
364  const uint8_t *dither, int offset)\
365 { \
366  yuv2plane1_ ## template_size ## _c_template((const typeX_t *) src, \
367  (uint16_t *) dest, dstW, is_be, bits); \
368 }\
369 static void yuv2planeX_ ## bits ## BE_LE ## _c(const int16_t *filter, int filterSize, \
370  const int16_t **src, uint8_t *dest, int dstW, \
371  const uint8_t *dither, int offset)\
372 { \
373  yuv2planeX_## template_size ## _c_template(filter, \
374  filterSize, (const typeX_t **) src, \
375  (uint16_t *) dest, dstW, is_be, bits); \
376 }
377 
378 yuv2NBPS( 9, BE, 1, 10, int16_t)
379 yuv2NBPS( 9, LE, 0, 10, int16_t)
380 yuv2NBPS(10, BE, 1, 10, int16_t)
381 yuv2NBPS(10, LE, 0, 10, int16_t)
382 yuv2NBPS(12, BE, 1, 10, int16_t)
383 yuv2NBPS(12, LE, 0, 10, int16_t)
384 yuv2NBPS(14, BE, 1, 10, int16_t)
385 yuv2NBPS(14, LE, 0, 10, int16_t)
386 yuv2NBPS(16, BE, 1, 16, int32_t)
387 yuv2NBPS(16, LE, 0, 16, int32_t)
388 
389 #define output_pixel(pos, val) \
390  if (big_endian) { \
391  AV_WB16(pos, av_clip_uintp2(val >> shift, output_bits) << (16 - output_bits)); \
392  } else { \
393  AV_WL16(pos, av_clip_uintp2(val >> shift, output_bits) << (16 - output_bits)); \
394  }
395 
396 static av_always_inline void
397 yuv2msbplane1_10_c_template(const int16_t *src, uint16_t *dest, int dstW,
398  int big_endian, int output_bits)
399 {
400  int i;
401  int shift = 15 - output_bits;
402 
403  for (i = 0; i < dstW; i++) {
404  int val = src[i] + (1 << (shift - 1));
405  output_pixel(&dest[i], val);
406  }
407 }
408 
409 static av_always_inline void
410 yuv2msbplaneX_10_c_template(const int16_t *filter, int filterSize,
411  const int16_t **src, uint16_t *dest, int dstW,
412  int big_endian, int output_bits)
413 {
414  int i;
415  int shift = 11 + 16 - output_bits;
416 
417  for (i = 0; i < dstW; i++) {
418  int val = 1 << (shift - 1);
419  int j;
420 
421  for (j = 0; j < filterSize; j++)
422  val += src[j][i] * filter[j];
423 
424  output_pixel(&dest[i], val);
425  }
426 }
427 
428 #define yuv2MSBNBPS(bits, BE_LE, is_be, template_size, typeX_t) \
429 static void yuv2msbplane1_ ## bits ## BE_LE ## _c(const int16_t *src, \
430  uint8_t *dest, int dstW, \
431  const uint8_t *dither, int offset)\
432 { \
433  yuv2msbplane1_ ## template_size ## _c_template((const typeX_t *) src, \
434  (uint16_t *) dest, dstW, is_be, bits); \
435 }\
436 static void yuv2msbplaneX_ ## bits ## BE_LE ## _c(const int16_t *filter, int filterSize, \
437  const int16_t **src, uint8_t *dest, int dstW, \
438  const uint8_t *dither, int offset)\
439 { \
440  yuv2msbplaneX_## template_size ## _c_template(filter, \
441  filterSize, (const typeX_t **) src, \
442  (uint16_t *) dest, dstW, is_be, bits); \
443 }
444 
445 yuv2MSBNBPS(10, BE, 1, 10, int16_t)
446 yuv2MSBNBPS(10, LE, 0, 10, int16_t)
447 yuv2MSBNBPS(12, BE, 1, 10, int16_t)
448 yuv2MSBNBPS(12, LE, 0, 10, int16_t)
449 
450 #undef output_pixel
451 
452 static void yuv2nv12cX_16LE_c(enum AVPixelFormat dstFormat, const uint8_t *chrDither,
453  const int16_t *chrFilter, int chrFilterSize,
454  const int16_t **chrUSrc, const int16_t **chrVSrc,
455  uint8_t *dest8, int chrDstW)
456 {
457  yuv2nv12cX_16_c_template(0, chrDither, chrFilter, chrFilterSize, chrUSrc, chrVSrc, dest8, chrDstW, 16);
458 }
459 
460 static void yuv2nv12cX_16BE_c(enum AVPixelFormat dstFormat, const uint8_t *chrDither,
461  const int16_t *chrFilter, int chrFilterSize,
462  const int16_t **chrUSrc, const int16_t **chrVSrc,
463  uint8_t *dest8, int chrDstW)
464 {
465  yuv2nv12cX_16_c_template(1, chrDither, chrFilter, chrFilterSize, chrUSrc, chrVSrc, dest8, chrDstW, 16);
466 }
467 
468 static void yuv2planeX_8_c(const int16_t *filter, int filterSize,
469  const int16_t **src, uint8_t *dest, int dstW,
470  const uint8_t *dither, int offset)
471 {
472  int i;
473  for (i=0; i<dstW; i++) {
474  int val = dither[(i + offset) & 7] << 12;
475  int j;
476  for (j=0; j<filterSize; j++)
477  val += src[j][i] * filter[j];
478 
479  dest[i]= av_clip_uint8(val>>19);
480  }
481 }
482 
483 static void yuv2plane1_8_c(const int16_t *src, uint8_t *dest, int dstW,
484  const uint8_t *dither, int offset)
485 {
486  int i;
487  for (i=0; i<dstW; i++) {
488  int val = (src[i] + dither[(i + offset) & 7]) >> 7;
489  dest[i]= av_clip_uint8(val);
490  }
491 }
492 
493 static void yuv2nv12cX_c(enum AVPixelFormat dstFormat, const uint8_t *chrDither,
494  const int16_t *chrFilter, int chrFilterSize,
495  const int16_t **chrUSrc, const int16_t **chrVSrc,
496  uint8_t *dest, int chrDstW)
497 {
498  int i;
499 
500  if (!isSwappedChroma(dstFormat))
501  for (i=0; i<chrDstW; i++) {
502  int u = chrDither[i & 7] << 12;
503  int v = chrDither[(i + 3) & 7] << 12;
504  int j;
505  for (j=0; j<chrFilterSize; j++) {
506  u += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
507  v += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
508  }
509 
510  dest[2*i]= av_clip_uint8(u>>19);
511  dest[2*i+1]= av_clip_uint8(v>>19);
512  }
513  else
514  for (i=0; i<chrDstW; i++) {
515  int u = chrDither[i & 7] << 12;
516  int v = chrDither[(i + 3) & 7] << 12;
517  int j;
518  for (j=0; j<chrFilterSize; j++) {
519  u += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
520  v += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
521  }
522 
523  dest[2*i]= av_clip_uint8(v>>19);
524  dest[2*i+1]= av_clip_uint8(u>>19);
525  }
526 }
527 
528 
529 #define output_pixel(pos, val) \
530  if (big_endian) { \
531  AV_WB16(pos, av_clip_uintp2(val >> shift, output_bits) << output_shift); \
532  } else { \
533  AV_WL16(pos, av_clip_uintp2(val >> shift, output_bits) << output_shift); \
534  }
535 
536 static void yuv2p01xl1_c(const int16_t *src,
537  uint16_t *dest, int dstW,
538  int big_endian, int output_bits, int output_shift)
539 {
540  int i;
541  int shift = 15 - output_bits;
542 
543  for (i = 0; i < dstW; i++) {
544  int val = src[i] + (1 << (shift - 1));
545  output_pixel(&dest[i], val);
546  }
547 }
548 
549 static void yuv2p01xlX_c(const int16_t *filter, int filterSize,
550  const int16_t **src, uint16_t *dest, int dstW,
551  int big_endian, int output_bits, int output_shift)
552 {
553  int i, j;
554  int shift = 11 + 16 - output_bits;
555 
556  for (i = 0; i < dstW; i++) {
557  int val = 1 << (shift - 1);
558 
559  for (j = 0; j < filterSize; j++)
560  val += src[j][i] * filter[j];
561 
562  output_pixel(&dest[i], val);
563  }
564 }
565 
566 static void yuv2p01xcX_c(int big_endian, const uint8_t *chrDither,
567  const int16_t *chrFilter, int chrFilterSize,
568  const int16_t **chrUSrc, const int16_t **chrVSrc,
569  uint8_t *dest8, int chrDstW, int output_bits, int output_shift)
570 {
571  uint16_t *dest = (uint16_t*)dest8;
572  int i, j;
573  int shift = 11 + 16 - output_bits;
574 
575  for (i = 0; i < chrDstW; i++) {
576  int u = 1 << (shift - 1);
577  int v = 1 << (shift - 1);
578 
579  for (j = 0; j < chrFilterSize; j++) {
580  u += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
581  v += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
582  }
583 
584  output_pixel(&dest[2*i] , u);
585  output_pixel(&dest[2*i+1], v);
586  }
587 }
588 
589 #undef output_pixel
590 
591 #define yuv2p01x_wrapper(fmt, bits, shift) \
592  static void yuv2 ## fmt ## l1_LE_c(const int16_t *src, \
593  uint8_t *dest, int dstW, \
594  const uint8_t *dither, int offset) \
595  { \
596  yuv2p01xl1_c(src, (uint16_t*)dest, dstW, 0, bits, shift); \
597  } \
598  \
599  static void yuv2 ## fmt ## l1_BE_c(const int16_t *src, \
600  uint8_t *dest, int dstW, \
601  const uint8_t *dither, int offset) \
602  { \
603  yuv2p01xl1_c(src, (uint16_t*)dest, dstW, 1, bits, shift); \
604  } \
605  \
606  static void yuv2 ## fmt ## lX_LE_c(const int16_t *filter, \
607  int filterSize, const int16_t **src, \
608  uint8_t *dest, int dstW, \
609  const uint8_t *dither, int offset) \
610  { \
611  yuv2p01xlX_c(filter, filterSize, src, (uint16_t*)dest, dstW, 0, \
612  bits, shift); \
613  } \
614  \
615  static void yuv2 ## fmt ## lX_BE_c(const int16_t *filter, \
616  int filterSize, const int16_t **src, \
617  uint8_t *dest, int dstW, \
618  const uint8_t *dither, int offset) \
619  { \
620  yuv2p01xlX_c(filter, filterSize, src, (uint16_t*)dest, dstW, 1, \
621  bits, shift); \
622  } \
623  \
624  static void yuv2 ## fmt ## cX_LE_c(enum AVPixelFormat dstFormat, \
625  const uint8_t *chrDither, \
626  const int16_t *chrFilter, \
627  int chrFilterSize, \
628  const int16_t **chrUSrc, \
629  const int16_t **chrVSrc, \
630  uint8_t *dest8, int chrDstW) \
631  { \
632  yuv2p01xcX_c(0, chrDither, chrFilter, chrFilterSize, chrUSrc, chrVSrc, \
633  dest8, chrDstW, bits, shift); \
634  } \
635  \
636  static void yuv2 ## fmt ## cX_BE_c(enum AVPixelFormat dstFormat, \
637  const uint8_t *chrDither, \
638  const int16_t *chrFilter, \
639  int chrFilterSize, \
640  const int16_t **chrUSrc, \
641  const int16_t **chrVSrc, \
642  uint8_t *dest8, int chrDstW) \
643  { \
644  yuv2p01xcX_c(1, chrDither, chrFilter, chrFilterSize, chrUSrc, chrVSrc, \
645  dest8, chrDstW, bits, shift); \
646  }
647 
648 yuv2p01x_wrapper(p010, 10, 6)
649 yuv2p01x_wrapper(p012, 12, 4)
650 yuv2p01x_wrapper(nv20, 10, 0)
651 
652 #define accumulate_bit(acc, val) \
653  acc <<= 1; \
654  acc |= (val) >= 234
655 #define output_pixel(pos, acc) \
656  if (target == AV_PIX_FMT_MONOBLACK) { \
657  pos = acc; \
658  } else { \
659  pos = ~acc; \
660  }
661 
662 static av_always_inline void
663 yuv2mono_X_c_template(SwsInternal *c, const int16_t *lumFilter,
664  const int16_t **lumSrc, int lumFilterSize,
665  const int16_t *chrFilter, const int16_t **chrUSrc,
666  const int16_t **chrVSrc, int chrFilterSize,
667  const int16_t **alpSrc, uint8_t *dest, int dstW,
668  int y, enum AVPixelFormat target)
669 {
670  const uint8_t * const d128 = ff_dither_8x8_220[y&7];
671  int i;
672  unsigned acc = 0;
673  int err = 0;
674 
675  for (i = 0; i < dstW; i += 2) {
676  int j;
677  int Y1 = 1 << 18;
678  int Y2 = 1 << 18;
679 
680  for (j = 0; j < lumFilterSize; j++) {
681  Y1 += (unsigned)(lumSrc[j][i] * lumFilter[j]);
682  Y2 += (unsigned)(lumSrc[j][i+1] * lumFilter[j]);
683  }
684  Y1 >>= 19;
685  Y2 >>= 19;
686  if ((Y1 | Y2) & 0x100) {
687  Y1 = av_clip_uint8(Y1);
688  Y2 = av_clip_uint8(Y2);
689  }
690  if (c->opts.dither == SWS_DITHER_ED) {
691  Y1 += (7*err + 1*c->dither_error[0][i] + 5*c->dither_error[0][i+1] + 3*c->dither_error[0][i+2] + 8 - 256)>>4;
692  c->dither_error[0][i] = err;
693  acc = 2*acc + (Y1 >= 128);
694  Y1 -= 220*(acc&1);
695 
696  err = Y2 + ((7*Y1 + 1*c->dither_error[0][i+1] + 5*c->dither_error[0][i+2] + 3*c->dither_error[0][i+3] + 8 - 256)>>4);
697  c->dither_error[0][i+1] = Y1;
698  acc = 2*acc + (err >= 128);
699  err -= 220*(acc&1);
700  } else {
701  accumulate_bit(acc, Y1 + d128[(i + 0) & 7]);
702  accumulate_bit(acc, Y2 + d128[(i + 1) & 7]);
703  }
704  if ((i & 7) == 6) {
705  output_pixel(*dest++, acc);
706  }
707  }
708  c->dither_error[0][i] = err;
709 
710  if (i & 6) {
711  output_pixel(*dest, acc);
712  }
713 }
714 
715 static av_always_inline void
716 yuv2mono_2_c_template(SwsInternal *c, const int16_t *buf[2],
717  const int16_t *ubuf[2], const int16_t *vbuf[2],
718  const int16_t *abuf[2], uint8_t *dest, int dstW,
719  int yalpha, int uvalpha, int y,
720  enum AVPixelFormat target)
721 {
722  const int16_t *buf0 = buf[0], *buf1 = buf[1];
723  const uint8_t * const d128 = ff_dither_8x8_220[y & 7];
724  int yalpha1 = 4096 - yalpha;
725  int i;
726  av_assert2(yalpha <= 4096U);
727 
728  if (c->opts.dither == SWS_DITHER_ED) {
729  int err = 0;
730  unsigned acc = 0;
731  for (i = 0; i < dstW; i +=2) {
732  int Y;
733 
734  Y = (buf0[i + 0] * yalpha1 + buf1[i + 0] * yalpha) >> 19;
735  Y += (7*err + 1*c->dither_error[0][i] + 5*c->dither_error[0][i+1] + 3*c->dither_error[0][i+2] + 8 - 256)>>4;
736  c->dither_error[0][i] = err;
737  acc = 2*acc + (Y >= 128);
738  Y -= 220*(acc&1);
739 
740  err = (buf0[i + 1] * yalpha1 + buf1[i + 1] * yalpha) >> 19;
741  err += (7*Y + 1*c->dither_error[0][i+1] + 5*c->dither_error[0][i+2] + 3*c->dither_error[0][i+3] + 8 - 256)>>4;
742  c->dither_error[0][i+1] = Y;
743  acc = 2*acc + (err >= 128);
744  err -= 220*(acc&1);
745 
746  if ((i & 7) == 6)
747  output_pixel(*dest++, acc);
748  }
749  c->dither_error[0][i] = err;
750  } else {
751  for (i = 0; i < dstW; i += 8) {
752  int Y;
753  unsigned acc = 0;
754 
755  Y = (buf0[i + 0] * yalpha1 + buf1[i + 0] * yalpha) >> 19;
756  accumulate_bit(acc, Y + d128[0]);
757  Y = (buf0[i + 1] * yalpha1 + buf1[i + 1] * yalpha) >> 19;
758  accumulate_bit(acc, Y + d128[1]);
759  Y = (buf0[i + 2] * yalpha1 + buf1[i + 2] * yalpha) >> 19;
760  accumulate_bit(acc, Y + d128[2]);
761  Y = (buf0[i + 3] * yalpha1 + buf1[i + 3] * yalpha) >> 19;
762  accumulate_bit(acc, Y + d128[3]);
763  Y = (buf0[i + 4] * yalpha1 + buf1[i + 4] * yalpha) >> 19;
764  accumulate_bit(acc, Y + d128[4]);
765  Y = (buf0[i + 5] * yalpha1 + buf1[i + 5] * yalpha) >> 19;
766  accumulate_bit(acc, Y + d128[5]);
767  Y = (buf0[i + 6] * yalpha1 + buf1[i + 6] * yalpha) >> 19;
768  accumulate_bit(acc, Y + d128[6]);
769  Y = (buf0[i + 7] * yalpha1 + buf1[i + 7] * yalpha) >> 19;
770  accumulate_bit(acc, Y + d128[7]);
771 
772  output_pixel(*dest++, acc);
773  }
774  }
775 }
776 
777 static av_always_inline void
778 yuv2mono_1_c_template(SwsInternal *c, const int16_t *buf0,
779  const int16_t *ubuf[2], const int16_t *vbuf[2],
780  const int16_t *abuf0, uint8_t *dest, int dstW,
781  int uvalpha, int y, enum AVPixelFormat target)
782 {
783  const uint8_t * const d128 = ff_dither_8x8_220[y & 7];
784  int i;
785 
786  if (c->opts.dither == SWS_DITHER_ED) {
787  int err = 0;
788  unsigned acc = 0;
789  for (i = 0; i < dstW; i +=2) {
790  int Y;
791 
792  Y = ((buf0[i + 0] + 64) >> 7);
793  Y += (7*err + 1*c->dither_error[0][i] + 5*c->dither_error[0][i+1] + 3*c->dither_error[0][i+2] + 8 - 256)>>4;
794  c->dither_error[0][i] = err;
795  acc = 2*acc + (Y >= 128);
796  Y -= 220*(acc&1);
797 
798  err = ((buf0[i + 1] + 64) >> 7);
799  err += (7*Y + 1*c->dither_error[0][i+1] + 5*c->dither_error[0][i+2] + 3*c->dither_error[0][i+3] + 8 - 256)>>4;
800  c->dither_error[0][i+1] = Y;
801  acc = 2*acc + (err >= 128);
802  err -= 220*(acc&1);
803 
804  if ((i & 7) == 6)
805  output_pixel(*dest++, acc);
806  }
807  c->dither_error[0][i] = err;
808  } else {
809  for (i = 0; i < dstW; i += 8) {
810  unsigned acc = 0;
811  accumulate_bit(acc, ((buf0[i + 0] + 64) >> 7) + d128[0]);
812  accumulate_bit(acc, ((buf0[i + 1] + 64) >> 7) + d128[1]);
813  accumulate_bit(acc, ((buf0[i + 2] + 64) >> 7) + d128[2]);
814  accumulate_bit(acc, ((buf0[i + 3] + 64) >> 7) + d128[3]);
815  accumulate_bit(acc, ((buf0[i + 4] + 64) >> 7) + d128[4]);
816  accumulate_bit(acc, ((buf0[i + 5] + 64) >> 7) + d128[5]);
817  accumulate_bit(acc, ((buf0[i + 6] + 64) >> 7) + d128[6]);
818  accumulate_bit(acc, ((buf0[i + 7] + 64) >> 7) + d128[7]);
819 
820  output_pixel(*dest++, acc);
821  }
822  }
823 }
824 
825 #undef output_pixel
826 #undef accumulate_bit
827 
828 #define YUV2PACKEDWRAPPER(name, base, ext, fmt) \
829 static void name ## ext ## _X_c(SwsInternal *c, const int16_t *lumFilter, \
830  const int16_t **lumSrc, int lumFilterSize, \
831  const int16_t *chrFilter, const int16_t **chrUSrc, \
832  const int16_t **chrVSrc, int chrFilterSize, \
833  const int16_t **alpSrc, uint8_t *dest, int dstW, \
834  int y) \
835 { \
836  name ## base ## _X_c_template(c, lumFilter, lumSrc, lumFilterSize, \
837  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
838  alpSrc, dest, dstW, y, fmt); \
839 } \
840  \
841 static void name ## ext ## _2_c(SwsInternal *c, const int16_t *buf[2], \
842  const int16_t *ubuf[2], const int16_t *vbuf[2], \
843  const int16_t *abuf[2], uint8_t *dest, int dstW, \
844  int yalpha, int uvalpha, int y) \
845 { \
846  name ## base ## _2_c_template(c, buf, ubuf, vbuf, abuf, \
847  dest, dstW, yalpha, uvalpha, y, fmt); \
848 } \
849  \
850 static void name ## ext ## _1_c(SwsInternal *c, const int16_t *buf0, \
851  const int16_t *ubuf[2], const int16_t *vbuf[2], \
852  const int16_t *abuf0, uint8_t *dest, int dstW, \
853  int uvalpha, int y) \
854 { \
855  name ## base ## _1_c_template(c, buf0, ubuf, vbuf, \
856  abuf0, dest, dstW, uvalpha, \
857  y, fmt); \
858 }
859 
860 YUV2PACKEDWRAPPER(yuv2mono,, white, AV_PIX_FMT_MONOWHITE)
861 YUV2PACKEDWRAPPER(yuv2mono,, black, AV_PIX_FMT_MONOBLACK)
862 
863 #define output_pixels(pos, Y1, U, Y2, V) \
864  if (target == AV_PIX_FMT_YUYV422) { \
865  dest[pos + 0] = Y1; \
866  dest[pos + 1] = U; \
867  dest[pos + 2] = Y2; \
868  dest[pos + 3] = V; \
869  } else if (target == AV_PIX_FMT_YVYU422) { \
870  dest[pos + 0] = Y1; \
871  dest[pos + 1] = V; \
872  dest[pos + 2] = Y2; \
873  dest[pos + 3] = U; \
874  } else { /* AV_PIX_FMT_UYVY422 */ \
875  dest[pos + 0] = U; \
876  dest[pos + 1] = Y1; \
877  dest[pos + 2] = V; \
878  dest[pos + 3] = Y2; \
879  }
880 
881 static av_always_inline void
882 yuv2422_X_c_template(SwsInternal *c, const int16_t *lumFilter,
883  const int16_t **lumSrc, int lumFilterSize,
884  const int16_t *chrFilter, const int16_t **chrUSrc,
885  const int16_t **chrVSrc, int chrFilterSize,
886  const int16_t **alpSrc, uint8_t *dest, int dstW,
887  int y, enum AVPixelFormat target)
888 {
889  int i;
890 
891  for (i = 0; i < ((dstW + 1) >> 1); i++) {
892  int j;
893  int Y1 = 1 << 18;
894  int Y2 = 1 << 18;
895  int U = 1 << 18;
896  int V = 1 << 18;
897 
898  for (j = 0; j < lumFilterSize; j++) {
899  Y1 += (unsigned)(lumSrc[j][i * 2] * lumFilter[j]);
900  Y2 += (unsigned)(lumSrc[j][i * 2 + 1] * lumFilter[j]);
901  }
902  for (j = 0; j < chrFilterSize; j++) {
903  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
904  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
905  }
906  Y1 >>= 19;
907  Y2 >>= 19;
908  U >>= 19;
909  V >>= 19;
910  if ((Y1 | Y2 | U | V) & 0x100) {
911  Y1 = av_clip_uint8(Y1);
912  Y2 = av_clip_uint8(Y2);
913  U = av_clip_uint8(U);
914  V = av_clip_uint8(V);
915  }
916  output_pixels(4*i, Y1, U, Y2, V);
917  }
918 }
919 
920 static av_always_inline void
921 yuv2422_2_c_template(SwsInternal *c, const int16_t *buf[2],
922  const int16_t *ubuf[2], const int16_t *vbuf[2],
923  const int16_t *abuf[2], uint8_t *dest, int dstW,
924  int yalpha, int uvalpha, int y,
925  enum AVPixelFormat target)
926 {
927  const int16_t *buf0 = buf[0], *buf1 = buf[1],
928  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
929  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1];
930  int yalpha1 = 4096 - yalpha;
931  int uvalpha1 = 4096 - uvalpha;
932  int i;
933  av_assert2(yalpha <= 4096U);
934  av_assert2(uvalpha <= 4096U);
935 
936  for (i = 0; i < ((dstW + 1) >> 1); i++) {
937  int Y1 = (buf0[i * 2] * yalpha1 + buf1[i * 2] * yalpha) >> 19;
938  int Y2 = (buf0[i * 2 + 1] * yalpha1 + buf1[i * 2 + 1] * yalpha) >> 19;
939  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha) >> 19;
940  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha) >> 19;
941 
942  if ((Y1 | Y2 | U | V) & 0x100) {
943  Y1 = av_clip_uint8(Y1);
944  Y2 = av_clip_uint8(Y2);
945  U = av_clip_uint8(U);
946  V = av_clip_uint8(V);
947  }
948 
949  output_pixels(i * 4, Y1, U, Y2, V);
950  }
951 }
952 
953 static av_always_inline void
954 yuv2422_1_c_template(SwsInternal *c, const int16_t *buf0,
955  const int16_t *ubuf[2], const int16_t *vbuf[2],
956  const int16_t *abuf0, uint8_t *dest, int dstW,
957  int uvalpha, int y, enum AVPixelFormat target)
958 {
959  const int16_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0];
960  int i;
961 
962  if (uvalpha < 2048) {
963  for (i = 0; i < ((dstW + 1) >> 1); i++) {
964  int Y1 = (buf0[i * 2 ]+64) >> 7;
965  int Y2 = (buf0[i * 2 + 1]+64) >> 7;
966  int U = (ubuf0[i] +64) >> 7;
967  int V = (vbuf0[i] +64) >> 7;
968 
969  if ((Y1 | Y2 | U | V) & 0x100) {
970  Y1 = av_clip_uint8(Y1);
971  Y2 = av_clip_uint8(Y2);
972  U = av_clip_uint8(U);
973  V = av_clip_uint8(V);
974  }
975 
976  output_pixels(i * 4, Y1, U, Y2, V);
977  }
978  } else {
979  const int16_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
980  for (i = 0; i < ((dstW + 1) >> 1); i++) {
981  int Y1 = (buf0[i * 2 ] + 64) >> 7;
982  int Y2 = (buf0[i * 2 + 1] + 64) >> 7;
983  int U = (ubuf0[i] + ubuf1[i]+128) >> 8;
984  int V = (vbuf0[i] + vbuf1[i]+128) >> 8;
985 
986  if ((Y1 | Y2 | U | V) & 0x100) {
987  Y1 = av_clip_uint8(Y1);
988  Y2 = av_clip_uint8(Y2);
989  U = av_clip_uint8(U);
990  V = av_clip_uint8(V);
991  }
992 
993  output_pixels(i * 4, Y1, U, Y2, V);
994  }
995  }
996 }
997 
998 #undef output_pixels
999 
1000 YUV2PACKEDWRAPPER(yuv2, 422, yuyv422, AV_PIX_FMT_YUYV422)
1001 YUV2PACKEDWRAPPER(yuv2, 422, yvyu422, AV_PIX_FMT_YVYU422)
1002 YUV2PACKEDWRAPPER(yuv2, 422, uyvy422, AV_PIX_FMT_UYVY422)
1003 
1004 #define R_B ((target == AV_PIX_FMT_RGB48LE || target == AV_PIX_FMT_RGB48BE || target == AV_PIX_FMT_RGBA64LE || target == AV_PIX_FMT_RGBA64BE) ? R : B)
1005 #define B_R ((target == AV_PIX_FMT_RGB48LE || target == AV_PIX_FMT_RGB48BE || target == AV_PIX_FMT_RGBA64LE || target == AV_PIX_FMT_RGBA64BE) ? B : R)
1006 #define output_pixel(pos, val) \
1007  if (is_be) { \
1008  AV_WB16(pos, val); \
1009  } else { \
1010  AV_WL16(pos, val); \
1011  }
1012 
1013 static av_always_inline void
1014 yuv2ya16_X_c_template(SwsInternal *c, const int16_t *lumFilter,
1015  const int32_t **lumSrc, int lumFilterSize,
1016  const int16_t *chrFilter, const int32_t **unused_chrUSrc,
1017  const int32_t **unused_chrVSrc, int unused_chrFilterSize,
1018  const int32_t **alpSrc, uint16_t *dest, int dstW,
1019  int y, enum AVPixelFormat target,
1020  int unused_hasAlpha, int unused_eightbytes, int is_be)
1021 {
1022  int hasAlpha = !!alpSrc;
1023  int i;
1024 
1025  for (i = 0; i < dstW; i++) {
1026  int j;
1027  int Y = -0x40000000;
1028  int A = 0xffff;
1029 
1030  for (j = 0; j < lumFilterSize; j++)
1031  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
1032 
1033  Y >>= 15;
1034  Y += (1<<3) + 0x8000;
1035  Y = av_clip_uint16(Y);
1036 
1037  if (hasAlpha) {
1038  A = -0x40000000 + (1<<14);
1039  for (j = 0; j < lumFilterSize; j++)
1040  A += (unsigned)(alpSrc[j][i] * lumFilter[j]);
1041 
1042  A >>= 15;
1043  A += 0x8000;
1044  A = av_clip_uint16(A);
1045  }
1046 
1047  output_pixel(&dest[2 * i ], Y);
1048  output_pixel(&dest[2 * i + 1], A);
1049  }
1050 }
1051 
1052 static av_always_inline void
1053 yuv2ya16_2_c_template(SwsInternal *c, const int32_t *buf[2],
1054  const int32_t *unused_ubuf[2], const int32_t *unused_vbuf[2],
1055  const int32_t *abuf[2], uint16_t *dest, int dstW,
1056  int yalpha_param, int unused_uvalpha, int y,
1057  enum AVPixelFormat target, int unused_hasAlpha,
1058  int unused_eightbytes, int is_be)
1059 {
1060  unsigned yalpha = yalpha_param;
1061  int hasAlpha = abuf && abuf[0] && abuf[1];
1062  const int32_t *buf0 = buf[0], *buf1 = buf[1],
1063  *abuf0 = hasAlpha ? abuf[0] : NULL,
1064  *abuf1 = hasAlpha ? abuf[1] : NULL;
1065  unsigned yalpha1 = 4096 - yalpha;
1066  int i;
1067 
1068  av_assert2(yalpha <= 4096U);
1069 
1070  for (i = 0; i < dstW; i++) {
1071  int Y = (int)(buf0[i] * yalpha1 + buf1[i] * yalpha) >> 15;
1072  int A;
1073 
1074  Y = av_clip_uint16(Y);
1075 
1076  if (hasAlpha) {
1077  A = (int)(abuf0[i] * yalpha1 + abuf1[i] * yalpha) >> 15;
1078  A = av_clip_uint16(A);
1079  }
1080 
1081  output_pixel(&dest[2 * i ], Y);
1082  output_pixel(&dest[2 * i + 1], hasAlpha ? A : 65535);
1083  }
1084 }
1085 
1086 static av_always_inline void
1087 yuv2ya16_1_c_template(SwsInternal *c, const int32_t *buf0,
1088  const int32_t *unused_ubuf[2], const int32_t *unused_vbuf[2],
1089  const int32_t *abuf0, uint16_t *dest, int dstW,
1090  int unused_uvalpha, int y, enum AVPixelFormat target,
1091  int unused_hasAlpha, int unused_eightbytes, int is_be)
1092 {
1093  int hasAlpha = !!abuf0;
1094  int i;
1095 
1096  for (i = 0; i < dstW; i++) {
1097  int Y = buf0[i] >> 3;/* 19 - 16 */
1098  int A;
1099 
1100  Y = av_clip_uint16(Y);
1101 
1102  if (hasAlpha) {
1103  A = abuf0[i] >> 3;
1104  if (A & 0x100)
1105  A = av_clip_uint16(A);
1106  }
1107 
1108  output_pixel(&dest[2 * i ], Y);
1109  output_pixel(&dest[2 * i + 1], hasAlpha ? A : 65535);
1110  }
1111 }
1112 
1113 static av_always_inline void
1114 yuv2rgba64_X_c_template(SwsInternal *c, const int16_t *lumFilter,
1115  const int32_t **lumSrc, int lumFilterSize,
1116  const int16_t *chrFilter, const int32_t **chrUSrc,
1117  const int32_t **chrVSrc, int chrFilterSize,
1118  const int32_t **alpSrc, uint16_t *dest, int dstW,
1119  int y, enum AVPixelFormat target, int hasAlpha, int eightbytes,
1120  int is_be)
1121 {
1122  int i;
1123  int A1 = 0xffff<<14, A2 = 0xffff<<14;
1124 
1125  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1126  int j;
1127  unsigned Y1 = -0x40000000;
1128  unsigned Y2 = -0x40000000;
1129  int U = -(128 << 23); // 19
1130  int V = -(128 << 23);
1131  int R, G, B;
1132 
1133  for (j = 0; j < lumFilterSize; j++) {
1134  Y1 += lumSrc[j][i * 2] * (unsigned)lumFilter[j];
1135  Y2 += lumSrc[j][i * 2 + 1] * (unsigned)lumFilter[j];
1136  }
1137  for (j = 0; j < chrFilterSize; j++) {;
1138  U += chrUSrc[j][i] * (unsigned)chrFilter[j];
1139  V += chrVSrc[j][i] * (unsigned)chrFilter[j];
1140  }
1141 
1142  if (hasAlpha) {
1143  A1 = -0x40000000;
1144  A2 = -0x40000000;
1145  for (j = 0; j < lumFilterSize; j++) {
1146  A1 += alpSrc[j][i * 2] * (unsigned)lumFilter[j];
1147  A2 += alpSrc[j][i * 2 + 1] * (unsigned)lumFilter[j];
1148  }
1149  A1 >>= 1;
1150  A1 += 0x20002000;
1151  A2 >>= 1;
1152  A2 += 0x20002000;
1153  }
1154 
1155  // 8 bits: 12+15=27; 16 bits: 12+19=31
1156  Y1 = (int)Y1 >> 14; // 10
1157  Y1 += 0x10000;
1158  Y2 = (int)Y2 >> 14;
1159  Y2 += 0x10000;
1160  U >>= 14;
1161  V >>= 14;
1162 
1163  // 8 bits: 27 -> 17 bits, 16 bits: 31 - 14 = 17 bits
1164  Y1 -= c->yuv2rgb_y_offset;
1165  Y2 -= c->yuv2rgb_y_offset;
1166  Y1 *= c->yuv2rgb_y_coeff;
1167  Y2 *= c->yuv2rgb_y_coeff;
1168  Y1 += (1 << 13) - (1 << 29); // 21
1169  Y2 += (1 << 13) - (1 << 29);
1170  // 8 bits: 17 + 13 bits = 30 bits, 16 bits: 17 + 13 bits = 30 bits
1171 
1172  R = V * c->yuv2rgb_v2r_coeff;
1173  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1174  B = U * c->yuv2rgb_u2b_coeff;
1175 
1176  // 8 bits: 30 - 22 = 8 bits, 16 bits: 30 bits - 14 = 16 bits
1177  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + Y1) >> 14) + (1<<15), 16));
1178  output_pixel(&dest[1], av_clip_uintp2(((int)( G + Y1) >> 14) + (1<<15), 16));
1179  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + Y1) >> 14) + (1<<15), 16));
1180  if (eightbytes) {
1181  output_pixel(&dest[3], av_clip_uintp2(A1 , 30) >> 14);
1182  output_pixel(&dest[4], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1183  output_pixel(&dest[5], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1184  output_pixel(&dest[6], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1185  output_pixel(&dest[7], av_clip_uintp2(A2 , 30) >> 14);
1186  dest += 8;
1187  } else {
1188  output_pixel(&dest[3], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1189  output_pixel(&dest[4], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1190  output_pixel(&dest[5], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1191  dest += 6;
1192  }
1193  }
1194 }
1195 
1196 static av_always_inline void
1197 yuv2rgba64_2_c_template(SwsInternal *c, const int32_t *buf[2],
1198  const int32_t *ubuf[2], const int32_t *vbuf[2],
1199  const int32_t *abuf[2], uint16_t *dest, int dstW,
1200  int yalpha_param, int uvalpha_param, int y,
1201  enum AVPixelFormat target, int hasAlpha, int eightbytes,
1202  int is_be)
1203 {
1204  unsigned yalpha = yalpha_param;
1205  unsigned uvalpha = uvalpha_param;
1206  const int32_t *buf0 = buf[0], *buf1 = buf[1],
1207  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
1208  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1],
1209  *abuf0 = hasAlpha ? abuf[0] : NULL,
1210  *abuf1 = hasAlpha ? abuf[1] : NULL;
1211  unsigned yalpha1 = 4096 - yalpha;
1212  unsigned uvalpha1 = 4096 - uvalpha;
1213  int i;
1214  int A1 = 0xffff<<14, A2 = 0xffff<<14;
1215 
1216  av_assert2(yalpha <= 4096U);
1217  av_assert2(uvalpha <= 4096U);
1218 
1219  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1220  unsigned Y1 = (int)(buf0[i * 2] * yalpha1 + buf1[i * 2] * yalpha) >> 14;
1221  unsigned Y2 = (int)(buf0[i * 2 + 1] * yalpha1 + buf1[i * 2 + 1] * yalpha) >> 14;
1222  int U = (int)(ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha - (128 << 23)) >> 14;
1223  int V = (int)(vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha - (128 << 23)) >> 14;
1224  int R, G, B;
1225 
1226  Y1 -= c->yuv2rgb_y_offset;
1227  Y2 -= c->yuv2rgb_y_offset;
1228  Y1 *= c->yuv2rgb_y_coeff;
1229  Y2 *= c->yuv2rgb_y_coeff;
1230  Y1 += (1 << 13) - (1 << 29);
1231  Y2 += (1 << 13) - (1 << 29);
1232 
1233  R = V * c->yuv2rgb_v2r_coeff;
1234  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1235  B = U * c->yuv2rgb_u2b_coeff;
1236 
1237  if (hasAlpha) {
1238  A1 = (int)(abuf0[i * 2 ] * yalpha1 + abuf1[i * 2 ] * yalpha) >> 1;
1239  A2 = (int)(abuf0[i * 2 + 1] * yalpha1 + abuf1[i * 2 + 1] * yalpha) >> 1;
1240 
1241  A1 += 1 << 13;
1242  A2 += 1 << 13;
1243  }
1244 
1245  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + Y1) >> 14) + (1<<15), 16));
1246  output_pixel(&dest[1], av_clip_uintp2(((int)( G + Y1) >> 14) + (1<<15), 16));
1247  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + Y1) >> 14) + (1<<15), 16));
1248  if (eightbytes) {
1249  output_pixel(&dest[3], av_clip_uintp2(A1 , 30) >> 14);
1250  output_pixel(&dest[4], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1251  output_pixel(&dest[5], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1252  output_pixel(&dest[6], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1253  output_pixel(&dest[7], av_clip_uintp2(A2 , 30) >> 14);
1254  dest += 8;
1255  } else {
1256  output_pixel(&dest[3], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1257  output_pixel(&dest[4], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1258  output_pixel(&dest[5], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1259  dest += 6;
1260  }
1261  }
1262 }
1263 
1264 static av_always_inline void
1265 yuv2rgba64_1_c_template(SwsInternal *c, const int32_t *buf0,
1266  const int32_t *ubuf[2], const int32_t *vbuf[2],
1267  const int32_t *abuf0, uint16_t *dest, int dstW,
1268  int uvalpha, int y, enum AVPixelFormat target,
1269  int hasAlpha, int eightbytes, int is_be)
1270 {
1271  const int32_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0];
1272  int i;
1273  int A1 = 0xffff<<14, A2= 0xffff<<14;
1274 
1275  if (uvalpha == 0) {
1276  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1277  SUINT Y1 = (buf0[i * 2] ) >> 2;
1278  SUINT Y2 = (buf0[i * 2 + 1]) >> 2;
1279  SUINT U = (ubuf0[i] - (128 << 11)) >> 2;
1280  SUINT V = (vbuf0[i] - (128 << 11)) >> 2;
1281  int R, G, B;
1282 
1283  Y1 -= c->yuv2rgb_y_offset;
1284  Y2 -= c->yuv2rgb_y_offset;
1285  Y1 *= c->yuv2rgb_y_coeff;
1286  Y2 *= c->yuv2rgb_y_coeff;
1287  Y1 += (1 << 13) - (1 << 29);
1288  Y2 += (1 << 13) - (1 << 29);
1289 
1290  if (hasAlpha) {
1291  A1 = abuf0[i * 2 ] * (1 << 11);
1292  A2 = abuf0[i * 2 + 1] * (1 << 11);
1293 
1294  A1 += 1 << 13;
1295  A2 += 1 << 13;
1296  }
1297 
1298  R = V * c->yuv2rgb_v2r_coeff;
1299  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1300  B = U * c->yuv2rgb_u2b_coeff;
1301 
1302  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + Y1) >> 14) + (1<<15), 16));
1303  output_pixel(&dest[1], av_clip_uintp2(((int)( G + Y1) >> 14) + (1<<15), 16));
1304  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + Y1) >> 14) + (1<<15), 16));
1305  if (eightbytes) {
1306  output_pixel(&dest[3], av_clip_uintp2(A1 , 30) >> 14);
1307  output_pixel(&dest[4], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1308  output_pixel(&dest[5], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1309  output_pixel(&dest[6], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1310  output_pixel(&dest[7], av_clip_uintp2(A2 , 30) >> 14);
1311  dest += 8;
1312  } else {
1313  output_pixel(&dest[3], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1314  output_pixel(&dest[4], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1315  output_pixel(&dest[5], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1316  dest += 6;
1317  }
1318  }
1319  } else {
1320  const int32_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
1321  int A1 = 0xffff<<14, A2 = 0xffff<<14;
1322  unsigned uvalpha1 = 4096 - uvalpha;
1323  av_assert2(uvalpha <= 4096U);
1324 
1325  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1326  SUINT Y1 = (buf0[i * 2] ) >> 2;
1327  SUINT Y2 = (buf0[i * 2 + 1]) >> 2;
1328  SUINT U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha - (128 << 23)) >> 14;
1329  SUINT V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha - (128 << 23)) >> 14;
1330  int R, G, B;
1331 
1332  Y1 -= c->yuv2rgb_y_offset;
1333  Y2 -= c->yuv2rgb_y_offset;
1334  Y1 *= c->yuv2rgb_y_coeff;
1335  Y2 *= c->yuv2rgb_y_coeff;
1336  Y1 += (1 << 13) - (1 << 29);
1337  Y2 += (1 << 13) - (1 << 29);
1338 
1339  if (hasAlpha) {
1340  A1 = abuf0[i * 2 ] * (1 << 11);
1341  A2 = abuf0[i * 2 + 1] * (1 << 11);
1342 
1343  A1 += 1 << 13;
1344  A2 += 1 << 13;
1345  }
1346 
1347  R = V * c->yuv2rgb_v2r_coeff;
1348  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1349  B = U * c->yuv2rgb_u2b_coeff;
1350 
1351  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + Y1) >> 14) + (1<<15), 16));
1352  output_pixel(&dest[1], av_clip_uintp2(((int)( G + Y1) >> 14) + (1<<15), 16));
1353  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + Y1) >> 14) + (1<<15), 16));
1354  if (eightbytes) {
1355  output_pixel(&dest[3], av_clip_uintp2(A1 , 30) >> 14);
1356  output_pixel(&dest[4], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1357  output_pixel(&dest[5], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1358  output_pixel(&dest[6], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1359  output_pixel(&dest[7], av_clip_uintp2(A2 , 30) >> 14);
1360  dest += 8;
1361  } else {
1362  output_pixel(&dest[3], av_clip_uintp2(((int)(R_B + Y2) >> 14) + (1<<15), 16));
1363  output_pixel(&dest[4], av_clip_uintp2(((int)( G + Y2) >> 14) + (1<<15), 16));
1364  output_pixel(&dest[5], av_clip_uintp2(((int)(B_R + Y2) >> 14) + (1<<15), 16));
1365  dest += 6;
1366  }
1367  }
1368  }
1369 }
1370 
1371 static av_always_inline void
1372 yuv2rgba64_full_X_c_template(SwsInternal *c, const int16_t *lumFilter,
1373  const int32_t **lumSrc, int lumFilterSize,
1374  const int16_t *chrFilter, const int32_t **chrUSrc,
1375  const int32_t **chrVSrc, int chrFilterSize,
1376  const int32_t **alpSrc, uint16_t *dest, int dstW,
1377  int y, enum AVPixelFormat target, int hasAlpha,
1378  int eightbytes, int is_be)
1379 {
1380  int i;
1381  int A = 0xffff<<14;
1382 
1383  for (i = 0; i < dstW; i++) {
1384  int j;
1385  int Y = -0x40000000;
1386  int U = -(128 << 23); // 19
1387  int V = -(128 << 23);
1388  int R, G, B;
1389 
1390  for (j = 0; j < lumFilterSize; j++) {
1391  Y += lumSrc[j][i] * (unsigned)lumFilter[j];
1392  }
1393  for (j = 0; j < chrFilterSize; j++) {;
1394  U += chrUSrc[j][i] * (unsigned)chrFilter[j];
1395  V += chrVSrc[j][i] * (unsigned)chrFilter[j];
1396  }
1397 
1398  if (hasAlpha) {
1399  A = -0x40000000;
1400  for (j = 0; j < lumFilterSize; j++) {
1401  A += alpSrc[j][i] * (unsigned)lumFilter[j];
1402  }
1403  A >>= 1;
1404  A += 0x20002000;
1405  }
1406 
1407  // 8bit: 12+15=27; 16-bit: 12+19=31
1408  Y >>= 14; // 10
1409  Y += 0x10000;
1410  U >>= 14;
1411  V >>= 14;
1412 
1413  // 8bit: 27 -> 17bit, 16bit: 31 - 14 = 17bit
1414  Y -= c->yuv2rgb_y_offset;
1415  Y *= c->yuv2rgb_y_coeff;
1416  Y += (1 << 13) - (1<<29); // 21
1417  // 8bit: 17 + 13bit = 30bit, 16bit: 17 + 13bit = 30bit
1418 
1419  R = V * c->yuv2rgb_v2r_coeff;
1420  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1421  B = U * c->yuv2rgb_u2b_coeff;
1422 
1423  // 8bit: 30 - 22 = 8bit, 16bit: 30bit - 14 = 16bit
1424  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + (unsigned)Y)>>14) + (1<<15), 16));
1425  output_pixel(&dest[1], av_clip_uintp2(((int)( G + (unsigned)Y)>>14) + (1<<15), 16));
1426  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + (unsigned)Y)>>14) + (1<<15), 16));
1427  if (eightbytes) {
1428  output_pixel(&dest[3], av_clip_uintp2(A, 30) >> 14);
1429  dest += 4;
1430  } else {
1431  dest += 3;
1432  }
1433  }
1434 }
1435 
1436 static av_always_inline void
1437 yuv2rgba64_full_2_c_template(SwsInternal *c, const int32_t *buf[2],
1438  const int32_t *ubuf[2], const int32_t *vbuf[2],
1439  const int32_t *abuf[2], uint16_t *dest, int dstW,
1440  int yalpha_param, int uvalpha_param, int y,
1441  enum AVPixelFormat target, int hasAlpha, int eightbytes,
1442  int is_be)
1443 {
1444  unsigned yalpha = yalpha_param;
1445  unsigned uvalpha = uvalpha_param;
1446  const int32_t *buf0 = buf[0], *buf1 = buf[1],
1447  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
1448  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1],
1449  *abuf0 = hasAlpha ? abuf[0] : NULL,
1450  *abuf1 = hasAlpha ? abuf[1] : NULL;
1451  unsigned yalpha1 = 4096 - yalpha;
1452  unsigned uvalpha1 = 4096 - uvalpha;
1453  int i;
1454  int A = 0xffff<<14;
1455 
1456  av_assert2(yalpha <= 4096U);
1457  av_assert2(uvalpha <= 4096U);
1458 
1459  for (i = 0; i < dstW; i++) {
1460  int Y = (int)(buf0[i] * yalpha1 + buf1[i] * yalpha) >> 14;
1461  int U = (int)(ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha - (128 << 23)) >> 14;
1462  int V = (int)(vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha - (128 << 23)) >> 14;
1463  int R, G, B;
1464 
1465  Y -= c->yuv2rgb_y_offset;
1466  Y *= c->yuv2rgb_y_coeff;
1467  Y += (1 << 13) - (1 << 29);
1468 
1469  R = V * c->yuv2rgb_v2r_coeff;
1470  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1471  B = U * c->yuv2rgb_u2b_coeff;
1472 
1473  if (hasAlpha) {
1474  A = (int)(abuf0[i] * yalpha1 + abuf1[i] * yalpha) >> 1;
1475 
1476  A += 1 << 13;
1477  }
1478 
1479  output_pixel(&dest[0], av_clip_uintp2(((R_B + Y) >> 14) + (1<<15), 16));
1480  output_pixel(&dest[1], av_clip_uintp2((( G + Y) >> 14) + (1<<15), 16));
1481  output_pixel(&dest[2], av_clip_uintp2(((B_R + Y) >> 14) + (1<<15), 16));
1482  if (eightbytes) {
1483  output_pixel(&dest[3], av_clip_uintp2(A, 30) >> 14);
1484  dest += 4;
1485  } else {
1486  dest += 3;
1487  }
1488  }
1489 }
1490 
1491 static av_always_inline void
1492 yuv2rgba64_full_1_c_template(SwsInternal *c, const int32_t *buf0,
1493  const int32_t *ubuf[2], const int32_t *vbuf[2],
1494  const int32_t *abuf0, uint16_t *dest, int dstW,
1495  int uvalpha, int y, enum AVPixelFormat target,
1496  int hasAlpha, int eightbytes, int is_be)
1497 {
1498  const int32_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0];
1499  int i;
1500  int A = 0xffff<<14;
1501 
1502  if (uvalpha == 0) {
1503  for (i = 0; i < dstW; i++) {
1504  SUINT Y = (buf0[i]) >> 2;
1505  SUINT U = (ubuf0[i] - (128 << 11)) >> 2;
1506  SUINT V = (vbuf0[i] - (128 << 11)) >> 2;
1507  int R, G, B;
1508 
1509  Y -= c->yuv2rgb_y_offset;
1510  Y *= c->yuv2rgb_y_coeff;
1511  Y += (1 << 13) - (1 << 29);
1512 
1513  if (hasAlpha) {
1514  A = abuf0[i] * (1 << 11);
1515 
1516  A += 1 << 13;
1517  }
1518 
1519  R = V * c->yuv2rgb_v2r_coeff;
1520  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1521  B = U * c->yuv2rgb_u2b_coeff;
1522 
1523  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + Y) >> 14) + (1<<15), 16));
1524  output_pixel(&dest[1], av_clip_uintp2(((int)( G + Y) >> 14) + (1<<15), 16));
1525  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + Y) >> 14) + (1<<15), 16));
1526  if (eightbytes) {
1527  output_pixel(&dest[3], av_clip_uintp2(A, 30) >> 14);
1528  dest += 4;
1529  } else {
1530  dest += 3;
1531  }
1532  }
1533  } else {
1534  const int32_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
1535  unsigned uvalpha1 = 4096 - uvalpha;
1536  int A = 0xffff<<14;
1537  av_assert2(uvalpha <= 4096U);
1538 
1539  for (i = 0; i < dstW; i++) {
1540  SUINT Y = (buf0[i] ) >> 2;
1541  SUINT U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha - (128 << 23)) >> 14;
1542  SUINT V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha - (128 << 23)) >> 14;
1543  int R, G, B;
1544 
1545  Y -= c->yuv2rgb_y_offset;
1546  Y *= c->yuv2rgb_y_coeff;
1547  Y += (1 << 13) - (1 << 29);
1548 
1549  if (hasAlpha) {
1550  A = abuf0[i] * (1 << 11);
1551 
1552  A += 1 << 13;
1553  }
1554 
1555  R = V * c->yuv2rgb_v2r_coeff;
1556  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
1557  B = U * c->yuv2rgb_u2b_coeff;
1558 
1559  output_pixel(&dest[0], av_clip_uintp2(((int)(R_B + Y) >> 14) + (1<<15), 16));
1560  output_pixel(&dest[1], av_clip_uintp2(((int)( G + Y) >> 14) + (1<<15), 16));
1561  output_pixel(&dest[2], av_clip_uintp2(((int)(B_R + Y) >> 14) + (1<<15), 16));
1562  if (eightbytes) {
1563  output_pixel(&dest[3], av_clip_uintp2(A, 30) >> 14);
1564  dest += 4;
1565  } else {
1566  dest += 3;
1567  }
1568  }
1569  }
1570 }
1571 
1572 #undef output_pixel
1573 #undef r_b
1574 #undef b_r
1575 
1576 #define YUV2PACKED16WRAPPER_EXT(name, base, ext, fmt, is_be, hasAlpha, eightbytes) \
1577 static void name ## ext ## _X_c(SwsInternal *c, const int16_t *lumFilter, \
1578  const int16_t **_lumSrc, int lumFilterSize, \
1579  const int16_t *chrFilter, const int16_t **_chrUSrc, \
1580  const int16_t **_chrVSrc, int chrFilterSize, \
1581  const int16_t **_alpSrc, uint8_t *_dest, int dstW, \
1582  int y) \
1583 { \
1584  const int32_t **lumSrc = (const int32_t **) _lumSrc, \
1585  **chrUSrc = (const int32_t **) _chrUSrc, \
1586  **chrVSrc = (const int32_t **) _chrVSrc, \
1587  **alpSrc = (const int32_t **) _alpSrc; \
1588  uint16_t *dest = (uint16_t *) _dest; \
1589  name ## base ## _X_c_template(c, lumFilter, lumSrc, lumFilterSize, \
1590  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
1591  alpSrc, dest, dstW, y, fmt, hasAlpha, eightbytes, is_be); \
1592 } \
1593  \
1594 static void name ## ext ## _2_c(SwsInternal *c, const int16_t *_buf[2], \
1595  const int16_t *_ubuf[2], const int16_t *_vbuf[2], \
1596  const int16_t *_abuf[2], uint8_t *_dest, int dstW, \
1597  int yalpha, int uvalpha, int y) \
1598 { \
1599  const int32_t **buf = (const int32_t **) _buf, \
1600  **ubuf = (const int32_t **) _ubuf, \
1601  **vbuf = (const int32_t **) _vbuf, \
1602  **abuf = (const int32_t **) _abuf; \
1603  uint16_t *dest = (uint16_t *) _dest; \
1604  name ## base ## _2_c_template(c, buf, ubuf, vbuf, abuf, \
1605  dest, dstW, yalpha, uvalpha, y, fmt, hasAlpha, eightbytes, is_be); \
1606 } \
1607  \
1608 static void name ## ext ## _1_c(SwsInternal *c, const int16_t *_buf0, \
1609  const int16_t *_ubuf[2], const int16_t *_vbuf[2], \
1610  const int16_t *_abuf0, uint8_t *_dest, int dstW, \
1611  int uvalpha, int y) \
1612 { \
1613  const int32_t *buf0 = (const int32_t *) _buf0, \
1614  **ubuf = (const int32_t **) _ubuf, \
1615  **vbuf = (const int32_t **) _vbuf, \
1616  *abuf0 = (const int32_t *) _abuf0; \
1617  uint16_t *dest = (uint16_t *) _dest; \
1618  name ## base ## _1_c_template(c, buf0, ubuf, vbuf, abuf0, dest, \
1619  dstW, uvalpha, y, fmt, hasAlpha, eightbytes, is_be); \
1620 }
1621 #define YUV2PACKED16WRAPPER(name, base, ext, base_fmt, endianness, hasAlpha, eightbytes) \
1622  YUV2PACKED16WRAPPER_EXT(name, base, ext, base_fmt ## endianness, IS_BE(endianness), hasAlpha, eightbytes)
1623 
1624 YUV2PACKED16WRAPPER(yuv2, rgba64, rgb48be, AV_PIX_FMT_RGB48, BE, 0, 0)
1625 YUV2PACKED16WRAPPER(yuv2, rgba64, rgb48le, AV_PIX_FMT_RGB48, LE, 0, 0)
1626 YUV2PACKED16WRAPPER(yuv2, rgba64, bgr48be, AV_PIX_FMT_BGR48, BE, 0, 0)
1627 YUV2PACKED16WRAPPER(yuv2, rgba64, bgr48le, AV_PIX_FMT_BGR48, LE, 0, 0)
1628 YUV2PACKED16WRAPPER(yuv2, rgba64, rgba64be, AV_PIX_FMT_RGBA64, BE, 1, 1)
1629 YUV2PACKED16WRAPPER(yuv2, rgba64, rgba64le, AV_PIX_FMT_RGBA64, LE, 1, 1)
1630 YUV2PACKED16WRAPPER(yuv2, rgba64, rgbx64be, AV_PIX_FMT_RGBA64, BE, 0, 1)
1631 YUV2PACKED16WRAPPER(yuv2, rgba64, rgbx64le, AV_PIX_FMT_RGBA64, LE, 0, 1)
1632 YUV2PACKED16WRAPPER(yuv2, rgba64, bgra64be, AV_PIX_FMT_BGRA64, BE, 1, 1)
1633 YUV2PACKED16WRAPPER(yuv2, rgba64, bgra64le, AV_PIX_FMT_BGRA64, LE, 1, 1)
1634 YUV2PACKED16WRAPPER(yuv2, rgba64, bgrx64be, AV_PIX_FMT_BGRA64, BE, 0, 1)
1635 YUV2PACKED16WRAPPER(yuv2, rgba64, bgrx64le, AV_PIX_FMT_BGRA64, LE, 0, 1)
1636 YUV2PACKED16WRAPPER(yuv2, ya16, ya16be, AV_PIX_FMT_YA16, BE, 1, 0)
1637 YUV2PACKED16WRAPPER(yuv2, ya16, ya16le, AV_PIX_FMT_YA16, LE, 1, 0)
1638 
1639 YUV2PACKED16WRAPPER(yuv2, rgba64_full, rgb48be_full, AV_PIX_FMT_RGB48, BE, 0, 0)
1640 YUV2PACKED16WRAPPER(yuv2, rgba64_full, rgb48le_full, AV_PIX_FMT_RGB48, LE, 0, 0)
1641 YUV2PACKED16WRAPPER(yuv2, rgba64_full, bgr48be_full, AV_PIX_FMT_BGR48, BE, 0, 0)
1642 YUV2PACKED16WRAPPER(yuv2, rgba64_full, bgr48le_full, AV_PIX_FMT_BGR48, LE, 0, 0)
1643 YUV2PACKED16WRAPPER(yuv2, rgba64_full, rgba64be_full, AV_PIX_FMT_RGBA64, BE, 1, 1)
1644 YUV2PACKED16WRAPPER(yuv2, rgba64_full, rgba64le_full, AV_PIX_FMT_RGBA64, LE, 1, 1)
1645 YUV2PACKED16WRAPPER(yuv2, rgba64_full, rgbx64be_full, AV_PIX_FMT_RGBA64, BE, 0, 1)
1646 YUV2PACKED16WRAPPER(yuv2, rgba64_full, rgbx64le_full, AV_PIX_FMT_RGBA64, LE, 0, 1)
1647 YUV2PACKED16WRAPPER(yuv2, rgba64_full, bgra64be_full, AV_PIX_FMT_BGRA64, BE, 1, 1)
1648 YUV2PACKED16WRAPPER(yuv2, rgba64_full, bgra64le_full, AV_PIX_FMT_BGRA64, LE, 1, 1)
1649 YUV2PACKED16WRAPPER(yuv2, rgba64_full, bgrx64be_full, AV_PIX_FMT_BGRA64, BE, 0, 1)
1650 YUV2PACKED16WRAPPER(yuv2, rgba64_full, bgrx64le_full, AV_PIX_FMT_BGRA64, LE, 0, 1)
1651 
1652 /*
1653  * Write out 2 RGB pixels in the target pixel format. This function takes a
1654  * R/G/B LUT as generated by ff_yuv2rgb_c_init_tables(), which takes care of
1655  * things like endianness conversion and shifting. The caller takes care of
1656  * setting the correct offset in these tables from the chroma (U/V) values.
1657  * This function then uses the luminance (Y1/Y2) values to write out the
1658  * correct RGB values into the destination buffer.
1659  */
1660 static av_always_inline void
1661 yuv2rgb_write(uint8_t *_dest, int i, int Y1, int Y2,
1662  unsigned A1, unsigned A2,
1663  const void *_r, const void *_g, const void *_b, int y,
1664  enum AVPixelFormat target, int hasAlpha)
1665 {
1666  if (target == AV_PIX_FMT_ARGB || target == AV_PIX_FMT_RGBA ||
1667  target == AV_PIX_FMT_ABGR || target == AV_PIX_FMT_BGRA) {
1668  uint32_t *dest = (uint32_t *) _dest;
1669  const uint32_t *r = (const uint32_t *) _r;
1670  const uint32_t *g = (const uint32_t *) _g;
1671  const uint32_t *b = (const uint32_t *) _b;
1672 
1673 #if CONFIG_SMALL
1674  int sh = hasAlpha ? ((target == AV_PIX_FMT_RGB32_1 || target == AV_PIX_FMT_BGR32_1) ? 0 : 24) : 0;
1675 
1676  dest[i * 2 + 0] = r[Y1] + g[Y1] + b[Y1] + (hasAlpha ? A1 << sh : 0);
1677  dest[i * 2 + 1] = r[Y2] + g[Y2] + b[Y2] + (hasAlpha ? A2 << sh : 0);
1678 #else
1679  if (hasAlpha) {
1680  int sh = (target == AV_PIX_FMT_RGB32_1 || target == AV_PIX_FMT_BGR32_1) ? 0 : 24;
1681 
1682  av_assert2((((r[Y1] + g[Y1] + b[Y1]) >> sh) & 0xFF) == 0);
1683  dest[i * 2 + 0] = r[Y1] + g[Y1] + b[Y1] + (A1 << sh);
1684  dest[i * 2 + 1] = r[Y2] + g[Y2] + b[Y2] + (A2 << sh);
1685  } else {
1686 #if defined(ASSERT_LEVEL) && ASSERT_LEVEL > 1
1687  int sh = (target == AV_PIX_FMT_RGB32_1 || target == AV_PIX_FMT_BGR32_1) ? 0 : 24;
1688 
1689  av_assert2((((r[Y1] + g[Y1] + b[Y1]) >> sh) & 0xFF) == 0xFF);
1690 #endif
1691  dest[i * 2 + 0] = r[Y1] + g[Y1] + b[Y1];
1692  dest[i * 2 + 1] = r[Y2] + g[Y2] + b[Y2];
1693  }
1694 #endif
1695  } else if (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) {
1696  uint8_t *dest = (uint8_t *) _dest;
1697  const uint8_t *r = (const uint8_t *) _r;
1698  const uint8_t *g = (const uint8_t *) _g;
1699  const uint8_t *b = (const uint8_t *) _b;
1700 
1701 #define r_b ((target == AV_PIX_FMT_RGB24) ? r : b)
1702 #define b_r ((target == AV_PIX_FMT_RGB24) ? b : r)
1703 
1704  dest[i * 6 + 0] = r_b[Y1];
1705  dest[i * 6 + 1] = g[Y1];
1706  dest[i * 6 + 2] = b_r[Y1];
1707  dest[i * 6 + 3] = r_b[Y2];
1708  dest[i * 6 + 4] = g[Y2];
1709  dest[i * 6 + 5] = b_r[Y2];
1710 #undef r_b
1711 #undef b_r
1712  } else if (target == AV_PIX_FMT_RGB565 || target == AV_PIX_FMT_BGR565 ||
1713  target == AV_PIX_FMT_RGB555 || target == AV_PIX_FMT_BGR555 ||
1714  target == AV_PIX_FMT_RGB444 || target == AV_PIX_FMT_BGR444) {
1715  uint16_t *dest = (uint16_t *) _dest;
1716  const uint16_t *r = (const uint16_t *) _r;
1717  const uint16_t *g = (const uint16_t *) _g;
1718  const uint16_t *b = (const uint16_t *) _b;
1719  int dr1, dg1, db1, dr2, dg2, db2;
1720 
1721  if (target == AV_PIX_FMT_RGB565 || target == AV_PIX_FMT_BGR565) {
1722  dr1 = ff_dither_2x2_8[ y & 1 ][0];
1723  dg1 = ff_dither_2x2_4[ y & 1 ][0];
1724  db1 = ff_dither_2x2_8[(y & 1) ^ 1][0];
1725  dr2 = ff_dither_2x2_8[ y & 1 ][1];
1726  dg2 = ff_dither_2x2_4[ y & 1 ][1];
1727  db2 = ff_dither_2x2_8[(y & 1) ^ 1][1];
1728  } else if (target == AV_PIX_FMT_RGB555 || target == AV_PIX_FMT_BGR555) {
1729  dr1 = ff_dither_2x2_8[ y & 1 ][0];
1730  dg1 = ff_dither_2x2_8[ y & 1 ][1];
1731  db1 = ff_dither_2x2_8[(y & 1) ^ 1][0];
1732  dr2 = ff_dither_2x2_8[ y & 1 ][1];
1733  dg2 = ff_dither_2x2_8[ y & 1 ][0];
1734  db2 = ff_dither_2x2_8[(y & 1) ^ 1][1];
1735  } else {
1736  dr1 = ff_dither_4x4_16[ y & 3 ][0];
1737  dg1 = ff_dither_4x4_16[ y & 3 ][1];
1738  db1 = ff_dither_4x4_16[(y & 3) ^ 3][0];
1739  dr2 = ff_dither_4x4_16[ y & 3 ][1];
1740  dg2 = ff_dither_4x4_16[ y & 3 ][0];
1741  db2 = ff_dither_4x4_16[(y & 3) ^ 3][1];
1742  }
1743 
1744  dest[i * 2 + 0] = r[Y1 + dr1] + g[Y1 + dg1] + b[Y1 + db1];
1745  dest[i * 2 + 1] = r[Y2 + dr2] + g[Y2 + dg2] + b[Y2 + db2];
1746  } else if (target == AV_PIX_FMT_X2RGB10 || target == AV_PIX_FMT_X2BGR10) {
1747  uint32_t *dest = (uint32_t *) _dest;
1748  const uint32_t *r = (const uint32_t *) _r;
1749  const uint32_t *g = (const uint32_t *) _g;
1750  const uint32_t *b = (const uint32_t *) _b;
1751  dest[i * 2 + 0] = r[Y1] + g[Y1] + b[Y1];
1752  dest[i * 2 + 1] = r[Y2] + g[Y2] + b[Y2];
1753  } else /* 8/4 bits */ {
1754  uint8_t *dest = (uint8_t *) _dest;
1755  const uint8_t *r = (const uint8_t *) _r;
1756  const uint8_t *g = (const uint8_t *) _g;
1757  const uint8_t *b = (const uint8_t *) _b;
1758  int dr1, dg1, db1, dr2, dg2, db2;
1759 
1760  if (target == AV_PIX_FMT_RGB8 || target == AV_PIX_FMT_BGR8) {
1761  const uint8_t * const d64 = ff_dither_8x8_73[y & 7];
1762  const uint8_t * const d32 = ff_dither_8x8_32[y & 7];
1763  dr1 = dg1 = d32[(i * 2 + 0) & 7];
1764  db1 = d64[(i * 2 + 0) & 7];
1765  dr2 = dg2 = d32[(i * 2 + 1) & 7];
1766  db2 = d64[(i * 2 + 1) & 7];
1767  } else {
1768  const uint8_t * const d64 = ff_dither_8x8_73 [y & 7];
1769  const uint8_t * const d128 = ff_dither_8x8_220[y & 7];
1770  dr1 = db1 = d128[(i * 2 + 0) & 7];
1771  dg1 = d64[(i * 2 + 0) & 7];
1772  dr2 = db2 = d128[(i * 2 + 1) & 7];
1773  dg2 = d64[(i * 2 + 1) & 7];
1774  }
1775 
1776  if (target == AV_PIX_FMT_RGB4 || target == AV_PIX_FMT_BGR4) {
1777  dest[i] = r[Y1 + dr1] + g[Y1 + dg1] + b[Y1 + db1] +
1778  ((r[Y2 + dr2] + g[Y2 + dg2] + b[Y2 + db2]) << 4);
1779  } else {
1780  dest[i * 2 + 0] = r[Y1 + dr1] + g[Y1 + dg1] + b[Y1 + db1];
1781  dest[i * 2 + 1] = r[Y2 + dr2] + g[Y2 + dg2] + b[Y2 + db2];
1782  }
1783  }
1784 }
1785 
1786 static av_always_inline void
1787 yuv2rgb_X_c_template(SwsInternal *c, const int16_t *lumFilter,
1788  const int16_t **lumSrc, int lumFilterSize,
1789  const int16_t *chrFilter, const int16_t **chrUSrc,
1790  const int16_t **chrVSrc, int chrFilterSize,
1791  const int16_t **alpSrc, uint8_t *dest, int dstW,
1792  int y, enum AVPixelFormat target, int hasAlpha)
1793 {
1794  int i;
1795 
1796  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1797  int j, A1, A2;
1798  int Y1 = 1 << 18;
1799  int Y2 = 1 << 18;
1800  int U = 1 << 18;
1801  int V = 1 << 18;
1802  const void *r, *g, *b;
1803 
1804  for (j = 0; j < lumFilterSize; j++) {
1805  Y1 += (unsigned)(lumSrc[j][i * 2] * lumFilter[j]);
1806  Y2 += (unsigned)(lumSrc[j][i * 2 + 1] * lumFilter[j]);
1807  }
1808  for (j = 0; j < chrFilterSize; j++) {
1809  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
1810  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
1811  }
1812  Y1 >>= 19;
1813  Y2 >>= 19;
1814  U >>= 19;
1815  V >>= 19;
1816  if (hasAlpha) {
1817  A1 = 1 << 18;
1818  A2 = 1 << 18;
1819  for (j = 0; j < lumFilterSize; j++) {
1820  A1 += (unsigned)(alpSrc[j][i * 2 ] * lumFilter[j]);
1821  A2 += (unsigned)(alpSrc[j][i * 2 + 1] * lumFilter[j]);
1822  }
1823  A1 >>= 19;
1824  A2 >>= 19;
1825  if ((A1 | A2) & 0x100) {
1826  A1 = av_clip_uint8(A1);
1827  A2 = av_clip_uint8(A2);
1828  }
1829  }
1830 
1831  r = c->table_rV[V + YUVRGB_TABLE_HEADROOM];
1832  g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]);
1833  b = c->table_bU[U + YUVRGB_TABLE_HEADROOM];
1834 
1835  yuv2rgb_write(dest, i, Y1, Y2, hasAlpha ? A1 : 0, hasAlpha ? A2 : 0,
1836  r, g, b, y, target, hasAlpha);
1837  }
1838 }
1839 
1840 static av_always_inline void
1841 yuv2rgb_2_c_template(SwsInternal *c, const int16_t *buf[2],
1842  const int16_t *ubuf[2], const int16_t *vbuf[2],
1843  const int16_t *abuf[2], uint8_t *dest, int dstW,
1844  int yalpha, int uvalpha, int y,
1845  enum AVPixelFormat target, int hasAlpha)
1846 {
1847  const int16_t *buf0 = buf[0], *buf1 = buf[1],
1848  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
1849  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1],
1850  *abuf0 = hasAlpha ? abuf[0] : NULL,
1851  *abuf1 = hasAlpha ? abuf[1] : NULL;
1852  int yalpha1 = 4096 - yalpha;
1853  int uvalpha1 = 4096 - uvalpha;
1854  int i;
1855  av_assert2(yalpha <= 4096U);
1856  av_assert2(uvalpha <= 4096U);
1857 
1858  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1859  int Y1 = (buf0[i * 2] * yalpha1 + buf1[i * 2] * yalpha) >> 19;
1860  int Y2 = (buf0[i * 2 + 1] * yalpha1 + buf1[i * 2 + 1] * yalpha) >> 19;
1861  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha) >> 19;
1862  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha) >> 19;
1863  int A1, A2;
1864  const void *r = c->table_rV[V + YUVRGB_TABLE_HEADROOM],
1865  *g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]),
1866  *b = c->table_bU[U + YUVRGB_TABLE_HEADROOM];
1867 
1868  if (hasAlpha) {
1869  A1 = (abuf0[i * 2 ] * yalpha1 + abuf1[i * 2 ] * yalpha) >> 19;
1870  A2 = (abuf0[i * 2 + 1] * yalpha1 + abuf1[i * 2 + 1] * yalpha) >> 19;
1871  A1 = av_clip_uint8(A1);
1872  A2 = av_clip_uint8(A2);
1873  }
1874 
1875  yuv2rgb_write(dest, i, Y1, Y2, hasAlpha ? A1 : 0, hasAlpha ? A2 : 0,
1876  r, g, b, y, target, hasAlpha);
1877  }
1878 }
1879 
1880 static av_always_inline void
1881 yuv2rgb_1_c_template(SwsInternal *c, const int16_t *buf0,
1882  const int16_t *ubuf[2], const int16_t *vbuf[2],
1883  const int16_t *abuf0, uint8_t *dest, int dstW,
1884  int uvalpha, int y, enum AVPixelFormat target,
1885  int hasAlpha)
1886 {
1887  const int16_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0];
1888  int i;
1889 
1890  if (uvalpha == 0) {
1891  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1892  int Y1 = (buf0[i * 2 ] + 64) >> 7;
1893  int Y2 = (buf0[i * 2 + 1] + 64) >> 7;
1894  int U = (ubuf0[i] + 64) >> 7;
1895  int V = (vbuf0[i] + 64) >> 7;
1896  int A1, A2;
1897  const void *r = c->table_rV[V + YUVRGB_TABLE_HEADROOM],
1898  *g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]),
1899  *b = c->table_bU[U + YUVRGB_TABLE_HEADROOM];
1900 
1901  if (hasAlpha) {
1902  A1 = abuf0[i * 2 ] * 255 + 16384 >> 15;
1903  A2 = abuf0[i * 2 + 1] * 255 + 16384 >> 15;
1904  A1 = av_clip_uint8(A1);
1905  A2 = av_clip_uint8(A2);
1906  }
1907 
1908  yuv2rgb_write(dest, i, Y1, Y2, hasAlpha ? A1 : 0, hasAlpha ? A2 : 0,
1909  r, g, b, y, target, hasAlpha);
1910  }
1911  } else {
1912  const int16_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
1913  int uvalpha1 = 4096 - uvalpha;
1914  av_assert2(uvalpha <= 4096U);
1915 
1916  for (i = 0; i < ((dstW + 1) >> 1); i++) {
1917  int Y1 = (buf0[i * 2 ] + 64) >> 7;
1918  int Y2 = (buf0[i * 2 + 1] + 64) >> 7;
1919  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha + (128 << 11)) >> 19;
1920  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha + (128 << 11)) >> 19;
1921  int A1, A2;
1922  const void *r = c->table_rV[V + YUVRGB_TABLE_HEADROOM],
1923  *g = (c->table_gU[U + YUVRGB_TABLE_HEADROOM] + c->table_gV[V + YUVRGB_TABLE_HEADROOM]),
1924  *b = c->table_bU[U + YUVRGB_TABLE_HEADROOM];
1925 
1926  if (hasAlpha) {
1927  A1 = (abuf0[i * 2 ] + 64) >> 7;
1928  A2 = (abuf0[i * 2 + 1] + 64) >> 7;
1929  A1 = av_clip_uint8(A1);
1930  A2 = av_clip_uint8(A2);
1931  }
1932 
1933  yuv2rgb_write(dest, i, Y1, Y2, hasAlpha ? A1 : 0, hasAlpha ? A2 : 0,
1934  r, g, b, y, target, hasAlpha);
1935  }
1936  }
1937 }
1938 
1939 #define YUV2RGBWRAPPERX(name, base, ext, fmt, hasAlpha) \
1940 static void name ## ext ## _X_c(SwsInternal *c, const int16_t *lumFilter, \
1941  const int16_t **lumSrc, int lumFilterSize, \
1942  const int16_t *chrFilter, const int16_t **chrUSrc, \
1943  const int16_t **chrVSrc, int chrFilterSize, \
1944  const int16_t **alpSrc, uint8_t *dest, int dstW, \
1945  int y) \
1946 { \
1947  name ## base ## _X_c_template(c, lumFilter, lumSrc, lumFilterSize, \
1948  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
1949  alpSrc, dest, dstW, y, fmt, hasAlpha); \
1950 }
1951 
1952 #define YUV2RGBWRAPPERX2(name, base, ext, fmt, hasAlpha) \
1953 YUV2RGBWRAPPERX(name, base, ext, fmt, hasAlpha) \
1954 static void name ## ext ## _2_c(SwsInternal *c, const int16_t *buf[2], \
1955  const int16_t *ubuf[2], const int16_t *vbuf[2], \
1956  const int16_t *abuf[2], uint8_t *dest, int dstW, \
1957  int yalpha, int uvalpha, int y) \
1958 { \
1959  name ## base ## _2_c_template(c, buf, ubuf, vbuf, abuf, \
1960  dest, dstW, yalpha, uvalpha, y, fmt, hasAlpha); \
1961 }
1962 
1963 #define YUV2RGBWRAPPER(name, base, ext, fmt, hasAlpha) \
1964 YUV2RGBWRAPPERX2(name, base, ext, fmt, hasAlpha) \
1965 static void name ## ext ## _1_c(SwsInternal *c, const int16_t *buf0, \
1966  const int16_t *ubuf[2], const int16_t *vbuf[2], \
1967  const int16_t *abuf0, uint8_t *dest, int dstW, \
1968  int uvalpha, int y) \
1969 { \
1970  name ## base ## _1_c_template(c, buf0, ubuf, vbuf, abuf0, dest, \
1971  dstW, uvalpha, y, fmt, hasAlpha); \
1972 }
1973 
1974 #if CONFIG_SMALL
1975 YUV2RGBWRAPPER(yuv2rgb,, 32_1, AV_PIX_FMT_RGB32_1, CONFIG_SWSCALE_ALPHA && c->needAlpha)
1976 YUV2RGBWRAPPER(yuv2rgb,, 32, AV_PIX_FMT_RGB32, CONFIG_SWSCALE_ALPHA && c->needAlpha)
1977 #else
1978 #if CONFIG_SWSCALE_ALPHA
1979 YUV2RGBWRAPPER(yuv2rgb,, a32_1, AV_PIX_FMT_RGB32_1, 1)
1980 YUV2RGBWRAPPER(yuv2rgb,, a32, AV_PIX_FMT_RGB32, 1)
1981 #endif
1982 YUV2RGBWRAPPER(yuv2rgb,, x32_1, AV_PIX_FMT_RGB32_1, 0)
1983 YUV2RGBWRAPPER(yuv2rgb,, x32, AV_PIX_FMT_RGB32, 0)
1984 #endif
1985 YUV2RGBWRAPPER(yuv2, rgb, rgb24, AV_PIX_FMT_RGB24, 0)
1986 YUV2RGBWRAPPER(yuv2, rgb, bgr24, AV_PIX_FMT_BGR24, 0)
1987 YUV2RGBWRAPPER(yuv2rgb,, 16, AV_PIX_FMT_RGB565, 0)
1988 YUV2RGBWRAPPER(yuv2rgb,, 15, AV_PIX_FMT_RGB555, 0)
1989 YUV2RGBWRAPPER(yuv2rgb,, 12, AV_PIX_FMT_RGB444, 0)
1990 YUV2RGBWRAPPER(yuv2rgb,, 8, AV_PIX_FMT_RGB8, 0)
1991 YUV2RGBWRAPPER(yuv2rgb,, 4, AV_PIX_FMT_RGB4, 0)
1992 YUV2RGBWRAPPER(yuv2rgb,, 4b, AV_PIX_FMT_RGB4_BYTE, 0)
1993 YUV2RGBWRAPPER(yuv2, rgb, x2rgb10, AV_PIX_FMT_X2RGB10, 0)
1994 YUV2RGBWRAPPER(yuv2, rgb, x2bgr10, AV_PIX_FMT_X2BGR10, 0)
1995 
1996 static av_always_inline void yuv2rgb_write_full(SwsInternal *c,
1997  uint8_t *dest, int i, int Y, int A, int U, int V,
1998  int y, enum AVPixelFormat target, int hasAlpha, int err[4])
1999 {
2000  int R, G, B;
2001  int isrgb8 = target == AV_PIX_FMT_BGR8 || target == AV_PIX_FMT_RGB8;
2002 
2003  Y -= c->yuv2rgb_y_offset;
2004  Y *= c->yuv2rgb_y_coeff;
2005  Y += 1 << 21;
2006  R = (unsigned)Y + V*(unsigned)c->yuv2rgb_v2r_coeff;
2007  G = (unsigned)Y + V*(unsigned)c->yuv2rgb_v2g_coeff + U*(unsigned)c->yuv2rgb_u2g_coeff;
2008  B = (unsigned)Y + U*(unsigned)c->yuv2rgb_u2b_coeff;
2009  if ((R | G | B) & 0xC0000000) {
2010  R = av_clip_uintp2(R, 30);
2011  G = av_clip_uintp2(G, 30);
2012  B = av_clip_uintp2(B, 30);
2013  }
2014 
2015  switch(target) {
2016  case AV_PIX_FMT_ARGB:
2017  dest[0] = hasAlpha ? A : 255;
2018  dest[1] = R >> 22;
2019  dest[2] = G >> 22;
2020  dest[3] = B >> 22;
2021  break;
2022  case AV_PIX_FMT_RGB24:
2023  dest[0] = R >> 22;
2024  dest[1] = G >> 22;
2025  dest[2] = B >> 22;
2026  break;
2027  case AV_PIX_FMT_RGBA:
2028  dest[0] = R >> 22;
2029  dest[1] = G >> 22;
2030  dest[2] = B >> 22;
2031  dest[3] = hasAlpha ? A : 255;
2032  break;
2033  case AV_PIX_FMT_ABGR:
2034  dest[0] = hasAlpha ? A : 255;
2035  dest[1] = B >> 22;
2036  dest[2] = G >> 22;
2037  dest[3] = R >> 22;
2038  break;
2039  case AV_PIX_FMT_BGR24:
2040  dest[0] = B >> 22;
2041  dest[1] = G >> 22;
2042  dest[2] = R >> 22;
2043  break;
2044  case AV_PIX_FMT_BGRA:
2045  dest[0] = B >> 22;
2046  dest[1] = G >> 22;
2047  dest[2] = R >> 22;
2048  dest[3] = hasAlpha ? A : 255;
2049  break;
2050  case AV_PIX_FMT_X2RGB10LE:
2051  R >>= 20;
2052  G >>= 20;
2053  B >>= 20;
2054  AV_WL32(dest, (3U << 30) + (R << 20) + (G << 10) + B);
2055  break;
2056  case AV_PIX_FMT_X2BGR10LE:
2057  R >>= 20;
2058  G >>= 20;
2059  B >>= 20;
2060  AV_WL32(dest, (3U << 30) + (B << 20) + (G << 10) + R);
2061  break;
2062  case AV_PIX_FMT_BGR4_BYTE:
2063  case AV_PIX_FMT_RGB4_BYTE:
2064  case AV_PIX_FMT_BGR8:
2065  case AV_PIX_FMT_RGB8:
2066  {
2067  int r,g,b;
2068 
2069  switch (c->opts.dither) {
2070  case SWS_DITHER_NONE:
2071  if (isrgb8) {
2072  r = av_clip_uintp2(R >> 27, 3);
2073  g = av_clip_uintp2(G >> 27, 3);
2074  b = av_clip_uintp2(B >> 28, 2);
2075  } else {
2076  r = av_clip_uintp2(R >> 29, 1);
2077  g = av_clip_uintp2(G >> 28, 2);
2078  b = av_clip_uintp2(B >> 29, 1);
2079  }
2080  break;
2081  default:
2082  case SWS_DITHER_AUTO:
2083  case SWS_DITHER_ED:
2084  R >>= 22;
2085  G >>= 22;
2086  B >>= 22;
2087  R += (7*err[0] + 1*c->dither_error[0][i] + 5*c->dither_error[0][i+1] + 3*c->dither_error[0][i+2])>>4;
2088  G += (7*err[1] + 1*c->dither_error[1][i] + 5*c->dither_error[1][i+1] + 3*c->dither_error[1][i+2])>>4;
2089  B += (7*err[2] + 1*c->dither_error[2][i] + 5*c->dither_error[2][i+1] + 3*c->dither_error[2][i+2])>>4;
2090  c->dither_error[0][i] = err[0];
2091  c->dither_error[1][i] = err[1];
2092  c->dither_error[2][i] = err[2];
2093  r = R >> (isrgb8 ? 5 : 7);
2094  g = G >> (isrgb8 ? 5 : 6);
2095  b = B >> (isrgb8 ? 6 : 7);
2096  r = av_clip(r, 0, isrgb8 ? 7 : 1);
2097  g = av_clip(g, 0, isrgb8 ? 7 : 3);
2098  b = av_clip(b, 0, isrgb8 ? 3 : 1);
2099  err[0] = R - r*(isrgb8 ? 36 : 255);
2100  err[1] = G - g*(isrgb8 ? 36 : 85);
2101  err[2] = B - b*(isrgb8 ? 85 : 255);
2102  break;
2103  case SWS_DITHER_A_DITHER:
2104  if (isrgb8) {
2105  /* see http://pippin.gimp.org/a_dither/ for details/origin */
2106 #define A_DITHER(u,v) (((((u)+((v)*236))*119)&0xff))
2107  r = (((R >> 19) + A_DITHER(i,y) -96)>>8);
2108  g = (((G >> 19) + A_DITHER(i + 17,y) - 96)>>8);
2109  b = (((B >> 20) + A_DITHER(i + 17*2,y) -96)>>8);
2110  r = av_clip_uintp2(r, 3);
2111  g = av_clip_uintp2(g, 3);
2112  b = av_clip_uintp2(b, 2);
2113  } else {
2114  r = (((R >> 21) + A_DITHER(i,y)-256)>>8);
2115  g = (((G >> 19) + A_DITHER(i + 17,y)-256)>>8);
2116  b = (((B >> 21) + A_DITHER(i + 17*2,y)-256)>>8);
2117  r = av_clip_uintp2(r, 1);
2118  g = av_clip_uintp2(g, 2);
2119  b = av_clip_uintp2(b, 1);
2120  }
2121  break;
2122  case SWS_DITHER_X_DITHER:
2123  if (isrgb8) {
2124  /* see http://pippin.gimp.org/a_dither/ for details/origin */
2125 #define X_DITHER(u,v) (((((u)^((v)*237))*181)&0x1ff)/2)
2126  r = (((R >> 19) + X_DITHER(i,y) - 96)>>8);
2127  g = (((G >> 19) + X_DITHER(i + 17,y) - 96)>>8);
2128  b = (((B >> 20) + X_DITHER(i + 17*2,y) - 96)>>8);
2129  r = av_clip_uintp2(r, 3);
2130  g = av_clip_uintp2(g, 3);
2131  b = av_clip_uintp2(b, 2);
2132  } else {
2133  r = (((R >> 21) + X_DITHER(i,y)-256)>>8);
2134  g = (((G >> 19) + X_DITHER(i + 17,y)-256)>>8);
2135  b = (((B >> 21) + X_DITHER(i + 17*2,y)-256)>>8);
2136  r = av_clip_uintp2(r, 1);
2137  g = av_clip_uintp2(g, 2);
2138  b = av_clip_uintp2(b, 1);
2139  }
2140 
2141  break;
2142  }
2143 
2144  if(target == AV_PIX_FMT_BGR4_BYTE) {
2145  dest[0] = r + 2*g + 8*b;
2146  } else if(target == AV_PIX_FMT_RGB4_BYTE) {
2147  dest[0] = b + 2*g + 8*r;
2148  } else if(target == AV_PIX_FMT_BGR8) {
2149  dest[0] = r + 8*g + 64*b;
2150  } else if(target == AV_PIX_FMT_RGB8) {
2151  dest[0] = b + 4*g + 32*r;
2152  } else
2153  av_assert2(0);
2154  break;}
2155  }
2156 }
2157 
2158 static av_always_inline void
2159 yuv2rgb_full_X_c_template(SwsInternal *c, const int16_t *lumFilter,
2160  const int16_t **lumSrc, int lumFilterSize,
2161  const int16_t *chrFilter, const int16_t **chrUSrc,
2162  const int16_t **chrVSrc, int chrFilterSize,
2163  const int16_t **alpSrc, uint8_t *dest,
2164  int dstW, int y, enum AVPixelFormat target, int hasAlpha)
2165 {
2166  int i;
2167  int step = (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) ? 3 : 4;
2168  int err[4] = {0};
2169  int A = 0; //init to silence warning
2170 
2171  if( target == AV_PIX_FMT_BGR4_BYTE || target == AV_PIX_FMT_RGB4_BYTE
2172  || target == AV_PIX_FMT_BGR8 || target == AV_PIX_FMT_RGB8)
2173  step = 1;
2174 
2175  for (i = 0; i < dstW; i++) {
2176  int j;
2177  int Y = 1<<9;
2178  int U = (1<<9)-(128 << 19);
2179  int V = (1<<9)-(128 << 19);
2180 
2181  for (j = 0; j < lumFilterSize; j++) {
2182  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
2183  }
2184  for (j = 0; j < chrFilterSize; j++) {
2185  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
2186  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
2187  }
2188  Y >>= 10;
2189  U >>= 10;
2190  V >>= 10;
2191  if (hasAlpha) {
2192  A = 1 << 18;
2193  for (j = 0; j < lumFilterSize; j++) {
2194  A += (unsigned)(alpSrc[j][i] * lumFilter[j]);
2195  }
2196  A >>= 19;
2197  if (A & 0x100)
2198  A = av_clip_uint8(A);
2199  }
2200  yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2201  dest += step;
2202  }
2203  c->dither_error[0][i] = err[0];
2204  c->dither_error[1][i] = err[1];
2205  c->dither_error[2][i] = err[2];
2206 }
2207 
2208 static av_always_inline void
2209 yuv2rgb_full_2_c_template(SwsInternal *c, const int16_t *buf[2],
2210  const int16_t *ubuf[2], const int16_t *vbuf[2],
2211  const int16_t *abuf[2], uint8_t *dest, int dstW,
2212  int yalpha, int uvalpha, int y,
2213  enum AVPixelFormat target, int hasAlpha)
2214 {
2215  const int16_t *buf0 = buf[0], *buf1 = buf[1],
2216  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
2217  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1],
2218  *abuf0 = hasAlpha ? abuf[0] : NULL,
2219  *abuf1 = hasAlpha ? abuf[1] : NULL;
2220  int yalpha1 = 4096 - yalpha;
2221  int uvalpha1 = 4096 - uvalpha;
2222  int i;
2223  int step = (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) ? 3 : 4;
2224  int err[4] = {0};
2225  int A = 0; // init to silcene warning
2226 
2227  av_assert2(yalpha <= 4096U);
2228  av_assert2(uvalpha <= 4096U);
2229 
2230  if( target == AV_PIX_FMT_BGR4_BYTE || target == AV_PIX_FMT_RGB4_BYTE
2231  || target == AV_PIX_FMT_BGR8 || target == AV_PIX_FMT_RGB8)
2232  step = 1;
2233 
2234  for (i = 0; i < dstW; i++) {
2235  int Y = ( buf0[i] * yalpha1 + buf1[i] * yalpha ) >> 10; //FIXME rounding
2236  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha-(128 << 19)) >> 10;
2237  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha-(128 << 19)) >> 10;
2238 
2239  if (hasAlpha) {
2240  A = (abuf0[i] * yalpha1 + abuf1[i] * yalpha + (1<<18)) >> 19;
2241  if (A & 0x100)
2242  A = av_clip_uint8(A);
2243  }
2244 
2245  yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2246  dest += step;
2247  }
2248  c->dither_error[0][i] = err[0];
2249  c->dither_error[1][i] = err[1];
2250  c->dither_error[2][i] = err[2];
2251 }
2252 
2253 static av_always_inline void
2254 yuv2rgb_full_1_c_template(SwsInternal *c, const int16_t *buf0,
2255  const int16_t *ubuf[2], const int16_t *vbuf[2],
2256  const int16_t *abuf0, uint8_t *dest, int dstW,
2257  int uvalpha, int y, enum AVPixelFormat target,
2258  int hasAlpha)
2259 {
2260  const int16_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0];
2261  int i;
2262  int step = (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) ? 3 : 4;
2263  int err[4] = {0};
2264 
2265  if( target == AV_PIX_FMT_BGR4_BYTE || target == AV_PIX_FMT_RGB4_BYTE
2266  || target == AV_PIX_FMT_BGR8 || target == AV_PIX_FMT_RGB8)
2267  step = 1;
2268 
2269  if (uvalpha == 0) {
2270  int A = 0; //init to silence warning
2271  for (i = 0; i < dstW; i++) {
2272  int Y = buf0[i] * 4;
2273  int U = (ubuf0[i] - (128<<7)) * 4;
2274  int V = (vbuf0[i] - (128<<7)) * 4;
2275 
2276  if (hasAlpha) {
2277  A = (abuf0[i] + 64) >> 7;
2278  if (A & 0x100)
2279  A = av_clip_uint8(A);
2280  }
2281 
2282  yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2283  dest += step;
2284  }
2285  } else {
2286  const int16_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
2287  int A = 0; //init to silence warning
2288  int uvalpha1 = 4096 - uvalpha;
2289  av_assert2(uvalpha <= 4096U);
2290 
2291  for (i = 0; i < dstW; i++) {
2292  int Y = buf0[i] * 4;
2293  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha - (128 << 19)) >> 10;
2294  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha - (128 << 19)) >> 10;
2295 
2296  if (hasAlpha) {
2297  A = (abuf0[i] + 64) >> 7;
2298  if (A & 0x100)
2299  A = av_clip_uint8(A);
2300  }
2301 
2302  yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2303  dest += step;
2304  }
2305  }
2306 
2307  c->dither_error[0][i] = err[0];
2308  c->dither_error[1][i] = err[1];
2309  c->dither_error[2][i] = err[2];
2310 }
2311 
2312 #if CONFIG_SMALL
2313 YUV2RGBWRAPPER(yuv2, rgb_full, bgra32_full, AV_PIX_FMT_BGRA, CONFIG_SWSCALE_ALPHA && c->needAlpha)
2314 YUV2RGBWRAPPER(yuv2, rgb_full, abgr32_full, AV_PIX_FMT_ABGR, CONFIG_SWSCALE_ALPHA && c->needAlpha)
2315 YUV2RGBWRAPPER(yuv2, rgb_full, rgba32_full, AV_PIX_FMT_RGBA, CONFIG_SWSCALE_ALPHA && c->needAlpha)
2316 YUV2RGBWRAPPER(yuv2, rgb_full, argb32_full, AV_PIX_FMT_ARGB, CONFIG_SWSCALE_ALPHA && c->needAlpha)
2317 #else
2318 #if CONFIG_SWSCALE_ALPHA
2319 YUV2RGBWRAPPER(yuv2, rgb_full, bgra32_full, AV_PIX_FMT_BGRA, 1)
2320 YUV2RGBWRAPPER(yuv2, rgb_full, abgr32_full, AV_PIX_FMT_ABGR, 1)
2321 YUV2RGBWRAPPER(yuv2, rgb_full, rgba32_full, AV_PIX_FMT_RGBA, 1)
2322 YUV2RGBWRAPPER(yuv2, rgb_full, argb32_full, AV_PIX_FMT_ARGB, 1)
2323 #endif
2324 YUV2RGBWRAPPER(yuv2, rgb_full, bgrx32_full, AV_PIX_FMT_BGRA, 0)
2325 YUV2RGBWRAPPER(yuv2, rgb_full, xbgr32_full, AV_PIX_FMT_ABGR, 0)
2326 YUV2RGBWRAPPER(yuv2, rgb_full, rgbx32_full, AV_PIX_FMT_RGBA, 0)
2327 YUV2RGBWRAPPER(yuv2, rgb_full, xrgb32_full, AV_PIX_FMT_ARGB, 0)
2328 #endif
2329 YUV2RGBWRAPPER(yuv2, rgb_full, bgr24_full, AV_PIX_FMT_BGR24, 0)
2330 YUV2RGBWRAPPER(yuv2, rgb_full, rgb24_full, AV_PIX_FMT_RGB24, 0)
2331 
2332 YUV2RGBWRAPPER(yuv2, rgb_full, bgr4_byte_full, AV_PIX_FMT_BGR4_BYTE, 0)
2333 YUV2RGBWRAPPER(yuv2, rgb_full, rgb4_byte_full, AV_PIX_FMT_RGB4_BYTE, 0)
2334 YUV2RGBWRAPPER(yuv2, rgb_full, bgr8_full, AV_PIX_FMT_BGR8, 0)
2335 YUV2RGBWRAPPER(yuv2, rgb_full, rgb8_full, AV_PIX_FMT_RGB8, 0)
2336 
2337 YUV2RGBWRAPPER(yuv2, rgb_full, x2rgb10_full, AV_PIX_FMT_X2RGB10LE, 0)
2338 YUV2RGBWRAPPER(yuv2, rgb_full, x2bgr10_full, AV_PIX_FMT_X2BGR10LE, 0)
2339 
2340 static void
2341 yuv2gbrp_full_X_c(SwsInternal *c, const int16_t *lumFilter,
2342  const int16_t **lumSrc, int lumFilterSize,
2343  const int16_t *chrFilter, const int16_t **chrUSrc,
2344  const int16_t **chrVSrc, int chrFilterSize,
2345  const int16_t **alpSrc, uint8_t **dest,
2346  int dstW, int y)
2347 {
2348  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.dst_format);
2349  int i;
2350  int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrc;
2351  uint16_t **dest16 = (uint16_t**)dest;
2352  int SH = 22 + 8 - desc->comp[0].depth;
2353  int A = 0; // init to silence warning
2354 
2355  for (i = 0; i < dstW; i++) {
2356  int j;
2357  int Y = 1 << 9;
2358  int U = (1 << 9) - (128 << 19);
2359  int V = (1 << 9) - (128 << 19);
2360  int R, G, B;
2361 
2362  for (j = 0; j < lumFilterSize; j++)
2363  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
2364 
2365  for (j = 0; j < chrFilterSize; j++) {
2366  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
2367  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
2368  }
2369 
2370  Y >>= 10;
2371  U >>= 10;
2372  V >>= 10;
2373 
2374  if (hasAlpha) {
2375  A = 1 << 18;
2376 
2377  for (j = 0; j < lumFilterSize; j++)
2378  A += (unsigned)(alpSrc[j][i] * lumFilter[j]);
2379 
2380  if (A & 0xF8000000)
2381  A = av_clip_uintp2(A, 27);
2382  }
2383 
2384  Y -= c->yuv2rgb_y_offset;
2385  Y *= c->yuv2rgb_y_coeff;
2386  Y += 1 << (SH-1);
2387  R = Y + V * (unsigned)c->yuv2rgb_v2r_coeff;
2388  G = Y + V * (unsigned)c->yuv2rgb_v2g_coeff + U * (unsigned)c->yuv2rgb_u2g_coeff;
2389  B = Y + U * (unsigned)c->yuv2rgb_u2b_coeff;
2390 
2391  if ((R | G | B) & 0xC0000000) {
2392  R = av_clip_uintp2(R, 30);
2393  G = av_clip_uintp2(G, 30);
2394  B = av_clip_uintp2(B, 30);
2395  }
2396 
2397  if (SH != 22) {
2398  dest16[0][i] = G >> SH;
2399  dest16[1][i] = B >> SH;
2400  dest16[2][i] = R >> SH;
2401  if (hasAlpha)
2402  dest16[3][i] = A >> (SH - 3);
2403  } else {
2404  dest[0][i] = G >> 22;
2405  dest[1][i] = B >> 22;
2406  dest[2][i] = R >> 22;
2407  if (hasAlpha)
2408  dest[3][i] = A >> 19;
2409  }
2410  }
2411  if (SH != 22 && (!isBE(c->opts.dst_format)) != (!HAVE_BIGENDIAN)) {
2412  for (i = 0; i < dstW; i++) {
2413  dest16[0][i] = av_bswap16(dest16[0][i]);
2414  dest16[1][i] = av_bswap16(dest16[1][i]);
2415  dest16[2][i] = av_bswap16(dest16[2][i]);
2416  if (hasAlpha)
2417  dest16[3][i] = av_bswap16(dest16[3][i]);
2418  }
2419  }
2420 }
2421 
2422 static void
2423 yuv2gbrpmsb_full_X_c(SwsInternal *c, const int16_t *lumFilter,
2424  const int16_t **lumSrc, int lumFilterSize,
2425  const int16_t *chrFilter, const int16_t **chrUSrc,
2426  const int16_t **chrVSrc, int chrFilterSize,
2427  const int16_t **alpSrc, uint8_t **dest,
2428  int dstW, int y)
2429 {
2430  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.dst_format);
2431  int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrc;
2432  uint16_t **dest16 = (uint16_t**)dest;
2433  int shift = 16 - desc->comp[0].depth;
2434  int i;
2435 
2436  yuv2gbrp_full_X_c(c, lumFilter, lumSrc, lumFilterSize,
2437  chrFilter, chrUSrc, chrVSrc, chrFilterSize,
2438  alpSrc, dest, dstW, y);
2439 
2440  if (desc->comp[0].depth <= 8)
2441  return;
2442 
2443  if ((!isBE(c->opts.dst_format)) != (!HAVE_BIGENDIAN)) {
2444  for (i = 0; i < dstW; i++) {
2445  dest16[0][i] = av_bswap16(av_bswap16(dest16[0][i]) << shift);
2446  dest16[1][i] = av_bswap16(av_bswap16(dest16[1][i]) << shift);
2447  dest16[2][i] = av_bswap16(av_bswap16(dest16[2][i]) << shift);
2448  if (hasAlpha)
2449  dest16[3][i] = av_bswap16(av_bswap16(dest16[3][i]) << shift);
2450  }
2451  } else {
2452  for (i = 0; i < dstW; i++) {
2453  dest16[0][i] = dest16[0][i] << shift;
2454  dest16[1][i] = dest16[1][i] << shift;
2455  dest16[2][i] = dest16[2][i] << shift;
2456  if (hasAlpha)
2457  dest16[3][i] = dest16[3][i] << shift;
2458  }
2459  }
2460 }
2461 
2462 static void
2463 yuv2gbrp16_full_X_c(SwsInternal *c, const int16_t *lumFilter,
2464  const int16_t **lumSrcx, int lumFilterSize,
2465  const int16_t *chrFilter, const int16_t **chrUSrcx,
2466  const int16_t **chrVSrcx, int chrFilterSize,
2467  const int16_t **alpSrcx, uint8_t **dest,
2468  int dstW, int y)
2469 {
2470  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.dst_format);
2471  int i;
2472  int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrcx;
2473  uint16_t **dest16 = (uint16_t**)dest;
2474  const int32_t **lumSrc = (const int32_t**)lumSrcx;
2475  const int32_t **chrUSrc = (const int32_t**)chrUSrcx;
2476  const int32_t **chrVSrc = (const int32_t**)chrVSrcx;
2477  const int32_t **alpSrc = (const int32_t**)alpSrcx;
2478 
2479  for (i = 0; i < dstW; i++) {
2480  int j;
2481  int Y = -0x40000000;
2482  int U = -(128 << 23);
2483  int V = -(128 << 23);
2484  int R, G, B, A;
2485 
2486  for (j = 0; j < lumFilterSize; j++)
2487  Y += lumSrc[j][i] * (unsigned)lumFilter[j];
2488 
2489  for (j = 0; j < chrFilterSize; j++) {
2490  U += chrUSrc[j][i] * (unsigned)chrFilter[j];
2491  V += chrVSrc[j][i] * (unsigned)chrFilter[j];
2492  }
2493 
2494  Y >>= 14;
2495  Y += 0x10000;
2496  U >>= 14;
2497  V >>= 14;
2498 
2499  if (hasAlpha) {
2500  A = -0x40000000;
2501 
2502  for (j = 0; j < lumFilterSize; j++)
2503  A += alpSrc[j][i] * (unsigned)lumFilter[j];
2504 
2505  A >>= 1;
2506  A += 0x20002000;
2507  }
2508 
2509  Y -= c->yuv2rgb_y_offset;
2510  Y *= c->yuv2rgb_y_coeff;
2511  Y += (1 << 13) - (1 << 29);
2512  R = V * c->yuv2rgb_v2r_coeff;
2513  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
2514  B = U * c->yuv2rgb_u2b_coeff;
2515 
2516  dest16[2][i] = av_clip_uintp2(((Y + R) >> 14) + (1<<15), 16);
2517  dest16[0][i] = av_clip_uintp2(((Y + G) >> 14) + (1<<15), 16);
2518  dest16[1][i] = av_clip_uintp2(((Y + B) >> 14) + (1<<15), 16);
2519 
2520  if (hasAlpha)
2521  dest16[3][i] = av_clip_uintp2(A, 30) >> 14;
2522  }
2523  if ((!isBE(c->opts.dst_format)) != (!HAVE_BIGENDIAN)) {
2524  for (i = 0; i < dstW; i++) {
2525  dest16[0][i] = av_bswap16(dest16[0][i]);
2526  dest16[1][i] = av_bswap16(dest16[1][i]);
2527  dest16[2][i] = av_bswap16(dest16[2][i]);
2528  if (hasAlpha)
2529  dest16[3][i] = av_bswap16(dest16[3][i]);
2530  }
2531  }
2532 }
2533 
2534 static void
2535 yuv2gbrpf32_full_X_c(SwsInternal *c, const int16_t *lumFilter,
2536  const int16_t **lumSrcx, int lumFilterSize,
2537  const int16_t *chrFilter, const int16_t **chrUSrcx,
2538  const int16_t **chrVSrcx, int chrFilterSize,
2539  const int16_t **alpSrcx, uint8_t **dest,
2540  int dstW, int y)
2541 {
2542  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->opts.dst_format);
2543  int i;
2544  int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrcx;
2545  uint32_t **dest32 = (uint32_t**)dest;
2546  const int32_t **lumSrc = (const int32_t**)lumSrcx;
2547  const int32_t **chrUSrc = (const int32_t**)chrUSrcx;
2548  const int32_t **chrVSrc = (const int32_t**)chrVSrcx;
2549  const int32_t **alpSrc = (const int32_t**)alpSrcx;
2550  static const float float_mult = 1.0f / 65535.0f;
2551 
2552  for (i = 0; i < dstW; i++) {
2553  int j;
2554  int Y = -0x40000000;
2555  int U = -(128 << 23);
2556  int V = -(128 << 23);
2557  int R, G, B, A;
2558 
2559  for (j = 0; j < lumFilterSize; j++)
2560  Y += lumSrc[j][i] * (unsigned)lumFilter[j];
2561 
2562  for (j = 0; j < chrFilterSize; j++) {
2563  U += chrUSrc[j][i] * (unsigned)chrFilter[j];
2564  V += chrVSrc[j][i] * (unsigned)chrFilter[j];
2565  }
2566 
2567  Y >>= 14;
2568  Y += 0x10000;
2569  U >>= 14;
2570  V >>= 14;
2571 
2572  if (hasAlpha) {
2573  A = -0x40000000;
2574 
2575  for (j = 0; j < lumFilterSize; j++)
2576  A += alpSrc[j][i] * (unsigned)lumFilter[j];
2577 
2578  A >>= 1;
2579  A += 0x20002000;
2580  }
2581 
2582  Y -= c->yuv2rgb_y_offset;
2583  Y *= c->yuv2rgb_y_coeff;
2584  Y += (1 << 13) - (1 << 29);
2585  R = V * c->yuv2rgb_v2r_coeff;
2586  G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
2587  B = U * c->yuv2rgb_u2b_coeff;
2588 
2589  R = av_clip_uintp2(((Y + R) >> 14) + (1<<15), 16);
2590  G = av_clip_uintp2(((Y + G) >> 14) + (1<<15), 16);
2591  B = av_clip_uintp2(((Y + B) >> 14) + (1<<15), 16);
2592 
2593  dest32[0][i] = av_float2int(float_mult * (float)G);
2594  dest32[1][i] = av_float2int(float_mult * (float)B);
2595  dest32[2][i] = av_float2int(float_mult * (float)R);
2596  if (hasAlpha)
2597  dest32[3][i] = av_float2int(float_mult * (float)(av_clip_uintp2(A, 30) >> 14));
2598  }
2599  if ((!isBE(c->opts.dst_format)) != (!HAVE_BIGENDIAN)) {
2600  for (i = 0; i < dstW; i++) {
2601  dest32[0][i] = av_bswap32(dest32[0][i]);
2602  dest32[1][i] = av_bswap32(dest32[1][i]);
2603  dest32[2][i] = av_bswap32(dest32[2][i]);
2604  if (hasAlpha)
2605  dest32[3][i] = av_bswap32(dest32[3][i]);
2606  }
2607  }
2608 }
2609 
2610 static void
2611 yuv2ya8_1_c(SwsInternal *c, const int16_t *buf0,
2612  const int16_t *ubuf[2], const int16_t *vbuf[2],
2613  const int16_t *abuf0, uint8_t *dest, int dstW,
2614  int uvalpha, int y)
2615 {
2616  int hasAlpha = !!abuf0;
2617  int i;
2618 
2619  for (i = 0; i < dstW; i++) {
2620  int Y = (buf0[i] + 64) >> 7;
2621  int A;
2622 
2623  Y = av_clip_uint8(Y);
2624 
2625  if (hasAlpha) {
2626  A = (abuf0[i] + 64) >> 7;
2627  if (A & 0x100)
2628  A = av_clip_uint8(A);
2629  }
2630 
2631  dest[i * 2 ] = Y;
2632  dest[i * 2 + 1] = hasAlpha ? A : 255;
2633  }
2634 }
2635 
2636 static void
2637 yuv2ya8_2_c(SwsInternal *c, const int16_t *buf[2],
2638  const int16_t *ubuf[2], const int16_t *vbuf[2],
2639  const int16_t *abuf[2], uint8_t *dest, int dstW,
2640  int yalpha, int uvalpha, int y)
2641 {
2642  int hasAlpha = abuf && abuf[0] && abuf[1];
2643  const int16_t *buf0 = buf[0], *buf1 = buf[1],
2644  *abuf0 = hasAlpha ? abuf[0] : NULL,
2645  *abuf1 = hasAlpha ? abuf[1] : NULL;
2646  int yalpha1 = 4096 - yalpha;
2647  int i;
2648 
2649  av_assert2(yalpha <= 4096U);
2650 
2651  for (i = 0; i < dstW; i++) {
2652  int Y = (buf0[i] * yalpha1 + buf1[i] * yalpha) >> 19;
2653  int A;
2654 
2655  Y = av_clip_uint8(Y);
2656 
2657  if (hasAlpha) {
2658  A = (abuf0[i] * yalpha1 + abuf1[i] * yalpha) >> 19;
2659  A = av_clip_uint8(A);
2660  }
2661 
2662  dest[i * 2 ] = Y;
2663  dest[i * 2 + 1] = hasAlpha ? A : 255;
2664  }
2665 }
2666 
2667 static void
2668 yuv2ya8_X_c(SwsInternal *c, const int16_t *lumFilter,
2669  const int16_t **lumSrc, int lumFilterSize,
2670  const int16_t *chrFilter, const int16_t **chrUSrc,
2671  const int16_t **chrVSrc, int chrFilterSize,
2672  const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
2673 {
2674  int hasAlpha = !!alpSrc;
2675  int i;
2676 
2677  for (i = 0; i < dstW; i++) {
2678  int j;
2679  int Y = 1 << 18, A = 1 << 18;
2680 
2681  for (j = 0; j < lumFilterSize; j++)
2682  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
2683 
2684  Y >>= 19;
2685  if (Y & 0x100)
2686  Y = av_clip_uint8(Y);
2687 
2688  if (hasAlpha) {
2689  for (j = 0; j < lumFilterSize; j++)
2690  A += (unsigned)(alpSrc[j][i] * lumFilter[j]);
2691 
2692  A >>= 19;
2693 
2694  if (A & 0x100)
2695  A = av_clip_uint8(A);
2696  }
2697 
2698  dest[2 * i ] = Y;
2699  dest[2 * i + 1] = hasAlpha ? A : 255;
2700  }
2701 }
2702 
2703 #define output_pixels(pos, val) \
2704  if (is_be) { \
2705  AV_WB16(pos, val); \
2706  } else { \
2707  AV_WL16(pos, val); \
2708  }
2709 
2710 static av_always_inline void
2711 yuv2ayuv64_X_c(SwsInternal *c, const int16_t *lumFilter,
2712  const int16_t **_lumSrc, int lumFilterSize,
2713  const int16_t *chrFilter, const int16_t **_chrUSrc,
2714  const int16_t **_chrVSrc, int chrFilterSize,
2715  const int16_t **_alpSrc, uint8_t *dest, int dstW, int y,
2716  int A_offset, int Y_offset, int U_offset, int V_offset, int is_be)
2717 {
2718  const int32_t **lumSrc = (const int32_t **) _lumSrc,
2719  **chrUSrc = (const int32_t **) _chrUSrc,
2720  **chrVSrc = (const int32_t **) _chrVSrc,
2721  **alpSrc = (const int32_t **) _alpSrc;
2722  int hasAlpha = !!alpSrc;
2723  int i;
2724 
2725  for (i = 0; i < dstW; i++) {
2726  int Y = 1 << 14, U = 1 << 14;
2727  int V = 1 << 14, A = 1 << 14;
2728  int j;
2729 
2730  Y -= 0x40000000;
2731  U -= 0x40000000;
2732  V -= 0x40000000;
2733  A -= 0x40000000;
2734 
2735  for (j = 0; j < lumFilterSize; j++)
2736  Y += lumSrc[j][i] * (unsigned)lumFilter[j];
2737 
2738  for (j = 0; j < chrFilterSize; j++)
2739  U += chrUSrc[j][i] * (unsigned)chrFilter[j];
2740 
2741  for (j = 0; j < chrFilterSize; j++)
2742  V += chrVSrc[j][i] * (unsigned)chrFilter[j];
2743 
2744  if (hasAlpha)
2745  for (j = 0; j < lumFilterSize; j++)
2746  A += alpSrc[j][i] * (unsigned)lumFilter[j];
2747 
2748  Y = 0x8000 + av_clip_int16(Y >> 15);
2749  U = 0x8000 + av_clip_int16(U >> 15);
2750  V = 0x8000 + av_clip_int16(V >> 15);
2751  if (hasAlpha)
2752  A = 0x8000 + av_clip_int16(A >> 15);
2753 
2754  output_pixels(dest + 8 * i + A_offset, hasAlpha ? A : 65535);
2755  output_pixels(dest + 8 * i + Y_offset, Y);
2756  output_pixels(dest + 8 * i + U_offset, U);
2757  output_pixels(dest + 8 * i + V_offset, V);
2758  }
2759 }
2760 
2761 #define YUV2AYUV64(pixfmt, BE_LE, A, Y, U, V, is_be) \
2762 static void \
2763 yuv2 ## pixfmt ## BE_LE ##_X_c(SwsInternal *c, const int16_t *lumFilter, \
2764  const int16_t **lumSrc, int lumFilterSize, \
2765  const int16_t *chrFilter, const int16_t **chrUSrc, \
2766  const int16_t **chrVSrc, int chrFilterSize, \
2767  const int16_t **alpSrc, uint8_t *dest, int dstW, int y) \
2768 { \
2769  yuv2ayuv64_X_c(c, lumFilter, lumSrc, lumFilterSize, \
2770  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
2771  alpSrc, dest, dstW, y, A, Y, U, V, is_be); \
2772 }
2773 
2774 YUV2AYUV64(ayuv64, le, 0, 2, 4, 6, 0)
2775 YUV2AYUV64(ayuv64, be, 0, 2, 4, 6, 1)
2776 
2777 YUV2AYUV64(xv48, le, 6, 2, 0, 4, 0)
2778 YUV2AYUV64(xv48, be, 6, 2, 0, 4, 1)
2779 
2780 #undef output_pixels
2781 
2782 static av_always_inline void
2783 yuv2v30_X_c_template(SwsInternal *c, const int16_t *lumFilter,
2784  const int16_t **lumSrc, int lumFilterSize,
2785  const int16_t *chrFilter, const int16_t **chrUSrc,
2786  const int16_t **chrVSrc, int chrFilterSize,
2787  const int16_t **alpSrc, uint8_t *dest, int dstW, int y,
2788  int shift)
2789 {
2790  int i;
2791  for (i = 0; i < dstW; i++) {
2792  int Y = 1 << 16, U = 1 << 16, V = 1 << 16, A = 0x3;
2793  int j;
2794 
2795  for (j = 0; j < lumFilterSize; j++)
2796  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
2797 
2798  for (j = 0; j < chrFilterSize; j++) {
2799  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
2800  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
2801  }
2802 
2803  Y = av_clip_uintp2(Y >> 17, 10);
2804  U = av_clip_uintp2(U >> 17, 10);
2805  V = av_clip_uintp2(V >> 17, 10);
2806 
2807  AV_WL32(dest + 4 * i, U << (shift + 0) |
2808  Y << (shift + 10) |
2809  (unsigned)V << (shift + 20) |
2810  (unsigned)A << (shift ? 0 : 30 /* xv30le = 30, v30xle = 0 */));
2811  }
2812 }
2813 
2814 #define V30LE_WRAPPER(name, shift) \
2815 static void yuv2 ## name ## _X_c(SwsInternal *c, const int16_t *lumFilter, \
2816  const int16_t **lumSrc, int lumFilterSize, \
2817  const int16_t *chrFilter, const int16_t **chrUSrc, \
2818  const int16_t **chrVSrc, int chrFilterSize, \
2819  const int16_t **alpSrc, uint8_t *dest, int dstW, \
2820  int y) \
2821 { \
2822  yuv2v30_X_c_template(c, lumFilter, lumSrc, lumFilterSize, \
2823  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
2824  alpSrc, dest, dstW, y, shift); \
2825 }
2826 
2827 V30LE_WRAPPER(xv30le, 0)
2828 V30LE_WRAPPER(v30xle, 2)
2829 
2830 #define output_pixels(pos, val, shift, bits, output_shift) \
2831  if (is_be) { \
2832  AV_WB16(pos, av_clip_uintp2(val >> shift, bits) << output_shift); \
2833  } else { \
2834  AV_WL16(pos, av_clip_uintp2(val >> shift, bits) << output_shift); \
2835  }
2836 
2837 static void
2838 yuv2xv36_X_c(SwsInternal *c, const int16_t *lumFilter,
2839  const int16_t **lumSrc, int lumFilterSize,
2840  const int16_t *chrFilter, const int16_t **chrUSrc,
2841  const int16_t **chrVSrc, int chrFilterSize,
2842  const int16_t **alpSrc, uint8_t *dest, int dstW, int y, int is_be)
2843 {
2844  int i;
2845  for (i = 0; i < dstW; i++) {
2846  int Y = 1 << 14, U = 1 << 14, V = 1 << 14, A = 65535;
2847  int j;
2848 
2849  for (j = 0; j < lumFilterSize; j++)
2850  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
2851 
2852  for (j = 0; j < chrFilterSize; j++) {
2853  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
2854  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
2855  }
2856 
2857  output_pixels(dest + 8 * i + 2, Y, 15, 12, 4)
2858  output_pixels(dest + 8 * i + 0, U, 15, 12, 4)
2859  output_pixels(dest + 8 * i + 4, V, 15, 12, 4)
2860  output_pixels(dest + 8 * i + 6, A, 0, 12, 4);
2861  }
2862 }
2863 
2864 #undef output_pixels
2865 
2866 #define YUV2XV36(BE_LE, is_be) \
2867 static void \
2868 yuv2xv36 ## BE_LE ##_X_c(SwsInternal *c, const int16_t *lumFilter, \
2869  const int16_t **lumSrc, int lumFilterSize, \
2870  const int16_t *chrFilter, const int16_t **chrUSrc, \
2871  const int16_t **chrVSrc, int chrFilterSize, \
2872  const int16_t **alpSrc, uint8_t *dest, int dstW, int y) \
2873 { \
2874  yuv2xv36_X_c(c, lumFilter, lumSrc, lumFilterSize, \
2875  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
2876  alpSrc, dest, dstW, y, is_be); \
2877 }
2878 
2879 YUV2XV36(le, 0)
2880 YUV2XV36(be, 1)
2881 
2882 #define output_pixels(pos, A, Y, U, V) \
2883  if (target == AV_PIX_FMT_AYUV) { \
2884  dest[pos + 0] = A; \
2885  dest[pos + 1] = Y; \
2886  dest[pos + 2] = U; \
2887  dest[pos + 3] = V; \
2888  } else if (target == AV_PIX_FMT_UYVA) { \
2889  dest[pos + 0] = U; \
2890  dest[pos + 1] = Y; \
2891  dest[pos + 2] = V; \
2892  dest[pos + 3] = A; \
2893  } else { /* AV_PIX_FMT_VUYA || AV_PIX_FMT_VUYX */ \
2894  dest[pos + 0] = V; \
2895  dest[pos + 1] = U; \
2896  dest[pos + 2] = Y; \
2897  dest[pos + 3] = A; \
2898  }
2899 
2900 static av_always_inline void
2901 yuv2ayuv_1_c_template(SwsInternal *c, const int16_t *buf0,
2902  const int16_t *ubuf[2], const int16_t *vbuf[2],
2903  const int16_t *abuf0, uint8_t *dest, int dstW,
2904  int uvalpha, int y, enum AVPixelFormat target)
2905 {
2906  int hasAlpha = !!abuf0;
2907  int i;
2908 
2909  if (uvalpha < 2048) {
2910  for (i = 0; i < dstW; i++) {
2911  int Y = (buf0[i] + 64) >> 7;
2912  int U = (ubuf[0][i] + 64) >> 7;
2913  int V = (vbuf[0][i] + 64) >> 7;
2914  int A = 255;
2915 
2916  if (Y & 0x100)
2917  Y = av_clip_uint8(Y);
2918  if (U & 0x100)
2919  U = av_clip_uint8(U);
2920  if (V & 0x100)
2921  V = av_clip_uint8(V);
2922 
2923  if (hasAlpha) {
2924  A = (abuf0[i] + 64) >> 7;
2925  if (A & 0x100)
2926  A = av_clip_uint8(A);
2927  }
2928 
2929  output_pixels(i * 4, A, Y, U, V)
2930  }
2931  } else {
2932  for (i = 0; i < dstW; i++) {
2933  int Y = (buf0[i] + 64) >> 7;
2934  int U = (ubuf[0][i] + ubuf[1][i] + 128) >> 8;
2935  int V = (vbuf[0][i] + vbuf[1][i] + 128) >> 8;
2936  int A = 255;
2937 
2938  if (Y & 0x100)
2939  Y = av_clip_uint8(Y);
2940  if (U & 0x100)
2941  U = av_clip_uint8(U);
2942  if (V & 0x100)
2943  V = av_clip_uint8(V);
2944 
2945  if (hasAlpha) {
2946  A = (abuf0[i] + 64) >> 7;
2947  if (A & 0x100)
2948  A = av_clip_uint8(A);
2949  }
2950 
2951  output_pixels(i * 4, A, Y, U, V)
2952  }
2953  }
2954 }
2955 
2956 static av_always_inline void
2957 yuv2ayuv_2_c_template(SwsInternal *c, const int16_t *buf[2],
2958  const int16_t *ubuf[2], const int16_t *vbuf[2],
2959  const int16_t *abuf[2], uint8_t *dest, int dstW,
2960  int yalpha, int uvalpha, int y,
2961  enum AVPixelFormat target)
2962 {
2963  int hasAlpha = abuf && abuf[0] && abuf[1];
2964  const int16_t *buf0 = buf[0], *buf1 = buf[1],
2965  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
2966  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1],
2967  *abuf0 = hasAlpha ? abuf[0] : NULL,
2968  *abuf1 = hasAlpha ? abuf[1] : NULL;
2969  int yalpha1 = 4096 - yalpha;
2970  int uvalpha1 = 4096 - uvalpha;
2971  int i;
2972 
2973  av_assert2(yalpha <= 4096U);
2974  av_assert2(uvalpha <= 4096U);
2975 
2976  for (i = 0; i < dstW; i++) {
2977  int Y = (buf0[i] * yalpha1 + buf1[i] * yalpha) >> 19;
2978  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha) >> 19;
2979  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha) >> 19;
2980  int A = 255;
2981 
2982  if (Y & 0x100)
2983  Y = av_clip_uint8(Y);
2984  if (U & 0x100)
2985  U = av_clip_uint8(U);
2986  if (V & 0x100)
2987  V = av_clip_uint8(V);
2988 
2989  if (hasAlpha) {
2990  A = (abuf0[i] * yalpha1 + abuf1[i] * yalpha) >> 19;
2991  A = av_clip_uint8(A);
2992  }
2993 
2994  output_pixels(i * 4, A, Y, U, V)
2995  }
2996 }
2997 
2998 static av_always_inline void
2999 yuv2ayuv_X_c_template(SwsInternal *c, const int16_t *lumFilter,
3000  const int16_t **lumSrc, int lumFilterSize,
3001  const int16_t *chrFilter, const int16_t **chrUSrc,
3002  const int16_t **chrVSrc, int chrFilterSize,
3003  const int16_t **alpSrc, uint8_t *dest, int dstW,
3004  int y, enum AVPixelFormat target)
3005 {
3006  int i;
3007 
3008  for (i = 0; i < dstW; i++) {
3009  int j;
3010  int Y = 1 << 18, U = 1 << 18;
3011  int V = 1 << 18, A = 255;
3012 
3013  for (j = 0; j < lumFilterSize; j++)
3014  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
3015 
3016  for (j = 0; j < chrFilterSize; j++)
3017  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
3018 
3019  for (j = 0; j < chrFilterSize; j++)
3020  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
3021 
3022  Y >>= 19;
3023  U >>= 19;
3024  V >>= 19;
3025 
3026  if (Y & 0x100)
3027  Y = av_clip_uint8(Y);
3028  if (U & 0x100)
3029  U = av_clip_uint8(U);
3030  if (V & 0x100)
3031  V = av_clip_uint8(V);
3032 
3033  if (alpSrc) {
3034  A = 1 << 18;
3035 
3036  for (j = 0; j < lumFilterSize; j++)
3037  A += (unsigned)(alpSrc[j][i] * lumFilter[j]);
3038 
3039  A >>= 19;
3040 
3041  if (A & 0x100)
3042  A = av_clip_uint8(A);
3043  }
3044 
3045  output_pixels(i * 4, A, Y, U, V)
3046  }
3047 }
3048 
3049 #undef output_pixels
3050 
3051 #define AYUVPACKEDWRAPPER(name, fmt) \
3052 static void yuv2 ## name ## _X_c(SwsInternal *c, const int16_t *lumFilter, \
3053  const int16_t **lumSrc, int lumFilterSize, \
3054  const int16_t *chrFilter, const int16_t **chrUSrc, \
3055  const int16_t **chrVSrc, int chrFilterSize, \
3056  const int16_t **alpSrc, uint8_t *dest, int dstW, \
3057  int y) \
3058 { \
3059  yuv2ayuv_X_c_template(c, lumFilter, lumSrc, lumFilterSize, \
3060  chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
3061  alpSrc, dest, dstW, y, fmt); \
3062 } \
3063  \
3064 static void yuv2 ## name ## _2_c(SwsInternal *c, const int16_t *buf[2], \
3065  const int16_t *ubuf[2], const int16_t *vbuf[2], \
3066  const int16_t *abuf[2], uint8_t *dest, int dstW, \
3067  int yalpha, int uvalpha, int y) \
3068 { \
3069  yuv2ayuv_2_c_template(c, buf, ubuf, vbuf, abuf, \
3070  dest, dstW, yalpha, uvalpha, y, fmt); \
3071 } \
3072  \
3073 static void yuv2 ## name ## _1_c(SwsInternal *c, const int16_t *buf0, \
3074  const int16_t *ubuf[2], const int16_t *vbuf[2], \
3075  const int16_t *abuf0, uint8_t *dest, int dstW, \
3076  int uvalpha, int y) \
3077 { \
3078  yuv2ayuv_1_c_template(c, buf0, ubuf, vbuf, \
3079  abuf0, dest, dstW, uvalpha, \
3080  y, fmt); \
3081 }
3082 
3083 AYUVPACKEDWRAPPER(vuyX, AV_PIX_FMT_VUYX)
3084 AYUVPACKEDWRAPPER(ayuv, AV_PIX_FMT_AYUV)
3085 AYUVPACKEDWRAPPER(uyva, AV_PIX_FMT_UYVA)
3086 
3087 #define output_pixel(pos, val, bits) \
3088  AV_WL16(pos, av_clip_uintp2(val >> shift, bits) << output_shift);
3089 
3090 #define yuv2y2xx_wrapper(bits) \
3091  static void \
3092  yuv2y2 ## bits ## le_X_c(SwsInternal *c, const int16_t *lumFilter, \
3093  const int16_t **lumSrc, int lumFilterSize, \
3094  const int16_t *chrFilter, \
3095  const int16_t **chrUSrc, \
3096  const int16_t **chrVSrc, int chrFilterSize, \
3097  const int16_t **alpSrc, \
3098  uint8_t *dest, int dstW, int y) \
3099  { \
3100  int i, j; \
3101  int shift = 11 + 16 - bits; \
3102  int output_shift = 16 - bits; \
3103  for (i = 0; i < ((dstW + 1) >> 1); i++) { \
3104  int Y1 = 1 << (shift - 1), Y2 = 1 << (shift - 1); \
3105  int U = 1 << (shift - 1), V = 1 << (shift - 1); \
3106  \
3107  for (j = 0; j < lumFilterSize; j++) { \
3108  Y1 += (unsigned)(lumSrc[j][i * 2] * lumFilter[j]); \
3109  Y2 += (unsigned)(lumSrc[j][i * 2 + 1] * lumFilter[j]); \
3110  } \
3111  \
3112  for (j = 0; j < chrFilterSize; j++) { \
3113  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]); \
3114  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]); \
3115  } \
3116  \
3117  output_pixel(dest + 8 * i + 0, Y1, bits); \
3118  output_pixel(dest + 8 * i + 2, U, bits); \
3119  output_pixel(dest + 8 * i + 4, Y2, bits); \
3120  output_pixel(dest + 8 * i + 6, V, bits); \
3121  } \
3122  }
3123 
3124 yuv2y2xx_wrapper(10)
3125 yuv2y2xx_wrapper(12)
3126 
3127 static void
3128 yuv2y216le_X_c(SwsInternal *c, const int16_t *lumFilter,
3129  const int16_t **_lumSrc, int lumFilterSize,
3130  const int16_t *chrFilter,
3131  const int16_t **_chrUSrc,
3132  const int16_t **_chrVSrc, int chrFilterSize,
3133  const int16_t **_alpSrc,
3134  uint8_t *dest, int dstW, int y)
3135 {
3136  const int32_t **lumSrc = (const int32_t **)_lumSrc;
3137  const int32_t **chrUSrc = (const int32_t **)_chrUSrc;
3138  const int32_t **chrVSrc = (const int32_t **)_chrVSrc;
3139  int shift = 15;
3140 
3141  for (int i = 0; i < ((dstW + 1) >> 1); i++) {
3142  int Y1 = 1 << (shift - 1), Y2 = 1 << (shift - 1);
3143  int U = 1 << (shift - 1), V = 1 << (shift - 1);
3144 
3145  /* See yuv2planeX_16_c_template for details. */
3146  Y1 -= 0x40000000;
3147  U -= 0x40000000;
3148  Y2 -= 0x40000000;
3149  V -= 0x40000000;
3150 
3151  for (int j = 0; j < lumFilterSize; j++) {
3152  Y1 += lumSrc[j][i * 2] * (unsigned)lumFilter[j];
3153  Y2 += lumSrc[j][i * 2 + 1] * (unsigned)lumFilter[j];
3154  }
3155 
3156  for (int j = 0; j < chrFilterSize; j++) {
3157  U += chrUSrc[j][i] * (unsigned)chrFilter[j];
3158  V += chrVSrc[j][i] * (unsigned)chrFilter[j];
3159  }
3160 
3161  AV_WL16(dest + 8 * i + 0, 0x8000 + av_clip_int16(Y1 >> shift));
3162  AV_WL16(dest + 8 * i + 2, 0x8000 + av_clip_int16(U >> shift));
3163  AV_WL16(dest + 8 * i + 4, 0x8000 + av_clip_int16(Y2 >> shift));
3164  AV_WL16(dest + 8 * i + 6, 0x8000 + av_clip_int16(V >> shift));
3165  }
3166 }
3167 
3168 static void
3169 yuv2vyu444_1_c(SwsInternal *c, const int16_t *buf0,
3170  const int16_t *ubuf[2], const int16_t *vbuf[2],
3171  const int16_t *abuf0, uint8_t *dest, int dstW,
3172  int uvalpha, int y)
3173 {
3174  int i;
3175 
3176  if (uvalpha < 2048) {
3177  for (i = 0; i < dstW; i++) {
3178  int Y = (buf0[i] + 64) >> 7;
3179  int U = (ubuf[0][i] + 64) >> 7;
3180  int V = (vbuf[0][i] + 64) >> 7;
3181 
3182  if (Y & 0x100)
3183  Y = av_clip_uint8(Y);
3184  if (U & 0x100)
3185  U = av_clip_uint8(U);
3186  if (V & 0x100)
3187  V = av_clip_uint8(V);
3188 
3189  dest[3 * i ] = V;
3190  dest[3 * i + 1] = Y;
3191  dest[3 * i + 2] = U;
3192  }
3193  } else {
3194  for (i = 0; i < dstW; i++) {
3195  int Y = (buf0[i] + 64) >> 7;
3196  int U = (ubuf[0][i] + ubuf[1][i] + 128) >> 8;
3197  int V = (vbuf[0][i] + vbuf[1][i] + 128) >> 8;
3198 
3199  if (Y & 0x100)
3200  Y = av_clip_uint8(Y);
3201  if (U & 0x100)
3202  U = av_clip_uint8(U);
3203  if (V & 0x100)
3204  V = av_clip_uint8(V);
3205 
3206  dest[3 * i ] = V;
3207  dest[3 * i + 1] = Y;
3208  dest[3 * i + 2] = U;
3209  }
3210  }
3211 }
3212 
3213 static void
3214 yuv2vyu444_2_c(SwsInternal *c, const int16_t *buf[2],
3215  const int16_t *ubuf[2], const int16_t *vbuf[2],
3216  const int16_t *abuf[2], uint8_t *dest, int dstW,
3217  int yalpha, int uvalpha, int y)
3218 {
3219  const int16_t *buf0 = buf[0], *buf1 = buf[1],
3220  *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
3221  *vbuf0 = vbuf[0], *vbuf1 = vbuf[1];
3222  int yalpha1 = 4096 - yalpha;
3223  int uvalpha1 = 4096 - uvalpha;
3224  int i;
3225 
3226  av_assert2(yalpha <= 4096U);
3227  av_assert2(uvalpha <= 4096U);
3228 
3229  for (i = 0; i < dstW; i++) {
3230  int Y = (buf0[i] * yalpha1 + buf1[i] * yalpha) >> 19;
3231  int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha) >> 19;
3232  int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha) >> 19;
3233 
3234  if (Y & 0x100)
3235  Y = av_clip_uint8(Y);
3236  if (U & 0x100)
3237  U = av_clip_uint8(U);
3238  if (V & 0x100)
3239  V = av_clip_uint8(V);
3240 
3241  dest[3 * i ] = V;
3242  dest[3 * i + 1] = Y;
3243  dest[3 * i + 2] = U;
3244  }
3245 }
3246 
3247 static void
3248 yuv2vyu444_X_c(SwsInternal *c, const int16_t *lumFilter,
3249  const int16_t **lumSrc, int lumFilterSize,
3250  const int16_t *chrFilter, const int16_t **chrUSrc,
3251  const int16_t **chrVSrc, int chrFilterSize,
3252  const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
3253 {
3254  int i;
3255 
3256  for (i = 0; i < dstW; i++) {
3257  int j;
3258  int Y = 1 << 18, U = 1 << 18;
3259  int V = 1 << 18;
3260 
3261  for (j = 0; j < lumFilterSize; j++)
3262  Y += (unsigned)(lumSrc[j][i] * lumFilter[j]);
3263 
3264  for (j = 0; j < chrFilterSize; j++)
3265  U += (unsigned)(chrUSrc[j][i] * chrFilter[j]);
3266 
3267  for (j = 0; j < chrFilterSize; j++)
3268  V += (unsigned)(chrVSrc[j][i] * chrFilter[j]);
3269 
3270  Y >>= 19;
3271  U >>= 19;
3272  V >>= 19;
3273 
3274  if (Y & 0x100)
3275  Y = av_clip_uint8(Y);
3276  if (U & 0x100)
3277  U = av_clip_uint8(U);
3278  if (V & 0x100)
3279  V = av_clip_uint8(V);
3280 
3281  dest[3 * i ] = V;
3282  dest[3 * i + 1] = Y;
3283  dest[3 * i + 2] = U;
3284  }
3285 }
3286 
3287 #undef output_pixel
3288 
3289 av_cold void ff_sws_init_output_funcs(SwsInternal *c,
3290  yuv2planar1_fn *yuv2plane1,
3291  yuv2planarX_fn *yuv2planeX,
3292  yuv2interleavedX_fn *yuv2nv12cX,
3293  yuv2packed1_fn *yuv2packed1,
3294  yuv2packed2_fn *yuv2packed2,
3295  yuv2packedX_fn *yuv2packedX,
3296  yuv2anyX_fn *yuv2anyX)
3297 {
3298  enum AVPixelFormat dstFormat = c->opts.dst_format;
3299  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
3300 
3301  if (isSemiPlanarYUV(dstFormat) && isDataInHighBits(dstFormat)) {
3302  if (desc->comp[0].depth == 10) {
3303  *yuv2plane1 = isBE(dstFormat) ? yuv2p010l1_BE_c : yuv2p010l1_LE_c;
3304  *yuv2planeX = isBE(dstFormat) ? yuv2p010lX_BE_c : yuv2p010lX_LE_c;
3305  *yuv2nv12cX = isBE(dstFormat) ? yuv2p010cX_BE_c : yuv2p010cX_LE_c;
3306  } else if (desc->comp[0].depth == 12) {
3307  *yuv2plane1 = isBE(dstFormat) ? yuv2p012l1_BE_c : yuv2p012l1_LE_c;
3308  *yuv2planeX = isBE(dstFormat) ? yuv2p012lX_BE_c : yuv2p012lX_LE_c;
3309  *yuv2nv12cX = isBE(dstFormat) ? yuv2p012cX_BE_c : yuv2p012cX_LE_c;
3310  } else
3311  av_assert0(0);
3312  } else if (isSemiPlanarYUV(dstFormat) && isNBPS(dstFormat)) {
3313  if (desc->comp[0].depth == 10) {
3314  *yuv2plane1 = isBE(dstFormat) ? yuv2nv20l1_BE_c : yuv2nv20l1_LE_c;
3315  *yuv2planeX = isBE(dstFormat) ? yuv2nv20lX_BE_c : yuv2nv20lX_LE_c;
3316  *yuv2nv12cX = isBE(dstFormat) ? yuv2nv20cX_BE_c : yuv2nv20cX_LE_c;
3317  } else
3318  av_assert0(0);
3319  } else if (is16BPS(dstFormat)) {
3320  *yuv2planeX = isBE(dstFormat) ? yuv2planeX_16BE_c : yuv2planeX_16LE_c;
3321  *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_16BE_c : yuv2plane1_16LE_c;
3322  if (isSemiPlanarYUV(dstFormat)) {
3323  *yuv2nv12cX = isBE(dstFormat) ? yuv2nv12cX_16BE_c : yuv2nv12cX_16LE_c;
3324  }
3325  } else if (isDataInHighBits(dstFormat) && isNBPS(dstFormat)) {
3326  if (desc->comp[0].depth == 10) {
3327  *yuv2planeX = isBE(dstFormat) ? yuv2msbplaneX_10BE_c : yuv2msbplaneX_10LE_c;
3328  *yuv2plane1 = isBE(dstFormat) ? yuv2msbplane1_10BE_c : yuv2msbplane1_10LE_c;
3329  } else if (desc->comp[0].depth == 12) {
3330  *yuv2planeX = isBE(dstFormat) ? yuv2msbplaneX_12BE_c : yuv2msbplaneX_12LE_c;
3331  *yuv2plane1 = isBE(dstFormat) ? yuv2msbplane1_12BE_c : yuv2msbplane1_12LE_c;
3332  } else
3333  av_assert0(0);
3334  } else if (isNBPS(dstFormat)) {
3335  if (desc->comp[0].depth == 9) {
3336  *yuv2planeX = isBE(dstFormat) ? yuv2planeX_9BE_c : yuv2planeX_9LE_c;
3337  *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_9BE_c : yuv2plane1_9LE_c;
3338  } else if (desc->comp[0].depth == 10) {
3339  *yuv2planeX = isBE(dstFormat) ? yuv2planeX_10BE_c : yuv2planeX_10LE_c;
3340  *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_10BE_c : yuv2plane1_10LE_c;
3341  } else if (desc->comp[0].depth == 12) {
3342  *yuv2planeX = isBE(dstFormat) ? yuv2planeX_12BE_c : yuv2planeX_12LE_c;
3343  *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_12BE_c : yuv2plane1_12LE_c;
3344  } else if (desc->comp[0].depth == 14) {
3345  *yuv2planeX = isBE(dstFormat) ? yuv2planeX_14BE_c : yuv2planeX_14LE_c;
3346  *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_14BE_c : yuv2plane1_14LE_c;
3347  } else
3348  av_assert0(0);
3349  } else if (dstFormat == AV_PIX_FMT_GRAYF32BE) {
3350  *yuv2planeX = yuv2planeX_floatBE_c;
3351  *yuv2plane1 = yuv2plane1_floatBE_c;
3352  } else if (dstFormat == AV_PIX_FMT_GRAYF32LE) {
3353  *yuv2planeX = yuv2planeX_floatLE_c;
3354  *yuv2plane1 = yuv2plane1_floatLE_c;
3355  } else {
3356  *yuv2plane1 = yuv2plane1_8_c;
3357  *yuv2planeX = yuv2planeX_8_c;
3358  if (isSemiPlanarYUV(dstFormat))
3359  *yuv2nv12cX = yuv2nv12cX_c;
3360  }
3361 
3362  if(c->opts.flags & SWS_FULL_CHR_H_INT) {
3363  switch (dstFormat) {
3364  case AV_PIX_FMT_RGBA:
3365 #if CONFIG_SMALL
3366  *yuv2packedX = yuv2rgba32_full_X_c;
3367  *yuv2packed2 = yuv2rgba32_full_2_c;
3368  *yuv2packed1 = yuv2rgba32_full_1_c;
3369 #else
3370 #if CONFIG_SWSCALE_ALPHA
3371  if (c->needAlpha) {
3372  *yuv2packedX = yuv2rgba32_full_X_c;
3373  *yuv2packed2 = yuv2rgba32_full_2_c;
3374  *yuv2packed1 = yuv2rgba32_full_1_c;
3375  } else
3376 #endif /* CONFIG_SWSCALE_ALPHA */
3377  {
3378  *yuv2packedX = yuv2rgbx32_full_X_c;
3379  *yuv2packed2 = yuv2rgbx32_full_2_c;
3380  *yuv2packed1 = yuv2rgbx32_full_1_c;
3381  }
3382 #endif /* !CONFIG_SMALL */
3383  break;
3384  case AV_PIX_FMT_ARGB:
3385 #if CONFIG_SMALL
3386  *yuv2packedX = yuv2argb32_full_X_c;
3387  *yuv2packed2 = yuv2argb32_full_2_c;
3388  *yuv2packed1 = yuv2argb32_full_1_c;
3389 #else
3390 #if CONFIG_SWSCALE_ALPHA
3391  if (c->needAlpha) {
3392  *yuv2packedX = yuv2argb32_full_X_c;
3393  *yuv2packed2 = yuv2argb32_full_2_c;
3394  *yuv2packed1 = yuv2argb32_full_1_c;
3395  } else
3396 #endif /* CONFIG_SWSCALE_ALPHA */
3397  {
3398  *yuv2packedX = yuv2xrgb32_full_X_c;
3399  *yuv2packed2 = yuv2xrgb32_full_2_c;
3400  *yuv2packed1 = yuv2xrgb32_full_1_c;
3401  }
3402 #endif /* !CONFIG_SMALL */
3403  break;
3404  case AV_PIX_FMT_BGRA:
3405 #if CONFIG_SMALL
3406  *yuv2packedX = yuv2bgra32_full_X_c;
3407  *yuv2packed2 = yuv2bgra32_full_2_c;
3408  *yuv2packed1 = yuv2bgra32_full_1_c;
3409 #else
3410 #if CONFIG_SWSCALE_ALPHA
3411  if (c->needAlpha) {
3412  *yuv2packedX = yuv2bgra32_full_X_c;
3413  *yuv2packed2 = yuv2bgra32_full_2_c;
3414  *yuv2packed1 = yuv2bgra32_full_1_c;
3415  } else
3416 #endif /* CONFIG_SWSCALE_ALPHA */
3417  {
3418  *yuv2packedX = yuv2bgrx32_full_X_c;
3419  *yuv2packed2 = yuv2bgrx32_full_2_c;
3420  *yuv2packed1 = yuv2bgrx32_full_1_c;
3421  }
3422 #endif /* !CONFIG_SMALL */
3423  break;
3424  case AV_PIX_FMT_ABGR:
3425 #if CONFIG_SMALL
3426  *yuv2packedX = yuv2abgr32_full_X_c;
3427  *yuv2packed2 = yuv2abgr32_full_2_c;
3428  *yuv2packed1 = yuv2abgr32_full_1_c;
3429 #else
3430 #if CONFIG_SWSCALE_ALPHA
3431  if (c->needAlpha) {
3432  *yuv2packedX = yuv2abgr32_full_X_c;
3433  *yuv2packed2 = yuv2abgr32_full_2_c;
3434  *yuv2packed1 = yuv2abgr32_full_1_c;
3435  } else
3436 #endif /* CONFIG_SWSCALE_ALPHA */
3437  {
3438  *yuv2packedX = yuv2xbgr32_full_X_c;
3439  *yuv2packed2 = yuv2xbgr32_full_2_c;
3440  *yuv2packed1 = yuv2xbgr32_full_1_c;
3441  }
3442 #endif /* !CONFIG_SMALL */
3443  break;
3444  case AV_PIX_FMT_RGBA64LE:
3445 #if CONFIG_SWSCALE_ALPHA
3446  if (c->needAlpha) {
3447  *yuv2packedX = yuv2rgba64le_full_X_c;
3448  *yuv2packed2 = yuv2rgba64le_full_2_c;
3449  *yuv2packed1 = yuv2rgba64le_full_1_c;
3450  } else
3451 #endif /* CONFIG_SWSCALE_ALPHA */
3452  {
3453  *yuv2packedX = yuv2rgbx64le_full_X_c;
3454  *yuv2packed2 = yuv2rgbx64le_full_2_c;
3455  *yuv2packed1 = yuv2rgbx64le_full_1_c;
3456  }
3457  break;
3458  case AV_PIX_FMT_RGBA64BE:
3459 #if CONFIG_SWSCALE_ALPHA
3460  if (c->needAlpha) {
3461  *yuv2packedX = yuv2rgba64be_full_X_c;
3462  *yuv2packed2 = yuv2rgba64be_full_2_c;
3463  *yuv2packed1 = yuv2rgba64be_full_1_c;
3464  } else
3465 #endif /* CONFIG_SWSCALE_ALPHA */
3466  {
3467  *yuv2packedX = yuv2rgbx64be_full_X_c;
3468  *yuv2packed2 = yuv2rgbx64be_full_2_c;
3469  *yuv2packed1 = yuv2rgbx64be_full_1_c;
3470  }
3471  break;
3472  case AV_PIX_FMT_BGRA64LE:
3473 #if CONFIG_SWSCALE_ALPHA
3474  if (c->needAlpha) {
3475  *yuv2packedX = yuv2bgra64le_full_X_c;
3476  *yuv2packed2 = yuv2bgra64le_full_2_c;
3477  *yuv2packed1 = yuv2bgra64le_full_1_c;
3478  } else
3479 #endif /* CONFIG_SWSCALE_ALPHA */
3480  {
3481  *yuv2packedX = yuv2bgrx64le_full_X_c;
3482  *yuv2packed2 = yuv2bgrx64le_full_2_c;
3483  *yuv2packed1 = yuv2bgrx64le_full_1_c;
3484  }
3485  break;
3486  case AV_PIX_FMT_BGRA64BE:
3487 #if CONFIG_SWSCALE_ALPHA
3488  if (c->needAlpha) {
3489  *yuv2packedX = yuv2bgra64be_full_X_c;
3490  *yuv2packed2 = yuv2bgra64be_full_2_c;
3491  *yuv2packed1 = yuv2bgra64be_full_1_c;
3492  } else
3493 #endif /* CONFIG_SWSCALE_ALPHA */
3494  {
3495  *yuv2packedX = yuv2bgrx64be_full_X_c;
3496  *yuv2packed2 = yuv2bgrx64be_full_2_c;
3497  *yuv2packed1 = yuv2bgrx64be_full_1_c;
3498  }
3499  break;
3500 
3501  case AV_PIX_FMT_RGB24:
3502  *yuv2packedX = yuv2rgb24_full_X_c;
3503  *yuv2packed2 = yuv2rgb24_full_2_c;
3504  *yuv2packed1 = yuv2rgb24_full_1_c;
3505  break;
3506  case AV_PIX_FMT_BGR24:
3507  *yuv2packedX = yuv2bgr24_full_X_c;
3508  *yuv2packed2 = yuv2bgr24_full_2_c;
3509  *yuv2packed1 = yuv2bgr24_full_1_c;
3510  break;
3511  case AV_PIX_FMT_RGB48LE:
3512  *yuv2packedX = yuv2rgb48le_full_X_c;
3513  *yuv2packed2 = yuv2rgb48le_full_2_c;
3514  *yuv2packed1 = yuv2rgb48le_full_1_c;
3515  break;
3516  case AV_PIX_FMT_BGR48LE:
3517  *yuv2packedX = yuv2bgr48le_full_X_c;
3518  *yuv2packed2 = yuv2bgr48le_full_2_c;
3519  *yuv2packed1 = yuv2bgr48le_full_1_c;
3520  break;
3521  case AV_PIX_FMT_RGB48BE:
3522  *yuv2packedX = yuv2rgb48be_full_X_c;
3523  *yuv2packed2 = yuv2rgb48be_full_2_c;
3524  *yuv2packed1 = yuv2rgb48be_full_1_c;
3525  break;
3526  case AV_PIX_FMT_BGR48BE:
3527  *yuv2packedX = yuv2bgr48be_full_X_c;
3528  *yuv2packed2 = yuv2bgr48be_full_2_c;
3529  *yuv2packed1 = yuv2bgr48be_full_1_c;
3530  break;
3531  case AV_PIX_FMT_BGR4_BYTE:
3532  *yuv2packedX = yuv2bgr4_byte_full_X_c;
3533  *yuv2packed2 = yuv2bgr4_byte_full_2_c;
3534  *yuv2packed1 = yuv2bgr4_byte_full_1_c;
3535  break;
3536  case AV_PIX_FMT_RGB4_BYTE:
3537  *yuv2packedX = yuv2rgb4_byte_full_X_c;
3538  *yuv2packed2 = yuv2rgb4_byte_full_2_c;
3539  *yuv2packed1 = yuv2rgb4_byte_full_1_c;
3540  break;
3541  case AV_PIX_FMT_BGR8:
3542  *yuv2packedX = yuv2bgr8_full_X_c;
3543  *yuv2packed2 = yuv2bgr8_full_2_c;
3544  *yuv2packed1 = yuv2bgr8_full_1_c;
3545  break;
3546  case AV_PIX_FMT_RGB8:
3547  *yuv2packedX = yuv2rgb8_full_X_c;
3548  *yuv2packed2 = yuv2rgb8_full_2_c;
3549  *yuv2packed1 = yuv2rgb8_full_1_c;
3550  break;
3551  case AV_PIX_FMT_X2RGB10LE:
3552  *yuv2packedX = yuv2x2rgb10_full_X_c;
3553  *yuv2packed2 = yuv2x2rgb10_full_2_c;
3554  *yuv2packed1 = yuv2x2rgb10_full_1_c;
3555  break;
3556  case AV_PIX_FMT_X2BGR10LE:
3557  *yuv2packedX = yuv2x2bgr10_full_X_c;
3558  *yuv2packed2 = yuv2x2bgr10_full_2_c;
3559  *yuv2packed1 = yuv2x2bgr10_full_1_c;
3560  break;
3561  case AV_PIX_FMT_GBRP:
3562  case AV_PIX_FMT_GBRP9BE:
3563  case AV_PIX_FMT_GBRP9LE:
3564  case AV_PIX_FMT_GBRP10BE:
3565  case AV_PIX_FMT_GBRP10LE:
3566  case AV_PIX_FMT_GBRP12BE:
3567  case AV_PIX_FMT_GBRP12LE:
3568  case AV_PIX_FMT_GBRP14BE:
3569  case AV_PIX_FMT_GBRP14LE:
3570  case AV_PIX_FMT_GBRAP:
3571  case AV_PIX_FMT_GBRAP10BE:
3572  case AV_PIX_FMT_GBRAP10LE:
3573  case AV_PIX_FMT_GBRAP12BE:
3574  case AV_PIX_FMT_GBRAP12LE:
3575  case AV_PIX_FMT_GBRAP14BE:
3576  case AV_PIX_FMT_GBRAP14LE:
3577  *yuv2anyX = yuv2gbrp_full_X_c;
3578  break;
3579  case AV_PIX_FMT_GBRP10MSBBE:
3580  case AV_PIX_FMT_GBRP10MSBLE:
3581  case AV_PIX_FMT_GBRP12MSBBE:
3582  case AV_PIX_FMT_GBRP12MSBLE:
3583  *yuv2anyX = yuv2gbrpmsb_full_X_c;
3584  break;
3585  case AV_PIX_FMT_GBRP16BE:
3586  case AV_PIX_FMT_GBRP16LE:
3587  case AV_PIX_FMT_GBRAP16BE:
3588  case AV_PIX_FMT_GBRAP16LE:
3589  *yuv2anyX = yuv2gbrp16_full_X_c;
3590  break;
3591  case AV_PIX_FMT_GBRPF32BE:
3592  case AV_PIX_FMT_GBRPF32LE:
3593  case AV_PIX_FMT_GBRAPF32BE:
3594  case AV_PIX_FMT_GBRAPF32LE:
3595  *yuv2anyX = yuv2gbrpf32_full_X_c;
3596  break;
3597  }
3598  if (!*yuv2packedX && !*yuv2anyX)
3599  goto YUV_PACKED;
3600  } else {
3601  YUV_PACKED:
3602  switch (dstFormat) {
3603  case AV_PIX_FMT_RGBA64LE:
3604 #if CONFIG_SWSCALE_ALPHA
3605  if (c->needAlpha) {
3606  *yuv2packed1 = yuv2rgba64le_1_c;
3607  *yuv2packed2 = yuv2rgba64le_2_c;
3608  *yuv2packedX = yuv2rgba64le_X_c;
3609  } else
3610 #endif /* CONFIG_SWSCALE_ALPHA */
3611  {
3612  *yuv2packed1 = yuv2rgbx64le_1_c;
3613  *yuv2packed2 = yuv2rgbx64le_2_c;
3614  *yuv2packedX = yuv2rgbx64le_X_c;
3615  }
3616  break;
3617  case AV_PIX_FMT_RGBA64BE:
3618 #if CONFIG_SWSCALE_ALPHA
3619  if (c->needAlpha) {
3620  *yuv2packed1 = yuv2rgba64be_1_c;
3621  *yuv2packed2 = yuv2rgba64be_2_c;
3622  *yuv2packedX = yuv2rgba64be_X_c;
3623  } else
3624 #endif /* CONFIG_SWSCALE_ALPHA */
3625  {
3626  *yuv2packed1 = yuv2rgbx64be_1_c;
3627  *yuv2packed2 = yuv2rgbx64be_2_c;
3628  *yuv2packedX = yuv2rgbx64be_X_c;
3629  }
3630  break;
3631  case AV_PIX_FMT_BGRA64LE:
3632 #if CONFIG_SWSCALE_ALPHA
3633  if (c->needAlpha) {
3634  *yuv2packed1 = yuv2bgra64le_1_c;
3635  *yuv2packed2 = yuv2bgra64le_2_c;
3636  *yuv2packedX = yuv2bgra64le_X_c;
3637  } else
3638 #endif /* CONFIG_SWSCALE_ALPHA */
3639  {
3640  *yuv2packed1 = yuv2bgrx64le_1_c;
3641  *yuv2packed2 = yuv2bgrx64le_2_c;
3642  *yuv2packedX = yuv2bgrx64le_X_c;
3643  }
3644  break;
3645  case AV_PIX_FMT_BGRA64BE:
3646 #if CONFIG_SWSCALE_ALPHA
3647  if (c->needAlpha) {
3648  *yuv2packed1 = yuv2bgra64be_1_c;
3649  *yuv2packed2 = yuv2bgra64be_2_c;
3650  *yuv2packedX = yuv2bgra64be_X_c;
3651  } else
3652 #endif /* CONFIG_SWSCALE_ALPHA */
3653  {
3654  *yuv2packed1 = yuv2bgrx64be_1_c;
3655  *yuv2packed2 = yuv2bgrx64be_2_c;
3656  *yuv2packedX = yuv2bgrx64be_X_c;
3657  }
3658  break;
3659  case AV_PIX_FMT_RGB48LE:
3660  *yuv2packed1 = yuv2rgb48le_1_c;
3661  *yuv2packed2 = yuv2rgb48le_2_c;
3662  *yuv2packedX = yuv2rgb48le_X_c;
3663  break;
3664  case AV_PIX_FMT_RGB48BE:
3665  *yuv2packed1 = yuv2rgb48be_1_c;
3666  *yuv2packed2 = yuv2rgb48be_2_c;
3667  *yuv2packedX = yuv2rgb48be_X_c;
3668  break;
3669  case AV_PIX_FMT_BGR48LE:
3670  *yuv2packed1 = yuv2bgr48le_1_c;
3671  *yuv2packed2 = yuv2bgr48le_2_c;
3672  *yuv2packedX = yuv2bgr48le_X_c;
3673  break;
3674  case AV_PIX_FMT_BGR48BE:
3675  *yuv2packed1 = yuv2bgr48be_1_c;
3676  *yuv2packed2 = yuv2bgr48be_2_c;
3677  *yuv2packedX = yuv2bgr48be_X_c;
3678  break;
3679  case AV_PIX_FMT_RGB32:
3680  case AV_PIX_FMT_BGR32:
3681 #if CONFIG_SMALL
3682  *yuv2packed1 = yuv2rgb32_1_c;
3683  *yuv2packed2 = yuv2rgb32_2_c;
3684  *yuv2packedX = yuv2rgb32_X_c;
3685 #else
3686 #if CONFIG_SWSCALE_ALPHA
3687  if (c->needAlpha) {
3688  *yuv2packed1 = yuv2rgba32_1_c;
3689  *yuv2packed2 = yuv2rgba32_2_c;
3690  *yuv2packedX = yuv2rgba32_X_c;
3691  } else
3692 #endif /* CONFIG_SWSCALE_ALPHA */
3693  {
3694  *yuv2packed1 = yuv2rgbx32_1_c;
3695  *yuv2packed2 = yuv2rgbx32_2_c;
3696  *yuv2packedX = yuv2rgbx32_X_c;
3697  }
3698 #endif /* !CONFIG_SMALL */
3699  break;
3700  case AV_PIX_FMT_RGB32_1:
3701  case AV_PIX_FMT_BGR32_1:
3702 #if CONFIG_SMALL
3703  *yuv2packed1 = yuv2rgb32_1_1_c;
3704  *yuv2packed2 = yuv2rgb32_1_2_c;
3705  *yuv2packedX = yuv2rgb32_1_X_c;
3706 #else
3707 #if CONFIG_SWSCALE_ALPHA
3708  if (c->needAlpha) {
3709  *yuv2packed1 = yuv2rgba32_1_1_c;
3710  *yuv2packed2 = yuv2rgba32_1_2_c;
3711  *yuv2packedX = yuv2rgba32_1_X_c;
3712  } else
3713 #endif /* CONFIG_SWSCALE_ALPHA */
3714  {
3715  *yuv2packed1 = yuv2rgbx32_1_1_c;
3716  *yuv2packed2 = yuv2rgbx32_1_2_c;
3717  *yuv2packedX = yuv2rgbx32_1_X_c;
3718  }
3719 #endif /* !CONFIG_SMALL */
3720  break;
3721  case AV_PIX_FMT_RGB24:
3722  *yuv2packed1 = yuv2rgb24_1_c;
3723  *yuv2packed2 = yuv2rgb24_2_c;
3724  *yuv2packedX = yuv2rgb24_X_c;
3725  break;
3726  case AV_PIX_FMT_BGR24:
3727  *yuv2packed1 = yuv2bgr24_1_c;
3728  *yuv2packed2 = yuv2bgr24_2_c;
3729  *yuv2packedX = yuv2bgr24_X_c;
3730  break;
3731  case AV_PIX_FMT_RGB565LE:
3732  case AV_PIX_FMT_RGB565BE:
3733  case AV_PIX_FMT_BGR565LE:
3734  case AV_PIX_FMT_BGR565BE:
3735  *yuv2packed1 = yuv2rgb16_1_c;
3736  *yuv2packed2 = yuv2rgb16_2_c;
3737  *yuv2packedX = yuv2rgb16_X_c;
3738  break;
3739  case AV_PIX_FMT_RGB555LE:
3740  case AV_PIX_FMT_RGB555BE:
3741  case AV_PIX_FMT_BGR555LE:
3742  case AV_PIX_FMT_BGR555BE:
3743  *yuv2packed1 = yuv2rgb15_1_c;
3744  *yuv2packed2 = yuv2rgb15_2_c;
3745  *yuv2packedX = yuv2rgb15_X_c;
3746  break;
3747  case AV_PIX_FMT_RGB444LE:
3748  case AV_PIX_FMT_RGB444BE:
3749  case AV_PIX_FMT_BGR444LE:
3750  case AV_PIX_FMT_BGR444BE:
3751  *yuv2packed1 = yuv2rgb12_1_c;
3752  *yuv2packed2 = yuv2rgb12_2_c;
3753  *yuv2packedX = yuv2rgb12_X_c;
3754  break;
3755  case AV_PIX_FMT_RGB8:
3756  case AV_PIX_FMT_BGR8:
3757  *yuv2packed1 = yuv2rgb8_1_c;
3758  *yuv2packed2 = yuv2rgb8_2_c;
3759  *yuv2packedX = yuv2rgb8_X_c;
3760  break;
3761  case AV_PIX_FMT_RGB4:
3762  case AV_PIX_FMT_BGR4:
3763  *yuv2packed1 = yuv2rgb4_1_c;
3764  *yuv2packed2 = yuv2rgb4_2_c;
3765  *yuv2packedX = yuv2rgb4_X_c;
3766  break;
3767  case AV_PIX_FMT_RGB4_BYTE:
3768  case AV_PIX_FMT_BGR4_BYTE:
3769  *yuv2packed1 = yuv2rgb4b_1_c;
3770  *yuv2packed2 = yuv2rgb4b_2_c;
3771  *yuv2packedX = yuv2rgb4b_X_c;
3772  break;
3773  case AV_PIX_FMT_X2RGB10LE:
3774  case AV_PIX_FMT_X2RGB10BE:
3775  *yuv2packed1 = yuv2x2rgb10_1_c;
3776  *yuv2packed2 = yuv2x2rgb10_2_c;
3777  *yuv2packedX = yuv2x2rgb10_X_c;
3778  break;
3779  case AV_PIX_FMT_X2BGR10LE:
3780  case AV_PIX_FMT_X2BGR10BE:
3781  *yuv2packed1 = yuv2x2bgr10_1_c;
3782  *yuv2packed2 = yuv2x2bgr10_2_c;
3783  *yuv2packedX = yuv2x2bgr10_X_c;
3784  break;
3785  }
3786  }
3787  switch (dstFormat) {
3788  case AV_PIX_FMT_MONOWHITE:
3789  *yuv2packed1 = yuv2monowhite_1_c;
3790  *yuv2packed2 = yuv2monowhite_2_c;
3791  *yuv2packedX = yuv2monowhite_X_c;
3792  break;
3793  case AV_PIX_FMT_MONOBLACK:
3794  *yuv2packed1 = yuv2monoblack_1_c;
3795  *yuv2packed2 = yuv2monoblack_2_c;
3796  *yuv2packedX = yuv2monoblack_X_c;
3797  break;
3798  case AV_PIX_FMT_YUYV422:
3799  *yuv2packed1 = yuv2yuyv422_1_c;
3800  *yuv2packed2 = yuv2yuyv422_2_c;
3801  *yuv2packedX = yuv2yuyv422_X_c;
3802  break;
3803  case AV_PIX_FMT_YVYU422:
3804  *yuv2packed1 = yuv2yvyu422_1_c;
3805  *yuv2packed2 = yuv2yvyu422_2_c;
3806  *yuv2packedX = yuv2yvyu422_X_c;
3807  break;
3808  case AV_PIX_FMT_UYVY422:
3809  *yuv2packed1 = yuv2uyvy422_1_c;
3810  *yuv2packed2 = yuv2uyvy422_2_c;
3811  *yuv2packedX = yuv2uyvy422_X_c;
3812  break;
3813  case AV_PIX_FMT_VYU444:
3814  *yuv2packed1 = yuv2vyu444_1_c;
3815  *yuv2packed2 = yuv2vyu444_2_c;
3816  *yuv2packedX = yuv2vyu444_X_c;
3817  break;
3818  case AV_PIX_FMT_YA8:
3819  *yuv2packed1 = yuv2ya8_1_c;
3820  *yuv2packed2 = yuv2ya8_2_c;
3821  *yuv2packedX = yuv2ya8_X_c;
3822  break;
3823  case AV_PIX_FMT_YA16LE:
3824  *yuv2packed1 = yuv2ya16le_1_c;
3825  *yuv2packed2 = yuv2ya16le_2_c;
3826  *yuv2packedX = yuv2ya16le_X_c;
3827  break;
3828  case AV_PIX_FMT_YA16BE:
3829  *yuv2packed1 = yuv2ya16be_1_c;
3830  *yuv2packed2 = yuv2ya16be_2_c;
3831  *yuv2packedX = yuv2ya16be_X_c;
3832  break;
3833  case AV_PIX_FMT_V30XLE:
3834  *yuv2packedX = yuv2v30xle_X_c;
3835  break;
3836  case AV_PIX_FMT_AYUV64LE:
3837  *yuv2packedX = yuv2ayuv64le_X_c;
3838  break;
3839  case AV_PIX_FMT_AYUV64BE:
3840  *yuv2packedX = yuv2ayuv64be_X_c;
3841  break;
3842  case AV_PIX_FMT_AYUV:
3843  *yuv2packed1 = yuv2ayuv_1_c;
3844  *yuv2packed2 = yuv2ayuv_2_c;
3845  *yuv2packedX = yuv2ayuv_X_c;
3846  break;
3847  case AV_PIX_FMT_VUYA:
3848  case AV_PIX_FMT_VUYX:
3849  *yuv2packed1 = yuv2vuyX_1_c;
3850  *yuv2packed2 = yuv2vuyX_2_c;
3851  *yuv2packedX = yuv2vuyX_X_c;
3852  break;
3853  case AV_PIX_FMT_UYVA:
3854  *yuv2packed1 = yuv2uyva_1_c;
3855  *yuv2packed2 = yuv2uyva_2_c;
3856  *yuv2packedX = yuv2uyva_X_c;
3857  break;
3858  case AV_PIX_FMT_XV30LE:
3859  *yuv2packedX = yuv2xv30le_X_c;
3860  break;
3861  case AV_PIX_FMT_XV36LE:
3862  *yuv2packedX = yuv2xv36le_X_c;
3863  break;
3864  case AV_PIX_FMT_XV36BE:
3865  *yuv2packedX = yuv2xv36be_X_c;
3866  break;
3867  case AV_PIX_FMT_XV48LE:
3868  *yuv2packedX = yuv2xv48le_X_c;
3869  break;
3870  case AV_PIX_FMT_XV48BE:
3871  *yuv2packedX = yuv2xv48be_X_c;
3872  break;
3873  case AV_PIX_FMT_Y210LE:
3874  *yuv2packedX = yuv2y210le_X_c;
3875  break;
3876  case AV_PIX_FMT_Y212LE:
3877  *yuv2packedX = yuv2y212le_X_c;
3878  break;
3879  case AV_PIX_FMT_Y216LE:
3880  *yuv2packedX = yuv2y216le_X_c;
3881  break;
3882  }
3883 }
yuv2rgb_full_1_c_template
static av_always_inline void yuv2rgb_full_1_c_template(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:2254
yuv2p01xcX_c
static void yuv2p01xcX_c(int big_endian, const uint8_t *chrDither, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest8, int chrDstW, int output_bits, int output_shift)
Definition: output.c:566
A
#define A(x)
Definition: vpx_arith.h:28
be
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it be(in the first position) for now. Options ------- Then comes the options array. This is what will define the user accessible options. For example
AV_PIX_FMT_XV30LE
@ AV_PIX_FMT_XV30LE
packed XVYU 4:4:4, 32bpp, (msb)2X 10V 10Y 10U(lsb), little-endian, variant of Y410 where alpha channe...
Definition: pixfmt.h:415
yuv2planar1_fn
void(* yuv2planar1_fn)(const int16_t *src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Write one line of horizontally scaled data to planar output without any additional vertical scaling (...
Definition: swscale_internal.h:108
YUV2PACKEDWRAPPER
#define YUV2PACKEDWRAPPER(name, base, ext, fmt)
Definition: output.c:828
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
SWS_DITHER_AUTO
@ SWS_DITHER_AUTO
Definition: swscale.h:81
av_clip
#define av_clip
Definition: common.h:100
ff_dither_4x4_16
const uint8_t ff_dither_4x4_16[][8]
Definition: output.c:52
X_DITHER
#define X_DITHER(u, v)
r
const char * r
Definition: vf_curves.c:127
yuv2rgba64_full_X_c_template
static av_always_inline void yuv2rgba64_full_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int32_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int32_t **chrUSrc, const int32_t **chrVSrc, int chrFilterSize, const int32_t **alpSrc, uint16_t *dest, int dstW, int y, enum AVPixelFormat target, int hasAlpha, int eightbytes, int is_be)
Definition: output.c:1372
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
AV_PIX_FMT_BGRA64BE
@ AV_PIX_FMT_BGRA64BE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:204
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
mem_internal.h
yuv2p01x_wrapper
#define yuv2p01x_wrapper(fmt, bits, shift)
Definition: output.c:591
AV_PIX_FMT_BGR32
#define AV_PIX_FMT_BGR32
Definition: pixfmt.h:513
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_GBRP16BE
@ AV_PIX_FMT_GBRP16BE
planar GBR 4:4:4 48bpp, big-endian
Definition: pixfmt.h:171
AV_PIX_FMT_GBRP10BE
@ AV_PIX_FMT_GBRP10BE
planar GBR 4:4:4 30bpp, big-endian
Definition: pixfmt.h:169
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3441
ff_dither_8x8_32
const uint8_t ff_dither_8x8_32[][8]
Definition: output.c:60
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
accumulate_bit
#define accumulate_bit(acc, val)
pixdesc.h
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:202
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
yuv2ya8_1_c
static void yuv2ya8_1_c(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y)
Definition: output.c:2611
AV_PIX_FMT_GBRAPF32LE
@ AV_PIX_FMT_GBRAPF32LE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, little-endian.
Definition: pixfmt.h:344
u
#define u(width, name, range_min, range_max)
Definition: cbs_apv.c:83
AV_PIX_FMT_X2BGR10BE
@ AV_PIX_FMT_X2BGR10BE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:387
SWS_DITHER_NONE
@ SWS_DITHER_NONE
Definition: swscale.h:80
AV_PIX_FMT_GBRPF32BE
@ AV_PIX_FMT_GBRPF32BE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, big-endian.
Definition: pixfmt.h:341
yuv2mono_1_c_template
static av_always_inline void yuv2mono_1_c_template(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target)
Definition: output.c:778
yuv2nv12cX_16_c_template
static av_always_inline void yuv2nv12cX_16_c_template(int big_endian, const uint8_t *chrDither, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest8, int chrDstW, int output_bits)
Definition: output.c:190
b
#define b
Definition: input.c:42
yuv2planeX
static void FUNC() yuv2planeX(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Definition: swscale_ppc_template.c:84
R
#define R
Definition: huffyuv.h:44
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:82
AV_PIX_FMT_RGB32_1
#define AV_PIX_FMT_RGB32_1
Definition: pixfmt.h:512
yuv2ayuv_2_c_template
static av_always_inline void yuv2ayuv_2_c_template(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y, enum AVPixelFormat target)
Definition: output.c:2957
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
b_r
#define b_r
AV_PIX_FMT_GBRP14BE
@ AV_PIX_FMT_GBRP14BE
planar GBR 4:4:4 42bpp, big-endian
Definition: pixfmt.h:281
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
yuv2ya16_1_c_template
static av_always_inline void yuv2ya16_1_c_template(SwsInternal *c, const int32_t *buf0, const int32_t *unused_ubuf[2], const int32_t *unused_vbuf[2], const int32_t *abuf0, uint16_t *dest, int dstW, int unused_uvalpha, int y, enum AVPixelFormat target, int unused_hasAlpha, int unused_eightbytes, int is_be)
Definition: output.c:1087
mathematics.h
av_float2int
static av_always_inline uint32_t av_float2int(float f)
Reinterpret a float as a 32-bit integer.
Definition: intfloat.h:50
A2
@ A2
Definition: mvs.c:530
yuv2plane1_8_c
static void yuv2plane1_8_c(const int16_t *src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Definition: output.c:483
intfloat.h
AV_PIX_FMT_GRAYF32LE
@ AV_PIX_FMT_GRAYF32LE
IEEE-754 single precision Y, 32bpp, little-endian.
Definition: pixfmt.h:364
yuv2planeX_10_c_template
static av_always_inline void yuv2planeX_10_c_template(const int16_t *filter, int filterSize, const int16_t **src, uint16_t *dest, int dstW, int big_endian, int output_bits)
Definition: output.c:341
AV_PIX_FMT_GBRAP14BE
@ AV_PIX_FMT_GBRAP14BE
planar GBR 4:4:4:4 56bpp, big-endian
Definition: pixfmt.h:432
yuv2xv36_X_c
static void yuv2xv36_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y, int is_be)
Definition: output.c:2838
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
yuv2p01xlX_c
static void yuv2p01xlX_c(const int16_t *filter, int filterSize, const int16_t **src, uint16_t *dest, int dstW, int big_endian, int output_bits, int output_shift)
Definition: output.c:549
AV_PIX_FMT_AYUV64LE
@ AV_PIX_FMT_AYUV64LE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
Definition: pixfmt.h:302
AV_PIX_FMT_AYUV64BE
@ AV_PIX_FMT_AYUV64BE
packed AYUV 4:4:4,64bpp (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
Definition: pixfmt.h:303
SH
#define SH(val, pdst)
Definition: generic_macros_msa.h:154
yuv2ayuv64_X_c
static av_always_inline void yuv2ayuv64_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **_lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **_chrUSrc, const int16_t **_chrVSrc, int chrFilterSize, const int16_t **_alpSrc, uint8_t *dest, int dstW, int y, int A_offset, int Y_offset, int U_offset, int V_offset, int is_be)
Definition: output.c:2711
yuv2422_1_c_template
static av_always_inline void yuv2422_1_c_template(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target)
Definition: output.c:954
AV_PIX_FMT_GBRAP12LE
@ AV_PIX_FMT_GBRAP12LE
planar GBR 4:4:4:4 48bpp, little-endian
Definition: pixfmt.h:311
is16BPS
static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:727
rgb
Definition: rpzaenc.c:60
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
yuv2plane1_16_c_template
static av_always_inline void yuv2plane1_16_c_template(const int32_t *src, uint16_t *dest, int dstW, int big_endian, int output_bits)
Definition: output.c:150
val
static double val(void *priv, double ch)
Definition: aeval.c:77
isNBPS
static av_always_inline int isNBPS(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:741
SWS_DITHER_X_DITHER
@ SWS_DITHER_X_DITHER
Definition: swscale.h:85
R_B
#define R_B
Definition: output.c:1004
yuv2rgb_full_X_c_template
static av_always_inline void yuv2rgb_full_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:2159
yuv2plane1_float
#define yuv2plane1_float(template, dest_type, BE_LE)
Definition: output.c:291
AV_PIX_FMT_VUYA
@ AV_PIX_FMT_VUYA
packed VUYA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), VUYAVUYA...
Definition: pixfmt.h:401
yuv2planeX_16_c_template
static av_always_inline void yuv2planeX_16_c_template(const int16_t *filter, int filterSize, const int32_t **src, uint16_t *dest, int dstW, int big_endian, int output_bits)
Definition: output.c:164
r_b
#define r_b
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
avassert.h
YUV2PACKED16WRAPPER
#define YUV2PACKED16WRAPPER(name, base, ext, base_fmt, endianness, hasAlpha, eightbytes)
Definition: output.c:1621
av_cold
#define av_cold
Definition: attributes.h:90
yuv2planeX_float
#define yuv2planeX_float(template, dest_type, BE_LE)
Definition: output.c:298
YUVRGB_TABLE_HEADROOM
#define YUVRGB_TABLE_HEADROOM
Definition: swscale_internal.h:47
yuv2packed2_fn
void(* yuv2packed2_fn)(SwsInternal *c, const int16_t *lumSrc[2], const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *alpSrc[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output by doing bilinear scalin...
Definition: swscale_internal.h:214
float
float
Definition: af_crystalizer.c:122
AV_PIX_FMT_GBRAP16BE
@ AV_PIX_FMT_GBRAP16BE
planar GBRA 4:4:4:4 64bpp, big-endian
Definition: pixfmt.h:213
yuv2gbrpf32_full_X_c
static void yuv2gbrpf32_full_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrcx, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrcx, const int16_t **chrVSrcx, int chrFilterSize, const int16_t **alpSrcx, uint8_t **dest, int dstW, int y)
Definition: output.c:2535
intreadwrite.h
AV_PIX_FMT_GBRP16LE
@ AV_PIX_FMT_GBRP16LE
planar GBR 4:4:4 48bpp, little-endian
Definition: pixfmt.h:172
output_pixels
#define output_pixels(pos, Y1, U, Y2, V)
Definition: output.c:2882
g
const char * g
Definition: vf_curves.c:128
AV_PIX_FMT_GBRP12LE
@ AV_PIX_FMT_GBRP12LE
planar GBR 4:4:4 36bpp, little-endian
Definition: pixfmt.h:280
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
yuv2rgba64_full_2_c_template
static av_always_inline void yuv2rgba64_full_2_c_template(SwsInternal *c, const int32_t *buf[2], const int32_t *ubuf[2], const int32_t *vbuf[2], const int32_t *abuf[2], uint16_t *dest, int dstW, int yalpha_param, int uvalpha_param, int y, enum AVPixelFormat target, int hasAlpha, int eightbytes, int is_be)
Definition: output.c:1437
B
#define B
Definition: huffyuv.h:42
yuv2plane1_float_bswap_c_template
static av_always_inline void yuv2plane1_float_bswap_c_template(const int32_t *src, uint32_t *dest, int dstW)
Definition: output.c:236
ff_dither_2x2_4
const uint8_t ff_dither_2x2_4[][8]
Definition: output.c:40
ff_dither_8x8_220
const uint8_t ff_dither_8x8_220[][8]
Definition: output.c:85
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
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_GBRP10LE
@ AV_PIX_FMT_GBRP10LE
planar GBR 4:4:4 30bpp, little-endian
Definition: pixfmt.h:170
yuv2rgb_write_full
static av_always_inline void yuv2rgb_write_full(SwsInternal *c, uint8_t *dest, int i, int Y, int A, int U, int V, int y, enum AVPixelFormat target, int hasAlpha, int err[4])
Definition: output.c:1996
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
if
if(ret)
Definition: filter_design.txt:179
AV_PIX_FMT_GBRP10MSBLE
@ AV_PIX_FMT_GBRP10MSBLE
planar GBR 4:4:4 30bpp, lowest bits zero, little-endian
Definition: pixfmt.h:496
isSemiPlanarYUV
static av_always_inline int isSemiPlanarYUV(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:773
yuv2nv12cX_16BE_c
static void yuv2nv12cX_16BE_c(enum AVPixelFormat dstFormat, const uint8_t *chrDither, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest8, int chrDstW)
Definition: output.c:460
yuv2NBPS
#define yuv2NBPS(bits, BE_LE, is_be, template_size, typeX_t)
Definition: output.c:361
yuv2ayuv_X_c_template
static av_always_inline void yuv2ayuv_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y, enum AVPixelFormat target)
Definition: output.c:2999
YUV2AYUV64
#define YUV2AYUV64(pixfmt, BE_LE, A, Y, U, V, is_be)
Definition: output.c:2761
yuv2vyu444_2_c
static void yuv2vyu444_2_c(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y)
Definition: output.c:3214
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:529
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_Y216LE
@ AV_PIX_FMT_Y216LE
packed YUV 4:2:2 like YUYV422, 32bpp, little-endian
Definition: pixfmt.h:461
AV_PIX_FMT_GBRAPF32BE
@ AV_PIX_FMT_GBRAPF32BE
IEEE-754 single precision planar GBRA 4:4:4:4, 128bpp, big-endian.
Definition: pixfmt.h:343
AV_PIX_FMT_GBRAP12BE
@ AV_PIX_FMT_GBRAP12BE
planar GBR 4:4:4:4 48bpp, big-endian
Definition: pixfmt.h:310
av_clip_int16
#define av_clip_int16
Definition: common.h:115
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:530
NULL
#define NULL
Definition: coverity.c:32
yuv2rgb_full_2_c_template
static av_always_inline void yuv2rgb_full_2_c_template(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:2209
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
yuv2rgba64_2_c_template
static av_always_inline void yuv2rgba64_2_c_template(SwsInternal *c, const int32_t *buf[2], const int32_t *ubuf[2], const int32_t *vbuf[2], const int32_t *abuf[2], uint16_t *dest, int dstW, int yalpha_param, int uvalpha_param, int y, enum AVPixelFormat target, int hasAlpha, int eightbytes, int is_be)
Definition: output.c:1197
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_YA16LE
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:210
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
V
#define V
Definition: avdct.c:31
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_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:203
AV_PIX_FMT_Y210LE
@ AV_PIX_FMT_Y210LE
packed YUV 4:2:2 like YUYV422, 20bpp, data in the high bits, little-endian
Definition: pixfmt.h:382
yuv2ya16_2_c_template
static av_always_inline void yuv2ya16_2_c_template(SwsInternal *c, const int32_t *buf[2], const int32_t *unused_ubuf[2], const int32_t *unused_vbuf[2], const int32_t *abuf[2], uint16_t *dest, int dstW, int yalpha_param, int unused_uvalpha, int y, enum AVPixelFormat target, int unused_hasAlpha, int unused_eightbytes, int is_be)
Definition: output.c:1053
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
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
yuv2plane1_float_c_template
static av_always_inline void yuv2plane1_float_c_template(const int32_t *src, float *dest, int dstW)
Definition: output.c:220
AV_PIX_FMT_GBRP12MSBLE
@ AV_PIX_FMT_GBRP12MSBLE
planar GBR 4:4:4 36bpp, lowest bits zero, little-endian
Definition: pixfmt.h:498
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
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
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
yuv2422_X_c_template
static av_always_inline void yuv2422_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y, enum AVPixelFormat target)
Definition: output.c:882
A_DITHER
#define A_DITHER(u, v)
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
isDataInHighBits
static av_always_inline int isDataInHighBits(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:936
yuv2MSBNBPS
#define yuv2MSBNBPS(bits, BE_LE, is_be, template_size, typeX_t)
Definition: output.c:428
yuv2packedX_fn
void(* yuv2packedX_fn)(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output by doing multi-point ver...
Definition: swscale_internal.h:246
yuv2y2xx_wrapper
#define yuv2y2xx_wrapper(bits)
Definition: output.c:3090
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:614
isBE
static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:748
yuv2rgba64_1_c_template
static av_always_inline void yuv2rgba64_1_c_template(SwsInternal *c, const int32_t *buf0, const int32_t *ubuf[2], const int32_t *vbuf[2], const int32_t *abuf0, uint16_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha, int eightbytes, int is_be)
Definition: output.c:1265
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
A1
@ A1
Definition: mvs.c:529
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
AV_PIX_FMT_GBRP10MSBBE
@ AV_PIX_FMT_GBRP10MSBBE
planar GBR 4:4:4 30bpp, lowest bits zero, big-endian
Definition: pixfmt.h:495
shift
static int shift(int a, int b)
Definition: bonk.c:261
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_XV36BE
@ AV_PIX_FMT_XV36BE
packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, big-endian,...
Definition: pixfmt.h:417
yuv2planeX_float_bswap_c_template
static av_always_inline void yuv2planeX_float_bswap_c_template(const int16_t *filter, int filterSize, const int32_t **src, uint32_t *dest, int dstW)
Definition: output.c:272
AV_PIX_FMT_YA16BE
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
Definition: pixfmt.h:209
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:525
AV_PIX_FMT_BGR555
#define AV_PIX_FMT_BGR555
Definition: pixfmt.h:532
AV_PIX_FMT_GBRP9BE
@ AV_PIX_FMT_GBRP9BE
planar GBR 4:4:4 27bpp, big-endian
Definition: pixfmt.h:167
AV_PIX_FMT_GBRP12MSBBE
@ AV_PIX_FMT_GBRP12MSBBE
planar GBR 4:4:4 36bpp, lowest bits zero, big-endian
Definition: pixfmt.h:497
AV_PIX_FMT_BGR444BE
@ AV_PIX_FMT_BGR444BE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:139
output_pixel
#define output_pixel(pos, val, bias, signedness)
Definition: output.c:3087
AV_PIX_FMT_GBRP9LE
@ AV_PIX_FMT_GBRP9LE
planar GBR 4:4:4 27bpp, little-endian
Definition: pixfmt.h:168
yuv2422_2_c_template
static av_always_inline void yuv2422_2_c_template(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y, enum AVPixelFormat target)
Definition: output.c:921
yuv2rgb_1_c_template
static av_always_inline void yuv2rgb_1_c_template(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:1881
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:408
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:511
AV_PIX_FMT_GBRAP10LE
@ AV_PIX_FMT_GBRAP10LE
planar GBR 4:4:4:4 40bpp, little-endian
Definition: pixfmt.h:314
isSwappedChroma
static av_always_inline int isSwappedChroma(enum AVPixelFormat pix_fmt)
Definition: swscale_internal.h:955
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
yuv2nv12cX_c
static void yuv2nv12cX_c(enum AVPixelFormat dstFormat, const uint8_t *chrDither, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest, int chrDstW)
Definition: output.c:493
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
attributes.h
yuv2rgb_2_c_template
static av_always_inline void yuv2rgb_2_c_template(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:1841
ff_dither_8x8_73
const uint8_t ff_dither_8x8_73[][8]
Definition: output.c:72
yuv2ya16_X_c_template
static av_always_inline void yuv2ya16_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int32_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int32_t **unused_chrUSrc, const int32_t **unused_chrVSrc, int unused_chrFilterSize, const int32_t **alpSrc, uint16_t *dest, int dstW, int y, enum AVPixelFormat target, int unused_hasAlpha, int unused_eightbytes, int is_be)
Definition: output.c:1014
Y
#define Y
Definition: boxblur.h:37
yuv2anyX_fn
void(* yuv2anyX_fn)(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t **dest, int dstW, int y)
Write one line of horizontally scaled Y/U/V/A to YUV/RGB output by doing multi-point vertical scaling...
Definition: swscale_internal.h:280
yuv2rgb_write
static av_always_inline void yuv2rgb_write(uint8_t *_dest, int i, int Y1, int Y2, unsigned A1, unsigned A2, const void *_r, const void *_g, const void *_b, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:1661
AV_PIX_FMT_AYUV
@ AV_PIX_FMT_AYUV
packed AYUV 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), AYUVAYUV...
Definition: pixfmt.h:442
AV_PIX_FMT_ARGB
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: pixfmt.h:99
AV_PIX_FMT_BGRA64LE
@ AV_PIX_FMT_BGRA64LE
packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:205
YUV2XV36
#define YUV2XV36(BE_LE, is_be)
Definition: output.c:2866
yuv2planeX_8_c
static void yuv2planeX_8_c(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Definition: output.c:468
AV_PIX_FMT_UYVA
@ AV_PIX_FMT_UYVA
packed UYVA 4:4:4:4, 32bpp (1 Cr & Cb sample per 1x1 Y & A samples), UYVAUYVA...
Definition: pixfmt.h:444
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:534
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
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:524
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
yuv2ya8_2_c
static void yuv2ya8_2_c(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y)
Definition: output.c:2637
AV_PIX_FMT_BGR444
#define AV_PIX_FMT_BGR444
Definition: pixfmt.h:533
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:527
yuv2planeX_float_c_template
static av_always_inline void yuv2planeX_float_c_template(const int16_t *filter, int filterSize, const int32_t **src, float *dest, int dstW)
Definition: output.c:252
av_always_inline
#define av_always_inline
Definition: attributes.h:49
swscale_internal.h
yuv2ayuv_1_c_template
static av_always_inline void yuv2ayuv_1_c_template(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target)
Definition: output.c:2901
yuv2interleavedX_fn
void(* yuv2interleavedX_fn)(enum AVPixelFormat dstFormat, const uint8_t *chrDither, const int16_t *chrFilter, int chrFilterSize, const int16_t **chrUSrc, const int16_t **chrVSrc, uint8_t *dest, int dstW)
Write one line of horizontally scaled chroma to interleaved output with multi-point vertical scaling ...
Definition: swscale_internal.h:144
SUINT
#define SUINT
Definition: dct32_template.c:30
yuv2rgba64_full_1_c_template
static av_always_inline void yuv2rgba64_full_1_c_template(SwsInternal *c, const int32_t *buf0, const int32_t *ubuf[2], const int32_t *vbuf[2], const int32_t *abuf0, uint16_t *dest, int dstW, int uvalpha, int y, enum AVPixelFormat target, int hasAlpha, int eightbytes, int is_be)
Definition: output.c:1492
AV_PIX_FMT_X2RGB10
#define AV_PIX_FMT_X2RGB10
Definition: pixfmt.h:613
AV_PIX_FMT_X2RGB10BE
@ AV_PIX_FMT_X2RGB10BE
packed RGB 10:10:10, 30bpp, (msb)2X 10R 10G 10B(lsb), big-endian, X=unused/undefined
Definition: pixfmt.h:385
AV_PIX_FMT_BGR565
#define AV_PIX_FMT_BGR565
Definition: pixfmt.h:531
AV_PIX_FMT_RGB4_BYTE
@ AV_PIX_FMT_RGB4_BYTE
packed RGB 1:2:1, 8bpp, (msb)1R 2G 1B(lsb)
Definition: pixfmt.h:95
AV_PIX_FMT_GBRPF32LE
@ AV_PIX_FMT_GBRPF32LE
IEEE-754 single precision planar GBR 4:4:4, 96bpp, little-endian.
Definition: pixfmt.h:342
AV_PIX_FMT_RGB565
#define AV_PIX_FMT_RGB565
Definition: pixfmt.h:526
AV_PIX_FMT_GBRAP16LE
@ AV_PIX_FMT_GBRAP16LE
planar GBRA 4:4:4:4 64bpp, little-endian
Definition: pixfmt.h:214
SWS_DITHER_ED
@ SWS_DITHER_ED
Definition: swscale.h:83
AV_PIX_FMT_YVYU422
@ AV_PIX_FMT_YVYU422
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
Definition: pixfmt.h:207
yuv2packed1_fn
void(* yuv2packed1_fn)(SwsInternal *c, const int16_t *lumSrc, const int16_t *chrUSrc[2], const int16_t *chrVSrc[2], const int16_t *alpSrc, uint8_t *dest, int dstW, int uvalpha, int y)
Write one line of horizontally scaled Y/U/V/A to packed-pixel YUV/RGB output without any additional v...
Definition: swscale_internal.h:181
SwsInternal
Definition: swscale_internal.h:317
bswap.h
yuv2gbrp_full_X_c
static void yuv2gbrp_full_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t **dest, int dstW, int y)
Definition: output.c:2341
yuv2v30_X_c_template
static av_always_inline void yuv2v30_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y, int shift)
Definition: output.c:2783
AV_PIX_FMT_Y212LE
@ AV_PIX_FMT_Y212LE
packed YUV 4:2:2 like YUYV422, 24bpp, data in the high bits, zeros in the low bits,...
Definition: pixfmt.h:412
V30LE_WRAPPER
#define V30LE_WRAPPER(name, shift)
Definition: output.c:2814
AV_PIX_FMT_GRAYF32BE
@ AV_PIX_FMT_GRAYF32BE
IEEE-754 single precision Y, 32bpp, big-endian.
Definition: pixfmt.h:363
SWS_FULL_CHR_H_INT
@ SWS_FULL_CHR_H_INT
Perform full chroma upsampling when upscaling to RGB.
Definition: swscale.h:132
YUV2RGBWRAPPER
#define YUV2RGBWRAPPER(name, base, ext, fmt, hasAlpha)
Definition: output.c:1963
AV_PIX_FMT_GBRP12BE
@ AV_PIX_FMT_GBRP12BE
planar GBR 4:4:4 36bpp, big-endian
Definition: pixfmt.h:279
AV_PIX_FMT_UYVY422
@ AV_PIX_FMT_UYVY422
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
Definition: pixfmt.h:88
U
#define U(x)
Definition: vpx_arith.h:37
yuv2planarX_fn
void(* yuv2planarX_fn)(const int16_t *filter, int filterSize, const int16_t **src, uint8_t *dest, int dstW, const uint8_t *dither, int offset)
Write one line of horizontally scaled data to planar output with multi-point vertical scaling between...
Definition: swscale_internal.h:124
SWS_DITHER_A_DITHER
@ SWS_DITHER_A_DITHER
Definition: swscale.h:84
AV_PIX_FMT_XV48LE
@ AV_PIX_FMT_XV48LE
packed XVYU 4:4:4, 64bpp, little-endian, variant of Y416 where alpha channel is left undefined
Definition: pixfmt.h:464
yuv2vyu444_1_c
static void yuv2vyu444_1_c(SwsInternal *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y)
Definition: output.c:3169
av_clip_uint8
#define av_clip_uint8
Definition: common.h:106
G
#define G
Definition: huffyuv.h:43
yuv2ya8_X_c
static void yuv2ya8_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
Definition: output.c:2668
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_clip_uint16
#define av_clip_uint16
Definition: common.h:112
yuv2gbrpmsb_full_X_c
static void yuv2gbrpmsb_full_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t **dest, int dstW, int y)
Definition: output.c:2423
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:79
avutil.h
AV_PIX_FMT_X2BGR10LE
@ AV_PIX_FMT_X2BGR10LE
packed BGR 10:10:10, 30bpp, (msb)2X 10B 10G 10R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:386
AV_PIX_FMT_V30XLE
@ AV_PIX_FMT_V30XLE
packed VYUX 4:4:4 like XV30, 32bpp, (msb)10V 10Y 10U 2X(lsb), little-endian
Definition: pixfmt.h:449
yuv2gbrp16_full_X_c
static void yuv2gbrp16_full_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrcx, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrcx, const int16_t **chrVSrcx, int chrFilterSize, const int16_t **alpSrcx, uint8_t **dest, int dstW, int y)
Definition: output.c:2463
AV_PIX_FMT_XV48BE
@ AV_PIX_FMT_XV48BE
packed XVYU 4:4:4, 64bpp, big-endian, variant of Y416 where alpha channel is left undefined
Definition: pixfmt.h:463
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
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
ff_sws_init_output_funcs
av_cold void ff_sws_init_output_funcs(SwsInternal *c, yuv2planar1_fn *yuv2plane1, yuv2planarX_fn *yuv2planeX, yuv2interleavedX_fn *yuv2nv12cX, yuv2packed1_fn *yuv2packed1, yuv2packed2_fn *yuv2packed2, yuv2packedX_fn *yuv2packedX, yuv2anyX_fn *yuv2anyX)
Definition: output.c:3289
AYUVPACKEDWRAPPER
#define AYUVPACKEDWRAPPER(name, fmt)
Definition: output.c:3051
AV_PIX_FMT_XV36LE
@ AV_PIX_FMT_XV36LE
packed XVYU 4:4:4, 48bpp, data in the high bits, zeros in the low bits, little-endian,...
Definition: pixfmt.h:418
B_R
#define B_R
Definition: output.c:1005
AV_PIX_FMT_GBRP14LE
@ AV_PIX_FMT_GBRP14LE
planar GBR 4:4:4 42bpp, little-endian
Definition: pixfmt.h:282
int32_t
int32_t
Definition: audioconvert.c:56
yuv2rgb_X_c_template
static av_always_inline void yuv2rgb_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y, enum AVPixelFormat target, int hasAlpha)
Definition: output.c:1787
yuv2msbplaneX_10_c_template
static av_always_inline void yuv2msbplaneX_10_c_template(const int16_t *filter, int filterSize, const int16_t **src, uint16_t *dest, int dstW, int big_endian, int output_bits)
Definition: output.c:410
AV_PIX_FMT_GBRAP10BE
@ AV_PIX_FMT_GBRAP10BE
planar GBR 4:4:4:4 40bpp, big-endian
Definition: pixfmt.h:313
yuv2vyu444_X_c
static void yuv2vyu444_X_c(SwsInternal *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
Definition: output.c:3248
d128
const uint8_t * d128
Definition: yuv2rgb.c:458
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
Definition: pixfmt.h:406
AV_PIX_FMT_VYU444
@ AV_PIX_FMT_VYU444
packed VYU 4:4:4, 24bpp (1 Cr & Cb sample per 1x1 Y), VYUVYU...
Definition: pixfmt.h:446
yuv2rgba64_X_c_template
static av_always_inline void yuv2rgba64_X_c_template(SwsInternal *c, const int16_t *lumFilter, const int32_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int32_t **chrUSrc, const int32_t **chrVSrc, int chrFilterSize, const int32_t **alpSrc, uint16_t *dest, int dstW, int y, enum AVPixelFormat target, int hasAlpha, int eightbytes, int is_be)
Definition: output.c:1114
av_bswap16
#define av_bswap16
Definition: bswap.h:28
AV_PIX_FMT_BGR444LE
@ AV_PIX_FMT_BGR444LE
packed BGR 4:4:4, 16bpp, (msb)4X 4B 4G 4R(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:138
yuv2mono_2_c_template
static av_always_inline void yuv2mono_2_c_template(SwsInternal *c, const int16_t *buf[2], const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf[2], uint8_t *dest, int dstW, int yalpha, int uvalpha, int y, enum AVPixelFormat target)
Definition: output.c:716
yuv2rgb
static void yuv2rgb(uint8_t *out, int ridx, int Y, int U, int V)
Definition: g2meet.c:263
rgb2rgb.h
src
#define src
Definition: vp8dsp.c:248
AV_PIX_FMT_GBRAP14LE
@ AV_PIX_FMT_GBRAP14LE
planar GBR 4:4:4:4 56bpp, little-endian
Definition: pixfmt.h:433
swscale.h
ff_dither_2x2_8
const uint8_t ff_dither_2x2_8[][8]
Definition: output.c:46
yuv2p01xl1_c
static void yuv2p01xl1_c(const int16_t *src, uint16_t *dest, int dstW, int big_endian, int output_bits, int output_shift)
Definition: output.c:536
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
dither
static const uint8_t dither[8][8]
Definition: vf_fspp.c:62
Generated on Mon Aug 4 2025 19:23:23 for FFmpeg by   doxygen 1.8.17