--- a/guestrendering/vghwutils/src/vghwutils.cpp Wed Sep 29 09:49:13 2010 +0100
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,908 +0,0 @@
-// 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:
-
-
-#include <e32atomics.h>
-#include <e32debug.h>
-
-#include <graphics/guestvideodriver.h>
-
-#include "vghwutils.h"
-#include "eglrfc.h"
-#include "openvgrfc.h"
-#include "opengles11rfc.h"
-
-#ifdef _DEBUG
-#define EGL_ERROR_PRINT(T, E) EglErrorPrint(T, E)
-#define GLES_ERROR_PRINT(T, E) GlesErrorPrint(T, E)
-#define VG_ERROR_PRINT(T, E) VgErrorPrint(T, E)
-static void EglErrorPrint(char* aTitle, EGLint aEglError);
-static void GlesErrorPrint(char* aTitle, GLenum aGlesError);
-static void VgErrorPrint(char* aTitle, VGErrorCode aVgError);
-#else
-#define EGL_ERROR_PRINT(T, E)
-#define GLES_ERROR_PRINT(T, E)
-#define VG_ERROR_PRINT(T, E)
-#endif
-
-
-// Min & Max sizes for creating Memory Heap for Guest Graphics DLLs
-#define KVghwHeapMin 0x1000
-#define KVghwHeapMax 0x100000
-
-
-// protection against concurrent initialisation from multiple threads
-volatile TBool CVghwUtils::iInitialized = EFalse;
-TInt CVghwUtils::iVghwInitMutex = 0;
-
-// static member objects - Writeable Static Data
-RGuestVideoDriver* CVghwUtils::iDriver = NULL;
-RHeap* CVghwUtils::iHeap = NULL;
-MEglManagementApi* CVghwUtils::iEglManagementApi = NULL;
-MVgApiForEgl* CVghwUtils::iVgApiForEgl = NULL;
-MGles11ApiForEgl* CVghwUtils::iGles11ApiForEgl = NULL;
-MGles2ApiForEgl* CVghwUtils::iGles2ApiForEgl = NULL;
-TBool CVghwUtils::iLoadedOpenVgDll = EFalse;
-TBool CVghwUtils::iLoadedOpenGles11Dll = EFalse;
-TBool CVghwUtils::iLoadedOpenGles2Dll = EFalse;
-
-
-
-_LIT(KVghwPanicCategory, "Guest VGHW");
-
-
-// NOTE: Exported because some VGHW functions are inline and could Assert & Panic from somewhere else
-EXPORT_C void VghwPanic(TVghwPanic aPanicCode, char* aPanicName, char* aCondition, char* aFile, TInt aLine)
- {
- if (aCondition && aFile)
- {
- RDebug::Printf("VghwUtils Panic %s for failed Assert (%s), at %s:%d", aPanicName, aCondition, aFile, aLine);
- }
- else
- {
- RDebug::Printf("VghwUtils Panic %d for failed Assert (line %d)", aPanicCode, aLine);
- }
-
- User::Panic(KVghwPanicCategory, aPanicCode);
- }
-
-// inline functions
-
-RGuestVideoDriver& CVghwUtils::Driver()
- {
- // TODO remove this later in refactoring - Open VG & GL ES commands should not reach here before EGL has initialized the singleton
- if (!iInitialized || !iDriver)
- {
- UTIL_TRACE("CVghwUtils::Driver called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iInitialized && iDriver, EVghwPanicGraphicsDriverNotOpen);
- return *iDriver;
- }
-
-
-EXPORT_C void CVghwUtils::DestroyStatics()
- {
-#ifdef _DEBUG
- TUint64 processId = RProcess().Id().Id();
- TUint64 threadId = RThread().Id().Id();
- UTIL_TRACE("CVghwUtils::DestroyStatics iInitialized=%d, iDriver=0x%x, iHeap=0x%x, Process=0x%lx, Thread=0x%lx",
- iInitialized, iDriver, iHeap, processId, threadId);
-#endif
- if (iHeap)
- {
- if (iDriver)
- {
- iDriver->Flush();
- iDriver->Close();
- RHeap* threadHeap = SwitchToVghwHeap();
- delete iDriver;
- SwitchFromVghwHeap(threadHeap);
- iDriver = NULL;
- }
- iHeap->Reset();
- iHeap->Close();
- iHeap = NULL;
- }
- if (iInitialized)
- {
- iInitialized = EFalse;
- }
- }
-
-
-// Ensure Graphics memory heap is created, and Open driver channel
-EXPORT_C void CVghwUtils::InitStatics()
- {
-#ifdef _DEBUG
- TUint64 processId = RProcess().Id().Id();
- TUint64 threadId = RThread().Id().Id();
- UTIL_TRACE("CVghwUtils::InitStatics start Process=0x%lx, Thread=0x%lx, iInitialized=%d",
- processId, threadId, iInitialized);
-#endif
- // bootstrap creation of mutexes and Graphics memory heap
- while (!iInitialized)
- {
- TInt creationError = KErrNone;
- // thread safe initialization
- // LockedDec() returns the value prior to decrement
- if (0 != User::LockedDec(iVghwInitMutex))
- {
- User::AfterHighRes(1000); // Yield X microseconds, review length if code is changed
- }
- else
- {
- // volatile attribute forces rereading of the pointer, in case another thread has done the allocation
- if (!iInitialized)
- { // loop style init exits if any stage fails, and gives per step debug logging
- TInt step = 0;
- do
- {
- switch (step)
- {
- case 0:
- // guarantee that initialisation of the object is flushed before the pointer is published
- __e32_atomic_store_rel_ptr(&iHeap, User::ChunkHeap(NULL, KVghwHeapMin, KVghwHeapMax));
- if (!iHeap)
- {
- creationError = KErrNoMemory;
- }
- break;
- case 1:
- {
- VGHWPANIC_ASSERT_DEBUG(iHeap, EVghwPanicVghwHeapDoesNotExist);
- RHeap* threadHeap = User::SwitchHeap(iHeap); // switch to VGHW graphics Heap
- iDriver = new RGuestVideoDriver();
- if (!iDriver)
- {
- creationError = KErrNoMemory;
- }
- User::SwitchHeap(threadHeap); // switch back to client Heap
- }
- break;
- case 2:
- creationError = User::LoadLogicalDevice(_L("guestvideohw"));
- if ( (KErrNone == creationError) || (KErrAlreadyExists == creationError) )
- {
- creationError = iDriver->Open();
- }
- break;
- default: // all initialisation steps completed
- iInitialized = ETrue;
- }
- ++step;
- }
- while (!iInitialized && !creationError);
- UTIL_TRACE("CVghwUtils::InitStatics %s step=%d; creationError=%d, iInitialized=%d, iDriver=0x%x, iHeap=0x%x",
- creationError ? "failed at" : "completed", step, creationError, iInitialized, iDriver, iHeap);
- }
- }
- User::LockedInc(iVghwInitMutex);
-
- VGHWPANIC_ASSERT(creationError == KErrNone, EVghwPanicInitializeFailed);
- }
- }
-
-
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C void CVghwUtils::DriverExecuteCommand(RemoteFunctionCallData& aRequestData)
- {
- if (!iInitialized || !iDriver)
- {
- UTIL_TRACE("CVghwUtils::DriverExecuteCommand called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iInitialized && iDriver, EVghwPanicGraphicsDriverNotOpen);
- iDriver->ExecuteCommand(aRequestData);
- }
-
-
-// -----------------------------------------------------------------------------
-// Use driver to discover linear memory address of chunk.
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CVghwUtils::MapToHWAddress( const TInt aChunkHandle, TUint32& aHWAddress )
- {
- UTIL_TRACE("CVghwUtils::MapToHWAddress");
- return Driver().MapToHWAddress( aChunkHandle, aHWAddress );
- }
-
-
-// SgImage support function - get underlying VGImage & Pbuffer handles
-EXPORT_C TInt CVghwUtils::EglGetSgHandles( const TUint64 aId, TUint64 *aSgHandles )
- {
- UTIL_TRACE("CVghwUtils::EglGetSgHandles");
- return Driver().EglGetSgHandles( aId, aSgHandles );
- }
-
-
-// Memory Heap Management functions
-
-EXPORT_C TAny* CVghwUtils::Alloc(TInt aSize)
- {
- if (!iInitialized || !iHeap)
- {
- UTIL_TRACE("CVghwUtils::Alloc called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iInitialized && iHeap, EVghwPanicVghwHeapDoesNotExist);
- return iHeap->Alloc(aSize);
- }
-
-
-EXPORT_C void CVghwUtils::Free(TAny* aPtr)
- {
- if (!iInitialized || !iHeap)
- {
- UTIL_TRACE("CVghwUtils::Free called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iInitialized && iHeap, EVghwPanicVghwHeapDoesNotExist);
- iHeap->Free(aPtr);
- }
-
-
-EXPORT_C RHeap* CVghwUtils::GetHeap()
- {
- if (!iInitialized || !iHeap)
- {
- UTIL_TRACE("CVghwUtils::GetHeap called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iInitialized && iHeap, EVghwPanicVghwHeapDoesNotExist);
- return iHeap;
- }
-
-
-// Switch to VGHW Memory Heap.
-EXPORT_C RHeap* CVghwUtils::SwitchToVghwHeap()
- {
- if (!iInitialized || !iHeap)
- {
- UTIL_TRACE("CVghwUtils::SwitchToVghwHeap called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iHeap, EVghwPanicVghwHeapDoesNotExist);
- RHeap* oldHeap = User::SwitchHeap(iHeap); // switch to Guest graphics heap
- VGHWPANIC_ASSERT(oldHeap != iHeap, EVghwPanicSwitchToVghwHeapOldHeapIsVghwHeap);
- return oldHeap;
- }
-
-
-// Switch back to original heap
-EXPORT_C void CVghwUtils::SwitchFromVghwHeap(RHeap* aOldHeapPtr)
- {
- if (!iInitialized || !iHeap)
- {
- UTIL_TRACE("CVghwUtils::SwitchFromVghwHeap called before EGL has initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iHeap, EVghwPanicVghwHeapDoesNotExist);
- VGHWPANIC_ASSERT(aOldHeapPtr, EVghwPanicSwitchFromVghwHeapParamIsNull);
- VGHWPANIC_ASSERT(aOldHeapPtr != iHeap, EVghwPanicSwitchFromVghwHeapParamIsVghwHeap);
-
- RHeap* oldHeap = User::SwitchHeap(aOldHeapPtr); // switch from Guest graphics heap back to thread heap
- VGHWPANIC_ASSERT(oldHeap == iHeap, EVghwPanicSwitchFromVghwHeapOldHeapIsNotVghwHeap);
- }
-
-
-// if this thread does not have an object try to alloc a new one
-EXPORT_C TEglThreadState* CVghwUtils::CreateThreadState()
- {
- TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());
- if (!threadState)
- {
- UTIL_TRACE("CVghwUtils::CreateThreadState - object is currently 0x%x, iInitialized=%d",
- threadState, iInitialized);
- if (!iInitialized)
- {
- InitStatics();
- }
- threadState = TEglThreadState::New();
- Dll::SetTls(threadState);
- }
- return threadState;
- }
-
-
-// current state object, if any, for this thread
-EXPORT_C TEglThreadState* CVghwUtils::EglThreadState()
- {
- TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());
- return threadState;
- }
-
-
-// current state object, if Open VG is the current bound API, for this thread
-EXPORT_C MVgContext* CVghwUtils::VgContext()
- {
- TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());
- return threadState;
- // ToDo sort this to check for valid Open VG context
- /*
- if (threadState && threadState->VgEglContext())
- return threadState;
- return NULL;
- */
- }
-
-
-// current state object, if Open GL ES is the current bound API, for this thread (for EGL)
-EXPORT_C MGlesContext* CVghwUtils::GlesContext()
- {
- TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());
- return threadState;
- // ToDo sort this to check for valid Open GL ES context
- /*
- if (threadState && threadState->GlesEglContext())
- return threadState;
- return NULL; */
- }
-
-
-// free current state object, if any, for this thread
-EXPORT_C void CVghwUtils::ReleaseThreadState()
- {
- TEglThreadState* threadState = reinterpret_cast<TEglThreadState*>(Dll::Tls());
- UTIL_TRACE("CVghwUtils::ReleaseThreadState - object = 0x%x", threadState);
- if (threadState)
- {
- threadState->Destroy();
- Dll::FreeTls();
- }
- }
-
-
-EXPORT_C MEglManagementApi* CVghwUtils::EglManagementApi()
- {
- return iEglManagementApi;
- }
-
-
-EXPORT_C void CVghwUtils::SetEglManagementApi(MEglManagementApi* aEglManagementApi)
- {
- UTIL_TRACE("CVghwUtils::SetEglManagementApi aEglManagementApi=0x%x", aEglManagementApi);
- iEglManagementApi = aEglManagementApi;
- }
-
-
-/*
- Stored pointers into Open GL ES 1.1, GL ES 2 and Open VG are problematic if the DLL is later unloaded.
- (RSgDriver::Open currently loads & unloads all the Open VG & GL ES DLLs, to determine features to publish.)
- Possibly Open the DLL again when the non-NULL pointer is fetched by EGL, probably needs flags so that
- this is only done once.
- */
-EXPORT_C void CVghwUtils::SetVgApiForEgl(MVgApiForEgl* aVgApiForEgl)
- {
- UTIL_TRACE("CVghwUtils::SetVgApiForEgl aVgApiForEgl=0x%x, iVgApiForEgl=0x%x, iLoadedOpenVgDll=0x%x",
- aVgApiForEgl, iVgApiForEgl, iLoadedOpenVgDll);
- // don't let a thread set this to NULL if we have forced the DLL to stay loaded
- if (aVgApiForEgl || !iLoadedOpenVgDll)
- {
- iVgApiForEgl = aVgApiForEgl;
- }
- }
-
-
-EXPORT_C MVgApiForEgl* CVghwUtils::VgApiForEgl()
- {
- if (iVgApiForEgl && !iLoadedOpenVgDll)
- { // ensure Open VG DLL stays loaded from now on
- _LIT(KLibOpenVg, "libOpenVG.dll");
- RLibrary lib;
- if (lib.Load(KLibOpenVg) == KErrNone)
- {
- UTIL_TRACE("CVghwUtils::VgApiForEgl - Open VG dll loaded, iVgApiForEgl=0x%x", iVgApiForEgl);
- iLoadedOpenVgDll = ETrue;
- return iVgApiForEgl;
- }
- }
- UTIL_TRACE("CVghwUtils::VgApiForEgl - Open VG dll not loaded or not safe to use");
- return NULL;
- }
-
-
-EXPORT_C void CVghwUtils::SetGles11ApiForEgl(MGles11ApiForEgl* aGles11ApiForEgl)
- {
- UTIL_TRACE("CVghwUtils::SetGles11ApiForEgl aGles11ApiForEgl=0x%x, iGles11ApiForEgl=0x%x, iLoadedOpenGles11Dll=0x%x",
- aGles11ApiForEgl, iGles11ApiForEgl, iLoadedOpenGles11Dll);
- // don't let a thread set this to NULL if we have forced the DLL to stay loaded
- if (aGles11ApiForEgl || !iLoadedOpenGles11Dll)
- {
- iGles11ApiForEgl = aGles11ApiForEgl;
- }
- }
-
-
-EXPORT_C MGles11ApiForEgl* CVghwUtils::Gles11ApiForEgl()
- {
- if (iGles11ApiForEgl && !iLoadedOpenGles11Dll)
- { // ensure Open VG DLL stays loaded from now on
- _LIT(KLibOpenGles, "libGLESv1_CM.dll");
- RLibrary lib;
- if (lib.Load(KLibOpenGles) == KErrNone)
- {
- UTIL_TRACE("CVghwUtils::Gles11ApiForEgl - Open GL ES 1.1 dll loaded, iGles11ApiForEgl=0x%x", iGles11ApiForEgl);
- iLoadedOpenGles11Dll = ETrue;
- return iGles11ApiForEgl;
- }
- }
- UTIL_TRACE("CVghwUtils::Gles11ApiForEgl - Open GL ES 1.1 dll not loaded or not safe to use");
- return NULL;
- }
-
-
-EXPORT_C void CVghwUtils::SetGles2ApiForEgl(MGles2ApiForEgl* aGles2ApiForEgl)
- {
- UTIL_TRACE("CVghwUtils::SetGles2ApiForEgl aGles2ApiForEgl=0x%x, iGles2ApiForEgl=0x%x, iLoadedOpenGles2Dll=0x%x",
- aGles2ApiForEgl, iGles2ApiForEgl, iLoadedOpenGles2Dll);
- // don't let a thread set this to NULL if we have forced the DLL to stay loaded
- if (aGles2ApiForEgl || !iLoadedOpenGles2Dll)
- {
- iGles2ApiForEgl = aGles2ApiForEgl;
- }
- }
-
-
-EXPORT_C MGles2ApiForEgl* CVghwUtils::Gles2ApiForEgl()
- {
- if (iGles2ApiForEgl && !iLoadedOpenGles2Dll)
- { // ensure Open VG DLL stays loaded from now on
- _LIT(KLibOpenGles2, "libGLESv2.dll");
- RLibrary lib;
- if (lib.Load(KLibOpenGles2) == KErrNone)
- {
- UTIL_TRACE("CVghwUtils::Gles2ApiForEgl - Open GL ES 2 dll loaded, iGles2ApiForEgl=0x%x", iGles2ApiForEgl);
- iLoadedOpenGles2Dll = ETrue;
- return iGles2ApiForEgl;
- }
- }
- UTIL_TRACE("CVghwUtils::Gles2ApiForEgl - Open GL ES 2 dll not loaded or not safe to use");
- return NULL;
- }
-
-
-////////////////////////////////////////////////////////////////////////////////////
-
-// factory method
-TEglThreadState* TEglThreadState::New()
- {
- UTIL_TRACE("TEglThreadState::New");
- RHeap* currentHeap = CVghwUtils::SwitchToVghwHeap();
- TEglThreadState* self = new TEglThreadState();
- CVghwUtils::SwitchFromVghwHeap(currentHeap);
- return self;
- }
-
-
-TEglThreadState::TEglThreadState() :
- // EGL thread state
- iEglError(EGL_SUCCESS),
- iEglHostHasRecentError(EFalse),
- // currently bound graphics API, initial value from EGL spec
- iEglBoundApi(EGL_OPENGL_ES_API),
- // Open VG thread state
- iVgError(VG_NO_ERROR),
- iVgEglContext(EGL_NO_CONTEXT),
- iVgCommandsSinceGetError(EFalse),
- iVgCommandsSinceFlush(EFalse),
- iVgCommandsSinceFinish(EFalse),
- // Open GL ES 1.1 state
- iGlesError(GL_NO_ERROR),
- iGlesEglContext(EGL_NO_CONTEXT),
- iGlesCommandsSinceGetError(EFalse),
- iGlesCommandsSinceFlush(EFalse),
- iGlesCommandsSinceFinish(EFalse)
- {}
-
-
-void TEglThreadState::Destroy()
- {
- UTIL_TRACE("TEglThreadState::Destroy");
- RHeap* currentHeap = CVghwUtils::SwitchToVghwHeap();
- delete this;
- CVghwUtils::SwitchFromVghwHeap(currentHeap);
- }
-
-
-TEglThreadState::~TEglThreadState()
- {}
-
-
-// -----------------------------------------------------------------------------
-//
-// -----------------------------------------------------------------------------
-//
-EXPORT_C EGLBoolean TEglThreadState::ExecEglBooleanCmd(EglRFC& aEglApiData)
- {
- CVghwUtils::DriverExecuteCommand(aEglApiData.Data());
-
- EGLBoolean hostResult = (EGLBoolean) aEglApiData.ReturnValue();
- if (hostResult == EGL_TRUE)
- {
- ClearEglError();
- }
- else
- { // error present in host graphics stack
- iEglHostHasRecentError = ETrue;
- }
- return hostResult;
- }
-
-
-EXPORT_C EGLContext TEglThreadState::ExecEglContextCmd(EglRFC& aEglApiData)
- {
- CVghwUtils::DriverExecuteCommand(aEglApiData.Data());
-
- EGLContext hostResult = (EGLContext) aEglApiData.ReturnValue();
- if (hostResult != EGL_NO_CONTEXT)
- {
- ClearEglError();
- }
- else
- { // error present in host graphics stack
- iEglHostHasRecentError = ETrue;
- }
- return hostResult;
- }
-
-
-EXPORT_C EGLSurface TEglThreadState::ExecEglSurfaceCmd(EglRFC& aEglApiData)
- {
- CVghwUtils::DriverExecuteCommand(aEglApiData.Data());
-
- EGLSurface hostResult = (EGLSurface) aEglApiData.ReturnValue();
- if (hostResult != EGL_NO_SURFACE)
- {
- ClearEglError();
- }
- else
- { // error present in host graphics stack
- iEglHostHasRecentError = ETrue;
- }
- return hostResult;
- }
-
-
-/*
- Get details of the last EGL api error.
- (Resets stored last error value to EGL_SUCCESS.)
-
- @return EGL_SUCCESS or an EGL_xxxx error constant.
- */
-EXPORT_C EGLint TEglThreadState::EglError()
- {
- EGLint eglError = iEglError;
- if (iEglHostHasRecentError)
- {
- // last EGL command was executed/failed in the Host side, so need to ask it for the error
- RemoteFunctionCallData rfcdata; EglRFC eglApiData(rfcdata);
- eglApiData.Init(EglRFC::EeglGetError);
- CVghwUtils::DriverExecuteCommand(eglApiData.Data());
- eglError = (EGLint)eglApiData.ReturnValue();
- EGL_ERROR_PRINT("TEglThreadState::EglError newest error fetched from Host EGL", eglError);
- iEglHostHasRecentError = EFalse;
- }
- else
- {
- EGL_ERROR_PRINT("TEglThreadState::EglError newest EGL error set by DLL", eglError);
- }
- iEglError = EGL_SUCCESS;
- return eglError;
- }
-
-
-void TEglThreadState::ExecuteVgCommand(OpenVgRFC& aVgApiData)
- {
- CVghwUtils::DriverExecuteCommand(aVgApiData.Data());
- iVgCommandsSinceGetError = ETrue;
- iVgCommandsSinceFlush = ETrue;
- iVgCommandsSinceFinish = ETrue;
- }
-
-
-void TEglThreadState::ExecuteVgFlushCommand()
- {
- if (iVgCommandsSinceFlush)
- {
- RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
- vgApiData.Init(OpenVgRFC::EvgFlush);
-
- CVghwUtils::DriverExecuteCommand(vgApiData.Data());
- iVgCommandsSinceFlush = EFalse;
- iVgCommandsSinceFinish = EFalse;
- }
- }
-
-
-void TEglThreadState::ExecuteVgFinishCommand()
- {
- if (iVgCommandsSinceFinish)
- {
- RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
- vgApiData.Init(OpenVgRFC::EvgFinish);
-
- CVghwUtils::DriverExecuteCommand(vgApiData.Data());
- iVgCommandsSinceFinish = EFalse;
- }
- }
-
-
-VGErrorCode TEglThreadState::VgError()
- {
- VGErrorCode vgError = iVgError;
- VG_ERROR_PRINT("TEglThreadState::VgError oldest Open VG DLL error", vgError);
-
- if (iVgCommandsSinceGetError)
- { // fetch and clear the host error state
- VGErrorCode hostVgError = GetHostVgError();
- VG_ERROR_PRINT("TEglThreadState::VgError oldest Host Open VG DLL error", hostVgError);
-
- if (vgError == VG_NO_ERROR)
- {
- vgError = hostVgError;
- }
- iVgCommandsSinceGetError = EFalse;
- }
-
- iVgError = VG_NO_ERROR;
- return vgError;
- }
-
-
-VGErrorCode TEglThreadState::GetHostVgError()
- {
- RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
- vgApiData.Init( OpenVgRFC::EvgGetError );
-
- CVghwUtils::DriverExecuteCommand(vgApiData.Data());
- return (VGErrorCode)vgApiData.ReturnValue();
- }
-
-
-// Open GL ES
-
-GLenum TEglThreadState::GlesError()
- {
- GLenum glesError = iGlesError;
- GLES_ERROR_PRINT("TEglThreadState::GlesError oldest Open GL ES DLL error", glesError);
-
- if (iGlesCommandsSinceGetError)
- { // fetch and clear the host error state
- GLenum hostGlesError = GetHostGlesError();
- GLES_ERROR_PRINT("TEglThreadState::GlesError oldest Host Open GL ES DLL error", hostGlesError);
-
- if (glesError == GL_NO_ERROR)
- {
- glesError = hostGlesError;
- }
- iGlesCommandsSinceGetError = EFalse;
- }
-
- iGlesError = GL_NO_ERROR;
- return glesError;
- }
-
-
-GLenum TEglThreadState::GetHostGlesError()
- {
- RemoteFunctionCallData data;
- OpenGlES11RFC glesApiData(data);
- glesApiData.Init(OpenGlES11RFC::EglGetError);
- CVghwUtils::DriverExecuteCommand(glesApiData.Data());
- return (GLint)glesApiData.ReturnValue();
- }
-
-
-void TEglThreadState::ExecuteGlesCommand(RemoteFunctionCall& aGlesRequestData)
- {
- CVghwUtils::DriverExecuteCommand(aGlesRequestData.Data());
- iGlesCommandsSinceGetError = ETrue;
- iGlesCommandsSinceFlush = ETrue;
- iGlesCommandsSinceFinish = ETrue;
- }
-
-
-void TEglThreadState::ExecuteGlesFlushCommand()
- {
- if (iGlesCommandsSinceFlush)
- {
- RemoteFunctionCallData rfcData;
- OpenGlES11RFC glesApiData( rfcData );
- glesApiData.Init(OpenGlES11RFC::EglFlush, RemoteFunctionCallData::EOpRequest);
- CVghwUtils::DriverExecuteCommand(glesApiData.Data());
- iGlesCommandsSinceFlush = EFalse;
- iGlesCommandsSinceFinish = EFalse;
- }
- }
-
-
-void TEglThreadState::ExecuteGlesFinishCommand()
- {
- if (iGlesCommandsSinceFinish)
- {
- RemoteFunctionCallData rfcData;
- OpenGlES11RFC glesApiData( rfcData );
- glesApiData.Init(OpenGlES11RFC::EglFinish, RemoteFunctionCallData::EOpRequest);
- CVghwUtils::DriverExecuteCommand(glesApiData.Data());
- iGlesCommandsSinceFinish = EFalse;
- }
- }
-
-
-// Open VG state
-void TEglThreadState::SetVgError(VGErrorCode aVgError)
- {
- VGHWPANIC_ASSERT_DEBUG( (aVgError >= VG_BAD_HANDLE_ERROR) && (aVgError <= 0x10FF), EVghwPanicBadVgErrorValue);
- // for Open VG track the oldest uncleared error
- VG_ERROR_PRINT("TEglThreadState::SetVgError error", aVgError);
- if ( (iVgError == VG_NO_ERROR) && (aVgError >= VG_BAD_HANDLE_ERROR) && (aVgError <= 0x10FF) )
- {
- if (iVgCommandsSinceGetError)
- {
- iVgError = GetHostVgError();
- VG_ERROR_PRINT("TEglThreadState::SetVgError oldest Host Open VG DLL error", iVgError);
- if (iVgError != VG_NO_ERROR)
- {
- return;
- }
- }
- iVgError = aVgError;
- }
- }
-
-
-EGLContext TEglThreadState::VgEglContext()
- {
- return iVgEglContext;
- }
-
-
-// Open GL ES thread state
-void TEglThreadState::SetGlesError(GLenum aGlesError)
- {
- VGHWPANIC_ASSERT_DEBUG( (aGlesError >= GL_INVALID_ENUM) && (aGlesError <= 0x05FF), EVghwPanicBadGlesErrorValue);
- // for Open GL ES track the oldest uncleared error
- GLES_ERROR_PRINT("TEglThreadState::SetGlesError error", aGlesError);
- if ( (iGlesError == GL_NO_ERROR) && (aGlesError >= GL_INVALID_ENUM) && (aGlesError <= 0x05FF) )
- {
- if (iGlesCommandsSinceGetError)
- {
- iGlesError = GetHostGlesError();
- GLES_ERROR_PRINT("TEglThreadState::SetGlesError oldest Host Open GL ES DLL error", iGlesError);
- if (iGlesError != GL_NO_ERROR)
- {
- return;
- }
- }
- iGlesError = aGlesError;
- }
- }
-
-
-EGLContext TEglThreadState::GlesEglContext()
- {
- return iGlesEglContext;
- }
-
-// -----------------------------------------------------------------------------
-// Use driver to discover base address of the surface memory.
-// -----------------------------------------------------------------------------
-//
-EXPORT_C TInt CVghwUtils::GetSurfaceBufferBaseAddress( TUint32& aHWAddress )
- {
- UTIL_TRACE("CVghwUtils::GetSurfaceBufferBaseAddress");
- if (!iInitialized || !iDriver)
- {
- UTIL_TRACE("CVghwUtils::GetSurfaceBufferBaseAddress called before initialised VghwUtils: iInitialized=%d, iDriver=0x%x", iInitialized, iDriver);
- InitStatics();
- }
- VGHWPANIC_ASSERT(iInitialized && iDriver, EVghwPanicGraphicsDriverNotOpen);
- return iDriver->GetSurfaceBufferBaseAddress( aHWAddress );
- }
-
-#ifdef _DEBUG
-static void EglErrorPrint(char* aTitle, EGLint aEglError)
- {
- char* errName = NULL;
- switch (aEglError)
- {
- case EGL_SUCCESS: errName = "EGL_SUCCESS"; break;
- case EGL_NOT_INITIALIZED: errName = "EGL_NOT_INITIALIZED"; break;
- case EGL_BAD_ACCESS: errName = "EGL_BAD_ACCESS"; break;
- case EGL_BAD_ALLOC: errName = "EGL_BAD_ALLOC"; break;
- case EGL_BAD_ATTRIBUTE: errName = "EGL_BAD_ATTRIBUTE"; break;
- case EGL_BAD_CONFIG: errName = "EGL_BAD_CONFIG"; break;
- case EGL_BAD_CONTEXT: errName = "EGL_BAD_CONTEXT"; break;
- case EGL_BAD_CURRENT_SURFACE: errName = "EGL_BAD_CURRENT_SURFACE"; break;
- case EGL_BAD_DISPLAY: errName = "EGL_BAD_DISPLAY"; break;
- case EGL_BAD_MATCH: errName = "EGL_BAD_MATCH"; break;
- case EGL_BAD_NATIVE_PIXMAP: errName = "EGL_BAD_NATIVE_PIXMAP"; break;
- case EGL_BAD_NATIVE_WINDOW: errName = "EGL_BAD_NATIVE_WINDOW"; break;
- case EGL_BAD_PARAMETER: errName = "EGL_BAD_PARAMETER"; break;
- case EGL_BAD_SURFACE: errName = "EGL_BAD_SURFACE"; break;
- case EGL_CONTEXT_LOST: errName = "EGL_CONTEXT_LOST"; break;
- default: break; // Error is from a new version of EGL
- }
-
- if (errName)
- {
- UTIL_TRACE( " %s=%s (0x%x)", aTitle, errName, aEglError);
- }
- else
- {
- UTIL_TRACE( " %s=0x%x", aTitle, aEglError);
- }
- }
-
-
-static void VgErrorPrint(char* aTitle, VGErrorCode aVgError)
- {
- char* errName = NULL;
- switch (aVgError)
- {
- case VG_NO_ERROR: errName = "VG_NO_ERROR"; break;
- case VG_BAD_HANDLE_ERROR: errName = "VG_BAD_HANDLE_ERROR"; break;
- case VG_ILLEGAL_ARGUMENT_ERROR: errName = "VG_ILLEGAL_ARGUMENT_ERROR"; break;
- case VG_OUT_OF_MEMORY_ERROR: errName = "VG_OUT_OF_MEMORY_ERROR"; break;
- case VG_PATH_CAPABILITY_ERROR: errName = "VG_PATH_CAPABILITY_ERROR"; break;
- case VG_UNSUPPORTED_IMAGE_FORMAT_ERROR: errName = "VG_UNSUPPORTED_IMAGE_FORMAT_ERROR"; break;
- case VG_UNSUPPORTED_PATH_FORMAT_ERROR: errName = "VG_UNSUPPORTED_PATH_FORMAT_ERROR"; break;
- case VG_IMAGE_IN_USE_ERROR: errName = "VG_IMAGE_IN_USE_ERROR"; break;
- case VG_NO_CONTEXT_ERROR: errName = "VG_NO_CONTEXT_ERROR"; break;
- default: break; // unknown error code from a new version of Open VG
- }
-
- if (errName)
- {
- UTIL_TRACE( " %s=%s (0x%x)", aTitle, errName, aVgError);
- }
- else
- {
- UTIL_TRACE( " %s=0x%x", aTitle, aVgError);
- }
- }
-
-
-static void GlesErrorPrint(char* aTitle, GLenum aGlesError)
- {
- char* errName = NULL;
- switch (aGlesError)
- {
- case GL_NO_ERROR: errName = "GL_NO_ERROR"; break;
- case GL_INVALID_ENUM: errName = "GL_INVALID_ENUM"; break;
- case GL_INVALID_VALUE: errName = "GL_INVALID_VALUE"; break;
- case GL_INVALID_OPERATION: errName = "GL_INVALID_OPERATION"; break;
- case GL_STACK_OVERFLOW: errName = "GL_STACK_OVERFLOW"; break;
- case GL_STACK_UNDERFLOW: errName = "GL_STACK_UNDERFLOW"; break;
- case GL_OUT_OF_MEMORY: errName = "GL_OUT_OF_MEMORY"; break;
- default: break; // unknown error code from a new version of Open GL ES
- }
-
- if (errName)
- {
- UTIL_TRACE( " %s=%s (0x%x)", aTitle, errName, aGlesError);
- }
- else
- {
- UTIL_TRACE( " %s=0x%x", aTitle, aGlesError);
- }
- }
-#endif
-
-
-// end of file vghwutils.cpp