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

		}