// Copyright (c) 2009-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:

//

/**

 @file

 @internalComponent - Internal Symbian test code

*/

#include <EGL/egl.h>

#include <VG/openvg.h>

#include <graphics/fbsglyphmetricsarray.h> 

#include <graphics/fbsglyphdataiterator.h>

#include <sgresource/sgimage.h>

#include <sgresource/sgdriver_test.h>

#include <sgresource/sgdriver_profiling.h>

#include "FbsMessage.h"

#include "tfbsglyphdata.h"

_LIT(KTypefaceName, "DejaVu Sans Condensed");

//_LIT(KMonoTypefaceName, "DejaVu Sans Mono");

const TInt KNumGlyphCodesLatin = 96;

const TUint KDejaVuInvalidGlyphCode = 0;

// Currently only used in debug. When TestMultithreadStressAtlas() test is enabled, #ifdef to be removed. 

#ifdef _DEBUG

const TInt KTestThreadMinHeapSize = 0x20000;

const TInt KTestThreadMaxHeapSize = 0x20000;

#endif

// 'most significant bit' flag to ensure value is interpreted as a glyph code rather than an ascii code

const TUint KGlyphCodeFlag = 0x80000000;      

// Please note the following macros which enable helper functions, and are declared in the header.

// SAVEGLYPHSTOMBMDURINGCOMPARISON and

// SAVEGLYPHSTOMBMDEBUGFUNCTION

/*

Lookup table to convert from ascii code to

glyph code for the Deja Vu family of fonts.

 */

const TUint DejaVuASCIIToGlyphCode[] = 

	{

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

	0, 0, 3, 4, 5, 6, 7, 8, 9, 10,

	11, 12, 13, 14, 15, 16, 17, 18, 19, 20,

	21, 22, 23, 24, 25, 26, 27, 28, 29, 30,

	31, 32, 33, 34, 35, 36, 37, 38, 39, 40,

	41, 42, 43, 44, 45, 46, 47, 48, 49, 50,

	51, 52, 53, 54, 55, 56, 57, 58, 59, 60,

	61, 62, 63, 64, 65, 66, 67, 68, 69, 70,

	71, 72, 73, 74, 75, 76, 77, 78, 79, 80,

	81, 82, 83, 84, 85, 86, 87, 88, 89, 90,

	91, 92, 93, 94, 95, 96, 97, 98,

	};

// Utility function declations - utilities used by the tests

static TFontSpec GenerateDejaVuFontSpec(TInt aSeed);

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

static void DecodeBinaryData(const TSize& aDataSize, const TUint8* aData, TInt aStride,	TUint32* aBinaryData);

static TInt CreateSgImageFromCharacterData(const TUint8* aData, const TSize& aSize, TGlyphBitmapType aType, RSgImage& aImage);

static TInt CreateSgImageFromCharacterData(const TUint8* aData, const TSize& aSize, TGlyphBitmapType aType, RSgImage& aImage, TUint8* aBuffer1, TUint8* aBuffer2);

// Following functions commented out because the tests which use these functions 

// are currently commented out due to Broadcom defect 

// ESLM-85LDV7 - TB10.1 Closing of RSgImage with duplicate handle used in same thread does not release GPU RAM

//static TInt FillGraphicsMemoryWithImages(const TSize& aSize, RArray<RSgImage>& aImages);

//static TInt NearlyFillGraphicsMemoryWithImages(const TSize& aSize, RArray<RSgImage>& aImages);

#if defined (SAVEGLYPHSTOMBMDEBUGFUNCTION) || defined (SAVEGLYPHSTOMBMDURINGCOMPARISON)

/**

Static utility function. Converts an A8 RSgImage into a CFbsBitmap.

To do this, the RSgImage is converted to an EGLImage, then to a VGImage,

where the image memory is read into a CFbsBitmap.

@param aEGL The EGL helper object that will read the SgImage into a memory buffer.

@param aSgImage The RSgImage to convert.

@param aRect A rectangular region of the RSgImage to convert.

@param aBitmap On success, holds a pointer to a CFbsBitmap which contains the image

	data of the RSgImage.

@return One of the system-wide error codes.

*/

static TInt CreateBitmapFromSgImage(CEGLHelper* aEGL, const RSgImage& aSgImage, const TRect& aRect, CFbsBitmap*& aBitmap)

	{

	TInt err = KErrNone;

	const TSize bufferSize = aRect.Size();

	const TInt dataStride = bufferSize.iWidth;

	TUint8* imageBuffer = reinterpret_cast<TUint8*>(User::AllocZ(bufferSize.iHeight * dataStride));

	if (!imageBuffer)

		{

		return KErrNoMemory;

		}

	err = aEGL->GetSgImageData(aSgImage, aRect, imageBuffer);

	if (err != KErrNone)

		{

		User::Free(imageBuffer);

		return err;

		}

	aBitmap = new CFbsBitmap();

	if (!aBitmap)

		{

		User::Free(imageBuffer);

		return KErrNoMemory;

		}

	err = aBitmap->Create(bufferSize, EGray256);

	if (KErrNone == err)

		{

		TUint8* buf = imageBuffer;

		aBitmap->BeginDataAccess();

		TUint8* dataAddress = reinterpret_cast<TUint8*>(aBitmap->DataAddress());

		const TInt dataStride = aBitmap->DataStride();	

		for (TInt scanline = 0; scanline < bufferSize.iHeight; scanline++)

			{

			Mem::Copy(dataAddress, buf, bufferSize.iWidth);

			dataAddress += dataStride;

			buf += bufferSize.iWidth;

			}

		aBitmap->EndDataAccess(EFalse);

		}

	else

		{

		delete aBitmap;

		aBitmap = NULL;

		}

	User::Free(imageBuffer);

	return err;

	}

/**

Utility function to aid with debugging.

Saves a bitmap to file.

@param aBmp Bitmap to save

@param aMeta Optional. If specified, it is added to the name of the bitmap file.

@param aRef Flag to show whether bitmap is a reference bitmap (ETrue) or test bitmap (EFalse).

*/

static void SaveBmp(CFbsBitmap* aBmp, TPtrC* aMeta, TBool aRef)

	{

	if (!aBmp)

		{

		return;

		}

	TBuf<256> testFileName;

	if (aRef)

		{

		testFileName.Append(_L("Ref"));

		}

	else

		{

		testFileName.Append(_L("Test"));

		}

	if (aMeta)

		{

		testFileName.Append(*aMeta);

		}

	TFileName mbmFile;

	TBuf<20> testPathName;

	#ifdef __WINS__

		testPathName.Append(_L("c:\\%S.mbm"));

	#else

		testPathName.Append(_L("e:\\%S.mbm"));

	#endif

	mbmFile.Format(testPathName, &testFileName);

	// As this is for debugging purposes only, doesn't matter reporting whether

	// saving succeeded or not.

	aBmp->Save(mbmFile);

	}

#endif // SAVEGLYPHSTOMBMDEBUGFUNCTION OR SAVEGLYPHSTOMBMDURINGCOMPARISON

#ifdef SAVEGLYPHSTOMBMDEBUGFUNCTION

void CTFbsGlyphData::SaveRSgImagesAsMbms(CEGLHelper* aEGL, const RSgImage& aImageA, const TRect& aRectA, const RSgImage& aImageB, const TRect& aRectB )

	{

	static TInt countToAppend = 0;

	CFbsBitmap* bitmap = NULL;

	if (KErrNone == CreateBitmapFromSgImage(aEGL, aImageA, aRectA, bitmap))

		{

		TBuf<KMaxFileName> buf( _L("String") );

		buf.AppendNum( countToAppend );

		TPtrC nameAppend( buf );

		SaveBmp(bitmap, &nameAppend, EFalse);

		}

	delete bitmap;  

	bitmap = NULL;

	if (KErrNone == CreateBitmapFromSgImage(aEGL, aImageB, aRectB, bitmap))

		{

		TBuf<KMaxFileName> buf( _L("String") );

		buf.AppendNum( countToAppend );

		TPtrC nameAppend( buf );

		SaveBmp(bitmap, &nameAppend, ETrue);

		}

	delete bitmap;

	bitmap = NULL;

	countToAppend++;

	}

/**

Static debug utility method that outputs the glyph images of the given glyph

codes for the given font to a file.

 */

static void DumpFontGlyphs(CEGLHelper* aEGL, CFont* aFont, TInt aCodesCount)

	{

	TFontSpec fontSpec = aFont->FontSpecInTwips();

	TOpenFontCharMetrics charMetrics;

	TSize bitmapSize;

	const TUint8* bitmapData = NULL;

	for (TInt glyphCode = 0; glyphCode < aCodesCount; glyphCode++)

		{

		CFont::TCharacterDataAvailability availability = aFont->GetCharacterData(glyphCode | KGlyphCodeFlag, charMetrics, bitmapData, bitmapSize);

		if (availability == CFont::EAllCharacterData)

			{

			RSgImage characterDataImage;

			TInt err = CreateSgImageFromCharacterData(bitmapData, bitmapSize, fontSpec.iFontStyle.BitmapType(), characterDataImage);

			if (err == KErrNone)

				{

				CFbsBitmap* bitmap = NULL;

				err = CreateBitmapFromSgImage(aEGL, characterDataImage, TRect(TPoint(0, 0), bitmapSize), bitmap);

				if (err == KErrNone)

					{

					TBuf<256> bitmapName;

					bitmapName.AppendFormat(_L("%S-%i"), &(fontSpec.iTypeface.Name()), glyphCode);

					TPtrC bitmapNamePtr(bitmapName);

					SaveBmp(bitmap, &bitmapNamePtr, EFalse);

					delete bitmap;

					}

				}

			characterDataImage.Close();

			}

		}

	}

#endif // SAVEGLYPHSTOMBMDEBUGFUNCTION

/**

Utility to return a fontspec such that the font created from it will

not match any other font generated by a different seed. The font

will be useable by RFbsGlyphDataIterator and RFbsGlyphMetricsArray.

It will always return a font based on the DejaVu fontspec, this is 

so that the glyphcodes in DejaVuASCIIToGlyphCode are guaranteed to

work.

@param aSeed Specifies a variant of the fontspec to create. Passing the

	same seed will cause the same TFontSpec to be returned.

@return The generated fontspec. 

 */

static TFontSpec GenerateDejaVuFontSpec(TInt aSeed)

	{

	const TInt KFontHeightStep = 4;

	const TInt KFontInitialHeight = 8;

	const TInt KNumFontTypefaces = 3;

	const TInt KNumFontBitmapTypes = 2;

	const TInt KNumFontStyles = 4;

	TInt fontBitmapTypeVariant = aSeed % KNumFontBitmapTypes;

	TInt fontStyleVariant = (aSeed / KNumFontBitmapTypes) % KNumFontStyles;

	TInt fontTypefaceVariant = (aSeed / ( KNumFontStyles * KNumFontBitmapTypes)) % KNumFontTypefaces;

	TInt fontHeightVariant = aSeed / (KNumFontStyles * KNumFontTypefaces * KNumFontBitmapTypes);

	TFontSpec fontSpec;	

	fontSpec.iHeight = KFontInitialHeight + (fontHeightVariant * KFontHeightStep);

	// Set the typeface name

	// Set the style.

	switch (fontStyleVariant)

		{

		case 1: // italic

			fontSpec.iFontStyle.SetPosture(EPostureItalic);

			fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

			break;

		case 2: // bold

			fontSpec.iFontStyle.SetPosture(EPostureUpright);

			fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

			break;

		case 3: // bold italic

			fontSpec.iFontStyle.SetPosture(EPostureItalic);

			fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);

			break;

		default: // normal 

			fontSpec.iFontStyle.SetPosture(EPostureUpright);

			fontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightNormal);

			break;

		}

	switch (fontTypefaceVariant)

		{

		case 1:

			fontSpec.iTypeface.SetName(_L("DejaVu Sans Mono"));

			break;

		case 2:

			fontSpec.iTypeface.SetName(_L("DejaVu Serif Condensed"));

			break;

		case 3:

			fontSpec.iTypeface.SetName(_L("DejaVu Sans Condensed"));

			break;

		}

	switch(fontBitmapTypeVariant)

		{

		case 1:

			fontSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap);

			break;

		default:

			fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);

			break;

		}

	return fontSpec;

	}

/**

 * 

 EGL helper class to retrieve image data from an SgImage into a memory buffer.

 */

CEGLHelper::CEGLHelper() :

	iDisplay(EGL_NO_DISPLAY),

	iContext(EGL_NO_CONTEXT),

	iSurface(EGL_NO_SURFACE)

	{

	}

CEGLHelper::~CEGLHelper()

	{

	iMutex.Close();

	eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

	eglDestroyContext(iDisplay, iContext);

	eglDestroySurface(iDisplay, iSurface);

	eglTerminate(iDisplay);

	eglReleaseThread();

	iSgDriver.Close();

	}

/**

Factory method to create CEGLHelper.

@return A pointer to an instance of CEGLHelper.

 */

CEGLHelper* CEGLHelper::NewL()

	{

	CEGLHelper* self = new CEGLHelper();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(1); // self

	return self;

	}

/**

Opens handle to the process-wide synchronisation semaphore,

loads EGL and VG extension function pointers,

sets up EGL resources so that EGLImages can be constructed. 

 */

void CEGLHelper::ConstructL()

	{

	_LIT(KEGLMutex, "TFbsGlyphDataEGLMutex");

	User::LeaveIfError(iMutex.CreateGlobal(KEGLMutex, EOwnerProcess));

	User::LeaveIfError(iSgDriver.Open());

	iDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

	if (iDisplay == EGL_NO_DISPLAY)

		{

		User::Leave(KErrNotSupported);

		}

	if (EGL_TRUE != eglInitialize(iDisplay, NULL, NULL))

		{

		User::Leave(KErrNotSupported);

		}

	eglBindAPI(EGL_OPENVG_API);

	// Load the necessary EGL extensions...

	eglCreateImageKHR = reinterpret_cast<PFNEGLCREATEIMAGEKHRPROC>(eglGetProcAddress("eglCreateImageKHR"));

	eglDestroyImageKHR = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(eglGetProcAddress("eglDestroyImageKHR"));

	vgCreateImageTargetKHR = reinterpret_cast<TvgCreateEGLImageTargetKHRTypefPtr>(eglGetProcAddress("vgCreateEGLImageTargetKHR"));

	if (!eglCreateImageKHR || !eglDestroyImageKHR || !vgCreateImageTargetKHR)

		{

		User::Leave(KErrExtensionNotSupported);

		}

	// In order to create VGImages from EGLImages, a context must be current.

	// Therefore create an EGLContext and EGLSurface to make current, using

	// a dummy RSgImage.

	RSgImage dummySurface;

	TSgImageInfo dummySurfaceInfo(TSize(1, 1), ESgPixelFormatRGB_565, ESgUsageBitOpenVgSurface);

	User::LeaveIfError(dummySurface.Create(dummySurfaceInfo, NULL, 0));

	CleanupClosePushL(dummySurface);

	EGLint configAttribs[] = 

		{

		EGL_MATCH_NATIVE_PIXMAP, (EGLint)&dummySurface,

		EGL_RENDERABLE_TYPE, EGL_OPENVG_BIT,

		EGL_NONE

		};

	EGLint configId = 0;

	EGLint numConfigs = 0;

	if (EGL_FALSE == eglChooseConfig(iDisplay, configAttribs, &configId, 1, &numConfigs) || numConfigs == 0)

		{

		User::Leave(KErrGeneral);

		}

	iContext = eglCreateContext(iDisplay, configId, EGL_NO_CONTEXT, NULL);

	if (iContext == EGL_NO_CONTEXT)

		{

		User::Leave(KErrGeneral);

		}

	iSurface = eglCreatePixmapSurface(iDisplay, configId, &dummySurface, NULL);

	if (iSurface == EGL_NO_SURFACE)

		{

		User::Leave(KErrGeneral);

		}

	CleanupStack::PopAndDestroy(1); // dummySurface

	}

/**

Retrieves the data from an A8 RSgImage into a buffer.

To do this, the RSgImage is converted to an EGLImage, then to a VGImage,

where the image memory is read into the given buffer.

The function can be called from multiple threads and synchronisation

with EGL is controlled via a mutex.

@param aSgImage The RSgImage to convert.

@param aRect A rectangular region of the RSgImage to convert.

@param aBuf On success, contains the image data of the RSgImage.

@return One of the system-wide error codes.

 */

TInt CEGLHelper::GetSgImageData(const RSgImage& aSgImage, const TRect& aRect, TUint8*& aBuf)

	{

	const TSize bufferSize = aRect.Size();

	const TInt dataStride = bufferSize.iWidth;

	if (bufferSize == TSize(0,0))

		{

		return KErrNone;

		}

	iMutex.Wait();

	TInt err = KErrNone;

	EGLImageKHR eglImage;

	if (EGL_FALSE == eglBindAPI(EGL_OPENVG_API))

		{

		err = KErrGeneral;

		}

	else if (EGL_FALSE == eglMakeCurrent(iDisplay, iSurface, iSurface, iContext))

		{

		err = KErrGeneral;

		}

	else

		{

		// Create EGLImages from the RSgImage.

		EGLint imageAttribs[] =

			{

			EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, 

			EGL_NONE

			};

		eglImage = eglCreateImageKHR(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<EGLClientBuffer>(&aSgImage), imageAttribs);

		if (eglImage == EGL_NO_IMAGE_KHR)

			{

			err = KErrArgument;

			}

		}

	if (err == KErrNone)

		{

		// Create VGImages from the EGLImage.

		VGImage vgImage = vgCreateImageTargetKHR(eglImage);

		eglDestroyImageKHR(iDisplay, eglImage);

		if (vgImage == VG_INVALID_HANDLE)

			{

			err = KErrArgument;

			}

		else

			{

			// Get the image data in 8bpp format

			vgGetImageSubData(vgImage, aBuf, dataStride, VG_A_8, aRect.iTl.iX, aRect.iTl.iY, bufferSize.iWidth, bufferSize.iHeight);

			vgDestroyImage(vgImage);

			}

		}

	eglReleaseThread();

	iMutex.Signal();

	return err;

	}

CTFbsGlyphData::CTFbsGlyphData(CTestStep* aStep):

	CTGraphicsBase(aStep)

	{

	}

void CTFbsGlyphData::ConstructL()

	{

	User::LeaveIfError(Logger().ShareAuto());

	User::LeaveIfError(RFbsSession::Connect());

	iFbs = RFbsSession::GetSession();

	iTs = (CFbsTypefaceStore*)CFbsTypefaceStore::NewL(NULL);

	User::LeaveIfError(iTs->GetNearestFontToDesignHeightInPixels((CFont*&)iFont, TFontSpec(KTypefaceName, 15)));

	User::LeaveIfError(iTs->GetNearestFontToDesignHeightInPixels((CFont*&)iFont2, TFontSpec(KTypefaceName, 8)));

	iGlyphCodesLatin = new(ELeave) TUint[KNumGlyphCodesLatin];

	for (TInt ii = 0; ii < KNumGlyphCodesLatin; ++ii)

		{

		TUint asciiCode = ii+0x20; // ASCII characters from 0020 to 007F

		iGlyphCodesLatin[ii] = DejaVuASCIIToGlyphCode[asciiCode];

		}

	User::LeaveIfError(iSgDriver.Open());

	iEGL = CEGLHelper::NewL();

	// Creating a CFbsBitmap will force the RFbsSession to allocate a scanline buffer

	// now rather than in the middle of a test, thus avoiding heap check failure. 

	CFbsBitmap* dummyBitmap = new (ELeave) CFbsBitmap;