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

   }