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

#include <graphics/blendingalgorithms.h>

/*

Does the same conversion as NonPMA2PMAPixel, but leaves the values in the RB and G uint32 values

ready for use in the blending algorithm. Also assumes alphas of 0 or 0xFF have already been

stripped out as special cases.

*/

FORCEINLINE void NonPMA2PMAPixelRBG(TUint32 aPixel, TUint32 &aSrcRB, TUint32 &aSrcG, TUint32 &aMask)

	{

	TUint32 alpha=(aPixel >> 24);

	aMask = 0x0100 - alpha;	// for use in PMABlend_fromRBandG

	TUint32 tap1=alpha+1;

	aSrcRB = (aPixel & KRBMask) * tap1;

	aSrcRB >>= 8;

	aSrcRB &= KRBMask;

	aSrcG = (aPixel&0xFF000000) | (((aPixel & KGMask)>>8) * tap1) & KAGMask;

	}

/*

Uses same algorithm as PMABlend_noChecksInplace, but optimised for use with NonPMA2PMAPixelRBG where

source values are pre-split into RB and G components ready for use in blend

*/

FORCEINLINE void PMABlend_fromRBandG(TUint32& aDest_io, const TUint32 aSrcRB, const TUint32 aSrcG, const TUint8 aMask)

	{

	TUint32 dst_ag = (aDest_io & KAGMask) >> 8;

	aDest_io = aDest_io  & KRBMask;

	aDest_io = (aSrcRB +  ((aMask * aDest_io) >> 8)) & KRBMask;

	aDest_io |= (aSrcG +  (aMask * dst_ag)) & KAGMask;

	}

/*

Takes a non-PM source colour and an alpha value

First pre-multiplies aSrcPixel with aAlpha

Then blends it into aDestIo using the same alpha value.

*/

FORCEINLINE void PMABlend_FromNonPmAndAlpha(TUint32& aDest_io, const TUint32& aSrcPixel, TUint32 aAlpha)

	{

	TUint32 tap1=aAlpha+1;

	TUint32 srcRB = (aSrcPixel & KRBMask) * tap1;

	srcRB=(srcRB>>8) & KRBMask;

	TUint32 srcAG = (aSrcPixel & KGMask ) * tap1;

	srcAG=(srcAG>>8) & KGMask;

	srcAG|=aAlpha<<24;

	TUint32 dst_ag = (aDest_io & KAGMask) >> 8;

	TUint32 dst_rb = aDest_io & KRBMask;

	const TUint32 mask = 0x0100 - aAlpha;

	aDest_io = (srcRB +  ((mask*dst_rb) >> 8)) & KRBMask;

	aDest_io |= (srcAG + mask*dst_ag) & KAGMask;

	}

// Same as NonPMA2PMAPixel, but for use where checks for alpha of 0 or 0xFF have already been done

FORCEINLINE TUint32 NonPMA2PMAPixelNoCheck(TUint32 aPixel)

	{

	TUint32 tap1=(aPixel>>24)+1;

	TUint32 scaledRB = (aPixel & KRBMask) * tap1;

	TUint32 scaledG = (aPixel & KGMask ) * tap1;

	return (aPixel & 0xff000000) | ((scaledRB>>8) & KRBMask) | ((scaledG>>8)& KGMask);

	}

/**

Composite mask application

where AlphaComposite = AlphaColor * AlphaMask / 255.

@param aColor - non-premltiplied color with alpha 

@param aMask  - the mask value. (0 to 255).

@return the color with alpha combined from color and mask (combination

operator used is scaled multiplication).

*/

FORCEINLINE TUint32 CompMask(TUint32 aColor, TUint8 aMask)

	{

	// if the mask is FF the colour will be fully opaque and can be immediatly returned

	if (aMask == 0xff)

		return aColor;

	TUint32 cAlpha = (aMask+1) * (aColor >> 24);

	return ((aColor & 0x00ffffff) | ((cAlpha <<16) & 0xff000000));

	}

TInt CDrawThirtyTwoBppBitmapAlphaPM::Construct(TSize aSize)

	{

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

	}

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

	{

	iDispMode = EColor16MAP;

	return CDrawThirtyTwoBppBitmapCommon::Construct(aSize, aStride);

	}

/**

MAlphaBlend::WriteRgbAlphaLine() implementation.

Blends the supplied buffer of TRgb format data (ARGB), and the mask, to the destination

which is specified by the pixel positions aX, aY and length.

@param aX	The starting position on the x-axis for the destination pixel.

@param aY	The starting position on the y-axis for the destination pixel.

@param aRgbBuffer	The RGB source data buffer. This is assumed to be bit aligned 32 bit non-premultiplied data

@param aMaskBuffer	The masking data. The mask buffer and the source alpha values are multiplied together to

					generate the alpha used for blending to the destination.

@param aShadowing	The shadowing flag. Indicates when and how to apply shadowing.

@param aDrawMode	The mode for rendering the source image to the destination. 

					Currently supports EWriteAlpha and EPenmode.

@see MAlphaBlend::WriteRgbAlphaLine()

*/

void CDrawThirtyTwoBppBitmapAlphaPM::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);

	const TInt pixelPtrInc = PixelAddressIncrement();

	const TUint16* normTable = PtrTo16BitNormalisationTable();

	TRgb tmp;

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	// The purpose of this conditional is to remove if statements from within the loop

	// if shadow mode is not enabled and the UserDispMode is none or EColor16MAP

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

		{

		while (aMaskBuffer < maskBufferPtrLimit)

			{

			if (*aMaskBuffer)

				{

				TUint32 srcData = *((TUint32*)aRgbBuffer);

				if ((aDrawMode == CGraphicsContext::EDrawModeWriteAlpha) && (*aMaskBuffer == 0xFF))

					{

					// Write the source straight through to the target, otherwise

					// blend. This relies on the fact that EDrawModeWriteAlpha can only

					// be used with masks that contain only black or white.

					Convert2PMA(srcData);

					*pixelPtr = srcData;

					}

				else

					{

					//blend alpha value in source with the mask value.

					srcData = CompMask(srcData, *aMaskBuffer);

					//pre-multiply, inplace.

					Convert2PMA(srcData);

					PMAInplaceBlend(*pixelPtr, srcData);

					}

				}

			pixelPtr += pixelPtrInc;

			aRgbBuffer += 4;

			aMaskBuffer++;

			}

		}

	else

		{

		while (aMaskBuffer < maskBufferPtrLimit)

			{

			TUint32 srcColor = *((TUint32*)(aRgbBuffer));

			if(*aMaskBuffer)

				{

				if(aShadowing == MAlphaBlend::EShdwBefore)

					{

					// src color in non-premultiplied.

					Shadow(*(TRgb*)&srcColor);

					}

				TUint32 srcData;

				if ((aDrawMode == CGraphicsContext::EDrawModeWriteAlpha) && (*aMaskBuffer == 0xFF))

					{

					Convert2PMA(srcColor);

					srcData = srcColor;

					}

				else

					{

					//blend alpha value in source with the mask value.

					srcData = CompMask(srcColor, *aMaskBuffer);

					//pre-multiply, inplace.

					Convert2PMA(srcData);

					srcData = PMAPixelBlend(*pixelPtr, srcData);

					}

				if(aShadowing == MAlphaBlend::EShdwAfter)

					{

					// shadow is done in PMA mode.

					Shadow(srcData);

					}

				if(iUserDispMode !=EColor16MAP && iUserDispMode != ENone)

					{

					tmp.SetInternal(PMA2NonPMAPixel(srcData, normTable));

					CDrawThirtyTwoBppBitmapCommon::MapColorToUserDisplayMode(tmp);

					srcData = tmp.Internal();

					Convert2PMA(srcData);

					}

				*pixelPtr = srcData;

				}

			pixelPtr += pixelPtrInc;

			aRgbBuffer += 4;

			aMaskBuffer++;

			}

		}

	}

/**

This assumes that the pen color (aColor) alpha information is to be blended with

the alpha provided by the mask buffer.

If pen is opaque, the mask is used as transparency information to be used.

If pen is semi-transparent, the mask is contructed by calculating the resulting alpha

by multiplying the mask with the alpha information of the pen color.

@see CFbsDrawDevice::WriteRgbAlphaMulti

*/

void CDrawThirtyTwoBppBitmapAlphaPM::WriteRgbAlphaMulti(TInt aX,TInt aY,TInt aLength,TRgb aColor,const TUint8* aMaskBuffer)

	{

	TUint32 srcAlpha = aColor.Alpha();

	if (srcAlpha==0 || aLength<=0)

		return;

	DeOrientate(aX,aY);

	TUint32* pixelPtr = PixelAddress(aX,aY);

	const TInt pixelPtrInc = PixelAddressIncrement();

	const TUint8* maskBufferPtrLimit = aMaskBuffer + aLength;

	if (iShadowMode)

		CDrawThirtyTwoBppBitmapCommon::Shadow(aColor);

	// pre-multiply the color.

	const TUint32 srcColor = aColor.Internal();

	if (srcAlpha == 255)

		{ // source (pen) is opaque, so we simply blend it using the mask

		// little trick to make main loop more optimised, having 'pixelPtr += pixelPtrInc' at the top 

		// of the loop makes the compiler generate better code without extra jumps to reach the

		// 'pixelPtr += pixelPtrInc' line.

		// We also need to do the FOREVER loop with a break when aMaskBuffer==maskBufferPtrLimit or

		// else the compiler puts the test at the end and extra jumps are required to reach it.

		pixelPtr -= pixelPtrInc;

		FOREVER

			{

			pixelPtr += pixelPtrInc;

			if (aMaskBuffer==maskBufferPtrLimit)

				break;

			const TUint maskAlpha=*aMaskBuffer++;

			if (maskAlpha==0)

				{	// Most pixels in text are blank, so this is the most important route to optimise

				continue;

				}

			else if (maskAlpha==0xFF)

				{	// Second most important are fully opaque pixels

				*pixelPtr=srcColor;

				continue;

				}

			TUint32 maskColor = NonPMA2PMAPixelNoCheck((srcColor&~0xFF000000) | ((TUint32)maskAlpha << 24));

			PMAInplaceBlend(*pixelPtr, maskColor);

			}

		}

	else if(srcAlpha > 0)

		{

		// pen is semi-transparent, so we must blend using both the mask and pen alpha

		// pre calculate ffMaskColor optimised for common case where aMaskBuffer contains 0xFF

		const TUint32 ffMaskColor=NonPMA2PMAPixelNoCheck(srcColor);

		const TUint32 noAlphaSrcColor=srcColor&0xFFFFFF;

		while (aMaskBuffer < maskBufferPtrLimit)

			{

			const TUint maskAlpha=*aMaskBuffer;

			if (maskAlpha)

				{

				if (maskAlpha==0xFF)

					PMABlend_noChecksInplace(*pixelPtr, ffMaskColor, srcAlpha);

				else

					{

					TUint32 mixedAlpha = ((maskAlpha+1) * srcAlpha)>>8;

					PMABlend_FromNonPmAndAlpha(*pixelPtr, noAlphaSrcColor, mixedAlpha);

					}

				}

			pixelPtr += pixelPtrInc;

			aMaskBuffer++;

			}

		}

	}

/**

@see CFbsDrawDevice::WriteRgb

*/

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

	{

	TUint32 srcColor = NonPMA2PMAPixel(aColor.Internal());

	TUint32* pixelPtr = PixelAddress(aX,aY);

	PMAInplaceBlend(*pixelPtr, srcColor);

	}

/**

@see CFbsDrawDevice::WriteBinary

*/

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

	{

	const TUint32 colorInternal=aColor.Internal();

	const TUint8  srcAlpha = colorInternal >> 24;

	if (srcAlpha==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 (srcAlpha==0xFF)

		{

		while (aBuffer < dataLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint32* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					*tempPixelPtr=colorInternal;

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	else

		{

		TUint32 src_rb;

		TUint32 src_g;

		TUint32 mask;

	//pre-multiply the src color, before blending.

		NonPMA2PMAPixelRBG(colorInternal,src_rb,src_g,mask);

		while (aBuffer < dataLimit)

			{

			TUint32 dataWord = *aBuffer++;

			TUint32 dataMask = 1;

			TUint32* tempPixelPtr = pixelPtr;

			while (dataMask != dataMaskLimit)

				{

				if(dataWord & dataMask)

					{

					PMABlend_fromRBandG(*tempPixelPtr, src_rb, src_g, mask);

					}

				tempPixelPtr += pixelInc;

				dataMask <<= 1;

				}

			pixelPtr += rowInc;

			}

		}

	}

/**

@see CFbsDrawDevice::WriteBinaryLineVertical

*/

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

	{

	const TUint32 colorInternal=aColor.Internal();

	const TInt sourceAlpha = colorInternal>>24;

	if (sourceAlpha==0)

		return;

	DeOrientate(aX,aY);

	TInt scanlineWordLength;

	switch(iOrientation)

		{

		case EOrientationNormal:

			scanlineWordLength = iScanLineWords;

			break;

		case EOrientationRotated90:

			scanlineWordLength = -1;

			break;

		case EOrientationRotated180:

			scanlineWordLength = -iScanLineWords;

			break;

		default: // 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==0xFF)

		{

		while(pixelPtr != pixelPtrLimit)

			{

			if(!dataMask)

				{

				dataMask = 1;

				aBuffer++;

				dataWord = *aBuffer;

				}

			if(dataWord & dataMask)

				{

				*pixelPtr = colorInternal;

				}

			dataMask <<= 1;

			pixelPtr += scanlineWordLength;

			}

		}

	else

		{

		TUint32 src_rb;

		TUint32 src_g;

		TUint32 mask;

	//pre-multiply the src color, before blending.

		NonPMA2PMAPixelRBG(colorInternal,src_rb,src_g,mask);

		while(pixelPtr != pixelPtrLimit)

			{

			if(!dataMask)

				{

				dataMask = 1;

				aBuffer++;

				dataWord = *aBuffer;

				}

			if(dataWord & dataMask)

				{

				PMABlend_fromRBandG(*pixelPtr, src_rb, src_g, mask);

				}

			dataMask <<= 1;

			pixelPtr += scanlineWordLength;

			}

		}

	}

/**

@see CFbsDrawDevice::BlendRgbMulti

*/

void CDrawThirtyTwoBppBitmapAlphaPM::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;

	TUint32 srcValue = NonPMA2PMAPixel(aColor.Internal());

	TUint32 src_c = srcValue & KRBMask;

	TUint32 src_g = (srcValue & KAGMask)>>8;

	const TUint32 mask = 0x0100 - sourceAlpha;

	while (pixelPtr < pixelRowPtrLimit)

		{

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

			{

			const TUint32 dst = *tempPixelPtr;

			TUint32 dst_c = dst  & KRBMask;

			dst_c = (src_c +  ((mask * dst_c)>>8)) & KRBMask;

			const TUint32 dst_ag = (dst & KAGMask)>>8;

			dst_c |= ((src_g +  ((mask * dst_ag)>>8)) & KRBMask)<<8;

			*tempPixelPtr=dst_c;

			}

		pixelPtr += iScanLineWords;

		pixelPtrLimit += iScanLineWords;

		}

	}

/**

@see CFbsDrawDevice::BlendLine

*/

void CDrawThirtyTwoBppBitmapAlphaPM::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)

		{

		PMAInplaceBlend(*pixelPtr,  *aBuffer);

		aBuffer++;

		pixelPtr += pixelPtrInc;

		}