// 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 "glyphimagecache.h"

#include "glyphlutab.h"

#include "vgengine.h"

#include <fbs.h>

//the image of the following size will be pre-allocated for low memory conditions.

const TSize KMaxSizeImageOOM(72, 64);

#ifdef DRAWGLYPH_MULTIPLY_MODE

// Matrix used for converting glyphs with a background colour of black and a character colour

// of white to have a background colour that is fully transparent black and a character colour

// of opaque black. 

const VGfloat KColorMatrix[20] = { 0, 0, 0, 1, // sets alpha of destination to R value of source

				                   0, 0, 0, 0,

				                   0, 0, 0, 0,

				                   0, 0, 0, 0,

				                   1, 1, 1, 0}; // sets RGB of destination to 1

#endif // DRAWGLYPH_MULTIPLY_MODE

//--------------class CFontGlyphTree --------------------

/**

Creates a new instance of the class. Will not be shared across different threads 

@param 	aFontId The unique font identifier.

@param 	aGlyphType The type for the format of a glyph bitmap.

@return The pointer to the CFontGlyphTree class instance.

 */

CFontGlyphTree* CFontGlyphTree::NewL(TUint32 aFontId, TGlyphBitmapType aGlyphType)

	{

	CFontGlyphTree*  self = new (ELeave) CFontGlyphTree(aFontId, aGlyphType);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Constructor for the image font glyph tree

@param 	aFontId The unique font identifier.

@param 	aGlyphType The type for the format of a glyph bitmap.

*/

CFontGlyphTree::CFontGlyphTree(TUint32 aFontId, TGlyphBitmapType aGlyphType) :

	iKey(_FOFF(TGlyphEntry,iGlyphCode),ECmpTUint32),

	iFontId(aFontId),

	iGlyphType(aGlyphType)

	{

	}

/**

Destructor for the image font glyph tree.

Destroys the VGImages, page pool and binary tree. 

*/

CFontGlyphTree::~CFontGlyphTree()

	{

	TRAP_IGNORE(DestroyAllVGImagesL());

	delete iGlyphTree;

	delete iPagePool;

	}

/**

Constructs memory page pool and binary tree. Glyph code will be used as a key.

*/

void CFontGlyphTree::ConstructL()

	{

	iPagePool = CMemPagePool::NewL();

	switch(iGlyphType)

		{

	case EFourColourBlendGlyphBitmap:

		iGlyphTree = new (ELeave) TBtreeFix<TGlyphEntryCompound, TChar> (EBtreeFast);

		((TBtreeFix<TGlyphEntryCompound, TChar> *)iGlyphTree) -> Connect(iPagePool, &iKey);

		break;

	case EMonochromeGlyphBitmap:

	case EAntiAliasedGlyphBitmap:

		iGlyphTree = new (ELeave) TBtreeFix<TGlyphEntry, TChar> (EBtreeFast);

		((TBtreeFix<TGlyphEntry, TChar> *)iGlyphTree) -> Connect(iPagePool, &iKey);

		break;

	default:

		User::Leave(KErrNotSupported);

		break;	

		}

	}

/**

Searches for the image entry in the binary tree. If fails, it will create a new entry.

@param	aGlyphCode General Unicode character value.

@param	aGlyphImage Glyph image	bitmap data. The data structure depends on glyph type.

@param	aGlyphImageSize Size of the glyph image.		

@param	aEntry Binary tree entry, which comprises OpenVG image(s).

@param	aDataForeground Pre-allocated buffer, which will be used for setting text VG image.

@see TGlyphEntryCompound

@see TGlyphEntry

@pre 	Rendering engine has been constructed.

@post 	Requested  OpenVG images are ready for rendering.

@return KErrNone if successful;  

		KErrNotSupported if font type is not supported,  

		otherwise one of the other system-wide error codes.

*/

template <class K>

void CFontGlyphTree::GlyphImageEntryL(TChar aGlyphCode, const TUint8* aGlyphImage, const TSize& aGlyphImageSize, K& aEntry, TUint8* aDataForeground)

	{

	TBtreePos pos;

	TBool found = EFalse;

	found = ((TBtreeFix<K, TChar> *)iGlyphTree) -> FindL(pos, aGlyphCode);

	if(found)

		{

		((TBtreeFix<K, TChar> *)iGlyphTree) -> ExtractAtL(pos, aEntry);

		}

	else

		{

		aEntry.iGlyphCode = aGlyphCode;

		aEntry.iForeground = VG_INVALID_HANDLE;

		TInt glyphSizeInByte = 0;

		switch(iGlyphType)

			{

		case EFourColourBlendGlyphBitmap:

			{

			((TGlyphEntryCompound&) aEntry).iOutline = VG_INVALID_HANDLE;

			((TGlyphEntryCompound&) aEntry).iShadow = VG_INVALID_HANDLE;

			CreateVGImageL(aGlyphImage, aGlyphImageSize, aEntry.iForeground, ((TGlyphEntryCompound&) aEntry).iOutline, ((TGlyphEntryCompound&) aEntry).iShadow, NULL, NULL, NULL);

			glyphSizeInByte = aGlyphImageSize.iWidth * aGlyphImageSize.iHeight;

			glyphSizeInByte *= 3; //foreground, shadow, outline

			break;

			}

		case EMonochromeGlyphBitmap:

			CreateVGImageL(aGlyphImage, aGlyphImageSize, EGray2, aEntry.iForeground, aDataForeground);

			glyphSizeInByte = (((aGlyphImageSize.iWidth + 31) / 32) << 2) * aGlyphImageSize.iHeight;

			break;

		case EAntiAliasedGlyphBitmap:

			CreateVGImageL(aGlyphImage, aGlyphImageSize, EGray256, aEntry.iForeground, NULL);

			glyphSizeInByte = aGlyphImageSize.iWidth * aGlyphImageSize.iHeight;

			break;

		default:

			User::Leave(KErrNotSupported);

			}

		((TBtreeFix<K, TChar> *)iGlyphTree) -> InsertL(pos, aEntry);

		iCacheSize += glyphSizeInByte;	

		}

	}

/**

Overridden function, which creates Open VG images for foreground, background, shadow and outline components of the font.

@param 	aGlyphImage Source bitmap data in 256 grey format. Each pixel value is an index to a constant lookup table. 

			Four entries of this table represent % of Outline, Shadow, Fill and Background colour to be used to get the final colour to be displayed on screen.

@param	aGlyphImageSize Size of the glyph bitmap image.

@param	aForeground Foreground component of the glyph.

@param	aOutline	Outline component of the glyph.

@param	aShadow 	Shadow component of the glyph. 

@param	aPreAllocForeground Pre-allocated buffer which will be used for setting text foreground VG image

@param	aPreAllocOutline Pre-allocated buffer which will be used for setting text outline VG image

@param	aPreAllocShadow Pre-allocated buffer which will be used for setting text shadow VG image

@post 	Requested OpenVG images are ready for rendering. 

*/

void CFontGlyphTree::CreateVGImageL(const TUint8* aGlyphImage, const TSize& aGlyphImageSize, VGImage& aForeground, VGImage& aOutline, VGImage& aShadow, TUint8* aPreAllocForeground, TUint8* aPreAllocOutline, TUint8* aPreAllocShadow)

	{

	TInt dataStride = aGlyphImageSize.iWidth;

	TInt targetByteCount = dataStride * aGlyphImageSize.iHeight;

		// Allocate memory and transform source into target format.

		//

	TAny* foregroundBuffer = NULL;

	TAny* outlineBuffer = NULL;

	TAny* shadowBuffer = NULL;

	TBool destroyTempBuffer = EFalse;

	if(aPreAllocForeground && aPreAllocOutline && aPreAllocShadow && 

			(aGlyphImageSize.iWidth <= KMaxSizeImageOOM.iWidth) && 

			(aGlyphImageSize.iHeight <= KMaxSizeImageOOM.iHeight))

		{

		foregroundBuffer = aPreAllocForeground;

		outlineBuffer = aPreAllocOutline;

		shadowBuffer = aPreAllocShadow;

		}

	else

		{

		foregroundBuffer = User::AllocL(targetByteCount);

		CleanupStack::PushL(foregroundBuffer);

		outlineBuffer = User::AllocL(targetByteCount);

		CleanupStack::PushL(outlineBuffer);

		shadowBuffer = User::AllocL(targetByteCount);

		CleanupStack::PushL(shadowBuffer);

		destroyTempBuffer = ETrue;

		}	

	TUint8* foregroundByte = static_cast <TUint8*> (foregroundBuffer); 

	TUint8* outlineByte = static_cast <TUint8*> (outlineBuffer);

	TUint8* shadowByte = static_cast <TUint8*> (shadowBuffer);

	const TUint8* endByte = (TUint8*)aGlyphImage + targetByteCount;

	TUint8* curSrcGlyphImage = const_cast <TUint8*> (aGlyphImage);

	while (curSrcGlyphImage < endByte)

		{

		*outlineByte++ = FourColorBlendLookup[*curSrcGlyphImage] [KOutlineColorIndex];

		*shadowByte++ = FourColorBlendLookup[*curSrcGlyphImage] [KShadowColorIndex];

		*foregroundByte++ = FourColorBlendLookup[*curSrcGlyphImage] [KFillColorIndex];

		curSrcGlyphImage++;

		}

	const VGImageFormat imageFormat = VG_sL_8;

	if(aForeground == VG_INVALID_HANDLE)

		{

		aForeground = vgCreateImage(imageFormat,

	                              aGlyphImageSize.iWidth, 

	                              aGlyphImageSize.iHeight,

	                              VG_IMAGE_QUALITY_NONANTIALIASED);

		if(aForeground == VG_INVALID_HANDLE)

			{

			User::Leave(KErrNoMemory);

			}

		aOutline = vgCreateImage(imageFormat,

	                              aGlyphImageSize.iWidth, 

	                              aGlyphImageSize.iHeight,

	                              VG_IMAGE_QUALITY_NONANTIALIASED);

		if(aOutline == VG_INVALID_HANDLE)

			{

			DestroyVGImage(&aForeground);

			User::Leave(KErrNoMemory);

			}

		aShadow = vgCreateImage(imageFormat,

	                              aGlyphImageSize.iWidth, 

	                              aGlyphImageSize.iHeight,

	                              VG_IMAGE_QUALITY_NONANTIALIASED);

		if(aShadow == VG_INVALID_HANDLE)

			{

			DestroyVGImage(&aForeground, &aOutline);

			User::Leave(KErrNoMemory);	

			}

		}

	vgImageSubData(

		aForeground, foregroundBuffer, 

		dataStride,	imageFormat, 

		0, 0,aGlyphImageSize.iWidth, aGlyphImageSize.iHeight);

#ifdef DRAWGLYPH_MULTIPLY_MODE

		VGImage image = vgCreateImage(VG_sARGB_8888_PRE, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight, VG_IMAGE_QUALITY_NONANTIALIASED);		

		vgColorMatrix(image, aForeground, KColorMatrix);

		vgDestroyImage(aForeground);

		aForeground = image;

#endif // DRAWGLYPH_MULTIPLY_MODE

	vgImageSubData(

		aOutline, outlineBuffer, 

		dataStride,	imageFormat, 

		0, 0, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight);

#ifdef DRAWGLYPH_MULTIPLY_MODE

		image = vgCreateImage(VG_sARGB_8888_PRE, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight, VG_IMAGE_QUALITY_NONANTIALIASED);		

		vgColorMatrix(image, aOutline, KColorMatrix);

		vgDestroyImage(aOutline);

		aOutline = image;

#endif // DRAWGLYPH_MULTIPLY_MODE

	vgImageSubData(

		aShadow, shadowBuffer, 

		dataStride,	imageFormat, 

		0, 0, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight);

#ifdef DRAWGLYPH_MULTIPLY_MODE

		image = vgCreateImage(VG_sARGB_8888_PRE, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight, VG_IMAGE_QUALITY_NONANTIALIASED);		

		vgColorMatrix(image, aShadow, KColorMatrix);

		vgDestroyImage(aShadow);

		aShadow = image;

#endif // DRAWGLYPH_MULTIPLY_MODE	

	if(destroyTempBuffer)

		{

		CleanupStack::PopAndDestroy(3, foregroundBuffer);

		}

	}

/**

Overridden function, which creates OpenVG images for monochrome and anti-aliased fonts.

@param 	aGlyphImage Data source bitmap in 256 or 2 Grey format. 

@param 	aGlyphImageSize Glyph image data size.

@param 	aDisplayMode Image display mode.

@param	aForeground Foreground component of the glyph.

@param	aPreAllocForeground Pre-allocated buffer which will be used for setting foreground VG image

@post 	Requested OpenVG image is ready for rendering. 

@panic 	Panic if bitmap display mode is not 256 grey or 2 grey.

*/

void CFontGlyphTree::CreateVGImageL(const TUint8* aGlyphImage, const TSize& aGlyphImageSize, TDisplayMode aDisplayMode, VGImage& aForeground, TUint8* aPreAllocForeground)

	{

	GRAPHICS_ASSERT_DEBUG((aDisplayMode == EGray256) || (aDisplayMode == EGray2), EDirectGdiPanicInvalidDisplayMode);

	GRAPHICS_ASSERT_DEBUG(aGlyphImage, EDirectGdiPanicInvalidParameter);

	VGImageFormat imageFormat = VG_IMAGE_FORMAT_INVALID;

	TInt  vgCompatibleSourceStride = 0x00;

	TUint32 binaryDataArray[32];

	TUint8* binaryData = NULL;

	TUint8* tempBuffer = NULL;	

	if(aDisplayMode == EGray256)

		{

		imageFormat = VG_sL_8;

		vgCompatibleSourceStride = aGlyphImageSize.iWidth; 

		binaryData = const_cast <TUint8*> (aGlyphImage);

		}

	else //EGray2

		{

		imageFormat = VG_BW_1;

		vgCompatibleSourceStride = ((aGlyphImageSize.iWidth + 31) / 32) << 2;

		if (aGlyphImageSize.iWidth > 30 || aGlyphImageSize.iHeight > 32)

			{

			binaryData = aPreAllocForeground;

			if(!binaryData)

				{

				tempBuffer = (TUint8*) User::AllocL(vgCompatibleSourceStride * aGlyphImageSize.iHeight);

				CleanupStack::PushL(tempBuffer);

				binaryData = tempBuffer;

				}

			DecodeBinaryDataExLarge(aGlyphImageSize, aGlyphImage, vgCompatibleSourceStride, reinterpret_cast <TUint32*> (binaryData));

			}

		else

			{

			DecodeBinaryData(aGlyphImageSize, aGlyphImage, binaryDataArray);

			binaryData = reinterpret_cast <TUint8*> (binaryDataArray);		

			}

		}

	if(aForeground == VG_INVALID_HANDLE)

		{

		aForeground = vgCreateImage(imageFormat,

                              aGlyphImageSize.iWidth, 

                              aGlyphImageSize.iHeight,

                              VG_IMAGE_QUALITY_NONANTIALIASED);

		}

	if (aForeground != VG_INVALID_HANDLE)

		{

			// Copy from the source image to our new VGImage

		vgImageSubData(aForeground, binaryData, vgCompatibleSourceStride,	imageFormat, 

			0,	0, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight);

#ifdef DRAWGLYPH_MULTIPLY_MODE

		VGImage image = vgCreateImage(VG_sARGB_8888_PRE, aGlyphImageSize.iWidth, aGlyphImageSize.iHeight, VG_IMAGE_QUALITY_NONANTIALIASED);		

		vgColorMatrix(image, aForeground, KColorMatrix);

		vgDestroyImage(aForeground);

		aForeground = image;

#endif

		}

	else

		{

		if(tempBuffer)

			{

			CleanupStack::PopAndDestroy(tempBuffer);	

			}

		User::Leave(KErrNoMemory);

		}

	if(tempBuffer)

		{

		CleanupStack::PopAndDestroy(tempBuffer);	

		}

	}

/**

Decodes binary data for monochrome bitmap.

@param aDataSize Image size.

@param aData Pointer to a source buffer.

@param aBinaryData Pointer to a destination buffer.

*/

void CFontGlyphTree::DecodeBinaryData(const TSize& aDataSize,

								const TUint8* aData,

								TUint32* aBinaryData) 

	{

	//Divert if the character is larger than expected; the criterion

	//for choosing this function is only a heuristic, because it's perfectly legal for

	//a character's bitmap to be wider than its escapement.

	//

	//Use a dummy value (0) for semi-ascent because this character is not italic and so semi-ascent

	//is irrelevant; it's used for pseudo-italic slanting.

	TInt dataheight = aDataSize.iHeight;

	TInt datalength = aDataSize.iWidth;

	TInt bitindex=0;

	TInt16 repeatcount=0;

	TUint32* binarydataptr=aBinaryData;

	TUint32* binarydataptrlimit;

	for(TInt charline=0;charline<dataheight;charline+=repeatcount) // for lines in the character...

		{

		repeatcount=Load16(aData+(bitindex>>3));

		repeatcount>>=bitindex&7;

		TInt multilineflag=repeatcount&1;

		repeatcount>>=1;

		repeatcount&=0xf;

		bitindex+=5;

		binarydataptrlimit=aBinaryData+charline+repeatcount;

		if(multilineflag)

			{

			while(binarydataptr<binarydataptrlimit)

				{

				TInt chardataoffsetptr=TInt(aData)+(bitindex>>3);

				TUint32* chardataword=(TUint32*)(chardataoffsetptr&~3);

				TInt bitshift=bitindex&7;

				bitshift+=(chardataoffsetptr&3)<<3;

				*binarydataptr=(*chardataword++)>>bitshift;

				if(bitshift) *binarydataptr|=(*chardataword<<(32-bitshift));

				bitindex+=datalength;

				binarydataptr++;

				}

			}

		else

			{

			TInt chardataoffsetptr=TInt(aData)+(bitindex>>3);

			TUint32* chardataword=(TUint32*)(chardataoffsetptr&~3);

			TInt bitshift=bitindex&7;

			bitshift+=(chardataoffsetptr&3)<<3;

			TUint32 data=(*chardataword++)>>bitshift;

			if(bitshift) data|=(*chardataword<<(32-bitshift));

			while(binarydataptr<binarydataptrlimit)

				*binarydataptr++=data;

			bitindex+=datalength;

			}

		}

	}

/**

Decodes binary data for extra large monochrome bitmap.

@param aDataSize Image size.

@param aData Pointer to a source buffer.

@param aStride Image data stride.

@param aBinaryData Pointer to a destination buffer.

*/

void CFontGlyphTree::DecodeBinaryDataExLarge(const TSize& aDataSize, const TUint8* aData, TInt aStride,

											TUint32* aBinaryData)

	{

	const TInt datalength = aDataSize.iWidth;

	const TInt dataheight = aDataSize.iHeight;

	TInt bitindex=0;

	TInt16 repeatcount=0;

	TUint32* slbuffer=aBinaryData;

	const TInt slwords=aStride;

	for(TInt charline=0;charline<dataheight;charline+=repeatcount) // for lines in the character...

		{

		repeatcount=Load16(aData+(bitindex>>3));

		repeatcount>>=bitindex&7;

		const TInt multilineflag=repeatcount&1;

		repeatcount>>=1;

		repeatcount&=0xf;

		bitindex+=5;

		if(multilineflag)

			{

			for(TInt currentline=0;currentline<repeatcount;currentline++)

				{

				CopyCharLine(slbuffer,slwords,aData+(bitindex>>3),bitindex&7,datalength, 1);

				bitindex+=datalength;

				}

			}

		else

			{

			CopyCharLine(slbuffer,slwords,aData+(bitindex>>3),bitindex&7,datalength, repeatcount);

			bitindex+=datalength;

			}

		}

	}

/**

Copies image data line(s) to a destination.

@param aBinaryDataPtr pointer to a destination buffer.

@param aBufferWords Stride of the image.

@param aData Pointer to a source buffer.

@param aBitShift Number of bits, binary data will be shifted. 

@param aCharWidth Width of the image.

@param aRepeatCount Number of lines to copy.

@panic DGDIAdapter 1018, if a null binary data pointer is passed in.

*/

void CFontGlyphTree::CopyCharLine(TUint32*& aBinaryDataPtr,TInt aBufferWords,const TUint8* aData,TInt aBitShift,TInt aCharWidth, TInt16 aRepeatCount)

	{

	GRAPHICS_ASSERT_DEBUG(aBinaryDataPtr, EDirectGdiPanicInvalidPointer);//this shouldn't happen, as we always allocate memory prior to call this function 

	aBitShift&=7;

	TInt wordstocopy=(aCharWidth+31)>>5;

	if(wordstocopy>aBufferWords) wordstocopy=aBufferWords;

	TUint32* ptrlimit=aBinaryDataPtr+wordstocopy;

	TUint32* dataword=(TUint32*)(TInt(aData)&~3);

	aBitShift+=(TInt(aData)-TInt(dataword))<<3;

	TUint32* startBinaryDataPtr = aBinaryDataPtr;

	while(aBinaryDataPtr<ptrlimit)

		{

		*aBinaryDataPtr=*dataword++;

		*aBinaryDataPtr>>=aBitShift;

		if(aBitShift) *aBinaryDataPtr|=(*dataword<<(32-aBitShift));

		aBinaryDataPtr++;

		}

	TUint32* curStartBinaryDataPtr = aBinaryDataPtr;

	TInt byteToCopy = wordstocopy << 2;

	while(aRepeatCount > 1)

		{

		Mem::Copy(curStartBinaryDataPtr, startBinaryDataPtr, byteToCopy);

		curStartBinaryDataPtr += wordstocopy;

		aRepeatCount--;