// 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 Open VG handle based objects

#include "vgstate.h"

#include "remotefunctioncall.h"

#include "openvgrfc.h"

const TInt KColorMatrixSize = 20;

const TInt KLUTLength = 256;

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

// CVgImageInfo

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

CVgImageInfo::CVgImageInfo(VGImageFormat aFormat, VGint aWidth, VGint aHeight, CVgImageInfo* aParent, VGbitfield aAllowedQuality,

			EGLImageKHR aEglImage, TUint64 aSgImageId) :

		CVgImageBase(EVgHandleForImage, aWidth, aHeight), iFormat(aFormat), iParent(aParent),

		iAllowedQuality(aAllowedQuality), iIsEglSibling( aSgImageId ? ETrue : EFalse),

		iEglImage(aEglImage), iSgImageId(aSgImageId),

		iChildCount(0)

	{

	if (aParent)

		{

		aParent->IncChildCount();

		}

	}

// eglChildImage

CVgImageInfo* CVgImageInfo::New(VGint aWidth, VGint aHeight, CVgImageInfo* aParent)

	{

	VGPANIC_ASSERT_DEBUG(aParent, EVgPanicImageParentIsInvalid);

	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();

	CVgImageInfo* self = new CVgImageInfo(aParent->iFormat, aWidth, aHeight, aParent, aParent->AllowedQuality(),

			aParent->EglImage(), aParent->SgImageId());

	CVghwUtils::SwitchFromVghwHeap(clientHeap);

	return self;

	}

// vgCreateEGLImageTargetKHR

CVgImageInfo* CVgImageInfo::New(VGImageFormat aFormat, VGint aWidth, VGint aHeight, EGLImageKHR aEglImage, TUint64& aSgImageId)

	{

	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();

	CVgImageInfo* self = new CVgImageInfo(aFormat, aWidth, aHeight, VG_INVALID_HANDLE, 0, aEglImage, aSgImageId);

	CVghwUtils::SwitchFromVghwHeap(clientHeap);

	return self;

	}

// eglCreateImage

CVgImageInfo* CVgImageInfo::New(VGImageFormat aFormat, VGint aWidth, VGint aHeight, VGbitfield aAllowedQuality)

	{

	RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();

	CVgImageInfo* self = new CVgImageInfo(aFormat, aWidth, aHeight, VG_INVALID_HANDLE, aAllowedQuality, NULL, 0l);

	CVghwUtils::SwitchFromVghwHeap(clientHeap);

	return self;

	}

CVgImageInfo::~CVgImageInfo()

	{

	VGPANIC_ASSERT(iChildCount == 0, EVgPanicDeleteInUseVgImageInfo);

	if (iParent)

		{

		iParent->DecChildCount();

		}

	}

CVgImageInfo* CVgImageInfo::Parent() const

	{

	return iParent;

	}

TInt CVgImageInfo::ChildCount() const

	{

	return iChildCount;

	}

void CVgImageInfo::IncChildCount()

	{

	VGPANIC_ASSERT(!iIsDestroyed, EVgPanicParentImageAlreadyDestroyed);

	User::LockedInc(iChildCount);

	}

void CVgImageInfo::DecChildCount()

	{

	User::LockedDec(iChildCount);

	if ((iChildCount == 0) && iIsDestroyed)

		{

		if (iParent == NULL)

			{

			if (IsEglSibling())

				{ // close the root EglImage

				OpenVgState.EglImageClose(iEglImage);

				}

			}

		else

			{

			iParent->DecChildCount();

			}

		// delete this image & remove it from HandleMap

		RHeap* clientHeap = CVghwUtils::SwitchToVghwHeap();

		OpenVgState.UnMapHandle(iClientHandle);

		delete this;

		CVghwUtils::SwitchFromVghwHeap(clientHeap);

		}

	}

VGbitfield CVgImageInfo::AllowedQuality() const

	{

	return iAllowedQuality;

	}

TBool CVgImageInfo::IsEglSibling() const

	{

	return iIsEglSibling;

	}

EGLImageKHR CVgImageInfo::EglImage() const

	{

	return iEglImage;

	}

TUint64 CVgImageInfo::SgImageId() const

	{

	return iSgImageId;

	}

TBool CVgImageInfo::DestroyObject(MVgContext& aVgContext)

	{

	VGPANIC_ASSERT_DEBUG(iIsDestroyed, EVgPanicTemp);

	OPENVG_TRACE("  CVgImageInfo::DestroyObject HostHandle=0x%x; ChildCount=%d, Parent=0x%x, IsEglSibling=%d, EglImage=0x%x",

			iHostHandle, ChildCount(), Parent(), IsEglSibling(), EglImage());

	if (iHostHandle)

		{

		// Destroy image, but not for eglImages/SgImages

		if (!IsEglSibling())

			{

			RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

			vgApiData.Init(OpenVgRFC::EvgDestroyImage, RemoteFunctionCallData::EOpRequest);

			vgApiData.AppendParam(iHostHandle);

			aVgContext.ExecuteVgCommand(vgApiData);

			}

		iHostHandle = VG_INVALID_HANDLE;

		}

	if (iChildCount == 0)

		{

		if (iParent == NULL)

			{

			if (IsEglSibling())

				{ // close the root EglImage

				OpenVgState.EglImageClose(iEglImage);

				}

			}

		else

			{

			iParent->DecChildCount();

			}

		return ETrue;

		}

	// don't delete this image until all children have been destroyed

	return EFalse;

	}

TInt CVgImageInfo::BitsPerPixelForVgImageFormat(VGImageFormat aFormat)

	{

	TInt result = -1;

	if ((aFormat == VG_BW_1) || (aFormat == VG_A_1))

		{

		result = 1;

		}

	else if (aFormat == VG_A_4)

		{

		result = 4;

		}

	else if ((aFormat == VG_sL_8) || (aFormat == VG_lL_8) || (aFormat == VG_A_8))

		{

		result = 8;

		}

	else if ((aFormat >= 0) && (aFormat < 256))

		{ // low bits of format number repeat in a pattern for 16/32 bit per pel

		TInt format = aFormat & 0x3f;

		if ((format >= VG_sRGB_565) && (format <= VG_sRGBA_4444))

			{

			result = 16;

			}

		else if (format <= VG_lRGBA_8888_PRE)

			{

			result = 32;

			}

		}

	return result;

	}

void CVgImageInfo::PixmapBlit(TUint8* aDest, const TUint8* aSource, TInt aDestStride, TInt aSourceStride, TInt aRowCount,

		size_t aRowLength, TInt aLastBits)

	{

	VGPANIC_ASSERT_DEBUG(aDest, EVgPanicNullPointer);

	VGPANIC_ASSERT_DEBUG(aSource, EVgPanicNullPointer);

	VGPANIC_ASSERT_DEBUG(aDestStride >= aRowLength, EVgPanicStrideSmallerThanRowLength);

	VGPANIC_ASSERT_DEBUG(aSourceStride >= aRowLength, EVgPanicStrideSmallerThanRowLength);

	VGPANIC_ASSERT_DEBUG(aRowCount > 0, EVgPanicBadRowCountParam);

	VGPANIC_ASSERT_DEBUG(aRowLength > 0, EVgPanicBadRowLengthParam);

	VGPANIC_ASSERT_DEBUG( (aLastBits >= 0) && (aLastBits <= 7), EVgPanicBadLastBitsParam);

	if (aLastBits)

		{ // bits per pixel < 8, only copy lowest <aLastBits> from source to dest

		TUint8 destMask = 0xFF << aLastBits; // high bits

		TUint8 srcMask = 0xFF ^ destMask; // low bits

		aRowLength -= 1;

		for (VGint row = 0; row < aRowCount; ++row)

			{

			memcpy(aDest, aSource, aRowLength);

			TUint8 byte = (aDest[aRowLength] & destMask) | (aSource[aRowLength] & srcMask);

			aDest[aRowLength] = byte;

			aSource += aSourceStride;

			aDest += aDestStride;

			}

		}

	else

		{

		for (VGint row = 0; row < aRowCount; ++row)

			{

			memcpy(aDest, aSource, aRowLength);

			aSource += aSourceStride;

			aDest += aDestStride;

			}

		}

	}

VGint CVgImageInfo::GetParameterVectorSize(MVgContext& aVgContext, VGint aParamType)

	{

	switch (aParamType)

		{

		case VG_IMAGE_FORMAT:

		case VG_IMAGE_WIDTH:

		case VG_IMAGE_HEIGHT:

			return 1;

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return 0;

	}

VGfloat CVgImageInfo::GetParameterf(MVgContext& aVgContext, VGint aParamType)

	{

	switch (aParamType)

		{

		case VG_IMAGE_FORMAT:

			if (iFormat != VG_IMAGE_FORMAT_INVALID)

				{

				return (VGfloat)iFormat;

				}

			// for EglImage need to get format of underlying VgImage

			return HostVgGetParameterf(aVgContext, aParamType);

		case VG_IMAGE_WIDTH:

			return (VGfloat)iWidth;

		case VG_IMAGE_HEIGHT:

			return (VGfloat)iHeight;

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return 0;

	}

VGint CVgImageInfo::GetParameteri(MVgContext& aVgContext, VGint aParamType)

	{

	switch (aParamType)

		{

		case VG_IMAGE_FORMAT:

			if (iFormat != VG_IMAGE_FORMAT_INVALID)

				{

				return iFormat;

				}

			// for EglImage need to get format of underlying VgImage

			iFormat = (VGImageFormat) HostVgGetParameteri(aVgContext, aParamType);

			return iFormat;

		case VG_IMAGE_WIDTH:

			return iWidth;

		case VG_IMAGE_HEIGHT:

			return iHeight;

		}

	// invalid ParamType

	aVgContext.SetVgError(VG_ILLEGAL_ARGUMENT_ERROR);

	return 0;

	}

void CVgImageInfo::ClearImage(MVgContext& aVgContext, VGint aX, VGint aY, VGint aWidth, VGint aHeight)

	{

	// **** Desirable: check aImage is not rendering target

	RemoteFunctionCallData data; OpenVgRFC vgApiData(data);

	vgApiData.Init(OpenVgRFC::EvgClearImage, RemoteFunctionCallData::EOpRequest);

	vgApiData.AppendParam(iHostHandle);

	vgApiData.AppendParam(aX);

	vgApiData.AppendParam(aY);

	vgApiData.AppendParam(aWidth);

	vgApiData.AppendParam(aHeight);

	TUint64 sgId(0L);

	if (iIsEglSibling)

		{

		sgId = iSgImageId;

		}

	vgApiData.AppendTUint64(sgId);

	aVgContext.ExecuteVgCommand(vgApiData);

	}

void CVgImageInfo::ImageSubData(MVgContext& aVgContext, const void * aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aX, VGint aY,

		VGint aWidth, VGint aHeight)

	{

	// **** Desirable: check image is not a rendering target

	// Limit aWidth & aHeight to the dimensions of aImage

	if (iWidth < aWidth)

		{

		aWidth = iWidth;

		}

	if (iHeight < aHeight)

		{

		aHeight = iHeight;

		}

	OPENVG_TRACE("CVgImageInfo::ImageSubData.1a dest Image: width=%d, height=%d; clipped width=%d, clipped height=%d",

			iWidth, iHeight, aWidth, aHeight);

	TInt bitsPerPixel = BitsPerPixelForVgImageFormat(aDataFormat);

	TUint32 lineLength = ((static_cast<TUint32>(aWidth) * static_cast<TUint32>(bitsPerPixel)) + 7) / 8;

	OPENVG_TRACE("CVgImageInfo::ImageSubData.1b bitsPerPixel=%d, lineLength=%d", bitsPerPixel, lineLength);

	if (bitsPerPixel <= 0)

		{

		aVgContext.SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);

		}

	else

		{

		if (lineLength  == aDataStride)

			{ // use original parameters

			OPENVG_TRACE("CVgImageInfo::ImageSubData.2a: lineLength == dataStride");

			HostVgImageSubData(aVgContext, aData, aDataStride * aHeight, aDataStride,

					aDataFormat, aX, aY, aWidth, aHeight);

			}

		else if (0 == aDataStride)

			{ // Fill operation, pixmap size = lineLength

			OPENVG_TRACE("CVgImageInfo::ImageSubData.2b: 0 == dataStride");

			HostVgImageSubData(aVgContext, aData, lineLength, aDataStride,

					aDataFormat, aX, aY, aWidth, aHeight);

			}

		else

			{ // try to alloc a translation buffer - datastride maybe negative or simply > lineLength

			size_t pixmapSize = lineLength * aHeight;

			TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);

			OPENVG_TRACE("CVgImageInfo::ImageSubData.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);

			if (localBuffer != NULL)

				{ // reformat data into temporary buffer

				PixmapBlit(localBuffer, static_cast<const TUint8*>(aData), lineLength, aDataStride, aHeight, lineLength);

				HostVgImageSubData(aVgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aX, aY, aWidth, aHeight);

				CVghwUtils::Free(localBuffer);

				}

			else

				{ // alloc failed, so do VG operation row by row

				const TUint8* source = static_cast<const TUint8*>(aData);

				for (VGint row = 0; row < aHeight; ++row)

					{

					HostVgImageSubData(aVgContext, source, lineLength, lineLength, aDataFormat, aX + row, aY, aWidth, 1);

					source += aDataStride;

					}

				}

			}

		}

	}

void CVgImageInfo::HostVgImageSubData(MVgContext& aVgContext, const void* aPixmap, size_t aPixmapSize, VGint aHostDataStride,

		VGImageFormat aDataFormat, VGint aX, VGint aY, VGint aWidth, VGint aHeight)

	{

	VGPANIC_ASSERT(aPixmap != NULL, EVgPanicNullPixmapPointer);

	VGPANIC_ASSERT(aPixmapSize >= (aHostDataStride * aHeight), EVgPanicPixmapSizeError);

	RemoteFunctionCallData rfcdata; OpenVgRFC vgApiData(rfcdata);

	vgApiData.Init(OpenVgRFC::EvgImageSubData, RemoteFunctionCallData::EOpRequest);

	vgApiData.AppendParam(iHostHandle);

	vgApiData.AppendVector(aPixmap, aPixmapSize);

	vgApiData.AppendParam(aHostDataStride);

	vgApiData.AppendParam(aDataFormat);

	vgApiData.AppendParam(aX);

	vgApiData.AppendParam(aY);

	vgApiData.AppendParam(aWidth);

	vgApiData.AppendParam(aHeight);

	TUint64 sgId(0L);

	if (iIsEglSibling)

		{

		sgId = iSgImageId;

		}

	OPENVG_TRACE("CVgImageInfo::HostVgImageSubData sgId 0x%lx", sgId);

	vgApiData.AppendTUint64(sgId);

	aVgContext.ExecuteVgCommand(vgApiData);

	}

void CVgImageInfo::GetImageSubData(MVgContext& aVgContext, void * aData, VGint aDataStride, VGImageFormat aDataFormat, VGint aX, VGint aY, VGint aWidth, VGint aHeight)

	{

	// **** Desirable: check VGImage is not currently a rendering target

	// Limit aWidth & aHeight to the dimensions of aImage

	if (iWidth < aWidth)

		{

		aWidth = iWidth;

		}

	if (iHeight < aHeight)

		{

		aHeight = iHeight;

		}

	OPENVG_TRACE("CVgImageInfo::GetImageSubData.1a source Image: width=%d, height=%d; clipped width=%d, clipped height=%d",

			iWidth, iHeight, aWidth, aHeight);

	TInt bitsPerPixel = BitsPerPixelForVgImageFormat(aDataFormat);

	TUint32 lineLength = static_cast<TUint32>(aWidth) * static_cast<TUint32>(bitsPerPixel);

	TUint32 tailBits = lineLength & 7;

	lineLength = (lineLength + 7) / 8;

	OPENVG_TRACE("CVgImageInfo::GetImageSubData.1b bitsPerPixel=%d, lineLength=%d, tailBits=%d", bitsPerPixel, lineLength, tailBits);

	if (bitsPerPixel <= 0)

		{

		aVgContext.SetVgError(VG_UNSUPPORTED_IMAGE_FORMAT_ERROR);

		}

	else

		{

		if (lineLength  == aDataStride)

			{ // use original params

			OPENVG_TRACE("CVgImageInfo::GetImageSubData.2a: lineLength == dataStride");

			HostVgGetImageSubData(aVgContext, aData, aDataStride * aHeight, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);

			}

		else if (0 == aDataStride)

			{ // unlikely unless aHeight = 1, symmetric to fill function for vgGetImageSubData

			OPENVG_TRACE("CVgImageInfo::GetImageSubData.2b: 0 == dataStride");

			HostVgGetImageSubData(aVgContext, aData, lineLength, aDataStride, aDataFormat, aX, aY, aWidth, aHeight);

			}

		else

			{ // datastride maybe negative or simply > lineLength

			TInt pixmapSize = lineLength * aHeight;

			TUint8* localBuffer = (TUint8*) CVghwUtils::Alloc(pixmapSize);

			OPENVG_TRACE("CVgImageInfo::GetImageSubData.2c: dataStride not 0 or lineLength, localBuffer=0x%x", localBuffer);

			if (localBuffer != NULL)

				{ // read pixels into temporary buffer

				HostVgGetImageSubData(aVgContext, localBuffer, pixmapSize, lineLength, aDataFormat, aX, aY, aWidth, aHeight);

				// reformat into client memory

				PixmapBlit(static_cast<TUint8*>(aData), localBuffer, aDataStride, lineLength, aHeight, lineLength, tailBits);

				CVghwUtils::Free(localBuffer);

				}

			else

				{ // alloc failed, so do VG operation row by row

				TUint8* dest = static_cast<TUint8*>(aData);

				for (VGint row = 0; row < aHeight; ++row)

					{

					HostVgGetImageSubData(aVgContext, dest, lineLength, lineLength, aDataFormat, aX + row, aY, aWidth, 1);

					dest += aDataStride;

					}

				}