diff -r 220791dae4c4 -r acbd4400e82b guestrendering/guestopenvg/src/vgstate.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/guestrendering/guestopenvg/src/vgstate.cpp	Wed Sep 08 17:02:34 2010 +0100
@@ -0,0 +1,788 @@
+// 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:
+// Client-side state information for Symbian DLL
+
+#include "vgstate.h"
+#include "remotefunctioncall.h"
+#include "openvgrfc.h"
+
+
+
+// VG Client-side state is Writeable Static Data in the DLL, (holds state information for the process)
+// Constructor/Destructor called on process load/unload to perform initialiser/release of static resources
+XOpenVgState OpenVgState;
+
+
+
+_LIT(KVgPanicCategory, "Guest VG");
+
+void VgPanic(TVgPanic aPanicCode, char* aPanicName, char* aCondition, char* aFile, TInt aLine)
+	{
+	if (aPanicName && aCondition && aFile)
+		{ // normal for Debug builds
+		RDebug::Printf("Guest Open VG DLL Panic %s for failed Assert (%s),\n\tat %s:%d", aPanicName, aCondition, aFile, aLine);
+		}
+	else if (aPanicName && aFile)
+		{ // Debug builds Assert Always
+		RDebug::Printf("Guest Open VG DLL Panic %s at %s:%d", aPanicName, aFile, aLine);
+		}
+	else
+		{ // normal for Release builds
+		RDebug::Printf("Guest Open VG DLL Panic %d (line %d)", aPanicCode, aLine);
+		}
+
+	User::Panic(KVgPanicCategory, aPanicCode);
+	}
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// TCheck - parameter checking utility functions
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+/*
+ aWidth & aHeight parameters must be >0, also ax, ay, aX + aWidth and aY + aHeight must all
+ be within image size, otherwise a VG_ILLEGAL_ARGUMENT_ERROR is flagged.
+ */
+TBool TCheck::ChkAreaIsWithinImage(MVgContext& aVgContext, CVgImageBase* aImageInfo, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+	{
+	VGPANIC_ASSERT_DEBUG(aImageInfo, EVgPanicTemp);
+	if ( (aX >= 0) && (aY >= 0) && (aWidth > 0) && (aHeight > 0) )
+		{
+		VGint maxX = aWidth + aX;
+		VGint maxY = aHeight + aY;
+		if ( (maxX > 0) && (maxY > 0) && (aImageInfo->Width() >= maxX) && (aImageInfo->Height() >= maxY) )
+			{
+			return ETrue;
+			}
+		}
+	OPENVG_TRACE("TCheck::ChkAreaIsWithinImage setting VG_ILLEGAL_ARGUMENT_ERROR");
+	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+	return EFalse;
+	}
+
+
+VGint TCheck::ImageFormatByteDepth(VGImageFormat aImageFormat)
+	{
+	switch (aImageFormat)
+		{
+		case VG_sRGBX_8888:
+		case VG_sRGBA_8888:
+		case VG_sRGBA_8888_PRE:
+		case VG_lRGBX_8888:
+		case VG_lRGBA_8888:
+		case VG_lRGBA_8888_PRE:
+		case VG_sXRGB_8888:
+		case VG_sARGB_8888:
+		case VG_sARGB_8888_PRE:
+		case VG_lXRGB_8888:
+		case VG_lARGB_8888:
+		case VG_lARGB_8888_PRE:
+		case VG_sBGRX_8888:
+		case VG_sBGRA_8888:
+		case VG_sBGRA_8888_PRE:
+		case VG_lBGRX_8888:
+		case VG_lBGRA_8888:
+		case VG_lBGRA_8888_PRE:
+		case VG_sXBGR_8888:
+		case VG_sABGR_8888:
+		case VG_sABGR_8888_PRE:
+		case VG_lXBGR_8888:
+		case VG_lABGR_8888:
+		case VG_lABGR_8888_PRE:
+			return 4;
+		case VG_sRGB_565:
+		case VG_sRGBA_5551:
+		case VG_sRGBA_4444:
+		case VG_sARGB_1555:
+		case VG_sARGB_4444:
+		case VG_sBGR_565:
+		case VG_sBGRA_5551:
+		case VG_sBGRA_4444:
+		case VG_sABGR_1555:
+		case VG_sABGR_4444:
+			return 2;
+		case VG_sL_8:
+		case VG_lL_8:
+		case VG_A_8:
+		case VG_A_4:
+		case VG_A_1:
+		case VG_BW_1:
+			return 1;
+		case VG_IMAGE_FORMAT_INVALID:
+		default:
+			return 0;
+		}
+	}
+
+
+// Checks aCount & aValues for SetParameteriv & SetParameterfv
+TBool TCheck::ChkParamCountAndValuesPtr(MVgContext& aVgContext, VGint aCount, const void* aValues)
+	{
+	VGErrorCode error = VG_NO_ERROR;
+	if (aValues == NULL)
+		{
+		if (aCount != 0)
+			{
+			error = VG_ILLEGAL_ARGUMENT_ERROR;
+			}
+		}
+	// we should check count for not being too large for serialization, but
+	// there is no limit in spec for VG_SCISSOR_RECTS and VG_STROKE_DASH_PATTERN
+	else if ( (3ul & (unsigned)aValues) || (aCount < 0) || (aCount > 100000) )
+		{
+		error = VG_ILLEGAL_ARGUMENT_ERROR;
+		}
+
+	if (error != VG_NO_ERROR)
+		{
+		OPENVG_TRACE("TCheck::ChkParamCountAndValuesPtr setting error=0x%x", error);
+		aVgContext.SetVgError(error);
+		return EFalse;
+		}
+	return ETrue;
+	}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// XOpenVgState
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+// Singleton object is in WSD memory, so this Constructor is called when the DLL is loaded
+XOpenVgState::XOpenVgState() :
+		iEglManagementApi(NULL), iKVgMaxKernelSize(0), iKVgMaxSeparableKernelSize(0)
+	{
+	OPENVG_TRACE("XOpenVgState::XOpenVgState 1. start Process=0x%lx, Thread=0x%lx", RProcess().Id().Id(), RThread().Id().Id());
+
+	TInt createErr1 = iStateLock.CreateLocal(EOwnerProcess);
+	OPENVG_TRACE("XOpenVgState::XOpenVgState 2. iStateLock.CreateLocal error=%d, Handle=0x%x", createErr1, iStateLock.Handle());
+
+	TInt createErr2 = iMapLock.CreateLocal(EOwnerProcess);
+	OPENVG_TRACE("XOpenVgState::XOpenVgState 2. iMapLock.CreateLocal error=%d, Handle=0x%x", createErr2, iMapLock.Handle());
+	// cannot continue if there is an error, so Panic
+	VGPANIC_ASSERT( (createErr1 == KErrNone) && (createErr2 == KErrNone), EVgPanicTemp);
+
+	CVgHandleBase::InitStatics();
+
+	// publish MVgApiforEgl vtable
+	CVghwUtils::SetVgApiForEgl(this);
+	}
+
+
+// Desstructor is called when the DLL is unloaded
+XOpenVgState::~XOpenVgState()
+	{
+	OPENVG_TRACE("XOpenVgState::~XOpenVgState 1. iStateLock handle=0x%x, iMapLock handle=0x%x, Process=0x%lx, Thread=0x%lx",
+			iStateLock.Handle(), iMapLock.Handle(), RProcess().Id().Id(), RThread().Id().Id());
+
+	if (iStateLock.Handle())
+		{
+		iStateLock.Close();
+		OPENVG_TRACE("XOpenVgState::~XOpenVgState 2. iStateLock Handle=0x%x", iStateLock.Handle());
+		}
+	if (iMapLock.Handle())
+		{
+		iMapLock.Close();
+		OPENVG_TRACE("XOpenVgState::~XOpenVgState 3. iMapLock Handle=0x%x", iMapLock.Handle());
+		}
+
+	// unpublish MVgApiforEgl vtable
+	CVghwUtils::SetVgApiForEgl(NULL);
+	}
+
+
+TBool XOpenVgState::CheckVGHandle(MVgContext& aVgContext, VGHandle aHandle, CVgHandleBase** aHandleInfo, TVgHandleType aMatchType)
+	{ // client side VGHandle is an opaque data handle to Host Open VG objects such as VGPath or VGImage
+	// only check for logic errors in VG code in Debug builds
+	VGPANIC_ASSERT_DEBUG(iStateLock.IsHeld(), EVgPanicStateLockMutexNotHeld);
+	VGPANIC_ASSERT_DEBUG(aHandleInfo, EVgPanicFunctionParameterIsNull);
+
+	if (aHandle != VG_INVALID_HANDLE)
+		{
+		iMapLock.Wait();
+		CVgHandleBase** pHandleInfo = iHandleHashMap.Find(aHandle);
+		if (pHandleInfo)
+			{
+			CVgHandleBase* handleInfo = *pHandleInfo;
+			if (handleInfo && !handleInfo->IsDestroyed() &&
+					( (aMatchType == EVgHandleAny) || (aMatchType == handleInfo->HandleType()) ) )
+				{
+				// ToDo confirm handle belongs to this context or is shared with this context
+				*aHandleInfo = handleInfo;
+				OPENVG_TRACE("  XOpenVgState::CheckVGHandle client handle=0x%x, match type=%d; found matching Host VG Handle=0x%x",
+						aHandle, aMatchType, handleInfo->HostHandle());
+				iMapLock.Signal();
+				return ETrue;
+				}
+			}
+		iMapLock.Signal();
+		}
+	OPENVG_TRACE("  XOpenVgState::CheckVGHandle client handle=0x%x, match type=%d, setting VG_BAD_HANDLE_ERROR", aHandle, aMatchType);
+	aVgContext.SetVgError(VG_BAD_HANDLE_ERROR);
+	return EFalse;
+	}
+
+
+/*
+ aKernelWidth or aKernelHeight must be >0 and <= [Size Limit], otherwise a VG_ILLEGAL_ARGUMENT_ERROR is flagged
+ */
+TBool XOpenVgState::CheckKernelWidthAndHeight(MVgContext& aVgContext, VGint aKernelWidth, VGint aKernelHeight, VGParamType aLimitType)
+	{
+	VGPANIC_ASSERT_DEBUG(iStateLock.IsHeld(), EVgPanicStateLockMutexNotHeld);
+	VGint limit = 0;
+	// aLimitType must be either VG_MAX_KERNEL_SIZE or VG_MAX_SEPARABLE_KERNEL_SIZE
+	if (aLimitType == VG_MAX_KERNEL_SIZE)
+		{
+		if (iKVgMaxKernelSize == 0)
+			{ // first access, so fetch value from Host
+			iKVgMaxKernelSize = TGuestOpenVg::HostGeti(aVgContext, VG_MAX_KERNEL_SIZE);
+			}
+		limit = iKVgMaxKernelSize;
+		}
+	else if (aLimitType == VG_MAX_SEPARABLE_KERNEL_SIZE)
+		{
+		if (iKVgMaxSeparableKernelSize == 0)
+			{ // first access, so fetch value from Host
+			iKVgMaxSeparableKernelSize = TGuestOpenVg::HostGeti(aVgContext, VG_MAX_SEPARABLE_KERNEL_SIZE);
+			}
+		limit = iKVgMaxSeparableKernelSize;
+		}
+	VGPANIC_ASSERT(limit > 0, EVgPanicValueFromHostVgIsInvalid);
+
+	if ( (aKernelHeight > 0) && (aKernelHeight <= limit) && (aKernelWidth > 0) && (aKernelWidth <= limit) )
+		{
+		return ETrue;
+		}
+	OPENVG_TRACE("XOpenVgState::CheckKernelWidthAndHeight setting VG_ILLEGAL_ARGUMENT_ERROR");
+	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+	return EFalse;
+	}
+
+
+TBool XOpenVgState::AddToHashMap(MVgContext& aVgContext, CVgHandleBase* aHandleInfo, VGHandle aHostHandle)
+	{
+	VGPANIC_ASSERT_DEBUG(iStateLock.IsHeld(), EVgPanicStateLockMutexNotHeld);
+
+	OPENVG_TRACE("  XOpenVgState::AddToHashMap aHandleInfo=0x%x, aHostHandle=0x%x, ClientHandle=0x%x",
+			aHandleInfo, aHostHandle, aHandleInfo->ClientHandle());
+	aHandleInfo->SetHostHandle(aHostHandle);
+
+	iMapLock.Wait();
+	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();
+	// ClientHandle is key to finding object, its Host Handle, object type, etc...
+	TInt err = iHandleHashMap.Insert(aHandleInfo->ClientHandle(), aHandleInfo);
+	CVghwUtils::SwitchFromVghwHeap(clientHeap);
+	iMapLock.Signal();
+
+	if (err == KErrNone)
+		{
+		return ETrue;
+		}
+
+	// Failed, Cleanup ...
+	OPENVG_TRACE("  XOpenVgState::AddToHashMap insert error = %d", err);
+	aVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+	return EFalse;
+	}
+
+
+void XOpenVgState::UnMapHandle(TUint32 aClientHandle)
+	{
+	OPENVG_TRACE("  XOpenVgState::UnMapHandle aHandleInfo=0x%x -->", aClientHandle);
+	VGPANIC_ASSERT_DEBUG(iStateLock.IsHeld(), EVgPanicStateLockMutexNotHeld);
+	VGPANIC_ASSERT_DEBUG( CVghwUtils::UsingVghwHeap(), EVgPanicTemp);
+
+	iMapLock.Wait();
+#ifdef _DEBUG
+	TInt dbgErr =
+#endif
+			iHandleHashMap.Remove(aClientHandle);
+	iMapLock.Signal();
+
+	OPENVG_TRACE("  XOpenVgState::UnMapHandle ... dbgErr =%d <--", dbgErr);
+	}
+
+
+TBool XOpenVgState::EglImageOpenForVgImage(EGLImageKHR aImage, TSize& aSize, VGHandle& aVgHandle, TUint64& aSgImageId)
+	{
+	if (!iEglManagementApi)
+		{ // try to get EGL interface via VghwUtils
+		iEglManagementApi = CVghwUtils::EglManagementApi();
+		VGPANIC_ASSERT_DEBUG(iEglManagementApi, EVgPanicMissingEglInterface);
+		}
+	if (iEglManagementApi)
+		{
+		return iEglManagementApi->EglImageOpenForVgImage(aImage, aSize, aVgHandle, aSgImageId);
+		}
+	return EFalse;
+	}
+
+
+void XOpenVgState::EglImageClose(EGLImageKHR aImage)
+	{
+	if (iEglManagementApi)
+		{
+		iEglManagementApi->EglImageClose(aImage);
+		}
+	}
+
+
+// Guest Open VG extension export support for eglGetProcAddress
+typedef struct
+	{
+	const char*          procName;		// procedure name
+	ExtensionProcPointer procAddr;
+	} TVgExtnInfo;
+
+// VG extension functions
+static const TVgExtnInfo vgProcedures[] =
+	{
+		{ "vgCreateEGLImageTargetKHR", (ExtensionProcPointer)vgCreateEGLImageTargetKHR },
+	};
+
+const TInt KVgProcCount = sizeof(vgProcedures) / sizeof(TVgExtnInfo);
+
+ExtensionProcPointer XOpenVgState::guestGetVgProcAddress (const char *aProcName)
+	{
+	// exhaustive search
+	for (TInt idx = 0; idx < KVgProcCount; idx++)
+	  {
+	  if (!strcmp(aProcName, vgProcedures[idx].procName))
+		  return vgProcedures[idx].procAddr;
+	  }
+	return NULL;
+	}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// TCleanupVgLocks
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+TCleanupVgLocks::TCleanupVgLocks(MVgContext& aVgContext) :
+		iVgContext(aVgContext), iMutex(OpenVgState.MutexWait()), iIsHeld(ETrue)
+	{}
+
+TCleanupVgLocks::~TCleanupVgLocks()
+	{
+	if (iIsHeld)
+		{
+		SignalMutex();
+		}
+	}
+
+void TCleanupVgLocks::SignalMutex()
+	{
+	VGPANIC_ASSERT_DEBUG(iIsHeld && iMutex.IsHeld(), EVgPanicTemp);
+	iMutex.Signal();
+	iIsHeld = EFalse;
+	}
+
+
+/*
+ Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if VGMaskOperation is not a supported operation
+ */
+TBool TCleanupVgLocks::CheckVGMaskOperationAndHandle(VGMaskOperation aOperation, VGHandle aMask, CVgImageBase** aHandleInfo)
+	{
+	VGPANIC_ASSERT_DEBUG(iIsHeld, EVgPanicStateLockMutexNotHeld);
+	*aHandleInfo = NULL;
+	switch (aOperation)
+		{
+		case VG_CLEAR_MASK:
+		case VG_FILL_MASK:
+			// aMask is not used for these operations
+			return ETrue;
+		case VG_SET_MASK:
+		case VG_UNION_MASK:
+		case VG_INTERSECT_MASK:
+		case VG_SUBTRACT_MASK:
+			{
+			if (aMask == VG_INVALID_HANDLE)
+				return ETrue;
+
+			CVgHandleBase* tempInfo;
+			if (CheckVGAnyHandle(aMask, &tempInfo))
+				{
+				if ( (tempInfo->HandleType() == EVgHandleForMaskLayer) || (tempInfo->HandleType() == EVgHandleForImage) )
+					{
+					*aHandleInfo = (CVgImageBase*)tempInfo;
+					// TODO if handle is a VgImage verify that it is not a rendering target
+					return ETrue;
+					}
+				OPENVG_TRACE("TCleanupVgLocks::CheckVGMaskOperationAndHandle setting VG_BAD_HANDLE_ERROR");
+				iVgContext.SetVgError(VG_BAD_HANDLE_ERROR);
+				}
+			return EFalse;
+			}
+		default:
+			OPENVG_TRACE("TCleanupVgLocks::CheckVGMaskOperationAndHandle setting VG_ILLEGAL_ARGUMENT_ERROR");
+			iVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+			return EFalse;
+		}
+	}
+
+
+VGFont TCleanupVgLocks::CreateFont(VGint aGlyphCapacityHint)
+	{
+	VGPANIC_ASSERT_DEBUG(iIsHeld && iMutex.IsHeld(), EVgPanicTemp);
+
+	CVgFontInfo* fontInfo = CVgFontInfo::New();
+	if (fontInfo == NULL)
+		{
+		OPENVG_TRACE("  TGuestOpenVg::vgCreateFont - CVgFontInfo::New() failed");
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		}
+	else
+		{
+		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+		vgApiData.Init(OpenVgRFC::EvgCreateFont);
+		vgApiData.AppendParam(aGlyphCapacityHint);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGFont hostFont = static_cast<VGFont>(vgApiData.ReturnValue());
+		OPENVG_TRACE("  TCleanupVgLocks::CreateFont - CVgFontInfo::New() success, hostFont=0x%x", hostFont);
+
+		if ( (hostFont != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, fontInfo, hostFont) )
+			{
+			return fontInfo->ClientHandle();
+			}
+
+		fontInfo->Destroy(iVgContext);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGImage TCleanupVgLocks::ChildImage(CVgImageInfo& aParentInfo, VGint aX, VGint aY, VGint aWidth, VGint aHeight)
+	{
+	CVgImageInfo* imageInfo = CVgImageInfo::New(aWidth, aHeight, &aParentInfo);
+	if (imageInfo == NULL)
+		{
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		OPENVG_TRACE("  TCleanupVgLocks::ChildImage - CVgImageInfo::New() failed");
+		}
+	else
+		{
+		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+		vgApiData.Init(OpenVgRFC::EvgChildImage);
+		vgApiData.AppendParam(aParentInfo.HostHandle());
+		vgApiData.AppendParam(aX);
+		vgApiData.AppendParam(aY);
+		vgApiData.AppendParam(aWidth);
+		vgApiData.AppendParam(aHeight);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGImage hostImageHandle = static_cast<VGImage>(vgApiData.ReturnValue());
+
+		OPENVG_TRACE("  TCleanupVgLocks::ChildImage - CVgImageInfo::New() success, hostImageHandle=0x%x", hostImageHandle);
+		if ( (hostImageHandle != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, imageInfo, hostImageHandle) )
+			{
+			return imageInfo->ClientHandle();
+			}
+		imageInfo->Destroy(iVgContext);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGImage TCleanupVgLocks::CreateImage(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality)
+	{
+	CVgImageInfo* imageInfo = CVgImageInfo::New(aFormat, aWidth, aHeight, aAllowedQuality);
+	if (imageInfo == NULL)
+		{
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		OPENVG_TRACE("  TCleanupVgLocks::CreateImage - CVgImageInfo::New() failed");
+		}
+	else
+		{
+		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+		vgApiData.Init(OpenVgRFC::EvgCreateImage);
+		vgApiData.AppendParam(aFormat);
+		vgApiData.AppendParam(aWidth);
+		vgApiData.AppendParam(aHeight);
+		vgApiData.AppendParam(aAllowedQuality);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGImage hostImageHandle = static_cast<VGImage>(vgApiData.ReturnValue());
+
+		OPENVG_TRACE("  TCleanupVgLocks::CreateImage - CVgImageInfo::New() success, hostImageHandle=0x%x", hostImageHandle);
+		if ( (hostImageHandle != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, imageInfo, hostImageHandle) )
+			{
+			return imageInfo->ClientHandle();
+			}
+		imageInfo->Destroy(iVgContext);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGMaskLayer TCleanupVgLocks::CreateMaskLayer(VGint aWidth, VGint aHeight)
+	{
+	CVgMaskLayerInfo* maskLayerInfo = CVgMaskLayerInfo::New(aWidth, aHeight);
+	if (maskLayerInfo == NULL)
+		{
+		OPENVG_TRACE("  TCleanupVgLocks::CreateMaskLayer - CVgMaskLayerInfo::New() failed");
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		}
+	else
+		{
+		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+		vgApiData.Init(OpenVgRFC::EvgCreateMaskLayer);
+		vgApiData.AppendParam(aWidth);
+		vgApiData.AppendParam(aHeight);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGMaskLayer hostMaskHandle = static_cast<VGMaskLayer>(vgApiData.ReturnValue());
+
+		OPENVG_TRACE("  TCleanupVgLocks::CreateMaskLayer - CVgMaskLayerInfo::New() success, hostMaskHandle=0x%x", hostMaskHandle);
+		if ( (hostMaskHandle != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, maskLayerInfo, hostMaskHandle) )
+			{
+			return maskLayerInfo->ClientHandle();
+			}
+		maskLayerInfo->Destroy(iVgContext);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGPaint TCleanupVgLocks::CreatePaint()
+	{
+	CVgPaintInfo* paintInfo = CVgPaintInfo::New();
+	if (paintInfo == NULL)
+		{
+		OPENVG_TRACE("  TCleanupVgLocks::CreatePaint - CVgPaintInfo::New() failed");
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		}
+	else
+		{
+		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+		vgApiData.Init(OpenVgRFC::EvgCreatePaint);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGPaint hostPaint = static_cast<VGPaint>(vgApiData.ReturnValue());
+
+		OPENVG_TRACE("  TCleanupVgLocks::CreatePaint - CVgPaintInfo::New() success, clientHandle=0x%x, hostHandle=0x%x",
+				paintInfo->ClientHandle(), hostPaint);
+		if ( (hostPaint != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, paintInfo, hostPaint) )
+			{
+			return paintInfo->ClientHandle();
+			}
+		paintInfo->Destroy(iVgContext);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGPaint TCleanupVgLocks::GetPaint(VGPaintMode aPaintMode)
+	{
+	CVgPaintInfo* paintInfo = CVgPaintInfo::New();
+	if (paintInfo == NULL)
+		{
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		OPENVG_TRACE("  TCleanupVgLocks::GetPaint - CVgPaintInfo::New() failed");
+		}
+	else
+		{
+		RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);
+		vgApiData.Init(OpenVgRFC::EvgGetPaint);
+		vgApiData.AppendParam(aPaintMode);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGPaint hostPaint = static_cast<VGPaint>(vgApiData.ReturnValue());
+
+		OPENVG_TRACE("  TCleanupVgLocks::GetPaint - CVgPaintInfo::New() success, clientHandle=0x%x, hostHandle=0x%x",
+				paintInfo->ClientHandle(), hostPaint);
+		if ( (hostPaint != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, paintInfo, hostPaint) )
+			{
+			return paintInfo->ClientHandle();
+			}
+		paintInfo->Destroy(iVgContext);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGPath TCleanupVgLocks::CreatePath(VGint aPathFormat, VGPathDatatype aDatatype, VGfloat aScale, VGfloat aBias,
+		VGint aSegmentCapacityHint, VGint aCoordCapacityHint, VGbitfield aCapabilities)
+	{
+	VGPANIC_ASSERT_DEBUG(iIsHeld && iMutex.IsHeld(), EVgPanicTemp);
+
+	aCapabilities &= VG_PATH_CAPABILITY_ALL;
+	CVgPathInfo* pathInfo = CVgPathInfo::New(aDatatype, aScale, aBias, aCapabilities);
+	if (pathInfo == NULL)
+		{
+		OPENVG_TRACE("  TCleanupVgLocks::CreatePath - CVgPathInfo::New() failed");
+		iVgContext.SetVgError(VG_OUT_OF_MEMORY_ERROR);
+		}
+	else
+		{
+		RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+		vgApiData.Init(OpenVgRFC::EvgCreatePath);
+		vgApiData.AppendParam(aPathFormat);
+		vgApiData.AppendParam(aDatatype);
+		vgApiData.AppendParam(aScale);
+		vgApiData.AppendParam(aBias);
+		vgApiData.AppendParam(aSegmentCapacityHint);
+		vgApiData.AppendParam(aCoordCapacityHint);
+		vgApiData.AppendParam(aCapabilities);
+		VGPANIC_ASSERT_DEBUG(vgApiData.Data().Header().iOpType == RemoteFunctionCallData::EOpRequestWithReply, EVgPanicNotReplyOpcode);
+		iVgContext.ExecuteVgCommand(vgApiData);
+		VGPath hostPath = static_cast<VGPath>(vgApiData.ReturnValue());
+		OPENVG_TRACE("  TCleanupVgLocks::CreatePath - CVgPathInfo::New() success, hostHandle=0x%x", hostPath);
+
+		if ( (hostPath != VG_INVALID_HANDLE) && OpenVgState.AddToHashMap(iVgContext, pathInfo, hostPath) )
+			{
+			return pathInfo->ClientHandle();
+			}
+
+		pathInfo->Destroy(iVgContext);
+		}
+	
+	return VG_INVALID_HANDLE;
+	}
+
+
+VGImage TCleanupVgLocks::CreateEGLImageTargetKHR(VGeglImageKHR aImage)
+	{
+	VGErrorCode error = VG_NO_ERROR;
+
+	if (aImage == NULL)
+		{
+		error = VG_ILLEGAL_ARGUMENT_ERROR;
+		}
+	else
+		{
+		// Try to open EGL Image from handle, and get info such as image size
+		TSize imageSize;
+		TUint64 sgImageId;
+		VGHandle vgHandle;
+		if (!OpenVgState.EglImageOpenForVgImage((EGLImageKHR) aImage, imageSize, vgHandle, sgImageId))
+			{
+			error = VG_UNSUPPORTED_IMAGE_FORMAT_ERROR;
+			}
+		else
+			{ // Open success, create a CVgImageInfo with all the details ...
+			// ToDo get & store VGImageFormat of underlying VGImage
+			CVgImageInfo* newImageInfo = CVgImageInfo::New(VG_IMAGE_FORMAT_INVALID, imageSize.iWidth, imageSize.iHeight,
+					(EGLImageKHR) aImage, sgImageId);
+			OPENVG_TRACE("TGuestOpenVg::vgCreateEGLImageTargetKHR imageSize=%d,%d, vgHandle=0x%x, sgImageId=0x%lx  newImageInfo=0x%x",
+					imageSize.iWidth, imageSize.iHeight, vgHandle, sgImageId, newImageInfo);
+			if (newImageInfo == NULL)
+				{
+				error = VG_OUT_OF_MEMORY_ERROR;
+				OpenVgState.EglImageClose((EGLImageKHR) aImage);
+				}
+			else
+				{
+				if (OpenVgState.AddToHashMap(iVgContext, newImageInfo, vgHandle))
+					{
+					// Notify Command Scheduler & KhronosWrappers
+					RemoteFunctionCallData data; OpenVgRFC vgApiData(data);
+					vgApiData.Init(OpenVgRFC::EvgCreateEGLImageTargetKHR, RemoteFunctionCallData::EOpRequestWithReply);
+					vgApiData.AppendParam(aImage);
+					// ToDo any other parameters needed? Is this really a Request with Reply?
+					iVgContext.ExecuteVgCommand(vgApiData);
+					return newImageInfo->ClientHandle();  
+					}
+				newImageInfo->Destroy(iVgContext);
+				}
+			}
+		}
+
+
+	if (error != VG_NO_ERROR)
+		{
+		iVgContext.SetVgError(error);
+		OPENVG_TRACE("TGuestOpenVg::vgCreateEGLImageTargetKHR fail - error=0x%x", error);
+		}
+
+	return VG_INVALID_HANDLE;
+	}
+
+
+
+
+// **** Desirable: could check VGParamType for vgGet & vgSet scalar & vector operations.
+/*
+  // Mode settings
+  VG_MATRIX_MODE  ???
+  VG_FILL_RULE  ???
+  VG_IMAGE_QUALITY  ???
+  VG_RENDERING_QUALITY  ???
+  VG_BLEND_MODE  ???
+  VG_IMAGE_MODE  ???
+
+  // Scissoring rectangles
+  VG_SCISSOR_RECTS  ???
+
+  // Color Transformation
+  VG_COLOR_TRANSFORM  ???
+  VG_COLOR_TRANSFORM_VALUES  ???
+
+  // Stroke parameters
+  VG_STROKE_LINE_WIDTH  ???
+  VG_STROKE_CAP_STYLE  ???
+  VG_STROKE_JOIN_STYLE  ???
+  VG_STROKE_MITER_LIMIT  ???
+  VG_STROKE_DASH_PATTERN  ???
+  VG_STROKE_DASH_PHASE  ???
+  VG_STROKE_DASH_PHASE_RESET  ???
+
+  // Edge fill color for VG_TILE_FILL tiling mode
+  VG_TILE_FILL_COLOR  ???
+
+  // Color for vgClear
+  VG_CLEAR_COLOR  ???
+
+  // Glyph origin
+  VG_GLYPH_ORIGIN  ???
+
+  // Enable/disable alpha masking and scissoring
+  VG_MASKING  ???
+  VG_SCISSORING  ???
+
+  // Pixel layout information
+  VG_PIXEL_LAYOUT  ???
+  VG_SCREEN_LAYOUT  ???
+
+  // Source format selection for image filters
+  VG_FILTER_FORMAT_LINEAR  ???
+  VG_FILTER_FORMAT_PREMULTIPLIED  ???
+
+  // Destination write enable mask for image filters
+  VG_FILTER_CHANNEL_MASK  ???
+
+  // Implementation limits (read-only)
+  VG_MAX_SCISSOR_RECTS, ReadOnly, Scalar
+  VG_MAX_DASH_COUNT  ???
+  VG_MAX_KERNEL_SIZE  ???
+  VG_MAX_SEPARABLE_KERNEL_SIZE  ???
+  VG_MAX_COLOR_RAMP_STOPS  ???
+  VG_MAX_IMAGE_WIDTH  ???
+  VG_MAX_IMAGE_HEIGHT  ???
+  VG_MAX_IMAGE_PIXELS  ???
+  VG_MAX_IMAGE_BYTES  ???
+  VG_MAX_FLOAT  ???
+  VG_MAX_GAUSSIAN_STD_DEVIATION  ???
+  */
+
+//////////////////////////////////////////////////////////////////////////
+
+// end of file vgstate.cpp