diff -r a4c94be9fb92 -r 220791dae4c4 guestrendering/guestegl/inc/guestegl.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/guestrendering/guestegl/inc/guestegl.h Wed Sep 08 15:45:18 2010 +0100 @@ -0,0 +1,410 @@ +// 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 Header file + +#ifndef __GUEST__EGL_H +#define __GUEST__EGL_H + + +// CLASS DECLARATION +typedef enum + { + EPixmapTypeNone, + EPixmapTypeFbsBitmap, + EPixmapTypeSgImage, + } TSymbianPixmapTypeId; + + +typedef enum + { + ESurfaceTypeWindow = 0, + ESurfaceTypePbuffer = 1, + ESurfaceTypePixmapFbsBitmap = 2, + ESurfaceTypePixmapSgImage = 3, + } TEglSurfaceType; + + +class RSurfaceManager; +class CEglContext; + +// client side info about a surface +struct TSurfaceInfo + { + TSize iSize; + TEglSurfaceType iSurfaceType; //Surface type + EGLConfig iConfigId; + CFbsBitmap* iFbsBitmap; // Handle for CFbsBitmap +#ifdef FAISALMEMON_S4_SGIMAGE + RSgDrawable iSgHandle; // Handle for RSgImge - keeps image open + TSgDrawableId iSgId; // SgImage Id - to detect 2nd attempted surface using the same SgImage +#endif + EGLSurface iHostSurfaceId; + // Note: most member data is only used by Window surfaces + TSurfaceId iSurfaceId; /* iSurfaceMap; +//private: +// RMutex iContextMapLock; + RHashMap iContextMap; + }; + + +// prototype to help eglGetProcAddress() API +typedef void (*ProcPointer)(...); + + +// Collection of static functions for processing EGL Attribute Lists +class TAttribUtils + { +public: // definitions in eglattribs.cpp + static TInt AttribListLength(const EGLint* aAttribList); + static const EGLint* FindAttribValue(const EGLint* aAttribList, EGLint aAttrib); + // NB only use these on AttribLists with adequate space for editing + static EGLint* FindAttribValue(EGLint* aAttribList, EGLint aAttrib); + static void AppendAttribValue(EGLint* aAttribList, EGLint aAttrib, EGLint aValue); + static void RemoveAttrib(EGLint* aAttribList, EGLint aAttrib); +#ifdef _DEBUG + // definitions in egldebug.cpp + static void TraceAttribList(const EGLint* aAttribList); + static void TraceAttribNames(EGLint aAttrib, EGLint aValue, char** aAttrName, char** aValueName); + static void TraceGetAttrib(char* aApiName, char* aObjType, EGLDisplay aDisplay, EGLint aObject, EGLint aAttribute, EGLint *aValue, EGLBoolean aResult); + static void TraceSetAttrib(char* aApiName, char* aObjType, EGLDisplay aDisplay, EGLint aObject, EGLint aAttribute, EGLint aValue); +#endif + }; + + +// CEglContext represents an EGLContext on Host EGL +NONSHARABLE_CLASS(CEglContext) : public CBase + { +public: + // factory function + static CEglContext* Create(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, CEglContext* aShareContext, const EGLint* aAttribList); + EGLBoolean MakeCurrent(TEglThreadState& aThreadState, EGLSurface aDraw, EGLSurface aRead); + EGLBoolean QueryAttribute(TEglThreadState& aThreadState, EGLint aAttribute, EGLint* aValue); + // These functions return ETrue if they delete themselves + TBool Destroy(TEglThreadState& aThreadState); + TBool MakeNotCurrent(TEglThreadState& aThreadState); + EGLContext ShareContextFamily(); + inline EGLContext HostContext() { return iHostContext; } + inline EGLContext ClientContext() { return iHostContext; } + inline TBool IsDestroyed() { return iIsDestroyed; } + +private: + CEglContext(EGLDisplay aDisplay, EGLConfig aConfig, EGLContext aShareContextFamily, EGLenum aRenderingApi, EGLint aGlesClientVersion); + void Delete(TEglThreadState& aThreadState); + ~CEglContext(); +private: + RMutex iCtxMutex; + TBool iFirstUse; // for eglMakeCurrent + EGLContext iHostContext; // corresponding Host EGL Context + // info from eglCreateContext & eglMakeCurrent + EGLDisplay iDisplay; + EGLContext iShareContextFamily; + EGLConfig iConfigId; // Config id used to create context + EGLenum iRenderingApi; // set by current bound API at creation + EGLSurface iDrawSurface; // currently bound draw surface, if any + // for GL ES Contexts + EGLSurface iReadSurface; // currently bound read surface, if any + EGLint iGlesClientVersion; // set by EGL_CONTEXT_CLIENT_VERSION attribute at creation (default is 1) + // object lifetime management + TBool iIsDestroyed; + }; + + +NONSHARABLE_CLASS(CEglImage) : public CBase + { +public: + CEglImage(); + ~CEglImage(); +#ifdef FAISALMEMON_S4_SGIMAGE + inline void Create(TSgDrawableId aSgImageId, EGLDisplay aDisplay, TSgImageInfo& aSgImageInfo, TInt aPbufferHandle, VGHandle aVgHandle); + TSgDrawableId SgImageId() const; +#endif + inline void Duplicate(); + inline TBool OpenForVgImage(TSize& aSize, VGHandle& aVgHandle, TUint64& aSgImageId); + inline TBool Close(); + inline TBool Destroy(); + inline TBool IsDestroyed() const; + inline TInt RefCount(); + inline EGLDisplay Display() const; + +private: +#ifdef FAISALMEMON_S4_SGIMAGE + RSgDrawable iSgHandle; // Client Handle + TSgImageInfo iSgImageInfo; +#endif + EGLDisplay iDisplay; + TInt iPbufferHandle; // Handle of the underlying Pbuffer, if any + VGHandle iVgHandle; // Handle of the underlying Host VgImage, if any + TInt iCreateCount; + TInt iOpenCount; + TBool iIsDestroyed; + }; + +const TInt KEglConfigSize = 29; + + +class XGuestEglInitialiser + { +public: + XGuestEglInitialiser(); + ~XGuestEglInitialiser(); + }; + + +/** + * CCGuestEGL + * + */ +NONSHARABLE_CLASS(CGuestEGL) : public CBase, public MEglManagementApi, + public MVgApiForEgl, public MGles11ApiForEgl, public MGles2ApiForEgl + { +public: + // Constructors and destructor + + /** + * Destructor. + */ + ~CGuestEGL(); + + /** + * Public constructor. + */ + static CGuestEGL* New(); + + // class MEglManagementApi - exported as a vtable via CVghwUtils for Open VG and Open GL ES to access EGL info + virtual TBool EglImageOpenForVgImage(EGLImageKHR aImage, TSize& aSize, VGHandle& aVgHandle, TUint64& aSgImageId); + virtual void EglImageClose(EGLImageKHR aImage); + + + // Private interfaces for EGL to call into Open VG & Open GL ES + // class MVgApiForEgl - redirects via CVghwUtils to exported functions from Open VG + virtual ExtensionProcPointer guestGetVgProcAddress (const char *aProcName); + // class MGles11ApiForEgl - redirects via CVghwUtils to exported functions from Open GL ES 1.1 + virtual ExtensionProcPointer guestGetGles11ProcAddress (const char *aProcName); + // class MGles2ApiForEgl - redirects via CVghwUtils to exported functions from Open GL ES 2 + virtual ExtensionProcPointer guestGetGles2ProcAddress (const char *aProcName); + + + // public support functions for EGL C API + static EGLint CheckColorAttributes(const EGLint* aAttribList, EGLint aColorBufferType, EGLint aLuminanceBits, + EGLint aRedBits, EGLint aGreenBits, EGLint aBlueBits, EGLint aAlphaBits=0); + static void AppendColorAttributes(EGLint* aAttribList, EGLint aColorBufferType, EGLint aLuminanceBits, EGLint aRedBits, + EGLint aGreenBits, EGLint aBlueBits, EGLint aAlphaBits=0, TBool aSetVgPreMultAlpha=EFalse); + + const char *QueryExtensionList(); + + // ToDo probably remove this after EGL Sync refactoring + void SetError( EGLint aError ); + void DestroySurfaceInfo(EGLDisplay aDisplay, EGLSurface aSurface); + + // static functions directly implementing an EGL API + ProcPointer eglGetProcAddress(const char *aProcName); + + // functions directly implementing an EGL API + EGLBoolean eglBindTexImage(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, EGLint aBuffer); + EGLBoolean eglChooseConfig(TEglThreadState& aThreadState, EGLDisplay aDisplay, const EGLint *aAttribList, + EGLConfig *aConfigs, EGLint aConfigSize, EGLint *aNumConfig); + EGLBoolean eglCopyBuffers(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, EGLNativePixmapType aTarget); + EGLContext eglCreateContext(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, + EGLContext aShareContext, const EGLint *aAttribList); + EGLImageKHR eglCreateImageKHR(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLContext aContext, EGLenum aTarget, + EGLClientBuffer aBuffer, const EGLint *aAttribList); + EGLSurface eglCreatePbufferFromClientBuffer(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLenum aBufType, + EGLClientBuffer aBuffer, EGLConfig aConfig, const EGLint *aAttribList); + EGLSurface eglCreatePbufferSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, const EGLint *aAttribList); + EGLSurface eglCreatePixmapSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, + EGLNativePixmapType aNativePixmap, const EGLint *aAttribList); + EGLSurface eglCreateWindowSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, + EGLNativeWindowType aNativeWindow, const EGLint *aAttribList); + EGLBoolean eglDestroyContext(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLContext aContext); + EGLBoolean eglDestroyImageKHR(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLImageKHR aImage); + EGLBoolean eglDestroySurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface); + EGLBoolean eglGetConfigAttrib(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, + EGLint aAttribute, EGLint *aValue); + EGLBoolean eglGetConfigs(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig *aConfigs, + EGLint aConfigSize, EGLint *aNumConfig); + EGLContext eglGetCurrentContext(TEglThreadState& aThreadState); + EGLDisplay eglGetCurrentDisplay(TEglThreadState& aThreadState); + EGLSurface eglGetCurrentSurface(TEglThreadState& aThreadState, EGLint aReadDraw); + EGLDisplay eglGetDisplay(TEglThreadState& aThreadState, EGLNativeDisplayType aDisplayId); + EGLBoolean eglInitialize(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLint *aMajor, EGLint *aMinor); + EGLBoolean eglMakeCurrent(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aDraw, EGLSurface aRead, + EGLContext aContext); + EGLBoolean eglQueryContext(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLContext aContext, EGLint aAttribute, EGLint *aValue); + const char* eglQueryString(EGLDisplay aDisplay, EGLint aName); + EGLBoolean eglQuerySurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, EGLint aAttribute, + EGLint *aValue); + EGLBoolean eglReleaseTexImage(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, EGLint aBuffer); + EGLBoolean eglSurfaceAttrib(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, + EGLint aAttribute, EGLint aValue); + EGLBoolean eglSwapBuffers(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface); + EGLBoolean eglSwapInterval(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLint aInterval); + EGLBoolean eglTerminate(TEglThreadState& aThreadState, EGLDisplay aDisplay); + EGLBoolean eglWaitClient(TEglThreadState& aThreadState); + +public: + // API supporting EGL sync extension + /*-------------------------------------------------------------------*//*! + * \brief Query and request to lock a specified display + * \ingroup eglSync + * \param aEglDisplay a display identifier + * \return EGL_SUCCESS if successful; + * EGL_BAD_DISPLAY is not a name of a valid EGLDisplay + * EGL_NOT_INITIALIZED if the display object associated + * with the has not been initialized + *//*-------------------------------------------------------------------*/ + EGLint FindAndLockDisplay(EGLDisplay aDisplay); + + /*-------------------------------------------------------------------*//*! + * \brief Releases the lock associated with a valid EGLDisplay + * \ingroup eglSync + * \param aEglDisplay a display identifier + *//*-------------------------------------------------------------------*/ + void ReleaseDisplayLock(EGLDisplay aDisplay); + + /*-------------------------------------------------------------------*//*! + * \brief Returns pointer to the EGL sync instance + * \ingroup eglSync + *//*-------------------------------------------------------------------*/ + CEglSyncExtension* EGLSyncExtension(); + +private: + /** + * private constructor, 2nd phase constructor + */ + CGuestEGL(); + void Create(); + void CloseSgResources(); + void OpenSgResources(); + + // private function with "EglInternalFunction_" prefix + TBool EglInternalFunction_CreateSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, EGLConfig aConfig, RWindow* aNativeWindow, TSurfaceInfo& aSurfaceInfo); + void EglInternalFunction_DestroyWindowSurface(TSurfaceInfo& aSurfaceInfo); + TUidPixelFormat EglInternalFunction_GetSymbianPixelFormat(const TSurfaceInfo& aSurfaceInfo); + EGLBoolean EglInternalFunction_CallSetSurfaceParams(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, TSurfaceInfo& aSurfaceInfo); + TBool EglInternalFunction_PixmapSurfacePreviouslyCreated(EGLNativePixmapType pixmap, TSymbianPixmapTypeId pixmapType); + static TSymbianPixmapTypeId EglInternalFunction_GetNativePixmapType(EGLNativePixmapType pixmap); + const char* EglInternalFunction_QueryExtensionList(); + TBool EglInternalFunction_IsValidNativePixmap(EGLNativePixmapType pixmap, TSymbianPixmapTypeId pixmapType); + EGLBoolean EglInternalFunction_SurfaceResized(TEglThreadState& aThreadState, TSurfaceInfo& aSurfaceInfo, EGLDisplay aDisplay, EGLSurface aSurface); + TSurfaceInfo* EglInternalFunction_GetPlatformSurface( EGLDisplay display, EGLSurface surface ); + void EglInternalFunction_AbortWindowInit(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface, TSurfaceInfo* ps, RWindow* window, CWsScreenDevice* screenDevice); + TBool EglInternalFunction_SwapWindowSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLSurface aSurface); + TInt EglInternalFunction_GetPitch( RWindow* aNativeWindow, TInt& aHorizontalPitch, TInt& aVerticalPitch ); + TBool EglInternalFunction_MetaGetConfigs( TEglThreadState& aThreadState, EGLConfig*& aConfigs, EGLint& aConfigCnt, EGLint*& aConfigAttribs, EGLint& aConfigAttribsLen, TMetaGetConfigsMode aFetchMode = EMetaGetConfigsSg ); + + // more private functions + + EGLint ConfigMatchesFbsBitmapPixmap(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, const EGLint* aAttribList, TDisplayMode aMode); + EGLBoolean ChooseConfigForPixmapSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, const EGLint* aAttribList, EGLConfig* aConfigs, EGLint aConfigSize, + EGLint* aNumConfig, const void* aPixmap); + EGLSurface CreateFbsBitmapSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, CFbsBitmap* aBitmap, const EGLint *aAttribList, TSurfaceInfo& aSurfaceInfo); + + EGLint ChooseConfigAttribsForFbsBitmap(TEglThreadState& aThreadState, const EGLint* aAttribList, const CFbsBitmap* aBitmap, EGLint** aNewList); + + EGLint ValidateEglImageTarget(EGLDisplay aDisplay, EGLContext aContext, EGLenum aTarget, + EGLClientBuffer aBuffer, const EGLint *aAttribList, TSymbianPixmapTypeId aTargetPixmapType); + + + TBool CreateDisplayInfo(EGLDisplay aDisplay); + TBool InitializeDisplayInfo(EGLDisplay aDisplay); + TBool IsDisplayInitialized(EGLDisplay aDisplay); + TBool DestroyDisplayInfo(EGLDisplay aDisplay); + +#ifdef FAISALMEMON_S4_SGIMAGE + EGLSurface CreateSgImageSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLConfig aConfig, const RSgImage* aSgImage, const EGLint *aAttribList, + TSurfaceInfo& aSurfaceInfo); + EGLImageKHR CreateNewEglImage(TEglThreadState& aThreadState, EGLDisplay aDisplay, TSgDrawableId aSgId, TSgImageInfo aSgImageInfo); + EGLImageKHR DuplicateEglImageIfItExists(EGLDisplay aDisplay, TSgDrawableId aSgId); + EGLint ChooseConfigAttribsForSgImage(TEglThreadState& aThreadState, const EGLint* aAttribList, const RSgImage* aSgImage, EGLint** aNewList); + EGLBoolean ChooseConfigForNativeSgImagePixmapSurface(TEglThreadState& aThreadState, EGLDisplay aDisplay, const EGLint* aAttribList, EGLConfig* aConfigs, EGLint aConfigSize, + EGLint* aNumConfig, const EGLint* aPixmap); +#endif +private: + //new methods supporting EGL Sync extension + EGLint InitialiseExtensions(); + +private: + RReadWriteLock iDisplayMapLock; // protects the iDisplayMap for multi-threaded clients + RHashMap iDisplayMap; + + RMutex iEglImageLock; // protects the iEglImageArray for multi-threaded clients + RPointerArray iEglImageArray; // ToDo use a Unique Id for the index/handle, rather than the object address + +#ifdef FAISALMEMON_S4_SGIMAGE + EGLint* iSgConfigAttribs; + EGLint iSgConfigsAttribtCnt; + // ToDo (SgImage Design Spec 3.5) ARM EGL should maintain its own lists of native window handles, pixmap handles etc + + char* iEglExtnNameList; // supporting data for eglQueryString() + RSgDriver iSgDriver; +#endif + //data members supporting EGL Sync extension + CEglSyncExtension* iEglSyncExtension; + // vtable pointers populated from CVghwUtils - to access Open VG & GL ES internals, e.g. to support eglGetProcAddress + MVgApiForEgl* iVgApiForEgl; + MGles11ApiForEgl* iGles11ApiForEgl; + MGles2ApiForEgl* iGles2ApiForEgl; + }; + + +/* Execute host EGL functions that cannot fail + These functions do not set the flag to say that an EGL command has been executed since the last host eglGetError. + */ + +inline EGLContext ExecEglContextNoErrorCmd(TEglThreadState& aThreadState, EglRFC& aEglApiData) + { + aThreadState.ExecuteEglNeverErrorCmd(aEglApiData); + return (EGLContext) aEglApiData.ReturnValue(); + } + +inline EGLSurface ExecEglSurfaceNoErrorCmd(TEglThreadState& aThreadState, EglRFC& aEglApiData) + { + aThreadState.ExecuteEglNeverErrorCmd(aEglApiData); + return (EGLSurface) aEglApiData.ReturnValue(); + } + +inline EGLDisplay ExecEglDisplayNoErrorCmd(TEglThreadState& aThreadState, EglRFC& aEglApiData) + { + aThreadState.ExecuteEglNeverErrorCmd(aEglApiData); + return (EGLDisplay) aEglApiData.ReturnValue(); + } + + +#endif // __GUEST__EGL_H