// Copyright (c) 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 <e32atomics.h>

#include <e32debug.h>

#include <graphics/guestvideodriver.h>

#include "vghwutils.h"

#include "eglrfc.h"

#include "openvgrfc.h"

#include "opengles11rfc.h"

#ifdef _DEBUG

#define EGL_ERROR_PRINT(T, E)  EglErrorPrint(T, E)

#define GLES_ERROR_PRINT(T, E) GlesErrorPrint(T, E)

#define VG_ERROR_PRINT(T, E)   VgErrorPrint(T, E)

static void EglErrorPrint(char* aTitle, EGLint aEglError);

static void GlesErrorPrint(char* aTitle, GLenum aGlesError);

static void VgErrorPrint(char* aTitle, VGErrorCode aVgError);

#else

#define EGL_ERROR_PRINT(T, E)

#define GLES_ERROR_PRINT(T, E)

#define VG_ERROR_PRINT(T, E)

#endif

// Min & Max sizes for creating Memory Heap for Guest Graphics DLLs

#define KVghwHeapMin 0x1000

#define KVghwHeapMax 0x100000

// protection against concurrent initialisation from multiple threads

volatile TBool       CVghwUtils::iInitialized = EFalse;

TInt                 CVghwUtils::iVghwInitMutex = 0;

// static member objects - Writeable Static Data

RGuestVideoDriver* CVghwUtils::iDriver = NULL;

RHeap*               CVghwUtils::iHeap = NULL;

MEglManagementApi*   CVghwUtils::iEglManagementApi = NULL;

MVgApiForEgl*        CVghwUtils::iVgApiForEgl = NULL;

MGles11ApiForEgl*    CVghwUtils::iGles11ApiForEgl = NULL;

MGles2ApiForEgl*     CVghwUtils::iGles2ApiForEgl = NULL;

TBool                CVghwUtils::iLoadedOpenVgDll = EFalse;

TBool                CVghwUtils::iLoadedOpenGles11Dll = EFalse;

TBool                CVghwUtils::iLoadedOpenGles2Dll = EFalse;	

_LIT(KVghwPanicCategory, "Guest VGHW");

// NOTE: Exported because some VGHW functions are inline and could Assert & Panic from somewhere else

EXPORT_C void VghwPanic(TVghwPanic aPanicCode, char* aPanicName, char* aCondition, char* aFile, TInt aLine)

	{

	if (aCondition && aFile)

		{

		RDebug::Printf("VghwUtils Panic %s for failed Assert (%s), at %s:%d", aPanicName, aCondition, aFile, aLine);

		}

	else

		{  

		RDebug::Printf("VghwUtils Panic %d for failed Assert (line %d)", aPanicCode, aLine);

		}

	User::Panic(KVghwPanicCategory, aPanicCode);

	}

// inline functions

RGuestVideoDriver& CVghwUtils::Driver()

	{

	// TODO remove this later in refactoring - Open VG & GL ES commands should not reach here before EGL has initialized the singleton

	if (!iInitialized || !iDriver)

		{

		UTIL_TRACE("CVghwUtils::Driver called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iInitialized && iDriver, EVghwPanicGraphicsDriverNotOpen);

	return *iDriver;

	}

EXPORT_C void CVghwUtils::DestroyStatics()

	{

#ifdef _DEBUG

	TUint64 processId = RProcess().Id().Id();

	TUint64 threadId = RThread().Id().Id();

	UTIL_TRACE("CVghwUtils::DestroyStatics iInitialized=%d, iDriver=0x%x, iHeap=0x%x, Process=0x%lx, Thread=0x%lx",

		iInitialized, iDriver, iHeap, processId, threadId);

#endif

	if (iHeap)

		{

		if (iDriver)

			{

			iDriver->Flush();

			iDriver->Close();

			RHeap* threadHeap = SwitchToVghwHeap();

			delete iDriver;

			SwitchFromVghwHeap(threadHeap);

			iDriver = NULL;

			}

		iHeap->Reset();

		iHeap->Close();

		iHeap = NULL;

		}

	if (iInitialized)

		{

		iInitialized = EFalse;

		}

	}

// Ensure Graphics memory heap is created, and Open driver channel

EXPORT_C void CVghwUtils::InitStatics()

	{

#ifdef _DEBUG

	TUint64 processId = RProcess().Id().Id();

	TUint64 threadId = RThread().Id().Id();

	UTIL_TRACE("CVghwUtils::InitStatics start Process=0x%lx, Thread=0x%lx, iInitialized=%d",

		processId, threadId, iInitialized);

#endif

	// bootstrap creation of mutexes and Graphics memory heap

	while (!iInitialized)

		{

		TInt creationError = KErrNone;

		// thread safe initialization

		// LockedDec() returns the value prior to decrement

		if (0 != User::LockedDec(iVghwInitMutex))

			{

			User::AfterHighRes(1000);     // Yield X microseconds, review length if code is changed

			}

		else

			{

			// volatile attribute forces rereading of the pointer, in case another thread has done the allocation

			if (!iInitialized)

				{ // loop style init exits if any stage fails, and gives per step debug logging

				TInt step = 0;

				do

					{

					switch (step)

						{

						case 0:

							// guarantee that initialisation of the object is flushed before the pointer is published

							__e32_atomic_store_rel_ptr(&iHeap, User::ChunkHeap(NULL, KVghwHeapMin, KVghwHeapMax));

							if (!iHeap)

								{

								creationError = KErrNoMemory;

								}

							break;

						case 1:

							{

							VGHWPANIC_ASSERT_DEBUG(iHeap, EVghwPanicVghwHeapDoesNotExist);

							RHeap* threadHeap = User::SwitchHeap(iHeap); // switch to VGHW graphics Heap

							iDriver = new RGuestVideoDriver();

							if (!iDriver)

								{

								creationError = KErrNoMemory;

								}

							User::SwitchHeap(threadHeap); // switch back to client Heap

							}

							break;

						case 2:

							creationError = User::LoadLogicalDevice(_L("guestvideohw"));

							if ( (KErrNone == creationError) || (KErrAlreadyExists == creationError) )

								{

								creationError = iDriver->Open();

								}

							break;

						default: // all initialisation steps completed

							iInitialized = ETrue;

						}

					++step;

					}

				while (!iInitialized && !creationError);

				UTIL_TRACE("CVghwUtils::InitStatics %s step=%d; creationError=%d, iInitialized=%d, iDriver=0x%x, iHeap=0x%x",

						creationError ? "failed at" : "completed", step, creationError, iInitialized, iDriver, iHeap);

				}

			}

		User::LockedInc(iVghwInitMutex);

		VGHWPANIC_ASSERT(creationError == KErrNone, EVghwPanicInitializeFailed);

		}

	}

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

//

EXPORT_C void CVghwUtils::DriverExecuteCommand(RemoteFunctionCallData& aRequestData)

	{

	if (!iInitialized || !iDriver)

		{

		UTIL_TRACE("CVghwUtils::DriverExecuteCommand called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iInitialized && iDriver, EVghwPanicGraphicsDriverNotOpen);

	iDriver->ExecuteCommand(aRequestData);

	}

// -----------------------------------------------------------------------------

// Use driver to discover linear memory address of chunk.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CVghwUtils::MapToHWAddress( const TInt aChunkHandle, TUint32& aHWAddress )

	{

	UTIL_TRACE("CVghwUtils::MapToHWAddress");

	return Driver().MapToHWAddress( aChunkHandle, aHWAddress );

	}

// SgImage support function - get underlying VGImage & Pbuffer handles

EXPORT_C TInt CVghwUtils::EglGetSgHandles( const TUint64 aId, TUint64 *aSgHandles )

	{

	UTIL_TRACE("CVghwUtils::EglGetSgHandles");

	return Driver().EglGetSgHandles( aId, aSgHandles );

	}

// Memory Heap Management functions

EXPORT_C TAny* CVghwUtils::Alloc(TInt aSize)

	{

	if (!iInitialized || !iHeap)

		{

		UTIL_TRACE("CVghwUtils::Alloc called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iInitialized && iHeap, EVghwPanicVghwHeapDoesNotExist);

	return iHeap->Alloc(aSize);

	}

EXPORT_C void CVghwUtils::Free(TAny* aPtr)

	{

	if (!iInitialized || !iHeap)

		{

		UTIL_TRACE("CVghwUtils::Free called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iInitialized && iHeap, EVghwPanicVghwHeapDoesNotExist);

	iHeap->Free(aPtr);

	}

EXPORT_C RHeap* CVghwUtils::GetHeap()

	{

	if (!iInitialized || !iHeap)

		{

		UTIL_TRACE("CVghwUtils::GetHeap called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iInitialized && iHeap, EVghwPanicVghwHeapDoesNotExist);

	return iHeap;

	}

// Switch to VGHW Memory Heap.

EXPORT_C RHeap* CVghwUtils::SwitchToVghwHeap()

	{

	if (!iInitialized || !iHeap)

		{

		UTIL_TRACE("CVghwUtils::SwitchToVghwHeap called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iHeap, EVghwPanicVghwHeapDoesNotExist);

	RHeap* oldHeap = User::SwitchHeap(iHeap); // switch to Guest graphics heap

	VGHWPANIC_ASSERT(oldHeap != iHeap, EVghwPanicSwitchToVghwHeapOldHeapIsVghwHeap);

	return oldHeap;

	}

// Switch back to original heap 

EXPORT_C void CVghwUtils::SwitchFromVghwHeap(RHeap* aOldHeapPtr)

	{

	if (!iInitialized || !iHeap)

		{

		UTIL_TRACE("CVghwUtils::SwitchFromVghwHeap called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);

		InitStatics();

		}

	VGHWPANIC_ASSERT(iHeap, EVghwPanicVghwHeapDoesNotExist);

	VGHWPANIC_ASSERT(aOldHeapPtr, EVghwPanicSwitchFromVghwHeapParamIsNull);

	VGHWPANIC_ASSERT(aOldHeapPtr != iHeap, EVghwPanicSwitchFromVghwHeapParamIsVghwHeap);

	RHeap* oldHeap = User::SwitchHeap(aOldHeapPtr); // switch from Guest graphics heap back to thread heap

	VGHWPANIC_ASSERT(oldHeap == iHeap, EVghwPanicSwitchFromVghwHeapOldHeapIsNotVghwHeap);

	}

// if this thread does not have an object try to alloc a new one

EXPORT_C TEglThreadState* CVghwUtils::CreateThreadState()

	{

	TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());

	if (!threadState)

		{

		UTIL_TRACE("CVghwUtils::CreateThreadState - object is currently 0x%x, iInitialized=%d",

				threadState, iInitialized);

		if (!iInitialized)

			{

			InitStatics();

			}

		threadState = TEglThreadState::New();

		Dll::SetTls(threadState);

		}

	return threadState;

	}

// current state object, if any, for this thread

EXPORT_C TEglThreadState* CVghwUtils::EglThreadState()

	{

	TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());

	return threadState;

	}

// current state object, if Open VG is the current bound API, for this thread 

EXPORT_C MVgContext* CVghwUtils::VgContext()

	{

	TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());

	return threadState;

	// ToDo sort this to check for valid Open VG context

	/*

	if (threadState && threadState->VgEglContext())

		return threadState;

	return NULL;

	*/

	}

// current state object, if Open GL ES is the current bound API, for this thread (for EGL)

EXPORT_C MGlesContext* CVghwUtils::GlesContext()

	{

	TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());

	return threadState;

	// ToDo sort this to check for valid Open GL ES context

	/*

	if (threadState && threadState->GlesEglContext())

		return threadState;

	return NULL; */

	}

// free current state object, if any, for this thread

EXPORT_C void CVghwUtils::ReleaseThreadState()

	{

	TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());

	UTIL_TRACE("CVghwUtils::ReleaseThreadState - object = 0x%x", threadState);

	if (threadState)

		{

		threadState->Destroy();

		Dll::FreeTls();

		}

	}

EXPORT_C MEglManagementApi* CVghwUtils::EglManagementApi()

	{

	return iEglManagementApi;

	}

EXPORT_C void CVghwUtils::SetEglManagementApi(MEglManagementApi* aEglManagementApi)

	{

	UTIL_TRACE("CVghwUtils::SetEglManagementApi  aEglManagementApi=0x%x", aEglManagementApi);

	iEglManagementApi = aEglManagementApi;

	}

/*

 Stored pointers into Open GL ES 1.1, GL ES 2 and Open VG are problematic if the DLL is later unloaded.

 (RSgDriver::Open currently loads & unloads all the Open VG & GL ES DLLs, to determine features to publish.)

 Possibly Open the DLL again when the non-NULL pointer is fetched by EGL, probably needs flags so that

 this is only done once.

 */

EXPORT_C void CVghwUtils::SetVgApiForEgl(MVgApiForEgl* aVgApiForEgl)

	{

	UTIL_TRACE("CVghwUtils::SetVgApiForEgl  aVgApiForEgl=0x%x, iVgApiForEgl=0x%x, iLoadedOpenVgDll=0x%x",

			aVgApiForEgl, iVgApiForEgl, iLoadedOpenVgDll);

	// don't let a thread set this to NULL if we have forced the DLL to stay loaded

	if (aVgApiForEgl || !iLoadedOpenVgDll)

		{

		iVgApiForEgl = aVgApiForEgl;

		}

	}

EXPORT_C MVgApiForEgl* CVghwUtils::VgApiForEgl()

	{

	if (iVgApiForEgl && !iLoadedOpenVgDll)

		{ // ensure Open VG DLL stays loaded from now on

		_LIT(KLibOpenVg, "libOpenVG.dll");

		RLibrary lib;

		if (lib.Load(KLibOpenVg) == KErrNone)

			{

			UTIL_TRACE("CVghwUtils::VgApiForEgl - Open VG dll loaded, iVgApiForEgl=0x%x", iVgApiForEgl);

			iLoadedOpenVgDll = ETrue;

			return iVgApiForEgl;

			}

		}

	UTIL_TRACE("CVghwUtils::VgApiForEgl - Open VG dll not loaded or not safe to use");

	return NULL;

	}

EXPORT_C void CVghwUtils::SetGles11ApiForEgl(MGles11ApiForEgl* aGles11ApiForEgl)

	{

	UTIL_TRACE("CVghwUtils::SetGles11ApiForEgl  aGles11ApiForEgl=0x%x, iGles11ApiForEgl=0x%x, iLoadedOpenGles11Dll=0x%x",

			aGles11ApiForEgl, iGles11ApiForEgl, iLoadedOpenGles11Dll);

	// don't let a thread set this to NULL if we have forced the DLL to stay loaded

	if (aGles11ApiForEgl || !iLoadedOpenGles11Dll)

		{

		iGles11ApiForEgl = aGles11ApiForEgl;

		}

	}

EXPORT_C MGles11ApiForEgl* CVghwUtils::Gles11ApiForEgl()

	{

	if (iGles11ApiForEgl && !iLoadedOpenGles11Dll)

		{ // ensure Open VG DLL stays loaded from now on

		_LIT(KLibOpenGles, "libGLESv1_CM.dll");

		RLibrary lib;

		if (lib.Load(KLibOpenGles) == KErrNone)

			{

			UTIL_TRACE("CVghwUtils::Gles11ApiForEgl - Open GL ES 1.1 dll loaded, iGles11ApiForEgl=0x%x", iGles11ApiForEgl);

			iLoadedOpenGles11Dll = ETrue;

			return iGles11ApiForEgl;

			}

		}

	UTIL_TRACE("CVghwUtils::Gles11ApiForEgl - Open GL ES 1.1 dll not loaded or not safe to use");

	return NULL;

	}

EXPORT_C void CVghwUtils::SetGles2ApiForEgl(MGles2ApiForEgl* aGles2ApiForEgl)

	{

	UTIL_TRACE("CVghwUtils::SetGles2ApiForEgl  aGles2ApiForEgl=0x%x, iGles2ApiForEgl=0x%x, iLoadedOpenGles2Dll=0x%x",

			aGles2ApiForEgl, iGles2ApiForEgl, iLoadedOpenGles2Dll);

	// don't let a thread set this to NULL if we have forced the DLL to stay loaded

	if (aGles2ApiForEgl || !iLoadedOpenGles2Dll)

		{

		iGles2ApiForEgl = aGles2ApiForEgl;

		}

	}

EXPORT_C MGles2ApiForEgl* CVghwUtils::Gles2ApiForEgl()

	{

	if (iGles2ApiForEgl && !iLoadedOpenGles2Dll)

		{ // ensure Open VG DLL stays loaded from now on

		_LIT(KLibOpenGles2, "libGLESv2.dll");

		RLibrary lib;

		if (lib.Load(KLibOpenGles2) == KErrNone)

			{

			UTIL_TRACE("CVghwUtils::Gles2ApiForEgl - Open GL ES 2 dll loaded, iGles2ApiForEgl=0x%x", iGles2ApiForEgl);

			iLoadedOpenGles2Dll = ETrue;

			return iGles2ApiForEgl;

			}

		}

	UTIL_TRACE("CVghwUtils::Gles2ApiForEgl - Open GL ES 2 dll not loaded or not safe to use");

	return NULL;

	}

////////////////////////////////////////////////////////////////////////////////////

// factory method

TEglThreadState* TEglThreadState::New()

	{

	UTIL_TRACE("TEglThreadState::New");

	RHeap* currentHeap = CVghwUtils::SwitchToVghwHeap();

	TEglThreadState* self = new TEglThreadState();

	CVghwUtils::SwitchFromVghwHeap(currentHeap);

	return self;

	}

TEglThreadState::TEglThreadState() :

	// EGL thread state

	iEglError(EGL_SUCCESS),

	iEglHostHasRecentError(EFalse),

	// currently bound graphics API, initial value from EGL spec 

	iEglBoundApi(EGL_OPENGL_ES_API),

	// Open VG thread state 

	iVgError(VG_NO_ERROR),

	iVgEglContext(EGL_NO_CONTEXT),

	iVgCommandsSinceGetError(EFalse),

	iVgCommandsSinceFlush(EFalse),

	iVgCommandsSinceFinish(EFalse),

	// Open GL ES 1.1 state

	iGlesError(GL_NO_ERROR),

	iGlesEglContext(EGL_NO_CONTEXT),

	iGlesCommandsSinceGetError(EFalse),

	iGlesCommandsSinceFlush(EFalse),

	iGlesCommandsSinceFinish(EFalse)

	{}

void TEglThreadState::Destroy()

	{

	UTIL_TRACE("TEglThreadState::Destroy");

	RHeap* currentHeap = CVghwUtils::SwitchToVghwHeap();

	delete this;

	CVghwUtils::SwitchFromVghwHeap(currentHeap);

	}

TEglThreadState::~TEglThreadState()

	{}

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------