* path to ffmpegs config.h
[ffmpeg.git] / postproc / swscale.c
1 /*
2     Copyright (C) 2001-2002 Michael Niedermayer <michaelni@gmx.at>
3
4     This program is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.
8
9     This program is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.
13
14     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software
16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17 */
18
19 /*
20   supported Input formats: YV12, I420, IYUV, YUY2, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8, Y800
21   supported output formats: YV12, I420, IYUV, BGR15, BGR16, BGR24, BGR32 (grayscale soon too)
22   BGR15/16 support dithering
23   
24   unscaled special converters
25   YV12/I420/IYUV -> BGR15/BGR16/BGR24/BGR32
26   YV12/I420/IYUV -> YV12/I420/IYUV
27   YUY2/BGR15/BGR16/BGR24/BGR32/RGB24/RGB32 -> same format
28   BGR24 -> BGR32 & RGB24 -> RGB32
29   BGR32 -> BGR24 & RGB32 -> RGB24
30   BGR15 -> BGR16
31 */
32
33 /* 
34 tested special converters
35  YV12/I420 -> BGR16
36  YV12 -> YV12
37  BGR15 -> BGR16
38  BGR16 -> BGR16
39
40 untested special converters
41   YV12/I420 -> BGR15/BGR24/BGR32 (its the yuv2rgb stuff, so it should be ok)
42   YV12/I420 -> YV12/I420
43   YUY2/BGR15/BGR24/BGR32/RGB24/RGB32 -> same format
44   BGR24 -> BGR32 & RGB24 -> RGB32
45   BGR32 -> BGR24 & RGB32 -> RGB24
46   BGR24 -> YV12
47 */
48
49 #include <inttypes.h>
50 #include <string.h>
51 #include <math.h>
52 #include <stdio.h>
53 #include "../config.h"
54 #include "../mangle.h"
55 #include <assert.h>
56 #ifdef HAVE_MALLOC_H
57 #include <malloc.h>
58 #endif
59 #include "swscale.h"
60 #include "../cpudetect.h"
61 #include "../bswap.h"
62 #include "../libvo/img_format.h"
63 #include "rgb2rgb.h"
64 #include "../libvo/fastmemcpy.h"
65 #undef MOVNTQ
66 #undef PAVGB
67
68 //#undef HAVE_MMX2
69 //#define HAVE_3DNOW
70 //#undef HAVE_MMX
71 //#undef ARCH_X86
72 //#define WORDS_BIGENDIAN
73 #define DITHER1XBPP
74
75 #define FAST_BGR2YV12 // use 7 bit coeffs instead of 15bit
76
77 #define RET 0xC3 //near return opcode for X86
78
79 #ifdef MP_DEBUG
80 #define ASSERT(x) assert(x);
81 #else
82 #define ASSERT(x) ;
83 #endif
84
85 #ifdef M_PI
86 #define PI M_PI
87 #else
88 #define PI 3.14159265358979323846
89 #endif
90
91 //FIXME replace this with something faster
92 #define isPlanarYUV(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420)
93 #define isYUV(x)       ((x)==IMGFMT_YUY2 || isPlanarYUV(x))
94 #define isHalfChrV(x)  ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420)
95 #define isHalfChrH(x)  ((x)==IMGFMT_YUY2 || (x)==IMGFMT_YV12 || (x)==IMGFMT_I420)
96 #define isPacked(x)    ((x)==IMGFMT_YUY2 || ((x)&IMGFMT_BGR_MASK)==IMGFMT_BGR || ((x)&IMGFMT_RGB_MASK)==IMGFMT_RGB)
97 #define isGray(x)      ((x)==IMGFMT_Y800)
98 #define isSupportedIn(x)  ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420 || (x)==IMGFMT_YUY2 \
99                         || (x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15\
100                         || (x)==IMGFMT_RGB32|| (x)==IMGFMT_RGB24\
101                         || (x)==IMGFMT_Y800)
102 #define isSupportedOut(x) ((x)==IMGFMT_YV12 || (x)==IMGFMT_I420 \
103                         || (x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15)
104 #define isBGR(x)       ((x)==IMGFMT_BGR32|| (x)==IMGFMT_BGR24|| (x)==IMGFMT_BGR16|| (x)==IMGFMT_BGR15)
105
106 #define RGB2YUV_SHIFT 16
107 #define BY ((int)( 0.098*(1<<RGB2YUV_SHIFT)+0.5))
108 #define BV ((int)(-0.071*(1<<RGB2YUV_SHIFT)+0.5))
109 #define BU ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
110 #define GY ((int)( 0.504*(1<<RGB2YUV_SHIFT)+0.5))
111 #define GV ((int)(-0.368*(1<<RGB2YUV_SHIFT)+0.5))
112 #define GU ((int)(-0.291*(1<<RGB2YUV_SHIFT)+0.5))
113 #define RY ((int)( 0.257*(1<<RGB2YUV_SHIFT)+0.5))
114 #define RV ((int)( 0.439*(1<<RGB2YUV_SHIFT)+0.5))
115 #define RU ((int)(-0.148*(1<<RGB2YUV_SHIFT)+0.5))
116
117 extern int verbose; // defined in mplayer.c
118 /*
119 NOTES
120 Special versions: fast Y 1:1 scaling (no interpolation in y direction)
121
122 TODO
123 more intelligent missalignment avoidance for the horizontal scaler
124 write special vertical cubic upscale version
125 Optimize C code (yv12 / minmax)
126 add support for packed pixel yuv input & output
127 add support for Y8 output
128 optimize bgr24 & bgr32
129 add BGR4 output support
130 write special BGR->BGR scaler
131 deglobalize yuv2rgb*.c
132 */
133
134 #define ABS(a) ((a) > 0 ? (a) : (-(a)))
135 #define MIN(a,b) ((a) > (b) ? (b) : (a))
136 #define MAX(a,b) ((a) < (b) ? (b) : (a))
137
138 #ifdef ARCH_X86
139 #define CAN_COMPILE_X86_ASM
140 #endif
141
142 #ifdef CAN_COMPILE_X86_ASM
143 static uint64_t __attribute__((aligned(8))) yCoeff=    0x2568256825682568LL;
144 static uint64_t __attribute__((aligned(8))) vrCoeff=   0x3343334333433343LL;
145 static uint64_t __attribute__((aligned(8))) ubCoeff=   0x40cf40cf40cf40cfLL;
146 static uint64_t __attribute__((aligned(8))) vgCoeff=   0xE5E2E5E2E5E2E5E2LL;
147 static uint64_t __attribute__((aligned(8))) ugCoeff=   0xF36EF36EF36EF36ELL;
148 static uint64_t __attribute__((aligned(8))) bF8=       0xF8F8F8F8F8F8F8F8LL;
149 static uint64_t __attribute__((aligned(8))) bFC=       0xFCFCFCFCFCFCFCFCLL;
150 static uint64_t __attribute__((aligned(8))) w400=      0x0400040004000400LL;
151 static uint64_t __attribute__((aligned(8))) w80=       0x0080008000800080LL;
152 static uint64_t __attribute__((aligned(8))) w10=       0x0010001000100010LL;
153 static uint64_t __attribute__((aligned(8))) w02=       0x0002000200020002LL;
154 static uint64_t __attribute__((aligned(8))) bm00001111=0x00000000FFFFFFFFLL;
155 static uint64_t __attribute__((aligned(8))) bm00000111=0x0000000000FFFFFFLL;
156 static uint64_t __attribute__((aligned(8))) bm11111000=0xFFFFFFFFFF000000LL;
157 static uint64_t __attribute__((aligned(8))) bm01010101=0x00FF00FF00FF00FFLL;
158
159 static volatile uint64_t __attribute__((aligned(8))) b5Dither;
160 static volatile uint64_t __attribute__((aligned(8))) g5Dither;
161 static volatile uint64_t __attribute__((aligned(8))) g6Dither;
162 static volatile uint64_t __attribute__((aligned(8))) r5Dither;
163
164 static uint64_t __attribute__((aligned(8))) dither4[2]={
165         0x0103010301030103LL,
166         0x0200020002000200LL,};
167
168 static uint64_t __attribute__((aligned(8))) dither8[2]={
169         0x0602060206020602LL,
170         0x0004000400040004LL,};
171
172 static uint64_t __attribute__((aligned(8))) b16Mask=   0x001F001F001F001FLL;
173 static uint64_t __attribute__((aligned(8))) g16Mask=   0x07E007E007E007E0LL;
174 static uint64_t __attribute__((aligned(8))) r16Mask=   0xF800F800F800F800LL;
175 static uint64_t __attribute__((aligned(8))) b15Mask=   0x001F001F001F001FLL;
176 static uint64_t __attribute__((aligned(8))) g15Mask=   0x03E003E003E003E0LL;
177 static uint64_t __attribute__((aligned(8))) r15Mask=   0x7C007C007C007C00LL;
178
179 static uint64_t __attribute__((aligned(8))) M24A=   0x00FF0000FF0000FFLL;
180 static uint64_t __attribute__((aligned(8))) M24B=   0xFF0000FF0000FF00LL;
181 static uint64_t __attribute__((aligned(8))) M24C=   0x0000FF0000FF0000LL;
182
183 #ifdef FAST_BGR2YV12
184 static const uint64_t bgr2YCoeff  __attribute__((aligned(8))) = 0x000000210041000DULL;
185 static const uint64_t bgr2UCoeff  __attribute__((aligned(8))) = 0x0000FFEEFFDC0038ULL;
186 static const uint64_t bgr2VCoeff  __attribute__((aligned(8))) = 0x00000038FFD2FFF8ULL;
187 #else
188 static const uint64_t bgr2YCoeff  __attribute__((aligned(8))) = 0x000020E540830C8BULL;
189 static const uint64_t bgr2UCoeff  __attribute__((aligned(8))) = 0x0000ED0FDAC23831ULL;
190 static const uint64_t bgr2VCoeff  __attribute__((aligned(8))) = 0x00003831D0E6F6EAULL;
191 #endif
192 static const uint64_t bgr2YOffset __attribute__((aligned(8))) = 0x1010101010101010ULL;
193 static const uint64_t bgr2UVOffset __attribute__((aligned(8)))= 0x8080808080808080ULL;
194 static const uint64_t w1111       __attribute__((aligned(8))) = 0x0001000100010001ULL;
195
196 // FIXME remove
197 static uint64_t __attribute__((aligned(8))) asm_yalpha1;
198 static uint64_t __attribute__((aligned(8))) asm_uvalpha1;
199 #endif
200
201 // clipping helper table for C implementations:
202 static unsigned char clip_table[768];
203
204 static unsigned short clip_table16b[768];
205 static unsigned short clip_table16g[768];
206 static unsigned short clip_table16r[768];
207 static unsigned short clip_table15b[768];
208 static unsigned short clip_table15g[768];
209 static unsigned short clip_table15r[768];
210
211 // yuv->rgb conversion tables:
212 static    int yuvtab_2568[256];
213 static    int yuvtab_3343[256];
214 static    int yuvtab_0c92[256];
215 static    int yuvtab_1a1e[256];
216 static    int yuvtab_40cf[256];
217 // Needed for cubic scaler to catch overflows
218 static    int clip_yuvtab_2568[768];
219 static    int clip_yuvtab_3343[768];
220 static    int clip_yuvtab_0c92[768];
221 static    int clip_yuvtab_1a1e[768];
222 static    int clip_yuvtab_40cf[768];
223
224 //global sws_flags from the command line
225 int sws_flags=2;
226
227 //global srcFilter
228 SwsFilter src_filter= {NULL, NULL, NULL, NULL};
229
230 float sws_lum_gblur= 0.0;
231 float sws_chr_gblur= 0.0;
232 int sws_chr_vshift= 0;
233 int sws_chr_hshift= 0;
234 float sws_chr_sharpen= 0.0;
235 float sws_lum_sharpen= 0.0;
236
237 /* cpuCaps combined from cpudetect and whats actually compiled in
238    (if there is no support for something compiled in it wont appear here) */
239 static CpuCaps cpuCaps;
240
241 void (*swScale)(SwsContext *context, uint8_t* src[], int srcStride[], int srcSliceY,
242              int srcSliceH, uint8_t* dst[], int dstStride[])=NULL;
243
244 static SwsVector *getConvVec(SwsVector *a, SwsVector *b);
245
246 #ifdef CAN_COMPILE_X86_ASM
247 void in_asm_used_var_warning_killer()
248 {
249  volatile int i= yCoeff+vrCoeff+ubCoeff+vgCoeff+ugCoeff+bF8+bFC+w400+w80+w10+
250  bm00001111+bm00000111+bm11111000+b16Mask+g16Mask+r16Mask+b15Mask+g15Mask+r15Mask+asm_yalpha1+ asm_uvalpha1+
251  M24A+M24B+M24C+w02 + b5Dither+g5Dither+r5Dither+g6Dither+dither4[0]+dither8[0]+bm01010101;
252  if(i) i=0;
253 }
254 #endif
255
256 static inline void yuv2yuvXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
257                                     int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
258                                     uint8_t *dest, uint8_t *uDest, uint8_t *vDest, int dstW)
259 {
260         //FIXME Optimize (just quickly writen not opti..)
261         int i;
262         for(i=0; i<dstW; i++)
263         {
264                 int val=0;
265                 int j;
266                 for(j=0; j<lumFilterSize; j++)
267                         val += lumSrc[j][i] * lumFilter[j];
268
269                 dest[i]= MIN(MAX(val>>19, 0), 255);
270         }
271
272         if(uDest != NULL)
273                 for(i=0; i<(dstW>>1); i++)
274                 {
275                         int u=0;
276                         int v=0;
277                         int j;
278                         for(j=0; j<chrFilterSize; j++)
279                         {
280                                 u += chrSrc[j][i] * chrFilter[j];
281                                 v += chrSrc[j][i + 2048] * chrFilter[j];
282                         }
283
284                         uDest[i]= MIN(MAX(u>>19, 0), 255);
285                         vDest[i]= MIN(MAX(v>>19, 0), 255);
286                 }
287 }
288
289 static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
290                                     int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
291                                     uint8_t *dest, int dstW, int dstFormat)
292 {
293         if(dstFormat==IMGFMT_BGR32)
294         {
295                 int i;
296 #ifdef WORDS_BIGENDIAN
297         dest++;
298 #endif
299                 for(i=0; i<(dstW>>1); i++){
300                         int j;
301                         int Y1=0;
302                         int Y2=0;
303                         int U=0;
304                         int V=0;
305                         int Cb, Cr, Cg;
306                         for(j=0; j<lumFilterSize; j++)
307                         {
308                                 Y1 += lumSrc[j][2*i] * lumFilter[j];
309                                 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
310                         }
311                         for(j=0; j<chrFilterSize; j++)
312                         {
313                                 U += chrSrc[j][i] * chrFilter[j];
314                                 V += chrSrc[j][i+2048] * chrFilter[j];
315                         }
316                         Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
317                         Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
318                         U >>= 19;
319                         V >>= 19;
320
321                         Cb= clip_yuvtab_40cf[U+ 256];
322                         Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
323                         Cr= clip_yuvtab_3343[V+ 256];
324
325                         dest[8*i+0]=clip_table[((Y1 + Cb) >>13)];
326                         dest[8*i+1]=clip_table[((Y1 + Cg) >>13)];
327                         dest[8*i+2]=clip_table[((Y1 + Cr) >>13)];
328
329                         dest[8*i+4]=clip_table[((Y2 + Cb) >>13)];
330                         dest[8*i+5]=clip_table[((Y2 + Cg) >>13)];
331                         dest[8*i+6]=clip_table[((Y2 + Cr) >>13)];
332                 }
333         }
334         else if(dstFormat==IMGFMT_BGR24)
335         {
336                 int i;
337                 for(i=0; i<(dstW>>1); i++){
338                         int j;
339                         int Y1=0;
340                         int Y2=0;
341                         int U=0;
342                         int V=0;
343                         int Cb, Cr, Cg;
344                         for(j=0; j<lumFilterSize; j++)
345                         {
346                                 Y1 += lumSrc[j][2*i] * lumFilter[j];
347                                 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
348                         }
349                         for(j=0; j<chrFilterSize; j++)
350                         {
351                                 U += chrSrc[j][i] * chrFilter[j];
352                                 V += chrSrc[j][i+2048] * chrFilter[j];
353                         }
354                         Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
355                         Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
356                         U >>= 19;
357                         V >>= 19;
358
359                         Cb= clip_yuvtab_40cf[U+ 256];
360                         Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
361                         Cr= clip_yuvtab_3343[V+ 256];
362
363                         dest[0]=clip_table[((Y1 + Cb) >>13)];
364                         dest[1]=clip_table[((Y1 + Cg) >>13)];
365                         dest[2]=clip_table[((Y1 + Cr) >>13)];
366
367                         dest[3]=clip_table[((Y2 + Cb) >>13)];
368                         dest[4]=clip_table[((Y2 + Cg) >>13)];
369                         dest[5]=clip_table[((Y2 + Cr) >>13)];
370                         dest+=6;
371                 }
372         }
373         else if(dstFormat==IMGFMT_BGR16)
374         {
375                 int i;
376 #ifdef DITHER1XBPP
377                 static int ditherb1=1<<14;
378                 static int ditherg1=1<<13;
379                 static int ditherr1=2<<14;
380                 static int ditherb2=3<<14;
381                 static int ditherg2=3<<13;
382                 static int ditherr2=0<<14;
383
384                 ditherb1 ^= (1^2)<<14;
385                 ditherg1 ^= (1^2)<<13;
386                 ditherr1 ^= (1^2)<<14;
387                 ditherb2 ^= (3^0)<<14;
388                 ditherg2 ^= (3^0)<<13;
389                 ditherr2 ^= (3^0)<<14;
390 #else
391                 const int ditherb1=0;
392                 const int ditherg1=0;
393                 const int ditherr1=0;
394                 const int ditherb2=0;
395                 const int ditherg2=0;
396                 const int ditherr2=0;
397 #endif
398                 for(i=0; i<(dstW>>1); i++){
399                         int j;
400                         int Y1=0;
401                         int Y2=0;
402                         int U=0;
403                         int V=0;
404                         int Cb, Cr, Cg;
405                         for(j=0; j<lumFilterSize; j++)
406                         {
407                                 Y1 += lumSrc[j][2*i] * lumFilter[j];
408                                 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
409                         }
410                         for(j=0; j<chrFilterSize; j++)
411                         {
412                                 U += chrSrc[j][i] * chrFilter[j];
413                                 V += chrSrc[j][i+2048] * chrFilter[j];
414                         }
415                         Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
416                         Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
417                         U >>= 19;
418                         V >>= 19;
419
420                         Cb= clip_yuvtab_40cf[U+ 256];
421                         Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
422                         Cr= clip_yuvtab_3343[V+ 256];
423
424                         ((uint16_t*)dest)[2*i] =
425                                 clip_table16b[(Y1 + Cb + ditherb1) >>13] |
426                                 clip_table16g[(Y1 + Cg + ditherg1) >>13] |
427                                 clip_table16r[(Y1 + Cr + ditherr1) >>13];
428
429                         ((uint16_t*)dest)[2*i+1] =
430                                 clip_table16b[(Y2 + Cb + ditherb2) >>13] |
431                                 clip_table16g[(Y2 + Cg + ditherg2) >>13] |
432                                 clip_table16r[(Y2 + Cr + ditherr2) >>13];
433                 }
434         }
435         else if(dstFormat==IMGFMT_BGR15)
436         {
437                 int i;
438 #ifdef DITHER1XBPP
439                 static int ditherb1=1<<14;
440                 static int ditherg1=1<<14;
441                 static int ditherr1=2<<14;
442                 static int ditherb2=3<<14;
443                 static int ditherg2=3<<14;
444                 static int ditherr2=0<<14;
445
446                 ditherb1 ^= (1^2)<<14;
447                 ditherg1 ^= (1^2)<<14;
448                 ditherr1 ^= (1^2)<<14;
449                 ditherb2 ^= (3^0)<<14;
450                 ditherg2 ^= (3^0)<<14;
451                 ditherr2 ^= (3^0)<<14;
452 #else
453                 const int ditherb1=0;
454                 const int ditherg1=0;
455                 const int ditherr1=0;
456                 const int ditherb2=0;
457                 const int ditherg2=0;
458                 const int ditherr2=0;
459 #endif
460                 for(i=0; i<(dstW>>1); i++){
461                         int j;
462                         int Y1=0;
463                         int Y2=0;
464                         int U=0;
465                         int V=0;
466                         int Cb, Cr, Cg;
467                         for(j=0; j<lumFilterSize; j++)
468                         {
469                                 Y1 += lumSrc[j][2*i] * lumFilter[j];
470                                 Y2 += lumSrc[j][2*i+1] * lumFilter[j];
471                         }
472                         for(j=0; j<chrFilterSize; j++)
473                         {
474                                 U += chrSrc[j][i] * chrFilter[j];
475                                 V += chrSrc[j][i+2048] * chrFilter[j];
476                         }
477                         Y1= clip_yuvtab_2568[ (Y1>>19) + 256 ];
478                         Y2= clip_yuvtab_2568[ (Y2>>19) + 256 ];
479                         U >>= 19;
480                         V >>= 19;
481
482                         Cb= clip_yuvtab_40cf[U+ 256];
483                         Cg= clip_yuvtab_1a1e[V+ 256] + yuvtab_0c92[U+ 256];
484                         Cr= clip_yuvtab_3343[V+ 256];
485
486                         ((uint16_t*)dest)[2*i] =
487                                 clip_table15b[(Y1 + Cb + ditherb1) >>13] |
488                                 clip_table15g[(Y1 + Cg + ditherg1) >>13] |
489                                 clip_table15r[(Y1 + Cr + ditherr1) >>13];
490
491                         ((uint16_t*)dest)[2*i+1] =
492                                 clip_table15b[(Y2 + Cb + ditherb2) >>13] |
493                                 clip_table15g[(Y2 + Cg + ditherg2) >>13] |
494                                 clip_table15r[(Y2 + Cr + ditherr2) >>13];
495                 }
496         }
497 }
498
499
500 //Note: we have C, X86, MMX, MMX2, 3DNOW version therse no 3DNOW+MMX2 one
501 //Plain C versions
502 #if !defined (HAVE_MMX) || defined (RUNTIME_CPUDETECT)
503 #define COMPILE_C
504 #endif
505
506 #ifdef CAN_COMPILE_X86_ASM
507
508 #if (defined (HAVE_MMX) && !defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
509 #define COMPILE_MMX
510 #endif
511
512 #if defined (HAVE_MMX2) || defined (RUNTIME_CPUDETECT)
513 #define COMPILE_MMX2
514 #endif
515
516 #if (defined (HAVE_3DNOW) && !defined (HAVE_MMX2)) || defined (RUNTIME_CPUDETECT)
517 #define COMPILE_3DNOW
518 #endif
519 #endif //CAN_COMPILE_X86_ASM
520
521 #undef HAVE_MMX
522 #undef HAVE_MMX2
523 #undef HAVE_3DNOW
524
525 #ifdef COMPILE_C
526 #undef HAVE_MMX
527 #undef HAVE_MMX2
528 #undef HAVE_3DNOW
529 #define RENAME(a) a ## _C
530 #include "swscale_template.c"
531 #endif
532
533 #ifdef CAN_COMPILE_X86_ASM
534
535 //X86 versions
536 /*
537 #undef RENAME
538 #undef HAVE_MMX
539 #undef HAVE_MMX2
540 #undef HAVE_3DNOW
541 #define ARCH_X86
542 #define RENAME(a) a ## _X86
543 #include "swscale_template.c"
544 */
545 //MMX versions
546 #ifdef COMPILE_MMX
547 #undef RENAME
548 #define HAVE_MMX
549 #undef HAVE_MMX2
550 #undef HAVE_3DNOW
551 #define RENAME(a) a ## _MMX
552 #include "swscale_template.c"
553 #endif
554
555 //MMX2 versions
556 #ifdef COMPILE_MMX2
557 #undef RENAME
558 #define HAVE_MMX
559 #define HAVE_MMX2
560 #undef HAVE_3DNOW
561 #define RENAME(a) a ## _MMX2
562 #include "swscale_template.c"
563 #endif
564
565 //3DNOW versions
566 #ifdef COMPILE_3DNOW
567 #undef RENAME
568 #define HAVE_MMX
569 #undef HAVE_MMX2
570 #define HAVE_3DNOW
571 #define RENAME(a) a ## _3DNow
572 #include "swscale_template.c"
573 #endif
574
575 #endif //CAN_COMPILE_X86_ASM
576
577 // minor note: the HAVE_xyz is messed up after that line so dont use it
578
579
580 // old global scaler, dont use for new code
581 // will use sws_flags from the command line
582 void SwScale_YV12slice(unsigned char* src[], int srcStride[], int srcSliceY ,
583                              int srcSliceH, uint8_t* dst[], int dstStride, int dstbpp,
584                              int srcW, int srcH, int dstW, int dstH){
585
586         static SwsContext *context=NULL;
587         int dstFormat;
588         int dstStride3[3]= {dstStride, dstStride>>1, dstStride>>1};
589
590         switch(dstbpp)
591         {
592                 case 8 : dstFormat= IMGFMT_Y8;          break;
593                 case 12: dstFormat= IMGFMT_YV12;        break;
594                 case 15: dstFormat= IMGFMT_BGR15;       break;
595                 case 16: dstFormat= IMGFMT_BGR16;       break;
596                 case 24: dstFormat= IMGFMT_BGR24;       break;
597                 case 32: dstFormat= IMGFMT_BGR32;       break;
598                 default: return;
599         }
600
601         if(!context) context=getSwsContextFromCmdLine(srcW, srcH, IMGFMT_YV12, dstW, dstH, dstFormat);
602
603         context->swScale(context, src, srcStride, srcSliceY, srcSliceH, dst, dstStride3);
604 }
605
606 // will use sws_flags & src_filter (from cmd line)
607 SwsContext *getSwsContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)
608 {
609         int flags=0;
610         static int firstTime=1;
611
612 #ifdef ARCH_X86
613         if(gCpuCaps.hasMMX)
614                 asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
615 #endif
616         if(firstTime)
617         {
618                 firstTime=0;
619                 flags= SWS_PRINT_INFO;
620         }
621         else if(verbose>1) flags= SWS_PRINT_INFO;
622
623         if(src_filter.lumH) freeVec(src_filter.lumH);
624         if(src_filter.lumV) freeVec(src_filter.lumV);
625         if(src_filter.chrH) freeVec(src_filter.chrH);
626         if(src_filter.chrV) freeVec(src_filter.chrV);
627
628         if(sws_lum_gblur!=0.0){
629                 src_filter.lumH= getGaussianVec(sws_lum_gblur, 3.0);
630                 src_filter.lumV= getGaussianVec(sws_lum_gblur, 3.0);
631         }else{
632                 src_filter.lumH= getIdentityVec();
633                 src_filter.lumV= getIdentityVec();
634         }
635
636         if(sws_chr_gblur!=0.0){
637                 src_filter.chrH= getGaussianVec(sws_chr_gblur, 3.0);
638                 src_filter.chrV= getGaussianVec(sws_chr_gblur, 3.0);
639         }else{
640                 src_filter.chrH= getIdentityVec();
641                 src_filter.chrV= getIdentityVec();
642         }
643
644         if(sws_chr_sharpen!=0.0){
645                 SwsVector *g= getConstVec(-1.0, 3);
646                 SwsVector *id= getConstVec(10.0/sws_chr_sharpen, 1);
647                 g->coeff[1]=2.0;
648                 addVec(id, g);
649                 convVec(src_filter.chrH, id);
650                 convVec(src_filter.chrV, id);
651                 freeVec(g);
652                 freeVec(id);
653         }
654
655         if(sws_lum_sharpen!=0.0){
656                 SwsVector *g= getConstVec(-1.0, 3);
657                 SwsVector *id= getConstVec(10.0/sws_lum_sharpen, 1);
658                 g->coeff[1]=2.0;
659                 addVec(id, g);
660                 convVec(src_filter.lumH, id);
661                 convVec(src_filter.lumV, id);
662                 freeVec(g);
663                 freeVec(id);
664         }
665
666         if(sws_chr_hshift)
667                 shiftVec(src_filter.chrH, sws_chr_hshift);
668
669         if(sws_chr_vshift)
670                 shiftVec(src_filter.chrV, sws_chr_vshift);
671
672         normalizeVec(src_filter.chrH, 1.0);
673         normalizeVec(src_filter.chrV, 1.0);
674         normalizeVec(src_filter.lumH, 1.0);
675         normalizeVec(src_filter.lumV, 1.0);
676
677         if(verbose > 1) printVec(src_filter.chrH);
678         if(verbose > 1) printVec(src_filter.lumH);
679
680         switch(sws_flags)
681         {
682                 case 0: flags|= SWS_FAST_BILINEAR; break;
683                 case 1: flags|= SWS_BILINEAR; break;
684                 case 2: flags|= SWS_BICUBIC; break;
685                 case 3: flags|= SWS_X; break;
686                 case 4: flags|= SWS_POINT; break;
687                 case 5: flags|= SWS_AREA; break;
688                 default:flags|= SWS_BILINEAR; break;
689         }
690
691         return getSwsContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags, &src_filter, NULL);
692 }
693
694
695 static inline void initFilter(int16_t **outFilter, int16_t **filterPos, int *outFilterSize, int xInc,
696                               int srcW, int dstW, int filterAlign, int one, int flags,
697                               SwsVector *srcFilter, SwsVector *dstFilter)
698 {
699         int i;
700         int filterSize;
701         int filter2Size;
702         int minFilterSize;
703         double *filter=NULL;
704         double *filter2=NULL;
705 #ifdef ARCH_X86
706         if(gCpuCaps.hasMMX)
707                 asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
708 #endif
709
710         // Note the +1 is for the MMXscaler which reads over the end
711         *filterPos = (int16_t*)memalign(8, (dstW+1)*sizeof(int16_t));
712
713         if(ABS(xInc - 0x10000) <10) // unscaled
714         {
715                 int i;
716                 filterSize= 1;
717                 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
718                 for(i=0; i<dstW*filterSize; i++) filter[i]=0;
719
720                 for(i=0; i<dstW; i++)
721                 {
722                         filter[i*filterSize]=1;
723                         (*filterPos)[i]=i;
724                 }
725
726         }
727         else if(flags&SWS_POINT) // lame looking point sampling mode
728         {
729                 int i;
730                 int xDstInSrc;
731                 filterSize= 1;
732                 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
733                 
734                 xDstInSrc= xInc/2 - 0x8000;
735                 for(i=0; i<dstW; i++)
736                 {
737                         int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
738
739                         (*filterPos)[i]= xx;
740                         filter[i]= 1.0;
741                         xDstInSrc+= xInc;
742                 }
743         }
744         else if(xInc <= (1<<16) || (flags&SWS_FAST_BILINEAR)) // upscale
745         {
746                 int i;
747                 int xDstInSrc;
748                 if     (flags&SWS_BICUBIC) filterSize= 4;
749                 else if(flags&SWS_X      ) filterSize= 4;
750                 else                       filterSize= 2; // SWS_BILINEAR / SWS_AREA 
751 //              printf("%d %d %d\n", filterSize, srcW, dstW);
752                 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
753
754                 xDstInSrc= xInc/2 - 0x8000;
755                 for(i=0; i<dstW; i++)
756                 {
757                         int xx= (xDstInSrc - ((filterSize-1)<<15) + (1<<15))>>16;
758                         int j;
759
760                         (*filterPos)[i]= xx;
761                         if((flags & SWS_BICUBIC) || (flags & SWS_X))
762                         {
763                                 double d= ABS(((xx+1)<<16) - xDstInSrc)/(double)(1<<16);
764                                 double y1,y2,y3,y4;
765                                 double A= -0.6;
766                                 if(flags & SWS_BICUBIC){
767                                                 // Equation is from VirtualDub
768                                         y1 = (        +     A*d -       2.0*A*d*d +       A*d*d*d);
769                                         y2 = (+ 1.0             -     (A+3.0)*d*d + (A+2.0)*d*d*d);
770                                         y3 = (        -     A*d + (2.0*A+3.0)*d*d - (A+2.0)*d*d*d);
771                                         y4 = (                  +           A*d*d -       A*d*d*d);
772                                 }else{
773                                                 // cubic interpolation (derived it myself)
774                                         y1 = (    -2.0*d + 3.0*d*d - 1.0*d*d*d)/6.0;
775                                         y2 = (6.0 -3.0*d - 6.0*d*d + 3.0*d*d*d)/6.0;
776                                         y3 = (    +6.0*d + 3.0*d*d - 3.0*d*d*d)/6.0;
777                                         y4 = (    -1.0*d           + 1.0*d*d*d)/6.0;
778                                 }
779
780 //                              printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
781                                 filter[i*filterSize + 0]= y1;
782                                 filter[i*filterSize + 1]= y2;
783                                 filter[i*filterSize + 2]= y3;
784                                 filter[i*filterSize + 3]= y4;
785 //                              printf("%1.3f %1.3f %1.3f %1.3f %1.3f\n",d , y1, y2, y3, y4);
786                         }
787                         else
788                         {
789                                 //Bilinear upscale / linear interpolate / Area averaging
790                                 for(j=0; j<filterSize; j++)
791                                 {
792                                         double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16);
793                                         double coeff= 1.0 - d;
794                                         if(coeff<0) coeff=0;
795         //                              printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
796                                         filter[i*filterSize + j]= coeff;
797                                         xx++;
798                                 }
799                         }
800                         xDstInSrc+= xInc;
801                 }
802         }
803         else // downscale
804         {
805                 int xDstInSrc;
806                 ASSERT(dstW <= srcW)
807
808                 if(flags&SWS_BICUBIC)   filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
809                 else if(flags&SWS_X)    filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
810                 else if(flags&SWS_AREA) filterSize= (int)ceil(1 + 1.0*srcW / (double)dstW);
811                 else /* BILINEAR */     filterSize= (int)ceil(1 + 2.0*srcW / (double)dstW);
812 //              printf("%d %d %d\n", *filterSize, srcW, dstW);
813                 filter= (double*)memalign(8, dstW*sizeof(double)*filterSize);
814
815                 xDstInSrc= xInc/2 - 0x8000;
816                 for(i=0; i<dstW; i++)
817                 {
818                         int xx= (int)((double)xDstInSrc/(double)(1<<16) - (filterSize-1)*0.5 + 0.5);
819                         int j;
820                         (*filterPos)[i]= xx;
821                         for(j=0; j<filterSize; j++)
822                         {
823                                 double d= ABS((xx<<16) - xDstInSrc)/(double)xInc;
824                                 double coeff;
825                                 if((flags & SWS_BICUBIC) || (flags & SWS_X))
826                                 {
827                                         double A= -0.75;
828 //                                      d*=2;
829                                         // Equation is from VirtualDub
830                                         if(d<1.0)
831                                                 coeff = (1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d);
832                                         else if(d<2.0)
833                                                 coeff = (-4.0*A + 8.0*A*d - 5.0*A*d*d + A*d*d*d);
834                                         else
835                                                 coeff=0.0;
836                                 }
837                                 else if(flags & SWS_AREA)
838                                 {
839                                         double srcPixelSize= (1<<16)/(double)xInc;
840                                         if(d + srcPixelSize/2 < 0.5) coeff= 1.0;
841                                         else if(d - srcPixelSize/2 < 0.5) coeff= (0.5-d)/srcPixelSize + 0.5;
842                                         else coeff=0.0;
843                                 }
844                                 else
845                                 {
846                                         coeff= 1.0 - d;
847                                         if(coeff<0) coeff=0;
848                                 }
849 //                              printf("%1.3f %2.3f %d \n", coeff, d, xDstInSrc);
850                                 filter[i*filterSize + j]= coeff;
851                                 xx++;
852                         }
853                         xDstInSrc+= xInc;
854                 }
855         }
856
857         /* apply src & dst Filter to filter -> filter2
858            free(filter);
859         */
860         ASSERT(filterSize>0)
861         filter2Size= filterSize;
862         if(srcFilter) filter2Size+= srcFilter->length - 1;
863         if(dstFilter) filter2Size+= dstFilter->length - 1;
864         ASSERT(filter2Size>0)
865         filter2= (double*)memalign(8, filter2Size*dstW*sizeof(double));
866
867         for(i=0; i<dstW; i++)
868         {
869                 int j;
870                 SwsVector scaleFilter;
871                 SwsVector *outVec;
872
873                 scaleFilter.coeff= filter + i*filterSize;
874                 scaleFilter.length= filterSize;
875
876                 if(srcFilter) outVec= getConvVec(srcFilter, &scaleFilter);
877                 else          outVec= &scaleFilter;
878
879                 ASSERT(outVec->length == filter2Size)
880                 //FIXME dstFilter
881
882                 for(j=0; j<outVec->length; j++)
883                 {
884                         filter2[i*filter2Size + j]= outVec->coeff[j];
885                 }
886
887                 (*filterPos)[i]+= (filterSize-1)/2 - (filter2Size-1)/2;
888
889                 if(outVec != &scaleFilter) freeVec(outVec);
890         }
891         free(filter); filter=NULL;
892
893         /* try to reduce the filter-size (step1 find size and shift left) */
894         // Assume its near normalized (*0.5 or *2.0 is ok but * 0.001 is not)
895         minFilterSize= 0;
896         for(i=dstW-1; i>=0; i--)
897         {
898                 int min= filter2Size;
899                 int j;
900                 double cutOff=0.0;
901
902                 /* get rid off near zero elements on the left by shifting left */
903                 for(j=0; j<filter2Size; j++)
904                 {
905                         int k;
906                         cutOff += ABS(filter2[i*filter2Size]);
907
908                         if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
909
910                         /* preserve Monotonicity because the core cant handle the filter otherwise */
911                         if(i<dstW-1 && (*filterPos)[i] >= (*filterPos)[i+1]) break;
912
913                         // Move filter coeffs left
914                         for(k=1; k<filter2Size; k++)
915                                 filter2[i*filter2Size + k - 1]= filter2[i*filter2Size + k];
916                         filter2[i*filter2Size + k - 1]= 0.0;
917                         (*filterPos)[i]++;
918                 }
919
920                 cutOff=0.0;
921                 /* count near zeros on the right */
922                 for(j=filter2Size-1; j>0; j--)
923                 {
924                         cutOff += ABS(filter2[i*filter2Size + j]);
925
926                         if(cutOff > SWS_MAX_REDUCE_CUTOFF) break;
927                         min--;
928                 }
929
930                 if(min>minFilterSize) minFilterSize= min;
931         }
932
933         ASSERT(minFilterSize > 0)
934         filterSize= (minFilterSize +(filterAlign-1)) & (~(filterAlign-1));
935         ASSERT(filterSize > 0)
936         filter= (double*)memalign(8, filterSize*dstW*sizeof(double));
937         *outFilterSize= filterSize;
938
939         if((flags&SWS_PRINT_INFO) && verbose)
940                 printf("SwScaler: reducing / aligning filtersize %d -> %d\n", filter2Size, filterSize);
941         /* try to reduce the filter-size (step2 reduce it) */
942         for(i=0; i<dstW; i++)
943         {
944                 int j;
945
946                 for(j=0; j<filterSize; j++)
947                 {
948                         if(j>=filter2Size) filter[i*filterSize + j]= 0.0;
949                         else               filter[i*filterSize + j]= filter2[i*filter2Size + j];
950                 }
951         }
952         free(filter2); filter2=NULL;
953         
954
955         //FIXME try to align filterpos if possible
956
957         //fix borders
958         for(i=0; i<dstW; i++)
959         {
960                 int j;
961                 if((*filterPos)[i] < 0)
962                 {
963                         // Move filter coeffs left to compensate for filterPos
964                         for(j=1; j<filterSize; j++)
965                         {
966                                 int left= MAX(j + (*filterPos)[i], 0);
967                                 filter[i*filterSize + left] += filter[i*filterSize + j];
968                                 filter[i*filterSize + j]=0;
969                         }
970                         (*filterPos)[i]= 0;
971                 }
972
973                 if((*filterPos)[i] + filterSize > srcW)
974                 {
975                         int shift= (*filterPos)[i] + filterSize - srcW;
976                         // Move filter coeffs right to compensate for filterPos
977                         for(j=filterSize-2; j>=0; j--)
978                         {
979                                 int right= MIN(j + shift, filterSize-1);
980                                 filter[i*filterSize +right] += filter[i*filterSize +j];
981                                 filter[i*filterSize +j]=0;
982                         }
983                         (*filterPos)[i]= srcW - filterSize;
984                 }
985         }
986
987         // Note the +1 is for the MMXscaler which reads over the end
988         *outFilter= (int16_t*)memalign(8, *outFilterSize*(dstW+1)*sizeof(int16_t));
989         memset(*outFilter, 0, *outFilterSize*(dstW+1)*sizeof(int16_t));
990
991         /* Normalize & Store in outFilter */
992         for(i=0; i<dstW; i++)
993         {
994                 int j;
995                 double sum=0;
996                 double scale= one;
997                 for(j=0; j<filterSize; j++)
998                 {
999                         sum+= filter[i*filterSize + j];
1000                 }
1001                 scale/= sum;
1002                 for(j=0; j<filterSize; j++)
1003                 {
1004                         (*outFilter)[i*(*outFilterSize) + j]= (int)(filter[i*filterSize + j]*scale);
1005                 }
1006         }
1007         
1008         (*filterPos)[dstW]= (*filterPos)[dstW-1]; // the MMX scaler will read over the end
1009         for(i=0; i<*outFilterSize; i++)
1010         {
1011                 int j= dstW*(*outFilterSize);
1012                 (*outFilter)[j + i]= (*outFilter)[j + i - (*outFilterSize)];
1013         }
1014
1015         free(filter);
1016 }
1017
1018 #ifdef ARCH_X86
1019 static void initMMX2HScaler(int dstW, int xInc, uint8_t *funnyCode, int16_t *filter, int32_t *filterPos, int numSplits)
1020 {
1021         uint8_t *fragmentA;
1022         int imm8OfPShufW1A;
1023         int imm8OfPShufW2A;
1024         int fragmentLengthA;
1025         uint8_t *fragmentB;
1026         int imm8OfPShufW1B;
1027         int imm8OfPShufW2B;
1028         int fragmentLengthB;
1029         int fragmentPos;
1030
1031         int xpos, i;
1032
1033         // create an optimized horizontal scaling routine
1034
1035         //code fragment
1036
1037         asm volatile(
1038                 "jmp 9f                         \n\t"
1039         // Begin
1040                 "0:                             \n\t"
1041                 "movq (%%edx, %%eax), %%mm3     \n\t" 
1042                 "movd (%%ecx, %%esi), %%mm0     \n\t" 
1043                 "movd 1(%%ecx, %%esi), %%mm1    \n\t"
1044                 "punpcklbw %%mm7, %%mm1         \n\t"
1045                 "punpcklbw %%mm7, %%mm0         \n\t"
1046                 "pshufw $0xFF, %%mm1, %%mm1     \n\t"
1047                 "1:                             \n\t"
1048                 "pshufw $0xFF, %%mm0, %%mm0     \n\t"
1049                 "2:                             \n\t"
1050                 "psubw %%mm1, %%mm0             \n\t"
1051                 "movl 8(%%ebx, %%eax), %%esi    \n\t"
1052                 "pmullw %%mm3, %%mm0            \n\t"
1053                 "psllw $7, %%mm1                \n\t"
1054                 "paddw %%mm1, %%mm0             \n\t"
1055
1056                 "movq %%mm0, (%%edi, %%eax)     \n\t"
1057
1058                 "addl $8, %%eax                 \n\t"
1059         // End
1060                 "9:                             \n\t"
1061 //              "int $3\n\t"
1062                 "leal 0b, %0                    \n\t"
1063                 "leal 1b, %1                    \n\t"
1064                 "leal 2b, %2                    \n\t"
1065                 "decl %1                        \n\t"
1066                 "decl %2                        \n\t"
1067                 "subl %0, %1                    \n\t"
1068                 "subl %0, %2                    \n\t"
1069                 "leal 9b, %3                    \n\t"
1070                 "subl %0, %3                    \n\t"
1071
1072
1073                 :"=r" (fragmentA), "=r" (imm8OfPShufW1A), "=r" (imm8OfPShufW2A),
1074                 "=r" (fragmentLengthA)
1075         );
1076
1077         asm volatile(
1078                 "jmp 9f                         \n\t"
1079         // Begin
1080                 "0:                             \n\t"
1081                 "movq (%%edx, %%eax), %%mm3     \n\t" 
1082                 "movd (%%ecx, %%esi), %%mm0     \n\t" 
1083                 "punpcklbw %%mm7, %%mm0         \n\t"
1084                 "pshufw $0xFF, %%mm0, %%mm1     \n\t"
1085                 "1:                             \n\t"
1086                 "pshufw $0xFF, %%mm0, %%mm0     \n\t"
1087                 "2:                             \n\t"
1088                 "psubw %%mm1, %%mm0             \n\t"
1089                 "movl 8(%%ebx, %%eax), %%esi    \n\t"
1090                 "pmullw %%mm3, %%mm0            \n\t"
1091                 "psllw $7, %%mm1                \n\t"
1092                 "paddw %%mm1, %%mm0             \n\t"
1093
1094                 "movq %%mm0, (%%edi, %%eax)     \n\t"
1095
1096                 "addl $8, %%eax                 \n\t"
1097         // End
1098                 "9:                             \n\t"
1099 //              "int $3\n\t"
1100                 "leal 0b, %0                    \n\t"
1101                 "leal 1b, %1                    \n\t"
1102                 "leal 2b, %2                    \n\t"
1103                 "decl %1                        \n\t"
1104                 "decl %2                        \n\t"
1105                 "subl %0, %1                    \n\t"
1106                 "subl %0, %2                    \n\t"
1107                 "leal 9b, %3                    \n\t"
1108                 "subl %0, %3                    \n\t"
1109
1110
1111                 :"=r" (fragmentB), "=r" (imm8OfPShufW1B), "=r" (imm8OfPShufW2B),
1112                 "=r" (fragmentLengthB)
1113         );
1114
1115         xpos= 0; //lumXInc/2 - 0x8000; // difference between pixel centers
1116         fragmentPos=0;
1117         
1118         for(i=0; i<dstW/numSplits; i++)
1119         {
1120                 int xx=xpos>>16;
1121
1122                 if((i&3) == 0)
1123                 {
1124                         int a=0;
1125                         int b=((xpos+xInc)>>16) - xx;
1126                         int c=((xpos+xInc*2)>>16) - xx;
1127                         int d=((xpos+xInc*3)>>16) - xx;
1128
1129                         filter[i  ] = (( xpos         & 0xFFFF) ^ 0xFFFF)>>9;
1130                         filter[i+1] = (((xpos+xInc  ) & 0xFFFF) ^ 0xFFFF)>>9;
1131                         filter[i+2] = (((xpos+xInc*2) & 0xFFFF) ^ 0xFFFF)>>9;
1132                         filter[i+3] = (((xpos+xInc*3) & 0xFFFF) ^ 0xFFFF)>>9;
1133                         filterPos[i/2]= xx;
1134
1135                         if(d+1<4)
1136                         {
1137                                 int maxShift= 3-(d+1);
1138                                 int shift=0;
1139
1140                                 memcpy(funnyCode + fragmentPos, fragmentB, fragmentLengthB);
1141
1142                                 funnyCode[fragmentPos + imm8OfPShufW1B]=
1143                                         (a+1) | ((b+1)<<2) | ((c+1)<<4) | ((d+1)<<6);
1144                                 funnyCode[fragmentPos + imm8OfPShufW2B]=
1145                                         a | (b<<2) | (c<<4) | (d<<6);
1146
1147                                 if(i+3>=dstW) shift=maxShift; //avoid overread
1148                                 else if((filterPos[i/2]&3) <= maxShift) shift=filterPos[i/2]&3; //Align
1149
1150                                 if(shift && i>=shift)
1151                                 {
1152                                         funnyCode[fragmentPos + imm8OfPShufW1B]+= 0x55*shift;
1153                                         funnyCode[fragmentPos + imm8OfPShufW2B]+= 0x55*shift;
1154                                         filterPos[i/2]-=shift;
1155                                 }
1156
1157                                 fragmentPos+= fragmentLengthB;
1158                         }
1159                         else
1160                         {
1161                                 int maxShift= 3-d;
1162                                 int shift=0;
1163
1164                                 memcpy(funnyCode + fragmentPos, fragmentA, fragmentLengthA);
1165
1166                                 funnyCode[fragmentPos + imm8OfPShufW1A]=
1167                                 funnyCode[fragmentPos + imm8OfPShufW2A]=
1168                                         a | (b<<2) | (c<<4) | (d<<6);
1169
1170                                 if(i+4>=dstW) shift=maxShift; //avoid overread
1171                                 else if((filterPos[i/2]&3) <= maxShift) shift=filterPos[i/2]&3; //partial align
1172
1173                                 if(shift && i>=shift)
1174                                 {
1175                                         funnyCode[fragmentPos + imm8OfPShufW1A]+= 0x55*shift;
1176                                         funnyCode[fragmentPos + imm8OfPShufW2A]+= 0x55*shift;
1177                                         filterPos[i/2]-=shift;
1178                                 }
1179
1180                                 fragmentPos+= fragmentLengthA;
1181                         }
1182
1183                         funnyCode[fragmentPos]= RET;
1184                 }
1185                 xpos+=xInc;
1186         }
1187         filterPos[i/2]= xpos>>16; // needed to jump to the next part
1188 }
1189 #endif // ARCH_X86
1190
1191 //FIXME remove
1192 void SwScale_Init(){
1193 }
1194
1195 static void globalInit(){
1196     // generating tables:
1197     int i;
1198     for(i=0; i<768; i++){
1199         int c= MIN(MAX(i-256, 0), 255);
1200         clip_table[i]=c;
1201         yuvtab_2568[c]= clip_yuvtab_2568[i]=(0x2568*(c-16))+(256<<13);
1202         yuvtab_3343[c]= clip_yuvtab_3343[i]=0x3343*(c-128);
1203         yuvtab_0c92[c]= clip_yuvtab_0c92[i]=-0x0c92*(c-128);
1204         yuvtab_1a1e[c]= clip_yuvtab_1a1e[i]=-0x1a1e*(c-128);
1205         yuvtab_40cf[c]= clip_yuvtab_40cf[i]=0x40cf*(c-128);
1206     }
1207
1208     for(i=0; i<768; i++)
1209     {
1210         int v= clip_table[i];
1211         clip_table16b[i]=  v>>3;
1212         clip_table16g[i]= (v<<3)&0x07E0;
1213         clip_table16r[i]= (v<<8)&0xF800;
1214         clip_table15b[i]=  v>>3;
1215         clip_table15g[i]= (v<<2)&0x03E0;
1216         clip_table15r[i]= (v<<7)&0x7C00;
1217     }
1218
1219 cpuCaps= gCpuCaps;
1220
1221 #ifdef RUNTIME_CPUDETECT
1222 #ifdef CAN_COMPILE_X86_ASM
1223         // ordered per speed fasterst first
1224         if(gCpuCaps.hasMMX2)
1225                 swScale= swScale_MMX2;
1226         else if(gCpuCaps.has3DNow)
1227                 swScale= swScale_3DNow;
1228         else if(gCpuCaps.hasMMX)
1229                 swScale= swScale_MMX;
1230         else
1231                 swScale= swScale_C;
1232
1233 #else
1234         swScale= swScale_C;
1235         cpuCaps.hasMMX2 = cpuCaps.hasMMX = cpuCaps.has3DNow = 0;
1236 #endif
1237 #else //RUNTIME_CPUDETECT
1238 #ifdef HAVE_MMX2
1239         swScale= swScale_MMX2;
1240         cpuCaps.has3DNow = 0;
1241 #elif defined (HAVE_3DNOW)
1242         swScale= swScale_3DNow;
1243         cpuCaps.hasMMX2 = 0;
1244 #elif defined (HAVE_MMX)
1245         swScale= swScale_MMX;
1246         cpuCaps.hasMMX2 = cpuCaps.has3DNow = 0;
1247 #else
1248         swScale= swScale_C;
1249         cpuCaps.hasMMX2 = cpuCaps.hasMMX = cpuCaps.has3DNow = 0;
1250 #endif
1251 #endif //!RUNTIME_CPUDETECT
1252 }
1253
1254 /* Warper functions for yuv2bgr */
1255 static void planarYuvToBgr(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
1256              int srcSliceH, uint8_t* dstParam[], int dstStride[]){
1257         uint8_t *dst=dstParam[0] + dstStride[0]*srcSliceY;
1258
1259         if(c->srcFormat==IMGFMT_YV12)
1260                 yuv2rgb( dst,src[0],src[1],src[2],c->srcW,srcSliceH,dstStride[0],srcStride[0],srcStride[1] );
1261         else /* I420 & IYUV */
1262                 yuv2rgb( dst,src[0],src[2],src[1],c->srcW,srcSliceH,dstStride[0],srcStride[0],srcStride[1] );
1263 }
1264
1265 static void bgr24to32Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
1266              int srcSliceH, uint8_t* dst[], int dstStride[]){
1267         
1268         if(dstStride[0]*3==srcStride[0]*4)
1269                 rgb24to32(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
1270         else
1271         {
1272                 int i;
1273                 uint8_t *srcPtr= src[0];
1274                 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
1275
1276                 for(i=0; i<srcSliceH; i++)
1277                 {
1278                         rgb24to32(srcPtr, dstPtr, c->srcW*3);
1279                         srcPtr+= srcStride[0];
1280                         dstPtr+= dstStride[0];
1281                 }
1282         }     
1283 }
1284
1285 static void bgr32to24Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
1286              int srcSliceH, uint8_t* dst[], int dstStride[]){
1287         
1288         if(dstStride[0]*4==srcStride[0]*3)
1289                 rgb32to24(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
1290         else
1291         {
1292                 int i;
1293                 uint8_t *srcPtr= src[0];
1294                 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
1295
1296                 for(i=0; i<srcSliceH; i++)
1297                 {
1298                         rgb32to24(srcPtr, dstPtr, c->srcW<<2);
1299                         srcPtr+= srcStride[0];
1300                         dstPtr+= dstStride[0];
1301                 }
1302         }     
1303 }
1304
1305 static void bgr15to16Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
1306              int srcSliceH, uint8_t* dst[], int dstStride[]){
1307         
1308         if(dstStride[0]==srcStride[0])
1309                 rgb15to16(src[0], dst[0] + dstStride[0]*srcSliceY, srcSliceH*srcStride[0]);
1310         else
1311         {
1312                 int i;
1313                 uint8_t *srcPtr= src[0];
1314                 uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
1315
1316                 for(i=0; i<srcSliceH; i++)
1317                 {
1318                         rgb15to16(srcPtr, dstPtr, c->srcW<<1);
1319                         srcPtr+= srcStride[0];
1320                         dstPtr+= dstStride[0];
1321                 }
1322         }     
1323 }
1324
1325 static void bgr24toyv12Wrapper(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
1326              int srcSliceH, uint8_t* dst[], int dstStride[]){
1327
1328         rgb24toyv12(
1329                 src[0], 
1330                 dst[0]+ srcSliceY    *dstStride[0], 
1331                 dst[1]+(srcSliceY>>1)*dstStride[1], 
1332                 dst[2]+(srcSliceY>>1)*dstStride[2],
1333                 c->srcW, srcSliceH, 
1334                 dstStride[0], dstStride[1], srcStride[0]);
1335 }
1336
1337
1338 /* unscaled copy like stuff (assumes nearly identical formats) */
1339 static void simpleCopy(SwsContext *c, uint8_t* srcParam[], int srcStrideParam[], int srcSliceY,
1340              int srcSliceH, uint8_t* dstParam[], int dstStride[]){
1341
1342         int srcStride[3];
1343         uint8_t *src[3];
1344         uint8_t *dst[3];
1345
1346         if(c->srcFormat == IMGFMT_I420){
1347                 src[0]= srcParam[0];
1348                 src[1]= srcParam[2];
1349                 src[2]= srcParam[1];
1350                 srcStride[0]= srcStrideParam[0];
1351                 srcStride[1]= srcStrideParam[2];
1352                 srcStride[2]= srcStrideParam[1];
1353         }
1354         else if(c->srcFormat==IMGFMT_YV12){
1355                 src[0]= srcParam[0];
1356                 src[1]= srcParam[1];
1357                 src[2]= srcParam[2];
1358                 srcStride[0]= srcStrideParam[0];
1359                 srcStride[1]= srcStrideParam[1];
1360                 srcStride[2]= srcStrideParam[2];
1361         }
1362         else if(isPacked(c->srcFormat) || isGray(c->srcFormat)){
1363                 src[0]= srcParam[0];
1364                 src[1]=
1365                 src[2]= NULL;
1366                 srcStride[0]= srcStrideParam[0];
1367                 srcStride[1]=
1368                 srcStride[2]= 0;
1369         }
1370
1371         if(c->dstFormat == IMGFMT_I420){
1372                 dst[0]= dstParam[0];
1373                 dst[1]= dstParam[2];
1374                 dst[2]= dstParam[1];
1375                 
1376         }else{
1377                 dst[0]= dstParam[0];
1378                 dst[1]= dstParam[1];
1379                 dst[2]= dstParam[2];
1380         }
1381
1382         if(isPacked(c->srcFormat))
1383         {
1384                 if(dstStride[0]==srcStride[0])
1385                         memcpy(dst[0] + dstStride[0]*srcSliceY, src[0], srcSliceH*dstStride[0]);
1386                 else
1387                 {
1388                         int i;
1389                         uint8_t *srcPtr= src[0];
1390                         uint8_t *dstPtr= dst[0] + dstStride[0]*srcSliceY;
1391                         int length=0;
1392
1393                         /* universal length finder */
1394                         while(length+c->srcW <= ABS(dstStride[0]) 
1395                            && length+c->srcW <= ABS(srcStride[0])) length+= c->srcW;
1396                         ASSERT(length!=0);
1397
1398                         for(i=0; i<srcSliceH; i++)
1399                         {
1400                                 memcpy(dstPtr, srcPtr, length);
1401                                 srcPtr+= srcStride[0];
1402                                 dstPtr+= dstStride[0];
1403                         }
1404                 }
1405         }
1406         else 
1407         { /* Planar YUV */
1408                 int plane;
1409                 for(plane=0; plane<3; plane++)
1410                 {
1411                         int length= plane==0 ? c->srcW  : ((c->srcW+1)>>1);
1412                         int y=      plane==0 ? srcSliceY: ((srcSliceY+1)>>1);
1413                         int height= plane==0 ? srcSliceH: ((srcSliceH+1)>>1);
1414
1415                         if(dstStride[plane]==srcStride[plane])
1416                                 memcpy(dst[plane] + dstStride[plane]*y, src[plane], height*dstStride[plane]);
1417                         else
1418                         {
1419                                 int i;
1420                                 uint8_t *srcPtr= src[plane];
1421                                 uint8_t *dstPtr= dst[plane] + dstStride[plane]*y;
1422                                 for(i=0; i<height; i++)
1423                                 {
1424                                         memcpy(dstPtr, srcPtr, length);
1425                                         srcPtr+= srcStride[plane];
1426                                         dstPtr+= dstStride[plane];
1427                                 }
1428                         }
1429                 }
1430         }
1431 }
1432
1433 SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags,
1434                          SwsFilter *srcFilter, SwsFilter *dstFilter){
1435
1436         SwsContext *c;
1437         int i;
1438         int usesFilter;
1439         SwsFilter dummyFilter= {NULL, NULL, NULL, NULL};
1440
1441 #ifdef ARCH_X86
1442         if(gCpuCaps.hasMMX)
1443                 asm volatile("emms\n\t"::: "memory");
1444 #endif
1445
1446         if(swScale==NULL) globalInit();
1447
1448         /* avoid dupplicate Formats, so we dont need to check to much */
1449         if(srcFormat==IMGFMT_IYUV) srcFormat=IMGFMT_I420;
1450         if(srcFormat==IMGFMT_Y8)   srcFormat=IMGFMT_Y800;
1451         if(dstFormat==IMGFMT_Y8)   dstFormat=IMGFMT_Y800;
1452
1453         if(!isSupportedIn(srcFormat)) 
1454         {
1455                 fprintf(stderr, "swScaler: %s is not supported as input format\n", vo_format_name(srcFormat));
1456                 return NULL;
1457         }
1458         if(!isSupportedOut(dstFormat))
1459         {
1460                 fprintf(stderr, "swScaler: %s is not supported as output format\n", vo_format_name(dstFormat));
1461                 return NULL;
1462         }
1463
1464         /* sanity check */
1465         if(srcW<4 || srcH<1 || dstW<8 || dstH<1) //FIXME check if these are enough and try to lowwer them after fixing the relevant parts of the code
1466         {
1467                 fprintf(stderr, "swScaler: %dx%d -> %dx%d is invalid scaling dimension\n", 
1468                         srcW, srcH, dstW, dstH);
1469                 return NULL;
1470         }
1471
1472         if(!dstFilter) dstFilter= &dummyFilter;
1473         if(!srcFilter) srcFilter= &dummyFilter;
1474
1475         c= memalign(64, sizeof(SwsContext));
1476         memset(c, 0, sizeof(SwsContext));
1477
1478         c->srcW= srcW;
1479         c->srcH= srcH;
1480         c->dstW= dstW;
1481         c->dstH= dstH;
1482         c->lumXInc= ((srcW<<16) + (dstW>>1))/dstW;
1483         c->lumYInc= ((srcH<<16) + (dstH>>1))/dstH;
1484         c->flags= flags;
1485         c->dstFormat= dstFormat;
1486         c->srcFormat= srcFormat;
1487
1488         usesFilter=0;
1489         if(dstFilter->lumV!=NULL && dstFilter->lumV->length>1) usesFilter=1;
1490         if(dstFilter->lumH!=NULL && dstFilter->lumH->length>1) usesFilter=1;
1491         if(dstFilter->chrV!=NULL && dstFilter->chrV->length>1) usesFilter=1;
1492         if(dstFilter->chrH!=NULL && dstFilter->chrH->length>1) usesFilter=1;
1493         if(srcFilter->lumV!=NULL && srcFilter->lumV->length>1) usesFilter=1;
1494         if(srcFilter->lumH!=NULL && srcFilter->lumH->length>1) usesFilter=1;
1495         if(srcFilter->chrV!=NULL && srcFilter->chrV->length>1) usesFilter=1;
1496         if(srcFilter->chrH!=NULL && srcFilter->chrH->length>1) usesFilter=1;
1497         
1498         /* unscaled special Cases */
1499         if(srcW==dstW && srcH==dstH && !usesFilter)
1500         {
1501                 /* yuv2bgr */
1502                 if(isPlanarYUV(srcFormat) && isBGR(dstFormat))
1503                 {
1504                         // FIXME multiple yuv2rgb converters wont work that way cuz that thing is full of globals&statics
1505 #ifdef WORDS_BIGENDIAN
1506                         if(dstFormat==IMGFMT_BGR32)
1507                                 yuv2rgb_init( dstFormat&0xFF /* =bpp */, MODE_BGR);
1508                         else
1509                                 yuv2rgb_init( dstFormat&0xFF /* =bpp */, MODE_RGB);
1510 #else
1511                         yuv2rgb_init( dstFormat&0xFF /* =bpp */, MODE_RGB);
1512 #endif
1513                         c->swScale= planarYuvToBgr;
1514
1515                         if(flags&SWS_PRINT_INFO)
1516                                 printf("SwScaler: using unscaled %s -> %s special converter\n", 
1517                                         vo_format_name(srcFormat), vo_format_name(dstFormat));
1518                         return c;
1519                 }
1520
1521                 /* simple copy */
1522                 if(srcFormat == dstFormat || (isPlanarYUV(srcFormat) && isPlanarYUV(dstFormat)))
1523                 {
1524                         c->swScale= simpleCopy;
1525
1526                         if(flags&SWS_PRINT_INFO)
1527                                 printf("SwScaler: using unscaled %s -> %s special converter\n", 
1528                                         vo_format_name(srcFormat), vo_format_name(dstFormat));
1529                         return c;
1530                 }
1531                 
1532                 /* bgr32to24 & rgb32to24*/
1533                 if((srcFormat==IMGFMT_BGR32 && dstFormat==IMGFMT_BGR24)
1534                  ||(srcFormat==IMGFMT_RGB32 && dstFormat==IMGFMT_RGB24))
1535                 {
1536                         c->swScale= bgr32to24Wrapper;
1537
1538                         if(flags&SWS_PRINT_INFO)
1539                                 printf("SwScaler: using unscaled %s -> %s special converter\n", 
1540                                         vo_format_name(srcFormat), vo_format_name(dstFormat));
1541                         return c;
1542                 }
1543                 
1544                 /* bgr24to32 & rgb24to32*/
1545                 if((srcFormat==IMGFMT_BGR24 && dstFormat==IMGFMT_BGR32)
1546                  ||(srcFormat==IMGFMT_RGB24 && dstFormat==IMGFMT_RGB32))
1547                 {
1548                         c->swScale= bgr24to32Wrapper;
1549
1550                         if(flags&SWS_PRINT_INFO)
1551                                 printf("SwScaler: using unscaled %s -> %s special converter\n", 
1552                                         vo_format_name(srcFormat), vo_format_name(dstFormat));
1553                         return c;
1554                 }
1555
1556                 /* bgr15to16 */
1557                 if(srcFormat==IMGFMT_BGR15 && dstFormat==IMGFMT_BGR16)
1558                 {
1559                         c->swScale= bgr15to16Wrapper;
1560
1561                         if(flags&SWS_PRINT_INFO)
1562                                 printf("SwScaler: using unscaled %s -> %s special converter\n", 
1563                                         vo_format_name(srcFormat), vo_format_name(dstFormat));
1564                         return c;
1565                 }
1566
1567                 /* bgr24toYV12 */
1568                 if(srcFormat==IMGFMT_BGR24 && dstFormat==IMGFMT_YV12)
1569                 {
1570                         c->swScale= bgr24toyv12Wrapper;
1571
1572                         if(flags&SWS_PRINT_INFO)
1573                                 printf("SwScaler: using unscaled %s -> %s special converter\n", 
1574                                         vo_format_name(srcFormat), vo_format_name(dstFormat));
1575                         return c;
1576                 }
1577         }
1578
1579         if(cpuCaps.hasMMX2)
1580         {
1581                 c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
1582                 if(!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR))
1583                 {
1584                         if(flags&SWS_PRINT_INFO)
1585                                 fprintf(stderr, "SwScaler: output Width is not a multiple of 32 -> no MMX2 scaler\n");
1586                 }
1587         }
1588         else
1589                 c->canMMX2BeUsed=0;
1590
1591
1592         /* dont use full vertical UV input/internaly if the source doesnt even have it */
1593         if(isHalfChrV(srcFormat)) c->flags= flags= flags&(~SWS_FULL_CHR_V);
1594         /* dont use full horizontal UV input if the source doesnt even have it */
1595         if(isHalfChrH(srcFormat)) c->flags= flags= flags&(~SWS_FULL_CHR_H_INP);
1596         /* dont use full horizontal UV internally if the destination doesnt even have it */
1597         if(isHalfChrH(dstFormat)) c->flags= flags= flags&(~SWS_FULL_CHR_H_INT);
1598
1599         if(flags&SWS_FULL_CHR_H_INP)    c->chrSrcW= srcW;
1600         else                            c->chrSrcW= (srcW+1)>>1;
1601
1602         if(flags&SWS_FULL_CHR_H_INT)    c->chrDstW= dstW;
1603         else                            c->chrDstW= (dstW+1)>>1;
1604
1605         if(flags&SWS_FULL_CHR_V)        c->chrSrcH= srcH;
1606         else                            c->chrSrcH= (srcH+1)>>1;
1607
1608         if(isHalfChrV(dstFormat))       c->chrDstH= (dstH+1)>>1;
1609         else                            c->chrDstH= dstH;
1610
1611         c->chrXInc= ((c->chrSrcW<<16) + (c->chrDstW>>1))/c->chrDstW;
1612         c->chrYInc= ((c->chrSrcH<<16) + (c->chrDstH>>1))/c->chrDstH;
1613
1614
1615         // match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
1616         // but only for the FAST_BILINEAR mode otherwise do correct scaling
1617         // n-2 is the last chrominance sample available
1618         // this is not perfect, but noone shuld notice the difference, the more correct variant
1619         // would be like the vertical one, but that would require some special code for the
1620         // first and last pixel
1621         if(flags&SWS_FAST_BILINEAR)
1622         {
1623                 if(c->canMMX2BeUsed)
1624                 {
1625                         c->lumXInc+= 20;
1626                         c->chrXInc+= 20;
1627                 }
1628                 //we dont use the x86asm scaler if mmx is available
1629                 else if(cpuCaps.hasMMX)
1630                 {
1631                         c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
1632                         c->chrXInc = ((c->chrSrcW-2)<<16)/(c->chrDstW-2) - 20;
1633                 }
1634         }
1635
1636         /* precalculate horizontal scaler filter coefficients */
1637         {
1638                 const int filterAlign= cpuCaps.hasMMX ? 4 : 1;
1639
1640                 initFilter(&c->hLumFilter, &c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
1641                                  srcW      ,       dstW, filterAlign, 1<<14, flags,
1642                                  srcFilter->lumH, dstFilter->lumH);
1643                 initFilter(&c->hChrFilter, &c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
1644                                 (srcW+1)>>1, c->chrDstW, filterAlign, 1<<14, flags,
1645                                  srcFilter->chrH, dstFilter->chrH);
1646
1647 #ifdef ARCH_X86
1648 // cant downscale !!!
1649                 if(c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR))
1650                 {
1651                         c->lumMmx2Filter   = (int16_t*)memalign(8, (dstW        /8+8)*sizeof(int16_t));
1652                         c->chrMmx2Filter   = (int16_t*)memalign(8, (c->chrDstW  /4+8)*sizeof(int16_t));
1653                         c->lumMmx2FilterPos= (int32_t*)memalign(8, (dstW      /2/8+8)*sizeof(int32_t));
1654                         c->chrMmx2FilterPos= (int32_t*)memalign(8, (c->chrDstW/2/4+8)*sizeof(int32_t));
1655
1656                         initMMX2HScaler(      dstW, c->lumXInc, c->funnyYCode , c->lumMmx2Filter, c->lumMmx2FilterPos, 8);
1657                         initMMX2HScaler(c->chrDstW, c->chrXInc, c->funnyUVCode, c->chrMmx2Filter, c->chrMmx2FilterPos, 4);
1658                 }
1659 #endif
1660         } // Init Horizontal stuff
1661
1662
1663
1664         /* precalculate vertical scaler filter coefficients */
1665         initFilter(&c->vLumFilter, &c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
1666                         srcH      ,        dstH, 1, (1<<12)-4, flags,
1667                         srcFilter->lumV, dstFilter->lumV);
1668         initFilter(&c->vChrFilter, &c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
1669                         (srcH+1)>>1, c->chrDstH, 1, (1<<12)-4, flags,
1670                          srcFilter->chrV, dstFilter->chrV);
1671
1672         // Calculate Buffer Sizes so that they wont run out while handling these damn slices
1673         c->vLumBufSize= c->vLumFilterSize;
1674         c->vChrBufSize= c->vChrFilterSize;
1675         for(i=0; i<dstH; i++)
1676         {
1677                 int chrI= i*c->chrDstH / dstH;
1678                 int nextSlice= MAX(c->vLumFilterPos[i   ] + c->vLumFilterSize - 1,
1679                                  ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<1));
1680                 nextSlice&= ~1; // Slices start at even boundaries
1681                 if(c->vLumFilterPos[i   ] + c->vLumBufSize < nextSlice)
1682                         c->vLumBufSize= nextSlice - c->vLumFilterPos[i   ];
1683                 if(c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>1))
1684                         c->vChrBufSize= (nextSlice>>1) - c->vChrFilterPos[chrI];
1685         }
1686
1687         // allocate pixbufs (we use dynamic allocation because otherwise we would need to
1688         c->lumPixBuf= (int16_t**)memalign(4, c->vLumBufSize*2*sizeof(int16_t*));
1689         c->chrPixBuf= (int16_t**)memalign(4, c->vChrBufSize*2*sizeof(int16_t*));
1690         //Note we need at least one pixel more at the end because of the mmx code (just in case someone wanna replace the 4000/8000)
1691         for(i=0; i<c->vLumBufSize; i++)
1692                 c->lumPixBuf[i]= c->lumPixBuf[i+c->vLumBufSize]= (uint16_t*)memalign(8, 4000);
1693         for(i=0; i<c->vChrBufSize; i++)
1694                 c->chrPixBuf[i]= c->chrPixBuf[i+c->vChrBufSize]= (uint16_t*)memalign(8, 8000);
1695
1696         //try to avoid drawing green stuff between the right end and the stride end
1697         for(i=0; i<c->vLumBufSize; i++) memset(c->lumPixBuf[i], 0, 4000);
1698         for(i=0; i<c->vChrBufSize; i++) memset(c->chrPixBuf[i], 64, 8000);
1699
1700         ASSERT(c->chrDstH <= dstH)
1701
1702         // pack filter data for mmx code
1703         if(cpuCaps.hasMMX)
1704         {
1705                 c->lumMmxFilter= (int16_t*)memalign(8, c->vLumFilterSize*      dstH*4*sizeof(int16_t));
1706                 c->chrMmxFilter= (int16_t*)memalign(8, c->vChrFilterSize*c->chrDstH*4*sizeof(int16_t));
1707                 for(i=0; i<c->vLumFilterSize*dstH; i++)
1708                         c->lumMmxFilter[4*i]=c->lumMmxFilter[4*i+1]=c->lumMmxFilter[4*i+2]=c->lumMmxFilter[4*i+3]=
1709                                 c->vLumFilter[i];
1710                 for(i=0; i<c->vChrFilterSize*c->chrDstH; i++)
1711                         c->chrMmxFilter[4*i]=c->chrMmxFilter[4*i+1]=c->chrMmxFilter[4*i+2]=c->chrMmxFilter[4*i+3]=
1712                                 c->vChrFilter[i];
1713         }
1714
1715         if(flags&SWS_PRINT_INFO)
1716         {
1717 #ifdef DITHER1XBPP
1718                 char *dither= " dithered";
1719 #else
1720                 char *dither= "";
1721 #endif
1722                 if(flags&SWS_FAST_BILINEAR)
1723                         fprintf(stderr, "\nSwScaler: FAST_BILINEAR scaler, ");
1724                 else if(flags&SWS_BILINEAR)
1725                         fprintf(stderr, "\nSwScaler: BILINEAR scaler, ");
1726                 else if(flags&SWS_BICUBIC)
1727                         fprintf(stderr, "\nSwScaler: BICUBIC scaler, ");
1728                 else if(flags&SWS_X)
1729                         fprintf(stderr, "\nSwScaler: Experimental scaler, ");
1730                 else if(flags&SWS_POINT)
1731                         fprintf(stderr, "\nSwScaler: Nearest Neighbor / POINT scaler, ");
1732                 else if(flags&SWS_AREA)
1733                         fprintf(stderr, "\nSwScaler: Area Averageing scaler, ");
1734                 else
1735                         fprintf(stderr, "\nSwScaler: ehh flags invalid?! ");
1736
1737                 if(dstFormat==IMGFMT_BGR15 || dstFormat==IMGFMT_BGR16)
1738                         fprintf(stderr, "from %s to%s %s ", 
1739                                 vo_format_name(srcFormat), dither, vo_format_name(dstFormat));
1740                 else
1741                         fprintf(stderr, "from %s to %s ", 
1742                                 vo_format_name(srcFormat), vo_format_name(dstFormat));
1743
1744                 if(cpuCaps.hasMMX2)
1745                         fprintf(stderr, "using MMX2\n");
1746                 else if(cpuCaps.has3DNow)
1747                         fprintf(stderr, "using 3DNOW\n");
1748                 else if(cpuCaps.hasMMX)
1749                         fprintf(stderr, "using MMX\n");
1750                 else
1751                         fprintf(stderr, "using C\n");
1752         }
1753
1754         if((flags & SWS_PRINT_INFO) && verbose)
1755         {
1756                 if(cpuCaps.hasMMX)
1757                 {
1758                         if(c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))
1759                                 printf("SwScaler: using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
1760                         else
1761                         {
1762                                 if(c->hLumFilterSize==4)
1763                                         printf("SwScaler: using 4-tap MMX scaler for horizontal luminance scaling\n");
1764                                 else if(c->hLumFilterSize==8)
1765                                         printf("SwScaler: using 8-tap MMX scaler for horizontal luminance scaling\n");
1766                                 else
1767                                         printf("SwScaler: using n-tap MMX scaler for horizontal luminance scaling\n");
1768
1769                                 if(c->hChrFilterSize==4)
1770                                         printf("SwScaler: using 4-tap MMX scaler for horizontal chrominance scaling\n");
1771                                 else if(c->hChrFilterSize==8)
1772                                         printf("SwScaler: using 8-tap MMX scaler for horizontal chrominance scaling\n");
1773                                 else
1774                                         printf("SwScaler: using n-tap MMX scaler for horizontal chrominance scaling\n");
1775                         }
1776                 }
1777                 else
1778                 {
1779 #ifdef ARCH_X86
1780                         printf("SwScaler: using X86-Asm scaler for horizontal scaling\n");
1781 #else
1782                         if(flags & SWS_FAST_BILINEAR)
1783                                 printf("SwScaler: using FAST_BILINEAR C scaler for horizontal scaling\n");
1784                         else
1785                                 printf("SwScaler: using C scaler for horizontal scaling\n");
1786 #endif
1787                 }
1788                 if(isPlanarYUV(dstFormat))
1789                 {
1790                         if(c->vLumFilterSize==1)
1791                                 printf("SwScaler: using 1-tap %s \"scaler\" for vertical scaling (YV12 like)\n", cpuCaps.hasMMX ? "MMX" : "C");
1792                         else
1793                                 printf("SwScaler: using n-tap %s scaler for vertical scaling (YV12 like)\n", cpuCaps.hasMMX ? "MMX" : "C");
1794                 }
1795                 else
1796                 {
1797                         if(c->vLumFilterSize==1 && c->vChrFilterSize==2)
1798                                 printf("SwScaler: using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
1799                                        "SwScaler:       2-tap scaler for vertical chrominance scaling (BGR)\n",cpuCaps.hasMMX ? "MMX" : "C");
1800                         else if(c->vLumFilterSize==2 && c->vChrFilterSize==2)
1801                                 printf("SwScaler: using 2-tap linear %s scaler for vertical scaling (BGR)\n", cpuCaps.hasMMX ? "MMX" : "C");
1802                         else
1803                                 printf("SwScaler: using n-tap %s scaler for vertical scaling (BGR)\n", cpuCaps.hasMMX ? "MMX" : "C");
1804                 }
1805
1806                 if(dstFormat==IMGFMT_BGR24)
1807                         printf("SwScaler: using %s YV12->BGR24 Converter\n",
1808                                 cpuCaps.hasMMX2 ? "MMX2" : (cpuCaps.hasMMX ? "MMX" : "C"));
1809                 else if(dstFormat==IMGFMT_BGR32)
1810                         printf("SwScaler: using %s YV12->BGR32 Converter\n", cpuCaps.hasMMX ? "MMX" : "C");
1811                 else if(dstFormat==IMGFMT_BGR16)
1812                         printf("SwScaler: using %s YV12->BGR16 Converter\n", cpuCaps.hasMMX ? "MMX" : "C");
1813                 else if(dstFormat==IMGFMT_BGR15)
1814                         printf("SwScaler: using %s YV12->BGR15 Converter\n", cpuCaps.hasMMX ? "MMX" : "C");
1815
1816                 printf("SwScaler: %dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1817         }
1818         if((flags & SWS_PRINT_INFO) && verbose>1)
1819         {
1820                 printf("SwScaler:Lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1821                         c->srcW, c->srcH, c->dstW, c->dstH, c->lumXInc, c->lumYInc);
1822                 printf("SwScaler:Chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1823                         c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH, c->chrXInc, c->chrYInc);
1824         }
1825
1826         c->swScale= swScale;
1827         return c;
1828 }
1829
1830 /**
1831  * returns a normalized gaussian curve used to filter stuff
1832  * quality=3 is high quality, lowwer is lowwer quality
1833  */
1834
1835 SwsVector *getGaussianVec(double variance, double quality){
1836         const int length= (int)(variance*quality + 0.5) | 1;
1837         int i;
1838         double *coeff= memalign(sizeof(double), length*sizeof(double));
1839         double middle= (length-1)*0.5;
1840         SwsVector *vec= malloc(sizeof(SwsVector));
1841
1842         vec->coeff= coeff;
1843         vec->length= length;
1844
1845         for(i=0; i<length; i++)
1846         {
1847                 double dist= i-middle;
1848                 coeff[i]= exp( -dist*dist/(2*variance*variance) ) / sqrt(2*variance*PI);
1849         }
1850
1851         normalizeVec(vec, 1.0);
1852
1853         return vec;
1854 }
1855
1856 SwsVector *getConstVec(double c, int length){
1857         int i;
1858         double *coeff= memalign(sizeof(double), length*sizeof(double));
1859         SwsVector *vec= malloc(sizeof(SwsVector));
1860
1861         vec->coeff= coeff;
1862         vec->length= length;
1863
1864         for(i=0; i<length; i++)
1865                 coeff[i]= c;
1866
1867         return vec;
1868 }
1869
1870
1871 SwsVector *getIdentityVec(void){
1872         double *coeff= memalign(sizeof(double), sizeof(double));
1873         SwsVector *vec= malloc(sizeof(SwsVector));
1874         coeff[0]= 1.0;
1875
1876         vec->coeff= coeff;
1877         vec->length= 1;
1878
1879         return vec;
1880 }
1881
1882 void normalizeVec(SwsVector *a, double height){
1883         int i;
1884         double sum=0;
1885         double inv;
1886
1887         for(i=0; i<a->length; i++)
1888                 sum+= a->coeff[i];
1889
1890         inv= height/sum;
1891
1892         for(i=0; i<a->length; i++)
1893                 a->coeff[i]*= height;
1894 }
1895
1896 void scaleVec(SwsVector *a, double scalar){
1897         int i;
1898
1899         for(i=0; i<a->length; i++)
1900                 a->coeff[i]*= scalar;
1901 }
1902
1903 static SwsVector *getConvVec(SwsVector *a, SwsVector *b){
1904         int length= a->length + b->length - 1;
1905         double *coeff= memalign(sizeof(double), length*sizeof(double));
1906         int i, j;
1907         SwsVector *vec= malloc(sizeof(SwsVector));
1908
1909         vec->coeff= coeff;
1910         vec->length= length;
1911
1912         for(i=0; i<length; i++) coeff[i]= 0.0;
1913
1914         for(i=0; i<a->length; i++)
1915         {
1916                 for(j=0; j<b->length; j++)
1917                 {
1918                         coeff[i+j]+= a->coeff[i]*b->coeff[j];
1919                 }
1920         }
1921
1922         return vec;
1923 }
1924
1925 static SwsVector *sumVec(SwsVector *a, SwsVector *b){
1926         int length= MAX(a->length, b->length);
1927         double *coeff= memalign(sizeof(double), length*sizeof(double));
1928         int i;
1929         SwsVector *vec= malloc(sizeof(SwsVector));
1930
1931         vec->coeff= coeff;
1932         vec->length= length;
1933
1934         for(i=0; i<length; i++) coeff[i]= 0.0;
1935
1936         for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
1937         for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]+= b->coeff[i];
1938
1939         return vec;
1940 }
1941
1942 static SwsVector *diffVec(SwsVector *a, SwsVector *b){
1943         int length= MAX(a->length, b->length);
1944         double *coeff= memalign(sizeof(double), length*sizeof(double));
1945         int i;
1946         SwsVector *vec= malloc(sizeof(SwsVector));
1947
1948         vec->coeff= coeff;
1949         vec->length= length;
1950
1951         for(i=0; i<length; i++) coeff[i]= 0.0;
1952
1953         for(i=0; i<a->length; i++) coeff[i + (length-1)/2 - (a->length-1)/2]+= a->coeff[i];
1954         for(i=0; i<b->length; i++) coeff[i + (length-1)/2 - (b->length-1)/2]-= b->coeff[i];
1955
1956         return vec;
1957 }
1958
1959 /* shift left / or right if "shift" is negative */
1960 static SwsVector *getShiftedVec(SwsVector *a, int shift){
1961         int length= a->length + ABS(shift)*2;
1962         double *coeff= memalign(sizeof(double), length*sizeof(double));
1963         int i;
1964         SwsVector *vec= malloc(sizeof(SwsVector));
1965
1966         vec->coeff= coeff;
1967         vec->length= length;
1968
1969         for(i=0; i<length; i++) coeff[i]= 0.0;
1970
1971         for(i=0; i<a->length; i++)
1972         {
1973                 coeff[i + (length-1)/2 - (a->length-1)/2 - shift]= a->coeff[i];
1974         }
1975
1976         return vec;
1977 }
1978
1979 void shiftVec(SwsVector *a, int shift){
1980         SwsVector *shifted= getShiftedVec(a, shift);
1981         free(a->coeff);
1982         a->coeff= shifted->coeff;
1983         a->length= shifted->length;
1984         free(shifted);
1985 }
1986
1987 void addVec(SwsVector *a, SwsVector *b){
1988         SwsVector *sum= sumVec(a, b);
1989         free(a->coeff);
1990         a->coeff= sum->coeff;
1991         a->length= sum->length;
1992         free(sum);
1993 }
1994
1995 void subVec(SwsVector *a, SwsVector *b){
1996         SwsVector *diff= diffVec(a, b);
1997         free(a->coeff);
1998         a->coeff= diff->coeff;
1999         a->length= diff->length;
2000         free(diff);
2001 }
2002
2003 void convVec(SwsVector *a, SwsVector *b){
2004         SwsVector *conv= getConvVec(a, b);
2005         free(a->coeff);
2006         a->coeff= conv->coeff;
2007         a->length= conv->length;
2008         free(conv);
2009 }
2010
2011 SwsVector *cloneVec(SwsVector *a){
2012         double *coeff= memalign(sizeof(double), a->length*sizeof(double));
2013         int i;
2014         SwsVector *vec= malloc(sizeof(SwsVector));
2015
2016         vec->coeff= coeff;
2017         vec->length= a->length;
2018
2019         for(i=0; i<a->length; i++) coeff[i]= a->coeff[i];
2020
2021         return vec;
2022 }
2023
2024 void printVec(SwsVector *a){
2025         int i;
2026         double max=0;
2027         double min=0;
2028         double range;
2029
2030         for(i=0; i<a->length; i++)
2031                 if(a->coeff[i]>max) max= a->coeff[i];
2032
2033         for(i=0; i<a->length; i++)
2034                 if(a->coeff[i]<min) min= a->coeff[i];
2035
2036         range= max - min;
2037
2038         for(i=0; i<a->length; i++)
2039         {
2040                 int x= (int)((a->coeff[i]-min)*60.0/range +0.5);
2041                 printf("%1.3f ", a->coeff[i]);
2042                 for(;x>0; x--) printf(" ");
2043                 printf("|\n");
2044         }
2045 }
2046
2047 void freeVec(SwsVector *a){
2048         if(!a) return;
2049         if(a->coeff) free(a->coeff);
2050         a->coeff=NULL;
2051         a->length=0;
2052         free(a);
2053 }
2054
2055 void freeSwsContext(SwsContext *c){
2056         int i;
2057
2058         if(!c) return;
2059
2060         if(c->lumPixBuf)
2061         {
2062                 for(i=0; i<c->vLumBufSize; i++)
2063                 {
2064                         if(c->lumPixBuf[i]) free(c->lumPixBuf[i]);
2065                         c->lumPixBuf[i]=NULL;
2066                 }
2067                 free(c->lumPixBuf);
2068                 c->lumPixBuf=NULL;
2069         }
2070
2071         if(c->chrPixBuf)
2072         {
2073                 for(i=0; i<c->vChrBufSize; i++)
2074                 {
2075                         if(c->chrPixBuf[i]) free(c->chrPixBuf[i]);
2076                         c->chrPixBuf[i]=NULL;
2077                 }
2078                 free(c->chrPixBuf);
2079                 c->chrPixBuf=NULL;
2080         }
2081
2082         if(c->vLumFilter) free(c->vLumFilter);
2083         c->vLumFilter = NULL;
2084         if(c->vChrFilter) free(c->vChrFilter);
2085         c->vChrFilter = NULL;
2086         if(c->hLumFilter) free(c->hLumFilter);
2087         c->hLumFilter = NULL;
2088         if(c->hChrFilter) free(c->hChrFilter);
2089         c->hChrFilter = NULL;
2090
2091         if(c->vLumFilterPos) free(c->vLumFilterPos);
2092         c->vLumFilterPos = NULL;
2093         if(c->vChrFilterPos) free(c->vChrFilterPos);
2094         c->vChrFilterPos = NULL;
2095         if(c->hLumFilterPos) free(c->hLumFilterPos);
2096         c->hLumFilterPos = NULL;
2097         if(c->hChrFilterPos) free(c->hChrFilterPos);
2098         c->hChrFilterPos = NULL;
2099
2100         if(c->lumMmxFilter) free(c->lumMmxFilter);
2101         c->lumMmxFilter = NULL;
2102         if(c->chrMmxFilter) free(c->chrMmxFilter);
2103         c->chrMmxFilter = NULL;
2104
2105         if(c->lumMmx2Filter) free(c->lumMmx2Filter);
2106         c->lumMmx2Filter=NULL;
2107         if(c->chrMmx2Filter) free(c->chrMmx2Filter);
2108         c->chrMmx2Filter=NULL;
2109         if(c->lumMmx2FilterPos) free(c->lumMmx2FilterPos);
2110         c->lumMmx2FilterPos=NULL;
2111         if(c->chrMmx2FilterPos) free(c->chrMmx2FilterPos);
2112         c->chrMmx2FilterPos=NULL;
2113
2114         free(c);
2115 }
2116
2117