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

#ifndef EGLPRIVATE_H
#define EGLPRIVATE_H

#include <e32std.h>
#include <e32base.h>
#include <e32hashtab.h>
#include <EGL/egl.h>

#include "riMiniEGL.h"

using namespace OpenVGRI;

#ifndef EGL_VERSION_1_4
#error Reference EGL requires at least EGL version 1.4 headers
#endif

// Panic category and codes
//
_LIT(KEglPanicCategory, "EGL");
enum TEglPanicCode
    {
    EEglPanicNotSupported = 1,
    EEglPanicPlsMutexError,
    EEglPanicDriverNull,
    EEglPanicInvalidHeap,
    EEglPanicDisplayStateInvalid,
    EEglPanicInvalidSyncObj,
    EEglPanicCondVarWaitFail,
    EEglPanicCondVarTimedWaitFail,
    EEglPanicInvalidSession,
    EEglPanicOutstandingSyncObj,
    EEglPanicSyncObjHasBeenDestroyed
    };

// Forward declarations
//
class CEglDriver;
class CEglDisplay;
class CEglThreadSession;
class CEglSync;

// Helper class to manage PLS
//
NONSHARABLE_CLASS(XEglPls)
	{
public:
	XEglPls();
	~XEglPls();
	
	inline void Lock();
	inline void Unlock();

public:
	RMutex iLock;
	TInt iError;
	CEglDriver* iDriver;
	};

// Function pointers
//
extern "C" 
{
typedef void (*TFuncPtrEglProc)(...);
}

typedef TFuncPtrEglProc (*TFuncPtrOwfGetProcAddress)(const char*);

// Function table used by OWF implementation
// The actual type and name of the structure is irrelevant here, 
// as long as its size and offset match it should be ok
//
NONSHARABLE_STRUCT(TOwfFuncTable)
    {
    TFuncPtrOwfGetProcAddress iOwfGetProcAddress;
    };

// EGL process state
//
NONSHARABLE_CLASS(CEglDriver): public CBase
	{
public:
	static TInt Open();
	static void Close();
	static CEglDriver* GetDriver();

	CEglDisplay* FindDisplay(EGLDisplay aDisplay) const;
    TFuncPtrEglProc GetProcAddress(const char* aName) const;
    inline void Lock();
    inline void Unlock();
    
#ifdef _DEBUG
    inline RHeap& Heap() const;
#endif

private:
	CEglDriver(RHeap& aHeap);
	~CEglDriver();
	TInt Construct();
	inline TBool IsDisplayValid(EGLDisplay aDisplay) const;
	
private:
	RMutex iLock;
	RHeap& iHeap;
	CEglDisplay* iDisplay;
	RLibrary iOwfLib;
	TOwfFuncTable iOwfFuncTable;
	TInt iRefCount;
	};

// Thread state and thread-specific tasks
//
NONSHARABLE_CLASS(CEglThreadSession): public CBase
	{
public:
	static CEglThreadSession* Static();
	~CEglThreadSession();
	
	// EGL APIs
	EGLint EglGetError();
	EGLDisplay EglGetDisplay(NativeDisplayType aDisplayId);
	EGLBoolean EglInitialize(EGLDisplay aDisplay, EGLint* aMajor, EGLint* aMinor);
	EGLBoolean EglTerminate(EGLDisplay aDisplay);
	const char* EglQueryString(EGLDisplay aDisplay, EGLint aName);
	EGLBoolean EglGetConfigs(EGLDisplay dpy, EGLConfig *configs,EGLint config_size, EGLint *num_config);
	EGLBoolean EglChooseConfig(EGLDisplay dpy,const EGLint *attrib_list, EGLConfig *configs,
			                   EGLint config_size,EGLint *num_config);
	EGLBoolean EglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,EGLint attribute, EGLint *value);
	EGLSurface EglCreateWindowSurface(EGLDisplay dpy,EGLConfig config, EGLNativeWindowType win, 
			                          const EGLint *attrib_list);
	EGLSurface EglCreatePbufferSurface(EGLDisplay dpy,EGLConfig config, const EGLint *attrib_list);
	EGLSurface EglCreatePixmapSurface(EGLDisplay dpy,EGLConfig config, EGLNativePixmapType pixmap,
			                          const EGLint *attrib_list);
	EGLSurface EglDestroySurface(EGLDisplay dpy, EGLSurface surface);
	EGLBoolean EglQuerySurface(EGLDisplay dpy, EGLSurface surface,EGLint attribute,EGLint *value);
	EGLBoolean EglBindAPI(EGLenum api);
	EGLenum EglQueryAPI(void);
	EGLBoolean EglWaitClient();
	EGLSurface EglCreatePbufferFromClientBuffer(EGLDisplay dpy,EGLenum buftype, EGLClientBuffer buffer, 
			                                    EGLConfig config,const EGLint *attrib_list);
	EGLBoolean EglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface,EGLint attribute, EGLint value);
	EGLBoolean EglBindTexImage(EGLDisplay dpy,EGLSurface surface, EGLint buffer);
	EGLBoolean EglReleaseTexImage(EGLDisplay dpy,EGLSurface surface, EGLint buffer);
	EGLBoolean EglSwapInterval(EGLDisplay dpy, EGLint interval);
	EGLContext EglCreateContext(EGLDisplay dpy, EGLConfig config,EGLContext share_context,
			                    const EGLint *attrib_list);
	EGLBoolean EglDestroyContext(EGLDisplay dpy, EGLContext ctx);
	EGLBoolean EglMakeCurrent(EGLDisplay dpy, EGLSurface draw,EGLSurface read, EGLContext ctx);
	EGLContext EglGetCurrentContext();
	EGLSurface EglGetCurrentSurface(EGLint readdraw);
	EGLDisplay EglGetCurrentDisplay();
	EGLBoolean EglQueryContext(EGLDisplay dpy, EGLContext ctx,EGLint attribute, EGLint* value);
	EGLBoolean EglWaitGL();
	EGLBoolean EglWaitNative(EGLint engine);
	EGLBoolean EglSwapBuffers(EGLDisplay dpy, EGLSurface surface);
	EGLBoolean EglCopyBuffers(EGLDisplay dpy, EGLSurface surface,EGLNativePixmapType target);
	
	TFuncPtrEglProc EglGetProcAddress(const char* aName);
	
	// EGLSync APIs
	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 APIs
	EGLint EglSignalSyncInternal(EGLDisplay aDisplay, EGLSyncKHR aSync, EGLenum aMode);
   
	void SetEgl(EGL* aEgl);
	EGL* getEgl();
	
	CEglThreadSession(CEglDriver& aDriver);
	// Debug APIs
#ifdef _DEBUG
	void EglHeapMarkStart();
	EGLint EglHeapMarkEnd(EGLint aCount);
	void EglHeapSetBurstAllocFail(EGLenum aType, EGLint aRate, EGLint aBurst);
#endif //_DEBUG
	
private:
	
    void SetError(EGLint aErrror);

private:
	CEglDriver& iDriver;
	EGLint iError;
	EGL* iEgl;
	};


// EGLDisplay implementation
//
const EGLDisplay KEglDefaultDisplayHandle = 0x01;

NONSHARABLE_CLASS(CEglDisplay): public CBase
	{
public:
	CEglDisplay(RHeap& aHeap);
	~CEglDisplay();
	
	TInt Initialize();
	void Terminate();
	inline TBool IsInitialized() const;
	inline RHeap& Heap() const;
	inline EGLDisplay Handle() const;

	CEglSync* CreateSyncObj();
	TInt DestroySyncObj(EGLSyncKHR aSyncObj);
    CEglSync* FindSyncObj(EGLSyncKHR aSyncObj) const;

    TInt RegisterSyncObj(CEglSync& aSyncObj);
    void UnregisterSyncObj(CEglSync& aSyncObj);

private:
    typedef RHashMap<TInt,CEglSync*> REglSyncHashMap;

    EGLDisplay iHandle;
	RHeap& iHeap;
	TBool iIsInitialized;
	REglSyncHashMap* iSyncObjList;
	};

// EGLSync implementation
//
NONSHARABLE_CLASS(CEglSync): public CBase 
    {
public:
    static CEglSync* Create(CEglDisplay& aDisplay);
    void Destroy();
    inline void Open();
    void Close();

    void Signal(EGLenum aMode);
    EGLint Wait(EGLTimeKHR aTimeOut);
    inline EGLenum Type() const;
    inline EGLenum Status() const;
    inline TBool IsDestroyed() const;

private:
    CEglSync(CEglDisplay& aDisplay);
    ~CEglSync();    
    TInt Construct();

private:
    CEglDisplay& iDisplay;
    EGLenum iType;
    EGLenum iStatus;
    RMutex iMutex;
    RCondVar iCondVar;
    TInt iRefCount;     // to determine when to delete this object
    TBool iIsDestroyed; // to prevent object from being used when its handle has been explicitly destroyed by client
    };

#include "eglprivate.inl"

#endif /* EGLPRIVATE_H */