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

GLREF_D const TUint8 ditherlutab[16][4];

GLREF_D const TUint8 shadowlutab[256];

const TInt KPixelsPerWord = 8;

const TInt KPixelsPerByte = 2;

const TInt KBitsPerPixel = 4;

// CDrawFourBppBitmapGray

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

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

//@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 CDrawFourBppBitmapGray::SetSize(const TSize& aSize) 

	{

	CDrawBitmap::SetSize(aSize);

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

	iLongWidth = (iSize.iWidth + (KPixelsPerWord - 1)) & ~(KPixelsPerWord - 1);

	iScanLineWords = iLongWidth / KPixelsPerWord;

	}

TInt CDrawFourBppBitmapGray::Construct(TSize aSize)

	{

	return Construct(aSize, ((aSize.iWidth + (KPixelsPerWord - 1)) & ~(KPixelsPerWord - 1)) / KPixelsPerByte);

	}

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

	{

	iBits = NULL;

	iDispMode = EGray16;

	CDrawBitmap::SetSize(aSize);

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

	if (aStride & 3)

		return KErrArgument;

	iLongWidth = aStride * KPixelsPerByte;

	if (iLongWidth < aSize.iWidth)

		return KErrArgument;

	iScanLineWords = aStride >> 2;

	TInt size = 1 + (Max(aSize.iWidth,aSize.iHeight) >> 1);

	if(size < 0)

		return KErrArgument;

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

	if (iScanLineBuffer == NULL)

		return KErrNoMemory;

	return KErrNone;

	}

void CDrawFourBppBitmapGray::Shadow(TRgb& aColor)

	{

	aColor = TRgb::_Gray16(ShadowAndFadeGray16(aColor._Gray16()));

	}

TUint8 CDrawFourBppBitmapGray::ShadowAndFadeGray16(TInt aGray16)

	{

	if (iShadowMode & EFade)

		aGray16 = FadeGray(aGray16 * 17) >> 4;

	if (iShadowMode & EShadow)

		aGray16 = Max(aGray16 - 5,0);

	return (TUint8)aGray16;

	}

TUint32 CDrawFourBppBitmapGray::FadeWord(TUint32 aWord)

	{

	TUint32 fadedWord = 0;

	for (TInt bitShift = 0; bitShift < 32; bitShift += 4)

		{

		TInt gray = (aWord >> bitShift) & 0xf;

		gray = FadeGray(gray * 17) >> 4;

		fadedWord |= gray << bitShift;

		}

	return fadedWord;

	}

TUint32 CDrawFourBppBitmapGray::ColorInt(TRgb aColor) const

	{

	TUint32 colorWord = aColor._Gray16();

	colorWord |= colorWord << 4;

	colorWord |= colorWord << 8;

	colorWord |= colorWord << 16;

	return colorWord;

	}

void CDrawFourBppBitmapGray::DitherBuffer(TInt aX,TInt aY,TInt aLength,TUint32* aBuffer)

	{

	aX += iDitherOrigin.iX;

	aY += iDitherOrigin.iY;

	aX &= 1;

	aY &= 1;

	aY <<= 1;

	const TInt first = aX + aY;

	aX ^= 1;

	const TInt second = aX + aY;

	TUint8* bufferPtr = (TUint8*)aBuffer;

	const TUint8* bufferLimit = bufferPtr + ((aLength + 1) / 2);

	for (; bufferPtr < bufferLimit; bufferPtr++)

		{

		TUint8 index1 = bufferPtr[0];

		TUint8 index2 = TUint8(index1 >> 4);

		index1 &= 0xf;

		const TUint8 value1 = ditherlutab[index1][first];

		const TUint8 value2 = ditherlutab[index2][second];

		bufferPtr[0] = TUint8(value1 | (value2 << 4));

		}

	}

TUint32 CDrawFourBppBitmapGray::HashInt(TRgb aColor,TInt aX,TInt aY) const

	{

	const TUint32 gray = aColor._Gray16();

	const TUint32 int1 = Hash(gray,aX,aY);

	const TUint32 int2 = Hash(gray,aX + 1,aY);

	TUint32 colorWord = int1 | (int2 << 4);

	colorWord |= colorWord << 8;

	colorWord |= colorWord << 16;

	return colorWord;

	}

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

	{

	const TUint32* bufferLimit = aBuffer + ((aLength + KPixelsPerWord - 1) / KPixelsPerWord);

	while (aBuffer < bufferLimit)

		*aBuffer++ ^= 0xffffffff;

	}

/**	Copies a number of pixels into a word-aligned buffer without format translation.

	Note that the byte length to the target buffer is honoured, 

 	but the end contents of the last byte are generally overwritten with extra pixel data (or garbage).

 	Note that I am assuming the compiler optimiser will convert all these divides and multiplies into shifts!  

@param	aX		x coordinate to start copy from (need not be aligned at all)

@param	aY		y coordinate to copy line from	

@param	aLength	number of pixels to copy  

@param	aBuffer	target word-aligned buffer (but may or may not be word length) 

 **/

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

	{

	TUint32* pixelPtr = ScanLine(aY);

	TInt startLongPix = aX & -KPixelsPerWord;

	pixelPtr += startLongPix / KPixelsPerWord;

	TUint32* bufferPtr = (TUint32*)aBuffer;

	TInt wordsCnt = (aLength+KPixelsPerByte-1) / KPixelsPerWord;		//how many words to write to target

	TInt restPixels = aLength - wordsCnt * KPixelsPerWord;				//how many pixels left to copy

	TInt bytesCnt = (restPixels+KPixelsPerByte-1) / KPixelsPerByte ;	//how many target bytes to copy

	TInt shiftBits = aX - startLongPix;

	restPixels=shiftBits+restPixels;	//How many pixels are read from the second word by the final word copy

	if (bytesCnt==0 && shiftBits && restPixels<=0)

		{

		// This correction is required because although a last whole word will be written to the target buffer,

		// this special test indicates that the required significant data bits plus the shift 

		// add up to one word (or less) to be read. 

		// The copy words optimisation used to copy the main body of the line 

		// will read from the next location after the copy, 

		// but this may not always be accessable memory (on the last scanline)

		// The correction is not required if the second word would need to be read anyway.

		//eg we want to copy 7 nibbles with a 1 nibble shift (16 color), restpixels would be 0

		bytesCnt=4;

		wordsCnt--;

		}

	//How many pixels are read from the second word in the final byte copy?

	//If zero (or less) then the second word should not be read in the copy bytes phase

	//really this should be an else of the if above, but this gives the same end condition.

	//eg we want to copy 5 nibbles with a 2 nibble shift (16 color), restpixels would be -1.

	restPixels-=KPixelsPerWord;	

	ReadLineCommon(pixelPtr,bufferPtr,wordsCnt,restPixels,bytesCnt,shiftBits*KBitsPerPixel);

	}

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

	{

	TUint32 colorWord = *(ScanLine(aY) + (aX / KPixelsPerWord));

	colorWord >>= ((aX & 7) * KBitsPerPixel);

	return TRgb::_Gray16(colorWord & 0xf);

	}

void CDrawFourBppBitmapGray::ShadowArea(const TRect& aRect)

	{

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

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

	TInt startLong = (aRect.iTl.iX + KPixelsPerWord - 1) & ~7;

	TInt finishLong = aRect.iBr.iX & ~7;

	TInt startShift = (startLong - aRect.iTl.iX) * KBitsPerPixel;

	TInt finishShift = (KPixelsPerWord - aRect.iBr.iX + finishLong) * KBitsPerPixel;

	TInt startLongAdjust = startLong / KPixelsPerWord;

	TInt finishLongAdjust = finishLong / KPixelsPerWord;

	TUint32* base = ScanLine(aRect.iTl.iY);

	if (iShadowMode & EFade)

		{

		TUint32* pixelPtr = base + startLongAdjust;

		TUint32* pixelPtrLimit = base + finishLongAdjust;

		if (finishLong < startLong)

			{

			const TUint32 mask = (0xffffffff >> finishShift) & (0xffffffff << (32 - startShift));

			const TUint32 invertedMask = ~mask;

			for (TInt y = aRect.iTl.iY; y < aRect.iBr.iY; y++)

				{

				TUint32 shadowed = FadeWord(pixelPtrLimit[0]) & mask;

				pixelPtrLimit[0] &= invertedMask;

				pixelPtrLimit[0] |= shadowed;

				pixelPtrLimit += iScanLineWords;

				}

			}

		else

			{

			for (TInt y = aRect.iTl.iY; y < aRect.iBr.iY; y++)

				{

				if (aRect.iTl.iX < startLong)

					{

					TUint32 shadowed = FadeWord(pixelPtr[-1]);

					pixelPtr[-1] = PasteInt(pixelPtr[-1],shadowed,startShift);

					}

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

					tempPixelPtr[0] = FadeWord(tempPixelPtr[0]);

				if (finishLong < aRect.iBr.iX)

					{

					TUint32 shadowed = FadeWord(pixelPtrLimit[0]);

					pixelPtrLimit[0] = PasteInt(shadowed,pixelPtrLimit[0],finishShift);

					}

				pixelPtr += iScanLineWords;

				pixelPtrLimit += iScanLineWords;

				}

			}

		}

	if (iShadowMode & EShadow)

		{

		if (iUserDispMode == EGray2)

			{

			WriteRgbMulti(aRect.iTl.iX,aRect.iTl.iY,aRect.Width(),aRect.Height(),KRgbBlack);

			return;

			}

		TUint32* pixelPtr = base + startLongAdjust;

		TUint32* pixelPtrLimit = base + finishLongAdjust;

		if (finishLong < startLong)

			{

			const TUint32 mask = (0xffffffff >> finishShift) & (0xffffffff << (32 - startShift));

			const TUint32 invertedMask = ~mask;

			for (TInt y = aRect.iTl.iY; y < aRect.iBr.iY; y++)

				{

				TUint32 shadowed = shadowlutab[pixelPtrLimit[0] & 0xff];

				shadowed |= (shadowlutab[(pixelPtrLimit[0] >> 8) & 0xff] << 8);

				shadowed |= (shadowlutab[(pixelPtrLimit[0] >> 16) & 0xff] << 16);

				shadowed |= (shadowlutab[(pixelPtrLimit[0] >> 24) & 0xff] << 24);

				pixelPtrLimit[0] &= invertedMask;

				pixelPtrLimit[0] |= (shadowed & mask);

				pixelPtrLimit += iScanLineWords;

				}

			}

		else

			{

			for (TInt y = aRect.iTl.iY; y < aRect.iBr.iY; y++)

				{

				if (aRect.iTl.iX < startLong)

					{

					TUint32 shadowed = shadowlutab[pixelPtr[-1] & 0xff];

					shadowed |= (shadowlutab[(pixelPtr[-1] >> 8) & 0xff] << 8);

					shadowed |= (shadowlutab[(pixelPtr[-1] >> 16) & 0xff] << 16);

					shadowed |= (shadowlutab[(pixelPtr[-1] >> 24) & 0xff] << 24);

					pixelPtr[-1] = PasteInt(pixelPtr[-1],shadowed,startShift);

					}

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

					{

					TUint32 shadowed = shadowlutab[tempPixelPtr[0] & 0xff];

					shadowed |= (shadowlutab[(tempPixelPtr[0] >> 8) & 0xff] << 8);

					shadowed |= (shadowlutab[(tempPixelPtr[0] >> 16) & 0xff] << 16);

					shadowed |= (shadowlutab[(tempPixelPtr[0] >> 24) & 0xff] << 24);

					tempPixelPtr[0] = shadowed;

					}

				if (finishLong < aRect.iBr.iX)

					{

					TUint32 shadowed = shadowlutab[pixelPtrLimit[0] & 0xff];

					shadowed |= (shadowlutab[(pixelPtrLimit[0] >> 8) & 0xff] << 8);

					shadowed |= (shadowlutab[(pixelPtrLimit[0] >> 16) & 0xff] << 16);

					shadowed |= (shadowlutab[(pixelPtrLimit[0] >> 24) & 0xff] << 24);

					pixelPtrLimit[0] = PasteInt(shadowed,pixelPtrLimit[0],finishShift);

					}

				pixelPtr += iScanLineWords;

				pixelPtrLimit += iScanLineWords;

				}

			}

		}

	}

void CDrawFourBppBitmapGray::ShadeBuffer(TInt aLength,TUint32* aBuffer)

	{

	__ASSERT_DEBUG(aBuffer != NULL,Panic(EScreenDriverPanicInvalidParameter));

	const TUint32* bufferLimit = aBuffer + ((aLength + KPixelsPerWord - 1) / KPixelsPerWord);

	while (aBuffer < bufferLimit)

		{

		TUint32 fourthbit = (0x88888888 & aBuffer[0]);

		aBuffer[0] = fourthbit | (fourthbit >> 1);

		aBuffer[0] |= aBuffer[0] >> 2;

		aBuffer++;

		}

	}

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

	{

	__ASSERT_DEBUG(aBuffer != NULL,Panic(EScreenDriverPanicInvalidParameter));

	const TUint32* bufferLimit = aBuffer + ((aLength + KPixelsPerWord - 1) / KPixelsPerWord);

	if (iShadowMode & EFade)

		{

		for (TUint32* bufferPtr = aBuffer; bufferPtr < bufferLimit; bufferPtr++)

			bufferPtr[0] = FadeWord(bufferPtr[0]);

		}

	if (iShadowMode & EShadow)

		{

		for (TUint32* bufferPtr = aBuffer; bufferPtr < bufferLimit; bufferPtr++)

			{

			TUint32 bufferWord = bufferPtr[0];

			TUint firstbyte = shadowlutab[bufferWord & 0xff];

			bufferWord >>= 8;

			firstbyte |= (shadowlutab[bufferWord & 0xff] << 8);

			bufferWord >>= 8;

			firstbyte |= (shadowlutab[bufferWord & 0xff] << 16);

			bufferWord >>= 8;

			firstbyte |= (shadowlutab[bufferWord & 0xff] << 24);

			bufferPtr[0] = firstbyte;

			}

		}

	}

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

	{

	TUint32 colorIndex = aColor._Gray16();

	if (iUserDispMode == EGray2)

		colorIndex = (colorIndex > 7) ? 15 : 0;

	else if (iUserDispMode == EGray4)

		colorIndex = Hash(colorIndex,aX,aY);

	TUint32* pixelPtr = ScanLine(aY) + (aX / KPixelsPerWord);

	TInt shift = (aX & 7) * KBitsPerPixel;

	pixelPtr[0] &= ~(0xf << shift);

	pixelPtr[0] |= colorIndex << shift;

	}

void CDrawFourBppBitmapGray::WriteBinary(TInt aX,TInt aY,TUint32* aData,TInt aLength,TInt aHeight,TRgb aColor)

	{

	TUint32 color1 = 0;

	TUint32 color2 = 0;

	const TInt yLimit = aY + aHeight;

	const TUint32 gray16 = aColor._Gray16();

	if (iUserDispMode == EGray2)

		{

		if (gray16 > 7)

			{

			color1 = 15;

			color2 = 15;

			}

		}

	else if (iUserDispMode != EGray4)

		{

		color1 = gray16;

		color2 = gray16;

		}

	for (; aY < yLimit; aY++,aData++)

		{

		if (iUserDispMode == EGray4)

			{

			color1 = Hash(gray16,aX,aY);

			color2 = Hash(gray16,aX + 1,aY);

			}

		TUint32 color = color1;

		TUint32 dataMask = 1;

		const TInt xLimit = aX + aLength;

		TUint8* pixelPtr = ((TUint8*)ScanLine(aY)) + (aX / 2);

		if (color1 || color2)

			{

			for (TInt x = aX; x < xLimit; x++,dataMask <<= 1)

				{

				if (aData[0] & dataMask)

					{

					if(x & 1)

						pixelPtr[0] = (TUint8)(color << 4 | (pixelPtr[0] & 0x0f));

					else

						pixelPtr[0] = (TUint8)(color | (pixelPtr[0] & 0xf0));

					}

				color = (color == color2) ? color1 : color2;

				if (x & 1)

					pixelPtr++;

				}

			}

		else

			{

			TUint8 bytemask = TUint8((aX & 1) ? 0x0f : 0xf0);

			for (TInt x = aX; x < xLimit; x++,dataMask <<= 1,bytemask = (TUint8)~bytemask)

				{

				if (aData[0] & dataMask)

					pixelPtr[0] &= bytemask;

				if (x & 1)

					pixelPtr++;

				}

			}

		}

	}

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

	{

	TUint32 color1 = 0;

	TUint32 color2 = 0;

	const TUint32 gray16 = aColor._Gray16();

	const TInt yLimit = aY + aHeight;

	if (iUserDispMode == EGray2)

		{

		if (gray16 > 7)

			{

			color1 = 15;

			color2 = 15;

			}

		}

	else if(iUserDispMode != EGray4)

		{

		color1 = gray16;

		color2 = gray16;

		}

	for (; aY < yLimit; aY++)

		{

		if (iUserDispMode == EGray4)

			{

			color1 = Hash(gray16,aX,aY);

			color2 = Hash(gray16,aX + 1,aY);

			}

		TUint32 color = color1;

		TUint32 dataMask = 1;

		const TInt xLimit = aX + aLength;

		TUint8* pixelPtr = ((TUint8*)ScanLine(aY)) + (aX / 2);

		if(color1 || color2)

			{

			for (TInt x = aX; x < xLimit; x++,dataMask <<= 1)

				{

				if (aData[0] & dataMask)

					{

					if (x & 1)

						{

						if (aDrawMode == CGraphicsContext::EDrawModeXOR)

							pixelPtr[0] = (TUint8)((color << 4) ^ pixelPtr[0]);

						else if (aDrawMode == CGraphicsContext::EDrawModeAND)

							pixelPtr[0] = (TUint8)(((color << 4) | 0x0f) & pixelPtr[0]);

						else if (aDrawMode==CGraphicsContext::EDrawModeOR)

							pixelPtr[0] = (TUint8)((color << 4) | pixelPtr[0]);

						}

					else

						{

						if (aDrawMode == CGraphicsContext::EDrawModeXOR)

							pixelPtr[0] = (TUint8)(color ^ pixelPtr[0]);

						else if (aDrawMode == CGraphicsContext::EDrawModeAND)

							pixelPtr[0] = (TUint8)((color | 0xf0) & pixelPtr[0]);

						else if (aDrawMode==CGraphicsContext::EDrawModeOR)

							pixelPtr[0] = (TUint8)(color | pixelPtr[0]);

						}

					}

				color = (color == color2) ? color1 : color2;

				if (x & 1)

					pixelPtr++;

				}

			}

		else

			{

			TUint8 bytemask = TUint8((aX & 1) ? 0x0f : 0xf0);

			if (aDrawMode == CGraphicsContext::EDrawModeAND)

				{

				for (TInt x = aX; x < xLimit; x++,dataMask <<= 1,bytemask = (TUint8)~bytemask)

					{