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

// Implementation of SgImage functions exported through eglGetProcAddress

#include "eglapi.h"

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

// CEgLImage

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

#ifdef FAISALMEMON_S4_SGIMAGE

CEglImage::CEglImage() : iSgHandle(), iDisplay(0), iSgImageInfo(), iPbufferHandle(0), iVgHandle(VG_INVALID_HANDLE),

		iCreateCount(1), iOpenCount(0), iIsDestroyed(EFalse)

	{

	EGL_TRACE("CEglImage::CEglImage(0x%x)", this);

	}

CEglImage::~CEglImage()

	{

	EGL_TRACE("CEglImage::~CEglImage(0x%x) iCreateCount=%d, iOpenCount=%d", this, iCreateCount, iOpenCount);

	EGLPANIC_ASSERT_DEBUG( (iCreateCount == 0) && (iOpenCount == 0), EEglPanicEglImageRefCountNonZero);

	iSgHandle.Close();

	}

// initialise member data

void CEglImage::Create(TSgDrawableId aSgImageId, EGLDisplay aDisplay, TSgImageInfo& aSgImageInfo, TInt aPbufferHandle,

		VGHandle aVgHandle)

	{

	EGL_TRACE("CEglImage::Create iCreateCount=%d, iOpenCount=%d", iCreateCount, iOpenCount);

	EGLPANIC_ASSERT_DEBUG(iCreateCount == 0, EEglPanicEglImageRefCountNonZero);

	EGLPANIC_ASSERT_DEBUG(!iIsDestroyed, EEglPanicEglImageIsDestroyed);

	EGLPANIC_ASSERT_DEBUG(aSgImageId != KSgNullDrawableId, EEglPanicTemp);

	++iCreateCount;

	TInt err = iSgHandle.Open(aSgImageId);

	EGLPANIC_ASSERT_DEBUG(err == KErrNone, EEglPanicTemp);

	iDisplay = aDisplay;

	iSgImageInfo = aSgImageInfo;

	iVgHandle = aVgHandle;

	iPbufferHandle = aPbufferHandle;

	}

// Duplicate open

void CEglImage::Duplicate()

	{

	EGL_TRACE("CEglImage::Duplicate iCreateCount=%d, iOpenCount=%d", iCreateCount, iOpenCount);

	EGLPANIC_ASSERT_DEBUG( (iCreateCount > 0) && !iIsDestroyed, EEglPanicEglImageIsDestroyed);

	++iCreateCount;

	}

// If successful increments reference count & returns ETrue. (Ultimtately called from e.g. vgCreateEGLImageTargetKHR.) 

TBool CEglImage::OpenForVgImage(TSize& aSize, VGHandle& aVgHandle, TUint64& aSgImageId)

	{

	EGL_TRACE("CEglImage::OpenForVgImage iCreateCount=%d, iOpenCount=%d", iCreateCount, iOpenCount);

	if ( (iCreateCount > 0) && (iSgImageInfo.iUsage & ESgUsageBitOpenVgImage) )

		{

		++iOpenCount;

		aSize = iSgImageInfo.iSizeInPixels;

		aVgHandle = iVgHandle;

		aSgImageId = iSgHandle.Id().iId;

		return ETrue;

		}

	return EFalse;

	}

// If successful decrements reference count & returns ETrue. (Ultimtately called from e.g. vgDestroyImage.) 

TBool CEglImage::Close()

	{

	EGL_TRACE("CEglImage::Close iCreateCount=%d, iOpenCount=%d", iCreateCount, iOpenCount);

	if (iOpenCount > 0)

		{

		--iOpenCount;

		if ( RefCount() == 0 )

			{

			iSgHandle.Close();

			}

		return ETrue;

		}

	return EFalse;

	}

// If not already destroyed: mark EglImage as destroyed, dec reference count, return ETrue. (Called from eglDestroyImageKHR.) 

TBool CEglImage::Destroy()

	{

	EGL_TRACE("CEglImage::Destroy iCreateCount=%d, iOpenCount=%d", iCreateCount, iOpenCount);

	if (!iIsDestroyed)

		{

		--iCreateCount;

		if (iCreateCount == 0)

			{

			iIsDestroyed = ETrue;

			if ( RefCount() == 0 )

				{

				iSgHandle.Close();

				}

			return ETrue;

			}

		}

	return EFalse;

	}

// Reference Count: count of unbalanced Create() plus Open() calls.

TInt CEglImage::RefCount()

	{

	return iOpenCount + iCreateCount;

	}

TSgDrawableId CEglImage::SgImageId() const

	{

	return iSgHandle.Id();

	}

EGLDisplay CEglImage::Display() const

	{

	return iDisplay;

	}

TBool CEglImage::IsDestroyed() const

	{

	return iIsDestroyed;

	}

#else

void CEglImage::Duplicate() {}

TBool CEglImage::OpenForVgImage(TSize& aSize, VGHandle& aVgHandle, TUint64& aSgImageId) {return ETrue;}

TBool CEglImage::Close() {return ETrue;}

TBool CEglImage::Destroy() {return ETrue;}

TBool CEglImage::IsDestroyed() const {return ETrue;}

TInt CEglImage::RefCount() {return 0;}

EGLDisplay CEglImage::Display() const {return ETrue;}

#endif

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

// SgImage stuff in CGuestEGL

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

EGLint CGuestEGL::ValidateEglImageTarget(EGLDisplay aDisplay, EGLContext aContext, EGLenum aTarget,

		EGLClientBuffer aBuffer, const EGLint *aAttribList, TSymbianPixmapTypeId aTargetPixmapType)

	{

	if (!IsDisplayInitialized(aDisplay)) // ToDo just check display is valid, don't care if it is initialised

		{

		return EGL_BAD_DISPLAY;

		}

	if ( (aContext != EGL_NO_CONTEXT) || (aTarget != EGL_NATIVE_PIXMAP_KHR) )

		{

		return EGL_BAD_PARAMETER;

		}

	aTargetPixmapType = EglInternalFunction_GetNativePixmapType((EGLNativePixmapType) aBuffer);

	if ( (aTargetPixmapType != EPixmapTypeSgImage) || !EglInternalFunction_IsValidNativePixmap((EGLNativePixmapType) aBuffer, aTargetPixmapType) )

		{

		return EGL_BAD_PARAMETER;

		}

	// ToDo check Attrib List is valid

	return EGL_SUCCESS;

	}

#ifdef FAISALMEMON_S4_SGIMAGE

EGLImageKHR CGuestEGL::DuplicateEglImageIfItExists(EGLDisplay aDisplay, TSgDrawableId aSgId)

	{ // ToDo something smarter with a Hash Map ?

	TInt imageCount = iEglImageArray.Count();

	for (TInt index = 0; index < imageCount; ++index)

		{

		CEglImage* imagePtr = iEglImageArray[index];

		if ( !imagePtr->IsDestroyed() && (imagePtr->SgImageId() == aSgId)  && (imagePtr->Display() == aDisplay) )

			{

			imagePtr->Duplicate();

			EGL_TRACE("CGuestEGL::DuplicateEglImageIfItExists SgImage already used for eglImage=0x%x", imagePtr);

			return (EGLImageKHR)imagePtr;

			}

		}

	return EGL_NO_IMAGE_KHR;

	}

EGLImageKHR CGuestEGL::CreateNewEglImage(TEglThreadState& aThreadState, EGLDisplay aDisplay, TSgDrawableId aSgId, TSgImageInfo aSgImageInfo)

	{

	RHeap* oldHeap = CVghwUtils::SwitchToVghwHeap();

	CEglImage* newImage = new CEglImage();

	if (newImage)

		{

		if (KErrNone != iEglImageArray.InsertInAddressOrder(newImage))

			{

			delete newImage;

			newImage = NULL;

			}

		}

	CVghwUtils::SwitchFromVghwHeap(oldHeap);

	if (newImage == NULL)

		{

		EGL_TRACE("CGuestEGL::CreateNewEglImage 1.a error creating new CEglImage");

		return EGL_NO_IMAGE_KHR;

		}

	// success ...

	EGL_TRACE("CGuestEGL::CreateNewEglImage 1.b Created new eglImage=0x%x", newImage);

	TInt pbufferHandle;

	TInt vgImageHandle;

	TUint64 sgHandles;

    EGLint hostResult = CVghwUtils::EglGetSgHandles(aSgId.iId, &sgHandles);

    pbufferHandle = (TInt)(sgHandles&0xFFFFFFFF);

    vgImageHandle = (TInt)((sgHandles>>32)&0xFFFFFFFF);

	EGL_TRACE("CGuestEGL::CreateNewEglImage 2. CVghwUtils::EglGetSgHandles result=%d, pbufferHandle=0x%x, vgImageHandle=0x%x", 

			hostResult, pbufferHandle, vgImageHandle);

	EGLPANIC_ASSERT(KErrNone == hostResult, EEglPanicTemp);

	newImage->Create(aSgId, aDisplay, aSgImageInfo, pbufferHandle, vgImageHandle);

	return (EGLImageKHR)newImage;

	}

#endif // FAISALMEMON_S4_SGIMAGE

/*

 * eglCreateImageKHR supports Khronos EGL extension #8, "KHR_image_base"

 *

 * Supported values for target parameter:

 * EGL_NATIVE_PIXMAP_KHR for Khronos EGL extension #9, "KHR_image_pixmap"

 */

EGLImageKHR CGuestEGL::eglCreateImageKHR(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLContext aContext, EGLenum aTarget,

		EGLClientBuffer aBuffer, const EGLint *aAttribList)

	{

	// ToDo lock aDisplay

	EGLImageKHR eglImage = EGL_NO_IMAGE_KHR;

	iEglImageLock.Wait();

	TSymbianPixmapTypeId targetPixmapType = EPixmapTypeNone;

	EGLint error = ValidateEglImageTarget(aDisplay, aContext, aTarget, aBuffer, aAttribList, targetPixmapType);

	EGL_TRACE("CGuestEGL::eglCreateImageKHR 1. validate error=%d, targetPixmapType=%d", error, targetPixmapType);

	if (error == EGL_SUCCESS)

		{

		switch(targetPixmapType)

			{

			case EPixmapTypeSgImage:

				{

#ifdef FAISALMEMON_S4_SGIMAGE

				// try to lock SgImage from disappearing by opening a temporary handle

				RSgImage* sgImagePtr = reinterpret_cast<RSgImage*>(aBuffer);

				TSgDrawableId sgId = sgImagePtr->Id();

				RSgDrawable sgHandle;

				TSgImageInfo imgInfo;

				// ToDo ensure SgImage has correct suitable usage bits 

				if ( (sgId != KSgNullDrawableId) && (KErrNone == sgHandle.Open(sgId)) && (KErrNone == sgImagePtr->GetInfo(imgInfo)) )

					{

					EGL_TRACE("CGuestEGL::eglCreateImageKHR 2. SgImage PixelFormat=%d; size=%d,%d; Usage=0x%x",

							imgInfo.iPixelFormat, imgInfo.iSizeInPixels.iWidth, imgInfo.iSizeInPixels.iHeight, imgInfo.iUsage);

					// find / create CEglImage

					if (error == EGL_SUCCESS)

						{ // SgImage may already be used for an EglImage

						eglImage = DuplicateEglImageIfItExists(aDisplay, sgId);

						if (eglImage == EGL_NO_IMAGE_KHR)

							{ // first use

							eglImage = CreateNewEglImage(aThreadState, aDisplay, sgId, imgInfo);

							if (eglImage == EGL_NO_IMAGE_KHR)

								{

								error = EGL_BAD_ALLOC;

								}

							}

						}

					}

				else

					{

					error = EGL_BAD_PARAMETER;

					}

				sgHandle.Close();

#endif

				}

				break;

			case EPixmapTypeFbsBitmap:

			case EPixmapTypeNone:

			default: // pixmap type not supported by this API

				error = EGL_BAD_PARAMETER;

				break;

			}

		}

	iEglImageLock.Signal();

	aThreadState.SetEglError(error);

	// we either failed or should have a non-NULL handle

	EGLPANIC_ASSERT_DEBUG( (error != EGL_SUCCESS) || (eglImage != EGL_NO_IMAGE_KHR), EEglPanicTemp);

	return eglImage;

	}

/*

 * eglDestroyImageKHR supports Khronos EGL extension #8, "KHR_image_base"

 */

EGLBoolean CGuestEGL::eglDestroyImageKHR(TEglThreadState& aThreadState, EGLDisplay aDisplay, EGLImageKHR aImage)

	{

	// ToDo lock aDisplay

	EGLBoolean result = EGL_FALSE;

	iEglImageLock.Wait();

	TInt index = iEglImageArray.FindInAddressOrder((CEglImage*)aImage);

	if (index >= 0)

		{

		CEglImage* eglImage = iEglImageArray[index];

		if ( (eglImage->Display() && aDisplay) && eglImage->Destroy())

			{

			result = EGL_TRUE;

			if (eglImage->RefCount() == 0)

				{

				iEglImageArray.Remove(index);

				delete eglImage;

				}

			}

		}

	iEglImageLock.Signal();

	// set EGL Error appropriately

	aThreadState.SetEglError( result ? EGL_SUCCESS : EGL_BAD_PARAMETER);

	return result;

	}

TBool CGuestEGL::EglImageOpenForVgImage(EGLImageKHR aImage, TSize& aSize, VGHandle& aVgHandle, TUint64& aSgImageId)

	{

	EGLBoolean result = EGL_FALSE;

	iEglImageLock.Wait();

	TInt index = iEglImageArray.FindInAddressOrder((CEglImage*)aImage);

	if (index >= 0)

		{

		CEglImage* eglImage = iEglImageArray[index];

		if (eglImage->OpenForVgImage(aSize, aVgHandle, aSgImageId))

			{

			result = EGL_TRUE;

			}

		}

	iEglImageLock.Signal();

	return result;

	}

void CGuestEGL::EglImageClose(EGLImageKHR aImage)

	{

	iEglImageLock.Wait();

	TInt index = iEglImageArray.FindInAddressOrder((CEglImage*)aImage);

	if (index >= 0)

		{

		CEglImage* eglImage = iEglImageArray[index];

		if (eglImage->Close())

			{

			if (eglImage->RefCount() == 0)

				{

				iEglImageArray.Remove(index);

				delete eglImage;

				}

			}

		}

	iEglImageLock.Signal();

	}

// end of file eglsgimage.cpp