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