f1d9a61d53ba3479e7224f87ba58d2d03738a324
[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) {
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
1852 static av_always_inline void yuv2rgb_write_full(SwsContext *c,
1853     uint8_t *dest, int i, int Y, int A, int U, int V,
1854     int y, enum AVPixelFormat target, int hasAlpha, int err[4])
1855 {
1856     int R, G, B;
1857     int isrgb8 = target == AV_PIX_FMT_BGR8 || target == AV_PIX_FMT_RGB8;
1858
1859     Y -= c->yuv2rgb_y_offset;
1860     Y *= c->yuv2rgb_y_coeff;
1861     Y += 1 << 21;
1862     R = (unsigned)Y + V*c->yuv2rgb_v2r_coeff;
1863     G = (unsigned)Y + V*c->yuv2rgb_v2g_coeff + U*c->yuv2rgb_u2g_coeff;
1864     B = (unsigned)Y +                          U*c->yuv2rgb_u2b_coeff;
1865     if ((R | G | B) & 0xC0000000) {
1866         R = av_clip_uintp2(R, 30);
1867         G = av_clip_uintp2(G, 30);
1868         B = av_clip_uintp2(B, 30);
1869     }
1870
1871     switch(target) {
1872     case AV_PIX_FMT_ARGB:
1873         dest[0] = hasAlpha ? A : 255;
1874         dest[1] = R >> 22;
1875         dest[2] = G >> 22;
1876         dest[3] = B >> 22;
1877         break;
1878     case AV_PIX_FMT_RGB24:
1879         dest[0] = R >> 22;
1880         dest[1] = G >> 22;
1881         dest[2] = B >> 22;
1882         break;
1883     case AV_PIX_FMT_RGBA:
1884         dest[0] = R >> 22;
1885         dest[1] = G >> 22;
1886         dest[2] = B >> 22;
1887         dest[3] = hasAlpha ? A : 255;
1888         break;
1889     case AV_PIX_FMT_ABGR:
1890         dest[0] = hasAlpha ? A : 255;
1891         dest[1] = B >> 22;
1892         dest[2] = G >> 22;
1893         dest[3] = R >> 22;
1894         break;
1895     case AV_PIX_FMT_BGR24:
1896         dest[0] = B >> 22;
1897         dest[1] = G >> 22;
1898         dest[2] = R >> 22;
1899         break;
1900     case AV_PIX_FMT_BGRA:
1901         dest[0] = B >> 22;
1902         dest[1] = G >> 22;
1903         dest[2] = R >> 22;
1904         dest[3] = hasAlpha ? A : 255;
1905         break;
1906     case AV_PIX_FMT_BGR4_BYTE:
1907     case AV_PIX_FMT_RGB4_BYTE:
1908     case AV_PIX_FMT_BGR8:
1909     case AV_PIX_FMT_RGB8:
1910     {
1911         int r,g,b;
1912
1913         switch (c->dither) {
1914         case SWS_DITHER_NONE:
1915             if (isrgb8) {
1916                 r = av_clip_uintp2(R >> 27, 3);
1917                 g = av_clip_uintp2(G >> 27, 3);
1918                 b = av_clip_uintp2(B >> 28, 2);
1919             } else {
1920                 r = av_clip_uintp2(R >> 29, 1);
1921                 g = av_clip_uintp2(G >> 28, 2);
1922                 b = av_clip_uintp2(B >> 29, 1);
1923             }
1924             break;
1925         default:
1926         case SWS_DITHER_AUTO:
1927         case SWS_DITHER_ED:
1928             R >>= 22;
1929             G >>= 22;
1930             B >>= 22;
1931             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;
1932             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;
1933             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;
1934             c->dither_error[0][i] = err[0];
1935             c->dither_error[1][i] = err[1];
1936             c->dither_error[2][i] = err[2];
1937             r = R >> (isrgb8 ? 5 : 7);
1938             g = G >> (isrgb8 ? 5 : 6);
1939             b = B >> (isrgb8 ? 6 : 7);
1940             r = av_clip(r, 0, isrgb8 ? 7 : 1);
1941             g = av_clip(g, 0, isrgb8 ? 7 : 3);
1942             b = av_clip(b, 0, isrgb8 ? 3 : 1);
1943             err[0] = R - r*(isrgb8 ? 36 : 255);
1944             err[1] = G - g*(isrgb8 ? 36 : 85);
1945             err[2] = B - b*(isrgb8 ? 85 : 255);
1946             break;
1947         case SWS_DITHER_A_DITHER:
1948             if (isrgb8) {
1949   /* see http://pippin.gimp.org/a_dither/ for details/origin */
1950 #define A_DITHER(u,v)   (((((u)+((v)*236))*119)&0xff))
1951                 r = (((R >> 19) + A_DITHER(i,y)  -96)>>8);
1952                 g = (((G >> 19) + A_DITHER(i + 17,y) - 96)>>8);
1953                 b = (((B >> 20) + A_DITHER(i + 17*2,y) -96)>>8);
1954                 r = av_clip_uintp2(r, 3);
1955                 g = av_clip_uintp2(g, 3);
1956                 b = av_clip_uintp2(b, 2);
1957             } else {
1958                 r = (((R >> 21) + A_DITHER(i,y)-256)>>8);
1959                 g = (((G >> 19) + A_DITHER(i + 17,y)-256)>>8);
1960                 b = (((B >> 21) + A_DITHER(i + 17*2,y)-256)>>8);
1961                 r = av_clip_uintp2(r, 1);
1962                 g = av_clip_uintp2(g, 2);
1963                 b = av_clip_uintp2(b, 1);
1964             }
1965             break;
1966         case SWS_DITHER_X_DITHER:
1967             if (isrgb8) {
1968   /* see http://pippin.gimp.org/a_dither/ for details/origin */
1969 #define X_DITHER(u,v)   (((((u)^((v)*237))*181)&0x1ff)/2)
1970                 r = (((R >> 19) + X_DITHER(i,y) - 96)>>8);
1971                 g = (((G >> 19) + X_DITHER(i + 17,y) - 96)>>8);
1972                 b = (((B >> 20) + X_DITHER(i + 17*2,y) - 96)>>8);
1973                 r = av_clip_uintp2(r, 3);
1974                 g = av_clip_uintp2(g, 3);
1975                 b = av_clip_uintp2(b, 2);
1976             } else {
1977                 r = (((R >> 21) + X_DITHER(i,y)-256)>>8);
1978                 g = (((G >> 19) + X_DITHER(i + 17,y)-256)>>8);
1979                 b = (((B >> 21) + X_DITHER(i + 17*2,y)-256)>>8);
1980                 r = av_clip_uintp2(r, 1);
1981                 g = av_clip_uintp2(g, 2);
1982                 b = av_clip_uintp2(b, 1);
1983             }
1984
1985             break;
1986         }
1987
1988         if(target == AV_PIX_FMT_BGR4_BYTE) {
1989             dest[0] = r + 2*g + 8*b;
1990         } else if(target == AV_PIX_FMT_RGB4_BYTE) {
1991             dest[0] = b + 2*g + 8*r;
1992         } else if(target == AV_PIX_FMT_BGR8) {
1993             dest[0] = r + 8*g + 64*b;
1994         } else if(target == AV_PIX_FMT_RGB8) {
1995             dest[0] = b + 4*g + 32*r;
1996         } else
1997             av_assert2(0);
1998         break;}
1999     }
2000 }
2001
2002 static av_always_inline void
2003 yuv2rgb_full_X_c_template(SwsContext *c, const int16_t *lumFilter,
2004                           const int16_t **lumSrc, int lumFilterSize,
2005                           const int16_t *chrFilter, const int16_t **chrUSrc,
2006                           const int16_t **chrVSrc, int chrFilterSize,
2007                           const int16_t **alpSrc, uint8_t *dest,
2008                           int dstW, int y, enum AVPixelFormat target, int hasAlpha)
2009 {
2010     int i;
2011     int step = (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) ? 3 : 4;
2012     int err[4] = {0};
2013     int A = 0; //init to silence warning
2014
2015     if(   target == AV_PIX_FMT_BGR4_BYTE || target == AV_PIX_FMT_RGB4_BYTE
2016        || target == AV_PIX_FMT_BGR8      || target == AV_PIX_FMT_RGB8)
2017         step = 1;
2018
2019     for (i = 0; i < dstW; i++) {
2020         int j;
2021         int Y = 1<<9;
2022         int U = (1<<9)-(128 << 19);
2023         int V = (1<<9)-(128 << 19);
2024
2025         for (j = 0; j < lumFilterSize; j++) {
2026             Y += lumSrc[j][i] * lumFilter[j];
2027         }
2028         for (j = 0; j < chrFilterSize; j++) {
2029             U += chrUSrc[j][i] * chrFilter[j];
2030             V += chrVSrc[j][i] * chrFilter[j];
2031         }
2032         Y >>= 10;
2033         U >>= 10;
2034         V >>= 10;
2035         if (hasAlpha) {
2036             A = 1 << 18;
2037             for (j = 0; j < lumFilterSize; j++) {
2038                 A += alpSrc[j][i] * lumFilter[j];
2039             }
2040             A >>= 19;
2041             if (A & 0x100)
2042                 A = av_clip_uint8(A);
2043         }
2044         yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2045         dest += step;
2046     }
2047     c->dither_error[0][i] = err[0];
2048     c->dither_error[1][i] = err[1];
2049     c->dither_error[2][i] = err[2];
2050 }
2051
2052 static av_always_inline void
2053 yuv2rgb_full_2_c_template(SwsContext *c, const int16_t *buf[2],
2054                      const int16_t *ubuf[2], const int16_t *vbuf[2],
2055                      const int16_t *abuf[2], uint8_t *dest, int dstW,
2056                      int yalpha, int uvalpha, int y,
2057                      enum AVPixelFormat target, int hasAlpha)
2058 {
2059     const int16_t *buf0  = buf[0],  *buf1  = buf[1],
2060                   *ubuf0 = ubuf[0], *ubuf1 = ubuf[1],
2061                   *vbuf0 = vbuf[0], *vbuf1 = vbuf[1],
2062                   *abuf0 = hasAlpha ? abuf[0] : NULL,
2063                   *abuf1 = hasAlpha ? abuf[1] : NULL;
2064     int  yalpha1 = 4096 - yalpha;
2065     int uvalpha1 = 4096 - uvalpha;
2066     int i;
2067     int step = (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) ? 3 : 4;
2068     int err[4] = {0};
2069     int A = 0; // init to silcene warning
2070
2071     av_assert2(yalpha  <= 4096U);
2072     av_assert2(uvalpha <= 4096U);
2073
2074     if(   target == AV_PIX_FMT_BGR4_BYTE || target == AV_PIX_FMT_RGB4_BYTE
2075        || target == AV_PIX_FMT_BGR8      || target == AV_PIX_FMT_RGB8)
2076         step = 1;
2077
2078     for (i = 0; i < dstW; i++) {
2079         int Y = ( buf0[i] * yalpha1  +  buf1[i] * yalpha             ) >> 10; //FIXME rounding
2080         int U = (ubuf0[i] * uvalpha1 + ubuf1[i] * uvalpha-(128 << 19)) >> 10;
2081         int V = (vbuf0[i] * uvalpha1 + vbuf1[i] * uvalpha-(128 << 19)) >> 10;
2082
2083         if (hasAlpha) {
2084             A = (abuf0[i] * yalpha1 + abuf1[i] * yalpha + (1<<18)) >> 19;
2085             if (A & 0x100)
2086                 A = av_clip_uint8(A);
2087         }
2088
2089         yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2090         dest += step;
2091     }
2092     c->dither_error[0][i] = err[0];
2093     c->dither_error[1][i] = err[1];
2094     c->dither_error[2][i] = err[2];
2095 }
2096
2097 static av_always_inline void
2098 yuv2rgb_full_1_c_template(SwsContext *c, const int16_t *buf0,
2099                      const int16_t *ubuf[2], const int16_t *vbuf[2],
2100                      const int16_t *abuf0, uint8_t *dest, int dstW,
2101                      int uvalpha, int y, enum AVPixelFormat target,
2102                      int hasAlpha)
2103 {
2104     const int16_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0];
2105     int i;
2106     int step = (target == AV_PIX_FMT_RGB24 || target == AV_PIX_FMT_BGR24) ? 3 : 4;
2107     int err[4] = {0};
2108
2109     if(   target == AV_PIX_FMT_BGR4_BYTE || target == AV_PIX_FMT_RGB4_BYTE
2110        || target == AV_PIX_FMT_BGR8      || target == AV_PIX_FMT_RGB8)
2111         step = 1;
2112
2113     if (uvalpha < 2048) {
2114         int A = 0; //init to silence warning
2115         for (i = 0; i < dstW; i++) {
2116             int Y = buf0[i] * 4;
2117             int U = (ubuf0[i] - (128<<7)) * 4;
2118             int V = (vbuf0[i] - (128<<7)) * 4;
2119
2120             if (hasAlpha) {
2121                 A = (abuf0[i] + 64) >> 7;
2122                 if (A & 0x100)
2123                     A = av_clip_uint8(A);
2124             }
2125
2126             yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2127             dest += step;
2128         }
2129     } else {
2130         const int16_t *ubuf1 = ubuf[1], *vbuf1 = vbuf[1];
2131         int A = 0; //init to silence warning
2132         for (i = 0; i < dstW; i++) {
2133             int Y = buf0[i] * 4;
2134             int U = (ubuf0[i] + ubuf1[i] - (128<<8)) * 2;
2135             int V = (vbuf0[i] + vbuf1[i] - (128<<8)) * 2;
2136
2137             if (hasAlpha) {
2138                 A = (abuf0[i] + 64) >> 7;
2139                 if (A & 0x100)
2140                     A = av_clip_uint8(A);
2141             }
2142
2143             yuv2rgb_write_full(c, dest, i, Y, A, U, V, y, target, hasAlpha, err);
2144             dest += step;
2145         }
2146     }
2147
2148     c->dither_error[0][i] = err[0];
2149     c->dither_error[1][i] = err[1];
2150     c->dither_error[2][i] = err[2];
2151 }
2152
2153 #if CONFIG_SMALL
2154 YUV2RGBWRAPPER(yuv2, rgb_full, bgra32_full, AV_PIX_FMT_BGRA,  CONFIG_SWSCALE_ALPHA && c->needAlpha)
2155 YUV2RGBWRAPPER(yuv2, rgb_full, abgr32_full, AV_PIX_FMT_ABGR,  CONFIG_SWSCALE_ALPHA && c->needAlpha)
2156 YUV2RGBWRAPPER(yuv2, rgb_full, rgba32_full, AV_PIX_FMT_RGBA,  CONFIG_SWSCALE_ALPHA && c->needAlpha)
2157 YUV2RGBWRAPPER(yuv2, rgb_full, argb32_full, AV_PIX_FMT_ARGB,  CONFIG_SWSCALE_ALPHA && c->needAlpha)
2158 #else
2159 #if CONFIG_SWSCALE_ALPHA
2160 YUV2RGBWRAPPER(yuv2, rgb_full, bgra32_full, AV_PIX_FMT_BGRA,  1)
2161 YUV2RGBWRAPPER(yuv2, rgb_full, abgr32_full, AV_PIX_FMT_ABGR,  1)
2162 YUV2RGBWRAPPER(yuv2, rgb_full, rgba32_full, AV_PIX_FMT_RGBA,  1)
2163 YUV2RGBWRAPPER(yuv2, rgb_full, argb32_full, AV_PIX_FMT_ARGB,  1)
2164 #endif
2165 YUV2RGBWRAPPER(yuv2, rgb_full, bgrx32_full, AV_PIX_FMT_BGRA,  0)
2166 YUV2RGBWRAPPER(yuv2, rgb_full, xbgr32_full, AV_PIX_FMT_ABGR,  0)
2167 YUV2RGBWRAPPER(yuv2, rgb_full, rgbx32_full, AV_PIX_FMT_RGBA,  0)
2168 YUV2RGBWRAPPER(yuv2, rgb_full, xrgb32_full, AV_PIX_FMT_ARGB,  0)
2169 #endif
2170 YUV2RGBWRAPPER(yuv2, rgb_full, bgr24_full,  AV_PIX_FMT_BGR24, 0)
2171 YUV2RGBWRAPPER(yuv2, rgb_full, rgb24_full,  AV_PIX_FMT_RGB24, 0)
2172
2173 YUV2RGBWRAPPER(yuv2, rgb_full, bgr4_byte_full,  AV_PIX_FMT_BGR4_BYTE, 0)
2174 YUV2RGBWRAPPER(yuv2, rgb_full, rgb4_byte_full,  AV_PIX_FMT_RGB4_BYTE, 0)
2175 YUV2RGBWRAPPER(yuv2, rgb_full, bgr8_full,   AV_PIX_FMT_BGR8,  0)
2176 YUV2RGBWRAPPER(yuv2, rgb_full, rgb8_full,   AV_PIX_FMT_RGB8,  0)
2177
2178 static void
2179 yuv2gbrp_full_X_c(SwsContext *c, const int16_t *lumFilter,
2180                   const int16_t **lumSrc, int lumFilterSize,
2181                   const int16_t *chrFilter, const int16_t **chrUSrc,
2182                   const int16_t **chrVSrc, int chrFilterSize,
2183                   const int16_t **alpSrc, uint8_t **dest,
2184                   int dstW, int y)
2185 {
2186     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
2187     int i;
2188     int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrc;
2189     uint16_t **dest16 = (uint16_t**)dest;
2190     int SH = 22 + 8 - desc->comp[0].depth;
2191     int A = 0; // init to silence warning
2192
2193     for (i = 0; i < dstW; i++) {
2194         int j;
2195         int Y = 1 << 9;
2196         int U = (1 << 9) - (128 << 19);
2197         int V = (1 << 9) - (128 << 19);
2198         int R, G, B;
2199
2200         for (j = 0; j < lumFilterSize; j++)
2201             Y += lumSrc[j][i] * lumFilter[j];
2202
2203         for (j = 0; j < chrFilterSize; j++) {
2204             U += chrUSrc[j][i] * chrFilter[j];
2205             V += chrVSrc[j][i] * chrFilter[j];
2206         }
2207
2208         Y >>= 10;
2209         U >>= 10;
2210         V >>= 10;
2211
2212         if (hasAlpha) {
2213             A = 1 << 18;
2214
2215             for (j = 0; j < lumFilterSize; j++)
2216                 A += alpSrc[j][i] * lumFilter[j];
2217
2218             if (A & 0xF8000000)
2219                 A =  av_clip_uintp2(A, 27);
2220         }
2221
2222         Y -= c->yuv2rgb_y_offset;
2223         Y *= c->yuv2rgb_y_coeff;
2224         Y += 1 << (SH-1);
2225         R = Y + V * c->yuv2rgb_v2r_coeff;
2226         G = Y + V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
2227         B = Y +                            U * c->yuv2rgb_u2b_coeff;
2228
2229         if ((R | G | B) & 0xC0000000) {
2230             R = av_clip_uintp2(R, 30);
2231             G = av_clip_uintp2(G, 30);
2232             B = av_clip_uintp2(B, 30);
2233         }
2234
2235         if (SH != 22) {
2236             dest16[0][i] = G >> SH;
2237             dest16[1][i] = B >> SH;
2238             dest16[2][i] = R >> SH;
2239             if (hasAlpha)
2240                 dest16[3][i] = A >> (SH - 3);
2241         } else {
2242             dest[0][i] = G >> 22;
2243             dest[1][i] = B >> 22;
2244             dest[2][i] = R >> 22;
2245             if (hasAlpha)
2246                 dest[3][i] = A >> 19;
2247         }
2248     }
2249     if (SH != 22 && (!isBE(c->dstFormat)) != (!HAVE_BIGENDIAN)) {
2250         for (i = 0; i < dstW; i++) {
2251             dest16[0][i] = av_bswap16(dest16[0][i]);
2252             dest16[1][i] = av_bswap16(dest16[1][i]);
2253             dest16[2][i] = av_bswap16(dest16[2][i]);
2254             if (hasAlpha)
2255                 dest16[3][i] = av_bswap16(dest16[3][i]);
2256         }
2257     }
2258 }
2259
2260 static void
2261 yuv2gbrp16_full_X_c(SwsContext *c, const int16_t *lumFilter,
2262                     const int16_t **lumSrcx, int lumFilterSize,
2263                     const int16_t *chrFilter, const int16_t **chrUSrcx,
2264                     const int16_t **chrVSrcx, int chrFilterSize,
2265                     const int16_t **alpSrcx, uint8_t **dest,
2266                     int dstW, int y)
2267 {
2268     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
2269     int i;
2270     int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrcx;
2271     uint16_t **dest16 = (uint16_t**)dest;
2272     const int32_t **lumSrc  = (const int32_t**)lumSrcx;
2273     const int32_t **chrUSrc = (const int32_t**)chrUSrcx;
2274     const int32_t **chrVSrc = (const int32_t**)chrVSrcx;
2275     const int32_t **alpSrc  = (const int32_t**)alpSrcx;
2276
2277     for (i = 0; i < dstW; i++) {
2278         int j;
2279         int Y = -0x40000000;
2280         int U = -(128 << 23);
2281         int V = -(128 << 23);
2282         int R, G, B, A;
2283
2284         for (j = 0; j < lumFilterSize; j++)
2285             Y += lumSrc[j][i] * (unsigned)lumFilter[j];
2286
2287         for (j = 0; j < chrFilterSize; j++) {
2288             U += chrUSrc[j][i] * (unsigned)chrFilter[j];
2289             V += chrVSrc[j][i] * (unsigned)chrFilter[j];
2290         }
2291
2292         Y >>= 14;
2293         Y += 0x10000;
2294         U >>= 14;
2295         V >>= 14;
2296
2297         if (hasAlpha) {
2298             A = -0x40000000;
2299
2300             for (j = 0; j < lumFilterSize; j++)
2301                 A += alpSrc[j][i] * (unsigned)lumFilter[j];
2302
2303             A >>= 1;
2304             A += 0x20002000;
2305         }
2306
2307         Y -= c->yuv2rgb_y_offset;
2308         Y *= c->yuv2rgb_y_coeff;
2309         Y += 1 << 13;
2310         R = V * c->yuv2rgb_v2r_coeff;
2311         G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
2312         B =                            U * c->yuv2rgb_u2b_coeff;
2313
2314         R = av_clip_uintp2(Y + R, 30);
2315         G = av_clip_uintp2(Y + G, 30);
2316         B = av_clip_uintp2(Y + B, 30);
2317
2318         dest16[0][i] = G >> 14;
2319         dest16[1][i] = B >> 14;
2320         dest16[2][i] = R >> 14;
2321         if (hasAlpha)
2322             dest16[3][i] = av_clip_uintp2(A, 30) >> 14;
2323     }
2324     if ((!isBE(c->dstFormat)) != (!HAVE_BIGENDIAN)) {
2325         for (i = 0; i < dstW; i++) {
2326             dest16[0][i] = av_bswap16(dest16[0][i]);
2327             dest16[1][i] = av_bswap16(dest16[1][i]);
2328             dest16[2][i] = av_bswap16(dest16[2][i]);
2329             if (hasAlpha)
2330                 dest16[3][i] = av_bswap16(dest16[3][i]);
2331         }
2332     }
2333 }
2334
2335 static void
2336 yuv2gbrpf32_full_X_c(SwsContext *c, const int16_t *lumFilter,
2337                     const int16_t **lumSrcx, int lumFilterSize,
2338                     const int16_t *chrFilter, const int16_t **chrUSrcx,
2339                     const int16_t **chrVSrcx, int chrFilterSize,
2340                     const int16_t **alpSrcx, uint8_t **dest,
2341                     int dstW, int y)
2342 {
2343     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->dstFormat);
2344     int i;
2345     int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrcx;
2346     uint32_t **dest32 = (uint32_t**)dest;
2347     const int32_t **lumSrc  = (const int32_t**)lumSrcx;
2348     const int32_t **chrUSrc = (const int32_t**)chrUSrcx;
2349     const int32_t **chrVSrc = (const int32_t**)chrVSrcx;
2350     const int32_t **alpSrc  = (const int32_t**)alpSrcx;
2351     static const float float_mult = 1.0f / 65535.0f;
2352
2353     for (i = 0; i < dstW; i++) {
2354         int j;
2355         int Y = -0x40000000;
2356         int U = -(128 << 23);
2357         int V = -(128 << 23);
2358         int R, G, B, A;
2359
2360         for (j = 0; j < lumFilterSize; j++)
2361             Y += lumSrc[j][i] * (unsigned)lumFilter[j];
2362
2363         for (j = 0; j < chrFilterSize; j++) {
2364             U += chrUSrc[j][i] * (unsigned)chrFilter[j];
2365             V += chrVSrc[j][i] * (unsigned)chrFilter[j];
2366         }
2367
2368         Y >>= 14;
2369         Y += 0x10000;
2370         U >>= 14;
2371         V >>= 14;
2372
2373         if (hasAlpha) {
2374             A = -0x40000000;
2375
2376             for (j = 0; j < lumFilterSize; j++)
2377                 A += alpSrc[j][i] * (unsigned)lumFilter[j];
2378
2379             A >>= 1;
2380             A += 0x20002000;
2381         }
2382
2383         Y -= c->yuv2rgb_y_offset;
2384         Y *= c->yuv2rgb_y_coeff;
2385         Y += 1 << 13;
2386         R = V * c->yuv2rgb_v2r_coeff;
2387         G = V * c->yuv2rgb_v2g_coeff + U * c->yuv2rgb_u2g_coeff;
2388         B =                            U * c->yuv2rgb_u2b_coeff;
2389
2390         R = av_clip_uintp2(Y + R, 30);
2391         G = av_clip_uintp2(Y + G, 30);
2392         B = av_clip_uintp2(Y + B, 30);
2393
2394         dest32[0][i] = av_float2int(float_mult * (float)(G >> 14));
2395         dest32[1][i] = av_float2int(float_mult * (float)(B >> 14));
2396         dest32[2][i] = av_float2int(float_mult * (float)(R >> 14));
2397         if (hasAlpha)
2398             dest32[3][i] = av_float2int(float_mult * (float)(av_clip_uintp2(A, 30) >> 14));
2399     }
2400     if ((!isBE(c->dstFormat)) != (!HAVE_BIGENDIAN)) {
2401         for (i = 0; i < dstW; i++) {
2402             dest32[0][i] = av_bswap32(dest32[0][i]);
2403             dest32[1][i] = av_bswap32(dest32[1][i]);
2404             dest32[2][i] = av_bswap32(dest32[2][i]);
2405             if (hasAlpha)
2406                 dest32[3][i] = av_bswap32(dest32[3][i]);
2407         }
2408     }
2409 }
2410
2411 static void
2412 yuv2ya8_1_c(SwsContext *c, const int16_t *buf0,
2413             const int16_t *ubuf[2], const int16_t *vbuf[2],
2414             const int16_t *abuf0, uint8_t *dest, int dstW,
2415             int uvalpha, int y)
2416 {
2417     int hasAlpha = !!abuf0;
2418     int i;
2419
2420     for (i = 0; i < dstW; i++) {
2421         int Y = (buf0[i] + 64) >> 7;
2422         int A;
2423
2424         Y = av_clip_uint8(Y);
2425
2426         if (hasAlpha) {
2427             A = (abuf0[i] + 64) >> 7;
2428             if (A & 0x100)
2429                 A = av_clip_uint8(A);
2430         }
2431
2432         dest[i * 2    ] = Y;
2433         dest[i * 2 + 1] = hasAlpha ? A : 255;
2434     }
2435 }
2436
2437 static void
2438 yuv2ya8_2_c(SwsContext *c, const int16_t *buf[2],
2439             const int16_t *ubuf[2], const int16_t *vbuf[2],
2440             const int16_t *abuf[2], uint8_t *dest, int dstW,
2441             int yalpha, int uvalpha, int y)
2442 {
2443     int hasAlpha = abuf && abuf[0] && abuf[1];
2444     const int16_t *buf0  = buf[0],  *buf1  = buf[1],
2445                   *abuf0 = hasAlpha ? abuf[0] : NULL,
2446                   *abuf1 = hasAlpha ? abuf[1] : NULL;
2447     int  yalpha1 = 4096 - yalpha;
2448     int i;
2449
2450     av_assert2(yalpha  <= 4096U);
2451
2452     for (i = 0; i < dstW; i++) {
2453         int Y = (buf0[i] * yalpha1 + buf1[i] * yalpha) >> 19;
2454         int A;
2455
2456         Y = av_clip_uint8(Y);
2457
2458         if (hasAlpha) {
2459             A = (abuf0[i] * yalpha1 + abuf1[i] * yalpha) >> 19;
2460             A = av_clip_uint8(A);
2461         }
2462
2463         dest[i * 2    ] = Y;
2464         dest[i * 2 + 1] = hasAlpha ? A : 255;
2465     }
2466 }
2467
2468 static void
2469 yuv2ya8_X_c(SwsContext *c, const int16_t *lumFilter,
2470             const int16_t **lumSrc, int lumFilterSize,
2471             const int16_t *chrFilter, const int16_t **chrUSrc,
2472             const int16_t **chrVSrc, int chrFilterSize,
2473             const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
2474 {
2475     int hasAlpha = !!alpSrc;
2476     int i;
2477
2478     for (i = 0; i < dstW; i++) {
2479         int j;
2480         int Y = 1 << 18, A = 1 << 18;
2481
2482         for (j = 0; j < lumFilterSize; j++)
2483             Y += lumSrc[j][i] * lumFilter[j];
2484
2485         Y >>= 19;
2486         if (Y  & 0x100)
2487             Y = av_clip_uint8(Y);
2488
2489         if (hasAlpha) {
2490             for (j = 0; j < lumFilterSize; j++)
2491                 A += alpSrc[j][i] * lumFilter[j];
2492
2493             A >>= 19;
2494
2495             if (A & 0x100)
2496                 A = av_clip_uint8(A);
2497         }
2498
2499         dest[2 * i    ] = Y;
2500         dest[2 * i + 1] = hasAlpha ? A : 255;
2501     }
2502 }
2503
2504 static void
2505 yuv2ayuv64le_X_c(SwsContext *c, const int16_t *lumFilter,
2506                  const int16_t **_lumSrc, int lumFilterSize,
2507                  const int16_t *chrFilter, const int16_t **_chrUSrc,
2508                  const int16_t **_chrVSrc, int chrFilterSize,
2509                  const int16_t **_alpSrc, uint8_t *dest, int dstW, int y)
2510 {
2511     const int32_t **lumSrc  = (const int32_t **) _lumSrc,
2512                   **chrUSrc = (const int32_t **) _chrUSrc,
2513                   **chrVSrc = (const int32_t **) _chrVSrc,
2514                   **alpSrc  = (const int32_t **) _alpSrc;
2515     int hasAlpha = !!alpSrc;
2516     int i;
2517
2518     for (i = 0; i < dstW; i++) {
2519         int Y = 1 << 14, U = 1 << 14;
2520         int V = 1 << 14, A = 1 << 14;
2521         int j;
2522
2523         Y -= 0x40000000;
2524         U -= 0x40000000;
2525         V -= 0x40000000;
2526         A -= 0x40000000;
2527
2528         for (j = 0; j < lumFilterSize; j++)
2529             Y += lumSrc[j][i] * (unsigned)lumFilter[j];
2530
2531         for (j = 0; j < chrFilterSize; j++)
2532             U += chrUSrc[j][i] * (unsigned)chrFilter[j];
2533
2534         for (j = 0; j < chrFilterSize; j++)
2535             V += chrVSrc[j][i] * (unsigned)chrFilter[j];
2536
2537         if (hasAlpha)
2538             for (j = 0; j < lumFilterSize; j++)
2539                 A += alpSrc[j][i] * (unsigned)lumFilter[j];
2540
2541         Y = 0x8000 + av_clip_int16(Y >> 15);
2542         U = 0x8000 + av_clip_int16(U >> 15);
2543         V = 0x8000 + av_clip_int16(V >> 15);
2544         A = 0x8000 + av_clip_int16(A >> 15);
2545
2546         AV_WL16(dest + 8 * i, hasAlpha ? A : 65535);
2547         AV_WL16(dest + 8 * i + 2, Y);
2548         AV_WL16(dest + 8 * i + 4, U);
2549         AV_WL16(dest + 8 * i + 6, V);
2550     }
2551 }
2552
2553 av_cold void ff_sws_init_output_funcs(SwsContext *c,
2554                                       yuv2planar1_fn *yuv2plane1,
2555                                       yuv2planarX_fn *yuv2planeX,
2556                                       yuv2interleavedX_fn *yuv2nv12cX,
2557                                       yuv2packed1_fn *yuv2packed1,
2558                                       yuv2packed2_fn *yuv2packed2,
2559                                       yuv2packedX_fn *yuv2packedX,
2560                                       yuv2anyX_fn *yuv2anyX)
2561 {
2562     enum AVPixelFormat dstFormat = c->dstFormat;
2563     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
2564
2565     if (dstFormat == AV_PIX_FMT_P010LE || dstFormat == AV_PIX_FMT_P010BE) {
2566         *yuv2plane1 = isBE(dstFormat) ? yuv2p010l1_BE_c : yuv2p010l1_LE_c;
2567         *yuv2planeX = isBE(dstFormat) ? yuv2p010lX_BE_c : yuv2p010lX_LE_c;
2568         *yuv2nv12cX = yuv2p010cX_c;
2569     } else if (is16BPS(dstFormat)) {
2570         *yuv2planeX = isBE(dstFormat) ? yuv2planeX_16BE_c  : yuv2planeX_16LE_c;
2571         *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_16BE_c  : yuv2plane1_16LE_c;
2572         if (dstFormat == AV_PIX_FMT_P016LE || dstFormat == AV_PIX_FMT_P016BE) {
2573           *yuv2nv12cX = yuv2p016cX_c;
2574         }
2575     } else if (isNBPS(dstFormat)) {
2576         if (desc->comp[0].depth == 9) {
2577             *yuv2planeX = isBE(dstFormat) ? yuv2planeX_9BE_c  : yuv2planeX_9LE_c;
2578             *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_9BE_c  : yuv2plane1_9LE_c;
2579         } else if (desc->comp[0].depth == 10) {
2580             *yuv2planeX = isBE(dstFormat) ? yuv2planeX_10BE_c  : yuv2planeX_10LE_c;
2581             *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_10BE_c  : yuv2plane1_10LE_c;
2582         } else if (desc->comp[0].depth == 12) {
2583             *yuv2planeX = isBE(dstFormat) ? yuv2planeX_12BE_c  : yuv2planeX_12LE_c;
2584             *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_12BE_c  : yuv2plane1_12LE_c;
2585         } else if (desc->comp[0].depth == 14) {
2586             *yuv2planeX = isBE(dstFormat) ? yuv2planeX_14BE_c  : yuv2planeX_14LE_c;
2587             *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_14BE_c  : yuv2plane1_14LE_c;
2588         } else
2589             av_assert0(0);
2590     } else if (dstFormat == AV_PIX_FMT_GRAYF32BE) {
2591         *yuv2planeX = yuv2planeX_floatBE_c;
2592         *yuv2plane1 = yuv2plane1_floatBE_c;
2593     } else if (dstFormat == AV_PIX_FMT_GRAYF32LE) {
2594         *yuv2planeX = yuv2planeX_floatLE_c;
2595         *yuv2plane1 = yuv2plane1_floatLE_c;
2596     } else {
2597         *yuv2plane1 = yuv2plane1_8_c;
2598         *yuv2planeX = yuv2planeX_8_c;
2599         if (dstFormat == AV_PIX_FMT_NV12 || dstFormat == AV_PIX_FMT_NV21 ||
2600             dstFormat == AV_PIX_FMT_NV24 || dstFormat == AV_PIX_FMT_NV42)
2601             *yuv2nv12cX = yuv2nv12cX_c;
2602     }
2603
2604     if(c->flags & SWS_FULL_CHR_H_INT) {
2605         switch (dstFormat) {
2606             case AV_PIX_FMT_RGBA:
2607 #if CONFIG_SMALL
2608                 *yuv2packedX = yuv2rgba32_full_X_c;
2609                 *yuv2packed2 = yuv2rgba32_full_2_c;
2610                 *yuv2packed1 = yuv2rgba32_full_1_c;
2611 #else
2612 #if CONFIG_SWSCALE_ALPHA
2613                 if (c->needAlpha) {
2614                     *yuv2packedX = yuv2rgba32_full_X_c;
2615                     *yuv2packed2 = yuv2rgba32_full_2_c;
2616                     *yuv2packed1 = yuv2rgba32_full_1_c;
2617                 } else
2618 #endif /* CONFIG_SWSCALE_ALPHA */
2619                 {
2620                     *yuv2packedX = yuv2rgbx32_full_X_c;
2621                     *yuv2packed2 = yuv2rgbx32_full_2_c;
2622                     *yuv2packed1 = yuv2rgbx32_full_1_c;
2623                 }
2624 #endif /* !CONFIG_SMALL */
2625                 break;
2626             case AV_PIX_FMT_ARGB:
2627 #if CONFIG_SMALL
2628                 *yuv2packedX = yuv2argb32_full_X_c;
2629                 *yuv2packed2 = yuv2argb32_full_2_c;
2630                 *yuv2packed1 = yuv2argb32_full_1_c;
2631 #else
2632 #if CONFIG_SWSCALE_ALPHA
2633                 if (c->needAlpha) {
2634                     *yuv2packedX = yuv2argb32_full_X_c;
2635                     *yuv2packed2 = yuv2argb32_full_2_c;
2636                     *yuv2packed1 = yuv2argb32_full_1_c;
2637                 } else
2638 #endif /* CONFIG_SWSCALE_ALPHA */
2639                 {
2640                     *yuv2packedX = yuv2xrgb32_full_X_c;
2641                     *yuv2packed2 = yuv2xrgb32_full_2_c;
2642                     *yuv2packed1 = yuv2xrgb32_full_1_c;
2643                 }
2644 #endif /* !CONFIG_SMALL */
2645                 break;
2646             case AV_PIX_FMT_BGRA:
2647 #if CONFIG_SMALL
2648                 *yuv2packedX = yuv2bgra32_full_X_c;
2649                 *yuv2packed2 = yuv2bgra32_full_2_c;
2650                 *yuv2packed1 = yuv2bgra32_full_1_c;
2651 #else
2652 #if CONFIG_SWSCALE_ALPHA
2653                 if (c->needAlpha) {
2654                     *yuv2packedX = yuv2bgra32_full_X_c;
2655                     *yuv2packed2 = yuv2bgra32_full_2_c;
2656                     *yuv2packed1 = yuv2bgra32_full_1_c;
2657                 } else
2658 #endif /* CONFIG_SWSCALE_ALPHA */
2659                 {
2660                     *yuv2packedX = yuv2bgrx32_full_X_c;
2661                     *yuv2packed2 = yuv2bgrx32_full_2_c;
2662                     *yuv2packed1 = yuv2bgrx32_full_1_c;
2663                 }
2664 #endif /* !CONFIG_SMALL */
2665                 break;
2666             case AV_PIX_FMT_ABGR:
2667 #if CONFIG_SMALL
2668                 *yuv2packedX = yuv2abgr32_full_X_c;
2669                 *yuv2packed2 = yuv2abgr32_full_2_c;
2670                 *yuv2packed1 = yuv2abgr32_full_1_c;
2671 #else
2672 #if CONFIG_SWSCALE_ALPHA
2673                 if (c->needAlpha) {
2674                     *yuv2packedX = yuv2abgr32_full_X_c;
2675                     *yuv2packed2 = yuv2abgr32_full_2_c;
2676                     *yuv2packed1 = yuv2abgr32_full_1_c;
2677                 } else
2678 #endif /* CONFIG_SWSCALE_ALPHA */
2679                 {
2680                     *yuv2packedX = yuv2xbgr32_full_X_c;
2681                     *yuv2packed2 = yuv2xbgr32_full_2_c;
2682                     *yuv2packed1 = yuv2xbgr32_full_1_c;
2683                 }
2684 #endif /* !CONFIG_SMALL */
2685                 break;
2686         case AV_PIX_FMT_RGBA64LE:
2687 #if CONFIG_SWSCALE_ALPHA
2688             if (c->needAlpha) {
2689                 *yuv2packedX = yuv2rgba64le_full_X_c;
2690                 *yuv2packed2 = yuv2rgba64le_full_2_c;
2691                 *yuv2packed1 = yuv2rgba64le_full_1_c;
2692             } else
2693 #endif /* CONFIG_SWSCALE_ALPHA */
2694             {
2695                 *yuv2packedX = yuv2rgbx64le_full_X_c;
2696                 *yuv2packed2 = yuv2rgbx64le_full_2_c;
2697                 *yuv2packed1 = yuv2rgbx64le_full_1_c;
2698             }
2699             break;
2700         case AV_PIX_FMT_RGBA64BE:
2701 #if CONFIG_SWSCALE_ALPHA
2702             if (c->needAlpha) {
2703                 *yuv2packedX = yuv2rgba64be_full_X_c;
2704                 *yuv2packed2 = yuv2rgba64be_full_2_c;
2705                 *yuv2packed1 = yuv2rgba64be_full_1_c;
2706             } else
2707 #endif /* CONFIG_SWSCALE_ALPHA */
2708             {
2709                 *yuv2packedX = yuv2rgbx64be_full_X_c;
2710                 *yuv2packed2 = yuv2rgbx64be_full_2_c;
2711                 *yuv2packed1 = yuv2rgbx64be_full_1_c;
2712             }
2713             break;
2714         case AV_PIX_FMT_BGRA64LE:
2715 #if CONFIG_SWSCALE_ALPHA
2716             if (c->needAlpha) {
2717                 *yuv2packedX = yuv2bgra64le_full_X_c;
2718                 *yuv2packed2 = yuv2bgra64le_full_2_c;
2719                 *yuv2packed1 = yuv2bgra64le_full_1_c;
2720             } else
2721 #endif /* CONFIG_SWSCALE_ALPHA */
2722             {
2723                 *yuv2packedX = yuv2bgrx64le_full_X_c;
2724                 *yuv2packed2 = yuv2bgrx64le_full_2_c;
2725                 *yuv2packed1 = yuv2bgrx64le_full_1_c;
2726             }
2727             break;
2728         case AV_PIX_FMT_BGRA64BE:
2729 #if CONFIG_SWSCALE_ALPHA
2730             if (c->needAlpha) {
2731                 *yuv2packedX = yuv2bgra64be_full_X_c;
2732                 *yuv2packed2 = yuv2bgra64be_full_2_c;
2733                 *yuv2packed1 = yuv2bgra64be_full_1_c;
2734             } else
2735 #endif /* CONFIG_SWSCALE_ALPHA */
2736             {
2737                 *yuv2packedX = yuv2bgrx64be_full_X_c;
2738                 *yuv2packed2 = yuv2bgrx64be_full_2_c;
2739                 *yuv2packed1 = yuv2bgrx64be_full_1_c;
2740             }
2741             break;
2742
2743         case AV_PIX_FMT_RGB24:
2744             *yuv2packedX = yuv2rgb24_full_X_c;
2745             *yuv2packed2 = yuv2rgb24_full_2_c;
2746             *yuv2packed1 = yuv2rgb24_full_1_c;
2747             break;
2748         case AV_PIX_FMT_BGR24:
2749             *yuv2packedX = yuv2bgr24_full_X_c;
2750             *yuv2packed2 = yuv2bgr24_full_2_c;
2751             *yuv2packed1 = yuv2bgr24_full_1_c;
2752             break;
2753         case AV_PIX_FMT_RGB48LE:
2754             *yuv2packedX = yuv2rgb48le_full_X_c;
2755             *yuv2packed2 = yuv2rgb48le_full_2_c;
2756             *yuv2packed1 = yuv2rgb48le_full_1_c;
2757             break;
2758         case AV_PIX_FMT_BGR48LE:
2759             *yuv2packedX = yuv2bgr48le_full_X_c;
2760             *yuv2packed2 = yuv2bgr48le_full_2_c;
2761             *yuv2packed1 = yuv2bgr48le_full_1_c;
2762             break;
2763         case AV_PIX_FMT_RGB48BE:
2764             *yuv2packedX = yuv2rgb48be_full_X_c;
2765             *yuv2packed2 = yuv2rgb48be_full_2_c;
2766             *yuv2packed1 = yuv2rgb48be_full_1_c;
2767             break;
2768         case AV_PIX_FMT_BGR48BE:
2769             *yuv2packedX = yuv2bgr48be_full_X_c;
2770             *yuv2packed2 = yuv2bgr48be_full_2_c;
2771             *yuv2packed1 = yuv2bgr48be_full_1_c;
2772             break;
2773         case AV_PIX_FMT_BGR4_BYTE:
2774             *yuv2packedX = yuv2bgr4_byte_full_X_c;
2775             *yuv2packed2 = yuv2bgr4_byte_full_2_c;
2776             *yuv2packed1 = yuv2bgr4_byte_full_1_c;
2777             break;
2778         case AV_PIX_FMT_RGB4_BYTE:
2779             *yuv2packedX = yuv2rgb4_byte_full_X_c;
2780             *yuv2packed2 = yuv2rgb4_byte_full_2_c;
2781             *yuv2packed1 = yuv2rgb4_byte_full_1_c;
2782             break;
2783         case AV_PIX_FMT_BGR8:
2784             *yuv2packedX = yuv2bgr8_full_X_c;
2785             *yuv2packed2 = yuv2bgr8_full_2_c;
2786             *yuv2packed1 = yuv2bgr8_full_1_c;
2787             break;
2788         case AV_PIX_FMT_RGB8:
2789             *yuv2packedX = yuv2rgb8_full_X_c;
2790             *yuv2packed2 = yuv2rgb8_full_2_c;
2791             *yuv2packed1 = yuv2rgb8_full_1_c;
2792             break;
2793         case AV_PIX_FMT_GBRP:
2794         case AV_PIX_FMT_GBRP9BE:
2795         case AV_PIX_FMT_GBRP9LE:
2796         case AV_PIX_FMT_GBRP10BE:
2797         case AV_PIX_FMT_GBRP10LE:
2798         case AV_PIX_FMT_GBRP12BE:
2799         case AV_PIX_FMT_GBRP12LE:
2800         case AV_PIX_FMT_GBRP14BE:
2801         case AV_PIX_FMT_GBRP14LE:
2802         case AV_PIX_FMT_GBRAP:
2803         case AV_PIX_FMT_GBRAP10BE:
2804         case AV_PIX_FMT_GBRAP10LE:
2805         case AV_PIX_FMT_GBRAP12BE:
2806         case AV_PIX_FMT_GBRAP12LE:
2807             *yuv2anyX = yuv2gbrp_full_X_c;
2808             break;
2809         case AV_PIX_FMT_GBRP16BE:
2810         case AV_PIX_FMT_GBRP16LE:
2811         case AV_PIX_FMT_GBRAP16BE:
2812         case AV_PIX_FMT_GBRAP16LE:
2813             *yuv2anyX = yuv2gbrp16_full_X_c;
2814             break;
2815         case AV_PIX_FMT_GBRPF32BE:
2816         case AV_PIX_FMT_GBRPF32LE:
2817         case AV_PIX_FMT_GBRAPF32BE:
2818         case AV_PIX_FMT_GBRAPF32LE:
2819             *yuv2anyX = yuv2gbrpf32_full_X_c;
2820             break;
2821         }
2822         if (!*yuv2packedX && !*yuv2anyX)
2823             goto YUV_PACKED;
2824     } else {
2825         YUV_PACKED:
2826         switch (dstFormat) {
2827         case AV_PIX_FMT_RGBA64LE:
2828 #if CONFIG_SWSCALE_ALPHA
2829             if (c->needAlpha) {
2830                 *yuv2packed1 = yuv2rgba64le_1_c;
2831                 *yuv2packed2 = yuv2rgba64le_2_c;
2832                 *yuv2packedX = yuv2rgba64le_X_c;
2833             } else
2834 #endif /* CONFIG_SWSCALE_ALPHA */
2835             {
2836                 *yuv2packed1 = yuv2rgbx64le_1_c;
2837                 *yuv2packed2 = yuv2rgbx64le_2_c;
2838                 *yuv2packedX = yuv2rgbx64le_X_c;
2839             }
2840             break;
2841         case AV_PIX_FMT_RGBA64BE:
2842 #if CONFIG_SWSCALE_ALPHA
2843             if (c->needAlpha) {
2844                 *yuv2packed1 = yuv2rgba64be_1_c;
2845                 *yuv2packed2 = yuv2rgba64be_2_c;
2846                 *yuv2packedX = yuv2rgba64be_X_c;
2847             } else
2848 #endif /* CONFIG_SWSCALE_ALPHA */
2849             {
2850                 *yuv2packed1 = yuv2rgbx64be_1_c;
2851                 *yuv2packed2 = yuv2rgbx64be_2_c;
2852                 *yuv2packedX = yuv2rgbx64be_X_c;
2853             }
2854             break;
2855         case AV_PIX_FMT_BGRA64LE:
2856 #if CONFIG_SWSCALE_ALPHA
2857             if (c->needAlpha) {
2858                 *yuv2packed1 = yuv2bgra64le_1_c;
2859                 *yuv2packed2 = yuv2bgra64le_2_c;
2860                 *yuv2packedX = yuv2bgra64le_X_c;
2861             } else
2862 #endif /* CONFIG_SWSCALE_ALPHA */
2863             {
2864                 *yuv2packed1 = yuv2bgrx64le_1_c;
2865                 *yuv2packed2 = yuv2bgrx64le_2_c;
2866                 *yuv2packedX = yuv2bgrx64le_X_c;
2867             }
2868             break;
2869         case AV_PIX_FMT_BGRA64BE:
2870 #if CONFIG_SWSCALE_ALPHA
2871             if (c->needAlpha) {
2872                 *yuv2packed1 = yuv2bgra64be_1_c;
2873                 *yuv2packed2 = yuv2bgra64be_2_c;
2874                 *yuv2packedX = yuv2bgra64be_X_c;
2875             } else
2876 #endif /* CONFIG_SWSCALE_ALPHA */
2877             {
2878                 *yuv2packed1 = yuv2bgrx64be_1_c;
2879                 *yuv2packed2 = yuv2bgrx64be_2_c;
2880                 *yuv2packedX = yuv2bgrx64be_X_c;
2881             }
2882             break;
2883         case AV_PIX_FMT_RGB48LE:
2884             *yuv2packed1 = yuv2rgb48le_1_c;
2885             *yuv2packed2 = yuv2rgb48le_2_c;
2886             *yuv2packedX = yuv2rgb48le_X_c;
2887             break;
2888         case AV_PIX_FMT_RGB48BE:
2889             *yuv2packed1 = yuv2rgb48be_1_c;
2890             *yuv2packed2 = yuv2rgb48be_2_c;
2891             *yuv2packedX = yuv2rgb48be_X_c;
2892             break;
2893         case AV_PIX_FMT_BGR48LE:
2894             *yuv2packed1 = yuv2bgr48le_1_c;
2895             *yuv2packed2 = yuv2bgr48le_2_c;
2896             *yuv2packedX = yuv2bgr48le_X_c;
2897             break;
2898         case AV_PIX_FMT_BGR48BE:
2899             *yuv2packed1 = yuv2bgr48be_1_c;
2900             *yuv2packed2 = yuv2bgr48be_2_c;
2901             *yuv2packedX = yuv2bgr48be_X_c;
2902             break;
2903         case AV_PIX_FMT_RGB32:
2904         case AV_PIX_FMT_BGR32:
2905 #if CONFIG_SMALL
2906             *yuv2packed1 = yuv2rgb32_1_c;
2907             *yuv2packed2 = yuv2rgb32_2_c;
2908             *yuv2packedX = yuv2rgb32_X_c;
2909 #else
2910 #if CONFIG_SWSCALE_ALPHA
2911                 if (c->needAlpha) {
2912                     *yuv2packed1 = yuv2rgba32_1_c;
2913                     *yuv2packed2 = yuv2rgba32_2_c;
2914                     *yuv2packedX = yuv2rgba32_X_c;
2915                 } else
2916 #endif /* CONFIG_SWSCALE_ALPHA */
2917                 {
2918                     *yuv2packed1 = yuv2rgbx32_1_c;
2919                     *yuv2packed2 = yuv2rgbx32_2_c;
2920                     *yuv2packedX = yuv2rgbx32_X_c;
2921                 }
2922 #endif /* !CONFIG_SMALL */
2923             break;
2924         case AV_PIX_FMT_RGB32_1:
2925         case AV_PIX_FMT_BGR32_1:
2926 #if CONFIG_SMALL
2927                 *yuv2packed1 = yuv2rgb32_1_1_c;
2928                 *yuv2packed2 = yuv2rgb32_1_2_c;
2929                 *yuv2packedX = yuv2rgb32_1_X_c;
2930 #else
2931 #if CONFIG_SWSCALE_ALPHA
2932                 if (c->needAlpha) {
2933                     *yuv2packed1 = yuv2rgba32_1_1_c;
2934                     *yuv2packed2 = yuv2rgba32_1_2_c;
2935                     *yuv2packedX = yuv2rgba32_1_X_c;
2936                 } else
2937 #endif /* CONFIG_SWSCALE_ALPHA */
2938                 {
2939                     *yuv2packed1 = yuv2rgbx32_1_1_c;
2940                     *yuv2packed2 = yuv2rgbx32_1_2_c;
2941                     *yuv2packedX = yuv2rgbx32_1_X_c;
2942                 }
2943 #endif /* !CONFIG_SMALL */
2944                 break;
2945         case AV_PIX_FMT_RGB24:
2946             *yuv2packed1 = yuv2rgb24_1_c;
2947             *yuv2packed2 = yuv2rgb24_2_c;
2948             *yuv2packedX = yuv2rgb24_X_c;
2949             break;
2950         case AV_PIX_FMT_BGR24:
2951             *yuv2packed1 = yuv2bgr24_1_c;
2952             *yuv2packed2 = yuv2bgr24_2_c;
2953             *yuv2packedX = yuv2bgr24_X_c;
2954             break;
2955         case AV_PIX_FMT_RGB565LE:
2956         case AV_PIX_FMT_RGB565BE:
2957         case AV_PIX_FMT_BGR565LE:
2958         case AV_PIX_FMT_BGR565BE:
2959             *yuv2packed1 = yuv2rgb16_1_c;
2960             *yuv2packed2 = yuv2rgb16_2_c;
2961             *yuv2packedX = yuv2rgb16_X_c;
2962             break;
2963         case AV_PIX_FMT_RGB555LE:
2964         case AV_PIX_FMT_RGB555BE:
2965         case AV_PIX_FMT_BGR555LE:
2966         case AV_PIX_FMT_BGR555BE:
2967             *yuv2packed1 = yuv2rgb15_1_c;
2968             *yuv2packed2 = yuv2rgb15_2_c;
2969             *yuv2packedX = yuv2rgb15_X_c;
2970             break;
2971         case AV_PIX_FMT_RGB444LE:
2972         case AV_PIX_FMT_RGB444BE:
2973         case AV_PIX_FMT_BGR444LE:
2974         case AV_PIX_FMT_BGR444BE:
2975             *yuv2packed1 = yuv2rgb12_1_c;
2976             *yuv2packed2 = yuv2rgb12_2_c;
2977             *yuv2packedX = yuv2rgb12_X_c;
2978             break;
2979         case AV_PIX_FMT_RGB8:
2980         case AV_PIX_FMT_BGR8:
2981             *yuv2packed1 = yuv2rgb8_1_c;
2982             *yuv2packed2 = yuv2rgb8_2_c;
2983             *yuv2packedX = yuv2rgb8_X_c;
2984             break;
2985         case AV_PIX_FMT_RGB4:
2986         case AV_PIX_FMT_BGR4:
2987             *yuv2packed1 = yuv2rgb4_1_c;
2988             *yuv2packed2 = yuv2rgb4_2_c;
2989             *yuv2packedX = yuv2rgb4_X_c;
2990             break;
2991         case AV_PIX_FMT_RGB4_BYTE:
2992         case AV_PIX_FMT_BGR4_BYTE:
2993             *yuv2packed1 = yuv2rgb4b_1_c;
2994             *yuv2packed2 = yuv2rgb4b_2_c;
2995             *yuv2packedX = yuv2rgb4b_X_c;
2996             break;
2997         case AV_PIX_FMT_X2RGB10LE:
2998         case AV_PIX_FMT_X2RGB10BE:
2999             *yuv2packed1 = yuv2x2rgb10_1_c;
3000             *yuv2packed2 = yuv2x2rgb10_2_c;
3001             *yuv2packedX = yuv2x2rgb10_X_c;
3002             break;
3003         }
3004     }
3005     switch (dstFormat) {
3006     case AV_PIX_FMT_MONOWHITE:
3007         *yuv2packed1 = yuv2monowhite_1_c;
3008         *yuv2packed2 = yuv2monowhite_2_c;
3009         *yuv2packedX = yuv2monowhite_X_c;
3010         break;
3011     case AV_PIX_FMT_MONOBLACK:
3012         *yuv2packed1 = yuv2monoblack_1_c;
3013         *yuv2packed2 = yuv2monoblack_2_c;
3014         *yuv2packedX = yuv2monoblack_X_c;
3015         break;
3016     case AV_PIX_FMT_YUYV422:
3017         *yuv2packed1 = yuv2yuyv422_1_c;
3018         *yuv2packed2 = yuv2yuyv422_2_c;
3019         *yuv2packedX = yuv2yuyv422_X_c;
3020         break;
3021     case AV_PIX_FMT_YVYU422:
3022         *yuv2packed1 = yuv2yvyu422_1_c;
3023         *yuv2packed2 = yuv2yvyu422_2_c;
3024         *yuv2packedX = yuv2yvyu422_X_c;
3025         break;
3026     case AV_PIX_FMT_UYVY422:
3027         *yuv2packed1 = yuv2uyvy422_1_c;
3028         *yuv2packed2 = yuv2uyvy422_2_c;
3029         *yuv2packedX = yuv2uyvy422_X_c;
3030         break;
3031     case AV_PIX_FMT_YA8:
3032         *yuv2packed1 = yuv2ya8_1_c;
3033         *yuv2packed2 = yuv2ya8_2_c;
3034         *yuv2packedX = yuv2ya8_X_c;
3035         break;
3036     case AV_PIX_FMT_YA16LE:
3037         *yuv2packed1 = yuv2ya16le_1_c;
3038         *yuv2packed2 = yuv2ya16le_2_c;
3039         *yuv2packedX = yuv2ya16le_X_c;
3040         break;
3041     case AV_PIX_FMT_YA16BE:
3042         *yuv2packed1 = yuv2ya16be_1_c;
3043         *yuv2packed2 = yuv2ya16be_2_c;
3044         *yuv2packedX = yuv2ya16be_X_c;
3045         break;
3046     case AV_PIX_FMT_AYUV64LE:
3047         *yuv2packedX = yuv2ayuv64le_X_c;
3048         break;
3049     }
3050 }