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

 // Reference EGL implementation to support EGL sync objects and OpenWF extensions

 #include "eglprivate.h"

 #include <EGL/egluids.hrh>

 #include <e32uid.h>

 #include <WF/openwfcuids.hrh>

 // OpenWF Composition library

 //

 _LIT(KOwfDllName, "libWFC.dll");

 const TUid KOwfDllUid1 = {KDynamicLibraryUidValue};

 const TUid KOwfDllUid2 = {KUidSharedDllUidValue};

 const TUid KOwfDllUid3 = {KUidOpenWfcDllUidValue};

 const TUidType KOwfDllUidType = TUidType(KOwfDllUid1, KOwfDllUid2, KOwfDllUid3);

 // EGL_KHR_reusable_sync extensions API

 // Declare here so their addresses can be used to build extensions table

 //

 EGLSyncKHR eglCreateSyncKHR(EGLDisplay aDisplay, EGLenum aType, const EGLint *aAttribList);

 EGLBoolean eglDestroySyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync);

 EGLint eglClientWaitSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLint aFlags, EGLTimeKHR aTimeout);

 EGLBoolean eglSignalSyncKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode);

 EGLBoolean eglGetSyncAttribKHR(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLint aAttribute, EGLint *aValue);

 // Private extensions

 //

 EGLint egl_Private_SignalSyncNOK(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode);

 // Extensions for shared heap OOM test

 #ifdef _DEBUG

 void egliDebugHeapMarkStart();

 EGLint egliDebugHeapMarkEnd(EGLint aCount);

 void egliDebugSetBurstAllocFail(EGLenum aType, EGLint aRate, EGLint aBurst);

 #endif //_DEBUG

 struct TEglNameProcRecord

     {

     char* iName;

     TFuncPtrEglProc iProc;

     };

 #define MAKE_NAME_PROC_RECORD(f)    {#f,reinterpret_cast<TFuncPtrEglProc>(f)}

 const TEglNameProcRecord KEglExtensionFuncs[] = {

     MAKE_NAME_PROC_RECORD(eglCreateSyncKHR),

     MAKE_NAME_PROC_RECORD(eglDestroySyncKHR),

     MAKE_NAME_PROC_RECORD(eglClientWaitSyncKHR),

     MAKE_NAME_PROC_RECORD(eglSignalSyncKHR),

     MAKE_NAME_PROC_RECORD(eglGetSyncAttribKHR),

     MAKE_NAME_PROC_RECORD(egl_Private_SignalSyncNOK) 

 #ifdef _DEBUG

     ,

     MAKE_NAME_PROC_RECORD(egliDebugHeapMarkStart),

     MAKE_NAME_PROC_RECORD(egliDebugHeapMarkEnd),

     MAKE_NAME_PROC_RECORD(egliDebugSetBurstAllocFail)

 #endif //_DEBUG

 };

 // Use common EglPls() function to hide difference between WINS and target in dealing with PLS

 //

 #ifdef __WINS__

 #include <pls.h>

 static inline XEglPls* EglPls()

 	{

 	const TUid KUidEglDll = {KUidEGLDllUidValue};

 	return Pls<XEglPls>(KUidEglDll);

 	}

 #else

 static XEglPls TheEglPls;

 static inline XEglPls* EglPls()

 	{

 	return &TheEglPls;

 	}

 #endif

 // Macros for placement new and delete of shared objects

 //

 #define EGL_PLACEMENT_NEW(heap, obj, klass)         klass* obj = NULL; \

                                                     TAny* buf = (heap).AllocZ(sizeof(klass)); \

                                                     if (buf) \

                                                         { \

                                                         obj = new(buf) klass((heap)); \

                                                         }

 #define EGL_PLACEMENT_DELETE(heap, obj, klass)      obj->~klass(); \

                                                     (heap).Free(obj);

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

 // PLS

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

 XEglPls::XEglPls()

 	{

 	iError = iLock.CreateLocal();

 	iDriver = NULL;

 	}

 XEglPls::~XEglPls()

 	{

 	iLock.Close();

 	}

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

 // EGL driver

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

 CEglDriver::CEglDriver(RHeap& aHeap):

 	iHeap(aHeap)

 	{

 	}

 CEglDriver::~CEglDriver()

 	{

 	// EGL display was allocated on shared heap using placement new

 	if (iDisplay)

 		{

 		EGL_PLACEMENT_DELETE(iHeap, iDisplay, CEglDisplay)

 		}

 	iOwfLib.Close();

 	iLock.Close();

 	}

 TInt CEglDriver::Open()

 	{

 	// we're in trouble if mutex creation failed during DLL initialisation

 	XEglPls& pls = *EglPls();

 	if (pls.iError != KErrNone)

 		{

 		return pls.iError;

 		}

 	pls.Lock();

 	if (pls.iDriver)

 		{

 		++(pls.iDriver->iRefCount);

 		pls.Unlock();

 		return KErrNone;

 		}

 	// create shared heap in a local chunk to allow access to shared objects from any threads within Driver

 	// allow heap to grow from 256 bytes up to 1MB

 	const TInt KMaxHeapSize = 0x100000;

 	const TInt KWordAlign = 4;

 	RHeap* heap = User::ChunkHeap(NULL, KMinHeapSize, KMaxHeapSize, KMinHeapGrowBy, KWordAlign);

 	if (!heap)

 		{

 		pls.Unlock();

 		return KErrNoMemory;

 		}

 	EGL_PLACEMENT_NEW(*heap, drv, CEglDriver)

 	if (!drv)

 		{

 		heap->Close();

 		pls.Unlock();

 		return KErrNoMemory;

 		}

 	const TInt err = drv->Construct();

 	if (err != KErrNone)

 		{

 		EGL_PLACEMENT_DELETE(*heap, drv, CEglDriver)

 		heap->Close();

 		pls.Unlock();

 		return err;

 		}

 	pls.iDriver = drv;

 	pls.iDriver->iRefCount = 1;

 	pls.Unlock();

 	return KErrNone;

 	}

 void CEglDriver::Close()

 	{

 	XEglPls& pls = *EglPls();

 	// must never happen if CEglDriver::Open() succeed

 	__ASSERT_DEBUG(pls.iError == KErrNone, User::Panic(KEglPanicCategory, EEglPanicPlsMutexError));

 	pls.Lock();

 	if (pls.iDriver)

 		{

 		if (--(pls.iDriver->iRefCount) == 0)

 			{

 			// copy shared heap pointer out as we're about to destroy the driver

 			RHeap& heap = pls.iDriver->iHeap;

 			// driver was allocated on shared heap using placement new

 			EGL_PLACEMENT_DELETE(heap, pls.iDriver, CEglDriver)

 			pls.iDriver = NULL;

 			heap.Close();

 			}

 		}

 	pls.Unlock();

 	}

 CEglDriver* CEglDriver::GetDriver()

     {

     XEglPls& pls = *EglPls();

     return pls.iDriver;    

     }

 // called when lock is held

 //

 TInt CEglDriver::Construct()

 	{

 	TInt err = iLock.CreateLocal();

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	// create default EGL display as part of driver initialisation, it will be destroyed when the driver is destroyed

 	// and recreated when driver is reinitialised

     EGL_PLACEMENT_NEW(iHeap, disp, CEglDisplay)

     if (!disp)

         {

         return KErrNoMemory;

         }

     iDisplay = disp;

 	// for security reason, use TUidType when loading OWF library to make sure it is not a spoofed DLL with the same name

 	err = iOwfLib.Load(KOwfDllName, KOwfDllUidType);

 	// allow initialisation to proceed even if OWF library is not found

 	if (err == KErrNone)

 	    {

         // promote library handle from thread-relative to process-wide to allow closing from any thread

         RLibrary dup = iOwfLib;

         err = iOwfLib.Duplicate(RThread());

         if (err != KErrNone)

             {

             return err;

             }

         // if Duplicate succeed, it will overwrite iOwfLib with process-wide handle

         // we need to close the original thread-relative handle

         dup.Close();

         // In SymbianOS implementation of Khronos API, ordinal #1 is always reserved for internal implementation use as defined in

         // SymbianOS standard DEF files for that API. This DEF file ensures BC among different implementations of that API.

         // In OWF case, ordinal #1 refers to GetExtensionFunctionTable, a function which will return a table of function pointer.

         // One of them is a function that implement GetProcAddress to retrieve OWF extension functions.

         //

         const TInt KOwfGetFuncTableOrdinalNum = 1;

         typedef void (*TFuncPtrOwfGetFuncTable)(TOwfFuncTable*);

         TFuncPtrOwfGetFuncTable owfGetFuncTable = reinterpret_cast<TFuncPtrOwfGetFuncTable>(iOwfLib.Lookup(KOwfGetFuncTableOrdinalNum));

         if (!owfGetFuncTable)

             {

             return KErrNotFound;

             }

         owfGetFuncTable(&iOwfFuncTable);

         if (!iOwfFuncTable.iOwfGetProcAddress)

             {

             return KErrNotSupported;

             }

 	    }

 	return  KErrNone;

 	}

 TFuncPtrEglProc CEglDriver::GetProcAddress(const char* aName) const

    {

    // start with EGL extension functions

    //

    TPtrC8 procName(reinterpret_cast<const TUint8*>(aName));

    const TInt nExts = sizeof(KEglExtensionFuncs) / sizeof(KEglExtensionFuncs[0]);

    for (TInt idx=0; idx<nExts; ++idx)

        {

        if (procName == TPtrC8(reinterpret_cast<TUint8*>(KEglExtensionFuncs[idx].iName)))

            {

            return KEglExtensionFuncs[idx].iProc;

            }

        }

    // not an EGL extension, pass it on to OWF

    //

    return iOwfFuncTable.iOwfGetProcAddress ? iOwfFuncTable.iOwfGetProcAddress(aName) : NULL;

    }