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

// Guest EGL implementation

#include <graphics/surfacemanager.h>

#include <graphics/surfaceconfiguration.h>

#include <graphics/suerror.h>

#include <graphics/surface_hints.h>

#include <e32debug.h>

#include <stdlib.h> // for malloc

#include "eglapi.h"

#include <graphics/guestvideodriverinterfaceconstants.h>

// FAISALMEMON HOLE 0

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

// constructor

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

//

// FAISALMEMON STUB CODE

#define EGL_CHECK_ERROR(a, b, c)      /* This does no checking; just a stub */

	{

	return; // stub code

	}

EGLBoolean CGuestEGL::EglInternalFunction_SurfaceResized(TEglThreadState&, TSurfaceInfo&, int, int) 

	{

	return EFalse; // stub code

	}

TBool CGuestEGL::EglInternalFunction_SwapWindowSurface(TEglThreadState&, int, int)

	{

	return EFalse; // stub code

	}

TSymbianPixmapTypeId CGuestEGL::EglInternalFunction_GetNativePixmapType(void*)

	{

	return EPixmapTypeNone; // stub code

	}

TBool CGuestEGL::EglInternalFunction_IsValidNativePixmap(void*, TSymbianPixmapTypeId)

	{

	return EFalse; // stub code

	}

const char * CGuestEGL::EglInternalFunction_QueryExtensionList()

	{

	return NULL; // stub code

	}

/**

Obtain extension function pointer.

Provide support for the Symbian Graphics SHAI for EGL Extensions

@param aName	Name of extension

@return			Function pointer, or NULL if not available.

@note  Known extensions and their directly associated functions:

   1. EGL_KHR_image 

		None

   2. EGL_KHR_image_base 

		eglCreateImageKHR,

		eglDestroyImageKHR

   3. EGL_KHR_image_pixmap

		None

   4. EGL_KHR_vg_parent_image

		None

   5. EGL_KHR_gl_texture_2D_image

		None

   6. EGL_KHR_gl_texture_cubemap_image

		EGLImageTargetTexture2DOES,

		EGLImageTargetRenderbufferStorageOES

   7. EGL_KHR_lock_surface2

		eglLockSurfaceKHR,

		eglUnlockSurfaceKHR

   8. EGL_NOK_resource_profiling2

		eglQueryProfilingDataNOK

   9. EGL_SYMBIAN_composition

		None

  10. EGL_NOK_image_endpoint

		eglCreateEndpointNOK,

		eglDestroyEndpointNOK,

		eglGetEndpointAttribNOK,

		eglSetEndpointAttribNOK,

		eglEndpointBeginStreamingNOK,

		eglEndpointEndStreamingNOK,

		eglAcquireImageNOK,

		eglReleaseImageNOK,

		eglGetEndpointDirtyAreaNOK,

		eglEndpointRequestNotificationNOK,

		eglEndpointCancelNotificationNOK,

		eglCreateEndpointNOK

  11. NOK_pixmap_type_rsgimage

		None

  12. EGL_NOK_swap_region

		eglSwapBuffersRegionNOK

@see Khronos EGL 1.4 Specification, eglGetProcAddress()

@author Faisal Memon Community EGL project

*/

ProcPointer CGuestEGL::eglGetProcAddress(const char* aName)

	{

    if (strncmp("eglCreateImageKHR", aName, strlen("eglCreateImageKHR")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglDestroyImageKHR", aName, strlen("eglDestroyImageKHR")) == 0)

        {

        return NULL;

        }

    else if (strncmp("EGLImageTargetTexture2DOES", aName, strlen("EGLImageTargetTexture2DOES")) == 0)

        {

        return NULL;

        }

    else if (strncmp("EGLImageTargetRenderbufferStorageOES", aName, strlen("EGLImageTargetRenderbufferStorageOES")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglLockSurfaceKHR", aName, strlen("eglLockSurfaceKHR")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglUnlockSurfaceKHR", aName, strlen("eglUnlockSurfaceKHR")) == 0)

        {

        return NULL;

        }

    else if (strncmp("EGL_KHR_lock_surface", aName, strlen("EGL_KHR_lock_surface")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglQueryProfilingDataNOK", aName, strlen("eglQueryProfilingDataNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglCreateEndpointNOK", aName, strlen("eglCreateEndpointNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglDestroyEndpointNOK", aName, strlen("eglDestroyEndpointNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglGetEndpointAttribNOK", aName, strlen("eglGetEndpointAttribNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglEndpointBeginStreamingNOK", aName, strlen("eglEndpointBeginStreamingNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglEndpointEndStreamingNOK", aName, strlen("eglEndpointEndStreamingNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglAcquireImageNOK", aName, strlen("eglAcquireImageNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglReleaseImageNOK", aName, strlen("eglReleaseImageNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglGetEndpointDirtyAreaNOK", aName, strlen("eglGetEndpointDirtyAreaNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglEndpointRequestNotificationNOK", aName, strlen("eglEndpointRequestNotificationNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglEndpointCancelNotificationNOK", aName, strlen("eglEndpointCancelNotificationNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglCreateEndpointNOK", aName, strlen("eglCreateEndpointNOK")) == 0)

        {

        return NULL;

        }

    else if (strncmp("eglSwapBuffersRegionNOK", aName, strlen("eglSwapBuffersRegionNOK")) == 0)

        {

        return NULL;

        }

	else if (strncmp("egl_Private_SignalSyncNOK", aName, strlen("egl_Private_SignalSyncNOK")) == 0)

		{

		return (ProcPointer)CEglSyncExtension::egl_Private_SignalSyncNOK;

		}

	else if (strncmp("eglCreateSyncKHR", aName, strlen("eglCreateSyncKHR")) == 0)

		{

		return (ProcPointer)CEglSyncExtension::eglCreateSyncKHR;

		}

	else if (strncmp("eglDestroySyncKHR", aName, strlen("eglDestroySyncKHR")) == 0)

		{

		return (ProcPointer)CEglSyncExtension::eglDestroySyncKHR;

		}

	else if (strncmp("eglClientWaitSyncKHR", aName, strlen("eglClientWaitSyncKHR")) == 0)

		{

		return (ProcPointer)CEglSyncExtension::eglClientWaitSyncKHR;

		}

	else if (strncmp("eglSignalSyncKHR", aName, strlen("eglSignalSyncKHR")) == 0)

		{

		return (ProcPointer)CEglSyncExtension::eglSignalSyncKHR;

		}

	else if (strncmp("eglGetSyncAttribKHR", aName, strlen("eglGetSyncAttribKHR")) == 0)

		{

		return (ProcPointer)CEglSyncExtension::eglGetSyncAttribKHR;

		}

    else

        {

        return NULL;

        }

	}

EGLSurface CGuestEGL::eglCreateWindowSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, 

		EGLNativeWindowType aNativeWindow, const EGLint *aAttribList)

	{

	// FAISALMEMON NEW

	/**

	 * pseudo code:

	 * 

	 * surfacemamanger.

	 * 	open()

	 *   createsurface(2 buffers, width, height, pixel format,...)

	 *   map surface -> get chunk

	 * serialization.eglCreateWindowSurface(..)

	 * eglinternalfunctioncreatesurface(chunk, width, height, ..)

	 * egl.... setwindowsurfacebuffers(...)

	 * surfaceupdatesession.connect()

	 * wnd.setbackgroundsurface()

	 */

	EGL_TRACE( "CGuestEGL::eglCreateWindowSurface");

	EGL_TRACE_ATTRIB_LIST(aAttribList);

	RWindow* window;

	window = (RWindow*) aNativeWindow;

	TSize size = window->Size();

	TSurfaceInfo* surfaceInfo = NULL;

    RSurfaceManager::TSurfaceCreationAttributesBuf buf;

    RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

    attributes.iSize = size;

    attributes.iBuffers = 2;           // REQUIREMENT because host side assumes exactly two buffers

    attributes.iPixelFormat = EUidPixelFormatARGB_8888;  // this is a guess; either query or hardcode to match syborg

    attributes.iStride = 4 * size.iWidth;          // Number of bytes between start of one line and start of next

    attributes.iOffsetToFirstBuffer = 0;

    attributes.iAlignment = RSurfaceManager::EPageAligned;                      // alignment, 1,2,4,8,16,32,64 byte aligned or EPageAligned

    attributes.iHintCount=0;  

    attributes.iSurfaceHints = NULL;

    attributes.iOffsetBetweenBuffers = 0;

    attributes.iContiguous = ETrue;

    attributes.iCacheAttrib = RSurfaceManager::ENotCached;      // Cache attributes

    attributes.iMappable = ETrue;

	iDisplayMapLock.WriteLock();

	CEglDisplayInfo** pDispInfo;

	pDispInfo = iDisplayMap.Find(aDisplay);

	if (pDispInfo && *pDispInfo)

			{

			RHeap* threadHeap = CVghwUtils::SwitchToVghwHeap();

			surfaceInfo = new TSurfaceInfo();

			if (surfaceInfo)

				{

				surfaceInfo->iNativeWindow = (RWindow*)aNativeWindow;

				surfaceInfo->iConfigId = aConfig;

				surfaceInfo->iSurfaceManager.Open();

				surfaceInfo->iSurfaceManager.CreateSurface(buf, surfaceInfo->iSurfaceId);

				TInt err =  surfaceInfo->iSurfaceManager.MapSurface(surfaceInfo->iSurfaceId, surfaceInfo->iChunk);

				EGL_TRACE("CGuestEGL::eglCreateWindowSurface surface manager returned chunk %x and ret val %d", surfaceInfo->iChunk, err);

				RemoteFunctionCallData rfcdata;

				EglRFC eglApiData( rfcdata );

				eglApiData.Init( EglRFC::EeglCreateWindowSurface);

				eglApiData.AppendEGLDisplay(aDisplay);

				eglApiData.AppendEGLConfig(aConfig);

				eglApiData.AppendEGLNativeWindowType(aNativeWindow);				

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

				eglApiData.AppendEGLint(size.iWidth);

				eglApiData.AppendEGLint(size.iHeight);

				eglApiData.AppendEGLint(1000); // horizontalPitch arbitrary

				eglApiData.AppendEGLint(1000); // verticalPitch arbitrary

				surfaceInfo->iHostSurfaceId = aThreadState.ExecEglSurfaceCmd(eglApiData); // todo check if is valid

				(*pDispInfo)->iSurfaceMap.Insert(surfaceInfo->iHostSurfaceId, surfaceInfo);

				EglInternalFunction_CreateSurface(aThreadState, aDisplay, surfaceInfo->iHostSurfaceId, aConfig, window, *surfaceInfo);

				surfaceInfo->iSurfaceUpdateSession.Connect();

				TSurfaceConfiguration surfaceConfig;

				surfaceConfig.SetSurfaceId(surfaceInfo->iSurfaceId);

				window->SetBackgroundSurface(surfaceConfig, ETrue);

				}

			CVghwUtils::SwitchFromVghwHeap(threadHeap);

			}

		iDisplayMapLock.Unlock();

	aThreadState.SetEglError(EGL_SUCCESS);

	return surfaceInfo->iHostSurfaceId;

	// FAISALMEMON END OF NEW

	}

const char* CGuestEGL::eglQueryString(EGLDisplay aDisplay, EGLint aName)

	{

	RemoteFunctionCallData rfcdata;

	EglRFC eglApiData( rfcdata );

	eglApiData.Init( EglRFC::EeglQueryString );

	eglApiData.AppendEGLDisplay(aDisplay);

	eglApiData.AppendEGLint(aName);

	TEglThreadState* threadState = CVghwUtils::CreateThreadState();

	EGLBoolean result = EGL_FALSE;

	if (threadState)

		{

		/*

		 * This command is pointless at the moment.  We actually want the host

		 * to return a string, not a boolean.  The serialization interface does

		 * not currently support the returning of strings from the host side,

		 * so there is no way to get back the result of the query properly.

		 * 

		 * We should improve the guest/host interface to add this support.  Then

		 * this code can be made "useful".  At the moment, returning true means

		 * the host knows about the extension and wants to reply with a non-NULL

		 * string. 

		 */

		result = threadState->ExecEglBooleanCmd(eglApiData);

		if (result == EGL_FALSE)

			{

			return NULL;

			}

		}

	switch (aName)

		{

		case EGL_CLIENT_APIS:

			return "OpenVG OpenGL_ES OpenGL_ES2";

		case EGL_EXTENSIONS:

			return "KHR_reusable_sync EGL_SYMBIAN_COMPOSITION";

		case EGL_VENDOR:

			return "Symbian Foundation";

		case EGL_VERSION:

			return "1.4 guestegl";

		}

	return NULL;

	}

// FAISALMEMON END OF STUB CODE

CGuestEGL::CGuestEGL() :

		iEglSyncExtension(NULL)

	{

	}

#ifdef FAISALMEMON_S4_SGIMAGE

void CGuestEGL::OpenSgResources()

	{

	// ToDo delay opening SgDriver until needed, as it force loads Open GL ES 1.1, GL ES 2 and Open VG DLLs if it finds them

	TInt err = iSgDriver.Open();

	EGL_TRACE("  CGuestEGL::Create SgDriver.Open err=%d", err);

	EGLPANIC_ASSERT(err == KErrNone, EEglPanicSgDriverCreateLocalFailed);

	TVersion sgImageVer = RSgDriver::Version();

	EGL_TRACE("  CGuestEGL::Create  sgImageVer=%d.%d", sgImageVer.iMajor, sgImageVer.iMinor);

	EGLPANIC_ASSERT(sgImageVer.iMajor == 1, EEglPanicBadSgDriverVersion);

	}

void CGuestEGL::CloseSgResources()

	{

	iSgDriver.Close();

	}

#else

void CGuestEGL::CloseSgResources()

	{

	}

void CGuestEGL::OpenSgResources()

	{

	}

#endif

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

// destructor

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

//

CGuestEGL::~CGuestEGL()

	{

	EGL_TRACE("CGuestEGL::~CGuestEGL");

	// only expected to be called during process termination

	if (iEglSyncExtension)

		{

		delete iEglSyncExtension;

		iEglSyncExtension = NULL;

		}

	iDisplayMapLock.Close();

	CloseSgResources();

	iEglImageLock.Close();

	}

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

// 2nd phase constructor

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

//

void CGuestEGL::Create()

	{

	EGL_TRACE("  CGuestEGL::Create -->");

    OpenSgResources();

    TInt err;

	err = iDisplayMapLock.CreateLocal();

	EGLPANIC_ASSERT(err == KErrNone, EEglPanicDisplayMapLockCreateLocalFailed);

	err = iEglImageLock.CreateLocal();

	EGLPANIC_ASSERT(err == KErrNone, EEglPanicEglImageLockCreateLocalFailed);	

	InitialiseExtensions();

	const char* initExtensionList = EglInternalFunction_QueryExtensionList();

	EGL_TRACE("  CGuestEGL::Create  initExtensionList=0x%x (\"%s\") <--",

			initExtensionList, initExtensionList ? initExtensionList : "");

	}

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

//

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

//

CGuestEGL* CGuestEGL::New()

	{

	EGL_TRACE("CGuestEGL::New  start -->");

	RHeap* threadHeap = CVghwUtils::SwitchToVghwHeap();

	CGuestEGL* result = new CGuestEGL();

	CVghwUtils::SwitchFromVghwHeap(threadHeap);

	EGLPANIC_ASSERT(result, EEglPanicGuestGraphicsAllocFailed);

	if (result)

		{

		result->Create();

		}

	EGL_TRACE("CGuestEGL::New end - result=0x%x  <--", result);

	return result;

	}

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

//

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

//

void CGuestEGL::SetError(EGLint aError)

	{ // ToDo remove - everything except EGL Sync already uses threadState->SetEglError

	EGL_TRACE( "CGuestEGL::SetError EGL error=0x%x", aError);

	TEglThreadState* threadState = CVghwUtils::EglThreadState();

	if (threadState)

		{

		threadState->SetEglError(aError);

		}

	}

EGLint CGuestEGL::CheckColorAttributes(const EGLint* aAttribList, EGLint aColorBufferType, EGLint aLuminanceBits, EGLint aRedBits,

		EGLint aGreenBits, EGLint aBlueBits, EGLint aAlphaBits)

	{

	const EGLint* pValue = TAttribUtils::FindAttribValue(aAttribList, EGL_COLOR_BUFFER_TYPE);

	if (pValue && (*pValue != aColorBufferType))

		{

		return EGL_BAD_MATCH;

		}

	EGLint colorBits = 0;

	if (aColorBufferType == EGL_RGB_BUFFER)

		{

		colorBits = aRedBits + aGreenBits + aBlueBits + aAlphaBits;

		pValue = TAttribUtils::FindAttribValue(aAttribList, EGL_RED_SIZE);

		if (pValue && (*pValue < aRedBits))

			{

			return EGL_BAD_MATCH;

			}

		pValue = TAttribUtils::FindAttribValue(aAttribList, EGL_GREEN_SIZE);

		if (pValue && (*pValue < aGreenBits))

			{

			return EGL_BAD_MATCH;

			}

		pValue = TAttribUtils::FindAttribValue(aAttribList, EGL_BLUE_SIZE);

		if (pValue && (*pValue < aBlueBits))

			{

			return EGL_BAD_MATCH;