// 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;+
−
   }+
−