--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/guestrendering/guestopenvg/inc/openvg.inl Wed Sep 08 17:02:34 2010 +0100
@@ -0,0 +1,522 @@
+// 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);
+ }
+ return result;
+ }
+
+
+/*
+ Returns false & sets VG error to VG_ILLEGAL_ARGUMENT_ERROR if aTilingMode is not a valid value from the
+ VGTilingMode enumeration
+ */
+TBool TCheck::ChkVGTilingMode(MVgContext& aVgContext, VGTilingMode aTilingMode)
+ {
+ switch (aTilingMode)
+ {
+ case VG_TILE_FILL:
+ case VG_TILE_PAD:
+ case VG_TILE_REPEAT:
+ case VG_TILE_REFLECT:
+ return ETrue;
+ default:
+ OPENVG_TRACE("TCheck::ChkVGTilingMode setting VG_ILLEGAL_ARGUMENT_ERROR");
+ aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);
+ return EFalse;
+ }
+ }
+
+
+#endif // OPENVG_INL