ffmpeg: use opt_acodec when setting audio codec in opt_target.
[ffmpeg.git] / libswscale / swscale.c
1 /*
2  * Copyright (C) 2001-2003 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 /*
22   supported Input formats: YV12, I420/IYUV, YUY2, UYVY, BGR32, BGR32_1, BGR24, BGR16, BGR15, RGB32, RGB32_1, RGB24, Y8/Y800, YVU9/IF09, PAL8
23   supported output formats: YV12, I420/IYUV, YUY2, UYVY, {BGR,RGB}{1,4,8,15,16,24,32}, Y8/Y800, YVU9/IF09
24   {BGR,RGB}{1,4,8,15,16} support dithering
25
26   unscaled special converters (YV12=I420=IYUV, Y800=Y8)
27   YV12 -> {BGR,RGB}{1,4,8,12,15,16,24,32}
28   x -> x
29   YUV9 -> YV12
30   YUV9/YV12 -> Y800
31   Y800 -> YUV9/YV12
32   BGR24 -> BGR32 & RGB24 -> RGB32
33   BGR32 -> BGR24 & RGB32 -> RGB24
34   BGR15 -> BGR16
35 */
36
37 /*
38 tested special converters (most are tested actually, but I did not write it down ...)
39  YV12 -> BGR12/BGR16
40  YV12 -> YV12
41  BGR15 -> BGR16
42  BGR16 -> BGR16
43  YVU9 -> YV12
44
45 untested special converters
46   YV12/I420 -> BGR15/BGR24/BGR32 (it is the yuv2rgb stuff, so it should be OK)
47   YV12/I420 -> YV12/I420
48   YUY2/BGR15/BGR24/BGR32/RGB24/RGB32 -> same format
49   BGR24 -> BGR32 & RGB24 -> RGB32
50   BGR32 -> BGR24 & RGB32 -> RGB24
51   BGR24 -> YV12
52 */
53
54 #include <inttypes.h>
55 #include <string.h>
56 #include <math.h>
57 #include <stdio.h>
58 #include "config.h"
59 #include <assert.h>
60 #include "swscale.h"
61 #include "swscale_internal.h"
62 #include "rgb2rgb.h"
63 #include "libavutil/avassert.h"
64 #include "libavutil/intreadwrite.h"
65 #include "libavutil/x86_cpu.h"
66 #include "libavutil/cpu.h"
67 #include "libavutil/avutil.h"
68 #include "libavutil/mathematics.h"
69 #include "libavutil/bswap.h"
70 #include "libavutil/pixdesc.h"
71
72 #undef MOVNTQ
73 #undef PAVGB
74
75 #define DITHER1XBPP
76
77 #define isPacked(x)         (       \
78            (x)==PIX_FMT_PAL8        \
79         || (x)==PIX_FMT_YUYV422     \
80         || (x)==PIX_FMT_UYVY422     \
81         || (x)==PIX_FMT_GRAY8A       \
82         || isAnyRGB(x)              \
83     )
84
85 #define RGB2YUV_SHIFT 15
86 #define BY ( (int)(0.114*219/255*(1<<RGB2YUV_SHIFT)+0.5))
87 #define BV (-(int)(0.081*224/255*(1<<RGB2YUV_SHIFT)+0.5))
88 #define BU ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
89 #define GY ( (int)(0.587*219/255*(1<<RGB2YUV_SHIFT)+0.5))
90 #define GV (-(int)(0.419*224/255*(1<<RGB2YUV_SHIFT)+0.5))
91 #define GU (-(int)(0.331*224/255*(1<<RGB2YUV_SHIFT)+0.5))
92 #define RY ( (int)(0.299*219/255*(1<<RGB2YUV_SHIFT)+0.5))
93 #define RV ( (int)(0.500*224/255*(1<<RGB2YUV_SHIFT)+0.5))
94 #define RU (-(int)(0.169*224/255*(1<<RGB2YUV_SHIFT)+0.5))
95
96 static const double rgb2yuv_table[8][9]={
97     {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5}, //ITU709
98     {0.7152, 0.0722, 0.2126, -0.386, 0.5, -0.115, -0.454, -0.046, 0.5}, //ITU709
99     {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
100     {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
101     {0.59  , 0.11  , 0.30  , -0.331, 0.5, -0.169, -0.421, -0.079, 0.5}, //FCC
102     {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
103     {0.587 , 0.114 , 0.299 , -0.331, 0.5, -0.169, -0.419, -0.081, 0.5}, //DEFAULT / ITU601 / ITU624 / SMPTE 170M
104     {0.701 , 0.087 , 0.212 , -0.384, 0.5, -0.116, -0.445, -0.055, 0.5}, //SMPTE 240M
105 };
106
107 /*
108 NOTES
109 Special versions: fast Y 1:1 scaling (no interpolation in y direction)
110
111 TODO
112 more intelligent misalignment avoidance for the horizontal scaler
113 write special vertical cubic upscale version
114 optimize C code (YV12 / minmax)
115 add support for packed pixel YUV input & output
116 add support for Y8 output
117 optimize BGR24 & BGR32
118 add BGR4 output support
119 write special BGR->BGR scaler
120 */
121
122 DECLARE_ALIGNED(8, static const uint8_t, dither_2x2_4)[2][8]={
123 {  1,   3,   1,   3,   1,   3,   1,   3, },
124 {  2,   0,   2,   0,   2,   0,   2,   0, },
125 };
126
127 DECLARE_ALIGNED(8, static const uint8_t, dither_2x2_8)[2][8]={
128 {  6,   2,   6,   2,   6,   2,   6,   2, },
129 {  0,   4,   0,   4,   0,   4,   0,   4, },
130 };
131
132 DECLARE_ALIGNED(8, const uint8_t, dither_4x4_16)[4][8]={
133 {  8,   4,  11,   7,   8,   4,  11,   7, },
134 {  2,  14,   1,  13,   2,  14,   1,  13, },
135 { 10,   6,   9,   5,  10,   6,   9,   5, },
136 {  0,  12,   3,  15,   0,  12,   3,  15, },
137 };
138
139 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_32)[8][8]={
140 { 17,   9,  23,  15,  16,   8,  22,  14, },
141 {  5,  29,   3,  27,   4,  28,   2,  26, },
142 { 21,  13,  19,  11,  20,  12,  18,  10, },
143 {  0,  24,   6,  30,   1,  25,   7,  31, },
144 { 16,   8,  22,  14,  17,   9,  23,  15, },
145 {  4,  28,   2,  26,   5,  29,   3,  27, },
146 { 20,  12,  18,  10,  21,  13,  19,  11, },
147 {  1,  25,   7,  31,   0,  24,   6,  30, },
148 };
149
150 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_73)[8][8]={
151 {  0,  55,  14,  68,   3,  58,  17,  72, },
152 { 37,  18,  50,  32,  40,  22,  54,  35, },
153 {  9,  64,   5,  59,  13,  67,   8,  63, },
154 { 46,  27,  41,  23,  49,  31,  44,  26, },
155 {  2,  57,  16,  71,   1,  56,  15,  70, },
156 { 39,  21,  52,  34,  38,  19,  51,  33, },
157 { 11,  66,   7,  62,  10,  65,   6,  60, },
158 { 48,  30,  43,  25,  47,  29,  42,  24, },
159 };
160
161 #if 1
162 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220)[8][8]={
163 {117,  62, 158, 103, 113,  58, 155, 100, },
164 { 34, 199,  21, 186,  31, 196,  17, 182, },
165 {144,  89, 131,  76, 141,  86, 127,  72, },
166 {  0, 165,  41, 206,  10, 175,  52, 217, },
167 {110,  55, 151,  96, 120,  65, 162, 107, },
168 { 28, 193,  14, 179,  38, 203,  24, 189, },
169 {138,  83, 124,  69, 148,  93, 134,  79, },
170 {  7, 172,  48, 213,   3, 168,  45, 210, },
171 };
172 #elif 1
173 // tries to correct a gamma of 1.5
174 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220)[8][8]={
175 {  0, 143,  18, 200,   2, 156,  25, 215, },
176 { 78,  28, 125,  64,  89,  36, 138,  74, },
177 { 10, 180,   3, 161,  16, 195,   8, 175, },
178 {109,  51,  93,  38, 121,  60, 105,  47, },
179 {  1, 152,  23, 210,   0, 147,  20, 205, },
180 { 85,  33, 134,  71,  81,  30, 130,  67, },
181 { 14, 190,   6, 171,  12, 185,   5, 166, },
182 {117,  57, 101,  44, 113,  54,  97,  41, },
183 };
184 #elif 1
185 // tries to correct a gamma of 2.0
186 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220)[8][8]={
187 {  0, 124,   8, 193,   0, 140,  12, 213, },
188 { 55,  14, 104,  42,  66,  19, 119,  52, },
189 {  3, 168,   1, 145,   6, 187,   3, 162, },
190 { 86,  31,  70,  21,  99,  39,  82,  28, },
191 {  0, 134,  11, 206,   0, 129,   9, 200, },
192 { 62,  17, 114,  48,  58,  16, 109,  45, },
193 {  5, 181,   2, 157,   4, 175,   1, 151, },
194 { 95,  36,  78,  26,  90,  34,  74,  24, },
195 };
196 #else
197 // tries to correct a gamma of 2.5
198 DECLARE_ALIGNED(8, const uint8_t, dither_8x8_220)[8][8]={
199 {  0, 107,   3, 187,   0, 125,   6, 212, },
200 { 39,   7,  86,  28,  49,  11, 102,  36, },
201 {  1, 158,   0, 131,   3, 180,   1, 151, },
202 { 68,  19,  52,  12,  81,  25,  64,  17, },
203 {  0, 119,   5, 203,   0, 113,   4, 195, },
204 { 45,   9,  96,  33,  42,   8,  91,  30, },
205 {  2, 172,   1, 144,   2, 165,   0, 137, },
206 { 77,  23,  60,  15,  72,  21,  56,  14, },
207 };
208 #endif
209
210 DECLARE_ALIGNED(8, const uint8_t, dithers)[8][8][8]={
211 {
212   {   0,  1,  0,  1,  0,  1,  0,  1,},
213   {   1,  0,  1,  0,  1,  0,  1,  0,},
214   {   0,  1,  0,  1,  0,  1,  0,  1,},
215   {   1,  0,  1,  0,  1,  0,  1,  0,},
216   {   0,  1,  0,  1,  0,  1,  0,  1,},
217   {   1,  0,  1,  0,  1,  0,  1,  0,},
218   {   0,  1,  0,  1,  0,  1,  0,  1,},
219   {   1,  0,  1,  0,  1,  0,  1,  0,},
220 },{
221   {   1,  2,  1,  2,  1,  2,  1,  2,},
222   {   3,  0,  3,  0,  3,  0,  3,  0,},
223   {   1,  2,  1,  2,  1,  2,  1,  2,},
224   {   3,  0,  3,  0,  3,  0,  3,  0,},
225   {   1,  2,  1,  2,  1,  2,  1,  2,},
226   {   3,  0,  3,  0,  3,  0,  3,  0,},
227   {   1,  2,  1,  2,  1,  2,  1,  2,},
228   {   3,  0,  3,  0,  3,  0,  3,  0,},
229 },{
230   {   2,  4,  3,  5,  2,  4,  3,  5,},
231   {   6,  0,  7,  1,  6,  0,  7,  1,},
232   {   3,  5,  2,  4,  3,  5,  2,  4,},
233   {   7,  1,  6,  0,  7,  1,  6,  0,},
234   {   2,  4,  3,  5,  2,  4,  3,  5,},
235   {   6,  0,  7,  1,  6,  0,  7,  1,},
236   {   3,  5,  2,  4,  3,  5,  2,  4,},
237   {   7,  1,  6,  0,  7,  1,  6,  0,},
238 },{
239   {   4,  8,  7, 11,  4,  8,  7, 11,},
240   {  12,  0, 15,  3, 12,  0, 15,  3,},
241   {   6, 10,  5,  9,  6, 10,  5,  9,},
242   {  14,  2, 13,  1, 14,  2, 13,  1,},
243   {   4,  8,  7, 11,  4,  8,  7, 11,},
244   {  12,  0, 15,  3, 12,  0, 15,  3,},
245   {   6, 10,  5,  9,  6, 10,  5,  9,},
246   {  14,  2, 13,  1, 14,  2, 13,  1,},
247 },{
248   {   9, 17, 15, 23,  8, 16, 14, 22,},
249   {  25,  1, 31,  7, 24,  0, 30,  6,},
250   {  13, 21, 11, 19, 12, 20, 10, 18,},
251   {  29,  5, 27,  3, 28,  4, 26,  2,},
252   {   8, 16, 14, 22,  9, 17, 15, 23,},
253   {  24,  0, 30,  6, 25,  1, 31,  7,},
254   {  12, 20, 10, 18, 13, 21, 11, 19,},
255   {  28,  4, 26,  2, 29,  5, 27,  3,},
256 },{
257   {  18, 34, 30, 46, 17, 33, 29, 45,},
258   {  50,  2, 62, 14, 49,  1, 61, 13,},
259   {  26, 42, 22, 38, 25, 41, 21, 37,},
260   {  58, 10, 54,  6, 57,  9, 53,  5,},
261   {  16, 32, 28, 44, 19, 35, 31, 47,},
262   {  48,  0, 60, 12, 51,  3, 63, 15,},
263   {  24, 40, 20, 36, 27, 43, 23, 39,},
264   {  56,  8, 52,  4, 59, 11, 55,  7,},
265 },{
266   {  18, 34, 30, 46, 17, 33, 29, 45,},
267   {  50,  2, 62, 14, 49,  1, 61, 13,},
268   {  26, 42, 22, 38, 25, 41, 21, 37,},
269   {  58, 10, 54,  6, 57,  9, 53,  5,},
270   {  16, 32, 28, 44, 19, 35, 31, 47,},
271   {  48,  0, 60, 12, 51,  3, 63, 15,},
272   {  24, 40, 20, 36, 27, 43, 23, 39,},
273   {  56,  8, 52,  4, 59, 11, 55,  7,},
274 },{
275   {  36, 68, 60, 92, 34, 66, 58, 90,},
276   { 100,  4,124, 28, 98,  2,122, 26,},
277   {  52, 84, 44, 76, 50, 82, 42, 74,},
278   { 116, 20,108, 12,114, 18,106, 10,},
279   {  32, 64, 56, 88, 38, 70, 62, 94,},
280   {  96,  0,120, 24,102,  6,126, 30,},
281   {  48, 80, 40, 72, 54, 86, 46, 78,},
282   { 112, 16,104,  8,118, 22,110, 14,},
283 }};
284
285 static const uint8_t flat64[8]={64,64,64,64,64,64,64,64};
286
287 uint16_t dither_scale[15][16]={
288 {    2,    3,    3,    5,    5,    5,    5,    5,    5,    5,    5,    5,    5,    5,    5,    5,},
289 {    2,    3,    7,    7,   13,   13,   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,},
290 {    3,    3,    4,   15,   15,   29,   57,   57,   57,  113,  113,  113,  113,  113,  113,  113,},
291 {    3,    4,    4,    5,   31,   31,   61,  121,  241,  241,  241,  241,  481,  481,  481,  481,},
292 {    3,    4,    5,    5,    6,   63,   63,  125,  249,  497,  993,  993,  993,  993,  993, 1985,},
293 {    3,    5,    6,    6,    6,    7,  127,  127,  253,  505, 1009, 2017, 4033, 4033, 4033, 4033,},
294 {    3,    5,    6,    7,    7,    7,    8,  255,  255,  509, 1017, 2033, 4065, 8129,16257,16257,},
295 {    3,    5,    6,    8,    8,    8,    8,    9,  511,  511, 1021, 2041, 4081, 8161,16321,32641,},
296 {    3,    5,    7,    8,    9,    9,    9,    9,   10, 1023, 1023, 2045, 4089, 8177,16353,32705,},
297 {    3,    5,    7,    8,   10,   10,   10,   10,   10,   11, 2047, 2047, 4093, 8185,16369,32737,},
298 {    3,    5,    7,    8,   10,   11,   11,   11,   11,   11,   12, 4095, 4095, 8189,16377,32753,},
299 {    3,    5,    7,    9,   10,   12,   12,   12,   12,   12,   12,   13, 8191, 8191,16381,32761,},
300 {    3,    5,    7,    9,   10,   12,   13,   13,   13,   13,   13,   13,   14,16383,16383,32765,},
301 {    3,    5,    7,    9,   10,   12,   14,   14,   14,   14,   14,   14,   14,   15,32767,32767,},
302 {    3,    5,    7,    9,   11,   12,   14,   15,   15,   15,   15,   15,   15,   15,   16,65535,},
303 };
304
305 static av_always_inline void yuv2yuvX16inC_template(const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
306                                                     const int16_t *chrFilter, const int16_t **chrUSrc,
307                                                     const int16_t **chrVSrc, int chrFilterSize,
308                                                     const int16_t **alpSrc, uint16_t *dest, uint16_t *uDest, uint16_t *vDest, uint16_t *aDest,
309                                                     int dstW, int chrDstW, int big_endian, int output_bits)
310 {
311     //FIXME Optimize (just quickly written not optimized..)
312     int i;
313     int shift = 11 + 16 - output_bits;
314
315 #define output_pixel(pos, val) \
316     if (big_endian) { \
317         if (output_bits == 16) { \
318             AV_WB16(pos, av_clip_uint16(val >> shift)); \
319         } else { \
320             AV_WB16(pos, av_clip_uintp2(val >> shift, output_bits)); \
321         } \
322     } else { \
323         if (output_bits == 16) { \
324             AV_WL16(pos, av_clip_uint16(val >> shift)); \
325         } else { \
326             AV_WL16(pos, av_clip_uintp2(val >> shift, output_bits)); \
327         } \
328     }
329     for (i = 0; i < dstW; i++) {
330         int val = 1 << (26-output_bits);
331         int j;
332
333         for (j = 0; j < lumFilterSize; j++)
334             val += lumSrc[j][i] * lumFilter[j];
335
336         output_pixel(&dest[i], val);
337     }
338
339     if (uDest) {
340         for (i = 0; i < chrDstW; i++) {
341             int u = 1 << (26-output_bits);
342             int v = 1 << (26-output_bits);
343             int j;
344
345             for (j = 0; j < chrFilterSize; j++) {
346                 u += chrUSrc[j][i] * chrFilter[j];
347                 v += chrVSrc[j][i] * chrFilter[j];
348             }
349
350             output_pixel(&uDest[i], u);
351             output_pixel(&vDest[i], v);
352         }
353     }
354
355     if (CONFIG_SWSCALE_ALPHA && aDest) {
356         for (i = 0; i < dstW; i++) {
357             int val = 1 << (26-output_bits);
358             int j;
359
360             for (j = 0; j < lumFilterSize; j++)
361                 val += alpSrc[j][i] * lumFilter[j];
362
363             output_pixel(&aDest[i], val);
364         }
365     }
366 }
367
368 #define yuv2NBPS(bits, BE_LE, is_be) \
369 static void yuv2yuvX ## bits ## BE_LE ## _c(const int16_t *lumFilter, \
370                               const int16_t **lumSrc, int lumFilterSize, \
371                               const int16_t *chrFilter, const int16_t **chrUSrc, \
372                               const int16_t **chrVSrc, \
373                               int chrFilterSize, const int16_t **alpSrc, \
374                               uint16_t *dest, uint16_t *uDest, uint16_t *vDest, \
375                               uint16_t *aDest, int dstW, int chrDstW) \
376 { \
377     yuv2yuvX16inC_template(lumFilter, lumSrc, lumFilterSize, \
378                            chrFilter, chrUSrc, chrVSrc, chrFilterSize, \
379                            alpSrc, \
380                            dest, uDest, vDest, aDest, \
381                            dstW, chrDstW, is_be, bits); \
382 }
383 yuv2NBPS( 9, BE, 1);
384 yuv2NBPS( 9, LE, 0);
385 yuv2NBPS(10, BE, 1);
386 yuv2NBPS(10, LE, 0);
387 yuv2NBPS(16, BE, 1);
388 yuv2NBPS(16, LE, 0);
389
390 static inline void yuv2yuvX16inC(const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
391                                  const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize,
392                                  const int16_t **alpSrc, uint16_t *dest, uint16_t *uDest, uint16_t *vDest, uint16_t *aDest, int dstW, int chrDstW,
393                                  enum PixelFormat dstFormat)
394 {
395     if (isNBPS(dstFormat)) {
396         const int depth = av_pix_fmt_descriptors[dstFormat].comp[0].depth_minus1+1;
397         yuv2yuvX16inC_template(lumFilter, lumSrc, lumFilterSize,
398                               chrFilter, chrUSrc, chrVSrc, chrFilterSize,
399                               alpSrc,
400                               dest, uDest, vDest, aDest,
401                               dstW, chrDstW, isBE(dstFormat), depth);
402     } else {
403         if (isBE(dstFormat)) {
404             yuv2yuvX16inC_template(lumFilter, lumSrc, lumFilterSize,
405                                    chrFilter, chrUSrc, chrVSrc, chrFilterSize,
406                                    alpSrc,
407                                    dest, uDest, vDest, aDest,
408                                    dstW, chrDstW, 1, 16);
409         } else {
410             yuv2yuvX16inC_template(lumFilter, lumSrc, lumFilterSize,
411                                    chrFilter, chrUSrc, chrVSrc, chrFilterSize,
412                                    alpSrc,
413                                    dest, uDest, vDest, aDest,
414                                    dstW, chrDstW, 0, 16);
415         }
416     }
417 }
418
419 static inline void yuv2yuvXinC(const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
420                                const int16_t *chrFilter, const int16_t **chrUSrc,
421                                const int16_t **chrVSrc, int chrFilterSize,
422                                const int16_t **alpSrc, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, uint8_t *aDest, int dstW, int chrDstW,
423                                const uint8_t *lumDither, const uint8_t *chrDither)
424 {
425     //FIXME Optimize (just quickly written not optimized..)
426     int i;
427     for (i=0; i<dstW; i++) {
428         int val = lumDither[i&7] << 12;
429         int j;
430         for (j=0; j<lumFilterSize; j++)
431             val += lumSrc[j][i] * lumFilter[j];
432
433         dest[i]= av_clip_uint8(val>>19);
434     }
435
436     if (uDest)
437         for (i=0; i<chrDstW; i++) {
438             int u = chrDither[i&7] << 12;
439             int v = chrDither[(i+3)&7] << 12;
440             int j;
441             for (j=0; j<chrFilterSize; j++) {
442                 u += chrUSrc[j][i] * chrFilter[j];
443                 v += chrVSrc[j][i] * chrFilter[j];
444             }
445
446             uDest[i]= av_clip_uint8(u>>19);
447             vDest[i]= av_clip_uint8(v>>19);
448         }
449
450     if (CONFIG_SWSCALE_ALPHA && aDest)
451         for (i=0; i<dstW; i++) {
452             int val = lumDither[i&7] << 12;
453             int j;
454             for (j=0; j<lumFilterSize; j++)
455                 val += alpSrc[j][i] * lumFilter[j];
456
457             aDest[i]= av_clip_uint8(val>>19);
458         }
459
460 }
461
462 static inline void yuv2nv12XinC(const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize,
463                                 const int16_t *chrFilter, const int16_t **chrUSrc,
464                                 const int16_t **chrVSrc, int chrFilterSize,
465                                 uint8_t *dest, uint8_t *uDest, int dstW, int chrDstW, int dstFormat,
466                                 const uint8_t *lumDither, const uint8_t *chrDither)
467 {
468     //FIXME Optimize (just quickly written not optimized..)
469     int i;
470     for (i=0; i<dstW; i++) {
471         int val = lumDither[i&7]<<12;
472         int j;
473         for (j=0; j<lumFilterSize; j++)
474             val += lumSrc[j][i] * lumFilter[j];
475
476         dest[i]= av_clip_uint8(val>>19);
477     }
478
479     if (!uDest)
480         return;
481
482     if (dstFormat == PIX_FMT_NV12)
483         for (i=0; i<chrDstW; i++) {
484             int u = chrDither[i&7]<<12;
485             int v = chrDither[(i+3)&7]<<12;
486             int j;
487             for (j=0; j<chrFilterSize; j++) {
488                 u += chrUSrc[j][i] * chrFilter[j];
489                 v += chrVSrc[j][i] * chrFilter[j];
490             }
491
492             uDest[2*i]= av_clip_uint8(u>>19);
493             uDest[2*i+1]= av_clip_uint8(v>>19);
494         }
495     else
496         for (i=0; i<chrDstW; i++) {
497             int u = chrDither[i&7]<<12;
498             int v = chrDither[(i+3)&7]<<12;
499             int j;
500             for (j=0; j<chrFilterSize; j++) {
501                 u += chrUSrc[j][i] * chrFilter[j];
502                 v += chrVSrc[j][i] * chrFilter[j];
503             }
504
505             uDest[2*i]= av_clip_uint8(v>>19);
506             uDest[2*i+1]= av_clip_uint8(u>>19);
507         }
508 }
509
510 #define YSCALE_YUV_2_PACKEDX_NOCLIP_C(type,alpha) \
511     for (i=0; i<(dstW>>1); i++) {\
512         int j;\
513         int Y1 = 1<<18;\
514         int Y2 = 1<<18;\
515         int U  = 1<<18;\
516         int V  = 1<<18;\
517         int av_unused A1, A2;\
518         type av_unused *r, *b, *g;\
519         const int i2= 2*i;\
520         \
521         for (j=0; j<lumFilterSize; j++) {\
522             Y1 += lumSrc[j][i2] * lumFilter[j];\
523             Y2 += lumSrc[j][i2+1] * lumFilter[j];\
524         }\
525         for (j=0; j<chrFilterSize; j++) {\
526             U += chrUSrc[j][i] * chrFilter[j];\
527             V += chrVSrc[j][i] * chrFilter[j];\
528         }\
529         Y1>>=19;\
530         Y2>>=19;\
531         U >>=19;\
532         V >>=19;\
533         if (alpha) {\
534             A1 = 1<<18;\
535             A2 = 1<<18;\
536             for (j=0; j<lumFilterSize; j++) {\
537                 A1 += alpSrc[j][i2  ] * lumFilter[j];\
538                 A2 += alpSrc[j][i2+1] * lumFilter[j];\
539             }\
540             A1>>=19;\
541             A2>>=19;\
542         }
543
544 #define YSCALE_YUV_2_PACKEDX_C(type,alpha) \
545         YSCALE_YUV_2_PACKEDX_NOCLIP_C(type,alpha)\
546         if ((Y1|Y2|U|V)&256) {\
547             if (Y1>255)   Y1=255; \
548             else if (Y1<0)Y1=0;   \
549             if (Y2>255)   Y2=255; \
550             else if (Y2<0)Y2=0;   \
551             if (U>255)    U=255;  \
552             else if (U<0) U=0;    \
553             if (V>255)    V=255;  \
554             else if (V<0) V=0;    \
555         }\
556         if (alpha && ((A1|A2)&256)) {\
557             A1=av_clip_uint8(A1);\
558             A2=av_clip_uint8(A2);\
559         }
560
561 #define YSCALE_YUV_2_PACKEDX_FULL_C(rnd,alpha) \
562     for (i=0; i<dstW; i++) {\
563         int j;\
564         int Y = 1<<9;\
565         int U = (1<<9)-(128<<19);\
566         int V = (1<<9)-(128<<19);\
567         int av_unused A;\
568         int R,G,B;\
569         \
570         for (j=0; j<lumFilterSize; j++) {\
571             Y += lumSrc[j][i     ] * lumFilter[j];\
572         }\
573         for (j=0; j<chrFilterSize; j++) {\
574             U += chrUSrc[j][i] * chrFilter[j];\
575             V += chrVSrc[j][i] * chrFilter[j];\
576         }\
577         Y >>=10;\
578         U >>=10;\
579         V >>=10;\
580         if (alpha) {\
581             A = rnd;\
582             for (j=0; j<lumFilterSize; j++)\
583                 A += alpSrc[j][i     ] * lumFilter[j];\
584             A >>=19;\
585             if (A&256)\
586                 A = av_clip_uint8(A);\
587         }
588
589 #define YSCALE_YUV_2_RGBX_FULL_C(rnd,alpha) \
590     YSCALE_YUV_2_PACKEDX_FULL_C(rnd>>3,alpha)\
591         Y-= c->yuv2rgb_y_offset;\
592         Y*= c->yuv2rgb_y_coeff;\
593         Y+= rnd;\
594         R= Y + V*c->yuv2rgb_v2r_coeff;\
595         G= Y + V*c->yuv2rgb_v2g_coeff + U*c->yuv2rgb_u2g_coeff;\
596         B= Y +                          U*c->yuv2rgb_u2b_coeff;\
597         if ((R|G|B)&(0xC0000000)) {\
598             if (R>=(256<<22))   R=(256<<22)-1; \
599             else if (R<0)R=0;   \
600             if (G>=(256<<22))   G=(256<<22)-1; \
601             else if (G<0)G=0;   \
602             if (B>=(256<<22))   B=(256<<22)-1; \
603             else if (B<0)B=0;   \
604         }
605
606 #define YSCALE_YUV_2_GRAY16_C \
607     for (i=0; i<(dstW>>1); i++) {\
608         int j;\
609         int Y1 = 1<<18;\
610         int Y2 = 1<<18;\
611         int U  = 1<<18;\
612         int V  = 1<<18;\
613         \
614         const int i2= 2*i;\
615         \
616         for (j=0; j<lumFilterSize; j++) {\
617             Y1 += lumSrc[j][i2] * lumFilter[j];\
618             Y2 += lumSrc[j][i2+1] * lumFilter[j];\
619         }\
620         Y1>>=11;\
621         Y2>>=11;\
622         if ((Y1|Y2|U|V)&65536) {\
623             if (Y1>65535)   Y1=65535; \
624             else if (Y1<0)Y1=0;   \
625             if (Y2>65535)   Y2=65535; \
626             else if (Y2<0)Y2=0;   \
627         }
628
629 #define YSCALE_YUV_2_RGBX_C(type,alpha) \
630     YSCALE_YUV_2_PACKEDX_C(type,alpha)  /* FIXME fix tables so that clipping is not needed and then use _NOCLIP*/\
631     r = (type *)c->table_rV[V];   \
632     g = (type *)(c->table_gU[U] + c->table_gV[V]); \
633     b = (type *)c->table_bU[U];
634
635 #define YSCALE_YUV_2_PACKED2_C(type,alpha)   \
636     for (i=0; i<(dstW>>1); i++) { \
637         const int i2= 2*i;       \
638         int Y1= (buf0[i2  ]*yalpha1+buf1[i2  ]*yalpha)>>19;           \
639         int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>19;           \
640         int U= (ubuf0[i]*uvalpha1+ubuf1[i]*uvalpha)>>19;              \
641         int V= (vbuf0[i]*uvalpha1+vbuf1[i]*uvalpha)>>19;              \
642         type av_unused *r, *b, *g;                                    \
643         int av_unused A1, A2;                                         \
644         if (alpha) {\
645             A1= (abuf0[i2  ]*yalpha1+abuf1[i2  ]*yalpha)>>19;         \
646             A2= (abuf0[i2+1]*yalpha1+abuf1[i2+1]*yalpha)>>19;         \
647         }
648
649 #define YSCALE_YUV_2_GRAY16_2_C   \
650     for (i=0; i<(dstW>>1); i++) { \
651         const int i2= 2*i;       \
652         int Y1= (buf0[i2  ]*yalpha1+buf1[i2  ]*yalpha)>>11;           \
653         int Y2= (buf0[i2+1]*yalpha1+buf1[i2+1]*yalpha)>>11;
654
655 #define YSCALE_YUV_2_RGB2_C(type,alpha) \
656     YSCALE_YUV_2_PACKED2_C(type,alpha)\
657     r = (type *)c->table_rV[V];\
658     g = (type *)(c->table_gU[U] + c->table_gV[V]);\
659     b = (type *)c->table_bU[U];
660
661 #define YSCALE_YUV_2_PACKED1_C(type,alpha) \
662     for (i=0; i<(dstW>>1); i++) {\
663         const int i2= 2*i;\
664         int Y1= buf0[i2  ]>>7;\
665         int Y2= buf0[i2+1]>>7;\
666         int U= (ubuf1[i])>>7;\
667         int V= (vbuf1[i])>>7;\
668         type av_unused *r, *b, *g;\
669         int av_unused A1, A2;\
670         if (alpha) {\
671             A1= abuf0[i2  ]>>7;\
672             A2= abuf0[i2+1]>>7;\
673         }
674
675 #define YSCALE_YUV_2_GRAY16_1_C \
676     for (i=0; i<(dstW>>1); i++) {\
677         const int i2= 2*i;\
678         int Y1= buf0[i2  ]<<1;\
679         int Y2= buf0[i2+1]<<1;
680
681 #define YSCALE_YUV_2_RGB1_C(type,alpha) \
682     YSCALE_YUV_2_PACKED1_C(type,alpha)\
683     r = (type *)c->table_rV[V];\
684     g = (type *)(c->table_gU[U] + c->table_gV[V]);\
685     b = (type *)c->table_bU[U];
686
687 #define YSCALE_YUV_2_PACKED1B_C(type,alpha) \
688     for (i=0; i<(dstW>>1); i++) {\
689         const int i2= 2*i;\
690         int Y1= buf0[i2  ]>>7;\
691         int Y2= buf0[i2+1]>>7;\
692         int U= (ubuf0[i] + ubuf1[i])>>8;\
693         int V= (vbuf0[i] + vbuf1[i])>>8;\
694         type av_unused *r, *b, *g;\
695         int av_unused A1, A2;\
696         if (alpha) {\
697             A1= abuf0[i2  ]>>7;\
698             A2= abuf0[i2+1]>>7;\
699         }
700
701 #define YSCALE_YUV_2_RGB1B_C(type,alpha) \
702     YSCALE_YUV_2_PACKED1B_C(type,alpha)\
703     r = (type *)c->table_rV[V];\
704     g = (type *)(c->table_gU[U] + c->table_gV[V]);\
705     b = (type *)c->table_bU[U];
706
707 #define YSCALE_YUV_2_MONO2_C \
708     const uint8_t * const d128=dither_8x8_220[y&7];\
709     uint8_t *g= c->table_gU[128] + c->table_gV[128];\
710     for (i=0; i<dstW-7; i+=8) {\
711         int acc;\
712         acc =       g[((buf0[i  ]*yalpha1+buf1[i  ]*yalpha)>>19) + d128[0]];\
713         acc+= acc + g[((buf0[i+1]*yalpha1+buf1[i+1]*yalpha)>>19) + d128[1]];\
714         acc+= acc + g[((buf0[i+2]*yalpha1+buf1[i+2]*yalpha)>>19) + d128[2]];\
715         acc+= acc + g[((buf0[i+3]*yalpha1+buf1[i+3]*yalpha)>>19) + d128[3]];\
716         acc+= acc + g[((buf0[i+4]*yalpha1+buf1[i+4]*yalpha)>>19) + d128[4]];\
717         acc+= acc + g[((buf0[i+5]*yalpha1+buf1[i+5]*yalpha)>>19) + d128[5]];\
718         acc+= acc + g[((buf0[i+6]*yalpha1+buf1[i+6]*yalpha)>>19) + d128[6]];\
719         acc+= acc + g[((buf0[i+7]*yalpha1+buf1[i+7]*yalpha)>>19) + d128[7]];\
720         ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
721         dest++;\
722     }
723
724 #define YSCALE_YUV_2_MONOX_C \
725     const uint8_t * const d128=dither_8x8_220[y&7];\
726     uint8_t *g= c->table_gU[128] + c->table_gV[128];\
727     int acc=0;\
728     for (i=0; i<dstW-1; i+=2) {\
729         int j;\
730         int Y1=1<<18;\
731         int Y2=1<<18;\
732 \
733         for (j=0; j<lumFilterSize; j++) {\
734             Y1 += lumSrc[j][i] * lumFilter[j];\
735             Y2 += lumSrc[j][i+1] * lumFilter[j];\
736         }\
737         Y1>>=19;\
738         Y2>>=19;\
739         if ((Y1|Y2)&256) {\
740             if (Y1>255)   Y1=255;\
741             else if (Y1<0)Y1=0;\
742             if (Y2>255)   Y2=255;\
743             else if (Y2<0)Y2=0;\
744         }\
745         acc+= acc + g[Y1+d128[(i+0)&7]];\
746         acc+= acc + g[Y2+d128[(i+1)&7]];\
747         if ((i&7)==6) {\
748             ((uint8_t*)dest)[0]= c->dstFormat == PIX_FMT_MONOBLACK ? acc : ~acc;\
749             dest++;\
750         }\
751     }
752
753 #define YSCALE_YUV_2_ANYRGB_C(func, func2, func_g16, func_monoblack)\
754     switch(c->dstFormat) {\
755     case PIX_FMT_RGB48BE:\
756     case PIX_FMT_RGB48LE:\
757         func(uint8_t,0)\
758             ((uint8_t*)dest)[ 0]= r[Y1];\
759             ((uint8_t*)dest)[ 1]= r[Y1];\
760             ((uint8_t*)dest)[ 2]= g[Y1];\
761             ((uint8_t*)dest)[ 3]= g[Y1];\
762             ((uint8_t*)dest)[ 4]= b[Y1];\
763             ((uint8_t*)dest)[ 5]= b[Y1];\
764             ((uint8_t*)dest)[ 6]= r[Y2];\
765             ((uint8_t*)dest)[ 7]= r[Y2];\
766             ((uint8_t*)dest)[ 8]= g[Y2];\
767             ((uint8_t*)dest)[ 9]= g[Y2];\
768             ((uint8_t*)dest)[10]= b[Y2];\
769             ((uint8_t*)dest)[11]= b[Y2];\
770             dest+=12;\
771         }\
772         break;\
773     case PIX_FMT_BGR48BE:\
774     case PIX_FMT_BGR48LE:\
775         func(uint8_t,0)\
776             ((uint8_t*)dest)[ 0] = ((uint8_t*)dest)[ 1] = b[Y1];\
777             ((uint8_t*)dest)[ 2] = ((uint8_t*)dest)[ 3] = g[Y1];\
778             ((uint8_t*)dest)[ 4] = ((uint8_t*)dest)[ 5] = r[Y1];\
779             ((uint8_t*)dest)[ 6] = ((uint8_t*)dest)[ 7] = b[Y2];\
780             ((uint8_t*)dest)[ 8] = ((uint8_t*)dest)[ 9] = g[Y2];\
781             ((uint8_t*)dest)[10] = ((uint8_t*)dest)[11] = r[Y2];\
782             dest+=12;\
783         }\
784         break;\
785     case PIX_FMT_RGBA:\
786     case PIX_FMT_BGRA:\
787         if (CONFIG_SMALL) {\
788             int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;\
789             func(uint32_t,needAlpha)\
790                 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (needAlpha ? (A1<<24) : 0);\
791                 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (needAlpha ? (A2<<24) : 0);\
792             }\
793         } else {\
794             if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {\
795                 func(uint32_t,1)\
796                     ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (A1<<24);\
797                     ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (A2<<24);\
798                 }\
799             } else {\
800                 func(uint32_t,0)\
801                     ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
802                     ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
803                 }\
804             }\
805         }\
806         break;\
807     case PIX_FMT_ARGB:\
808     case PIX_FMT_ABGR:\
809         if (CONFIG_SMALL) {\
810             int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;\
811             func(uint32_t,needAlpha)\
812                 ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + (needAlpha ? A1 : 0);\
813                 ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + (needAlpha ? A2 : 0);\
814             }\
815         } else {\
816             if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {\
817                 func(uint32_t,1)\
818                     ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1] + A1;\
819                     ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2] + A2;\
820                 }\
821             } else {\
822                 func(uint32_t,0)\
823                     ((uint32_t*)dest)[i2+0]= r[Y1] + g[Y1] + b[Y1];\
824                     ((uint32_t*)dest)[i2+1]= r[Y2] + g[Y2] + b[Y2];\
825                 }\
826             }\
827         }                \
828         break;\
829     case PIX_FMT_RGB24:\
830         func(uint8_t,0)\
831             ((uint8_t*)dest)[0]= r[Y1];\
832             ((uint8_t*)dest)[1]= g[Y1];\
833             ((uint8_t*)dest)[2]= b[Y1];\
834             ((uint8_t*)dest)[3]= r[Y2];\
835             ((uint8_t*)dest)[4]= g[Y2];\
836             ((uint8_t*)dest)[5]= b[Y2];\
837             dest+=6;\
838         }\
839         break;\
840     case PIX_FMT_BGR24:\
841         func(uint8_t,0)\
842             ((uint8_t*)dest)[0]= b[Y1];\
843             ((uint8_t*)dest)[1]= g[Y1];\
844             ((uint8_t*)dest)[2]= r[Y1];\
845             ((uint8_t*)dest)[3]= b[Y2];\
846             ((uint8_t*)dest)[4]= g[Y2];\
847             ((uint8_t*)dest)[5]= r[Y2];\
848             dest+=6;\
849         }\
850         break;\
851     case PIX_FMT_RGB565BE:\
852     case PIX_FMT_RGB565LE:\
853     case PIX_FMT_BGR565BE:\
854     case PIX_FMT_BGR565LE:\
855         {\
856             const int dr1= dither_2x2_8[y&1    ][0];\
857             const int dg1= dither_2x2_4[y&1    ][0];\
858             const int db1= dither_2x2_8[(y&1)^1][0];\
859             const int dr2= dither_2x2_8[y&1    ][1];\
860             const int dg2= dither_2x2_4[y&1    ][1];\
861             const int db2= dither_2x2_8[(y&1)^1][1];\
862             func(uint16_t,0)\
863                 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
864                 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
865             }\
866         }\
867         break;\
868     case PIX_FMT_RGB555BE:\
869     case PIX_FMT_RGB555LE:\
870     case PIX_FMT_BGR555BE:\
871     case PIX_FMT_BGR555LE:\
872         {\
873             const int dr1= dither_2x2_8[y&1    ][0];\
874             const int dg1= dither_2x2_8[y&1    ][1];\
875             const int db1= dither_2x2_8[(y&1)^1][0];\
876             const int dr2= dither_2x2_8[y&1    ][1];\
877             const int dg2= dither_2x2_8[y&1    ][0];\
878             const int db2= dither_2x2_8[(y&1)^1][1];\
879             func(uint16_t,0)\
880                 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
881                 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
882             }\
883         }\
884         break;\
885     case PIX_FMT_RGB444BE:\
886     case PIX_FMT_RGB444LE:\
887     case PIX_FMT_BGR444BE:\
888     case PIX_FMT_BGR444LE:\
889         {\
890             const int dr1= dither_4x4_16[y&3    ][0];\
891             const int dg1= dither_4x4_16[y&3    ][1];\
892             const int db1= dither_4x4_16[(y&3)^3][0];\
893             const int dr2= dither_4x4_16[y&3    ][1];\
894             const int dg2= dither_4x4_16[y&3    ][0];\
895             const int db2= dither_4x4_16[(y&3)^3][1];\
896             func(uint16_t,0)\
897                 ((uint16_t*)dest)[i2+0]= r[Y1+dr1] + g[Y1+dg1] + b[Y1+db1];\
898                 ((uint16_t*)dest)[i2+1]= r[Y2+dr2] + g[Y2+dg2] + b[Y2+db2];\
899             }\
900         }\
901         break;\
902     case PIX_FMT_RGB8:\
903     case PIX_FMT_BGR8:\
904         {\
905             const uint8_t * const d64= dither_8x8_73[y&7];\
906             const uint8_t * const d32= dither_8x8_32[y&7];\
907             func(uint8_t,0)\
908                 ((uint8_t*)dest)[i2+0]= r[Y1+d32[(i2+0)&7]] + g[Y1+d32[(i2+0)&7]] + b[Y1+d64[(i2+0)&7]];\
909                 ((uint8_t*)dest)[i2+1]= r[Y2+d32[(i2+1)&7]] + g[Y2+d32[(i2+1)&7]] + b[Y2+d64[(i2+1)&7]];\
910             }\
911         }\
912         break;\
913     case PIX_FMT_RGB4:\
914     case PIX_FMT_BGR4:\
915         {\
916             const uint8_t * const d64= dither_8x8_73 [y&7];\
917             const uint8_t * const d128=dither_8x8_220[y&7];\
918             func(uint8_t,0)\
919                 ((uint8_t*)dest)[i]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]]\
920                                  + ((r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]])<<4);\
921             }\
922         }\
923         break;\
924     case PIX_FMT_RGB4_BYTE:\
925     case PIX_FMT_BGR4_BYTE:\
926         {\
927             const uint8_t * const d64= dither_8x8_73 [y&7];\
928             const uint8_t * const d128=dither_8x8_220[y&7];\
929             func(uint8_t,0)\
930                 ((uint8_t*)dest)[i2+0]= r[Y1+d128[(i2+0)&7]] + g[Y1+d64[(i2+0)&7]] + b[Y1+d128[(i2+0)&7]];\
931                 ((uint8_t*)dest)[i2+1]= r[Y2+d128[(i2+1)&7]] + g[Y2+d64[(i2+1)&7]] + b[Y2+d128[(i2+1)&7]];\
932             }\
933         }\
934         break;\
935     case PIX_FMT_MONOBLACK:\
936     case PIX_FMT_MONOWHITE:\
937         {\
938             func_monoblack\
939         }\
940         break;\
941     case PIX_FMT_YUYV422:\
942         func2\
943             ((uint8_t*)dest)[2*i2+0]= Y1;\
944             ((uint8_t*)dest)[2*i2+1]= U;\
945             ((uint8_t*)dest)[2*i2+2]= Y2;\
946             ((uint8_t*)dest)[2*i2+3]= V;\
947         }                \
948         break;\
949     case PIX_FMT_UYVY422:\
950         func2\
951             ((uint8_t*)dest)[2*i2+0]= U;\
952             ((uint8_t*)dest)[2*i2+1]= Y1;\
953             ((uint8_t*)dest)[2*i2+2]= V;\
954             ((uint8_t*)dest)[2*i2+3]= Y2;\
955         }                \
956         break;\
957     case PIX_FMT_GRAY16BE:\
958         func_g16\
959             ((uint8_t*)dest)[2*i2+0]= Y1>>8;\
960             ((uint8_t*)dest)[2*i2+1]= Y1;\
961             ((uint8_t*)dest)[2*i2+2]= Y2>>8;\
962             ((uint8_t*)dest)[2*i2+3]= Y2;\
963         }                \
964         break;\
965     case PIX_FMT_GRAY16LE:\
966         func_g16\
967             ((uint8_t*)dest)[2*i2+0]= Y1;\
968             ((uint8_t*)dest)[2*i2+1]= Y1>>8;\
969             ((uint8_t*)dest)[2*i2+2]= Y2;\
970             ((uint8_t*)dest)[2*i2+3]= Y2>>8;\
971         }                \
972         break;\
973     }
974
975 static inline void yuv2packedXinC(SwsContext *c, const int16_t *lumFilter,
976                                   const int16_t **lumSrc, int lumFilterSize,
977                                   const int16_t *chrFilter, const int16_t **chrUSrc,
978                                   const int16_t **chrVSrc, int chrFilterSize,
979                                   const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
980 {
981     int i;
982     YSCALE_YUV_2_ANYRGB_C(YSCALE_YUV_2_RGBX_C, YSCALE_YUV_2_PACKEDX_C(void,0), YSCALE_YUV_2_GRAY16_C, YSCALE_YUV_2_MONOX_C)
983 }
984
985 static inline void yuv2rgbXinC_full(SwsContext *c, const int16_t *lumFilter,
986                                     const int16_t **lumSrc, int lumFilterSize,
987                                     const int16_t *chrFilter, const int16_t **chrUSrc,
988                                     const int16_t **chrVSrc, int chrFilterSize,
989                                     const int16_t **alpSrc, uint8_t *dest, int dstW, int y)
990 {
991     int i;
992     int step= c->dstFormatBpp/8;
993     int aidx= 3;
994
995     switch(c->dstFormat) {
996     case PIX_FMT_ARGB:
997         dest++;
998         aidx= 0;
999     case PIX_FMT_RGB24:
1000         aidx--;
1001     case PIX_FMT_RGBA:
1002         if (CONFIG_SMALL) {
1003             int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;
1004             YSCALE_YUV_2_RGBX_FULL_C(1<<21, needAlpha)
1005                 dest[aidx]= needAlpha ? A : 255;
1006                 dest[0]= R>>22;
1007                 dest[1]= G>>22;
1008                 dest[2]= B>>22;
1009                 dest+= step;
1010             }
1011         } else {
1012             if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
1013                 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 1)
1014                     dest[aidx]= A;
1015                     dest[0]= R>>22;
1016                     dest[1]= G>>22;
1017                     dest[2]= B>>22;
1018                     dest+= step;
1019                 }
1020             } else {
1021                 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 0)
1022                     dest[aidx]= 255;
1023                     dest[0]= R>>22;
1024                     dest[1]= G>>22;
1025                     dest[2]= B>>22;
1026                     dest+= step;
1027                 }
1028             }
1029         }
1030         break;
1031     case PIX_FMT_ABGR:
1032         dest++;
1033         aidx= 0;
1034     case PIX_FMT_BGR24:
1035         aidx--;
1036     case PIX_FMT_BGRA:
1037         if (CONFIG_SMALL) {
1038             int needAlpha = CONFIG_SWSCALE_ALPHA && c->alpPixBuf;
1039             YSCALE_YUV_2_RGBX_FULL_C(1<<21, needAlpha)
1040                 dest[aidx]= needAlpha ? A : 255;
1041                 dest[0]= B>>22;
1042                 dest[1]= G>>22;
1043                 dest[2]= R>>22;
1044                 dest+= step;
1045             }
1046         } else {
1047             if (CONFIG_SWSCALE_ALPHA && c->alpPixBuf) {
1048                 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 1)
1049                     dest[aidx]= A;
1050                     dest[0]= B>>22;
1051                     dest[1]= G>>22;
1052                     dest[2]= R>>22;
1053                     dest+= step;
1054                 }
1055             } else {
1056                 YSCALE_YUV_2_RGBX_FULL_C(1<<21, 0)
1057                     dest[aidx]= 255;
1058                     dest[0]= B>>22;
1059                     dest[1]= G>>22;
1060                     dest[2]= R>>22;
1061                     dest+= step;
1062                 }
1063             }
1064         }
1065         break;
1066     default:
1067         assert(0);
1068     }
1069 }
1070
1071 static void fillPlane(uint8_t* plane, int stride, int width, int height, int y, uint8_t val)
1072 {
1073     int i;
1074     uint8_t *ptr = plane + stride*y;
1075     for (i=0; i<height; i++) {
1076         memset(ptr, val, width);
1077         ptr += stride;
1078     }
1079 }
1080
1081 #define RGB48(name, R, B, READ)\
1082 static inline void name ## ToY(int16_t *dst, const uint16_t *src, int width, uint32_t *unused)\
1083 {\
1084     int i;\
1085     for (i = 0; i < width; i++) {\
1086         int r = READ(&src[i*3+R]);\
1087         int g = READ(&src[i*3+1]);\
1088         int b = READ(&src[i*3+B]);\
1089 \
1090         dst[i] = (RY*r + GY*g + BY*b + (32<<(RGB2YUV_SHIFT-1+8)) + (1<<(RGB2YUV_SHIFT-7+8))) >> (RGB2YUV_SHIFT-6+8);\
1091     }\
1092 }\
1093 \
1094 static inline void name ## ToUV(int16_t *dstU, int16_t *dstV,\
1095                              const uint16_t *src1, const uint16_t *src2,\
1096                              int width, uint32_t *unused)\
1097 {\
1098     int i;\
1099     assert(src1==src2);\
1100     for (i = 0; i < width; i++) {\
1101         int r = READ(&src1[3*i + R]);\
1102         int g = READ(&src1[3*i + 1]);\
1103         int b = READ(&src1[3*i + B]);\
1104 \
1105         dstU[i] = (RU*r + GU*g + BU*b + (256<<(RGB2YUV_SHIFT-1+8)) + (1<<(RGB2YUV_SHIFT-7+8))) >> (RGB2YUV_SHIFT-6+8);\
1106         dstV[i] = (RV*r + GV*g + BV*b + (256<<(RGB2YUV_SHIFT-1+8)) + (1<<(RGB2YUV_SHIFT-7+8))) >> (RGB2YUV_SHIFT-6+8);\
1107     }\
1108 }\
1109 \
1110 static inline void name ## ToUV_half(int16_t *dstU, int16_t *dstV,\
1111                                   const uint16_t *src1, const uint16_t *src2,\
1112                                   int width, uint32_t *unused)\
1113 {\
1114     int i;\
1115     assert(src1==src2);\
1116     for (i = 0; i < width; i++) {\
1117         int r= READ(&src1[6*i + R]) + READ(&src1[6*i + 3+R]);\
1118         int g= READ(&src1[6*i + 1]) + READ(&src1[6*i + 4]);\
1119         int b= READ(&src1[6*i + B]) + READ(&src1[6*i + 3+B]);\
1120 \
1121         dstU[i]= (RU*r + GU*g + BU*b + (256U<<(RGB2YUV_SHIFT+8)) + (1<<(RGB2YUV_SHIFT-6+8))) >> (RGB2YUV_SHIFT-5+8);\
1122         dstV[i]= (RV*r + GV*g + BV*b + (256U<<(RGB2YUV_SHIFT+8)) + (1<<(RGB2YUV_SHIFT-6+8))) >> (RGB2YUV_SHIFT-5+8);\
1123     }\
1124 }
1125
1126 RGB48(rgb48LE, 0, 2, AV_RL16)
1127 RGB48(rgb48BE, 0, 2, AV_RB16)
1128 RGB48(bgr48LE, 2, 0, AV_RL16)
1129 RGB48(bgr48BE, 2, 0, AV_RB16)
1130
1131 #define BGR2Y(type, name, shr, shg, shb, maskr, maskg, maskb, RY, GY, BY, S)\
1132 static inline void name(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)\
1133 {\
1134     int i;\
1135     for (i=0; i<width; i++) {\
1136         int b= (((const type*)src)[i]>>shb)&maskb;\
1137         int g= (((const type*)src)[i]>>shg)&maskg;\
1138         int r= (((const type*)src)[i]>>shr)&maskr;\
1139 \
1140         dst[i]= (((RY)*r + (GY)*g + (BY)*b + (32<<((S)-1)) + (1<<(S-7)))>>((S)-6));\
1141     }\
1142 }
1143
1144 BGR2Y(uint32_t, bgr32ToY,16, 0, 0, 0x00FF, 0xFF00, 0x00FF, RY<< 8, GY   , BY<< 8, RGB2YUV_SHIFT+8)
1145 BGR2Y(uint32_t,bgr321ToY,16,16, 0, 0xFF00, 0x00FF, 0xFF00, RY    , GY<<8, BY    , RGB2YUV_SHIFT+8)
1146 BGR2Y(uint32_t, rgb32ToY, 0, 0,16, 0x00FF, 0xFF00, 0x00FF, RY<< 8, GY   , BY<< 8, RGB2YUV_SHIFT+8)
1147 BGR2Y(uint32_t,rgb321ToY, 0,16,16, 0xFF00, 0x00FF, 0xFF00, RY    , GY<<8, BY    , RGB2YUV_SHIFT+8)
1148 BGR2Y(uint16_t, bgr16ToY, 0, 0, 0, 0x001F, 0x07E0, 0xF800, RY<<11, GY<<5, BY    , RGB2YUV_SHIFT+8)
1149 BGR2Y(uint16_t, bgr15ToY, 0, 0, 0, 0x001F, 0x03E0, 0x7C00, RY<<10, GY<<5, BY    , RGB2YUV_SHIFT+7)
1150 BGR2Y(uint16_t, rgb16ToY, 0, 0, 0, 0xF800, 0x07E0, 0x001F, RY    , GY<<5, BY<<11, RGB2YUV_SHIFT+8)
1151 BGR2Y(uint16_t, rgb15ToY, 0, 0, 0, 0x7C00, 0x03E0, 0x001F, RY    , GY<<5, BY<<10, RGB2YUV_SHIFT+7)
1152
1153 static inline void abgrToA(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
1154 {
1155     int i;
1156     for (i=0; i<width; i++) {
1157         dst[i]= src[4*i]<<6;
1158     }
1159 }
1160
1161 #define BGR2UV(type, name, shr, shg, shb, shp, maskr, maskg, maskb, RU, GU, BU, RV, GV, BV, S) \
1162 static inline void name(int16_t *dstU, int16_t *dstV, const uint8_t *src, const uint8_t *dummy, int width, uint32_t *unused)\
1163 {\
1164     int i;\
1165     for (i=0; i<width; i++) {\
1166         int b= ((((const type*)src)[i]>>shp)&maskb)>>shb;\
1167         int g= ((((const type*)src)[i]>>shp)&maskg)>>shg;\
1168         int r= ((((const type*)src)[i]>>shp)&maskr)>>shr;\
1169 \
1170         dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (256<<((S)-1)) + (1<<(S-7)))>>((S)-6);\
1171         dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (256<<((S)-1)) + (1<<(S-7)))>>((S)-6);\
1172     }\
1173 }\
1174 static inline void name ## _half(int16_t *dstU, int16_t *dstV, const uint8_t *src, const uint8_t *dummy, int width, uint32_t *unused)\
1175 {\
1176     int i;\
1177     for (i=0; i<width; i++) {\
1178         int pix0= ((const type*)src)[2*i+0]>>shp;\
1179         int pix1= ((const type*)src)[2*i+1]>>shp;\
1180         int g= (pix0&~(maskr|maskb))+(pix1&~(maskr|maskb));\
1181         int b= ((pix0+pix1-g)&(maskb|(2*maskb)))>>shb;\
1182         int r= ((pix0+pix1-g)&(maskr|(2*maskr)))>>shr;\
1183         g&= maskg|(2*maskg);\
1184 \
1185         g>>=shg;\
1186 \
1187         dstU[i]= ((RU)*r + (GU)*g + (BU)*b + (256U<<(S)) + (1<<(S-6)))>>((S)-6+1);\
1188         dstV[i]= ((RV)*r + (GV)*g + (BV)*b + (256U<<(S)) + (1<<(S-6)))>>((S)-6+1);\
1189     }\
1190 }
1191
1192 BGR2UV(uint32_t, bgr32ToUV,16, 0, 0, 0, 0xFF0000, 0xFF00,   0x00FF, RU<< 8, GU   , BU<< 8, RV<< 8, GV   , BV<< 8, RGB2YUV_SHIFT+8)
1193 BGR2UV(uint32_t,bgr321ToUV,16, 0, 0, 8, 0xFF0000, 0xFF00,   0x00FF, RU<< 8, GU   , BU<< 8, RV<< 8, GV   , BV<< 8, RGB2YUV_SHIFT+8)
1194 BGR2UV(uint32_t, rgb32ToUV, 0, 0,16, 0,   0x00FF, 0xFF00, 0xFF0000, RU<< 8, GU   , BU<< 8, RV<< 8, GV   , BV<< 8, RGB2YUV_SHIFT+8)
1195 BGR2UV(uint32_t,rgb321ToUV, 0, 0,16, 8,   0x00FF, 0xFF00, 0xFF0000, RU<< 8, GU   , BU<< 8, RV<< 8, GV   , BV<< 8, RGB2YUV_SHIFT+8)
1196 BGR2UV(uint16_t, bgr16ToUV, 0, 0, 0, 0,   0x001F, 0x07E0,   0xF800, RU<<11, GU<<5, BU    , RV<<11, GV<<5, BV    , RGB2YUV_SHIFT+8)
1197 BGR2UV(uint16_t, bgr15ToUV, 0, 0, 0, 0,   0x001F, 0x03E0,   0x7C00, RU<<10, GU<<5, BU    , RV<<10, GV<<5, BV    , RGB2YUV_SHIFT+7)
1198 BGR2UV(uint16_t, rgb16ToUV, 0, 0, 0, 0,   0xF800, 0x07E0,   0x001F, RU    , GU<<5, BU<<11, RV    , GV<<5, BV<<11, RGB2YUV_SHIFT+8)
1199 BGR2UV(uint16_t, rgb15ToUV, 0, 0, 0, 0,   0x7C00, 0x03E0,   0x001F, RU    , GU<<5, BU<<10, RV    , GV<<5, BV<<10, RGB2YUV_SHIFT+7)
1200
1201 static inline void palToA(int16_t *dst, const uint8_t *src, int width, uint32_t *pal)
1202 {
1203     int i;
1204     for (i=0; i<width; i++) {
1205         int d= src[i];
1206
1207         dst[i]= (pal[d] >> 24)<<6;
1208     }
1209 }
1210
1211 static inline void palToY(int16_t *dst, const uint8_t *src, long width, uint32_t *pal)
1212 {
1213     int i;
1214     for (i=0; i<width; i++) {
1215         int d= src[i];
1216
1217         dst[i]= (pal[d] & 0xFF)<<6;
1218     }
1219 }
1220
1221 static inline void palToUV(uint16_t *dstU, int16_t *dstV,
1222                            const uint8_t *src1, const uint8_t *src2,
1223                            int width, uint32_t *pal)
1224 {
1225     int i;
1226     assert(src1 == src2);
1227     for (i=0; i<width; i++) {
1228         int p= pal[src1[i]];
1229
1230         dstU[i]= (uint8_t)(p>> 8)<<6;
1231         dstV[i]= (uint8_t)(p>>16)<<6;
1232     }
1233 }
1234
1235 static inline void monowhite2Y(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
1236 {
1237     int i, j;
1238     for (i=0; i<width/8; i++) {
1239         int d= ~src[i];
1240         for(j=0; j<8; j++)
1241             dst[8*i+j]= ((d>>(7-j))&1)*16383;
1242     }
1243 }
1244
1245 static inline void monoblack2Y(int16_t *dst, const uint8_t *src, int width, uint32_t *unused)
1246 {
1247     int i, j;
1248     for (i=0; i<width/8; i++) {
1249         int d= src[i];
1250         for(j=0; j<8; j++)
1251             dst[8*i+j]= ((d>>(7-j))&1)*16383;
1252     }
1253 }
1254
1255 //Note: we have C, MMX, MMX2, 3DNOW versions, there is no 3DNOW+MMX2 one
1256 //Plain C versions
1257
1258 #define COMPILE_TEMPLATE_MMX2 0
1259 #define COMPILE_TEMPLATE_ALTIVEC 0
1260
1261 #include "swscale_template.c"
1262
1263 #if HAVE_ALTIVEC
1264 #undef RENAME
1265 #undef COMPILE_TEMPLATE_ALTIVEC
1266 #define COMPILE_TEMPLATE_ALTIVEC 1
1267 #define RENAME(a) a ## _altivec
1268 #include "ppc/swscale_template.c"
1269 #endif
1270
1271 //MMX versions
1272 #if HAVE_MMX
1273 #undef RENAME
1274 #undef COMPILE_TEMPLATE_MMX2
1275 #define COMPILE_TEMPLATE_MMX2 0
1276 #define RENAME(a) a ## _MMX
1277 #include "x86/swscale_template.c"
1278 #endif
1279
1280 //MMX2 versions
1281 #if HAVE_MMX2
1282 #undef RENAME
1283 #undef COMPILE_TEMPLATE_MMX2
1284 #define COMPILE_TEMPLATE_MMX2 1
1285 #define RENAME(a) a ## _MMX2
1286 #include "x86/swscale_template.c"
1287 #endif
1288
1289 SwsFunc ff_getSwsFunc(SwsContext *c)
1290 {
1291     int cpu_flags = av_get_cpu_flags();
1292
1293     sws_init_swScale_c(c);
1294
1295 #if HAVE_MMX
1296     if (cpu_flags & AV_CPU_FLAG_MMX)
1297         sws_init_swScale_MMX(c);
1298 #endif
1299 #if HAVE_MMX2
1300     if (cpu_flags & AV_CPU_FLAG_MMX2)
1301         sws_init_swScale_MMX2(c);
1302 #endif
1303 #if HAVE_ALTIVEC
1304     if (cpu_flags & AV_CPU_FLAG_ALTIVEC)
1305         sws_init_swScale_altivec(c);
1306 #endif
1307
1308     return swScale_c;
1309 }
1310
1311 static void copyPlane(const uint8_t *src, int srcStride,
1312                       int srcSliceY, int srcSliceH, int width,
1313                       uint8_t *dst, int dstStride)
1314 {
1315     dst += dstStride * srcSliceY;
1316     if (dstStride == srcStride && srcStride > 0) {
1317         memcpy(dst, src, srcSliceH * dstStride);
1318     } else {
1319         int i;
1320         for (i=0; i<srcSliceH; i++) {
1321             memcpy(dst, src, width);
1322             src += srcStride;
1323             dst += dstStride;
1324         }
1325     }
1326 }
1327
1328 static int planarToNv12Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1329                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1330 {
1331     uint8_t *dst = dstParam[1] + dstStride[1]*srcSliceY/2;
1332
1333     copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
1334               dstParam[0], dstStride[0]);
1335
1336     if (c->dstFormat == PIX_FMT_NV12)
1337         interleaveBytes(src[1], src[2], dst, c->srcW/2, srcSliceH/2, srcStride[1], srcStride[2], dstStride[0]);
1338     else
1339         interleaveBytes(src[2], src[1], dst, c->srcW/2, srcSliceH/2, srcStride[2], srcStride[1], dstStride[0]);
1340
1341     return srcSliceH;
1342 }
1343
1344 static int planarToYuy2Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1345                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1346 {
1347     uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
1348
1349     yv12toyuy2(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0], srcStride[1], dstStride[0]);
1350
1351     return srcSliceH;
1352 }
1353
1354 static int planarToUyvyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1355                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1356 {
1357     uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
1358
1359     yv12touyvy(src[0], src[1], src[2], dst, c->srcW, srcSliceH, srcStride[0], srcStride[1], dstStride[0]);
1360
1361     return srcSliceH;
1362 }
1363
1364 static int yuv422pToYuy2Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1365                                 int srcSliceH, uint8_t* dstParam[], int dstStride[])
1366 {
1367     uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
1368
1369     yuv422ptoyuy2(src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0]);
1370
1371     return srcSliceH;
1372 }
1373
1374 static int yuv422pToUyvyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1375                                 int srcSliceH, uint8_t* dstParam[], int dstStride[])
1376 {
1377     uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
1378
1379     yuv422ptouyvy(src[0],src[1],src[2],dst,c->srcW,srcSliceH,srcStride[0],srcStride[1],dstStride[0]);
1380
1381     return srcSliceH;
1382 }
1383
1384 static int yuyvToYuv420Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1385                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1386 {
1387     uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
1388     uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY/2;
1389     uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY/2;
1390
1391     yuyvtoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
1392
1393     if (dstParam[3])
1394         fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1395
1396     return srcSliceH;
1397 }
1398
1399 static int yuyvToYuv422Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1400                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1401 {
1402     uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
1403     uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY;
1404     uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY;
1405
1406     yuyvtoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
1407
1408     return srcSliceH;
1409 }
1410
1411 static int uyvyToYuv420Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1412                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1413 {
1414     uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
1415     uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY/2;
1416     uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY/2;
1417
1418     uyvytoyuv420(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
1419
1420     if (dstParam[3])
1421         fillPlane(dstParam[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1422
1423     return srcSliceH;
1424 }
1425
1426 static int uyvyToYuv422Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1427                                int srcSliceH, uint8_t* dstParam[], int dstStride[])
1428 {
1429     uint8_t *ydst=dstParam[0] + dstStride[0]*srcSliceY;
1430     uint8_t *udst=dstParam[1] + dstStride[1]*srcSliceY;
1431     uint8_t *vdst=dstParam[2] + dstStride[2]*srcSliceY;
1432
1433     uyvytoyuv422(ydst, udst, vdst, src[0], c->srcW, srcSliceH, dstStride[0], dstStride[1], srcStride[0]);
1434
1435     return srcSliceH;
1436 }
1437
1438 static void gray8aToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
1439 {
1440     int i;
1441     for (i=0; i<num_pixels; i++)
1442         ((uint32_t *) dst)[i] = ((const uint32_t *)palette)[src[i<<1]] | (src[(i<<1)+1] << 24);
1443 }
1444
1445 static void gray8aToPacked32_1(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
1446 {
1447     int i;
1448
1449     for (i=0; i<num_pixels; i++)
1450         ((uint32_t *) dst)[i] = ((const uint32_t *)palette)[src[i<<1]] | src[(i<<1)+1];
1451 }
1452
1453 static void gray8aToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
1454 {
1455     int i;
1456
1457     for (i=0; i<num_pixels; i++) {
1458         //FIXME slow?
1459         dst[0]= palette[src[i<<1]*4+0];
1460         dst[1]= palette[src[i<<1]*4+1];
1461         dst[2]= palette[src[i<<1]*4+2];
1462         dst+= 3;
1463     }
1464 }
1465
1466 static int palToRgbWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1467                            int srcSliceH, uint8_t* dst[], int dstStride[])
1468 {
1469     const enum PixelFormat srcFormat= c->srcFormat;
1470     const enum PixelFormat dstFormat= c->dstFormat;
1471     void (*conv)(const uint8_t *src, uint8_t *dst, int num_pixels,
1472                  const uint8_t *palette)=NULL;
1473     int i;
1474     uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
1475     const uint8_t *srcPtr= src[0];
1476
1477     if (srcFormat == PIX_FMT_GRAY8A) {
1478         switch (dstFormat) {
1479         case PIX_FMT_RGB32  : conv = gray8aToPacked32; break;
1480         case PIX_FMT_BGR32  : conv = gray8aToPacked32; break;
1481         case PIX_FMT_BGR32_1: conv = gray8aToPacked32_1; break;
1482         case PIX_FMT_RGB32_1: conv = gray8aToPacked32_1; break;
1483         case PIX_FMT_RGB24  : conv = gray8aToPacked24; break;
1484         case PIX_FMT_BGR24  : conv = gray8aToPacked24; break;
1485         }
1486     } else if (usePal(srcFormat)) {
1487         switch (dstFormat) {
1488         case PIX_FMT_RGB32  : conv = sws_convertPalette8ToPacked32; break;
1489         case PIX_FMT_BGR32  : conv = sws_convertPalette8ToPacked32; break;
1490         case PIX_FMT_BGR32_1: conv = sws_convertPalette8ToPacked32; break;
1491         case PIX_FMT_RGB32_1: conv = sws_convertPalette8ToPacked32; break;
1492         case PIX_FMT_RGB24  : conv = sws_convertPalette8ToPacked24; break;
1493         case PIX_FMT_BGR24  : conv = sws_convertPalette8ToPacked24; break;
1494         }
1495     }
1496
1497     if (!conv)
1498         av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
1499                av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1500     else {
1501         for (i=0; i<srcSliceH; i++) {
1502             conv(srcPtr, dstPtr, c->srcW, (uint8_t *) c->pal_rgb);
1503             srcPtr+= srcStride[0];
1504             dstPtr+= dstStride[0];
1505         }
1506     }
1507
1508     return srcSliceH;
1509 }
1510
1511 #define isRGBA32(x) (            \
1512            (x) == PIX_FMT_ARGB   \
1513         || (x) == PIX_FMT_RGBA   \
1514         || (x) == PIX_FMT_BGRA   \
1515         || (x) == PIX_FMT_ABGR   \
1516         )
1517
1518 /* {RGB,BGR}{15,16,24,32,32_1} -> {RGB,BGR}{15,16,24,32} */
1519 static int rgbToRgbWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1520                            int srcSliceH, uint8_t* dst[], int dstStride[])
1521 {
1522     const enum PixelFormat srcFormat= c->srcFormat;
1523     const enum PixelFormat dstFormat= c->dstFormat;
1524     const int srcBpp= (c->srcFormatBpp + 7) >> 3;
1525     const int dstBpp= (c->dstFormatBpp + 7) >> 3;
1526     const int srcId= c->srcFormatBpp >> 2; /* 1:0, 4:1, 8:2, 15:3, 16:4, 24:6, 32:8 */
1527     const int dstId= c->dstFormatBpp >> 2;
1528     void (*conv)(const uint8_t *src, uint8_t *dst, int src_size)=NULL;
1529
1530 #define CONV_IS(src, dst) (srcFormat == PIX_FMT_##src && dstFormat == PIX_FMT_##dst)
1531
1532     if (isRGBA32(srcFormat) && isRGBA32(dstFormat)) {
1533         if (     CONV_IS(ABGR, RGBA)
1534               || CONV_IS(ARGB, BGRA)
1535               || CONV_IS(BGRA, ARGB)
1536               || CONV_IS(RGBA, ABGR)) conv = shuffle_bytes_3210;
1537         else if (CONV_IS(ABGR, ARGB)
1538               || CONV_IS(ARGB, ABGR)) conv = shuffle_bytes_0321;
1539         else if (CONV_IS(ABGR, BGRA)
1540               || CONV_IS(ARGB, RGBA)) conv = shuffle_bytes_1230;
1541         else if (CONV_IS(BGRA, RGBA)
1542               || CONV_IS(RGBA, BGRA)) conv = shuffle_bytes_2103;
1543         else if (CONV_IS(BGRA, ABGR)
1544               || CONV_IS(RGBA, ARGB)) conv = shuffle_bytes_3012;
1545     } else
1546     /* BGR -> BGR */
1547     if (  (isBGRinInt(srcFormat) && isBGRinInt(dstFormat))
1548        || (isRGBinInt(srcFormat) && isRGBinInt(dstFormat))) {
1549         switch(srcId | (dstId<<4)) {
1550         case 0x34: conv= rgb16to15; break;
1551         case 0x36: conv= rgb24to15; break;
1552         case 0x38: conv= rgb32to15; break;
1553         case 0x43: conv= rgb15to16; break;
1554         case 0x46: conv= rgb24to16; break;
1555         case 0x48: conv= rgb32to16; break;
1556         case 0x63: conv= rgb15to24; break;
1557         case 0x64: conv= rgb16to24; break;
1558         case 0x68: conv= rgb32to24; break;
1559         case 0x83: conv= rgb15to32; break;
1560         case 0x84: conv= rgb16to32; break;
1561         case 0x86: conv= rgb24to32; break;
1562         }
1563     } else if (  (isBGRinInt(srcFormat) && isRGBinInt(dstFormat))
1564              || (isRGBinInt(srcFormat) && isBGRinInt(dstFormat))) {
1565         switch(srcId | (dstId<<4)) {
1566         case 0x33: conv= rgb15tobgr15; break;
1567         case 0x34: conv= rgb16tobgr15; break;
1568         case 0x36: conv= rgb24tobgr15; break;
1569         case 0x38: conv= rgb32tobgr15; break;
1570         case 0x43: conv= rgb15tobgr16; break;
1571         case 0x44: conv= rgb16tobgr16; break;
1572         case 0x46: conv= rgb24tobgr16; break;
1573         case 0x48: conv= rgb32tobgr16; break;
1574         case 0x63: conv= rgb15tobgr24; break;
1575         case 0x64: conv= rgb16tobgr24; break;
1576         case 0x66: conv= rgb24tobgr24; break;
1577         case 0x68: conv= rgb32tobgr24; break;
1578         case 0x83: conv= rgb15tobgr32; break;
1579         case 0x84: conv= rgb16tobgr32; break;
1580         case 0x86: conv= rgb24tobgr32; break;
1581         }
1582     }
1583
1584     if (!conv) {
1585         av_log(c, AV_LOG_ERROR, "internal error %s -> %s converter\n",
1586                av_get_pix_fmt_name(srcFormat), av_get_pix_fmt_name(dstFormat));
1587     } else {
1588         const uint8_t *srcPtr= src[0];
1589               uint8_t *dstPtr= dst[0];
1590         if ((srcFormat == PIX_FMT_RGB32_1 || srcFormat == PIX_FMT_BGR32_1) && !isRGBA32(dstFormat))
1591             srcPtr += ALT32_CORR;
1592
1593         if ((dstFormat == PIX_FMT_RGB32_1 || dstFormat == PIX_FMT_BGR32_1) && !isRGBA32(srcFormat))
1594             dstPtr += ALT32_CORR;
1595
1596         if (dstStride[0]*srcBpp == srcStride[0]*dstBpp && srcStride[0] > 0 && !(srcStride[0]%srcBpp))
1597             conv(srcPtr, dstPtr + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
1598         else {
1599             int i;
1600             dstPtr += dstStride[0]*srcSliceY;
1601
1602             for (i=0; i<srcSliceH; i++) {
1603                 conv(srcPtr, dstPtr, c->srcW*srcBpp);
1604                 srcPtr+= srcStride[0];
1605                 dstPtr+= dstStride[0];
1606             }
1607         }
1608     }
1609     return srcSliceH;
1610 }
1611
1612 static int bgr24ToYv12Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1613                               int srcSliceH, uint8_t* dst[], int dstStride[])
1614 {
1615     rgb24toyv12(
1616         src[0],
1617         dst[0]+ srcSliceY    *dstStride[0],
1618         dst[1]+(srcSliceY>>1)*dstStride[1],
1619         dst[2]+(srcSliceY>>1)*dstStride[2],
1620         c->srcW, srcSliceH,
1621         dstStride[0], dstStride[1], srcStride[0]);
1622     if (dst[3])
1623         fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1624     return srcSliceH;
1625 }
1626
1627 static int yvu9ToYv12Wrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1628                              int srcSliceH, uint8_t* dst[], int dstStride[])
1629 {
1630     copyPlane(src[0], srcStride[0], srcSliceY, srcSliceH, c->srcW,
1631               dst[0], dstStride[0]);
1632
1633     planar2x(src[1], dst[1] + dstStride[1]*(srcSliceY >> 1), c->chrSrcW,
1634              srcSliceH >> 2, srcStride[1], dstStride[1]);
1635     planar2x(src[2], dst[2] + dstStride[2]*(srcSliceY >> 1), c->chrSrcW,
1636              srcSliceH >> 2, srcStride[2], dstStride[2]);
1637     if (dst[3])
1638         fillPlane(dst[3], dstStride[3], c->srcW, srcSliceH, srcSliceY, 255);
1639     return srcSliceH;
1640 }
1641
1642 /* unscaled copy like stuff (assumes nearly identical formats) */
1643 static int packedCopyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1644                              int srcSliceH, uint8_t* dst[], int dstStride[])
1645 {
1646     if (dstStride[0]==srcStride[0] && srcStride[0] > 0)
1647         memcpy(dst[0] + dstStride[0]*srcSliceY, src[0], srcSliceH*dstStride[0]);
1648     else {
1649         int i;
1650         const uint8_t *srcPtr= src[0];
1651         uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
1652         int length=0;
1653
1654         /* universal length finder */
1655         while(length+c->srcW <= FFABS(dstStride[0])
1656            && length+c->srcW <= FFABS(srcStride[0])) length+= c->srcW;
1657         assert(length!=0);
1658
1659         for (i=0; i<srcSliceH; i++) {
1660             memcpy(dstPtr, srcPtr, length);
1661             srcPtr+= srcStride[0];
1662             dstPtr+= dstStride[0];
1663         }
1664     }
1665     return srcSliceH;
1666 }
1667
1668 #define DITHER_COPY(dst, dstStride, src, srcStride, bswap, dbswap)\
1669     uint16_t scale= dither_scale[dst_depth-1][src_depth-1];\
1670     int shift= src_depth-dst_depth + dither_scale[src_depth-2][dst_depth-1];\
1671     for (i = 0; i < height; i++) {\
1672         const uint8_t *dither= dithers[src_depth-9][i&7];\
1673         for (j = 0; j < length-7; j+=8){\
1674             dst[j+0] = dbswap((bswap(src[j+0]) + dither[0])*scale>>shift);\
1675             dst[j+1] = dbswap((bswap(src[j+1]) + dither[1])*scale>>shift);\
1676             dst[j+2] = dbswap((bswap(src[j+2]) + dither[2])*scale>>shift);\
1677             dst[j+3] = dbswap((bswap(src[j+3]) + dither[3])*scale>>shift);\
1678             dst[j+4] = dbswap((bswap(src[j+4]) + dither[4])*scale>>shift);\
1679             dst[j+5] = dbswap((bswap(src[j+5]) + dither[5])*scale>>shift);\
1680             dst[j+6] = dbswap((bswap(src[j+6]) + dither[6])*scale>>shift);\
1681             dst[j+7] = dbswap((bswap(src[j+7]) + dither[7])*scale>>shift);\
1682         }\
1683         for (; j < length; j++)\
1684             dst[j] = dbswap((bswap(src[j]) + dither[j&7])*scale>>shift);\
1685         dst += dstStride;\
1686         src += srcStride;\
1687     }
1688
1689
1690 static int planarCopyWrapper(SwsContext *c, const uint8_t* src[], int srcStride[], int srcSliceY,
1691                              int srcSliceH, uint8_t* dst[], int dstStride[])
1692 {
1693     int plane, i, j;
1694     for (plane=0; plane<4; plane++) {
1695         int length= (plane==0 || plane==3) ? c->srcW  : -((-c->srcW  )>>c->chrDstHSubSample);
1696         int y=      (plane==0 || plane==3) ? srcSliceY: -((-srcSliceY)>>c->chrDstVSubSample);
1697         int height= (plane==0 || plane==3) ? srcSliceH: -((-srcSliceH)>>c->chrDstVSubSample);
1698         const uint8_t *srcPtr= src[plane];
1699         uint8_t *dstPtr= dst[plane] + dstStride[plane]*y;
1700
1701         if (!dst[plane]) continue;
1702         // ignore palette for GRAY8
1703         if (plane == 1 && !dst[2]) continue;
1704         if (!src[plane] || (plane == 1 && !src[2])) {
1705             if(is16BPS(c->dstFormat))
1706                 length*=2;
1707             fillPlane(dst[plane], dstStride[plane], length, height, y, (plane==3) ? 255 : 128);
1708         } else {
1709             if(isNBPS(c->srcFormat) || isNBPS(c->dstFormat)
1710                || (is16BPS(c->srcFormat) != is16BPS(c->dstFormat))
1711             ) {
1712                 const int src_depth = av_pix_fmt_descriptors[c->srcFormat].comp[plane].depth_minus1+1;
1713                 const int dst_depth = av_pix_fmt_descriptors[c->dstFormat].comp[plane].depth_minus1+1;
1714                 const uint16_t *srcPtr2 = (const uint16_t*)srcPtr;
1715                 uint16_t *dstPtr2 = (uint16_t*)dstPtr;
1716
1717                 if (dst_depth == 8) {
1718                     if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
1719                         DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, , )
1720                     } else {
1721                         DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, av_bswap16, )
1722                     }
1723                 } else if (src_depth == 8) {
1724                     for (i = 0; i < height; i++) {
1725                         if(isBE(c->dstFormat)){
1726                             for (j = 0; j < length; j++)
1727                                 AV_WB16(&dstPtr2[j], (srcPtr[j]<<(dst_depth-8)) |
1728                                                      (srcPtr[j]>>(2*8-dst_depth)));
1729                         } else {
1730                             for (j = 0; j < length; j++)
1731                                 AV_WL16(&dstPtr2[j], (srcPtr[j]<<(dst_depth-8)) |
1732                                                      (srcPtr[j]>>(2*8-dst_depth)));
1733                         }
1734                         dstPtr2 += dstStride[plane]/2;
1735                         srcPtr  += srcStride[plane];
1736                     }
1737                 } else if (src_depth <= dst_depth) {
1738                     for (i = 0; i < height; i++) {
1739 #define COPY_UP(r,w) \
1740     for (j = 0; j < length; j++){ \
1741         unsigned int v= r(&srcPtr2[j]);\
1742         w(&dstPtr2[j], (v<<(dst_depth-src_depth)) | \
1743                        (v>>(2*src_depth-dst_depth)));\
1744     }
1745                         if(isBE(c->srcFormat)){
1746                             if(isBE(c->dstFormat)){
1747                                 COPY_UP(AV_RB16, AV_WB16)
1748                             } else {
1749                                 COPY_UP(AV_RB16, AV_WL16)
1750                             }
1751                         } else {
1752                             if(isBE(c->dstFormat)){
1753                                 COPY_UP(AV_RL16, AV_WB16)
1754                             } else {
1755                                 COPY_UP(AV_RL16, AV_WL16)
1756                             }
1757                         }
1758                         dstPtr2 += dstStride[plane]/2;
1759                         srcPtr2 += srcStride[plane]/2;
1760                     }
1761                 } else {
1762                     if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
1763                         if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
1764                             DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , )
1765                         } else {
1766                             DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , av_bswap16)
1767                         }
1768                     }else{
1769                         if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
1770                             DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, )
1771                         } else {
1772                             DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, av_bswap16)
1773                         }
1774                     }
1775                 }
1776             } else if(is16BPS(c->srcFormat) && is16BPS(c->dstFormat)
1777                   && isBE(c->srcFormat) != isBE(c->dstFormat)) {
1778
1779                 for (i=0; i<height; i++) {
1780                     for (j=0; j<length; j++)
1781                         ((uint16_t*)dstPtr)[j] = av_bswap16(((const uint16_t*)srcPtr)[j]);
1782                     srcPtr+= srcStride[plane];
1783                     dstPtr+= dstStride[plane];
1784                 }
1785             } else if (dstStride[plane] == srcStride[plane] &&
1786                        srcStride[plane] > 0 && srcStride[plane] == length) {
1787                 memcpy(dst[plane] + dstStride[plane]*y, src[plane],
1788                        height*dstStride[plane]);
1789             } else {
1790                 if(is16BPS(c->srcFormat) && is16BPS(c->dstFormat))
1791                     length*=2;
1792                 for (i=0; i<height; i++) {
1793                     memcpy(dstPtr, srcPtr, length);
1794                     srcPtr+= srcStride[plane];
1795                     dstPtr+= dstStride[plane];
1796                 }
1797             }
1798         }
1799     }
1800     return srcSliceH;
1801 }
1802
1803 void ff_get_unscaled_swscale(SwsContext *c)
1804 {
1805     const enum PixelFormat srcFormat = c->srcFormat;
1806     const enum PixelFormat dstFormat = c->dstFormat;
1807     const int flags = c->flags;
1808     const int dstH = c->dstH;
1809     int needsDither;
1810
1811     needsDither= isAnyRGB(dstFormat)
1812         &&  c->dstFormatBpp < 24
1813         && (c->dstFormatBpp < c->srcFormatBpp || (!isAnyRGB(srcFormat)));
1814
1815     /* yv12_to_nv12 */
1816     if ((srcFormat == PIX_FMT_YUV420P || srcFormat == PIX_FMT_YUVA420P) && (dstFormat == PIX_FMT_NV12 || dstFormat == PIX_FMT_NV21)) {
1817         c->swScale= planarToNv12Wrapper;
1818     }
1819     /* yuv2bgr */
1820     if ((srcFormat==PIX_FMT_YUV420P || srcFormat==PIX_FMT_YUV422P || srcFormat==PIX_FMT_YUVA420P) && isAnyRGB(dstFormat)
1821         && !(flags & SWS_ACCURATE_RND) && !(dstH&1)) {
1822         c->swScale= ff_yuv2rgb_get_func_ptr(c);
1823     }
1824
1825     if (srcFormat==PIX_FMT_YUV410P && (dstFormat==PIX_FMT_YUV420P || dstFormat==PIX_FMT_YUVA420P) && !(flags & SWS_BITEXACT)) {
1826         c->swScale= yvu9ToYv12Wrapper;
1827     }
1828
1829     /* bgr24toYV12 */
1830     if (srcFormat==PIX_FMT_BGR24 && (dstFormat==PIX_FMT_YUV420P || dstFormat==PIX_FMT_YUVA420P) && !(flags & SWS_ACCURATE_RND))
1831         c->swScale= bgr24ToYv12Wrapper;
1832
1833     /* RGB/BGR -> RGB/BGR (no dither needed forms) */
1834     if (   isAnyRGB(srcFormat)
1835         && isAnyRGB(dstFormat)
1836         && srcFormat != PIX_FMT_BGR8      && dstFormat != PIX_FMT_BGR8
1837         && srcFormat != PIX_FMT_RGB8      && dstFormat != PIX_FMT_RGB8
1838         && srcFormat != PIX_FMT_BGR4      && dstFormat != PIX_FMT_BGR4
1839         && srcFormat != PIX_FMT_RGB4      && dstFormat != PIX_FMT_RGB4
1840         && srcFormat != PIX_FMT_BGR4_BYTE && dstFormat != PIX_FMT_BGR4_BYTE
1841         && srcFormat != PIX_FMT_RGB4_BYTE && dstFormat != PIX_FMT_RGB4_BYTE
1842         && srcFormat != PIX_FMT_MONOBLACK && dstFormat != PIX_FMT_MONOBLACK
1843         && srcFormat != PIX_FMT_MONOWHITE && dstFormat != PIX_FMT_MONOWHITE
1844         && srcFormat != PIX_FMT_RGB48LE   && dstFormat != PIX_FMT_RGB48LE
1845         && srcFormat != PIX_FMT_RGB48BE   && dstFormat != PIX_FMT_RGB48BE
1846         && srcFormat != PIX_FMT_BGR48LE   && dstFormat != PIX_FMT_BGR48LE
1847         && srcFormat != PIX_FMT_BGR48BE   && dstFormat != PIX_FMT_BGR48BE
1848         && (!needsDither || (c->flags&(SWS_FAST_BILINEAR|SWS_POINT))))
1849         c->swScale= rgbToRgbWrapper;
1850
1851     if ((usePal(srcFormat) && (
1852         dstFormat == PIX_FMT_RGB32   ||
1853         dstFormat == PIX_FMT_RGB32_1 ||
1854         dstFormat == PIX_FMT_RGB24   ||
1855         dstFormat == PIX_FMT_BGR32   ||
1856         dstFormat == PIX_FMT_BGR32_1 ||
1857         dstFormat == PIX_FMT_BGR24)))
1858         c->swScale= palToRgbWrapper;
1859
1860     if (srcFormat == PIX_FMT_YUV422P) {
1861         if (dstFormat == PIX_FMT_YUYV422)
1862             c->swScale= yuv422pToYuy2Wrapper;
1863         else if (dstFormat == PIX_FMT_UYVY422)
1864             c->swScale= yuv422pToUyvyWrapper;
1865     }
1866
1867     /* LQ converters if -sws 0 or -sws 4*/
1868     if (c->flags&(SWS_FAST_BILINEAR|SWS_POINT)) {
1869         /* yv12_to_yuy2 */
1870         if (srcFormat == PIX_FMT_YUV420P || srcFormat == PIX_FMT_YUVA420P) {
1871             if (dstFormat == PIX_FMT_YUYV422)
1872                 c->swScale= planarToYuy2Wrapper;
1873             else if (dstFormat == PIX_FMT_UYVY422)
1874                 c->swScale= planarToUyvyWrapper;
1875         }
1876     }
1877     if(srcFormat == PIX_FMT_YUYV422 && (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P))
1878         c->swScale= yuyvToYuv420Wrapper;
1879     if(srcFormat == PIX_FMT_UYVY422 && (dstFormat == PIX_FMT_YUV420P || dstFormat == PIX_FMT_YUVA420P))
1880         c->swScale= uyvyToYuv420Wrapper;
1881     if(srcFormat == PIX_FMT_YUYV422 && dstFormat == PIX_FMT_YUV422P)
1882         c->swScale= yuyvToYuv422Wrapper;
1883     if(srcFormat == PIX_FMT_UYVY422 && dstFormat == PIX_FMT_YUV422P)
1884         c->swScale= uyvyToYuv422Wrapper;
1885
1886 #if HAVE_ALTIVEC
1887     if ((av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) &&
1888         !(c->flags & SWS_BITEXACT) &&
1889         srcFormat == PIX_FMT_YUV420P) {
1890         // unscaled YV12 -> packed YUV, we want speed
1891         if (dstFormat == PIX_FMT_YUYV422)
1892             c->swScale= yv12toyuy2_unscaled_altivec;
1893         else if (dstFormat == PIX_FMT_UYVY422)
1894             c->swScale= yv12touyvy_unscaled_altivec;
1895     }
1896 #endif
1897
1898     /* simple copy */
1899     if (  srcFormat == dstFormat
1900         || (srcFormat == PIX_FMT_YUVA420P && dstFormat == PIX_FMT_YUV420P)
1901         || (srcFormat == PIX_FMT_YUV420P && dstFormat == PIX_FMT_YUVA420P)
1902         || (isPlanarYUV(srcFormat) && isGray(dstFormat))
1903         || (isPlanarYUV(dstFormat) && isGray(srcFormat))
1904         || (isGray(dstFormat) && isGray(srcFormat))
1905         || (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat)
1906             && c->chrDstHSubSample == c->chrSrcHSubSample
1907             && c->chrDstVSubSample == c->chrSrcVSubSample
1908             && dstFormat != PIX_FMT_NV12 && dstFormat != PIX_FMT_NV21
1909             && srcFormat != PIX_FMT_NV12 && srcFormat != PIX_FMT_NV21))
1910     {
1911         if (isPacked(c->srcFormat))
1912             c->swScale= packedCopyWrapper;
1913         else /* Planar YUV or gray */
1914             c->swScale= planarCopyWrapper;
1915     }
1916 #if ARCH_BFIN
1917     ff_bfin_get_unscaled_swscale (c);
1918 #endif
1919 }
1920
1921 static void reset_ptr(const uint8_t* src[], int format)
1922 {
1923     if(!isALPHA(format))
1924         src[3]=NULL;
1925     if(!isPlanarYUV(format)) {
1926         src[3]=src[2]=NULL;
1927
1928         if (!usePal(format))
1929             src[1]= NULL;
1930     }
1931 }
1932
1933 static int check_image_pointers(uint8_t *data[4], enum PixelFormat pix_fmt,
1934                                 const int linesizes[4])
1935 {
1936     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt];
1937     int i;
1938
1939     for (i = 0; i < 4; i++) {
1940         int plane = desc->comp[i].plane;
1941         if (!data[plane] || !linesizes[plane])
1942             return 0;
1943     }
1944
1945     return 1;
1946 }
1947
1948 /**
1949  * swscale wrapper, so we don't need to export the SwsContext.
1950  * Assumes planar YUV to be in YUV order instead of YVU.
1951  */
1952 int sws_scale(SwsContext *c, const uint8_t* const src[], const int srcStride[], int srcSliceY,
1953               int srcSliceH, uint8_t* const dst[], const int dstStride[])
1954 {
1955     int i;
1956     const uint8_t* src2[4]= {src[0], src[1], src[2], src[3]};
1957     uint8_t* dst2[4]= {dst[0], dst[1], dst[2], dst[3]};
1958
1959     // do not mess up sliceDir if we have a "trailing" 0-size slice
1960     if (srcSliceH == 0)
1961         return 0;
1962
1963     if (!check_image_pointers(src, c->srcFormat, srcStride)) {
1964         av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
1965         return 0;
1966     }
1967     if (!check_image_pointers(dst, c->dstFormat, dstStride)) {
1968         av_log(c, AV_LOG_ERROR, "bad dst image pointers\n");
1969         return 0;
1970     }
1971
1972     if (c->sliceDir == 0 && srcSliceY != 0 && srcSliceY + srcSliceH != c->srcH) {
1973         av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
1974         return 0;
1975     }
1976     if (c->sliceDir == 0) {
1977         if (srcSliceY == 0) c->sliceDir = 1; else c->sliceDir = -1;
1978     }
1979
1980     if (usePal(c->srcFormat)) {
1981         for (i=0; i<256; i++) {
1982             int p, r, g, b, y, u, v, a = 0xff;
1983             if(c->srcFormat == PIX_FMT_PAL8) {
1984                 p=((const uint32_t*)(src[1]))[i];
1985                 a= (p>>24)&0xFF;
1986                 r= (p>>16)&0xFF;
1987                 g= (p>> 8)&0xFF;
1988                 b=  p     &0xFF;
1989             } else if(c->srcFormat == PIX_FMT_RGB8) {
1990                 r= (i>>5    )*36;
1991                 g= ((i>>2)&7)*36;
1992                 b= (i&3     )*85;
1993             } else if(c->srcFormat == PIX_FMT_BGR8) {
1994                 b= (i>>6    )*85;
1995                 g= ((i>>3)&7)*36;
1996                 r= (i&7     )*36;
1997             } else if(c->srcFormat == PIX_FMT_RGB4_BYTE) {
1998                 r= (i>>3    )*255;
1999                 g= ((i>>1)&3)*85;
2000                 b= (i&1     )*255;
2001             } else if(c->srcFormat == PIX_FMT_GRAY8 || c->srcFormat == PIX_FMT_GRAY8A) {
2002                 r = g = b = i;
2003             } else {
2004                 assert(c->srcFormat == PIX_FMT_BGR4_BYTE);
2005                 b= (i>>3    )*255;
2006                 g= ((i>>1)&3)*85;
2007                 r= (i&1     )*255;
2008             }
2009             y= av_clip_uint8((RY*r + GY*g + BY*b + ( 33<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
2010             u= av_clip_uint8((RU*r + GU*g + BU*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
2011             v= av_clip_uint8((RV*r + GV*g + BV*b + (257<<(RGB2YUV_SHIFT-1)))>>RGB2YUV_SHIFT);
2012             c->pal_yuv[i]= y + (u<<8) + (v<<16) + (a<<24);
2013
2014             switch(c->dstFormat) {
2015             case PIX_FMT_BGR32:
2016 #if !HAVE_BIGENDIAN
2017             case PIX_FMT_RGB24:
2018 #endif
2019                 c->pal_rgb[i]=  r + (g<<8) + (b<<16) + (a<<24);
2020                 break;
2021             case PIX_FMT_BGR32_1:
2022 #if HAVE_BIGENDIAN
2023             case PIX_FMT_BGR24:
2024 #endif
2025                 c->pal_rgb[i]= a + (r<<8) + (g<<16) + (b<<24);
2026                 break;
2027             case PIX_FMT_RGB32_1:
2028 #if HAVE_BIGENDIAN
2029             case PIX_FMT_RGB24:
2030 #endif
2031                 c->pal_rgb[i]= a + (b<<8) + (g<<16) + (r<<24);
2032                 break;
2033             case PIX_FMT_RGB32:
2034 #if !HAVE_BIGENDIAN
2035             case PIX_FMT_BGR24:
2036 #endif
2037             default:
2038                 c->pal_rgb[i]=  b + (g<<8) + (r<<16) + (a<<24);
2039             }
2040         }
2041     }
2042
2043     // copy strides, so they can safely be modified
2044     if (c->sliceDir == 1) {
2045         // slices go from top to bottom
2046         int srcStride2[4]= {srcStride[0], srcStride[1], srcStride[2], srcStride[3]};
2047         int dstStride2[4]= {dstStride[0], dstStride[1], dstStride[2], dstStride[3]};
2048
2049         reset_ptr(src2, c->srcFormat);
2050         reset_ptr((const uint8_t**)dst2, c->dstFormat);
2051
2052         /* reset slice direction at end of frame */
2053         if (srcSliceY + srcSliceH == c->srcH)
2054             c->sliceDir = 0;
2055
2056         return c->swScale(c, src2, srcStride2, srcSliceY, srcSliceH, dst2, dstStride2);
2057     } else {
2058         // slices go from bottom to top => we flip the image internally
2059         int srcStride2[4]= {-srcStride[0], -srcStride[1], -srcStride[2], -srcStride[3]};
2060         int dstStride2[4]= {-dstStride[0], -dstStride[1], -dstStride[2], -dstStride[3]};
2061
2062         src2[0] += (srcSliceH-1)*srcStride[0];
2063         if (!usePal(c->srcFormat))
2064             src2[1] += ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[1];
2065         src2[2] += ((srcSliceH>>c->chrSrcVSubSample)-1)*srcStride[2];
2066         src2[3] += (srcSliceH-1)*srcStride[3];
2067         dst2[0] += ( c->dstH                      -1)*dstStride[0];
2068         dst2[1] += ((c->dstH>>c->chrDstVSubSample)-1)*dstStride[1];
2069         dst2[2] += ((c->dstH>>c->chrDstVSubSample)-1)*dstStride[2];
2070         dst2[3] += ( c->dstH                      -1)*dstStride[3];
2071
2072         reset_ptr(src2, c->srcFormat);
2073         reset_ptr((const uint8_t**)dst2, c->dstFormat);
2074
2075         /* reset slice direction at end of frame */
2076         if (!srcSliceY)
2077             c->sliceDir = 0;
2078
2079         return c->swScale(c, src2, srcStride2, c->srcH-srcSliceY-srcSliceH, srcSliceH, dst2, dstStride2);
2080     }
2081 }
2082
2083 #if LIBSWSCALE_VERSION_MAJOR < 1
2084 int sws_scale_ordered(SwsContext *c, const uint8_t* const src[], int srcStride[], int srcSliceY,
2085                       int srcSliceH, uint8_t* dst[], int dstStride[])
2086 {
2087     return sws_scale(c, src, srcStride, srcSliceY, srcSliceH, dst, dstStride);
2088 }
2089 #endif
2090
2091 /* Convert the palette to the same packed 32-bit format as the palette */
2092 void sws_convertPalette8ToPacked32(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
2093 {
2094     int i;
2095
2096     for (i=0; i<num_pixels; i++)
2097         ((uint32_t *) dst)[i] = ((const uint32_t *) palette)[src[i]];
2098 }
2099
2100 /* Palette format: ABCD -> dst format: ABC */
2101 void sws_convertPalette8ToPacked24(const uint8_t *src, uint8_t *dst, int num_pixels, const uint8_t *palette)
2102 {
2103     int i;
2104
2105     for (i=0; i<num_pixels; i++) {
2106         //FIXME slow?
2107         dst[0]= palette[src[i]*4+0];
2108         dst[1]= palette[src[i]*4+1];
2109         dst[2]= palette[src[i]*4+2];
2110         dst+= 3;
2111     }
2112 }