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

// Inline functions for Open VG client-side state classes.

#ifndef OPENVG_INL

#define OPENVG_INL

#include "vgstate.h"

/////////////////////////////////////////////////////////////////////////////////////////////

// XOpenVgState

/////////////////////////////////////////////////////////////////////////////////////////////

RMutex& XOpenVgState::MutexWait()

	{

	iStateLock.Wait();

	return iStateLock;

	}

/////////////////////////////////////////////////////////////////////////////////////////////

// CVgHandleBase

/////////////////////////////////////////////////////////////////////////////////////////////

CVgHandleBase::CVgHandleBase(TVgHandleType aHandleType) :

		iClientHandle(iHandleGen.NextUid()), iHandleType(aHandleType), iHostHandle(VG_INVALID_HANDLE), iIsDestroyed(EFalse)

	{

	}

CVgHandleBase::~CVgHandleBase()

	{

	VGPANIC_ASSERT_DEBUG( iIsDestroyed || (iHostHandle == VG_INVALID_HANDLE), EVgPanicTemp);

	}

TUint CVgHandleBase::ClientHandle() const

	{

	return iClientHandle;

	}

VGHandle CVgHandleBase::HostHandle() const

	{

	VGPANIC_ASSERT(iHostHandle, EVgPanicHostHandleIsInvalid);

	return iHostHandle;

	}

TVgHandleType CVgHandleBase::HandleType() const

	{

	return iHandleType;

	}

TBool CVgHandleBase::IsDestroyed() const

	{

	return iIsDestroyed;

	}

void CVgHandleBase::SetHostHandle(VGHandle aHostHandle)

	{ // should be set exactly once (For EglImages it should be the underlying VG Image)

	VGPANIC_ASSERT(iHostHandle == 0, EVgPanicHostHandleAlreadySet);

	VGPANIC_ASSERT(aHostHandle, EVgPanicHostHandleIsInvalid);

	iHostHandle = aHostHandle;

	}

/////////////////////////////////////////////////////////////////////////////////////////////

// CVgImageBase

/////////////////////////////////////////////////////////////////////////////////////////////

CVgImageBase::CVgImageBase(TVgHandleType aHandleType, VGint aWidth, VGint aHeight) :

		CVgHandleBase(aHandleType), iWidth(aWidth), iHeight(aHeight)

	{

	}

VGint CVgImageBase::Width() const

	{

	return iWidth;

	}

VGint CVgImageBase::Height() const

	{

	return iHeight;

	}

/////////////////////////////////////////////////////////////////////////////////////////////

// TCleanupVgLocks

/////////////////////////////////////////////////////////////////////////////////////////////

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aPath is not a valid VGPath handle

 */

TBool TCleanupVgLocks::CheckVGPath(VGPath aPath, CVgPathInfo** aPathInfo, VGbitfield aReqdCapabilities)

	{ // VGPath is an opaque data handle

	TBool valid = OpenVgState.CheckVGHandle(iVgContext, aPath, (CVgHandleBase**)aPathInfo, EVgHandleForPath);

	if (valid && aReqdCapabilities)

		{  // Check for VG_PATH_CAPABILITY_ERROR

		return (*aPathInfo)->CheckHasPathCapabilities(iVgContext, aReqdCapabilities);

		}

	return valid;

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aPath is neither VG_INVALID_HANDLE or a valid VGPath handle

 */

TBool TCleanupVgLocks::CheckOptionalVGPath(VGPath aPath, CVgPathInfo** aPathInfo)

	{ // VGPath is an opaque data handle

	if (aPath == VG_INVALID_HANDLE)

		{

		return ETrue;

		}

	return OpenVgState.CheckVGHandle(iVgContext, aPath, (CVgHandleBase**)aPathInfo, EVgHandleForPath);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aPaint is not a valid VGPaint handle

 */

TBool TCleanupVgLocks::CheckVGPaint(VGPaint aPaint, CVgPaintInfo** aPaintInfo)

	{ // VGPaint is an opaque data handle

	return OpenVgState.CheckVGHandle(iVgContext, aPaint, (CVgHandleBase**)aPaintInfo, EVgHandleForPaint);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aPaint is neither VG_INVALID_HANDLE or a valid VGPaint handle

 */

TBool TCleanupVgLocks::CheckOptionalVGPaint(VGPaint aPaint, CVgPaintInfo** aPaintInfo)

	{ // VGPaint is an opaque data handle

	if (aPaint == VG_INVALID_HANDLE)

		{

		return ETrue;

		}

	return OpenVgState.CheckVGHandle(iVgContext, aPaint, (CVgHandleBase**)aPaintInfo, EVgHandleForPaint);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aImage is not a valid VGImage handle

 */

TBool TCleanupVgLocks::CheckVGImage(VGImage aImage, CVgImageInfo** aImageInfo)

	{ // VGImage is an opaque data handle

	return OpenVgState.CheckVGHandle(iVgContext, aImage, (CVgHandleBase**)aImageInfo, EVgHandleForImage);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aImage is neither VG_INVALID_HANDLE or a valid VGImage handle

 */

TBool TCleanupVgLocks::CheckOptionalVGImage(VGImage aImage, CVgImageInfo** aImageInfo)

	{ // VGImage is an opaque data handle

	if (aImage == VG_INVALID_HANDLE)

		{

		return ETrue;

		}

	return OpenVgState.CheckVGHandle(iVgContext, aImage, (CVgHandleBase**)aImageInfo, EVgHandleForImage);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aImage is not a valid VGImage handle,

 or if the 2 Images are the same.

 */

TBool TCleanupVgLocks::Check2VGImages(VGImage aImage1, CVgImageInfo** aImageInfo1, VGImage aImage2, CVgImageInfo** aImageInfo2)

	{ // VGImage is an opaque data handle

	// ToDo some (all?) callers need the 2 images to not be overlapping

	if (aImage1 != aImage2)

		{

		return OpenVgState.CheckVGHandle(iVgContext, aImage1, (CVgHandleBase**)aImageInfo1, EVgHandleForImage) &&

				OpenVgState.CheckVGHandle(iVgContext, aImage2, (CVgHandleBase**)aImageInfo2, EVgHandleForImage);

		}

	iVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return EFalse;

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aFont is not a valid VGFont handle

 */

TBool TCleanupVgLocks::CheckVGFont(VGFont aFont, CVgFontInfo** aFontInfo)

	{ // VGFont is an opaque data handle

	return OpenVgState.CheckVGHandle(iVgContext, aFont, (CVgHandleBase**)aFontInfo, EVgHandleForFont);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aMaskLayer is not a valid VGMaskLayer handle

 */

TBool TCleanupVgLocks::CheckVGMaskLayer(VGMaskLayer aMaskLayer, CVgMaskLayerInfo** aMaskLayerInfo)

	{ // VGMaskLayer is an opaque data handle

	return OpenVgState.CheckVGHandle(iVgContext, aMaskLayer, (CVgHandleBase**)aMaskLayerInfo, EVgHandleForMaskLayer);

	}

/*

 Returns false & sets VG error to VG_BAD_HANDLE_ERROR if aHandle is not a valid Open VG handle

 */

TBool TCleanupVgLocks::CheckVGAnyHandle(VGHandle aHandle, CVgHandleBase** aHandleInfo)

	{

	return OpenVgState.CheckVGHandle(iVgContext, aHandle, aHandleInfo, EVgHandleAny);

	}

TBool TCleanupVgLocks::CheckKernelWidthAndHeight(VGint aKernelWidth, VGint aKernelHeight, VGParamType aLimitType)

	{

	return OpenVgState.CheckKernelWidthAndHeight(iVgContext, aKernelWidth, aKernelHeight, aLimitType);

	}

/////////////////////////////////////////////////////////////////////////////////////////////

// TCheck - parameter checking utility functions

/////////////////////////////////////////////////////////////////////////////////////////////

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aDataPtr is NULL or not 32-bit aligned

 */

TBool TCheck::Chk32bitPtr(MVgContext& aVgContext, const void* aDataPtr)

	{

	TBool result = (aDataPtr != NULL) && !(3ul & (unsigned)aDataPtr);

	if (!result)

		{

		OPENVG_TRACE("TCheck::Chk32bitPtr setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	return result;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aDataPtrN is NULL or not 32-bit aligned

 */

TBool TCheck::Chk2x32bitPtr(MVgContext& aVgContext, const void* aDataPtr1, const void* aDataPtr2)

	{

	TBool result = (aDataPtr1 != NULL) && !(3ul & (unsigned)aDataPtr1) && (aDataPtr2 != NULL) && !(3ul & (unsigned)aDataPtr2);

	if (!result)

		{

		OPENVG_TRACE("TCheck::Chk2x32bitPtr setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	return result;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aDataPtrN is NULL or not 32-bit aligned

 */

TBool TCheck::Chk4x32bitPtr(MVgContext& aVgContext, const void* aDataPtr1, const void* aDataPtr2, const void* aDataPtr3, const void* aDataPtr4)

	{

	TBool result = (aDataPtr1 != NULL) && !(3ul & (unsigned)aDataPtr1) && (aDataPtr2 != NULL) && !(3ul & (unsigned)aDataPtr2) &&

			 (aDataPtr3 != NULL) && !(3ul & (unsigned)aDataPtr3) && (aDataPtr4 != NULL) && !(3ul & (unsigned)aDataPtr4);

	if (!result)

		{

		OPENVG_TRACE("TCheck::Chk4x32bitPtr setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	return result;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aDataPtrN is not-NULL and not 32-bit aligned

 */

TBool TCheck::Chk2xOptional32bitPtr(MVgContext& aVgContext, const void* aDataPtr1, const void* aDataPtr2)

	{

	TBool result = !(3ul & (unsigned)aDataPtr1) && !(3ul & (unsigned)aDataPtr2);

	if (!result)

		{

		OPENVG_TRACE("TCheck::Chk2xOptional32bitPtr setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	return result;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aDataPtr is NULL or not 16-bit aligned

 */

TBool TCheck::Chk16bitPtr(MVgContext& aVgContext, const void* aDataPtr)

	{

	TBool result = (aDataPtr != NULL) && !(1ul & (unsigned)aDataPtr);

	if (!result)

		{

		OPENVG_TRACE("TCheck::Chk16bitPtr setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	return result;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if either aDataPtr1 or aDataPtr2 is NULL or not 16-bit aligned

 */

TBool TCheck::Chk2x16bitPtr(MVgContext& aVgContext, const void* aDataPtr1, const void* aDataPtr2)

	{

	TBool result = (aDataPtr1 != NULL) && !(1ul & (unsigned)aDataPtr1) && (aDataPtr2 != NULL) && !(1ul & (unsigned)aDataPtr2);

	if (!result)

		{

		OPENVG_TRACE("TCheck::Chk2x16bitPtr setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		}

	return result;

	}

/*

 Returns false & sets VG error to VG_UNSUPPORTED_PATH_FORMAT_ERROR if pathFormat is not a supported format

 */

TBool TCheck::ChkVGPathFormat(MVgContext& aVgContext, VGint aPathFormat)

	{

	switch (aPathFormat)

		{

		case VG_PATH_FORMAT_STANDARD:

			return ETrue;

		default:

			OPENVG_TRACE("TCheck::ChkVGPathFormat setting VG_UNSUPPORTED_PATH_FORMAT_ERROR");

			aVgContext.SetVgError(VG_UNSUPPORTED_PATH_FORMAT_ERROR);

			return EFalse;

		}

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if datatype is not a valid value from the VGPathDatatype enumeration

 */

TBool TCheck::ChkVGPathDataType(MVgContext& aVgContext, VGPathDatatype aDatatype)

	{

	switch (aDatatype)

		{

		case VG_PATH_DATATYPE_S_8:

		case VG_PATH_DATATYPE_S_16:

		case VG_PATH_DATATYPE_S_32:

		case VG_PATH_DATATYPE_F:

			return ETrue;

		default:

			OPENVG_TRACE("TCheck::ChkVGPathDataType setting VG_ILLEGAL_ARGUMENT_ERROR");

			aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

			return EFalse;

		}

	}

/*

 aWidth & aHeight parameters must be >0, otherwise a VG_ILLEGAL_ARGUMENT_ERROR is flagged.

 */

TBool TCheck::ChkPositiveImageSize(MVgContext& aVgContext, VGint aWidth, VGint aHeight)

	{

	if ( (aWidth > 0) && (aHeight > 0) )

		{

		return ETrue;

		}

	OPENVG_TRACE("TCheck::ChkPositiveImageSize setting VG_ILLEGAL_ARGUMENT_ERROR");

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return EFalse;

	}

/*

 aWidth & aHeight parameters must be >0, otherwise a VG_ILLEGAL_ARGUMENT_ERROR is flagged.

 */

TBool TCheck::ChkNewImageSize(MVgContext& aVgContext, VGint aWidth, VGint aHeight)

	{

	// ToDo compare with max limits fetched from Host Open VG:VG_MAX_IMAGE_WIDTH, VG_MAX_IMAGE_HEIGHT & VG_MAX_IMAGE_PIXELS

	if ( (aWidth > 0) && (aHeight > 0) )

		{

		return ETrue;

		}

	OPENVG_TRACE("TCheck::ChkNewImageSize setting VG_ILLEGAL_ARGUMENT_ERROR");

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return EFalse;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aPaintMode is not a valid VGPaintMode

 */

TBool TCheck::ChkVGPaintMode(MVgContext& aVgContext, VGPaintMode aPaintMode)

	{

	switch(aPaintMode)

		{

		case VG_STROKE_PATH:

		case VG_FILL_PATH:

			return ETrue;

		default:

			OPENVG_TRACE("TCheck::ChkVGPaintMode setting VG_ILLEGAL_ARGUMENT_ERROR");

			aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

			return EFalse;

		}

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aPaintModes has invalid VGPaintMode bits set

 */

TBool TCheck::ChkVGPaintModesCombination(MVgContext& aVgContext, VGbitfield aPaintModes)

	{

	if (aPaintModes & ~(VG_STROKE_PATH | VG_FILL_PATH))

		{

		OPENVG_TRACE("TCheck::ChkVGPaintModesCombination setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

		return EFalse;

		}

	return ETrue;

	}

/*

 Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if VGMaskOperation is not a supported operation

 */

TBool TCheck::ChkVGMaskOperation(MVgContext& aVgContext, VGMaskOperation aOperation)

	{

	switch (aOperation)

		{

		case VG_CLEAR_MASK:

		case VG_FILL_MASK:

		case VG_SET_MASK:

		case VG_UNION_MASK:

		case VG_INTERSECT_MASK:

		case VG_SUBTRACT_MASK:

			return ETrue;

		default:

			OPENVG_TRACE("TCheck::ChkVGMaskOperation setting VG_ILLEGAL_ARGUMENT_ERROR");

			aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

			return EFalse;

		}

	}

TBool TCheck::ChkVgImageFormat(MVgContext& aVgContext, VGImageFormat aFormat)

	{

	if ( ImageFormatByteDepth(aFormat) )

		{

		return ETrue;

		}

	OPENVG_TRACE("TCheck::ChkVgImageFormat setting VG_UNSUPPORTED_IMAGE_FORMAT_ERROR");

	aVgContext.SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);

	return EFalse;

	}

/*

 Checks aData is aligned according to the specified VGImageFormet.

 On failure sets these VgErrors:

    VG_UNSUPPORTED_IMAGE_FORMAT_ERROR

   – if aImageFormat is not a valid value from the VGImageFormat enumeration

   VG_ILLEGAL_ARGUMENT_ERROR

   – if width or height is less than or equal to 0

   – if data is NULL

   – if data is not properly aligned

 */

TBool TCheck::ChkImageAlignment(MVgContext& aVgContext, VGImageFormat aImageFormat, const void* aData)

	{

	TBool result = EFalse;

	if (aData != NULL)

		{

		switch( ImageFormatByteDepth(aImageFormat) )

			{

			case 1:

				result = ETrue;

				break;

			case 2:

				result = !( 1ul & (unsigned)aData );

				break;

			case 4:

				result = !( 3ul & (unsigned)aData );

				break;

			default:

				OPENVG_TRACE("TCheck::ImageAlignment setting VG_UNSUPPORTED_IMAGE_FORMAT_ERROR");

				aVgContext.SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);

				return EFalse;

			}

		}

	if (!result)

		{

		OPENVG_TRACE("TCheck::ImageAlignment setting VG_ILLEGAL_ARGUMENT_ERROR");

		aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);