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