removed global vars so that multiple swscalers can be used

experimental upscaling mode (-sws 3)
general convolution filters support (unfinished)
bugfix for bicubic upscaling
assertion checking if defined MP_DEBUG
checking of the input/output size instead of segfault if its very large

Originally committed as revision 4277 to svn://svn.mplayerhq.hu/mplayer/trunk/postproc

3 files changed, 920 insertions, 737 deletions

diff --git a/postproc/swscale.c b/postproc/swscale.c
index 0f51745032..2ba194afc0 100644
--- a/postproc/swscale.c
+++ b/postproc/swscale.c
@@ -5,6 +5,11 @@
 // current version mostly by Michael Niedermayer (michaelni@gmx.at)
 // the parts written by michael are under GNU GPL
 
+/*
+  supported Input formats: YV12 (grayscale soon too)
+  supported output formats: YV12, BGR15, BGR16, BGR24, BGR32 (grayscale soon too)
+*/
+
 #include <inttypes.h>
 #include <string.h>
 #include <math.h>
@@ -16,6 +21,7 @@
 #endif
 #include "swscale.h"
 #include "../cpudetect.h"
+#include "../libvo/img_format.h"
 #undef MOVNTQ
 #undef PAVGB
 
@@ -23,14 +29,20 @@
 //#undef HAVE_MMX
 //#undef ARCH_X86
 #define DITHER1XBPP
-int fullUVIpol=0;
-//disables the unscaled height version
-int allwaysIpol=0;
 
 #define RET 0xC3 //near return opcode
 
-//#define ASSERT(x) if(!(x)) { printf("ASSERT " #x " failed\n"); *((int*)0)=0; }
+#ifdef MP_DEBUG
+#define ASSERT(x) if(!(x)) { printf("ASSERT " #x " failed\n"); *((int*)0)=0; }
+#else
 #define ASSERT(x) ;
+#endif
+
+#ifdef M_PI
+#define PI M_PI
+#else
+#define PI 3.14159265358979323846
+#endif
 
 extern int verbose; // defined in mplayer.c
 /*
@@ -50,7 +62,6 @@ change the distance of the u & v buffer
 Move static / global vars into a struct so multiple scalers can be used
 write special vertical cubic upscale version
 Optimize C code (yv12 / minmax)
-dstStride[3]
 */
 
 #define ABS(a) ((a) > 0 ? (a) : (-(a)))
@@ -101,39 +112,9 @@ static uint64_t __attribute__((aligned(8))) M24A=   0x00FF0000FF0000FFLL;
 static uint64_t __attribute__((aligned(8))) M24B=   0xFF0000FF0000FF00LL;
 static uint64_t __attribute__((aligned(8))) M24C=   0x0000FF0000FF0000LL;
 
-static uint64_t __attribute__((aligned(8))) temp0;
+// FIXME remove
 static uint64_t __attribute__((aligned(8))) asm_yalpha1;
 static uint64_t __attribute__((aligned(8))) asm_uvalpha1;
-
-static int16_t __attribute__((aligned(8))) *lumPixBuf[2000];
-static int16_t __attribute__((aligned(8))) *chrPixBuf[2000];
-static int16_t __attribute__((aligned(8))) hLumFilter[8000];
-static int16_t __attribute__((aligned(8))) hLumFilterPos[2000];
-static int16_t __attribute__((aligned(8))) hChrFilter[8000];
-static int16_t __attribute__((aligned(8))) hChrFilterPos[2000];
-static int16_t __attribute__((aligned(8))) vLumFilter[8000];
-static int16_t __attribute__((aligned(8))) vLumFilterPos[2000];
-static int16_t __attribute__((aligned(8))) vChrFilter[8000];
-static int16_t __attribute__((aligned(8))) vChrFilterPos[2000];
-
-// Contain simply the values from v(Lum|Chr)Filter just nicely packed for mmx
-//FIXME these are very likely too small / 8000 caused problems with 480x480
-static int16_t __attribute__((aligned(8))) lumMmxFilter[16000];
-static int16_t __attribute__((aligned(8))) chrMmxFilter[16000];
-#else
-static int16_t *lumPixBuf[2000];
-static int16_t *chrPixBuf[2000];
-static int16_t hLumFilter[8000];
-static int16_t hLumFilterPos[2000];
-static int16_t hChrFilter[8000];
-static int16_t hChrFilterPos[2000];
-static int16_t vLumFilter[8000];
-static int16_t vLumFilterPos[2000];
-static int16_t vChrFilter[8000];
-static int16_t vChrFilterPos[2000];
-//FIXME just dummy vars
-static int16_t lumMmxFilter[1];
-static int16_t chrMmxFilter[1];
 #endif
 
 // clipping helper table for C implementations:
@@ -159,28 +140,22 @@ static    int clip_yuvtab_0c92[768];
 static    int clip_yuvtab_1a1e[768];
 static    int clip_yuvtab_40cf[768];
 
-static int hLumFilterSize=0;
-static int hChrFilterSize=0;
-static int vLumFilterSize=0;
-static int vChrFilterSize=0;
-static int vLumBufSize=0;
-static int vChrBufSize=0;
-
+//global sws_flags from the command line
 int sws_flags=0;
 
-#ifdef CAN_COMPILE_X86_ASM
-static uint8_t funnyYCode[10000];
-static uint8_t funnyUVCode[10000];
-#endif
+/* cpuCaps combined from cpudetect and whats actually compiled in
+   (if there is no support for something compiled in it wont appear here) */
+static CpuCaps cpuCaps;
 
-static int canMMX2BeUsed=0;
+void (*swScale)(SwsContext *context, uint8_t* src[], int srcStride[], int srcSliceY,
+             int srcSliceH, uint8_t* dst[], int dstStride[])=NULL;
 
 #ifdef CAN_COMPILE_X86_ASM
 void in_asm_used_var_warning_killer()
 {
  volatile int i= yCoeff+vrCoeff+ubCoeff+vgCoeff+ugCoeff+bF8+bFC+w400+w80+w10+
- bm00001111+bm00000111+bm11111000+b16Mask+g16Mask+r16Mask+b15Mask+g15Mask+r15Mask+temp0+asm_yalpha1+ asm_uvalpha1+
- M24A+M24B+M24C+w02 + funnyYCode[0]+ funnyUVCode[0]+b5Dither+g5Dither+r5Dither+g6Dither+dither4[0]+dither8[0];
+ bm00001111+bm00000111+bm11111000+b16Mask+g16Mask+r16Mask+b15Mask+g15Mask+r15Mask+asm_yalpha1+ asm_uvalpha1+
+ M24A+M24B+M24C+w02 + b5Dither+g5Dither+r5Dither+g6Dither+dither4[0]+dither8[0];
  if(i) i=0;
 }
 #endif
@@ -220,9 +195,9 @@ static inline void yuv2yuvXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilt
 
 static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
 				    int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
-				    uint8_t *dest, int dstW, int dstbpp)
+				    uint8_t *dest, int dstW, int dstFormat)
 {
-	if(dstbpp==32)
+	if(dstFormat==IMGFMT_BGR32)
 	{
 		int i;
 		for(i=0; i<(dstW>>1); i++){
@@ -260,7 +235,7 @@ static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilt
 			dest[8*i+6]=clip_table[((Y2 + Cr) >>13)];
 		}
 	}
-	else if(dstbpp==24)
+	else if(dstFormat==IMGFMT_BGR24)
 	{
 		int i;
 		for(i=0; i<(dstW>>1); i++){
@@ -299,7 +274,7 @@ static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilt
 			dest+=6;
 		}
 	}
-	else if(dstbpp==16)
+	else if(dstFormat==IMGFMT_BGR16)
 	{
 		int i;
 		for(i=0; i<(dstW>>1); i++){
@@ -339,7 +314,7 @@ static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilt
 				clip_table16r[(Y2 + Cr) >>13];
 		}
 	}
-	else if(dstbpp==15)
+	else if(dstFormat==IMGFMT_BGR15)
 	{
 		int i;
 		for(i=0; i<(dstW>>1); i++){
@@ -467,42 +442,320 @@ static inline void yuv2rgbXinC(int16_t *lumFilter, int16_t **lumSrc, int lumFilt
 // minor note: the HAVE_xyz is messed up after that line so dont use it
 
 
-// *** bilinear scaling and yuv->rgb or yuv->yuv conversion of yv12 slices:
-// *** Note: it's called multiple times while decoding a frame, first time y==0
-// switching the cpu type during a sliced drawing can have bad effects, like sig11
-void SwScale_YV12slice(unsigned char* srcptr[],int stride[], int srcSliceY ,
-			     int srcSliceH, uint8_t* dstptr[], int dststride, int dstbpp,
+// old global scaler, dont use for new code
+// will use sws_flags from the command line
+void SwScale_YV12slice(unsigned char* src[], int srcStride[], int srcSliceY ,
+			     int srcSliceH, uint8_t* dst[], int dstStride, int dstbpp,
 			     int srcW, int srcH, int dstW, int dstH){
 
-#ifdef RUNTIME_CPUDETECT
-#ifdef CAN_COMPILE_X86_ASM
-	// ordered per speed fasterst first
-	if(gCpuCaps.hasMMX2)
-		SwScale_YV12slice_MMX2(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-	else if(gCpuCaps.has3DNow)
-		SwScale_YV12slice_3DNow(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-	else if(gCpuCaps.hasMMX)
-		SwScale_YV12slice_MMX(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-	else
-		SwScale_YV12slice_C(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-#else
-		SwScale_YV12slice_C(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-#endif
-#else //RUNTIME_CPUDETECT
-#ifdef HAVE_MMX2
-		SwScale_YV12slice_MMX2(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-#elif defined (HAVE_3DNOW)
-		SwScale_YV12slice_3DNow(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-#elif defined (HAVE_MMX)
-		SwScale_YV12slice_MMX(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
-#else
-		SwScale_YV12slice_C(srcptr, stride, srcSliceY, srcSliceH, dstptr, dststride, dstbpp, srcW, srcH, dstW, dstH);
+	static SwsContext *context=NULL;
+	int dstFormat;
+	int flags=0;
+	static int firstTime=1;
+	int dstStride3[3]= {dstStride, dstStride>>1, dstStride>>1};
+
+	if(firstTime)
+	{
+		flags= SWS_PRINT_INFO;
+		firstTime=0;
+	}
+
+	switch(dstbpp)
+	{
+		case 8 : dstFormat= IMGFMT_Y8;		break;
+		case 12: dstFormat= IMGFMT_YV12;	break;
+		case 15: dstFormat= IMGFMT_BGR15;	break;
+		case 16: dstFormat= IMGFMT_BGR16;	break;
+		case 24: dstFormat= IMGFMT_BGR24;	break;
+		case 32: dstFormat= IMGFMT_BGR32;	break;
+		default: return;
+	}
+
+	switch(sws_flags)
+	{
+		case 0: flags|= SWS_FAST_BILINEAR; break;
+		case 1: flags|= SWS_BILINEAR; break;
+		case 2: flags|= SWS_BICUBIC; break;
+		case 3: flags|= SWS_X; break;
+		default:flags|= SWS_BILINEAR; break;
+	}
+
+	if(!context) context=getSwsContext(srcW, srcH, IMGFMT_YV12, dstW, dstH, dstFormat, flags, NULL, NULL);
+
+
+	swScale(context, src, srcStride, srcSliceY, srcSliceH, dst, dstStride3);
+}
+
+static inline void initFilter(int16_t *dstFilter, int16_t *filterPos, int *filterSize, int xInc,
+			      int srcW, int dstW, int filterAlign, int one, int flags)
+{
+	int i;
+	double filter[10000];
+#ifdef ARCH_X86
+	if(gCpuCaps.hasMMX)
+		asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
 #endif
-#endif //!RUNTIME_CPUDETECT
 
+	if(ABS(xInc - 0x10000) <10) // unscaled
+	{
+		int i;
+		*filterSize= (1 +(filterAlign-1)) & (~(filterAlign-1)); // 1 or 4 normaly
+		for(i=0; i<dstW*(*filterSize); i++) filter[i]=0;
+
+		for(i=0; i<dstW; i++)
+		{
+			filter[i*(*filterSize)]=1;
+			filterPos[i]=i;
+		}
+
+	}
+	else if(xInc <= (1<<16) || (flags&SWS_FAST_BILINEAR)) // upscale
+	{
+		int i;
+		int xDstInSrc;
+		if     (flags&SWS_BICUBIC) *filterSize= 4;
+		else if(flags&SWS_X      ) *filterSize= 4;
+		else			   *filterSize= 2;
+//		printf("%d %d %d\n", filterSize, srcW, dstW);
+		*filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1));
+
+		xDstInSrc= xInc/2 - 0x8000;
+		for(i=0; i<dstW; i++)
+		{
+			int xx= (xDstInSrc>>16) - (*filterSize>>1) + 1;
+			int j;
+
+			filterPos[i]= xx;
+			if((flags & SWS_BICUBIC) || (flags & SWS_X))
+			{
+				double d= ABS(((xx+1)<<16) - xDstInSrc)/(double)(1<<16);
+				double y1,y2,y3,y4;
+				double A= -0.6;
+				if(flags & SWS_BICUBIC){
+						// Equation is from VirtualDub
+					y1 = (        +     A*d -       2.0*A*d*d +       A*d*d*d);
+					y2 = (+ 1.0             -     (A+3.0)*d*d + (A+2.0)*d*d*d);
+					y3 = (        -     A*d + (2.0*A+3.0)*d*d - (A+2.0)*d*d*d);
+					y4 = (                  +           A*d*d -       A*d*d*d);
+				}else{
+						// cubic interpolation (derived it myself)
+					y1 = (    -2.0*d + 3.0*d*d - 1.0*d*d*d)/6.0;
+					y2 = (6.0 -3.0*d - 6.0*d*d + 3.0*d*d*d)/6.0;
+					y3 = (    +6.0*d + 3.0*d*d - 3.0*d*d*d)/6.0;
+					y4 = (    -1.0*d           + 1.0*d*d*d)/6.0;
+				}
+
+//				printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
+				filter[i*(*filterSize) + 0]= y1;
+				filter[i*(*filterSize) + 1]= y2;
+				filter[i*(*filterSize) + 2]= y3;
+				filter[i*(*filterSize) + 3]= y4;
+//				printf("%1.3f %1.3f %1.3f %1.3f %1.3f\n",d , y1, y2, y3, y4);
+			}
+			else
+			{
+				for(j=0; j<*filterSize; j++)
+				{
+					double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16);
+					double coeff= 1.0 - d;
+					if(coeff<0) coeff=0;
+	//				printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
+					filter[i*(*filterSize) + j]= coeff;
+					xx++;
+				}
+			}
+			xDstInSrc+= xInc;
+		}
+	}
+	else // downscale
+	{
+		int xDstInSrc;
+		if(flags&SWS_BICUBIC) *filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
+		else if(flags&SWS_X)  *filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
+		else		      *filterSize= (int)ceil(1 + 2.0*srcW / (double)dstW);
+//		printf("%d %d %d\n", *filterSize, srcW, dstW);
+		*filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1));
+
+		xDstInSrc= xInc/2 - 0x8000;
+		for(i=0; i<dstW; i++)
+		{
+			int xx= (int)((double)xDstInSrc/(double)(1<<16) - ((*filterSize)-1)*0.5 + 0.5);
+			int j;
+			filterPos[i]= xx;
+			for(j=0; j<*filterSize; j++)
+			{
+				double d= ABS((xx<<16) - xDstInSrc)/(double)xInc;
+				double coeff;
+				if((flags & SWS_BICUBIC) || (flags & SWS_X))
+				{
+					double A= -0.75;
+//					d*=2;
+					// Equation is from VirtualDub
+					if(d<1.0)
+						coeff = (1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d);
+					else if(d<2.0)
+						coeff = (-4.0*A + 8.0*A*d - 5.0*A*d*d + A*d*d*d);
+					else
+						coeff=0.0;
+				}
+/*				else if(flags & SWS_X)
+				{
+				}*/
+				else
+				{
+					coeff= 1.0 - d;
+					if(coeff<0) coeff=0;
+				}
+//				printf("%1.3f %d %d \n", coeff, (int)d, xDstInSrc);
+				filter[i*(*filterSize) + j]= coeff;
+				xx++;
+			}
+			xDstInSrc+= xInc;
+		}
+	}
+
+	//fix borders
+	for(i=0; i<dstW; i++)
+	{
+		int j;
+		if(filterPos[i] < 0)
+		{
+			// Move filter coeffs left to compensate for filterPos
+			for(j=1; j<*filterSize; j++)
+			{
+				int left= MAX(j + filterPos[i], 0);
+				filter[i*(*filterSize) + left] += filter[i*(*filterSize) + j];
+				filter[i*(*filterSize) + j]=0;
+			}
+			filterPos[i]= 0;
+		}
+
+		if(filterPos[i] + (*filterSize) > srcW)
+		{
+			int shift= filterPos[i] + (*filterSize) - srcW;
+			// Move filter coeffs right to compensate for filterPos
+			for(j=(*filterSize)-2; j>=0; j--)
+			{
+				int right= MIN(j + shift, (*filterSize)-1);
+				filter[i*(*filterSize) +right] += filter[i*(*filterSize) +j];
+				filter[i*(*filterSize) +j]=0;
+			}
+			filterPos[i]= srcW - (*filterSize);
+		}
+	}
+
+	//FIXME try to align filterpos if possible / try to shift filterpos to put zeros at the end
+	// and skip these than later
+
+	//Normalize
+	for(i=0; i<dstW; i++)
+	{
+		int j;
+		double sum=0;
+		double scale= one;
+		for(j=0; j<*filterSize; j++)
+		{
+			sum+= filter[i*(*filterSize) + j];
+		}
+		scale/= sum;
+		for(j=0; j<*filterSize; j++)
+		{
+			dstFilter[i*(*filterSize) + j]= (int)(filter[i*(*filterSize) + j]*scale);
+		}
+	}
 }
 
+#ifdef ARCH_X86
+static void initMMX2HScaler(int dstW, int xInc, uint8_t *funnyCode)
+{
+	uint8_t *fragment;
+	int imm8OfPShufW1;
+	int imm8OfPShufW2;
+	int fragmentLength;
+
+	int xpos, i;
+
+	// create an optimized horizontal scaling routine
+
+	//code fragment
+
+	asm volatile(
+		"jmp 9f				\n\t"
+	// Begin
+		"0:				\n\t"
+		"movq (%%esi), %%mm0		\n\t" //FIXME Alignment
+		"movq %%mm0, %%mm1		\n\t"
+		"psrlq $8, %%mm0		\n\t"
+		"punpcklbw %%mm7, %%mm1	\n\t"
+		"movq %%mm2, %%mm3		\n\t"
+		"punpcklbw %%mm7, %%mm0	\n\t"
+		"addw %%bx, %%cx		\n\t" //2*xalpha += (4*lumXInc)&0xFFFF
+		"pshufw $0xFF, %%mm1, %%mm1	\n\t"
+		"1:				\n\t"
+		"adcl %%edx, %%esi		\n\t" //xx+= (4*lumXInc)>>16 + carry
+		"pshufw $0xFF, %%mm0, %%mm0	\n\t"
+		"2:				\n\t"
+		"psrlw $9, %%mm3		\n\t"
+		"psubw %%mm1, %%mm0		\n\t"
+		"pmullw %%mm3, %%mm0		\n\t"
+		"paddw %%mm6, %%mm2		\n\t" // 2*alpha += xpos&0xFFFF
+		"psllw $7, %%mm1		\n\t"
+		"paddw %%mm1, %%mm0		\n\t"
+
+		"movq %%mm0, (%%edi, %%eax)	\n\t"
+
+		"addl $8, %%eax			\n\t"
+	// End
+		"9:				\n\t"
+//		"int $3\n\t"
+		"leal 0b, %0			\n\t"
+		"leal 1b, %1			\n\t"
+		"leal 2b, %2			\n\t"
+		"decl %1			\n\t"
+		"decl %2			\n\t"
+		"subl %0, %1			\n\t"
+		"subl %0, %2			\n\t"
+		"leal 9b, %3			\n\t"
+		"subl %0, %3			\n\t"
+		:"=r" (fragment), "=r" (imm8OfPShufW1), "=r" (imm8OfPShufW2),
+		"=r" (fragmentLength)
+	);
+
+	xpos= 0; //lumXInc/2 - 0x8000; // difference between pixel centers
+
+	for(i=0; i<dstW/8; i++)
+	{
+		int xx=xpos>>16;
+
+		if((i&3) == 0)
+		{
+			int a=0;
+			int b=((xpos+xInc)>>16) - xx;
+			int c=((xpos+xInc*2)>>16) - xx;
+			int d=((xpos+xInc*3)>>16) - xx;
+
+			memcpy(funnyCode + fragmentLength*i/4, fragment, fragmentLength);
+
+			funnyCode[fragmentLength*i/4 + imm8OfPShufW1]=
+			funnyCode[fragmentLength*i/4 + imm8OfPShufW2]=
+				a | (b<<2) | (c<<4) | (d<<6);
+
+			// if we dont need to read 8 bytes than dont :), reduces the chance of
+			// crossing a cache line
+			if(d<3) funnyCode[fragmentLength*i/4 + 1]= 0x6E;
+
+			funnyCode[fragmentLength*(i+4)/4]= RET;
+		}
+		xpos+=xInc;
+	}
+}
+#endif // ARCH_X86
+
+//FIXME remove
 void SwScale_Init(){
+}
+
+static void globalInit(){
     // generating tables:
     int i;
     for(i=0; i<768; i++){
@@ -517,7 +770,7 @@ void SwScale_Init(){
 
     for(i=0; i<768; i++)
     {
-    	int v= clip_table[i];
+	int v= clip_table[i];
 	clip_table16b[i]= v>>3;
 	clip_table16g[i]= (v<<3)&0x07E0;
 	clip_table16r[i]= (v<<8)&0xF800;
@@ -526,5 +779,346 @@ void SwScale_Init(){
 	clip_table15r[i]= (v<<7)&0x7C00;
     }
 
+cpuCaps= gCpuCaps;
+
+#ifdef RUNTIME_CPUDETECT
+#ifdef CAN_COMPILE_X86_ASM
+	// ordered per speed fasterst first
+	if(gCpuCaps.hasMMX2)
+		swScale= swScale_MMX2;
+	else if(gCpuCaps.has3DNow)
+		swScale= swScale_3DNOW;
+	else if(gCpuCaps.hasMMX)
+		swScale= swScale_MMX;
+	else
+		swScale= swScale_C;
+
+#else
+	swScale= swScale_C;
+	cpuCaps.hasMMX2 = cpuCaps.hasMMX = cpuCaps.has3DNow = 0;
+#endif
+#else //RUNTIME_CPUDETECT
+#ifdef HAVE_MMX2
+	swScale= swScale_MMX2;
+	cpuCaps.has3DNow = 0;
+#elif defined (HAVE_3DNOW)
+	swScale= swScale_3DNOW;
+	cpuCaps.hasMMX2 = 0;
+#elif defined (HAVE_MMX)
+	swScale= swScale_MMX;
+	cpuCaps.hasMMX2 = cpuCaps.has3DNow = 0;
+#else
+	swScale= swScale_C;
+	cpuCaps.hasMMX2 = cpuCaps.hasMMX = cpuCaps.has3DNow = 0;
+#endif
+#endif //!RUNTIME_CPUDETECT
 }
 
+
+SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags,
+                         SwsFilter *srcFilter, SwsFilter *dstFilter){
+
+	const int widthAlign= dstFormat==IMGFMT_YV12 ? 16 : 8;
+	SwsContext *c;
+	int i;
+//const int bytespp= (dstbpp+1)/8; //(12->1, 15&16->2, 24->3, 32->4)
+//const int over= dstFormat==IMGFMT_YV12 ? 	  (((dstW+15)&(~15))) - dststride
+//						: (((dstW+7)&(~7)))*bytespp - dststride;
+	if(swScale==NULL) globalInit();
+
+	/* sanity check */
+	if(srcW<1 || srcH<1 || dstW<1 || dstH<1) return NULL;
+	if(srcW>=SWS_MAX_SIZE || dstW>=SWS_MAX_SIZE || srcH>=SWS_MAX_SIZE || dstH>=SWS_MAX_SIZE)
+	{
+		fprintf(stderr, "size is too large, increase SWS_MAX_SIZE\n");
+		return NULL;
+	}
+
+/* FIXME
+	if(dstStride[0]%widthAlign !=0 )
+	{
+		if(flags & SWS_PRINT_INFO)
+			fprintf(stderr, "SwScaler: Warning: dstStride is not a multiple of %d!\n"
+					"SwScaler:          ->cannot do aligned memory acesses anymore\n",
+					widthAlign);
+	}
+*/
+	c= memalign(64, sizeof(SwsContext));
+
+	c->srcW= srcW;
+	c->srcH= srcH;
+	c->dstW= dstW;
+	c->dstH= dstH;
+	c->lumXInc= ((srcW<<16) + (1<<15))/dstW;
+	c->lumYInc= ((srcH<<16) + (1<<15))/dstH;
+	c->flags= flags;
+	c->dstFormat= dstFormat;
+	c->srcFormat= srcFormat;
+
+	if(cpuCaps.hasMMX2)
+	{
+		c->canMMX2BeUsed= (dstW >=srcW && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
+		if(!c->canMMX2BeUsed && dstW >=srcW && (srcW&15)==0 && (flags&SWS_FAST_BILINEAR))
+		{
+			if(flags&SWS_PRINT_INFO)
+				fprintf(stderr, "SwScaler: output Width is not a multiple of 32 -> no MMX2 scaler\n");
+		}
+	}
+	else
+		c->canMMX2BeUsed=0;
+
+	// match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
+	// but only for the FAST_BILINEAR mode otherwise do correct scaling
+	// n-2 is the last chrominance sample available
+	// this is not perfect, but noone shuld notice the difference, the more correct variant
+	// would be like the vertical one, but that would require some special code for the
+	// first and last pixel
+	if(flags&SWS_FAST_BILINEAR)
+	{
+		if(c->canMMX2BeUsed) 	c->lumXInc+= 20;
+		//we dont use the x86asm scaler if mmx is available
+		else if(cpuCaps.hasMMX)	c->lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
+	}
+
+	/* set chrXInc & chrDstW */
+	if((flags&SWS_FULL_UV_IPOL) && dstFormat!=IMGFMT_YV12)
+		c->chrXInc= c->lumXInc>>1, c->chrDstW= dstW;
+	else
+		c->chrXInc= c->lumXInc,    c->chrDstW= (dstW+1)>>1;
+
+	/* set chrYInc & chrDstH */
+	if(dstFormat==IMGFMT_YV12)	c->chrYInc= c->lumYInc,    c->chrDstH= (dstH+1)>>1;
+	else				c->chrYInc= c->lumYInc>>1, c->chrDstH= dstH;
+
+	/* precalculate horizontal scaler filter coefficients */
+	{
+		const int filterAlign= cpuCaps.hasMMX ? 4 : 1;
+
+		initFilter(c->hLumFilter, c->hLumFilterPos, &c->hLumFilterSize, c->lumXInc,
+				 srcW      ,       dstW, filterAlign, 1<<14, flags);
+		initFilter(c->hChrFilter, c->hChrFilterPos, &c->hChrFilterSize, c->chrXInc,
+				(srcW+1)>>1, c->chrDstW, filterAlign, 1<<14, flags);
+
+#ifdef ARCH_X86
+// cant downscale !!!
+		if(c->canMMX2BeUsed && (flags & SWS_FAST_BILINEAR))
+		{
+			initMMX2HScaler(      dstW, c->lumXInc, c->funnyYCode);
+			initMMX2HScaler(c->chrDstW, c->chrXInc, c->funnyUVCode);
+		}
+#endif
+	} // Init Horizontal stuff
+
+
+
+	/* precalculate vertical scaler filter coefficients */
+	initFilter(c->vLumFilter, c->vLumFilterPos, &c->vLumFilterSize, c->lumYInc,
+			srcH      ,        dstH, 1, (1<<12)-4, flags);
+	initFilter(c->vChrFilter, c->vChrFilterPos, &c->vChrFilterSize, c->chrYInc,
+			(srcH+1)>>1, c->chrDstH, 1, (1<<12)-4, flags);
+
+	// Calculate Buffer Sizes so that they wont run out while handling these damn slices
+	c->vLumBufSize= c->vLumFilterSize;
+	c->vChrBufSize= c->vChrFilterSize;
+	for(i=0; i<dstH; i++)
+	{
+		int chrI= i*c->chrDstH / dstH;
+		int nextSlice= MAX(c->vLumFilterPos[i   ] + c->vLumFilterSize - 1,
+				 ((c->vChrFilterPos[chrI] + c->vChrFilterSize - 1)<<1));
+		nextSlice&= ~1; // Slices start at even boundaries
+		if(c->vLumFilterPos[i   ] + c->vLumBufSize < nextSlice)
+			c->vLumBufSize= nextSlice - c->vLumFilterPos[i   ];
+		if(c->vChrFilterPos[chrI] + c->vChrBufSize < (nextSlice>>1))
+			c->vChrBufSize= (nextSlice>>1) - c->vChrFilterPos[chrI];
+	}
+
+	// allocate pixbufs (we use dynamic allocation because otherwise we would need to
+	// allocate several megabytes to handle all possible cases)
+	for(i=0; i<c->vLumBufSize; i++)
+		c->lumPixBuf[i]= c->lumPixBuf[i+c->vLumBufSize]= (uint16_t*)memalign(8, 4000);
+	for(i=0; i<c->vChrBufSize; i++)
+		c->chrPixBuf[i]= c->chrPixBuf[i+c->vChrBufSize]= (uint16_t*)memalign(8, 8000);
+
+	//try to avoid drawing green stuff between the right end and the stride end
+	for(i=0; i<c->vLumBufSize; i++) memset(c->lumPixBuf[i], 0, 4000);
+	for(i=0; i<c->vChrBufSize; i++) memset(c->chrPixBuf[i], 64, 8000);
+
+	ASSERT(c->chrDstH <= dstH)
+	ASSERT(c->vLumFilterSize*      dstH*4 <= SWS_MAX_SIZE*20)
+	ASSERT(c->vChrFilterSize*c->chrDstH*4 <= SWS_MAX_SIZE*20)
+
+	// pack filter data for mmx code
+	if(cpuCaps.hasMMX)
+	{
+		for(i=0; i<c->vLumFilterSize*dstH; i++)
+			c->lumMmxFilter[4*i]=c->lumMmxFilter[4*i+1]=c->lumMmxFilter[4*i+2]=c->lumMmxFilter[4*i+3]=
+				c->vLumFilter[i];
+		for(i=0; i<c->vChrFilterSize*c->chrDstH; i++)
+			c->chrMmxFilter[4*i]=c->chrMmxFilter[4*i+1]=c->chrMmxFilter[4*i+2]=c->chrMmxFilter[4*i+3]=
+				c->vChrFilter[i];
+	}
+
+	if(flags&SWS_PRINT_INFO)
+	{
+#ifdef DITHER1XBPP
+		char *dither= cpuCaps.hasMMX ? " dithered" : "";
+#endif
+		if(flags&SWS_FAST_BILINEAR)
+			fprintf(stderr, "\nSwScaler: FAST_BILINEAR scaler ");
+		else if(flags&SWS_BILINEAR)
+			fprintf(stderr, "\nSwScaler: BILINEAR scaler ");
+		else if(flags&SWS_BICUBIC)
+			fprintf(stderr, "\nSwScaler: BICUBIC scaler ");
+		else
+			fprintf(stderr, "\nSwScaler: ehh flags invalid?! ");
+
+		if(dstFormat==IMGFMT_BGR15)
+			fprintf(stderr, "with%s BGR15 output ", dither);
+		else if(dstFormat==IMGFMT_BGR16)
+			fprintf(stderr, "with%s BGR16 output ", dither);
+		else if(dstFormat==IMGFMT_BGR24)
+			fprintf(stderr, "with BGR24 output ");
+		else if(dstFormat==IMGFMT_BGR32)
+			fprintf(stderr, "with BGR32 output ");
+		else if(dstFormat==IMGFMT_YV12)
+			fprintf(stderr, "with YV12 output ");
+		else
+			fprintf(stderr, "without output ");
+
+		if(cpuCaps.hasMMX2)
+			fprintf(stderr, "using MMX2\n");
+		else if(cpuCaps.has3DNow)
+			fprintf(stderr, "using 3DNOW\n");
+		else if(cpuCaps.hasMMX)
+			fprintf(stderr, "using MMX\n");
+		else
+			fprintf(stderr, "using C\n");
+	}
+
+	if((flags & SWS_PRINT_INFO) && verbose)
+	{
+		if(cpuCaps.hasMMX)
+		{
+			if(c->canMMX2BeUsed && (flags&SWS_FAST_BILINEAR))
+				printf("SwScaler: using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
+			else
+			{
+				if(c->hLumFilterSize==4)
+					printf("SwScaler: using 4-tap MMX scaler for horizontal luminance scaling\n");
+				else if(c->hLumFilterSize==8)
+					printf("SwScaler: using 8-tap MMX scaler for horizontal luminance scaling\n");
+				else
+					printf("SwScaler: using n-tap MMX scaler for horizontal luminance scaling\n");
+
+				if(c->hChrFilterSize==4)
+					printf("SwScaler: using 4-tap MMX scaler for horizontal chrominance scaling\n");
+				else if(c->hChrFilterSize==8)
+					printf("SwScaler: using 8-tap MMX scaler for horizontal chrominance scaling\n");
+				else
+					printf("SwScaler: using n-tap MMX scaler for horizontal chrominance scaling\n");
+			}
+		}
+		else
+		{
+#ifdef ARCH_X86
+			printf("SwScaler: using X86-Asm scaler for horizontal scaling\n");
+#else
+			if(flags & SWS_FAST_BILINEAR)
+				printf("SwScaler: using FAST_BILINEAR C scaler for horizontal scaling\n");
+			else
+				printf("SwScaler: using C scaler for horizontal scaling\n");
+#endif
+		}
+		if(dstFormat==IMGFMT_YV12)
+		{
+			if(c->vLumFilterSize==1)
+				printf("SwScaler: using 1-tap %s \"scaler\" for vertical scaling (YV12)\n", cpuCaps.hasMMX ? "MMX" : "C");
+			else
+				printf("SwScaler: using n-tap %s scaler for vertical scaling (YV12)\n", cpuCaps.hasMMX ? "MMX" : "C");
+		}
+		else
+		{
+			if(c->vLumFilterSize==1 && c->vChrFilterSize==2)
+				printf("SwScaler: using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
+				       "SwScaler:       2-tap scaler for vertical chrominance scaling (BGR)\n",cpuCaps.hasMMX ? "MMX" : "C");
+			else if(c->vLumFilterSize==2 && c->vChrFilterSize==2)
+				printf("SwScaler: using 2-tap linear %s scaler for vertical scaling (BGR)\n", cpuCaps.hasMMX ? "MMX" : "C");
+			else
+				printf("SwScaler: using n-tap %s scaler for vertical scaling (BGR)\n", cpuCaps.hasMMX ? "MMX" : "C");
+		}
+
+		if(dstFormat==IMGFMT_BGR24)
+			printf("SwScaler: using %s YV12->BGR24 Converter\n",
+				cpuCaps.hasMMX2 ? "MMX2" : (cpuCaps.hasMMX ? "MMX" : "C"));
+		else
+			printf("SwScaler: using %s YV12->BGR Converter\n", cpuCaps.hasMMX ? "MMX" : "C");//FIXME print format
+
+		printf("SwScaler: %dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
+	}
+
+	return c;
+}
+
+/**
+ * returns a normalized gaussian curve used to filter stuff
+ * quality=3 is high quality, lowwer is lowwer quality
+ */
+double *getGaussian(double variance, double quality){
+	const int length= (int)(variance*quality + 0.5) | 1;
+	int i;
+	double *coeff= memalign(sizeof(double), length*sizeof(double));
+	double middle= (length-1)*0.5;
+
+	for(i=0; i<length; i++)
+	{
+		double dist= i-middle;
+		coeff[i]= exp( -dist*dist/(2*variance*variance) ) / sqrt(2*variance*PI);
+	}
+
+	normalize(coeff, length, 1.0);
+	return coeff;
+}
+
+void normalize(double *coeff, int length, double height){
+	int i;
+	double sum=0;
+	double inv;
+
+	for(i=0; i<length; i++)
+		sum+= coeff[i];
+
+	inv= height/sum;
+
+	for(i=0; i<length; i++)
+		coeff[i]*= height;
+}
+
+double *conv(double *a, int aLength, double *b, int bLength){
+	int length= aLength + bLength - 1;
+	double *coeff= memalign(sizeof(double), length*sizeof(double));
+	int i, j;
+
+	for(i=0; i<length; i++) coeff[i]= 0.0;
+
+	for(i=0; i<aLength; i++)
+	{
+		for(j=0; j<bLength; j++)
+		{
+			coeff[i+j]+= a[i]*b[j];
+		}
+	}
+
+	return coeff;
+}
+
+/*
+double *sum(double *a, int aLength, double *b, int bLength){
+	int length= MAX(aLength, bLength);
+	double *coeff= memalign(sizeof(double), length*sizeof(double));
+	int i;
+
+	for(i=0; i<length; i++) coeff[i]= 0.0;
+
+	for(i=0; i<aLength; i++) coeff[i]+= a[i];
+}
+*/
\ No newline at end of file
diff --git a/postproc/swscale.h b/postproc/swscale.h
index 2757ba5f20..8c6c0543d3 100644
--- a/postproc/swscale.h
+++ b/postproc/swscale.h
@@ -1,14 +1,90 @@
 
-#define SWS_FAST_BILINEAR 0
-#define SWS_BILINEAR 1
-#define SWS_BICUBIC 2
+/* values for the flags, the stuff on the command line is different */
+#define SWS_FAST_BILINEAR 1
+#define SWS_BILINEAR 2
+#define SWS_BICUBIC  4
+#define SWS_X        8
+#define SWS_FULL_UV_IPOL 0x100
+#define SWS_PRINT_INFO 0x1000
+
+#define SWS_MAX_SIZE 2000
+
+/* this struct should be aligned on at least 32-byte boundary */
+typedef struct{
+	int srcW, srcH, dstW, dstH;
+	int chrDstW, chrDstH;
+	int lumXInc, chrXInc;
+	int lumYInc, chrYInc;
+	int dstFormat, srcFormat;
+	int16_t __attribute__((aligned(8))) *lumPixBuf[SWS_MAX_SIZE];
+	int16_t __attribute__((aligned(8))) *chrPixBuf[SWS_MAX_SIZE];
+	int16_t __attribute__((aligned(8))) hLumFilter[SWS_MAX_SIZE*5];
+	int16_t __attribute__((aligned(8))) hLumFilterPos[SWS_MAX_SIZE];
+	int16_t __attribute__((aligned(8))) hChrFilter[SWS_MAX_SIZE*5];
+	int16_t __attribute__((aligned(8))) hChrFilterPos[SWS_MAX_SIZE];
+	int16_t __attribute__((aligned(8))) vLumFilter[SWS_MAX_SIZE*5];
+	int16_t __attribute__((aligned(8))) vLumFilterPos[SWS_MAX_SIZE];
+	int16_t __attribute__((aligned(8))) vChrFilter[SWS_MAX_SIZE*5];
+	int16_t __attribute__((aligned(8))) vChrFilterPos[SWS_MAX_SIZE];
+
+// Contain simply the values from v(Lum|Chr)Filter just nicely packed for mmx
+	int16_t __attribute__((aligned(8))) lumMmxFilter[SWS_MAX_SIZE*20];
+	int16_t __attribute__((aligned(8))) chrMmxFilter[SWS_MAX_SIZE*20];
+
+	int hLumFilterSize;
+	int hChrFilterSize;
+	int vLumFilterSize;
+	int vChrFilterSize;
+	int vLumBufSize;
+	int vChrBufSize;
+
+	uint8_t __attribute__((aligned(32))) funnyYCode[10000];
+	uint8_t __attribute__((aligned(32))) funnyUVCode[10000];
+
+	int canMMX2BeUsed;
+
+	int lastInLumBuf;
+	int lastInChrBuf;
+	int lumBufIndex;
+	int chrBufIndex;
+	int dstY;
+	int flags;
+} SwsContext;
+//FIXME check init (where 0)
+
+typedef struct {
+	double *lumH;
+	double *lumV;
+	double *chrH;
+	double *chrV;
+	int length;
+} SwsFilter;
+
 
 // *** bilinear scaling and yuv->rgb & yuv->yuv conversion of yv12 slices:
 // *** Note: it's called multiple times while decoding a frame, first time y==0
-// *** Designed to upscale, but may work for downscale too.
 // dstbpp == 12 -> yv12 output
-void SwScale_YV12slice(unsigned char* srcptr[],int stride[], int srcSliceY,
-			     int srcSliceH, uint8_t* dstptr[], int dststride, int dstbpp,
+// will use sws_flags
+void SwScale_YV12slice(unsigned char* src[],int srcStride[], int srcSliceY,
+			     int srcSliceH, uint8_t* dst[], int dstStride, int dstbpp,
 			     int srcW, int srcH, int dstW, int dstH);
-// generating tables
-void SwScale_Init();
\ No newline at end of file
+
+// Obsolete, will be removed soon
+void SwScale_Init();
+
+
+
+void freeSwsContext(SwsContext swsContext);
+
+SwsContext *getSwsContext(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat, int flags,
+			 SwsFilter *srcFilter, SwsFilter *dstFilter);
+
+extern void (*swScale)(SwsContext *context, uint8_t* src[], int srcStride[], int srcSliceY,
+             int srcSliceH, uint8_t* dst[], int dstStride[]);
+
+double *getGaussian(double variance, double quality);
+
+void normalize(double *coeff, int length, double height);
+
+double *conv(double *a, int aLength, double *b, int bLength);
+
diff --git a/postproc/swscale_template.c b/postproc/swscale_template.c
index 1cdf7ab7b8..b70806b1a1 100644
--- a/postproc/swscale_template.c
+++ b/postproc/swscale_template.c
@@ -734,16 +734,16 @@ static inline void RENAME(yuv2yuv1)(int16_t *lumSrc, int16_t *chrSrc,
  */
 static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize,
 				    int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize,
-			    uint8_t *dest, int dstW, int dstbpp, int16_t * lumMmxFilter, int16_t * chrMmxFilter)
+			    uint8_t *dest, int dstW, int dstFormat, int16_t * lumMmxFilter, int16_t * chrMmxFilter)
 {
-	if(fullUVIpol)
+/*	if(flags&SWS_FULL_UV_IPOL)
 	{
 //FIXME
 	}//FULL_UV_IPOL
-	else
+	else*/
 	{
 #ifdef HAVE_MMX
-		if(dstbpp == 32) //FIXME untested
+		if(dstFormat == IMGFMT_BGR32) //FIXME untested
 		{
 			asm volatile(
 				YSCALEYUV2RGBX
@@ -756,7 +756,7 @@ static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lu
 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"
 			);
 		}
-		else if(dstbpp==24) //FIXME untested
+		else if(dstFormat == IMGFMT_BGR24) //FIXME untested
 		{
 			asm volatile(
 				YSCALEYUV2RGBX
@@ -771,7 +771,7 @@ static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lu
 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"
 			);
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			asm volatile(
 				YSCALEYUV2RGBX
@@ -791,7 +791,7 @@ static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lu
 			: "%eax", "%ebx", "%ecx", "%edx", "%esi"
 			);
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			asm volatile(
 				YSCALEYUV2RGBX
@@ -814,7 +814,7 @@ static inline void RENAME(yuv2rgbX)(int16_t *lumFilter, int16_t **lumSrc, int lu
 #else
 yuv2rgbXinC(lumFilter, lumSrc, lumFilterSize,
 	    chrFilter, chrSrc, chrFilterSize,
-	    dest, dstW, dstbpp);
+	    dest, dstW, dstFormat);
 
 #endif
 	} //!FULL_UV_IPOL
@@ -825,16 +825,16 @@ yuv2rgbXinC(lumFilter, lumSrc, lumFilterSize,
  * vertical bilinear scale YV12 to RGB
  */
 static inline void RENAME(yuv2rgb2)(uint16_t *buf0, uint16_t *buf1, uint16_t *uvbuf0, uint16_t *uvbuf1,
-			    uint8_t *dest, int dstW, int yalpha, int uvalpha, int dstbpp)
+			    uint8_t *dest, int dstW, int yalpha, int uvalpha, int dstFormat, int flags)
 {
 	int yalpha1=yalpha^4095;
 	int uvalpha1=uvalpha^4095;
 
-	if(fullUVIpol)
+	if(flags&SWS_FULL_UV_IPOL)
 	{
 
 #ifdef HAVE_MMX
-		if(dstbpp == 32)
+		if(dstFormat==IMGFMT_BGR32)
 		{
 			asm volatile(
 
@@ -860,7 +860,7 @@ FULL_YSCALEYUV2RGB
 			: "%eax"
 			);
 		}
-		else if(dstbpp==24)
+		else if(dstFormat==IMGFMT_BGR24)
 		{
 			asm volatile(
 
@@ -910,7 +910,7 @@ FULL_YSCALEYUV2RGB
 			: "%eax", "%ebx"
 			);
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			asm volatile(
 
@@ -944,7 +944,7 @@ FULL_YSCALEYUV2RGB
 			: "%eax"
 			);
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			asm volatile(
 
@@ -979,7 +979,21 @@ FULL_YSCALEYUV2RGB
 			);
 		}
 #else
-		if(dstbpp==32 || dstbpp==24)
+		if(dstFormat==IMGFMT_BGR32)
+		{
+			int i;
+			for(i=0;i<dstW;i++){
+				// vertical linear interpolation && yuv2rgb in a single step:
+				int Y=yuvtab_2568[((buf0[i]*yalpha1+buf1[i]*yalpha)>>19)];
+				int U=((uvbuf0[i]*uvalpha1+uvbuf1[i]*uvalpha)>>19);
+				int V=((uvbuf0[i+2048]*uvalpha1+uvbuf1[i+2048]*uvalpha)>>19);
+				dest[0]=clip_table[((Y + yuvtab_40cf[U]) >>13)];
+				dest[1]=clip_table[((Y + yuvtab_1a1e[V] + yuvtab_0c92[U]) >>13)];
+				dest[2]=clip_table[((Y + yuvtab_3343[V]) >>13)];
+				dest+= 4;
+			}
+		}
+		else if(dstFormat==IMGFMT_BGR24)
 		{
 			int i;
 			for(i=0;i<dstW;i++){
@@ -990,10 +1004,10 @@ FULL_YSCALEYUV2RGB
 				dest[0]=clip_table[((Y + yuvtab_40cf[U]) >>13)];
 				dest[1]=clip_table[((Y + yuvtab_1a1e[V] + yuvtab_0c92[U]) >>13)];
 				dest[2]=clip_table[((Y + yuvtab_3343[V]) >>13)];
-				dest+=dstbpp>>3;
+				dest+= 3;
 			}
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			int i;
 			for(i=0;i<dstW;i++){
@@ -1008,7 +1022,7 @@ FULL_YSCALEYUV2RGB
 					clip_table16r[(Y + yuvtab_3343[V]) >>13];
 			}
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			int i;
 			for(i=0;i<dstW;i++){
@@ -1028,7 +1042,7 @@ FULL_YSCALEYUV2RGB
 	else
 	{
 #ifdef HAVE_MMX
-		if(dstbpp == 32)
+		if(dstFormat==IMGFMT_BGR32)
 		{
 			asm volatile(
 				YSCALEYUV2RGB
@@ -1039,7 +1053,7 @@ FULL_YSCALEYUV2RGB
 			: "%eax"
 			);
 		}
-		else if(dstbpp==24)
+		else if(dstFormat==IMGFMT_BGR24)
 		{
 			asm volatile(
 				"movl %4, %%ebx			\n\t"
@@ -1051,7 +1065,7 @@ FULL_YSCALEYUV2RGB
 			: "%eax", "%ebx"
 			);
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			asm volatile(
 				YSCALEYUV2RGB
@@ -1069,7 +1083,7 @@ FULL_YSCALEYUV2RGB
 			: "%eax"
 			);
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			asm volatile(
 				YSCALEYUV2RGB
@@ -1088,7 +1102,7 @@ FULL_YSCALEYUV2RGB
 			);
 		}
 #else
-		if(dstbpp==32)
+		if(dstFormat==IMGFMT_BGR32)
 		{
 			int i;
 			for(i=0; i<dstW-1; i+=2){
@@ -1111,7 +1125,7 @@ FULL_YSCALEYUV2RGB
 				dest[4*i+6]=clip_table[((Y2 + Cr) >>13)];
 			}
 		}
-		else if(dstbpp==24)
+		else if(dstFormat==IMGFMT_BGR24)
 		{
 			int i;
 			for(i=0; i<dstW-1; i+=2){
@@ -1135,7 +1149,7 @@ FULL_YSCALEYUV2RGB
 				dest+=6;
 			}
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			int i;
 			for(i=0; i<dstW-1; i+=2){
@@ -1160,7 +1174,7 @@ FULL_YSCALEYUV2RGB
 					clip_table16r[(Y2 + Cr) >>13];
 			}
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			int i;
 			for(i=0; i<dstW-1; i+=2){
@@ -1193,21 +1207,21 @@ FULL_YSCALEYUV2RGB
  * YV12 to RGB without scaling or interpolating
  */
 static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *uvbuf1,
-			    uint8_t *dest, int dstW, int uvalpha, int dstbpp)
+			    uint8_t *dest, int dstW, int uvalpha, int dstFormat, int flags)
 {
 	int uvalpha1=uvalpha^4095;
 	const int yalpha1=0;
 
-	if(fullUVIpol || allwaysIpol)
+	if(flags&SWS_FULL_UV_IPOL)
 	{
-		RENAME(yuv2rgb2)(buf0, buf0, uvbuf0, uvbuf1, dest, dstW, 0, uvalpha, dstbpp);
+		RENAME(yuv2rgb2)(buf0, buf0, uvbuf0, uvbuf1, dest, dstW, 0, uvalpha, dstFormat, flags);
 		return;
 	}
 
 #ifdef HAVE_MMX
 	if( uvalpha < 2048 ) // note this is not correct (shifts chrominance by 0.5 pixels) but its a bit faster
 	{
-		if(dstbpp == 32)
+		if(dstFormat==IMGFMT_BGR32)
 		{
 			asm volatile(
 				YSCALEYUV2RGB1
@@ -1217,7 +1231,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			: "%eax"
 			);
 		}
-		else if(dstbpp==24)
+		else if(dstFormat==IMGFMT_BGR24)
 		{
 			asm volatile(
 				"movl %4, %%ebx			\n\t"
@@ -1228,7 +1242,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			: "%eax", "%ebx"
 			);
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			asm volatile(
 				YSCALEYUV2RGB1
@@ -1244,7 +1258,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			: "%eax"
 			);
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			asm volatile(
 				YSCALEYUV2RGB1
@@ -1264,7 +1278,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 	}
 	else
 	{
-		if(dstbpp == 32)
+		if(dstFormat==IMGFMT_BGR32)
 		{
 			asm volatile(
 				YSCALEYUV2RGB1b
@@ -1274,7 +1288,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			: "%eax"
 			);
 		}
-		else if(dstbpp==24)
+		else if(dstFormat==IMGFMT_BGR24)
 		{
 			asm volatile(
 				"movl %4, %%ebx			\n\t"
@@ -1285,7 +1299,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			: "%eax", "%ebx"
 			);
 		}
-		else if(dstbpp==15)
+		else if(dstFormat==IMGFMT_BGR15)
 		{
 			asm volatile(
 				YSCALEYUV2RGB1b
@@ -1301,7 +1315,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			: "%eax"
 			);
 		}
-		else if(dstbpp==16)
+		else if(dstFormat==IMGFMT_BGR16)
 		{
 			asm volatile(
 				YSCALEYUV2RGB1b
@@ -1322,7 +1336,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 #else
 //FIXME write 2 versions (for even & odd lines)
 
-	if(dstbpp==32)
+	if(dstFormat==IMGFMT_BGR32)
 	{
 		int i;
 		for(i=0; i<dstW-1; i+=2){
@@ -1345,7 +1359,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			dest[4*i+6]=clip_table[((Y2 + Cr) >>13)];
 		}
 	}
-	else if(dstbpp==24)
+	else if(dstFormat==IMGFMT_BGR24)
 	{
 		int i;
 		for(i=0; i<dstW-1; i+=2){
@@ -1369,7 +1383,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 			dest+=6;
 		}
 	}
-	else if(dstbpp==16)
+	else if(dstFormat==IMGFMT_BGR16)
 	{
 		int i;
 		for(i=0; i<dstW-1; i+=2){
@@ -1394,7 +1408,7 @@ static inline void RENAME(yuv2rgb1)(uint16_t *buf0, uint16_t *uvbuf0, uint16_t *
 				clip_table16r[(Y2 + Cr) >>13];
 		}
 	}
-	else if(dstbpp==15)
+	else if(dstFormat==IMGFMT_BGR15)
 	{
 		int i;
 		for(i=0; i<dstW-1; i+=2){
@@ -1584,13 +1598,15 @@ static inline void RENAME(hScale)(int16_t *dst, int dstW, uint8_t *src, int srcW
 #endif
 }
       // *** horizontal scale Y line to temp buffer
-static inline void RENAME(hyscale)(uint16_t *dst, int dstWidth, uint8_t *src, int srcW, int xInc)
+static inline void RENAME(hyscale)(uint16_t *dst, int dstWidth, uint8_t *src, int srcW, int xInc,
+				   int flags, int canMMX2BeUsed, int16_t *hLumFilter,
+				   int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode)
 {
 #ifdef HAVE_MMX
 	// use the new MMX scaler if th mmx2 cant be used (its faster than the x86asm one)
-    if(sws_flags != SWS_FAST_BILINEAR || (!canMMX2BeUsed))
+    if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
 #else
-    if(sws_flags != SWS_FAST_BILINEAR)
+    if(!(flags&SWS_FAST_BILINEAR))
 #endif
     {
     	RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
@@ -1614,7 +1630,7 @@ static inline void RENAME(hyscale)(uint16_t *dst, int dstWidth, uint8_t *src, in
 			"psllq $16, %%mm2		\n\t"
 			"paddw %%mm6, %%mm2		\n\t"
 			"psllq $16, %%mm2		\n\t" //0,t,2t,3t		t=xInc&0xFF
-			"movq %%mm2, "MANGLE(temp0)"	\n\t"
+			"movq %%mm2, %%mm4		\n\t"
 			"movd %4, %%mm6			\n\t" //(xInc*4)&0xFFFF
 			"punpcklwd %%mm6, %%mm6		\n\t"
 			"punpcklwd %%mm6, %%mm6		\n\t"
@@ -1630,8 +1646,8 @@ static inline void RENAME(hyscale)(uint16_t *dst, int dstWidth, uint8_t *src, in
 			PREFETCH" 1024(%%esi)		\n\t"\
 			PREFETCH" 1056(%%esi)		\n\t"\
 			PREFETCH" 1088(%%esi)		\n\t"\
-			"call "MANGLE(funnyYCode)"	\n\t"\
-			"movq "MANGLE(temp0)", %%mm2	\n\t"\
+			"call *%6			\n\t"\
+			"movq %%mm4, %%mm2		\n\t"\
 			"xorl %%ecx, %%ecx		\n\t"
 
 FUNNY_Y_CODE
@@ -1644,7 +1660,7 @@ FUNNY_Y_CODE
 FUNNY_Y_CODE
 
 			:: "m" (src), "m" (dst), "m" (dstWidth), "m" ((xInc*4)>>16),
-			"m" ((xInc*4)&0xFFFF), "m" (xInc&0xFFFF)
+			"m" ((xInc*4)&0xFFFF), "m" (xInc&0xFFFF), "m" (funnyYCode)
 			: "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"
 		);
 		for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;
@@ -1709,14 +1725,15 @@ FUNNY_Y_CODE
     }
 }
 
-inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth,
-				uint8_t *src1, uint8_t *src2, int srcW, int xInc)
+inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth, uint8_t *src1, uint8_t *src2,
+				   int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,
+				   int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode)
 {
 #ifdef HAVE_MMX
 	// use the new MMX scaler if th mmx2 cant be used (its faster than the x86asm one)
-    if(sws_flags != SWS_FAST_BILINEAR || (!canMMX2BeUsed))
+    if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
 #else
-    if(sws_flags != SWS_FAST_BILINEAR)
+    if(!(flags&SWS_FAST_BILINEAR))
 #endif
     {
     	RENAME(hScale)(dst     , dstWidth, src1, srcW, xInc, hChrFilter, hChrFilterPos, hChrFilterSize);
@@ -1741,7 +1758,7 @@ inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth,
 		"psllq $16, %%mm2		\n\t"
 		"paddw %%mm6, %%mm2		\n\t"
 		"psllq $16, %%mm2		\n\t" //0,t,2t,3t		t=xInc&0xFFFF
-		"movq %%mm2, "MANGLE(temp0)"	\n\t"
+		"movq %%mm2, %%mm4		\n\t"
 		"movd %4, %%mm6			\n\t" //(xInc*4)&0xFFFF
 		"punpcklwd %%mm6, %%mm6		\n\t"
 		"punpcklwd %%mm6, %%mm6		\n\t"
@@ -1757,8 +1774,8 @@ inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth,
 			PREFETCH" 1024(%%esi)		\n\t"\
 			PREFETCH" 1056(%%esi)		\n\t"\
 			PREFETCH" 1088(%%esi)		\n\t"\
-			"call "MANGLE(funnyUVCode)"	\n\t"\
-			"movq "MANGLE(temp0)", %%mm2	\n\t"\
+			"call *%7			\n\t"\
+			"movq %%mm4, %%mm2	\n\t"\
 			"xorl %%ecx, %%ecx		\n\t"
 
 FUNNYUVCODE
@@ -1786,7 +1803,7 @@ FUNNYUVCODE
 FUNNYUVCODE
 
 		:: "m" (src1), "m" (dst), "m" (dstWidth), "m" ((xInc*4)>>16),
-		  "m" ((xInc*4)&0xFFFF), "m" (xInc&0xFFFF), "m" (src2)
+		  "m" ((xInc*4)&0xFFFF), "m" (xInc&0xFFFF), "m" (src2), "m" (funnyUVCode)
 		: "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"
 	);
 		for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--)
@@ -1858,585 +1875,67 @@ FUNNYUVCODE
    }
 }
 
-static inline void RENAME(initFilter)(int16_t *dstFilter, int16_t *filterPos, int *filterSize, int xInc,
-				      int srcW, int dstW, int filterAlign, int one)
-{
-	int i;
-	double filter[8000];
-#ifdef HAVE_MMX
-	asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions)
-#endif
-
-	if(ABS(xInc - 0x10000) <10) // unscaled
-	{
-		int i;
-		*filterSize= (1 +(filterAlign-1)) & (~(filterAlign-1)); // 1 or 4 normaly
-		for(i=0; i<dstW*(*filterSize); i++) filter[i]=0;
-
-		for(i=0; i<dstW; i++)
-		{
-			filter[i*(*filterSize)]=1;
-			filterPos[i]=i;
-		}
-
-	}
-	else if(xInc <= (1<<16) || sws_flags==SWS_FAST_BILINEAR) // upscale
-	{
-		int i;
-		int xDstInSrc;
-		if(sws_flags==SWS_BICUBIC) *filterSize= 4;
-		else			   *filterSize= 2;
-//		printf("%d %d %d\n", filterSize, srcW, dstW);
-		*filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1));
-
-		xDstInSrc= xInc/2 - 0x8000;
-		for(i=0; i<dstW; i++)
-		{
-			int xx= (xDstInSrc>>16) - (*filterSize>>1) + 1;
-			int j;
-
-			filterPos[i]= xx;
-			if(sws_flags == SWS_BICUBIC)
-			{
-				double d= ABS(((xx+1)<<16) - xDstInSrc)/(double)(1<<16);
-				double y1,y2,y3,y4;
-				double A= -0.75;
-					// Equation is from VirtualDub
-				y1 = (        +     A*d -       2.0*A*d*d +       A*d*d*d);
-				y2 = (+ 1.0             -     (A+3.0)*d*d + (A+2.0)*d*d*d);
-				y3 = (        -     A*d + (2.0*A+3.0)*d*d - (A+2.0)*d*d*d);
-				y4 = (                  +           A*d*d -       A*d*d*d);
-
-//				printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
-				filter[i*(*filterSize) + 0]= y1;
-				filter[i*(*filterSize) + 1]= y2;
-				filter[i*(*filterSize) + 2]= y3;
-				filter[i*(*filterSize) + 3]= y4;
-//				printf("%1.3f %d, %d, %d, %d\n",d , y1, y2, y3, y4);
-			}
-			else
-			{
-				for(j=0; j<*filterSize; j++)
-				{
-					double d= ABS((xx<<16) - xDstInSrc)/(double)(1<<16);
-					double coeff= 1.0 - d;
-					if(coeff<0) coeff=0;
-	//				printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
-					filter[i*(*filterSize) + j]= coeff;
-					xx++;
-				}
-			}
-			xDstInSrc+= xInc;
-		}
+static void RENAME(swScale)(SwsContext *c, uint8_t* src[], int srcStride[], int srcSliceY,
+             int srcSliceH, uint8_t* dst[], int dstStride[]){
+
+	/* load a few things into local vars to make the code more readable? and faster */
+	const int srcW= c->srcW;
+	const int dstW= c->dstW;
+	const int dstH= c->dstH;
+	const int chrDstW= c->chrDstW;
+	const int lumXInc= c->lumXInc;
+	const int chrXInc= c->chrXInc;
+	const int dstFormat= c->dstFormat; //FIXME serach for dstbpp;
+	const int flags= c->flags;
+	const int canMMX2BeUsed= c->canMMX2BeUsed;
+	int16_t *vLumFilterPos= c->vLumFilterPos;
+	int16_t *vChrFilterPos= c->vChrFilterPos;
+	int16_t *hLumFilterPos= c->hLumFilterPos;
+	int16_t *hChrFilterPos= c->hChrFilterPos;
+	int16_t *vLumFilter= c->vLumFilter;
+	int16_t *vChrFilter= c->vChrFilter;
+	int16_t *hLumFilter= c->hLumFilter;
+	int16_t *hChrFilter= c->hChrFilter;
+	int16_t *lumMmxFilter= c->lumMmxFilter;
+	int16_t *chrMmxFilter= c->chrMmxFilter;
+	const int vLumFilterSize= c->vLumFilterSize;
+	const int vChrFilterSize= c->vChrFilterSize;
+	const int hLumFilterSize= c->hLumFilterSize;
+	const int hChrFilterSize= c->hChrFilterSize;
+	int16_t **lumPixBuf= c->lumPixBuf;
+	int16_t **chrPixBuf= c->chrPixBuf;
+	const int vLumBufSize= c->vLumBufSize;
+	const int vChrBufSize= c->vChrBufSize;
+	uint8_t *funnyYCode= c->funnyYCode;
+	uint8_t *funnyUVCode= c->funnyUVCode;
+
+	/* vars whch will change and which we need to storw back in the context */
+	int dstY= c->dstY;
+	int lumBufIndex= c->lumBufIndex;
+	int chrBufIndex= c->chrBufIndex;
+	int lastInLumBuf= c->lastInLumBuf;
+	int lastInChrBuf= c->lastInChrBuf;
+
+	if(srcSliceY ==0){
+		lumBufIndex=0;
+		chrBufIndex=0;
+		dstY=0;
+		lastInLumBuf= -1;
+		lastInChrBuf= -1;
 	}
-	else // downscale
-	{
-		int xDstInSrc;
-		if(sws_flags==SWS_BICUBIC) *filterSize= (int)ceil(1 + 4.0*srcW / (double)dstW);
-		else			   *filterSize= (int)ceil(1 + 2.0*srcW / (double)dstW);
-//		printf("%d %d %d\n", *filterSize, srcW, dstW);
-		*filterSize= (*filterSize +(filterAlign-1)) & (~(filterAlign-1));
-
-		xDstInSrc= xInc/2 - 0x8000;
-		for(i=0; i<dstW; i++)
-		{
-			int xx= (int)((double)xDstInSrc/(double)(1<<16) - ((*filterSize)-1)*0.5 + 0.5);
-			int j;
-
-			filterPos[i]= xx;
-			for(j=0; j<*filterSize; j++)
-			{
-				double d= ABS((xx<<16) - xDstInSrc)/(double)xInc;
-				double coeff;
-				if(sws_flags == SWS_BICUBIC)
-				{
-					double A= -0.75;
-//					d*=2;
-					// Equation is from VirtualDub
-					if(d<1.0)
-						coeff = (1.0 - (A+3.0)*d*d + (A+2.0)*d*d*d);
-					else if(d<2.0)
-						coeff = (-4.0*A + 8.0*A*d - 5.0*A*d*d + A*d*d*d);
-					else
-						coeff=0.0;
-				}
-				else
-				{
-					coeff= 1.0 - d;
-					if(coeff<0) coeff=0;
-				}
-//				if(filterAlign==1) printf("%d %d %d \n", coeff, (int)d, xDstInSrc);
-				filter[i*(*filterSize) + j]= coeff;
-				xx++;
-			}
-			xDstInSrc+= xInc;
-		}
-	}
-
-	//fix borders
-	for(i=0; i<dstW; i++)
-	{
-		int j;
-		if(filterPos[i] < 0)
-		{
-			// Move filter coeffs left to compensate for filterPos
-			for(j=1; j<*filterSize; j++)
-			{
-				int left= MAX(j + filterPos[i], 0);
-				filter[i*(*filterSize) + left] += filter[i*(*filterSize) + j];
-				filter[i*(*filterSize) + j]=0;
-			}
-			filterPos[i]= 0;
-		}
-
-		if(filterPos[i] + (*filterSize) > srcW)
-		{
-			int shift= filterPos[i] + (*filterSize) - srcW;
-			// Move filter coeffs right to compensate for filterPos
-			for(j=(*filterSize)-2; j>=0; j--)
-			{
-				int right= MIN(j + shift, (*filterSize)-1);
-				filter[i*(*filterSize) +right] += filter[i*(*filterSize) +j];
-				filter[i*(*filterSize) +j]=0;
-			}
-			filterPos[i]= srcW - (*filterSize);
-		}
-	}
-
-	//FIXME try to align filterpos if possible / try to shift filterpos to put zeros at the end
-	// and skip these than later
-
-	//Normalize
-	for(i=0; i<dstW; i++)
-	{
-		int j;
-		double sum=0;
-		double scale= one;
-		for(j=0; j<*filterSize; j++)
-		{
-			sum+= filter[i*(*filterSize) + j];
-		}
-		scale/= sum;
-		for(j=0; j<*filterSize; j++)
-		{
-			dstFilter[i*(*filterSize) + j]= (int)(filter[i*(*filterSize) + j]*scale);
-		}
-	}
-}
-
-#ifdef HAVE_MMX2
-static void initMMX2HScaler(int dstW, int xInc, uint8_t *funnyCode)
-{
-	uint8_t *fragment;
-	int imm8OfPShufW1;
-	int imm8OfPShufW2;
-	int fragmentLength;
-
-	int xpos, i;
-
-	// create an optimized horizontal scaling routine
-
-	//code fragment
-
-	asm volatile(
-		"jmp 9f				\n\t"
-	// Begin
-		"0:				\n\t"
-		"movq (%%esi), %%mm0		\n\t" //FIXME Alignment
-		"movq %%mm0, %%mm1		\n\t"
-		"psrlq $8, %%mm0		\n\t"
-		"punpcklbw %%mm7, %%mm1	\n\t"
-		"movq %%mm2, %%mm3		\n\t"
-		"punpcklbw %%mm7, %%mm0	\n\t"
-		"addw %%bx, %%cx		\n\t" //2*xalpha += (4*lumXInc)&0xFFFF
-		"pshufw $0xFF, %%mm1, %%mm1	\n\t"
-		"1:				\n\t"
-		"adcl %%edx, %%esi		\n\t" //xx+= (4*lumXInc)>>16 + carry
-		"pshufw $0xFF, %%mm0, %%mm0	\n\t"
-		"2:				\n\t"
-		"psrlw $9, %%mm3		\n\t"
-		"psubw %%mm1, %%mm0		\n\t"
-		"pmullw %%mm3, %%mm0		\n\t"
-		"paddw %%mm6, %%mm2		\n\t" // 2*alpha += xpos&0xFFFF
-		"psllw $7, %%mm1		\n\t"
-		"paddw %%mm1, %%mm0		\n\t"
-
-		"movq %%mm0, (%%edi, %%eax)	\n\t"
-
-		"addl $8, %%eax			\n\t"
-	// End
-		"9:				\n\t"
-//		"int $3\n\t"
-		"leal 0b, %0			\n\t"
-		"leal 1b, %1			\n\t"
-		"leal 2b, %2			\n\t"
-		"decl %1			\n\t"
-		"decl %2			\n\t"
-		"subl %0, %1			\n\t"
-		"subl %0, %2			\n\t"
-		"leal 9b, %3			\n\t"
-		"subl %0, %3			\n\t"
-		:"=r" (fragment), "=r" (imm8OfPShufW1), "=r" (imm8OfPShufW2),
-		"=r" (fragmentLength)
-	);
-
-	xpos= 0; //lumXInc/2 - 0x8000; // difference between pixel centers
-
-	for(i=0; i<dstW/8; i++)
-	{
-		int xx=xpos>>16;
-
-		if((i&3) == 0)
-		{
-			int a=0;
-			int b=((xpos+xInc)>>16) - xx;
-			int c=((xpos+xInc*2)>>16) - xx;
-			int d=((xpos+xInc*3)>>16) - xx;
-
-			memcpy(funnyCode + fragmentLength*i/4, fragment, fragmentLength);
-
-			funnyCode[fragmentLength*i/4 + imm8OfPShufW1]=
-			funnyCode[fragmentLength*i/4 + imm8OfPShufW2]=
-				a | (b<<2) | (c<<4) | (d<<6);
-
-			// if we dont need to read 8 bytes than dont :), reduces the chance of
-			// crossing a cache line
-			if(d<3) funnyCode[fragmentLength*i/4 + 1]= 0x6E;
-
-			funnyCode[fragmentLength*(i+4)/4]= RET;
-		}
-		xpos+=xInc;
-	}
-/*
-	xpos= 0; //chrXInc/2 - 0x10000; // difference between centers of chrom samples
-	for(i=0; i<dstUVw/8; i++)
-	{
-		int xx=xpos>>16;
-
-		if((i&3) == 0)
-		{
-			int a=0;
-			int b=((xpos+chrXInc)>>16) - xx;
-			int c=((xpos+chrXInc*2)>>16) - xx;
-			int d=((xpos+chrXInc*3)>>16) - xx;
-
-			memcpy(funnyUVCode + fragmentLength*i/4, fragment, fragmentLength);
-
-			funnyUVCode[fragmentLength*i/4 + imm8OfPShufW1]=
-			funnyUVCode[fragmentLength*i/4 + imm8OfPShufW2]=
-				a | (b<<2) | (c<<4) | (d<<6);
-
-			// if we dont need to read 8 bytes than dont :), reduces the chance of
-			// crossing a cache line
-			if(d<3) funnyUVCode[fragmentLength*i/4 + 1]= 0x6E;
-
-			funnyUVCode[fragmentLength*(i+4)/4]= RET;
-		}
-		xpos+=chrXInc;
-	}
-*/
-//	funnyCode[0]= RET;
-}
-#endif // HAVE_MMX2
-
-static void RENAME(SwScale_YV12slice)(unsigned char* srcptr[],int stride[], int srcSliceY ,
-			     int srcSliceH, uint8_t* dstptr[], int dststride, int dstbpp,
-			     int srcW, int srcH, int dstW, int dstH){
-
-
-unsigned int lumXInc= (srcW << 16) / dstW;
-unsigned int lumYInc= (srcH << 16) / dstH;
-unsigned int chrXInc;
-unsigned int chrYInc;
-
-static int dstY;
-
-// used to detect a size change
-static int oldDstW= -1;
-static int oldSrcW= -1;
-static int oldDstH= -1;
-static int oldSrcH= -1;
-static int oldFlags=-1;
-
-static int lastInLumBuf;
-static int lastInChrBuf;
-
-int chrDstW, chrDstH;
-
-static int lumBufIndex=0;
-static int chrBufIndex=0;
-
-static int firstTime=1;
-
-const int widthAlign= dstbpp==12 ? 16 : 8;
-const int bytespp= (dstbpp+1)/8; //(12->1, 15&16->2, 24->3, 32->4)
-const int over= dstbpp==12 ? 	  (((dstW+15)&(~15))) - dststride
-				: (((dstW+7)&(~7)))*bytespp - dststride;
-if(dststride%widthAlign !=0 )
-{
-	if(firstTime)
-		fprintf(stderr, "SwScaler: Warning: dstStride is not a multiple of %d!\n"
-				"SwScaler:          ->cannot do aligned memory acesses anymore\n",
-				widthAlign);
-}
-
-if(over>0 && verbose)
-{
-	if(firstTime)
-		fprintf(stderr, "SwScaler: Warning: output width is not a multiple of 8 (16 for YV12)\n"
-				"SwScaler:          and dststride is not large enough to handle %d extra bytes\n"
-				"SwScaler:          ->using unoptimized C version for last line(s)\n",
-				over);
-}
-
-
-
-//printf("%d %d %d %d\n", srcW, srcH, dstW, dstH);
-//printf("%d %d %d %d\n", lumXInc, lumYInc, srcSliceY, srcSliceH);
-
-#ifdef HAVE_MMX2
-canMMX2BeUsed= (lumXInc <= 0x10000 && (dstW&31)==0 && (srcW&15)==0) ? 1 : 0;
-if(!canMMX2BeUsed && lumXInc <= 0x10000 && (srcW&15)==0 && sws_flags==SWS_FAST_BILINEAR)
-{
-	if(firstTime)
-		fprintf(stderr, "SwScaler: output Width is not a multiple of 32 -> no MMX2 scaler\n");
-}
-#else
-canMMX2BeUsed=0; // should be 0 anyway but ...
-#endif
-
-if(firstTime)
-{
-#if defined (DITHER1XBPP) && defined (HAVE_MMX)
-	char *dither= " dithered";
-#else
-	char *dither= "";
-#endif
-	if(sws_flags==SWS_FAST_BILINEAR)
-		fprintf(stderr, "\nSwScaler: FAST_BILINEAR scaler ");
-	else if(sws_flags==SWS_BILINEAR)
-		fprintf(stderr, "\nSwScaler: BILINEAR scaler ");
-	else if(sws_flags==SWS_BICUBIC)
-		fprintf(stderr, "\nSwScaler: BICUBIC scaler ");
-	else
-		fprintf(stderr, "\nSwScaler: ehh flags invalid?! ");
-
-	if(dstbpp==15)
-		fprintf(stderr, "with%s BGR15 output ", dither);
-	else if(dstbpp==16)
-		fprintf(stderr, "with%s BGR16 output ", dither);
-	else if(dstbpp==24)
-		fprintf(stderr, "with BGR24 output ");
-	else if(dstbpp==32)
-		fprintf(stderr, "with BGR32 output ");
-	else if(dstbpp==12)
-		fprintf(stderr, "with YV12 output ");
-	else
-		fprintf(stderr, "without output ");
-
-#ifdef HAVE_MMX2
-		fprintf(stderr, "using MMX2\n");
-#elif defined (HAVE_3DNOW)
-		fprintf(stderr, "using 3DNOW\n");
-#elif defined (HAVE_MMX)
-		fprintf(stderr, "using MMX\n");
-#elif defined (ARCH_X86)
-		fprintf(stderr, "using X86 ASM\n");
-#else
-		fprintf(stderr, "using C\n");
-#endif
-}
-
-
-// match pixel 0 of the src to pixel 0 of dst and match pixel n-2 of src to pixel n-2 of dst
-// n-2 is the last chrominance sample available
-// this is not perfect, but noone shuld notice the difference, the more correct variant
-// would be like the vertical one, but that would require some special code for the
-// first and last pixel
-if(sws_flags==SWS_FAST_BILINEAR)
-{
-	if(canMMX2BeUsed) 	lumXInc+= 20;
-#ifndef HAVE_MMX //we dont use the x86asm scaler if mmx is available
-	else			lumXInc = ((srcW-2)<<16)/(dstW-2) - 20;
-#endif
-}
-
-if(fullUVIpol && !(dstbpp==12)) 	chrXInc= lumXInc>>1, chrDstW= dstW;
-else					chrXInc= lumXInc,    chrDstW= (dstW+1)>>1;
-
-if(dstbpp==12)	chrYInc= lumYInc,    chrDstH= (dstH+1)>>1;
-else		chrYInc= lumYInc>>1, chrDstH= dstH;
-
-  // force calculation of the horizontal interpolation of the first line
-
-  if(srcSliceY ==0){
-//	printf("dstW %d, srcw %d, mmx2 %d\n", dstW, srcW, canMMX2BeUsed);
-	lumBufIndex=0;
-	chrBufIndex=0;
-	dstY=0;
-
-	//precalculate horizontal scaler filter coefficients
-	if(oldDstW!=dstW || oldSrcW!=srcW || oldFlags!=sws_flags)
-	{
-#ifdef HAVE_MMX
-		const int filterAlign=4;
-#else
-		const int filterAlign=1;
-#endif
-		oldDstW= dstW; oldSrcW= srcW; oldFlags= sws_flags;
-
-		RENAME(initFilter)(hLumFilter, hLumFilterPos, &hLumFilterSize, lumXInc,
-				srcW   , dstW   , filterAlign, 1<<14);
-		RENAME(initFilter)(hChrFilter, hChrFilterPos, &hChrFilterSize, chrXInc,
-				(srcW+1)>>1, chrDstW, filterAlign, 1<<14);
-
-#ifdef HAVE_MMX2
-// cant downscale !!!
-		if(canMMX2BeUsed && sws_flags == SWS_FAST_BILINEAR)
-		{
-			initMMX2HScaler(dstW   , lumXInc, funnyYCode);
-			initMMX2HScaler(chrDstW, chrXInc, funnyUVCode);
-		}
-#endif
-	} // Init Horizontal stuff
-
-	if(oldDstH!=dstH || oldSrcH!=srcH || oldFlags!=sws_flags)
-	{
-		int i;
-		oldDstH= dstH; oldSrcH= srcH; oldFlags= sws_flags; //FIXME swsflags conflict with x check
-
-		// deallocate pixbufs
-		for(i=0; i<vLumBufSize; i++) free(lumPixBuf[i]);
-		for(i=0; i<vChrBufSize; i++) free(chrPixBuf[i]);
-
-		RENAME(initFilter)(vLumFilter, vLumFilterPos, &vLumFilterSize, lumYInc,
-				srcH   , dstH,    1, (1<<12)-4);
-		RENAME(initFilter)(vChrFilter, vChrFilterPos, &vChrFilterSize, chrYInc,
-				(srcH+1)>>1, chrDstH, 1, (1<<12)-4);
-
-		// Calculate Buffer Sizes so that they wont run out while handling these damn slices
-		vLumBufSize= vLumFilterSize; vChrBufSize= vChrFilterSize;
-		for(i=0; i<dstH; i++)
-		{
-			int chrI= i*chrDstH / dstH;
-			int nextSlice= MAX(vLumFilterPos[i   ] + vLumFilterSize - 1,
-					 ((vChrFilterPos[chrI] + vChrFilterSize - 1)<<1));
-			nextSlice&= ~1; // Slices start at even boundaries
-			if(vLumFilterPos[i   ] + vLumBufSize < nextSlice)
-				vLumBufSize= nextSlice - vLumFilterPos[i   ];
-			if(vChrFilterPos[chrI] + vChrBufSize < (nextSlice>>1))
-				vChrBufSize= (nextSlice>>1) - vChrFilterPos[chrI];
-		}
-
-		// allocate pixbufs (we use dynamic allocation because otherwise we would need to
-		// allocate several megabytes to handle all possible cases)
-		for(i=0; i<vLumBufSize; i++)
-			lumPixBuf[i]= lumPixBuf[i+vLumBufSize]= (uint16_t*)memalign(8, 4000);
-		for(i=0; i<vChrBufSize; i++)
-			chrPixBuf[i]= chrPixBuf[i+vChrBufSize]= (uint16_t*)memalign(8, 8000);
-
-		//try to avoid drawing green stuff between the right end and the stride end
-		for(i=0; i<vLumBufSize; i++) memset(lumPixBuf[i], 0, 4000);
-		for(i=0; i<vChrBufSize; i++) memset(chrPixBuf[i], 64, 8000);
-
-		ASSERT(chrDstH<=dstH)
-		ASSERT(vLumFilterSize*dstH*4<16000)
-		ASSERT(vChrFilterSize*chrDstH*4<16000)
-#ifdef HAVE_MMX
-		// pack filter data for mmx code
-		for(i=0; i<vLumFilterSize*dstH; i++)
-			lumMmxFilter[4*i]=lumMmxFilter[4*i+1]=lumMmxFilter[4*i+2]=lumMmxFilter[4*i+3]=
-				vLumFilter[i];
-		for(i=0; i<vChrFilterSize*chrDstH; i++)
-			chrMmxFilter[4*i]=chrMmxFilter[4*i+1]=chrMmxFilter[4*i+2]=chrMmxFilter[4*i+3]=
-				vChrFilter[i];
-#endif
-	}
-
-	if(firstTime && verbose)
-	{
-#ifdef HAVE_MMX2
-		int mmx2=1;
-#else
-		int mmx2=0;
-#endif
-#ifdef HAVE_MMX
-		int mmx=1;
-#else
-		int mmx=0;
-#endif
-
-#ifdef HAVE_MMX
-		if(canMMX2BeUsed && sws_flags==SWS_FAST_BILINEAR)
-			printf("SwScaler: using FAST_BILINEAR MMX2 scaler for horizontal scaling\n");
-		else
-		{
-			if(hLumFilterSize==4)
-				printf("SwScaler: using 4-tap MMX scaler for horizontal luminance scaling\n");
-			else if(hLumFilterSize==8)
-				printf("SwScaler: using 8-tap MMX scaler for horizontal luminance scaling\n");
-			else
-				printf("SwScaler: using n-tap MMX scaler for horizontal luminance scaling\n");
-
-			if(hChrFilterSize==4)
-				printf("SwScaler: using 4-tap MMX scaler for horizontal chrominance scaling\n");
-			else if(hChrFilterSize==8)
-				printf("SwScaler: using 8-tap MMX scaler for horizontal chrominance scaling\n");
-			else
-				printf("SwScaler: using n-tap MMX scaler for horizontal chrominance scaling\n");
-		}
-#elif defined (ARCH_X86)
-		printf("SwScaler: using X86-Asm scaler for horizontal scaling\n");
-#else
-		if(sws_flags==SWS_FAST_BILINEAR)
-			printf("SwScaler: using FAST_BILINEAR C scaler for horizontal scaling\n");
-		else
-			printf("SwScaler: using C scaler for horizontal scaling\n");
-#endif
-
-		if(dstbpp==12)
-		{
-			if(vLumFilterSize==1)
-				printf("SwScaler: using 1-tap %s \"scaler\" for vertical scaling (YV12)\n", mmx ? "MMX" : "C");
-			else
-				printf("SwScaler: using n-tap %s scaler for vertical scaling (YV12)\n", mmx ? "MMX" : "C");
-		}
-		else
-		{
-			if(vLumFilterSize==1 && vChrFilterSize==2)
-				printf("SwScaler: using 1-tap %s \"scaler\" for vertical luminance scaling (BGR)\n"
-				       "SwScaler:       2-tap scaler for vertical chrominance scaling (BGR)\n", mmx ? "MMX" : "C");
-			else if(vLumFilterSize==2 && vChrFilterSize==2)
-				printf("SwScaler: using 2-tap linear %s scaler for vertical scaling (BGR)\n", mmx ? "MMX" : "C");
-			else
-				printf("SwScaler: using n-tap %s scaler for vertical scaling (BGR)\n", mmx ? "MMX" : "C");
-		}
-
-		if(dstbpp==24)
-			printf("SwScaler: using %s YV12->BGR24 Converter\n",
-				mmx2 ? "MMX2" : (mmx ? "MMX" : "C"));
-		else
-			printf("SwScaler: using %s YV12->BGR%d Converter\n", mmx ? "MMX" : "C", dstbpp);
-
-		printf("SwScaler: %dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
-	}
-
-	lastInLumBuf= -1;
-	lastInChrBuf= -1;
-  } // if(firstLine)
 
 	for(;dstY < dstH; dstY++){
-		unsigned char *dest =dstptr[0]+dststride*dstY;
-		unsigned char *uDest=dstptr[1]+(dststride>>1)*(dstY>>1);
-		unsigned char *vDest=dstptr[2]+(dststride>>1)*(dstY>>1);
-		const int chrDstY= dstbpp==12 ? (dstY>>1) : dstY;
+		unsigned char *dest =dst[0]+dstStride[0]*dstY;
+		unsigned char *uDest=dst[1]+dstStride[1]*(dstY>>1);
+		unsigned char *vDest=dst[2]+dstStride[2]*(dstY>>1);
+		const int chrDstY= dstFormat==IMGFMT_YV12 ? (dstY>>1) : dstY;
 
 		const int firstLumSrcY= vLumFilterPos[dstY]; //First line needed as input
 		const int firstChrSrcY= vChrFilterPos[chrDstY]; //First line needed as input
 		const int lastLumSrcY= firstLumSrcY + vLumFilterSize -1; // Last line needed as input
 		const int lastChrSrcY= firstChrSrcY + vChrFilterSize -1; // Last line needed as input
 
-		if(sws_flags == SWS_FAST_BILINEAR)
+		if(flags&SWS_FAST_BILINEAR)
 		{
 			//handle holes
 			if(firstLumSrcY > lastInLumBuf) lastInLumBuf= firstLumSrcY-1;
@@ -2452,24 +1951,29 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 			//Do horizontal scaling
 			while(lastInLumBuf < lastLumSrcY)
 			{
-				uint8_t *src= srcptr[0]+(lastInLumBuf + 1 - srcSliceY)*stride[0];
+				uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];
 				lumBufIndex++;
 				ASSERT(lumBufIndex < 2*vLumBufSize)
 				ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)
 				ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)
 //				printf("%d %d\n", lumBufIndex, vLumBufSize);
-				RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, src, srcW, lumXInc);
+				RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
+						flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,
+						funnyYCode);
 				lastInLumBuf++;
 			}
 			while(lastInChrBuf < lastChrSrcY)
 			{
-				uint8_t *src1= srcptr[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[1];
-				uint8_t *src2= srcptr[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[2];
+				uint8_t *src1= src[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[1];
+				uint8_t *src2= src[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[2];
 				chrBufIndex++;
 				ASSERT(chrBufIndex < 2*vChrBufSize)
 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) < (srcSliceH>>1))
 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) >= 0)
-				RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, (srcW+1)>>1, chrXInc);
+				//FIXME replace parameters through context struct (some at least)
+				RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, (srcW+1)>>1, chrXInc,
+						flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,
+						funnyUVCode);
 				lastInChrBuf++;
 			}
 			//wrap buf index around to stay inside the ring buffer
@@ -2486,23 +1990,27 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 			//Do horizontal scaling
 			while(lastInLumBuf+1 < srcSliceY + srcSliceH)
 			{
-				uint8_t *src= srcptr[0]+(lastInLumBuf + 1 - srcSliceY)*stride[0];
+				uint8_t *s= src[0]+(lastInLumBuf + 1 - srcSliceY)*srcStride[0];
 				lumBufIndex++;
 				ASSERT(lumBufIndex < 2*vLumBufSize)
 				ASSERT(lastInLumBuf + 1 - srcSliceY < srcSliceH)
 				ASSERT(lastInLumBuf + 1 - srcSliceY >= 0)
-				RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, src, srcW, lumXInc);
+				RENAME(hyscale)(lumPixBuf[ lumBufIndex ], dstW, s, srcW, lumXInc,
+						flags, canMMX2BeUsed, hLumFilter, hLumFilterPos, hLumFilterSize,
+						funnyYCode);
 				lastInLumBuf++;
 			}
 			while(lastInChrBuf+1 < ((srcSliceY + srcSliceH)>>1))
 			{
-				uint8_t *src1= srcptr[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[1];
-				uint8_t *src2= srcptr[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*stride[2];
+				uint8_t *src1= src[1]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[1];
+				uint8_t *src2= src[2]+(lastInChrBuf + 1 - (srcSliceY>>1))*srcStride[2];
 				chrBufIndex++;
 				ASSERT(chrBufIndex < 2*vChrBufSize)
 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) < (srcSliceH>>1))
 				ASSERT(lastInChrBuf + 1 - (srcSliceY>>1) >= 0)
-				RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, (srcW+1)>>1, chrXInc);
+				RENAME(hcscale)(chrPixBuf[ chrBufIndex ], chrDstW, src1, src2, (srcW+1)>>1, chrXInc,
+						flags, canMMX2BeUsed, hChrFilter, hChrFilterPos, hChrFilterSize,
+						funnyUVCode);
 				lastInChrBuf++;
 			}
 			//wrap buf index around to stay inside the ring buffer
@@ -2517,9 +2025,9 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 		g5Dither= dither8[dstY&1];
 		r5Dither= dither8[(dstY+1)&1];
 #endif
-	    if(dstY < dstH-2 || over<=0)
+	    if(dstY < dstH-2)
 	    {
-		if(dstbpp==12) //YV12
+		if(dstFormat==IMGFMT_YV12) //YV12
 		{
 			if(dstY&1) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
 			if(vLumFilterSize == 1 && vChrFilterSize == 1) // Unscaled YV12
@@ -2551,7 +2059,7 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 				int chrAlpha= vChrFilter[2*dstY+1];
 
 				RENAME(yuv2rgb1)(*lumSrcPtr, *chrSrcPtr, *(chrSrcPtr+1),
-						 dest, dstW, chrAlpha, dstbpp);
+						 dest, dstW, chrAlpha, dstFormat, flags);
 			}
 			else if(vLumFilterSize == 2 && vChrFilterSize == 2) //BiLinear Upscale RGB
 			{
@@ -2559,14 +2067,14 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 				int chrAlpha= vChrFilter[2*dstY+1];
 
 				RENAME(yuv2rgb2)(*lumSrcPtr, *(lumSrcPtr+1), *chrSrcPtr, *(chrSrcPtr+1),
-						 dest, dstW, lumAlpha, chrAlpha, dstbpp);
+						 dest, dstW, lumAlpha, chrAlpha, dstFormat, flags);
 			}
 			else //General RGB
 			{
 				RENAME(yuv2rgbX)(
 					vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
 					vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
-					dest, dstW, dstbpp,
+					dest, dstW, dstFormat,
 					lumMmxFilter+dstY*vLumFilterSize*4, chrMmxFilter+dstY*vChrFilterSize*4);
 			}
 		}
@@ -2575,7 +2083,7 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 	    {
 		int16_t **lumSrcPtr= lumPixBuf + lumBufIndex + firstLumSrcY - lastInLumBuf + vLumBufSize;
 		int16_t **chrSrcPtr= chrPixBuf + chrBufIndex + firstChrSrcY - lastInChrBuf + vChrBufSize;
-		if(dstbpp==12) //YV12
+		if(dstFormat==IMGFMT_YV12) //YV12
 		{
 			if(dstY&1) uDest=vDest= NULL; //FIXME split functions in lumi / chromi
 			yuv2yuvXinC(
@@ -2590,7 +2098,7 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 			yuv2rgbXinC(
 				vLumFilter+dstY*vLumFilterSize, lumSrcPtr, vLumFilterSize,
 				vChrFilter+dstY*vChrFilterSize, chrSrcPtr, vChrFilterSize,
-				dest, dstW, dstbpp);
+				dest, dstW, dstFormat);
 		}
 	    }
 	}
@@ -2599,5 +2107,10 @@ else		chrYInc= lumYInc>>1, chrDstH= dstH;
 	__asm __volatile(SFENCE:::"memory");
 	__asm __volatile(EMMS:::"memory");
 #endif
-	firstTime=0;
+	/* store changed local vars back in the context */
+	c->dstY= dstY;
+	c->lumBufIndex= lumBufIndex;
+	c->chrBufIndex= chrBufIndex;
+	c->lastInLumBuf= lastInLumBuf;
+	c->lastInChrBuf= lastInChrBuf;
 }