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