// Copyright (c) 2003-2010 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 "BMDRAW.H"

#include "BitDrawInterfaceId.h"

#include <graphics/lookuptable.h>

#include <graphics/blendingalgorithms.h>

TInt CDrawUTwentyFourBppBitmap::Construct(TSize aSize)

	{

	return Construct(aSize, aSize.iWidth << 2);

	}

TInt CDrawUTwentyFourBppBitmap::Construct(TSize aSize, TInt aStride)

	{

	iDispMode = EColor16MU;

	return CDrawThirtyTwoBppBitmapCommon::Construct(aSize, aStride);

	}

/**

MAlphaBlend::WriteRgbAlphaLine() implementation.

@see MAlphaBlend::WriteRgbAlphaLine()

*/

void CDrawUTwentyFourBppBitmap::WriteRgbAlphaLine(TInt aX, TInt aY, TInt aLength,

													const TUint8* aRgbBuffer,

													const TUint8* aMaskBuffer,

													MAlphaBlend::TShadowing aShadowing,

													CGraphicsContext::TDrawMode /*aDrawMode*/)

	{

	// precondition for this function is that the aRgbBuffer lies on a word boundary

    // Assert checks that the pointer is at a word boundary

    __ASSERT_DEBUG(!(((TUint)aRgbBuffer) & 0x3), Panic(EScreenDriverPanicInvalidPointer));

	DeOrientate(aX,aY);

	TUint32* pixelPtr = PixelAddress(aX,aY);

	TUint32* rgbBuffer = (TUint32*)aRgbBuffer;

	const TInt pixelPtrInc = PixelAddressIncrement();

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	if (!(iShadowMode & (EFade | EShadow)) && (iUserDispMode == ENone))

		{

		while (aMaskBuffer < maskBufferPtrLimit)

			{

			*pixelPtr = CalcAlphaPixel(*rgbBuffer, *aMaskBuffer, *pixelPtr);

			aMaskBuffer++;

			pixelPtr += pixelPtrInc;

			rgbBuffer++;

			}

		}

	else

		{

		while (aMaskBuffer < maskBufferPtrLimit)

			{

			TInt mask = *aMaskBuffer++;

			if (mask)

				{     

				TInt b = aRgbBuffer[0];

				TInt g = aRgbBuffer[1];

				TInt r = aRgbBuffer[2];

				if(aShadowing == MAlphaBlend::EShdwBefore)

					{

					if (iShadowMode & EFade)

						{

						r = ((r * iFadeMapFactor) >> 8) + iFadeMapOffset;

						g = ((g * iFadeMapFactor) >> 8) + iFadeMapOffset;

						b = ((b * iFadeMapFactor) >> 8) + iFadeMapOffset;

						}

					if (iShadowMode & EShadow)

						{

						r = (Max(0,r-0x40));

						g = (Max(0,g-0x40));

						b = (Max(0,b-0x40));

						}

					}

				if (mask != 0xff)

					{

					// (mask * r + (255 - mask) * value) / 255 =

					// ((257 * mask * (r - value)) >> 16) + value

					TInt value = *pixelPtr & 0xffffff;

					mask = (mask << 8) + mask; // mask = mask * 257

					TInt v = value >> 16;

					r = ((mask * (r - v)) >> 16) + v;

					v = (value >> 8) & 0xff;

					g = ((mask * (g - v)) >> 16) + v;

					v = value & 0xff;

					b = ((mask * (b - v)) >> 16) + v;

					}

				if(aShadowing == MAlphaBlend::EShdwAfter)

					{

					if (iShadowMode & EFade)

						{  

						r = ((r * iFadeMapFactor) >> 8) + iFadeMapOffset;

						g = ((g * iFadeMapFactor) >> 8) + iFadeMapOffset;

						b = ((b * iFadeMapFactor) >> 8) + iFadeMapOffset;            

						}

					if (iShadowMode & EShadow)

						{

						r = (Max(0,r-0x40));

						g = (Max(0,g-0x40));

						b = (Max(0,b-0x40));                  

						}

					}

				// Convert colour if an incompatible UserDisplayMode is being used

				CDrawBitmap::MapColorToUserDisplayMode(r,g,b);

				*pixelPtr = (r<<16) | (g<<8) | b | 0xff000000;

				}

			aRgbBuffer += 4;

			pixelPtr += pixelPtrInc;

			}

		}

	}

void CDrawUTwentyFourBppBitmap::ReadLine(TInt aX, TInt aY, TInt aLength, TAny* aBuffer, TDisplayMode aDispMode) const

	{

	if (aDispMode == EColor16MAP)

		{

		DeOrientate(aX, aY);

		CDrawThirtyTwoBppBitmapCommon::ReadLine(aX, aY, aLength, aBuffer);

		//Overwrite unused byte with 0xff to produce valid 16MAP data

		TUint8* alphaptr = (TUint8*) aBuffer+3;

		TUint8* bufEnd = (TUint8*) aBuffer + (aLength << 2);

		while (alphaptr < bufEnd)

			{

			*alphaptr = 0xff;

			alphaptr+=4;

			}

		return;

		}

	CDrawBitmap::ReadLine(aX, aY, aLength, aBuffer, aDispMode);

	}

void CDrawUTwentyFourBppBitmap::BlendRgbMulti(TInt aX,TInt aY,TInt aLength,TInt aHeight,TRgb aColor)

	{

	const TInt sourceAlpha = aColor.Alpha();

	if (sourceAlpha==255)// opaque

		{

		WriteRgbMulti(aX,aY,aLength,aHeight,aColor);

		return;

		}

	if (sourceAlpha==0)// transparent

		return;

	TUint32* pixelPtr = PixelAddress(aX,aY);

	TUint32* pixelRowPtrLimit = pixelPtr + (aHeight * iScanLineWords);

	TUint32* pixelPtrLimit = pixelPtr + aLength;

	const TUint32 sourceInternal=aColor.Internal();

	const TUint32 s_rb = sourceInternal & 0x00FF00FF;

	const TUint32 s_g = (sourceInternal & 0xFF00) >> 8;

	const TUint32 mask2 = sourceAlpha | (sourceAlpha << 16);

	while (pixelPtr < pixelRowPtrLimit)

		{

		for (TUint32* tempPixelPtr = pixelPtr; tempPixelPtr < pixelPtrLimit; tempPixelPtr++)

			{

			const TUint32 d = *tempPixelPtr;

			const TUint32 d_rb = d & 0x00FF00FF;

			const TUint32 rb = ((((sourceAlpha * ((0x01000100 + s_rb) - d_rb)) >> 8) + d_rb) - mask2) & 0x00FF00FF;

			const TInt d_g = (d & 0xFF00) >> 8;

			const TInt g = ((sourceAlpha * (s_g - d_g)) >> 8) + d_g;

			*tempPixelPtr = rb | (g<<8) | 0xff000000;

			}

		pixelPtr += iScanLineWords;

		pixelPtrLimit += iScanLineWords;

		}

	}

void CDrawUTwentyFourBppBitmap::BlendLine(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)

	{

	TUint32* pixelPtr = PixelAddress(aX,aY);

	const TUint32* bufferPtrLimit = aBuffer + aLength;

	const TInt pixelPtrInc = (iOrientation == EOrientationNormal) ? 1 : PixelAddressIncrement();

	while (aBuffer < bufferPtrLimit)

		{

		if((*aBuffer &0xFF000000) == 0xFF000000)

			{

			*pixelPtr = *aBuffer;

			}

		else if((*aBuffer & 0xFF000000))

			{	

			// specialization of pre-multiplied blending when the destination alpha is always 255

			const TUint32 src_rb = *aBuffer & 0x00FF00FF;

			const TUint32 src_g = *aBuffer & 0x0000FF00;

			const TUint32 mask = 0x100 - (*aBuffer >> 24);

			TUint32 dst_rb = *pixelPtr & 0x00FF00FF;

			TUint32 dst_g = *pixelPtr & 0x0000FF00;

			dst_rb = (src_rb + ((mask * dst_rb) >> 8)) & 0x00FF00FF;

			dst_g = (src_g + ((mask * dst_g) >> 8)) & 0x0000FF00;

			*pixelPtr = 0xFF000000 | dst_rb | dst_g;

			}

		aBuffer++;

		pixelPtr += pixelPtrInc;

		}

	}

TRgb CDrawUTwentyFourBppBitmap::RgbColor(TUint32 aColor) const

	{

	return TRgb::_Color16MU(aColor);

	}

TUint32 CDrawUTwentyFourBppBitmap::Color(const TRgb& aColor)

	{

	return aColor._Color16MA() | 0xff000000;	

	}

// Copies an EColor64K pixel to an EColor16MU screen

FORCEINLINE static void CopyPixel(const TUint16*& aSrcPtr, TUint32*& aDestPtr, TInt aPixelPtrInc, const TUint32* aHighAdd, const TUint16* aLowAdd)

	{

	*aDestPtr = aHighAdd[(*aSrcPtr) >> 8] | aLowAdd[(*aSrcPtr) & 0xff];

	aDestPtr += aPixelPtrInc;

	aSrcPtr++;

	}

// Copies two EColor64K pixels to an EColor16MU screen

FORCEINLINE static void CopyTwoPixels(const TUint32*& aSrcPtr, TUint32*& aDestPtr, TInt aPixelPtrInc, const TUint32* aHighAdd, const TUint16* aLowAdd)

	{

	const TUint16* scanPtr = reinterpret_cast<const TUint16*&>(aSrcPtr);

	*aDestPtr = aHighAdd[(*scanPtr) >> 8] | aLowAdd[(*scanPtr) & 0xff];

 	aDestPtr += aPixelPtrInc;

	scanPtr++;

	*aDestPtr = aHighAdd[(*scanPtr) >> 8] | aLowAdd[(*scanPtr) & 0xff];

 	aDestPtr += aPixelPtrInc;

 	aSrcPtr++;

	}

// Copies an EColor16MU pixel to an EColor16MU screen if necessary.

FORCEINLINE static void ProcessMaskPixel(const TUint32*& aSrcPtr, const TUint32 aMaskWord, TUint32& aSingleBitMask, TUint32*& aDestPtr, TInt aPixelPtrInc)

	{

	if (aMaskWord & aSingleBitMask)

		{

		*aDestPtr = *aSrcPtr;

		}

	aSrcPtr++;

	aDestPtr += aPixelPtrInc;

	aSingleBitMask <<= 1;

	}

// Copies an EColor64K pixel to an EColor16MU screen if necessary.	

FORCEINLINE static void ProcessMaskPixel(const TUint16*& aSrcPtr, const TUint32 aMaskWord, TUint32& aSingleBitMask, TUint32*& aDestPtr, TInt aPixelPtrInc, const TUint32* aHighAdd, const TUint16* aLowAdd)

	{	

	if (aMaskWord & aSingleBitMask)

		{

		*aDestPtr = aHighAdd[(*aSrcPtr) >> 8] | aLowAdd[(*aSrcPtr) & 0xff];

		}

	aSrcPtr++;

	aDestPtr += aPixelPtrInc;

	aSingleBitMask <<= 1;

	}

// Alpha-blends an EColor16MU pixel to an EColor16MU screen using a fixed mask value.

FORCEINLINE static void BlendAlphaPixel(const TUint32*& aSrcPtr, const TUint8 aMask, TUint32*& aDestPtr, TInt aPixelPtrInc)

	{

	const TUint32 s = *aSrcPtr++;

	const TUint32 d = *aDestPtr;

	// (a)  (mask * src + (255 - mask) * dest) / 255           This ideal formula

	// (b)  ((mask * (src - dest)) >> 8) + dest                A faster approximation to (a)

	// (c)  ((mask * (256 + src - dest) >> 8) + dest - mask    Equivalent to (b) but can be used on multiple colors at a time

	const TUint32 s_rb = s & 0x00FF00FF;

	const TUint32 d_rb = d & 0x00FF00FF;

	const TUint32 mask2 = aMask | (aMask << 16);

	const TUint32 rb = ((((aMask * ((0x01000100 + s_rb) - d_rb)) >> 8) + d_rb) - mask2) & 0x00FF00FF;

	const TInt s_g = (s & 0xFF00) >> 8;

	const TInt d_g = (d & 0xFF00) >> 8;

	const TInt g = ((aMask * (s_g - d_g)) >> 8) + d_g;

	*aDestPtr = rb | (g<<8) | 0xff000000;

	aDestPtr += aPixelPtrInc;

	}

// Alpha-blends an EColor16MU pixel to an EColor16MU screen if necessary.	

FORCEINLINE static void ProcessAlphaPixel(const TUint32*& aSrcPtr, const TUint8*& aMaskPtr, TUint32*& aDestPtr, TInt aPixelPtrInc)

	{

	const TInt mask = *aMaskPtr++;

	if (!mask)

		{

		// pixel is masked

		aSrcPtr++;

		aDestPtr += aPixelPtrInc;

		}

	else if (mask == 0xFF)

		{

		// pixel is unmasked

		*aDestPtr = *aSrcPtr++;

		aDestPtr += aPixelPtrInc;

		}

	else

		{

		BlendAlphaPixel(aSrcPtr, mask, aDestPtr, aPixelPtrInc);

		}

	}

// Alpha-blends an EColor64K pixel to an EColor16MU screen using a fixed mask value.

FORCEINLINE static void BlendAlphaPixel(const TUint16*& aSrcPtr, const TUint8 aMask, TUint32*& aDestPtr, TInt aPixelPtrInc)

	{

	const TUint32 s = *aSrcPtr++;

	const TUint32 d = *aDestPtr;

	// convert the source EColor64K red / blue pixels to EColor16MU

	// the top two bits in EColor64K are used to fill the bottom two bits in EColor16MU

	const TUint32 s_rb = ((s & 0xF800) << 8) | ((s & 0xE000) << 3) | ((s & 0x1F) << 3) | ((s & 0x1C) >>2);	

	const TUint32 d_rb = d & 0x00FF00FF;

	const TUint32 mask2 = aMask | (aMask << 16);

	const TUint32 rb = ((((aMask * ((0x01000100 + s_rb) - d_rb)) >> 8) + d_rb) - mask2) & 0x00FF00FF;

	// convert the source EColor64K green pixel to EColor16MU

	const TInt s_g = ((s & 0x07E0) >> 3) | ((s & 0x0600) >> 9);

	const TInt d_g = (d & 0xFF00) >> 8;

	const TInt g = ((aMask * (s_g - d_g)) >> 8) + d_g;

	*aDestPtr = rb | (g<<8) | 0xff000000;

	aDestPtr += aPixelPtrInc;

	}

// Alpha-blends an EColor64K pixel to an EColor16MU screen if necessary.	

FORCEINLINE static void ProcessAlphaPixel(const TUint16*& aSrcPtr, const TUint8*& aMaskPtr, TUint32*& aDestPtr, TInt aPixelPtrInc, const TUint32* aHighAdd, const TUint16* aLowAdd)

	{

	const TInt mask = *aMaskPtr++;

	if (!mask)

		{

		// pixel is masked

		aSrcPtr++;

		aDestPtr += aPixelPtrInc;

		}

	else if (mask == 0xFF) 

		{

		// pixel is unmasked

		CopyPixel(aSrcPtr, aDestPtr, aPixelPtrInc, aHighAdd, aLowAdd);

		}

	else

		{

		BlendAlphaPixel(aSrcPtr, mask, aDestPtr, aPixelPtrInc);

		}

	}

/**

CDrawUTwentyFourBppBitmap::WriteAlphaLineEx() implementation.

@internalTechnology

@see MFastBlit::WriteAlphaLineEx()

*/

void CDrawUTwentyFourBppBitmap::WriteAlphaLineEx(TInt aX, TInt aY, TInt aLength, TInt aSrcX,

													const TUint32* aSrcPtr,  TDisplayMode aSrcFormat,

													TInt aMaskX, const TUint32* aMaskPtr,

													MAlphaBlend::TShadowing aShadowing)

	{

	// Only certain pixel formats are supported.  Caller should check this.

	__ASSERT_DEBUG(aSrcFormat ==EColor16MU || aSrcFormat ==EColor64K, User::Invariant());

	DeOrientate(aX,aY);

	TUint32* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = PixelAddressIncrement();

	if (aSrcFormat==EColor16MU)

		{		

		if (!(iShadowMode & EFade) && !(iShadowMode & EShadow) && ((iUserDispMode==ENone) || (iUserDispMode==EColor16MU)) )

			{

			aSrcPtr += aSrcX;

			const TUint32* maskWordPtr = aMaskPtr + (aMaskX >> 2);

			const TInt startBit = aMaskX & 0x3;

			if (startBit)

				{

				// Process initial incomplete mask word

				const TUint32 maskWord = *maskWordPtr++;

				TInt numPix = Min(aLength, 4 - startBit);  // number of pixels to process from the first word of the mask

				aLength -= numPix;

				if (!maskWord)

					{

					// maskWord is fully masked - skip the pixels

					aSrcPtr += numPix;

					pixelPtr += pixelPtrInc * numPix;

					}

				else if (maskWord == 0xFFFFFFFF)

					{

					// maskWord is fully unmasked - copy the pixels

					while (numPix--)

						{

						*pixelPtr = *aSrcPtr++;

						pixelPtr += pixelPtrInc;

						}

					}

				else

					{

					// At least one of the pixels needs to be blended

					const TUint8* maskPtr8 = reinterpret_cast<const TUint8*>(&maskWord);

					maskPtr8 += startBit;

					while (numPix--)

						{

						ProcessAlphaPixel(aSrcPtr, maskPtr8, pixelPtr, pixelPtrInc);

						}

					}

				}

			TInt numMaskWords = aLength >> 2;

			aLength &= 0x3;

			while (numMaskWords--)

				{

				// Process a complete mask word - 4 pixels

				const TUint32 maskWord = *maskWordPtr++;

				if (!maskWord)

					{

					// maskWord is fully masked - skip 4 pixels

					aSrcPtr += 4;

					pixelPtr += pixelPtrInc << 2;

					}

				else if (maskWord == 0xFFFFFFFF)

					{

					// maskWord is fully unmasked - copy 4 pixels

					*pixelPtr = *aSrcPtr++; pixelPtr += pixelPtrInc;

					*pixelPtr = *aSrcPtr++; pixelPtr += pixelPtrInc;

					*pixelPtr = *aSrcPtr++; pixelPtr += pixelPtrInc;

					*pixelPtr = *aSrcPtr++; pixelPtr += pixelPtrInc;

					}

				else

					{	

					// At least one of the 4 pixels needs to be blended

					const TUint8* maskPtr8 = reinterpret_cast<const TUint8*>(&maskWord);

					if (maskPtr8[0] && (maskPtr8[0] != 0xFF) &&

						maskPtr8[1] && (maskPtr8[1] != 0xFF) &&

						maskPtr8[2] && (maskPtr8[2] != 0xFF) &&

						maskPtr8[3] && (maskPtr8[3] != 0xFF))

						{

						// Blend all 4 pixels inline

						BlendAlphaPixel(aSrcPtr, maskPtr8[0], pixelPtr, pixelPtrInc);

						BlendAlphaPixel(aSrcPtr, maskPtr8[1], pixelPtr, pixelPtrInc);

						BlendAlphaPixel(aSrcPtr, maskPtr8[2], pixelPtr, pixelPtrInc);

						BlendAlphaPixel(aSrcPtr, maskPtr8[3], pixelPtr, pixelPtrInc);

						}

					else

						{

						ProcessAlphaPixel(aSrcPtr, maskPtr8, pixelPtr, pixelPtrInc);

						ProcessAlphaPixel(aSrcPtr, maskPtr8, pixelPtr, pixelPtrInc);

						ProcessAlphaPixel(aSrcPtr, maskPtr8, pixelPtr, pixelPtrInc);

						ProcessAlphaPixel(aSrcPtr, maskPtr8, pixelPtr, pixelPtrInc);

						}

					}

				}

			if (aLength)

				{

				const TUint32 maskWord = *maskWordPtr;

				if (!maskWord)

					{

					// maskWord is fully masked - skip the pixels

					return;

					}

				if (maskWord == 0xFFFFFFFF)

					{

					// maskWord is fully unmasked - copy the pixels

					while (aLength--)

						{

						*pixelPtr = *aSrcPtr++;

						pixelPtr += pixelPtrInc;

						}

					}

				else

					{

					// At least one of the pixels needs to be blended

					const TUint8* maskPtr8 = reinterpret_cast<const TUint8*>(&maskWord);

					while (aLength--)

						{

						ProcessAlphaPixel(aSrcPtr, maskPtr8, pixelPtr, pixelPtrInc);

						}

					}

				}

			}

		else

			{

			// Non-optimised path including shadowing and UserDisplayMode conversion

			const TUint8* srcPtr8  = reinterpret_cast<const TUint8*>(aSrcPtr + aSrcX);

			const TUint8* maskPtr8 = reinterpret_cast<const TUint8*>(aMaskPtr) + aMaskX;

			while (aLength--)

				{

				TInt mask = *maskPtr8++;

				if (mask)

					{

					TInt b = srcPtr8[0];

					TInt g = srcPtr8[1];

					TInt r = srcPtr8[2];

					if(aShadowing == MAlphaBlend::EShdwBefore)

						{

						if (iShadowMode & EFade)

							{

							r = ((r * iFadeMapFactor) >> 8) + iFadeMapOffset;

							g = ((g * iFadeMapFactor) >> 8) + iFadeMapOffset;

							b = ((b * iFadeMapFactor) >> 8) + iFadeMapOffset;

							}

						if (iShadowMode & EShadow)

							{

							r = (Max(0,r-0x40));

							g = (Max(0,g-0x40));