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