// Copyright (c) 2004-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 <graphics/lookuptable.h>

#include <graphics/blendingalgorithms.h>

#include "BMDRAW.H"

#include "BitDrawInterfaceId.h"

FORCEINLINE void BlendFromRBandG(TUint32 *aPixelPtr, TUint32 aSrcRB, TUint32 aSrcG, TUint32 aSrcAlpha, TUint32 aMaskX2)

	{

	const TUint32 d = *aPixelPtr;

	const TUint32 d_rb = d & 0x00FF00FF;

	const TUint32 rb = ((((aSrcAlpha * ((0x01000100 + aSrcRB) - d_rb)) >> 8) + d_rb) - aMaskX2) & 0x00FF00FF;

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

	const TInt g = ((aSrcAlpha * (aSrcG - d_g)) >> 8) + d_g;

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

	}

/**Initializes iSize, iDrawRect, iLongWidth, iScanLineBytes, iScanlineWords data members.

 It should be called every time when iSize is going to be changed - from Construct().

 If you are calling SetSize for an offscreen bitmap then this function operates correctly 

 but for hardware bitmaps the calculated values for iScanLineWords and iLongWidth members 

 may not be compatible. For hardware bitmaps you should explicitly set iScanLineWords to 

 a correct value as shown in CGuidScreenDevice<T,guidMode,pixelsPerWord>::SetDeviceOrientation.

 @param aSize Physical screen size in pixels.

 @panic EScreenDriverPanicInvalidSize - Invalid aSize parameter. This might happen if the

 device is scaled and the scaling origin goes outside physical drawing rectangle. */

void CDrawThirtyTwoBppBitmapCommon::SetSize(const TSize& aSize)

	{

	CDrawBitmap::SetSize(aSize);

	__ASSERT_DEBUG(iSize == aSize, User::Invariant());

	iLongWidth = iSize.iWidth;

	iScanLineWords = iSize.iWidth;

	}

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

	{

	iBits = NULL;

	CDrawBitmap::SetSize(aSize);

	__ASSERT_DEBUG(iSize == aSize, User::Invariant());

	if (aStride & 3)

		return KErrArgument;

	iLongWidth = aStride >> 2;

	if (iLongWidth < aSize.iWidth)

		return KErrArgument;

	iScanLineWords = iLongWidth;

	TInt size = Max(aSize.iWidth,aSize.iHeight) << 2;

	if(size < 0)

		return KErrArgument;

	iScanLineBuffer = (TUint32*)(User::Heap().Alloc(size));

	if (iScanLineBuffer == NULL)

		return KErrNoMemory;

	return KErrNone;

	}

void CDrawThirtyTwoBppBitmapCommon::Shadow(TRgb& aColor)

	{

	TUint32 value = aColor.Internal();

	const TInt alpha = value >> 24;

	if (iShadowMode & EFade)

		{

#if defined(SYMBIAN_USE_FAST_FADING)

		value = ((value >> 1) & ~0x00808080) + (SYMBIAN_USE_FAST_FADING);

#else		

		const TInt wordFadeMapOffset = ((iFadeMapOffset & 0xff) << 16) | (iFadeMapOffset & 0xff);		

		const TInt rb = ((((value & 0x00ff00ff) * iFadeMapFactor) >> 8) + wordFadeMapOffset) & 0x00ff00ff;

	  	const TInt g = ((((value & 0x0000ff00) * iFadeMapFactor) >> 16) + iFadeMapOffset) << 8;

		value = rb | g;

#endif		

		}

	if (iShadowMode & EShadow)

		{

		const TInt r = (value & 0x00c00000) ? ((value & 0x00ff0000)-0x00400000) : 0;

		const TInt g = (value & 0x0000c000) ? ((value & 0x0000ff00)-0x00004000) : 0;

		const TInt b = (value & 0x000000c0) ? ((value & 0x000000ff)-0x00000040) : 0;

		value = r | g | b;

		}

	aColor = TRgb(value,alpha);

	}

void CDrawThirtyTwoBppBitmapCommon::Shadow(TUint32& aColor)

	{

	// aColor is in the format indicated by ScanLineDisplayMode(), which we

	// assume is EColor16MAP here. If not, this function must be overridden.

	const TInt alpha = (aColor >> 24) + 1;

	TUint32 value = aColor & 0x00ffffff;

	if (iShadowMode & EFade)

		{

#if defined(SYMBIAN_USE_FAST_FADING)

		const TUint32 fast_fade_offset = NonPMA2PMAPixel((aColor & 0xff000000) | SYMBIAN_USE_FAST_FADING) & 0x00ffffff;

		value = ((value >> 1) & ~0x00808080) + (fast_fade_offset);

#else

		const TInt fadeMapOffset = ((alpha * iFadeMapOffset) >> 8) & 0xff;

		const TInt wordFadeMapOffset = ((fadeMapOffset) << 16) | (fadeMapOffset);

		const TInt rb = ((((value & 0x00ff00ff) * iFadeMapFactor) >> 8) + wordFadeMapOffset) & 0x00ff00ff;

	  	const TInt g = ((((value & 0x0000ff00) * iFadeMapFactor) >> 16) + fadeMapOffset) << 8;

		value = rb | g;

#endif

		}

	if (iShadowMode & EShadow)

		{

		const TInt uLimit = ((0x40) * alpha) >> 8;

		TInt r = (value >> 16) & 0xff;

		r = (r > uLimit) ? (r-uLimit) : 0;

		TInt g = (value >> 8) & 0xff;

		g = (g > uLimit) ? (g - uLimit) : 0;

		TInt b = value & 0xff;

		b = (b > uLimit) ? (b - uLimit) : 0;

		value = (r << 16) | (g << 8) | b;

		}

	// alpha is unchanged.

	aColor = (aColor & 0xff000000) | value;

	}

TUint8 CDrawThirtyTwoBppBitmapCommon::ShadowAndFade(TInt aComponent)

	{

	if (iShadowMode & EFade)

		aComponent = FadeGray(aComponent);

	if (iShadowMode & EShadow)

		aComponent = ShadowComponent(aComponent);

	return TUint8(aComponent);

	}

TUint8 CDrawThirtyTwoBppBitmapCommon::ShadowComponent(TInt aRgbComponent)

	{

	return TUint8(Max(0,aRgbComponent-0x40));

	}

void CDrawThirtyTwoBppBitmapCommon::InvertBuffer(TInt aLength,TUint32* aBuffer)

	{

	__ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

	TUint32* limit = aBuffer + aLength;

	while (aBuffer < limit)

		{

		*aBuffer++ ^= 0x00ffffff;

		}

	}

void CDrawThirtyTwoBppBitmapCommon::ReadLine(TInt aX,TInt aY,TInt aLength,TAny* aBuffer) const

	{

	const TUint32* pixelPtr = PixelAddress(aX,aY);

	if (iOrientation == EOrientationNormal)

		Mem::Copy(aBuffer,pixelPtr,aLength << 2);

	else

		{

		const TInt pixelPtrInc = PixelAddressIncrement();

		TUint32* bufferPtr = static_cast <TUint32*> (aBuffer);

		const TUint32* bufferPtrLimit = bufferPtr + aLength;

		while (bufferPtr < bufferPtrLimit)

			{

			*bufferPtr++ = *pixelPtr;

			pixelPtr += pixelPtrInc;

			}

		}

	}

TRgb CDrawThirtyTwoBppBitmapCommon::ReadRgbNormal(TInt aX,TInt aY) const

	{

	return RgbColor(*PixelAddress(aX,aY));

	}

void CDrawThirtyTwoBppBitmapCommon::ShadowArea(const TRect& aRect)

	{

	const TRect rect(DeOrientate(aRect));

	__ASSERT_DEBUG(rect.iTl.iX>=0 && rect.iBr.iX<=iSize.iWidth,Panic(EScreenDriverPanicOutOfBounds));

	__ASSERT_DEBUG(rect.iTl.iY>=0 && rect.iBr.iY<=iSize.iHeight,Panic(EScreenDriverPanicOutOfBounds));

	TUint32* pixelPtr = PixelAddress(rect.iTl.iX,rect.iTl.iY);

	TUint32* pixelRowPtrLimit = pixelPtr + (rect.Height() * iScanLineWords);

	TUint32* pixelRowPtr = pixelPtr;

	TUint32* pixelPtrLimit = pixelPtr + rect.Width();

	if (iShadowMode & EFade)

		{

#if !defined(SYMBIAN_USE_FAST_FADING)		

		const TInt wordFadeMapOffset = ((iFadeMapOffset & 0xff) << 16) | (iFadeMapOffset & 0xff);

#endif

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			TUint32* tempPixelPtr = pixelRowPtr;

			while (tempPixelPtr < pixelPtrLimit)

				{

#if defined(SYMBIAN_USE_FAST_FADING)

				*tempPixelPtr++ = 0xff000000 | ((((*tempPixelPtr) >> 1) & ~0x00808080) + (SYMBIAN_USE_FAST_FADING));

#else

				const TUint32 color = *tempPixelPtr;

				const TInt rb = ((((color & 0x00ff00ff) * iFadeMapFactor) >> 8) + wordFadeMapOffset) & 0x00ff00ff;

	  			const TInt g = ((((color & 0x0000ff00) * iFadeMapFactor) >> 16) + iFadeMapOffset) << 8;

				*tempPixelPtr++ = 0xff000000 | rb | g;

#endif				

				}

			pixelRowPtr += iScanLineWords;

			pixelPtrLimit += iScanLineWords;

			}

		}

	if (iShadowMode & EShadow)

		{

		pixelRowPtr = pixelPtr;

		pixelPtrLimit = pixelPtr + rect.Width();		

		while (pixelRowPtr < pixelRowPtrLimit)

			{

			TUint32* tempPixelPtr = pixelRowPtr;

			while (tempPixelPtr < pixelPtrLimit)

				{

				const TUint32 color = *tempPixelPtr;

				const TInt r = (color & 0x00c00000) ? ((color & 0x00ff0000)-0x00400000) : 0;

				const TInt g = (color & 0x0000c000) ? ((color & 0x0000ff00)-0x00004000) : 0;

				const TInt b = (color & 0x000000c0) ? ((color & 0x000000ff)-0x00000040) : 0;

				*tempPixelPtr++	= 0xff000000 | r | g | b;

				}

			pixelRowPtr += iScanLineWords;

			pixelPtrLimit += iScanLineWords;

			}

		}

	}

void CDrawThirtyTwoBppBitmapCommon::ShadowBuffer(TInt aLength,TUint32* aBuffer)

	{

	__ASSERT_DEBUG(aLength>0,Panic(EScreenDriverPanicZeroLength));

	__ASSERT_DEBUG(aBuffer,Panic(EScreenDriverPanicNullPointer));

	TUint32* limit = aBuffer + aLength;

	while (aBuffer < limit)

		Shadow(*aBuffer++);

	}

void CDrawThirtyTwoBppBitmapCommon::WriteRgb(TInt aX,TInt aY,TRgb aColor)

	{

	TUint8* componentPtr = reinterpret_cast <TUint8*> (PixelAddress(aX,aY));

	const TInt sourceAlpha = aColor.Alpha();

	if (sourceAlpha==0)

		return;

	if(sourceAlpha != 0xff)

		{

		aColor = AlphaBlend(aColor.Red(), aColor.Green(), aColor.Blue(), TRgb(componentPtr[2], componentPtr[1], componentPtr[0]), sourceAlpha);

		}

	componentPtr[0] = TUint8(aColor.Blue());

	componentPtr[1] = TUint8(aColor.Green());

	componentPtr[2] = TUint8(aColor.Red());

	}

void CDrawThirtyTwoBppBitmapCommon::WriteBinary(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor)

	{

	const TInt sourceAlpha = aColor.Alpha();

	if(sourceAlpha == 0)

		return;

	DeOrientate(aX,aY);

	TInt pixelInc;

	TInt rowInc;

	switch(iOrientation)

		{

		case EOrientationNormal:

			{

			pixelInc = 1;

			rowInc = iScanLineWords;

			break;

			}

		case EOrientationRotated90:

			{

			pixelInc = iScanLineWords;

			rowInc = -1;

			break;

			}

		case EOrientationRotated180:

			{

			pixelInc = -1;

			rowInc = -iScanLineWords;

			break;

			}

		default: // EOrientationRotated270

			{

			pixelInc = -iScanLineWords;

			rowInc = 1;

			}

		}

	const TUint32* dataLimit = aBuffer + aHeight;

	const TUint32 dataMaskLimit = (aLength < 32) ? 1 << aLength : 0;

	TUint32* pixelPtr = PixelAddress(aX,aY);

	if(sourceAlpha == 255) //we split code on two parts because of performance reasons

		{

		TInt color = Color(aColor);

		while (aBuffer < dataLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint32* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					*tempPixelPtr = color;

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	else //sourceAlpha != 255

		{

		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 (aBuffer < dataLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint32* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if (dataWord & dataMask)

					{

					BlendFromRBandG(tempPixelPtr,s_rb,s_g,sourceAlpha,mask2);

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	}

void CDrawThirtyTwoBppBitmapCommon::WriteBinaryOp(TInt aX,TInt aY,TUint32* aBuffer,TInt aLength,TInt aHeight,TRgb aColor,CGraphicsContext::TDrawMode aDrawMode)

	{

	if (aLength <= 0)

		return;

	DeOrientate(aX,aY);

	TUint32* pixelPtr = PixelAddress(aX,aY);

	const TUint32* dataPtrLimit = aBuffer + aHeight;

	const TUint32 dataMaskLimit = (aLength < 32) ? 1 << aLength : 0;

	TInt pixelInc;

	TInt rowInc;

	if (iOrientation == EOrientationNormal)

		{

		pixelInc = 1;

		rowInc = iScanLineWords;

		}

	else if (iOrientation == EOrientationRotated90)

		{

		pixelInc = iScanLineWords;

		rowInc = -1;

		}

	else if (iOrientation == EOrientationRotated180)

		{

		pixelInc = -1;

		rowInc = -iScanLineWords;

		}

	else // EOrientationRotated270

		{

		pixelInc = -iScanLineWords;

		rowInc = 1;

		}

	TInt color = Color(aColor);// & 0x00FFFFFF;

	if (color != 0)

		{

		while (aBuffer < dataPtrLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint32* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					if(aDrawMode==CGraphicsContext::EDrawModeXOR)

						{

						*tempPixelPtr ^= color;

						}

					else if(aDrawMode==CGraphicsContext::EDrawModeAND)

						{

						*tempPixelPtr &= color;

						}

					else if(aDrawMode==CGraphicsContext::EDrawModeOR)

						{

						*tempPixelPtr |= color;

						}

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	else if (aDrawMode == CGraphicsContext::EDrawModeAND)

		{

		while (aBuffer < dataPtrLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint32* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					*tempPixelPtr = 0;

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	}

void CDrawThirtyTwoBppBitmapCommon::WriteBinaryLineVertical(TInt aX,TInt aY,TUint32* aBuffer,TInt aHeight,TRgb aColor,TBool aUp)

	{

	const TInt sourceAlpha = aColor.Alpha();

	if(sourceAlpha == 0)

		return;

	DeOrientate(aX,aY);

	TInt scanlineWordLength;

	if (iOrientation == EOrientationNormal)

		scanlineWordLength = iScanLineWords;

	else if (iOrientation == EOrientationRotated90)

		scanlineWordLength = -1;

	else if (iOrientation == EOrientationRotated180)

		scanlineWordLength = -iScanLineWords;

	else // EOrientationRotated270

		scanlineWordLength = 1;

	if (aUp)

		scanlineWordLength = -scanlineWordLength;

	TUint32* pixelPtr = PixelAddress(aX,aY);

	const TUint32* pixelPtrLimit = pixelPtr + (aHeight * scanlineWordLength);

	TUint32 dataWord = *aBuffer;

	TUint32 dataMask = 1;

	if(sourceAlpha == 255) //we split code on two parts because of performance reasons

		{

		TInt color = Color(aColor);

		while(pixelPtr != pixelPtrLimit)

			{

			if(!dataMask)

				{

				dataMask = 1;

				aBuffer++;

				dataWord = *aBuffer;

				}

			if(dataWord & dataMask)

				{

				*pixelPtr = color;

				}

			dataMask <<= 1;

			pixelPtr += scanlineWordLength;

			}

		}

	else //sourceAlpha != 255

		{

		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 != pixelPtrLimit)

			{

			if(!dataMask)

				{

				dataMask = 1;

				aBuffer++;

				dataWord = *aBuffer;

				}