// 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:

// Implementation of guest egl context

#include <e32debug.h>

#include "eglapi.h"

// factory function

CEglContext* CEglContext::Create(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, CEglContext* aShareContext, const EGLint* aAttribList)

	{

	// ToDo validate aConfig

	// ToDo validate aShareContext

	// which Khronos Graphics API is the Context for: Open GL ES, Open VG, ...

	EGLenum api = aThreadState.EglBoundApi();

	// (in case supported APIs ever change) ensure the current API is valid 

	if (api == EGL_NONE)

		{

		aThreadState.SetEglError(EGL_BAD_MATCH);

		return EGL_NO_CONTEXT;

		}

	EGLint glesClientVersion = 1;

	// validate AttribList parameter

	if ( aAttribList && (*aAttribList != EGL_NONE) )

		{

		TBool attribsOkay = EFalse;

		// As of EGL 1.4 only Open GL ES api supports any attributes for eglCreateContext

		if (api == EGL_OPENGL_ES_API)

			{

			// only supported attribute for Open GL ES is EGL_CONTEXT_CLIENT_VERSION

			if ( (aAttribList[0] == EGL_CONTEXT_CLIENT_VERSION) && (aAttribList[2] == EGL_NONE) )

				{

				glesClientVersion = aAttribList[1];

				// modify this code when GL ES 2 support is added

				if (glesClientVersion == 1)

					{

					attribsOkay = ETrue;

					}

				}

			}

		if (!attribsOkay)

			{

			aThreadState.SetEglError(EGL_BAD_PARAMETER);

			return EGL_NO_CONTEXT;

			}

		}

	// ToDo validate that aConfig supports this API (inc GL ES v2 versus v1)

	EGLContext shareContextFamily = EGL_NO_CONTEXT;

	if (aShareContext)

		{

		shareContextFamily = aShareContext->ShareContextFamily();

		}

	RHeap* threadHeap = CVghwUtils::SwitchToVghwHeap();

	CEglContext* self = new CEglContext(aDisplay, aConfig, shareContextFamily, api, glesClientVersion);

	if (self == EGL_NO_CONTEXT)

		{

		aThreadState.SetEglError(EGL_BAD_ALLOC);

		}

	else

		{

		// call Host EGL, & set iHostContext

		RemoteFunctionCallData rfcdata; EglRFC eglApiData( rfcdata );

		eglApiData.Init(EglRFC::EeglCreateContext);

		eglApiData.AppendEGLDisplay(aDisplay);

		eglApiData.AppendEGLConfig(aConfig);

		eglApiData.AppendEGLContext(aShareContext ? aShareContext->HostContext() : EGL_NO_CONTEXT);

		eglApiData.AppendEGLintVector(aAttribList, TAttribUtils::AttribListLength(aAttribList));

		self->iHostContext = aThreadState.ExecEglContextCmd(eglApiData);

		if (self->iHostContext == EGL_NO_CONTEXT)

			{ // Host EGL error

			delete self;

			self = EGL_NO_CONTEXT;

			}

		}

	CVghwUtils::SwitchFromVghwHeap(threadHeap);

	return self;

	}

CEglContext::CEglContext(EGLDisplay aDisplay, EGLConfig aConfig, EGLContext aShareContextFamily, EGLenum aRenderingApi,

			EGLint aGlesClientVersion) :

		iFirstUse(ETrue), iHostContext(EGL_NO_CONTEXT), iDisplay(aDisplay), iShareContextFamily(aShareContextFamily),

		iConfigId(aConfig), iRenderingApi(aRenderingApi), iDrawSurface(EGL_NO_SURFACE), iReadSurface(EGL_NO_SURFACE),

		iGlesClientVersion(aGlesClientVersion), iIsDestroyed(EFalse)

	{

	iCtxMutex.CreateLocal(EOwnerProcess);

	}

void CEglContext::Delete(TEglThreadState& aThreadState)

	{

	EGLPANIC_ASSERT_DEBUG(iCtxMutex.IsHeld(), EEglPanicTemp);

	// tell Host EGL to destroy the Context now

	RemoteFunctionCallData rfcdata; EglRFC eglApiData( rfcdata );

	eglApiData.Init(EglRFC::EeglDestroyContext);

	eglApiData.AppendEGLDisplay(iDisplay);

	eglApiData.AppendEGLContext(iHostContext);

	EGLBoolean hostResult = aThreadState.ExecEglBooleanCmd(eglApiData);

	EGLPANIC_ASSERT_DEBUG(hostResult,  EEglPanicTemp);

	// free

	iCtxMutex.Close();

	RHeap* threadHeap = CVghwUtils::SwitchToVghwHeap();

	delete this;

	CVghwUtils::SwitchFromVghwHeap(threadHeap);

	}

CEglContext::~CEglContext()

	{

	if (iCtxMutex.Handle())

		{

	iCtxMutex.Close();

		}

	}

EGLBoolean CEglContext::MakeCurrent(TEglThreadState& aThreadState, EGLSurface aDraw, EGLSurface aRead)

	{

	// ToDo support different number spaces for Host & Client EGL Surfaces 

	EGLBoolean hostResult = EGL_FALSE;

	EGLint error = EGL_SUCCESS;

	iCtxMutex.Wait();

	if (iIsDestroyed)

		{

		error = EGL_BAD_CONTEXT;

		}

	else

		{

		// ToDo validate aDraw & aRead are compatible with API

		RemoteFunctionCallData rfcdata; EglRFC eglApiData( rfcdata );

		eglApiData.Init( EglRFC::EeglMakeCurrent );

		eglApiData.AppendEGLDisplay(iDisplay);

		eglApiData.AppendEGLSurface(aDraw);

		eglApiData.AppendEGLSurface(aRead);

		eglApiData.AppendEGLContext(iHostContext);

		hostResult = aThreadState.ExecEglBooleanCmd(eglApiData);

		if (hostResult)

			{

			iDrawSurface = aDraw;

			iReadSurface = aRead;

			}

		}

	iCtxMutex.Signal();

	if (error != EGL_SUCCESS)

		{ // error in parameter checks 

		aThreadState.SetEglError(error);

		}

	return hostResult;

	}

TBool CEglContext::Destroy(TEglThreadState& aThreadState)

	{

	iCtxMutex.Wait();

	iIsDestroyed = ETrue;

	if ( (iDrawSurface == EGL_NO_SURFACE) && (iReadSurface == EGL_NO_SURFACE) )

		{ // Context not in use

		Delete(aThreadState);

		return ETrue;

		}

	iCtxMutex.Signal();

	return EFalse;

	}

TBool CEglContext::MakeNotCurrent(TEglThreadState& aThreadState)

	{

	iCtxMutex.Wait();

	iDrawSurface = EGL_NO_SURFACE;

	iReadSurface = EGL_NO_SURFACE;

	if (iIsDestroyed)

		{ // Destroyed & no longer in use

		Delete(aThreadState);

		return ETrue;

		}

	iCtxMutex.Signal();

	return EFalse;

	}

EGLContext CEglContext::ShareContextFamily()

	{

	EGLContext result = EGL_NO_CONTEXT;

	// ToDo review - maybe just check Mutex is held

	iCtxMutex.Wait();

	if (!iIsDestroyed)

		{

		if (iShareContextFamily)

			{

			result = iShareContextFamily;

			}

		else

			{

			result = iHostContext;

			}

		}

	iCtxMutex.Signal();

	return result;

	}

// Valid attributes are: EGL_CONFIG_ID, EGL_CONTEXT_CLIENT_TYPE, EGL_CONTEXT_CLIENT_VERSION, or EGL_RENDER_BUFFER

EGLBoolean CEglContext::QueryAttribute(TEglThreadState& aThreadState, EGLint aAttribute, EGLint* aValue)

	{

	EGLint error = EGL_SUCCESS;

	iCtxMutex.Wait();

	if (iIsDestroyed)

		{

		error = EGL_BAD_CONTEXT;

		}

	else

		{

		switch (aAttribute)

			{

			case EGL_CONFIG_ID:

				*aValue = iConfigId;

				break;

			case EGL_CONTEXT_CLIENT_TYPE:

				*aValue = iRenderingApi;

				break;

			case EGL_CONTEXT_CLIENT_VERSION:

				*aValue = iGlesClientVersion;

				break;

			case EGL_RENDER_BUFFER:

				if (iDrawSurface == NULL)

					{ // context is not bound to any surface

					*aValue = EGL_NONE;

					}

				else

					// ToDo check the currently bound surface type to answer this

					{

					RemoteFunctionCallData rfcdata; EglRFC eglApiData( rfcdata );

					eglApiData.Init(EglRFC::EeglQueryContext);

					eglApiData.AppendEGLDisplay(iDisplay);

					eglApiData.AppendEGLContext(iHostContext);

					eglApiData.AppendEGLint(aAttribute);

					eglApiData.AppendEGLintVector(aValue, 1, RemoteFunctionCallData::EOut);

					EGLBoolean hostResult = aThreadState.ExecEglBooleanCmd(eglApiData);

					return hostResult;

					}

				break;

			default:

				error = EGL_BAD_ATTRIBUTE;

				break;

			}

		// Debug compare with Host EGL result

#ifdef _DEBUG

		EGLint hostValue = 0;

		RemoteFunctionCallData rfcdata; EglRFC eglApiData( rfcdata );

		eglApiData.Init(EglRFC::EeglQueryContext);

		eglApiData.AppendEGLDisplay(iDisplay);

		eglApiData.AppendEGLContext(iHostContext);

		eglApiData.AppendEGLint(aAttribute);

		eglApiData.AppendEGLintVector(&hostValue, 1, RemoteFunctionCallData::EOut);

		EGLBoolean hostResult = aThreadState.ExecEglBooleanCmd(eglApiData);

		if (error == EGL_SUCCESS)

			{ // Host EGl result should match ours

			EGLPANIC_ASSERT(hostResult,  EEglPanicTemp);

			EGLPANIC_ASSERT(hostValue == *aValue, EEglPanicTemp);

			}

		else

			{

			EGLPANIC_ASSERT(!hostResult,  EEglPanicTemp);		

			}

#endif

		}

	aThreadState.SetEglError(error);

	iCtxMutex.Signal();

	return (error == EGL_SUCCESS);

	}

// end of file eglcontext.cpp