// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <bitstd.h>

#include <graphics/lookuptable.h>

#include <bitdrawinterfaceid.h>

#include "../inc/BMDRAW.H"

#include <graphics/gdi/gdiinline.inl>

// Current plan is to depreciate 16MA targets so we have removed acceleration of these.

// To re-enable put the __SUPPORT_16MA_TARGET__ back in

//#define __SUPPORT_16MA_TARGET__

// Enabling __CHECK_ALPHA01__ causes checks for alpha values of 0 and 1 to be made to attempt to

// accelerate handling of these cases. This may not always work as branching the execution path

// can potentially lose more time than is gained.

#define __CHECK_ALPHA01__

#define WRITE_RUN \

	FORCEINLINE static void write(const TUint8* &aSrc, TUint8* &aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 7:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 6:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 5:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 4:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 3:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 2:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 1:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN2ROT \

	FORCEINLINE static void write2rot(const TUint8* aSrc, TUint8* aDst, TInt aLen, TInt aSrcStep, TInt aDstStep) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 7:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 6:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 5:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 4:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 3:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 2:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

			case 1:              write(aSrc, aDst);aSrc+=aSrcStep;aDst+=aDstStep; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN2H \

	static void write2(const TUint8* aSrc, TUint8* aDst, TInt aLen);

#define WRITE_RUN2C(class3232) \

	void class3232::write2(const TUint8* aSrc, TUint8* aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 7:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 6:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 5:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 4:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 3:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 2:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

			case 1:              write(aSrc, aDst);aSrc+=4;aDst+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN2416 \

	FORCEINLINE static void write(const TUint8* &aSrc, TUint8* &aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 7:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 6:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 5:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 4:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 3:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 2:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 1:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN3216 \

	FORCEINLINE static void write(const TUint8* &aSrc, TUint8* &aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 7:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 6:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 5:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 4:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 3:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 2:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 1:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN3216C2(class3216) \

	void class3216::write2(const TUint8* aSrc, TUint8* aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 7:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 6:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 5:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 4:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 3:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 2:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

			case 1:              write(aSrc, aDst);aSrc+=4;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN2416C2(class2416) \

	void class2416::write2(const TUint8* aSrc, TUint8* aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 7:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 6:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 5:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 4:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 3:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 2:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

			case 1:              write(aSrc, aDst);aSrc+=3;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_RUN1632 \

	FORCEINLINE static void write(const TUint8* &aSrc, TUint8* &aDst, TInt aLen) \

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 7:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 6:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 5:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 4:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 3:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 2:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

			case 1:              write(aSrc, aDst);aSrc+=2;aDst+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		}

// Using non-inline versions can make better usage of registers, need to experiment to find fastest mix

#define WRITE_RUN1632C(class1632) \

	void class1632::write2(const TUint8* aSrc, TUint8* aDst, TInt aLen)\

		{ \

		const TUint16* lowAdd = Convert16to32bppLow();\

		const TUint32* highAdd = Convert16to32bppHigh();\

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 7:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 6:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 5:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 4:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 3:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 2:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

			case 1:              Write64KTo16MLookup(aSrc, aDst, lowAdd, highAdd);aSrc+=2;aDst+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN \

	FORCEINLINE static void writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 7:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 6:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 5:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 4:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 3:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 2:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

			case 1:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN3216 \

	FORCEINLINE static void writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 7:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 6:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 5:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 4:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 3:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 2:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

			case 1:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=4;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN2416 \

	FORCEINLINE static void writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 7:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 6:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 5:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 4:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 3:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 2:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

			case 1:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=3;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN1632 \

	FORCEINLINE static void writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 7:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 6:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 5:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 4:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 3:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 2:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

			case 1:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN1632H \

	static void writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen);

#define WRITE_ALPHA_MASK_RUN1632C(class1632) \

	void class1632::writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen)\

		{ \

		const TUint8* srcPtr=aSrc;\

		TUint8* dstPtr=aDst;\

		const TUint8* alphaPtr=aAlpha;\

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 7:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 6:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 5:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 4:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 3:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 2:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

			case 1:              writeMask(srcPtr, dstPtr, *alphaPtr++);srcPtr+=2;dstPtr+=4; \

				} while ((aLen -= 8) > 0); \

			} \

		aSrc=srcPtr;\

		aDst=dstPtr;\

		aAlpha=alphaPtr;\

		}

#define WRITE_ALPHA_MASK_RUN1616 \

	FORCEINLINE static void writeAlphaMask(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 7:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 6:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 5:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 4:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 3:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 2:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

			case 1:              writeMask(aSrc, aDst, *aAlpha++);aSrc+=2;aDst+=2; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN_ROT32 \

	FORCEINLINE static void writeAlphaMaskRot(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen, TInt aSrcStride, TInt aMaskStride)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 7:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 6:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 5:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 4:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 3:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 2:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

			case 1:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=4;aAlpha+=aMaskStride; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define WRITE_ALPHA_MASK_RUN_ROT16 \

	FORCEINLINE static void writeAlphaMaskRot(const TUint8* &aSrc, TUint8* &aDst, const TUint8* aAlpha, TInt aLen, TInt aSrcStride, TInt aMaskStride)\

		{ \

		switch (aLen % 8)  /* aLen > 0 assumed */ \

			{ \

			case 0:        do {  writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 7:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 6:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 5:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 4:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 3:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 2:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

			case 1:              writeMask(aSrc, aDst, *aAlpha);aSrc+=aSrcStride;aDst+=2;aAlpha+=aMaskStride; \

				} while ((aLen -= 8) > 0); \

			} \

		}

#define MultAlphaWithSrcAlpha(aAlpha, aSrc)\

	{\

	const TUint32 src=*(TUint32*)aSrc;\

	TUint32 srcAlpha=src>>24;\

	aAlpha=(aAlpha*srcAlpha);\

	aAlpha+=srcAlpha;\

	aAlpha>>=8;\

	}

// Takes a pre-multipled alpha source and additionally multiplies it by the alpha

// value so the source is effectively now pre-multiplied by both it's own alpha

// and the specified alpha.

// No aAlpha==0xFF or ==0 checks as should never come here in those situations

#define MultMapSrcByAlpha(aAlpha, aSrc)\

	{\

	TUint32 d1 = (aSrc>>8)&0x00FF00FF;\

	d1=d1*aAlpha+d1;\

	TUint32 d2=aSrc&0x00FF00FF;\

	d2=d2*aAlpha+d2;\

	aSrc=(d1&0xFF00FF00)|((d2&0xFF00FF00)>>8);\

	}

#define Write16MTo64K(aSrc, aDst)\

	{\

	TInt color64K=(aSrc & 0x0000f8) >> 3;\

	color64K|=(aSrc & 0x00fc00) >> 5;\

	color64K|=(aSrc & 0xf80000) >> 8;\

	*(TUint16*)aDst = color64K;\

	}

// Calc new alpha as src+(1-src)*dst;

#define CalcDestMultAlpha(aDestMultAlpha, aDA, aSrcAlpha, aDstAlpha)\

	{\

	const TUint32 srcAlpha=aSrcAlpha;\

	const TUint32 dstAlpha=aDstAlpha;\

	aDA=dstAlpha<<16;\

	aDA=aDA*(0x100-srcAlpha);\

	aDA+=srcAlpha<<24;\

	aDestMultAlpha=(((0x100-srcAlpha)*dstAlpha)>>8)+1;\

	}

// Note: This function assumes incoming rgb's are shifted up by an extra 8 bits as that's the

// most efficient way of processing the preceding functions with this final write to 64K handling

// the extra shift down.

#define WriteRedBlueAndGreenTo64K(aRedBlue, aGreen, aDst)\

	{\

	TInt targ64K=(aRedBlue&0x00f800) >> 11;\

	targ64K|=(aRedBlue&0xf8000000) >> 16;\

	targ64K|=(aGreen&0xfc0000) >> 13;\

	*(TUint16*)aDst = targ64K;\

	}

// Used for calculating blending from a MAP source to any of 16M dest formats.

#define CalcMapToMxRGBA(aSrcPixel, aDst, aDestMult, aDestAG, aDestRB)\

	{\

	const TUint32 dstPixel=*(TUint32*)aDst;\

	aDestAG=(dstPixel&0xFF00FF00)>>8;\

	aDestAG=aDestAG*aDestMult;\

	aDestAG+=aSrcPixel&0xFF00FF00;\

	aDestRB=dstPixel&0x00FF00FF;\

	aDestRB=(aDestRB*aDestMult)>>8;\

	aDestRB+=aSrcPixel&0x00FF00FF;\

	}

// Used For non MAP source blending using dest=src*alpha+dest*destAlpha

// aDestMultAlpha is typically (1-aAlpha) or (srcAlpha+(1-srcAlpha)*destAlpha)

#define CalcMxToMxRGBA2A(aMxMxSrcPixel, aMxMxDestPixel, aMxMxAlpha, aMxMxDestMultAlpha, aMxMxDestAG, aMxMxDestRB)\

	{\

	aMxMxDestAG=(aMxMxDestPixel & 0xFF00FF00)>>8;\

	aMxMxDestAG=aMxMxDestAG*aMxMxDestMultAlpha;\

	TUint32 srcAG=(aMxMxSrcPixel&0xFF00FF00)>>8;\

	aMxMxDestAG&=0xFF00FF00;\

	TUint32 alphaPlus1=aMxMxAlpha+1;\

	aMxMxDestAG+=srcAG*alphaPlus1;\

	aMxMxDestRB=aMxMxDestPixel&0x00FF00FF;\

	aMxMxDestRB=aMxMxDestRB*aMxMxDestMultAlpha;\

	aMxMxDestRB&=0xFF00FF00;\

	TUint32 srcRB=(aMxMxSrcPixel&0x00FF00FF);\

	aMxMxDestRB+=srcRB*alphaPlus1;\

	aMxMxDestRB>>=8;\

	}

// Used For non MAP source blending using dest=src*alpha+dest*(1-alpha)

#define CalcMxToMxRGBA(aSrc, aDest, aAlpha, aDestAG, aDestRB)\

	{\

	const TUint32 srcPixel=*(TUint32*)aSrc;\

	const TUint32 dstPixel=*(TUint32*)aDst;\

	const TUint32 oneMinusAlpha = 0x100 - aAlpha;\

	CalcMxToMxRGBA2A(srcPixel, dstPixel, aAlpha, oneMinusAlpha , aDestAG, aDestRB);\

	}

#define WriteMu(aDestAG, aDestRB, aDst)\

	*(TUint32*)aDst=(aDestAG&0xFF00FF00)|(aDestRB&0x00FF00FF)|0xFF000000

#define WriteMxA(aDestG, aDestRB, aDestA, aDst)\

	*(TUint32*)aDst=(aDestG&0x0000FF00)|(aDestRB&0x00FF00FF)|(aDestA&0xFF000000)

#define WriteMx(aDestAG, aDestRB, aDst)\

	*(TUint32*)aDst=(aDestAG&0xFF00FF00)|(aDestRB&0x00FF00FF)

struct TMapToMu

	{

	#define writeMapMu(aSrc, aDst)\

		{\

		const TUint32 oneMinusAlpha = 0x100-(aSrc>>24);\

		TUint32 d1;\

		TUint32 d2;\

		CalcMapToMxRGBA(aSrc,aDst,oneMinusAlpha,d1,d2);\

		WriteMu(d1,d2,aDst);\

		}

	FORCEINLINE static void write(const TUint8 *aSrc, TUint8* aDst)

		{

		const TUint32 src=*(TUint32*)aSrc;

#if defined(__CHECK_ALPHA01__)

		if (src >= 0xFF000000)

			{

			*(TUint32*)aDst = src;

			return;

			}

		if (src <= 0x00FFFFFF)

			return;

#endif

		writeMapMu(src, aDst);

		}

	WRITE_ALPHA_MASK_RUN_ROT32

	WRITE_RUN2ROT

	WRITE_RUN

	WRITE_RUN2H

	FORCEINLINE static void writeMask(const TUint8 *aSrc, TUint8* aDst, TUint aAlpha)

		{

		TUint32 src=*(TUint32*)aSrc;

#if defined(__CHECK_ALPHA01__)

		if (src>0x00FFFFFF)

#endif

			{

			MultMapSrcByAlpha(aAlpha,src);

			// No aAlpha==0xFF check as should never come here in that situation

			writeMapMu(src, aDst);

			}

		}

	WRITE_ALPHA_MASK_RUN

	FORCEINLINE static TInt SrcPixelBytes() {return(sizeof(TUint32));};

	FORCEINLINE static TInt DestPixelBytes() {return(sizeof(TUint32));};

	};

struct TMapToMa

	{

	#define writeMapMa(aSrc, aDst)\

		{\

		const TUint32 d=*(TUint32*)aDst;\

		TUint32 da;\

		TUint32 destMultAlpha;\

		CalcDestMultAlpha(destMultAlpha,da,aSrc>>24,d>>24);\

		TUint32 d1;\

		TUint32 d2;\

		CalcMapToMxRGBA(aSrc,aDst,destMultAlpha,d1,d2);\

		WriteMxA(d1,d2,da,aDst);\

		}

	FORCEINLINE static void write(const TUint8 *aSrc, TUint8* aDst)

		{

		const TUint32 src=*(TUint32*)aSrc;

#if defined(__CHECK_ALPHA01__)

		if (src>0x00FFFFFF)

			{

			if (src >= 0xFF000000)

				*(TUint32*)aDst=src;

			else

				writeMapMa(src,aDst);

			}

#else

		writeMapMa(src,aDst);

#endif

		}

	WRITE_RUN

	WRITE_ALPHA_MASK_RUN_ROT32

	WRITE_RUN2ROT

	WRITE_RUN2H

	FORCEINLINE static void writeMask(const TUint8 *aSrc, TUint8* aDst, TUint aAlpha)

		{

		TUint32 src=*(TUint32*)aSrc;

#if defined(__CHECK_ALPHA01__)

		if (src>0x00FFFFFF)

#endif

			{

			MultMapSrcByAlpha(aAlpha,src);

			// No aAlpha==0xFF check as should never come here in that situation

			writeMapMa(src,aDst);

			}

		}

	WRITE_ALPHA_MASK_RUN

	FORCEINLINE static TInt SrcPixelBytes() {return(sizeof(TUint32));};