winamp/Src/tataki/bitmap/win/bitmap.cpp

#include <tataki/api__tataki.h>

//#define NO_SIMPLEFASTMODE
#include <api/imgldr/api_imgldr.h>
#include <tataki/blending/blending.h>

#include "bitmap.h"

#include <bfc/wasabi_std.h>
#include <tataki/canvas/bltcanvas.h>

#include <api/memmgr/api_memmgr.h>


#if !defined(WIN32) && !defined(LINUX)
#error port me!
#endif

#define ERRORBMP L"wasabi.bitmapnotfound"
#define HARDERRORBMP L"xml/wasabi/window/error.png"
// do not define NO_MMX in this file. :)

#ifndef NO_MMX

#ifdef WIN32
#define MMX_CONST const
#else
#define MMX_CONST
#endif

static unsigned int MMX_CONST SkinBitmap_mmx_revn2[2]={0x01000100,0x01000100};
static unsigned int MMX_CONST SkinBitmap_mmx_zero[2];
static unsigned int MMX_CONST SkinBitmap_mmx_one[2]={1,0};
#define HAS_MMX Blenders::MMX_AVAILABLE()

#else

//NO_MMX defined
#define HAS_MMX 0

#endif
#if 0
		int bitmap_x = bitmap->getX();
		int bitmap_y = bitmap->getY();
		int bmpheight = bitmap->getHeight();
		int fullimage_w = bitmap->getFullWidth();
		void *bits = bitmap->getBits();
		int xp=xe-xs;
		for (int yp = ys; yp < ye; yp ++)
		{
			int t=yv>>16;
			if (t < 0) t=0;
			if (t >= bmpheight) t=bmpheight-1;
			int *psrc=((int*)bits) + (t+bitmap_y)*fullimage_w + bitmap_x;
			int *dest=((int*)dib) + pitch*yp + xs;

			C::stretch(xp, psrc, dest, xstart, dxv, alpha);

			yv+=dyv;
		}
	}
#endif
	static __inline int shc(int offset, int offset16, int pos, int delta)
	{
		__int64 num = (Int32x32To64(pos, delta) + (__int64)offset16)/65536LL;
		return (int)(num+offset);
	}

	static __inline void *ROUNDUP16(void *ptr)
	{
		return (void *)(((size_t)ptr+15) & ~15);
	}

static void Shrink(SkinBitmap *src_, int ys, int ye, int xe, int xs, int xstart, int yv, void *dst_, int dstpitch, int dxv, int dyv, int alpha)
{
// to scale an image
	// where the destination image is both smaller on X *and* Y.

	// inputs:
	int srcpitch = src_->getFullWidth();
	int bitmap_x = src_->getX();
	int bitmap_height = src_->getHeight();
	int bitmap_fullheight = src_->getFullHeight();
	int bitmap_y = src_->getY();

	uint8_t *src=(uint8_t *)src_->getBits();;
	ARGB32 *dst= (ARGB32 *)dst_;

//#define NEW_X(x__) ((srcxs+bitmap_x)+MulDiv(x__, dxv, 65536))
#define NEW_X(x__) shc(bitmap_x, xstart,(x__), dxv)
#define NEW_Y(y__) shc(bitmap_y, yv,    (y__)-ys, dyv)
	
	int dstw = xe-xs;
	// make sure we have enough room.  I don't think anyone is going to have destination bitmaps this big, but might as well play it safe
	ASSERT(dstw <= 4096);
	if (dstw > 4096)		return; 

	// all this weird stuff is to align on 16 byte boundary
	char *_new_x[4096*sizeof(int)+15] = {0}; 
	char *new_x_aligned = (char *)_new_x;
	ROUNDUP16(new_x_aligned);
	int *new_x = (int *)new_x_aligned;
	for (int x=0; x<=dstw; x++)
	  new_x[x] = NEW_X(x);
	
	// FOR EACH DEST PIXEL
	for (int y=ys; y<ye; y++)
	{
		int sy1 = NEW_Y(y);
		int sy2 = NEW_Y(y+1);
		for (int x=0; x<dstw; x++)
		{
			uint32_t sum[4] = { 0, 0, 0, 0 };
			int sx1 = new_x[x];
			int sx2 = new_x[x+1];
			// FOR EACH CONTRIBUTING SOURCE PIXEL: in a block [sx1..sx2) x [sy1..sy2)
			for (int b=sy1; b<sy2; b++)
				for (int a=sx1; a<sx2; a++)
				{
					uint8_t *ps = &src[(b*srcpitch + a)*4];
					sum[0] += (uint32_t)ps[0];
					sum[1] += (uint32_t)ps[1];
					sum[2] += (uint32_t)ps[2];
					sum[3] += (uint32_t)ps[3];
				}
			// write downsampled pixel:
			ARGB32 &dstpix = dst[(y*dstpitch + x+xs)];
			uint32_t out;
			uint8_t *pd = (uint8_t *)&out;
			int pixels_covered = (sy2-sy1)*(sx2-sx1);
			pd[0] = (uint32_t)(sum[0] / pixels_covered);
			pd[1] = (uint32_t)(sum[1] / pixels_covered);
			pd[2] = (uint32_t)(sum[2] / pixels_covered);
			pd[3] = (uint32_t)(sum[3] / pixels_covered);
#ifdef NO_MMX
					dstpix = Blenders::BLEND_ADJ3(dstpix, out, alpha);
#else
			dstpix = Blenders::BLEND_ADJ3_MMX(dstpix, out, alpha);
#endif
		}
	}
}

static wchar_t skinBitmapBlankName[] = L"";
SkinBitmap::SkinBitmap(HINSTANCE hInstance, int id, const wchar_t *forcegroup)
{
	high_quality_resampling = false;
	references = 1;
	bitmapname = skinBitmapBlankName;
	subimage_w = -1;
	subimage_h = -1;
	x_offset = -1;
	y_offset = -1;
	fullimage_w = fullimage_h = 0;
	has_alpha = 0;
	ASSERT(hInstance != NULL);
	ownbits = 1;
	fromskin = 0;
	bits = WASABI_API_IMGLDR->imgldr_makeBmp(hInstance, id,&has_alpha,&fullimage_w,&fullimage_h, forcegroup);
	last_failed = 0;
	if (bits == NULL)
	{
		//last_failed = 1;
		//TODO: bits = WASABI_API_IMGLDR->imgldr_requestSkinBitmap(ERRORBMP, &has_alpha, &x_offset, &y_offset, &subimage_w, &subimage_h, &fullimage_w, &fullimage_h,_cached);
	}
	if (bits == NULL)
	{
		last_failed = 1;
		bits = WASABI_API_IMGLDR->imgldr_makeBmp(HARDERRORBMP, &has_alpha, &fullimage_w, &fullimage_h);
	}
}

SkinBitmap::SkinBitmap(ARGB32 *_bits, int w, int h, bool own)
{
	high_quality_resampling = false;
	references = 1;
	subimage_w = -1;
	subimage_h = -1;
	x_offset = -1;
	y_offset = -1;
	bitmapname = skinBitmapBlankName;
	fullimage_w = w;
	fullimage_h = h;
	has_alpha = 1;
	if (own)
		ownbits = OWNBITS_USECFREE;
	else
		ownbits = OWNBITS_NOTOURS;
	bits = _bits;
	fromskin = 0;
	last_failed = 0;
}

// TODO: benski> could we be using GetDIBits here?
void SkinBitmap::bmpToBits(HBITMAP hbmp, HDC defaultDC)
{
#ifdef WIN32
	if (hbmp && !bits)
	{
		BITMAPINFO srcbmi={0};
		HDC hMemDC, hMemDC2;
		HBITMAP hprev,hprev2=0;
		HBITMAP hsrcdib;
		void *srcdib;
		BITMAP bm;
		int r = GetObject(hbmp, sizeof(BITMAP), &bm);
		ASSERT(r != 0);

		fullimage_w=bm.bmWidth;
		fullimage_h=ABS(bm.bmHeight);

		int bmw=getWidth();
		int bmh=getHeight();
		int xo=getX();
		int yo=getY();

		srcbmi.bmiHeader.biSize=sizeof(srcbmi.bmiHeader);
		srcbmi.bmiHeader.biWidth=bmw;
		srcbmi.bmiHeader.biHeight=-bmh;
		srcbmi.bmiHeader.biPlanes=1;
		srcbmi.bmiHeader.biBitCount=32;
		srcbmi.bmiHeader.biCompression=BI_RGB;
		hMemDC = CreateCompatibleDC(NULL);
		hsrcdib=CreateDIBSection(hMemDC,&srcbmi,DIB_RGB_COLORS,&srcdib,NULL,0);
		ASSERTPR(hsrcdib != 0, "CreateDIBSection() failed #6");
		if (defaultDC)
			hMemDC2 = defaultDC;
		else
		{
			hMemDC2 = CreateCompatibleDC(NULL);
			hprev2 = (HBITMAP) SelectObject(hMemDC2, hbmp);
		}
		hprev = (HBITMAP) SelectObject(hMemDC, hsrcdib);
		BitBlt(hMemDC,0,0,bmw,bmh,hMemDC2,xo,yo,SRCCOPY);
		SelectObject(hMemDC, hprev);
		if (!defaultDC)
		{
			SelectObject(hMemDC2, hprev2);
			DeleteDC(hMemDC2);
		}
		DeleteDC(hMemDC);
		bits=(ARGB32*)MALLOC(bmw*bmh*4);
		if (getHeight()+getY() > bm.bmHeight || getWidth()+getX() > bm.bmWidth)
		{
			ASSERTALWAYS(StringPrintf("Subbitmap coordinates outside master bitmap [%d,%d,%d,%d in 0,0,%d,%d]", getX(), getY(), getWidth(), getHeight(), bm.bmWidth, bm.bmHeight));
		}
		MEMCPY32(bits,srcdib,bmw*bmh/**sizeof(ARGB32)*/);
		DeleteObject(hsrcdib);
		x_offset=-1;
		y_offset=-1;
		subimage_w=-1;
		subimage_h=-1;
		fullimage_w=bmw;
		fullimage_h=bmh;
	}
#endif
#ifdef LINUX
	if (! bits)
	{
		fullimage_w=hbmp.bmWidth;
		fullimage_h=ABS(hbmp.bmHeight);

		bits=(ARGB32*)MALLOC_(fullimage_w * fullimage_h * 4);
		MEMCPY32(bits, hbmp.shmseginfo->shmaddr, fullimage_w * fullimage_h);
		x_offset=-1;
		y_offset=-1;
		subimage_w=-1;
		subimage_h=-1;
	}
#endif
}

SkinBitmap::SkinBitmap(const wchar_t *elementname, int _cached)
{
	ASSERT(elementname!= NULL);

	high_quality_resampling=false;
	references=1;
	bitmapname = _wcsdup(elementname);
	x_offset = -1;
	y_offset = -1;
	subimage_w = -1;
	subimage_h = -1;
	fullimage_w = fullimage_h = 0;
	ownbits = OWNBITS_USEIMGLDR;
	bits = NULL;
	fromskin = 0;
	last_failed = 0;

	if (WASABI_API_IMGLDR) // someone might be using us in Classic Skin so explicitly check this
	{
		bits = WASABI_API_IMGLDR->imgldr_requestSkinBitmap(elementname, &has_alpha, &x_offset, &y_offset, &subimage_w, &subimage_h, &fullimage_w, &fullimage_h,_cached);
		fromskin = (bits != NULL);

		if (bits == NULL)
			bits = WASABI_API_IMGLDR->imgldr_makeBmp(elementname, &has_alpha, &fullimage_w, &fullimage_h);

		if (bits == NULL)
		{
			bits = WASABI_API_IMGLDR->imgldr_requestSkinBitmap(ERRORBMP, &has_alpha, &x_offset, &y_offset, &subimage_w, &subimage_h, &fullimage_w, &fullimage_h,_cached);
			last_failed = 1;
		}

		if (bits == NULL)
		{
			bits = WASABI_API_IMGLDR->imgldr_makeBmp(HARDERRORBMP, &has_alpha, &fullimage_w, &fullimage_h);
			last_failed = 1;
		}

		// check that coordinates are correct
		if (x_offset!=-1 && x_offset>fullimage_w) x_offset=fullimage_w-1;
		if (y_offset!=-1 && y_offset>fullimage_h) y_offset=fullimage_h-1;
		if (subimage_w!=-1 && (x_offset+subimage_w)>fullimage_w) subimage_w=fullimage_w-x_offset;
		if (subimage_h!=-1 && (y_offset+subimage_h)>fullimage_h) subimage_h=fullimage_h-y_offset;

			// ASSERTPR(bits != NULL, elementname);
	if (bits == NULL)
	{
		DebugStringW(L"element not found ! %s\n", elementname);
		int n = 10*10;
		bits = (ARGB32 *)WASABI_API_MEMMGR->sysMalloc(n * sizeof(ARGB32));
		fromskin = OWNBITS_USESYSFREE;
		ARGB32 *p = bits;
		while (n--)
			*p++ = 0xFFFF00FF;
	}
	}
	else
		last_failed = 1;
}

SkinBitmap::SkinBitmap(HBITMAP bitmap)
{
#ifdef WIN32
	ASSERT(bitmap != NULL);
#endif
	high_quality_resampling = false;
	references = 1;
	subimage_w = -1;
	subimage_h = -1;
	x_offset = -1;
	y_offset = -1;
	bitmapname = skinBitmapBlankName;
	fullimage_w = fullimage_h = 0;
	has_alpha = 0;
	ownbits = OWNBITS_USESTDFREE;
	bits = NULL;
	fromskin = 0;
	last_failed = 0;
	bmpToBits(bitmap,NULL);
}

SkinBitmap::SkinBitmap(HBITMAP bitmap, HDC dc, int _has_alpha, void *_bits)
{
	high_quality_resampling=false;
	references=1;
	subimage_w=-1;
	subimage_h=-1;
	x_offset=-1;
	y_offset=-1;
	fromskin = 0;
	last_failed = 0;
	bitmapname = skinBitmapBlankName;
	fullimage_w=fullimage_h=0;
#ifdef WIN32
	ASSERT(bitmap != NULL);
#endif
	has_alpha = _has_alpha;
	bits = (ARGB32*)_bits;
	if (!_bits)
	{
		ownbits = OWNBITS_USESTDFREE;
		bmpToBits(bitmap,dc);
	}
	else
	{
#ifdef WIN32
		BITMAP bm;
		ownbits = OWNBITS_NOTOURS;
		int r = GetObject(bitmap, sizeof(BITMAP), &bm);
		ASSERT(r != 0);
		fullimage_w = bm.bmWidth;
		fullimage_h = ABS(bm.bmHeight);
#endif
#ifdef LINUX
		ownbits = OWNBITS_NOTOURS;
		fullimage_w = bitmap.bmWidth;
		fullimage_h = ABS(bitmap.bmHeight);
#endif
//port me
	}
}

SkinBitmap::SkinBitmap(ifc_canvas *canvas)
{
	high_quality_resampling=false;
	references=1;
	subimage_w=-1;
	subimage_h=-1;
	x_offset=-1;
	y_offset=-1;
	bits = NULL;

	void *canvas_bits = canvas->getBits();
	if (canvas_bits)
	{
	canvas->getDim(&subimage_w, &fullimage_h, &fullimage_w);
	fullimage_w/=4;
	canvas->getOffsets(&x_offset, &y_offset);
	size_t copylen = fullimage_h*fullimage_w*sizeof(ARGB32);
	bits =(ARGB32 *)MALLOC(copylen);
	memcpy(bits, canvas_bits, copylen);
	last_failed = 0;
	ownbits = OWNBITS_USESTDFREE;
	}
	else
	{
		last_failed = 1;
		ownbits = OWNBITS_NOTOURS;
	}
	subimage_h=-1;
	bitmapname = skinBitmapBlankName;
	has_alpha = 1;
	fromskin = 0;	
}

SkinBitmap::SkinBitmap(int w, int h, ARGB32 bgcolor)
{
	high_quality_resampling=false;
	references=1;
	subimage_w=-1;
	subimage_h=-1;
	x_offset=-1;
	y_offset=-1;
	fullimage_w=w;
	bitmapname = skinBitmapBlankName;
	fullimage_h=h;
	fromskin = 0;
	last_failed = 0;

	int memsize = w*h*sizeof(ARGB32);
	if (memsize == 0) memsize++; // +1 so no failure when 0x0
	bits = (ARGB32*)MALLOC(memsize);

	DWORD *dw = (DWORD *)bits;
	MEMFILL<DWORD>(dw, bgcolor, w*h);

	has_alpha = TRUE;
	ownbits = OWNBITS_USESTDFREE; // 2 specifies should be FREE()'d
}

SkinBitmap::~SkinBitmap()
{
	if (bits)
	{
		switch(ownbits)
		{
			case OWNBITS_USESTDFREE:
				FREE(bits);
				break;
			case OWNBITS_USECFREE:
				free(bits);
				break;
			case OWNBITS_USESYSFREE:
				WASABI_API_MEMMGR->sysFree(bits);
				break;
			case OWNBITS_USEIMGLDR:
			{
				if (WASABI_API_IMGLDR)
				{
					if (fromskin)
						WASABI_API_IMGLDR->imgldr_releaseSkinBitmap(bits);
					else
#ifndef _WASABIRUNTIME
						WASABI_API_IMGLDR->imgldr_releaseBmp(bits);
#else
						WASABI_API_IMGLDR->imgldr_releaseSkinBitmap(bits);
#endif
				}
			}
			break;
		}
	}
	bits = NULL;

	if (bitmapname && bitmapname != skinBitmapBlankName)
		free(bitmapname);
}

void SkinBitmap::blit(ifc_canvas *canvas, int x, int y)
{
	RECT src, dst;
	src.left=0;
	src.top=0;
	src.bottom=getHeight();
	src.right=getWidth();
	dst.left=x;
	dst.right=x+getWidth();
	dst.top=y;
	dst.bottom=y+getHeight();
	blitToRect(canvas,&src,&dst,255);
}

void SkinBitmap::blitRectToTile(ifc_canvas *canvas, RECT *dest, RECT *src, int xoffs, int yoffs, int alpha)
{
	int startx,starty;

	int w,h;

	w = src->right-src->left;
	h = src->bottom-src->top;
	if (w <= 0 || h <= 0) return;	//wtfmf

	RECT c;
	if (canvas->getClipBox(&c) == NULLREGION)
	{
		c = *dest;
	}
	else
	{
		if (dest->left > c.left) c.left = dest->left;
		if (dest->top > c.top) c.top = dest->top;
		if (dest->right < c.right) c.right = dest->right;
		if (dest->bottom < c.bottom) c.bottom = dest->bottom;
	}


	starty = c.top-((c.top - dest->top) % h)- yoffs;
	startx = c.left-((c.left - dest->left) % w) - xoffs;

	for (int j=starty;j<c.bottom;j+=h)
		for (int i=startx;i<c.right;i+=w)
		{
			int xp=i;
			int yp=j;
			int xo=0;
			int yo=0;
			int _w=getWidth();
			int _h=getHeight();
			if (xp < c.left)
			{
				xo=c.left-xp;
				_w+=xo;
				xp=c.left;
			}
			if (yp < c.top)
			{
				yo=c.top-yp;
				_h+=yo;
				yp=c.top;
			}
			if (xp + _w >= c.right) _w=c.right-xp;
			if (yp + _h >= c.bottom) _h=c.bottom-yp;
			RECT _s={xo, yo, xo+_w, yo+_h};
			RECT _d={xp, yp, xp+_w, yp+_h};
			blitToRect(canvas, &_s, &_d, alpha);
		}
}


void SkinBitmap::blitTile(ifc_canvas *canvas, RECT *dest, int xoffs, int yoffs, int alpha)
{
	RECT r={0,0,getWidth(),getHeight()};
	blitRectToTile(canvas, dest, &r, xoffs, yoffs, alpha);
}

#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4799)
#endif


#define DEFAULT_CACHE_WIDTH 64
#define DEFAULT_CACHE_HEIGHT 64

extern DWORD bitmap_cache_tls;

void SkinBitmap::blitToRect(ifc_canvas *canvas, RECT *src, RECT *dst, int alpha)   // only dst(top,left) are used
{
	if (alpha <= 0) return;
	if (alpha > 255) alpha = 255;

	BltCanvas *blitToRectCanvas=0;
	HDC hdc = canvas->getHDC();
	if (hdc == NULL) return;
	void *dib=canvas->getBits();
	int cwidth,cheight, pitch;
	BaseCloneCanvas clone(canvas);
	bool usingBlitCanvas = false;
	RECT destrect=*dst;
	destrect.bottom=destrect.top+(src->bottom-src->top);
	destrect.right=destrect.left+(src->right-src->left);

	RECT c;
	int ctype=canvas->getClipBox(&c);

	if (c.top > destrect.top) destrect.top=c.top;
	if (c.left > destrect.left) destrect.left=c.left;
	if (c.bottom < destrect.bottom) destrect.bottom=c.bottom;
	if (c.right < destrect.right) destrect.right=c.right;

#ifdef NO_SIMPLEFASTMODE
	dib=NULL;
#endif

	if (destrect.right <= destrect.left || destrect.bottom <= destrect.top) return;
	int xs,yp,xe,ye;

	if (!dib || canvas->getDim(NULL,&cheight,&cwidth) || !cwidth || cheight < 1 || ctype == COMPLEXREGION)
	{
		cwidth=destrect.right-destrect.left;
		cheight=destrect.bottom-destrect.top;

/* create cached canvas for this thread if it doesn't exist */		
		blitToRectCanvas = (BltCanvas *)TlsGetValue(bitmap_cache_tls);
		if (!blitToRectCanvas)
		{
			blitToRectCanvas = new BltCanvas(cwidth, cheight);
			TlsSetValue(bitmap_cache_tls, (LPVOID)blitToRectCanvas);
		}
		int cacheWidth, cacheHeight;
		blitToRectCanvas->getDim(&cacheWidth, &cacheHeight, NULL);

	  /* resize cache if necessary */
		if (cwidth > cacheWidth || cheight > cacheHeight)
		{
			cacheWidth=MAX(cacheWidth, cwidth);
			cacheHeight=MAX(cacheHeight, cheight);
			blitToRectCanvas->DestructiveResize(cacheWidth, cacheHeight);
		}

		dib = blitToRectCanvas->getBits();
		if (has_alpha || alpha < 255)
			clone.blit(destrect.left, destrect.top, blitToRectCanvas, 0, 0, cwidth, cheight);

		xs=0;
		yp=0;
		xe=cwidth;
		ye=cheight;
		pitch=cacheWidth;
		usingBlitCanvas = true;
	}
	else
	{
		xs=destrect.left;
		xe=destrect.right;
		yp=destrect.top;
		ye=destrect.bottom;

		cwidth/=4;
		pitch=cwidth;
	}
	int xpo=(dst->left-destrect.left+xs)-(getX()+src->left);
	int ypo=(dst->top-destrect.top+yp)-(getY()+src->top);

	if (yp < 0) yp=0;
	if (xs < 0) xs=0;

	if (yp<getY()+ypo) yp=ypo+getY();
	if (xs<getX()+xpo) xs=xpo+getX();

	if (xe > getWidth()+getX()+xpo) xe=getWidth()+getX()+xpo;
	if (ye > getHeight()+getY()+ypo) ye=getHeight()+getY()+ypo;

	// blend bitmap to dib

	if (xs<xe) for (; yp < ye; yp ++)
		{
			int xp=xe-xs;
			unsigned int *dest=((unsigned int*)dib) + pitch*yp + xs;
			unsigned int *src=((unsigned int*)bits) + (yp-ypo)*fullimage_w + (xs-xpo);

			if (!has_alpha && alpha==255) // simple copy
			{
				MEMCPY32(dest,src,xp);
			}
			else if (!has_alpha)   // no alpha channel info, but just a simple blend
			{
				if (!HAS_MMX)
					while (xp--) 					*dest++ = Blenders::BLEND_ADJ1(*src++, *dest, alpha);

#ifndef NO_MMX
				else
				{
#ifdef WIN32
					if (xp>1) __asm
					{
						movd mm3, [alpha]
						mov ecx, xp

						movq mm4, [SkinBitmap_mmx_revn2]
						packuswb mm3, mm3 // 0000HHVV

						paddusw mm3, [SkinBitmap_mmx_one]
						mov edi, dest

						punpcklwd mm3, mm3 // HHVVHHVV
						mov esi, src

						punpckldq mm3, mm3 // HHVVHHVV HHVVHHVV
						shr ecx, 1

						psubw mm4, mm3

						align 16
_blitAlpha_Loop1:

						movd mm0, [edi]

						movd mm1, [esi]
						punpcklbw mm0, [SkinBitmap_mmx_zero]

						movd mm7, [edi+4]
						punpcklbw mm1, [SkinBitmap_mmx_zero]

						pmullw mm0, mm4
						pmullw mm1, mm3

						movd mm6, [esi+4]
						punpcklbw mm7, [SkinBitmap_mmx_zero]

						punpcklbw mm6, [SkinBitmap_mmx_zero]

						pmullw mm7, mm4
						pmullw mm6, mm3

						paddw mm0, mm1

						psrlw mm0, 8

						packuswb mm0, mm0
						add esi, 8

						movd [edi], mm0
						paddw mm7, mm6

						psrlw mm7, 8

						packuswb mm7, mm7

						movd [edi+4], mm7

						add edi, 8

						dec ecx
						jnz _blitAlpha_Loop1
						mov src, esi
						mov dest, edi
#else
					if (xp > 1)
					{
						__asm__ volatile(
						  "movd %6, %%mm3\n"
						  "mov %2, %%ecx\n"
						  "movq (SkinBitmap_mmx_revn2), %%mm4\n"
						  "packuswb %%mm3, %%mm3\n"
						  "paddusw (SkinBitmap_mmx_one), %%mm3\n"
						  "mov %0, %%edi\n"
						  "punpcklwd %%mm3, %%mm3\n"
						  "mov %1, %%esi\n"
						  "punpckldq %%mm3, %%mm3\n"
						  "shr $1, %%ecx\n"
						  "psubw %%mm3, %%mm4\n"
						  ".align 16\n"
						  "_blitAlpha_Loop1:\n"
						  "movd (%%edi), %%mm0\n"
						  "movd (%%esi), %%mm1\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
						  "movd 4(%%edi), %%mm7\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
						  "pmullw %%mm3, %%mm0\n"
						  "pmullw %%mm4, %%mm1\n"
						  "movd 4(%%esi), %%mm6\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
						  "pmullw %%mm4, %%mm6\n"
						  "pmullw %%mm3, %%mm7\n"
						  "paddw %%mm1, %%mm0\n"
						  "psrlw $8, %%mm0\n"
						  "packuswb %%mm0, %%mm0\n"
						  "add $8, %%esi\n"
						  "movd %%mm0, (%%edi)\n"
						  "paddw %%mm6, %%mm7\n"
						  "psrlw $8, %%mm7\n"
						  "packuswb %%mm7, %%mm7\n"
						  "movd %%mm7, 4(%%edi)\n"
						  "add $8, %%edi\n"
						  "dec %%ecx\n"
						  "jnz _blitAlpha_Loop1\n"
						  "mov %%esi, %1\n"
						  "mov %%edi, %0\n"

  : "=m"(dest), "=m"(src), "=m"(xp)
								  : "0"(dest), "1"(src), "2"(xp), "m"(alpha)
								  : "%eax", "%ecx", "%esi", "%edi");

#endif
					}
					if (xp & 1) *dest++ = Blenders::BLEND_ADJ1_MMX(*src++, *dest, alpha);
				} // mmx available
#endif // !NO_MMX
			}
			else if (alpha == 255)   // no global alpha, just alpha channel
			{
				if (!HAS_MMX)
					while (xp--)					*dest++ = Blenders::BLEND_ADJ2(*dest, *src++);

#ifndef NO_MMX
				else
				{
#ifdef WIN32
					if (xp > 1) __asm
					{
						mov ecx, xp
						shr ecx, 1
						mov edi, dest
						mov esi, src
						align 16
_blitAlpha_Loop2:

						movd mm3, [esi]
						movd mm5, [esi+4]

						movq mm2, [SkinBitmap_mmx_revn2]
						psrld mm3, 24

						movq mm4, [SkinBitmap_mmx_revn2]
						psrld mm5, 24

						movd mm0, [edi]
						packuswb mm3, mm3 // 0000HHVV

						movd mm1, [esi]
						packuswb mm5, mm5 // 0000HHVV

						movd mm6, [esi+4]
						paddusw mm3, [SkinBitmap_mmx_one]

						punpcklwd mm3, mm3 // HHVVHHVV
						paddusw mm5, [SkinBitmap_mmx_one]

						movd mm7, [edi+4]
						punpcklwd mm5, mm5 // HHVVHHVV

						punpckldq mm3, mm3 // HHVVHHVV HHVVHHVV
						punpckldq mm5, mm5 // HHVVHHVV HHVVHHVV

						punpcklbw mm6, [SkinBitmap_mmx_zero]
						psubw mm4, mm5

						punpcklbw mm0, [SkinBitmap_mmx_zero]
						psubw mm2, mm3

						punpcklbw mm7, [SkinBitmap_mmx_zero]
						pmullw mm0, mm2

						pmullw mm7, mm4
						punpcklbw mm1, [SkinBitmap_mmx_zero]

						psubw mm2, mm3

						psrlw mm0, 8
						psrlw mm7, 8
						paddw mm0, mm1

						paddw mm7, mm6
						packuswb mm0, mm0

						movd [edi], mm0
						packuswb mm7, mm7

						movd [edi+4], mm7

						add esi, 8
						add edi, 8

						dec ecx
						jnz _blitAlpha_Loop2
						mov src, esi
						mov dest, edi
#else
					if (xp > 1)
					{
						__asm__ volatile(
						  "mov %4, %%ecx\n"
						  "shr $1, %%ecx\n"
						  "mov %0, %%edi\n"
						  "mov %1, %%esi\n"
						  ".align 16\n"
						  "_blitAlpha_Loop2:\n"
						  "movd (%%esi), %%mm3\n"
						  "movd 4(%%esi), %%mm5\n"
						  "movq (SkinBitmap_mmx_revn2), %%mm2\n"
						  "psrld $24, %%mm3\n"
						  "movq (SkinBitmap_mmx_revn2), %%mm4\n"
						  "psrld $24, %%mm5\n"
						  "movd (%%edi), %%mm0\n"
						  "packuswb %%mm3, %%mm3\n"
						  "movd (%%esi), %%mm1\n"
						  "packuswb %%mm5, %%mm5\n"
						  "movd 4(%%esi), %%mm6\n"
						  "paddusw (SkinBitmap_mmx_one), %%mm3\n"
						  "punpcklwd %%mm3, %%mm3\n"
						  "paddusw (SkinBitmap_mmx_one), %%mm5\n"
						  "movd 4(%%edi), %%mm7\n"
						  "punpcklwd %%mm5, %%mm5\n"
						  "punpckldq %%mm3, %%mm3\n"
						  "punpckldq %%mm5, %%mm5\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
						  "psubw %%mm5, %%mm4\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
						  "psubw %%mm3, %%mm2\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
						  "pmullw %%mm2, %%mm0\n"
						  "pmullw %%mm4, %%mm7\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
						  "psubw %%mm3, %%mm2\n"
						  "psrlw $8, %%mm0\n"
						  "psrlw $8, %%mm7\n"
						  "paddw %%mm1, %%mm0\n"
						  "paddw %%mm6, %%mm7\n"
						  "packuswb %%mm0, %%mm0\n"
						  "movd %%mm0, (%%edi)\n"
						  "packuswb %%mm7, %%mm7\n"
						  "movd %%mm7, 4(%%edi)\n"
						  "add $8, %%esi\n"
						  "add $8, %%edi\n"
						  "dec %%ecx\n"
						  "jnz _blitAlpha_Loop2\n"
						  "mov %%esi, %1\n"
						  "mov %%edi, %0\n"

  : "=m"(dest), "=m"(src)
								  : "0"(dest), "1"(src), "m"(xp)
								  : "%eax", "%ecx", "%esi", "%edi");
#endif
					}
					if (xp&1) *dest++ = Blenders::BLEND_ADJ2_MMX(*dest, *src++);
				} // HAS_MMX
#endif // ifndef NO_MMX
			}
			else   // both
			{
				if (!HAS_MMX)
					while (xp--) 					*dest++ = Blenders::BLEND_ADJ3(*dest, *src++, alpha);
#ifndef NO_MMX
				else
				{
#ifdef WIN32
					if (xp > 1) __asm
					{
						movd mm5, [alpha]
						mov ecx, xp

						packuswb mm5, mm5
						shr ecx, 1

						paddusw mm5, [SkinBitmap_mmx_one]

						punpcklwd mm5, mm5
						mov edi, dest

						punpckldq mm5, mm5
						mov esi, src

						align 16
_blitAlpha_Loop3:

						movd mm3, [esi] // VVVVVVVV
						movd mm4, [esi+4] // VVVVVVVV

						movd mm0, [edi]
						psrld mm3, 24

						movd mm1, [esi]
						psrld mm4, 24

						paddusw mm3, [SkinBitmap_mmx_one]
						paddusw mm4, [SkinBitmap_mmx_one]

						movd mm7, [edi+4]
						punpcklwd mm3, mm3

						movd mm6, [esi+4]
						punpcklwd mm4, mm4

						punpckldq mm3, mm3
						punpckldq mm4, mm4

						pmullw mm3, mm5
						pmullw mm4, mm5

						punpcklbw mm7, [SkinBitmap_mmx_zero]
						punpcklbw mm6, [SkinBitmap_mmx_zero]

						movq mm2, [SkinBitmap_mmx_revn2]
						psrlw mm3, 8

						psrlw mm4, 8

						punpcklbw mm0, [SkinBitmap_mmx_zero]
						punpcklbw mm1, [SkinBitmap_mmx_zero]

						psubw mm2, mm3
						pmullw mm0, mm2

						pmullw mm1, mm5
						add esi, 8

						movq mm2, [SkinBitmap_mmx_revn2]
						pmullw mm6, mm5

						paddusw mm0, mm1
						psubw mm2, mm4

						pmullw mm7, mm2
						psrlw mm0, 8

						packuswb mm0, mm0
						paddusw mm7, mm6

						movd [edi], mm0
						psrlw mm7, 8

						packuswb mm7, mm7

						movd [edi+4], mm7

						add edi, 8

						dec ecx
						jnz _blitAlpha_Loop3
						mov src, esi
						mov dest, edi
#else
					if (xp > 1)
					{
						__asm__ volatile(
						  "movd %5, %%mm5\n"
						  "mov %4, %%ecx\n"
						  "packuswb %%mm5, %%mm5 \n"
						  "shr $1, %%ecx\n"
						  "paddusw (SkinBitmap_mmx_one), %%mm5\n"
						  "punpcklwd %%mm5, %%mm5\n"
						  "mov %0, %%edi\n"
						  "punpckldq %%mm5, %%mm5\n"
						  "mov %1, %%esi\n"
						  ".align 16\n"
						  "_blitAlpha_Loop3:\n"
						  "movd (%%esi), %%mm3\n"
						  "movd 4(%%esi), %%mm4\n"
						  "movd (%%edi), %%mm0\n"
						  "psrld $24, %%mm3\n"
						  "movd (%%esi), %%mm1\n"
						  "psrld $24, %%mm4\n"
						  "paddusw (SkinBitmap_mmx_one), %%mm3\n"
						  "paddusw (SkinBitmap_mmx_one), %%mm4\n"
						  "movd 4(%%edi), %%mm7\n"
						  "punpcklwd %%mm3, %%mm3\n"
						  "movd 4(%%esi), %%mm6\n"
						  "punpcklwd %%mm4, %%mm4\n"
						  "punpckldq %%mm3, %%mm3\n"
						  "punpckldq %%mm4, %%mm4\n"
						  "pmullw %%mm5, %%mm3\n"
						  "pmullw %%mm5, %%mm4\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
						  "movq (SkinBitmap_mmx_revn2), %%mm2\n"
						  "psrlw $8, %%mm3\n"
						  "psrlw $8, %%mm4\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
						  "punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
						  "psubw %%mm3, %%mm2\n"
						  "pmullw %%mm2, %%mm0\n"
						  "pmullw %%mm5, %%mm1\n"
						  "add $8, %%esi\n"
						  "movq (SkinBitmap_mmx_revn2), %%mm2\n"
						  "pmullw %%mm5, %%mm6\n"
						  "paddusw %%mm1, %%mm0\n"
						  "psubw %%mm4, %%mm2\n"
						  "pmullw %%mm2, %%mm7\n"
						  "psrlw $8, %%mm0\n"
						  "packuswb %%mm0, %%mm0\n"
						  "paddusw %%mm6, %%mm7\n"
						  "movd %%mm0, (%%edi)\n"
						  "psrlw $8, %%mm7\n"
						  "packuswb %%mm7, %%mm7\n"
						  "movd %%mm7, 4(%%edi)\n"
						  "add $8, %%edi\n"
						  "dec %%ecx\n"
						  "jnz _blitAlpha_Loop3\n"
						  "mov %%esi, %1\n"
						  "mov %%edi, %0\n"

  : "=m"(dest), "=m"(src)
								  : "0"(dest), "1"(src), "m"(xp), "m"(alpha)
								  : "%eax", "%ecx", "%esi", "%edi");
#endif
					}
					if (xp&1) *dest++ = Blenders::BLEND_ADJ3_MMX(*dest, *src++, alpha);
				} // HAS_MMX
#endif // ifndef NO_MMX
			}
		}
#ifndef NO_MMX
	Blenders::BLEND_MMX_END();
#endif
	// write bits back to dib.

	if (usingBlitCanvas)
	{
		blitToRectCanvas->blit(0, 0, &clone, destrect.left, destrect.top, cwidth, cheight);
	}
}

#ifdef WIN32
#pragma warning(pop)
#endif

void SkinBitmap::stretch(ifc_canvas *canvas, int x, int y, int w, int h)
{
	RECT src, dst;
	src.left=0;
	src.top=0;
	src.right=getWidth();
	src.bottom=getHeight();
	dst.left=x;
	dst.right=x+w;
	dst.top=y;
	dst.bottom=y+h;
	stretchToRectAlpha(canvas,&src,&dst,255);
}

void SkinBitmap::stretchToRect(ifc_canvas *canvas, RECT *r)
{
	stretch(canvas, r->left, r->top, r->right - r->left, r->bottom - r->top);
}

void SkinBitmap::stretchRectToRect(ifc_canvas *canvas, RECT *src, RECT *dst)
{
	stretchToRectAlpha(canvas,src,dst,255);
}


void SkinBitmap::stretchToRectAlpha(ifc_canvas *canvas, RECT *r, int alpha)
{
	RECT re;
	re.left=0; re.top=0;
	re.right=getWidth(); re.bottom=getHeight();
	stretchToRectAlpha(canvas,&re,r,alpha);
}

void SkinBitmap::blitAlpha(ifc_canvas *canvas, int x, int y, int alpha)
{
	RECT dst,src;
	dst.left=x;
	dst.top=y;
	src.left=0;
	src.top=0;
	src.bottom=getHeight();
	src.right=getWidth();
	blitToRect(canvas,&src,&dst,alpha);
}

#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4799)
#endif

template <class C>
class Stretcher
{
public:
	static void _stretchToRectAlpha(SkinBitmap *bitmap, int ys, int ye, int xe, int xs, int xstart, int yv, void *dib, int pitch, int dxv, int dyv, int alpha)
	{
		int bitmap_x = bitmap->getX();
		int bitmap_y = bitmap->getY();
		int bmpheight = bitmap->getHeight();
		int fullimage_w = bitmap->getFullWidth();
		void *bits = bitmap->getBits();
		int xp=xe-xs;
		for (int yp = ys; yp < ye; yp ++)
		{
			int t=yv>>16;
			if (t < 0) t=0;
			if (t >= bmpheight) t=bmpheight-1;
			int *psrc=((int*)bits) + (t+bitmap_y)*fullimage_w + bitmap_x;
			int *dest=((int*)dib) + pitch*yp + xs;

			C::stretch(xp, psrc, dest, xstart, dxv, alpha);

			yv+=dyv;
		}
	}
};

// no alpha, just stretch
class Stretch
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
		while (xp--)   //JFtodo: assembly optimize - these first two modes aren't used that much anyway
		{
			*dest++ = psrc[xv>>16];
			xv+=dxv;
		}
	}
};

// no alpha channel, just a global alpha val
class StretchGlobal
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
		while (xp--)   //JFTODO: make MMX optimized version
		{
			*dest++ = Blenders::BLEND_ADJ1(psrc[xv>>16], *dest, alpha);
			xv+=dxv;
		}
	}
};

// alpha channel, no global alpha val
class StretchChannel
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
		while (xp--)
		{
			*dest++ = Blenders::BLEND_ADJ2(*dest, psrc[xv>>16]);
			xv+=dxv;
		}
	}
};

class StretchGlobalChannel
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
		while (xp--)
		{
			*dest++ = Blenders::BLEND_ADJ3(*dest, psrc[xv>>16], alpha);
			xv+=dxv;
		}
	}
};


#ifndef NO_MMX

// no alpha channel, just a global alpha val
class StretchGlobalMMX
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
		while (xp--)   //JFTODO: make MMX optimized version
		{
			*dest++ = Blenders::BLEND_ADJ1_MMX(psrc[xv>>16], *dest, alpha);
			xv+=dxv;
		}
	}
};


// alpha channel, no global alpha val
class StretchChannelMMX
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
#ifdef WIN32
		if (xp>1) __asm
		{
			mov ecx, xp
			mov edi, dest

			shr ecx, 1
			mov esi, psrc

			mov edx, xv
			mov ebx, dxv

			align 16
_stretchAlpha_Loop2:

			mov eax, edx
			movd mm0, [edi]

			movq mm4, [SkinBitmap_mmx_revn2]
			shr eax, 16

			movq mm2, [SkinBitmap_mmx_revn2]
			punpcklbw mm0, [SkinBitmap_mmx_zero]

			movd mm3, [esi+eax*4]
			movd mm1, [esi+eax*4]

			lea eax, [edx+ebx]
			shr eax, 16

			movd mm7, [edi+4]
			psrld mm3, 24

			packuswb mm3, mm3 // 0000HHVV
			movd mm5, [esi+eax*4]

			movd mm6, [esi+eax*4]
			psrld mm5, 24

			paddusw mm3, [SkinBitmap_mmx_one]
			punpcklbw mm6, [SkinBitmap_mmx_zero]

			packuswb mm5, mm5 // 0000HHVV
			lea edx, [edx+ebx*2]

			paddusw mm5, [SkinBitmap_mmx_one]
			punpcklwd mm3, mm3 // HHVVHHVV

			punpcklwd mm5, mm5 // HHVVHHVV
			add edi, 8

			punpckldq mm3, mm3 // HHVVHHVV HHVVHHVV

			punpckldq mm5, mm5 // HHVVHHVV HHVVHHVV

			psubw mm4, mm5

			psubw mm2, mm3

			punpcklbw mm7, [SkinBitmap_mmx_zero]
			pmullw mm0, mm2

			pmullw mm7, mm4
			punpcklbw mm1, [SkinBitmap_mmx_zero]

			psubw mm2, mm3

			psrlw mm0, 8
			psrlw mm7, 8
			paddw mm0, mm1

			paddw mm7, mm6
			packuswb mm0, mm0

			movd [edi-8], mm0
			packuswb mm7, mm7

			movd [edi-4], mm7

			dec ecx
			jnz _stretchAlpha_Loop2
			mov dest, edi
			mov xv, edx
		}
#else
		if (xp>1)
		{
			__asm__ volatile(
			  "mov %5, %%ecx\n"
			  "mov %0, %%edi\n"
			  "shr $1, %%ecx\n"
			  "mov %1, %%esi\n"
			  "mov %2, %%edx\n"
			  "mov %7, %%ebx\n"
			  ".align 16\n"
			  "_stretchAlpha_Loop2:\n"
			  "mov %%edx, %%eax\n"
			  "movd (%%edi), %%mm0\n"
			  "movq (SkinBitmap_mmx_revn2), %%mm4\n"
			  "shr $16, %%eax\n"
			  "movq (SkinBitmap_mmx_revn2), %%mm2\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
			  "movd (%%esi,%%eax,4), %%mm3\n"
			  "movd (%%esi,%%eax,4), %%mm1\n"
			  "lea (%%edx,%%ebx), %%eax\n"
			  "shr $16, %%eax\n"
			  "movd 4(%%edi), %%mm7\n"
			  "psrld $24, %%mm3\n"
			  "packuswb %%mm3, %%mm3\n"
			  "movd (%%esi,%%eax,4), %%mm5\n"
			  "movd (%%esi,%%eax,4), %%mm6\n"
			  "psrld $24, %%mm5\n"
			  "paddusw (SkinBitmap_mmx_one), %%mm3\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
			  "packuswb %%mm5, %%mm5\n"
			  "lea (%%edx,%%ebx,2), %%edx\n"
			  "paddusw (SkinBitmap_mmx_one), %%mm5\n"
			  "punpcklwd %%mm3, %%mm3\n"
			  "punpcklwd %%mm5, %%mm5\n"
			  "add $8, %%edi\n"
			  "punpckldq %%mm3, %%mm3\n"
			  "punpckldq %%mm5, %%mm5\n"
			  "psubw %%mm5, %%mm4\n"
			  "psubw %%mm3, %%mm2\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
			  "pmullw %%mm2, %%mm0\n"
			  "pmullw %%mm4, %%mm7\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
			  "psubw %%mm3, %%mm2\n"
			  "psrlw $8, %%mm0\n"
			  "psrlw $8, %%mm7\n"
			  "paddw %%mm1, %%mm0\n"
			  "paddw %%mm6, %%mm7\n"
			  "packuswb %%mm0, %%mm0\n"
			  "movd %%mm0, -8(%%edi)\n"
			  "packuswb %%mm7, %%mm7\n"
			  "movd %%mm7, -4(%%edi)\n"
			  "dec %%ecx\n"
			  "jnz _stretchAlpha_Loop2\n"
			  "mov %%edi, %0\n"
			  "mov %%edx, %2\n"

  : "=m"(dest), "=m"(psrc), "=m"(xv)
					  : "0"(dest), "1"(psrc), "m"(xp),
					  "2"(xv), "m"(dxv), "m"(alpha)
					  : "%eax", "%ebx", "%ecx", "%edx",
					  "%esi", "%edi");

		}
#endif

		if (xp&1) *dest++ = Blenders::BLEND_ADJ2_MMX(*dest, psrc[xv>>16]);
	}
};


class StretchGlobalChannelMMX
{
public:
	static void stretch(int xp, int *psrc, int *dest, int xv, int dxv, int alpha)
	{
#ifdef WIN32
		if (xp>1) __asm
		{
			movd mm5, [alpha]
			mov ecx, xp

			packuswb mm5, mm5
			shr ecx, 1

			paddusw mm5, [SkinBitmap_mmx_one]

			punpcklwd mm5, mm5
			mov edi, dest

			punpckldq mm5, mm5
			mov esi, psrc

			mov edx, xv
			mov ebx, dxv

			align 16
_stretchAlpha_Loop3:
			movd mm0, [edi]
			mov eax, edx

			movd mm7, [edi+4]
			shr eax, 16

			movd mm1, [esi+eax*4]
			movd mm3, [esi+eax*4] // VVVVVVVV

			lea eax, [edx+ebx]
			psrld mm3, 24

			paddusw mm3, [SkinBitmap_mmx_one]

			punpcklwd mm3, mm3
			shr eax, 16

			punpckldq mm3, mm3

			pmullw mm3, mm5

			movd mm4, [esi+eax*4] // VVVVVVVV
			movd mm6, [esi+eax*4]

			movq mm2, [SkinBitmap_mmx_revn2]
			psrld mm4, 24

			paddusw mm4, [SkinBitmap_mmx_one]
			punpcklbw mm7, [SkinBitmap_mmx_zero]

			punpcklwd mm4, mm4
			lea edx, [edx+ebx*2]

			punpckldq mm4, mm4
			add edi, 8

			punpcklbw mm6, [SkinBitmap_mmx_zero]
			pmullw mm4, mm5

			psrlw mm3, 8

			punpcklbw mm0, [SkinBitmap_mmx_zero]

			punpcklbw mm1, [SkinBitmap_mmx_zero]
			psubw mm2, mm3

			pmullw mm0, mm2
			pmullw mm1, mm5

			pmullw mm6, mm5
			psrlw mm4, 8

			movq mm2, [SkinBitmap_mmx_revn2]
			paddusw mm0, mm1
			psubw mm2, mm4

			pmullw mm7, mm2
			psrlw mm0, 8

			packuswb mm0, mm0
			paddusw mm7, mm6

			movd [edi-8], mm0
			psrlw mm7, 8

			packuswb mm7, mm7

			movd [edi-4], mm7

			dec ecx
			jnz _stretchAlpha_Loop3
			mov xv, edx
			mov dest, edi
		}
#else
		if (xp>1)
		{
			__asm__ volatile(
			  "movd %8, %%mm5\n"
			  "mov %5, %%ecx\n"
			  "packuswb %%mm5, %%mm5 \n"
			  "shr $1, %%ecx\n"
			  "paddusw (SkinBitmap_mmx_one), %%mm5\n"
			  "punpcklwd %%mm5, %%mm5\n"
			  "mov %0, %%edi\n"
			  "punpckldq %%mm5, %%mm5\n"
			  "mov %1, %%esi\n"
			  "mov %6, %%edx\n"
			  "mov %7, %%ebx\n"
			  ".align 16\n"
			  "_stretchAlpha_Loop3:\n"
			  "movd (%%edi), %%mm0\n"
			  "mov %%edx, %%eax\n"
			  "movd 4(%%edi), %%mm7\n"
			  "shr $16, %%eax\n"
			  "movd (%%esi,%%eax,4), %%mm1\n"
			  "movd (%%esi,%%eax,4), %%mm3\n"
			  "lea (%%edx,%%ebx), %%eax\n"
			  "psrld $24, %%mm3\n"
			  "paddusw (SkinBitmap_mmx_one), %%mm3\n"
			  "punpcklwd %%mm3, %%mm3\n"
			  "shr $16, %%eax\n"
			  "punpckldq %%mm3, %%mm3\n"
			  "pmullw %%mm5, %%mm3\n"
			  "movd (%%esi,%%eax,4), %%mm4\n"
			  "movd (%%esi,%%eax,4), %%mm6\n"
			  "movq (SkinBitmap_mmx_revn2), %%mm2\n"
			  "psrld $24, %%mm4\n"
			  "paddusw (SkinBitmap_mmx_one), %%mm4\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm7\n"
			  "punpcklwd %%mm4, %%mm4\n"
			  "lea (%%edx,%%ebx,2), %%edx\n"
			  "punpckldq %%mm4, %%mm4\n"
			  "add $8, %%edi\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm6\n"
			  "pmullw %%mm5, %%mm4\n"
			  "psrlw $8, %%mm3\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm0\n"
			  "punpcklbw (SkinBitmap_mmx_zero), %%mm1\n"
			  "psubw %%mm3, %%mm2\n"
			  "pmullw %%mm2, %%mm0\n"
			  "pmullw %%mm5, %%mm1\n"
			  "pmullw %%mm5, %%mm6\n"
			  "psrlw $8, %%mm4\n"
			  "movq (SkinBitmap_mmx_revn2), %%mm2\n"
			  "paddusw %%mm1, %%mm0\n"
			  "psubw %%mm4, %%mm2\n"
			  "pmullw %%mm2, %%mm7\n"
			  "psrlw $8, %%mm0\n"
			  "packuswb %%mm0, %%mm0\n"
			  "paddusw %%mm6, %%mm7\n"
			  "movd %%mm0, -8(%%edi)\n"
			  "psrlw $8, %%mm7\n"
			  "packuswb %%mm7, %%mm7\n"
			  "movd %%mm7, -4(%%edi)\n"
			  "dec %%ecx\n"
			  "jnz _stretchAlpha_Loop3\n"
			  "mov %%edi, %0\n"
			  "mov %%edx, %2\n"

  : "=m"(dest), "=m"(psrc), "=m"(xv)
					  : "0"(dest), "1"(psrc), "m"(xp),
					  "m"(xv), "m"(dxv), "m"(alpha)
					  : "%eax", "%ebx", "%ecx", "%edx",
					  "%esi", "%edi");

		}
#endif

		if (xp&1) *dest++ = Blenders::BLEND_ADJ3_MMX(*dest, psrc[xv>>16], alpha);
	}
};
#endif


class __Stretch : public Stretcher<Stretch> {};
class __StretchGlobal : public Stretcher<StretchGlobal> {};
class __StretchChannel : public Stretcher<StretchChannel> {};
class __StretchGlobalChannel : public Stretcher<StretchGlobalChannel> {};

#ifndef NO_MMX
class __StretchGlobalMMX : public Stretcher<StretchGlobalMMX> {};
class __StretchChannelMMX : public Stretcher<StretchChannelMMX> {};
class __StretchGlobalChannelMMX : public Stretcher<StretchGlobalChannelMMX> {};
#endif

#ifdef WIN32
#pragma warning(pop)
#endif


void SkinBitmap::stretchToRectAlpha(ifc_canvas *canvas, RECT *_src, RECT *_dst, int alpha)
{

	if (alpha <= 0) return;
	if (alpha > 255) alpha = 255;

	RECT src=*_src;
	RECT dst=*_dst;

	if ((src.right-src.left) == (dst.right-dst.left) &&
	    (src.bottom-src.top) == (dst.bottom-dst.top))
	{
		blitToRect(canvas,_src,_dst,alpha);
		return;
	}
	//FG> this is a hack, we should support subpixels instead
	if (src.left == src.right)
	{
		if (src.right < getWidth())
			src.right++;
		else
			src.left--;
	}
	if (src.top== src.bottom)
	{
		if (src.bottom < getHeight())
			src.bottom++;
		else
			src.top--;
	}

	if (src.left >= src.right || src.top >= src.bottom) return;
	if (dst.left >= dst.right || dst.top >= dst.bottom) return;

	BltCanvas *blitToRectCanvas=0;
	void *dib=canvas->getBits();
	bool usingBlitCanvas = false;
	BaseCloneCanvas clone(canvas);
	int cwidth, cheight, pitch;

	int dyv=((src.bottom-src.top)<<16)/(dst.bottom-dst.top);
	int dxv=((src.right-src.left)<<16)/(dst.right-dst.left);
	int yv=(src.top<<16);
	int xstart=(src.left<<16);

	RECT c;
	int ctype=canvas->getClipBox(&c);
	if (c.top > dst.top)
	{
		yv+=(c.top-dst.top)*dyv;
		dst.top=c.top;
	}
	if (c.left > dst.left)
	{
		xstart+=(c.left-dst.left)*dxv;
		dst.left=c.left;
	}
	if (c.bottom < dst.bottom)
		dst.bottom=c.bottom;
	if (c.right < dst.right) 
		dst.right=c.right;

	if (dst.right <= dst.left || dst.bottom <= dst.top) return;

	int xs,xe,ys,ye;

#ifdef NO_SIMPLEFASTMODE
	dib=NULL;
#endif
	if (!dib || canvas->getDim(NULL,&cheight,&cwidth) || !cwidth || cheight < 1 || ctype == COMPLEXREGION)
	{
		cwidth=dst.right-dst.left;
		cheight=dst.bottom-dst.top;

		/* create cached canvas for this thread if it doesn't exist */		
		blitToRectCanvas = (BltCanvas *)TlsGetValue(bitmap_cache_tls);
		if (!blitToRectCanvas)
		{
			blitToRectCanvas = new BltCanvas(cwidth, cheight);
			TlsSetValue(bitmap_cache_tls, (LPVOID)blitToRectCanvas);
		}
		int cacheWidth, cacheHeight;
		blitToRectCanvas->getDim(&cacheWidth, &cacheHeight, NULL);

		 /* resize cache, if necessary */
		if (cwidth > cacheWidth || cheight > cacheHeight)
		{
			cacheWidth=MAX(cacheWidth, cwidth);
			cacheHeight=MAX(cacheHeight, cheight);
			blitToRectCanvas->DestructiveResize(cacheWidth, cacheHeight);
		}

		dib = blitToRectCanvas->getBits();
		if (has_alpha || alpha < 255)
			clone.blit(dst.left, dst.top, blitToRectCanvas, 0, 0, cwidth, cheight);

		xs=0;
		ys=0;
		xe=cwidth;
		ye=cheight;
		pitch=cacheWidth;
		usingBlitCanvas=true;
	}
	else
	{
		xs=dst.left;
		xe=dst.right;
		ys=dst.top;
		ye=dst.bottom;
		cwidth/=4;
		pitch=cwidth;
	}

	// stretch and blend bitmap to dib

	if (xstart < 0) xstart=0;

	// Martin> TODO
	// we should separate the stretching from this function and move it to the Shrink() function (avoiding breaks from this fragile class)
	// HQSkinBitmap will then override the Shrink funtion in order to apply it's own resizing stuff.
	// and if we ever want a new algorithm we can just create a new UltraFastAndCoolSkinBitmap class overriding the function again

	if (xs<xe)
	{
		if (!has_alpha)  	// doesn't have alpha channel
		{
			if (!high_quality_resampling || dxv<65536 || dyv<65536)
			{
				if (alpha == 255)  	// no global alpha
				{
					__Stretch::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
				}
				else  	// has global alpha
				{
#ifndef NO_MMX
					if (HAS_MMX)
					{
						__StretchGlobalMMX::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
					}
					else
#endif
					{
						__StretchGlobal::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
					}
				}
			}
			else
			{
				Shrink(this, ys,ye,xe,xs, xstart,yv, (ARGB32 *)dib, pitch,  dxv, dyv, alpha);
			}
		}
		else  	// has alpha channel
		{
			// FUCKO: JF> BRENNAN FIX THESE BITCHES :)
			if (alpha == 255)  	// no global alpha
			{
				if (!high_quality_resampling || dxv<65536 || dyv<65536)
				{
#ifndef NO_MMX
					if (HAS_MMX)
					{
						__StretchChannelMMX::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
					}
					else
#endif
					{
						__StretchChannel::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
					}
				}
				else
				{
					Shrink(this, ys,ye,xe,xs, xstart,yv, (ARGB32 *)dib, pitch,  dxv, dyv, alpha);
				}
			}
			else  	// has global alpha
			{
				if (!high_quality_resampling || dxv<65536 || dyv<65536)
				{
#ifndef NO_MMX
					if (HAS_MMX)
					{
						__StretchGlobalChannelMMX::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
					}
					else
#endif
					{
						__StretchGlobalChannel::_stretchToRectAlpha(this, ys, ye, xe, xs, xstart, yv, dib, pitch, dxv, dyv, alpha);
					}
				}
				else
				{
					Shrink(this, ys, ye, xe, xs, xstart, yv, (ARGB32 *)dib, pitch, dxv, dyv,alpha);
				}
			}
		}
	}

#ifndef NO_MMX
	Blenders::BLEND_MMX_END();
#endif
	// write bits back to dib.

	if (usingBlitCanvas)
	{
		blitToRectCanvas->blit(0, 0, &clone, dst.left, dst.top, cwidth, cheight);
	}
}

COLORREF SkinBitmap::getPixel(int x, int y)
{
	ASSERT(bits != NULL);
	if (x < 0 || y < 0 || x >= getFullWidth()-getX() || y>= getFullHeight()-getY()) return (COLORREF)0;
	return (COLORREF)(((int*)bits)[x+getX()+(y+getY())*getFullWidth()]);
}

void *SkinBitmap::getBits()
{
	return bits;
}

int SkinBitmap::isInvalid()
{
	return last_failed;
}

void SkinBitmap::setHasAlpha(int ha)
{
	has_alpha=ha;
}

const wchar_t *SkinBitmap::getBitmapName()
{
	return bitmapname;
}

void SkinBitmap::AddRef()
{
	references++;
}

void SkinBitmap::Release()
{
	if (--references == 0)
		delete this;
}