// 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 stub functions

#include "eglapi.h"

#include <e32atomics.h>

/*

 Only having the pointer as "Writeable Static Data" makes it very easy to tell if

 initialisation has been done: the pointer is not NULL!

 */

CGuestEGL* guestEGL;

// Writeable Static Data - causes constructor to be called at load DLL time.

XGuestEglInitialiser GuestEglInitialiser;

XGuestEglInitialiser::XGuestEglInitialiser()

	{

	EGL_TRACE("XGuestEglInitialiser::XGuestEglInitialiser() - guestEGL=0x%x", guestEGL);

	if (!guestEGL)

		{

		// ensure VGHW Memory heap is created & channel to LDD is opened

		CVghwUtils::InitStatics();

		// Multi-Threading safe creation of CGuestEGL instance

		if (!guestEGL)

			{

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

			__e32_atomic_store_rel_ptr(&guestEGL, CGuestEGL::New());

			}

		// cast away volatile attribute

		CGuestEGL* instance = (CGuestEGL*)guestEGL;

		// cannot continue if alloc failed

		EGLPANIC_ASSERT(guestEGL, EEglPanicCGuestEGLAllocFailed);

		CVghwUtils::SetEglManagementApi(instance);

		CVghwUtils::CreateThreadState();

		}

	}

XGuestEglInitialiser::~XGuestEglInitialiser()

	{

	EGL_TRACE("XGuestEglInitialiser::~XGuestEglInitialiser() - guestEGL=0x%x", guestEGL);

	if (guestEGL)

		{

		delete guestEGL;

		guestEGL = NULL;

		}

	CVghwUtils::DestroyStatics();

	}

_LIT(KEglPanicCategory, "Guest EGL");

void EglPanic(TEglPanic aPanicCode, char* aPanicName, char* aCondition, char* aFile, TInt aLine)

	{

	if (aPanicName && aCondition && aFile)

		{

		RDebug::Printf("Guest EGL DLL Panic %s for failed Assert (%s),\n\tat %s:%d", aPanicName, aCondition, aFile, aLine);

		}

	else if (aPanicName && aFile)

		{

		RDebug::Printf("Guest EGL DLL Panic %s at %s:%d", aPanicName, aFile, aLine);

		}

	else

		{

		RDebug::Printf("Guest EGL DLL Panic %d (line %d)", aPanicCode, aLine);

		}

	User::Panic(KEglPanicCategory, aPanicCode);

	}

extern "C" {

/*

 Note: Comments at the start of each EGL api are adapted from the Khronos EGL 1.4 specification.

 The text has been chosen/adapted to give a helpful overview of the function, and the errors

 that it may generate.  For more details see the full Khronos EGL specification.

 */

/*

 Get details of the last EGL api error in this thread.

 Returns EGL_SUCCESS or an EGL_xxxx error constant.

 */

EXPORT_C EGLint eglGetError(void)

    {

	EGL_TRACE("eglGetError -->");

	EGLint eglError = EGL_SUCCESS;

	// threadState is non-null if an EGL api has been called in this thread

	TEglThreadState* threadState = CVghwUtils::EglThreadState(); // do not create thread object for this API

	if (threadState)

		{ // get error (may be from parameter checking in this DLL or from Host EGL) - fetching resets error to EGL_SUCCESS

		eglError = threadState->EglError();

		}

	EGL_TRACE("eglGetError returning eglError=0x%x <--", eglError);

	return eglError;

    }

/*

 Get display handle for display with requested properties.

 If display id is EGL_DEFAULT_DISPLAY, a default display is returned.

 Multiple calls made to eglGetDisplay with the same display-id will

 all return the same EGLDisplay handle.

 If no display matching display id is available, EGL_NO_DISPLAY is

 returned; no error condition is raised in this case.

 */

EXPORT_C EGLDisplay eglGetDisplay(EGLNativeDisplayType aDisplayId)

	{

	EGL_TRACE("eglGetDisplay Display Id=%d -->", aDisplayId);

	EGLDisplay display = EGL_NO_DISPLAY;

	// Most likely eglGetDisplay is the first API called, so try initialising EGL instance first

	CGuestEGL& instance = Instance();

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		display = instance.eglGetDisplay(*threadState, aDisplayId);

		}

	EGL_TRACE("eglGetDisplay result Display=%d <--", display);

	return display;

	}

/*

 Initialize EGL on a display.

 EGL_TRUE is returned on success, and major and minor are updated with the major

 and minor version numbers of the EGL implementation (for example, in an EGL

 1.2 implementation, the values of *major and *minor would be 1 and 2, respectively).

 major and minor are not updated if they are specified as NULL.

 EGL_FALSE is returned on failure and major and minor are not updated. An

 EGL_BAD_DISPLAY error is generated if the dpy argument does not refer to a valid

 EGLDisplay. An EGL_NOT_INITIALIZED error is generated if EGL cannot be

 initialized for an otherwise valid dpy.

 */

EXPORT_C EGLBoolean eglInitialize(EGLDisplay aDisplay, EGLint *aMajor, EGLint *aMinor)

	{

	EGL_TRACE("eglInitialize Display=%d, Major 0x%x, Minor 0x%x", aDisplay, aMajor, aMinor );

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	EGLBoolean success = EGL_FALSE;

	if (threadState)

		{

		success = Instance().eglInitialize(*threadState, aDisplay, aMajor, aMinor);

		}

	EGL_TRACE("eglInitialize <- result=%d", success);

	return success;

	}

/*

 Marks all EGL-specific resources associated with the specified display

 for deletion.

 If the dpy argument does not refer to a valid EGLDisplay, EGL_FALSE is

 returned, and an EGL_BAD_DISPLAY error is generated.

 */

EXPORT_C EGLBoolean eglTerminate(EGLDisplay aDisplay)

	{

	EGL_TRACE("eglTerminate Display=%d", aDisplay);

	EGLBoolean result = EGL_FALSE;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		result = Instance().eglTerminate(*threadState, aDisplay);

		}

	return result;

	}

/*

 Returns a pointer to a static, zero-terminated string describing some aspect

 of the EGL implementation running on the specified display. name may be one

 of EGL_CLIENT_APIS, EGL_EXTENSIONS, EGL_VENDOR, or EGL_VERSION.

 The EGL_CLIENT_APIS string describes which client rendering APIs are

 supported. It is zero-terminated and contains a space-separated list of API

 names, which must include at least one of ‘‘OpenGL’’, ‘‘OpenGL_ES’’ or

 ‘‘OpenVG’’.

 The EGL_EXTENSIONS string describes which EGL extensions are supported

 by the EGL implementation running on the specified display, and for the

 current client API context. The string is zero terminated and contains a

 space-separated list of extension names;  extension names themselves do

 not contain spaces. If there are no extensions to EGL, then the empty string

 is returned.

 The format and contents of the EGL_VENDOR string is implementation dependent.

 The format of the EGL_VERSION string is:

 <major version.minor version><space><vendor specific info>

 On failure, NULL is returned. An EGL_NOT_INITIALIZED error is generated

 if EGL is not initialized for dpy. An EGL_BAD_PARAMETER error is generated if

 name is not one of the values described above.

 */

EXPORT_C const char* eglQueryString(EGLDisplay aDisplay, EGLint aName)

    {

    EGL_TRACE("eglQueryString Display=%d, Name=0x%x", aDisplay, aName);

    return Instance().eglQueryString(aDisplay, aName);

    }

/*

 Get the list of all EGLConfigs that are available on the specified display.

 On failure, EGL_FALSE is returned. An EGL_NOT_INITIALIZED error is generated

 if EGL is not initialized on dpy. An EGL_BAD_PARAMETER error is generated

 if num config is NULL.

 */

EXPORT_C EGLBoolean eglGetConfigs(EGLDisplay aDisplay, EGLConfig *aConfigs,

			 EGLint aConfigSize, EGLint *aNumConfig)

	{

	EGL_TRACE("eglGetConfigs Display=%d, ConfigSize=%d , NumConfig=0x%x -->", aDisplay, aConfigSize, aNumConfig);

	EGLBoolean result = EGL_FALSE;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		result = Instance().eglGetConfigs(*threadState, aDisplay, aConfigs, aConfigSize, aNumConfig);

		}

	EGL_TRACE("eglGetConfigs hostResult=%d, NumConfig-%d <--", result, aNumConfig ? *aNumConfig : 0);

	return result;

	}

/*

 Get EGLConfigs that match a list of attributes. The return value and the meaning

 of configs, config size, and num config are the same as for eglGetConfigs.

 However, only configurations matching attrib list will be returned.

 On failure, EGL_FALSE is returned. An EGL_BAD_ATTRIBUTE error is generated

 if attrib list contains an undefined EGL attribute or an attribute value that is

 unrecognized or out of range.

 */

EXPORT_C EGLBoolean eglChooseConfig(EGLDisplay aDisplay, const EGLint *aAttribList,

			   EGLConfig *aConfigs, EGLint aConfigSize, EGLint *aNumConfig)

	{

	EGL_TRACE("eglChooseConfig Display=%d, AttribList=0x%x, Configs=0x%x, ConfigSize=%d, NumConfig=0x%x -->",

			aDisplay, aAttribList, aConfigs, aConfigSize, aNumConfig);

	EGL_TRACE_ATTRIB_LIST(aAttribList);

	EGLBoolean result = EGL_FALSE;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		result = Instance().eglChooseConfig(*threadState, aDisplay, aAttribList, aConfigs, aConfigSize, aNumConfig);

		}

	EGL_TRACE("eglChooseConfig Result=%s, Num configs=%d, First config=%d <--",

			result ? "success" : "fail", 

			aNumConfig ? *aNumConfig : 0,

			(aConfigs && aNumConfig && (*aNumConfig > 0)) ? *aConfigs : -1);

	return result;

	}

/*

 Get the value of an EGLConfig attribute.

 On failure returns EGL_FALSE. If attribute

 is not a valid attribute then EGL_BAD_ATTRIBUTE is generated.

 */

EXPORT_C EGLBoolean eglGetConfigAttrib(EGLDisplay aDisplay, EGLConfig aConfig,

			      EGLint aAttribute, EGLint *aValue)

	{

	EGLBoolean result = EGL_FALSE;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		result = Instance().eglGetConfigAttrib(*threadState, aDisplay, aConfig, aAttribute, aValue);

		}

	return result;

	}

/*

 Creates an onscreen EGLSurface and returns a handle to it. Any EGL context created

 with a compatible EGLConfig can be used to render into this surface.

 On failure returns EGL_NO_SURFACE. If the attributes of win do not correspond to

 config, then an EGL_BAD_MATCH error is generated. If config does not support

 rendering to windows (the EGL_SURFACE_TYPE attribute does not contain

 EGL_WINDOW_BIT), an EGL_BAD_MATCH error is generated. If config does not support

 the colorspace or  alpha format attributes specified in attrib list (as defined

 for eglCreateWindowSurface), an EGL_BAD_MATCH error is generated. If config is

 not a valid EGLConfig, an EGL_BAD_CONFIG error is generated. If win is not a valid

 native window handle, then an EGL_BAD_NATIVE_WINDOW error should be generated. If

 there is already an EGLConfig associated with win (as a result of a previous

 eglCreateWindowSurface call), then an EGL_BAD_ALLOC error is generated. Finally,

 if the implementation cannot allocate resources for the new EGL window, an

 EGL_BAD_ALLOC error is generated.

 */

EXPORT_C EGLSurface eglCreateWindowSurface(EGLDisplay aDisplay, EGLConfig aConfig,

				  EGLNativeWindowType aWindow, const EGLint *aAttribList)

	{

	EGL_TRACE("eglCreateWindowSurface Display=%d, Config=%d, Window=0x%x -->", aDisplay, aConfig, aWindow);

	EGLSurface newSurface = EGL_NO_SURFACE;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		newSurface = Instance().eglCreateWindowSurface(*threadState, aDisplay, aConfig, aWindow, aAttribList);

		}

	EGL_TRACE("eglCreateWindowSurface new Surface=0x%x <--", newSurface);

	return newSurface;

	}

/*

 Creates a single off-screen pbuffer surface and returns a handle to it.

 On failure returns EGL_NO_SURFACE. If the pbuffer could not be created due

 to insufficient resources, then an EGL_BAD_ALLOC error is generated. If

 config is not a valid EGLConfig, an EGL_BAD_CONFIG error is generated. If

 the value specified for either EGL_WIDTH or EGL_HEIGHT is less than zero,

 an EGL_BAD_PARAMETER error is generated. If config does not support

 pbuffers, an EGL_BAD_MATCH error is generated. In addition, an EGL_BAD_MATCH

 error is generated if any of the following conditions are true:

 * The EGL_TEXTURE_FORMAT attribute is not EGL_NO_TEXTURE, and EGL_WIDTH

   and/or EGL_HEIGHT specify an invalid size (e.g., the texture size is

   not a power of two, and the underlying OpenGL ES implementation does not

   support non-power-of-two textures).

 * The EGL_TEXTURE_FORMAT attribute is EGL_NO_TEXTURE, and EGL_TEXTURE_TARGET

   is something other than EGL_NO_TEXTURE; or, EGL_TEXTURE_FORMAT is

   something other than EGL_NO_TEXTURE, and EGL_TEXTURE_TARGET is

   EGL_NO_TEXTURE.

 Finally, an EGL_BAD_ATTRIBUTE error is generated if any of the EGL_-

 TEXTURE_FORMAT, EGL_TEXTURE_TARGET, or EGL_MIPMAP_TEXTURE attributes

 are specified, but config does not support OpenGL ES rendering (e.g.

 the EGL_RENDERABLE_TYPE attribute does not include at least one of EGL_-

 OPENGL_ES_BIT or EGL_OPENGL_ES2_BIT.

 */

EXPORT_C EGLSurface eglCreatePbufferSurface(EGLDisplay aDisplay, EGLConfig aConfig, const EGLint *aAttribList)

	{

	EGL_TRACE("eglCreatePbufferSurface Display=%d, Config=%d -->", aDisplay, aConfig);

	EGL_TRACE_ATTRIB_LIST(aAttribList);

	EGLSurface newSurface = EGL_NO_SURFACE;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{

		newSurface = Instance().eglCreatePbufferSurface(*threadState, aDisplay, aConfig, aAttribList);

		}

	EGL_TRACE("eglCreatePbufferSurface new Surface=0x%x <--", newSurface);

	return newSurface;

	}

/*

 Creates an offscreen EGLSurface and returns a handle to it. Any EGL context

 created with a compatible EGLConfig can be used to render into this surface.

 To create a pixmap rendering surface, first create a native platform pixmap,

 then select an EGLConfig matching the pixel format of that pixmap (calling

 eglChooseConfig with an attribute list including EGL_MATCH_NATIVE_PIXMAP

 returns only EGLConfigs matching the pixmap specified in the attribute list).

 Returns EGL_NO_SURFACE on failure. If the attributes of pixmap do not

 correspond to config, then an EGL_BAD_MATCH error is generated. If config does

 not support rendering to pixmaps (the EGL_SURFACE_TYPE attribute does not

 contain EGL_PIXMAP_BIT), an EGL_BAD_MATCH error is generated. If config does

 not support the colorspace or alpha format attributes specified in attrib list

 (as defined for eglCreateWindowSurface), an EGL_BAD_MATCH error is generated.

 If config is not a valid EGLConfig, an EGL_BAD_CONFIG error is generated. If

 pixmap is not a valid native pixmap handle, then an EGL_BAD_NATIVE_PIXMAP

 error should be generated. If there is already an EGLSurface associated with

 pixmap (as a result of a previous eglCreatePixmapSurface call), then a

 EGL_BAD_ALLOC error is generated. Finally, if the implementation cannotallocate

 resources for the new EGL pixmap, an EGL_BAD_ALLOC error is generated.

 */

EXPORT_C EGLSurface eglCreatePixmapSurface(EGLDisplay aDisplay, EGLConfig aConfig, EGLNativePixmapType aPixmap, const EGLint *aAttribList)

	{

	EGL_TRACE("eglCreatePixmapSurface Display=%d, Config=%d, Pixmap=0x%x -->", aDisplay, aConfig, aPixmap);

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	EGLSurface newSurface = EGL_NO_SURFACE;

	if (threadState)

		{

		newSurface = Instance().eglCreatePixmapSurface(*threadState, aDisplay, aConfig, aPixmap, aAttribList);

		}

	EGL_TRACE("eglCreatePixmapSurface new Surface=0x%x <--", newSurface);

	return newSurface;

	}

/*

 Destroy an EGLSurface of any type (window, pbuffer, or pixmap).

 All resources associated with surface which were allocated by EGL are marked

 for deletion as soon as possible. Following eglDestroySurface, the surface

 and  the handle referring to it are treated in the same fashion as a surface

 destroyed by eglTerminate.

 Resources associated with surface but not allocated by EGL, such as native

 windows, native pixmaps, or client API buffers, are not affected when the

 surface is destroyed. Only storage actually allocated by EGL is marked for

 deletion. Furthermore, resources associated with a pbuffer surface are not

 released until all color buffers of that pbuffer bound to a OpenGL ES texture

 object have been released.

 Returns EGL_FALSE on failure. An EGL_BAD_SURFACE error is generated if surface

 is not a valid rendering surface.

 */

EXPORT_C EGLBoolean eglDestroySurface(EGLDisplay aDisplay, EGLSurface aSurface)

	{

	EGL_TRACE("eglDestroySurface Display=%d, Surface=0x%x", aDisplay, aSurface);

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	EGLBoolean result = EGL_FALSE;

	if (threadState)

		{

		result = Instance().eglDestroySurface(*threadState, aDisplay, aSurface);

		}

	return result;

	}

/*

 Returns in value the value of attribute for surface. attribute must be set

 to one of the attributes in table 3.5 of the EGL specification.

 Returns EGL_FALSE on failure and value is not updated. If attribute is not a

 valid EGL surface attribute, then an EGL_BAD_ATTRIBUTE error is generated. If

 surface is not a valid EGLSurface then an EGL_BAD_SURFACE error is generated.

 */

EXPORT_C EGLBoolean eglQuerySurface(EGLDisplay aDisplay, EGLSurface aSurface, EGLint aAttribute, EGLint *aValue)

    {

    EGL_TRACE("eglQuerySurface display=%d, surface=%d, attribute=%d", aDisplay, aSurface, aAttribute);

    TEglThreadState* threadState = CVghwUtils::CreateThreadState();

    if (threadState)

    	{

		return Instance().eglQuerySurface(*threadState, aDisplay, aSurface, aAttribute, aValue);

    	}

    return EGL_FALSE;

    }

/*

 Set the current rendering API, this is set on a per-thread basis.

 api must specify one of the supported client APIs , either EGL_OPENVG_API

 or EGL_OPENGL_ES_API. (EGL_OPENGL_API is not currently supported by Symbian.)

 Returns EGL_FALSE on failure. If api is not one of the values specified

 above, or if the client API specified by api is not supported by the

 implementation, an EGL_BAD_PARAMETER error is generated.

 */

EXPORT_C EGLBoolean eglBindAPI(EGLenum aApi)

	{

	EGL_TRACE("eglBindAPI 0x%x (%s)", aApi, (aApi == EGL_OPENGL_ES_API) ? "EGL_OPENGL_ES_API" : (aApi == EGL_OPENVG_API) ? "EGL_OPENVG_API" : "???");

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	EGLBoolean result = EGL_FALSE;

	if (threadState)

		{

		if ( (aApi == EGL_OPENGL_ES_API) || (aApi == EGL_OPENVG_API) )

			{

			threadState->SetEglBoundApi(aApi);

			result = EGL_TRUE;

			RemoteFunctionCallData rfcdata; EglRFC eglApiData(rfcdata);

			eglApiData.Init(EglRFC::EeglBindAPI);

			eglApiData.AppendEGLenum(aApi);

			EGLBoolean hostResult = threadState->ExecEglBooleanCmd(eglApiData);

			// confirm Host EGL matches what we think about the parameter

			EGLPANIC_ASSERT_DEBUG(hostResult == result, EEglPanicTemp);

			}

		else

			{

			threadState->SetEglError(EGL_BAD_PARAMETER);

			}

		}

	return result;

	}

/*

 Get the current rendering API, this is set on a per-thread basis.

 The value returned will be one of the valid api parameters to eglBindAPI,

 or EGL_NONE.

 The initial value of the current rendering API is EGL_OPENGL_ES_API.

 Applications using multiple client APIs are responsible for ensuring

 the current rendering API is correct before calling the functions

 eglCreateContext, eglGetCurrentContext, eglGetCurrentDisplay,

 eglGetCurrentSurface, eglMakeCurrent (when its ctx parameter is

 EGL_NO_CONTEXT), eglWaitClient, or eglWaitNative.

 */

EXPORT_C EGLenum eglQueryAPI(void)

	{

	EGL_TRACE("eglQueryAPI");

	EGLenum result = EGL_OPENGL_ES_API;

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	if (threadState)

		{ // EGL threadState exists

		result = threadState->EglBoundApi();

		threadState->SetEglError(EGL_SUCCESS);

#ifdef _DEBUG

		// Debug build checks that local threadState is in sync with Host EGL state

		RemoteFunctionCallData rfcdata; EglRFC eglApiData( rfcdata );

		eglApiData.Init(EglRFC::EeglQueryAPI);

		threadState->ExecuteEglNeverErrorCmd(eglApiData);

		EGLPANIC_ASSERT(result == (EGLenum)eglApiData.ReturnValue(), EEglPanicHostAndClientBoundApiOutOfSync);

#endif

		}

	return result;

	}

/*

 Wait for client (Open GL ES, VG, ...) rendering to complete, before

 using Symbian native rendering.

 Returns EGL_TRUE on success. If there is no current context for  the current

 rendering API, the function has no effect but still returns EGL_TRUE. If the

 surface associated with the calling thread’s current context is no longer valid,

 EGL_FALSE is returned and an EGL_BAD_CURRENT_SURFACE error is generated.

 */

EXPORT_C EGLBoolean eglWaitClient(void)

    {

	EGL_TRACE("eglWaitClient");