// Copyright (c) 2007-2009 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:

//

#include "directgdidriverimpl.h"

#include "directgdiimagetargetimpl.h"

#include "directgdiimagesourceimpl.h"

#include "directgdiadapter.h"

#include "directgdiimageref.h"

#include "vgengine.h"

#include "confighelper.h"

#include <graphics/directgdiimagetarget.h>

#include <graphics/sgresource.h>

#include <fbs.h>

#include <bitdev.h>

#ifndef __WINS__

// Static member variable

XDirectGdiDriverProcessState CDirectGdiDriverImpl::gProcessState;

#endif

/**

Handles an EGL failure. It may either set the passed-in TInt to a Symbian OS-mapped error code,

or panic the specified panic code, depending on the egl failure. Done as a macro so the line number is reported.

*/

#define HANDLE_EGL_ERROR(err, panic) \

	{ \

	const EGLint eglError = eglGetError(); \

	if (eglError == EGL_BAD_ALLOC) \

		err = KErrNoMemory; \

	else if (eglError == EGL_CONTEXT_LOST) \

		err = KErrDied; \

	else if (eglError != EGL_SUCCESS) \

		{ \

		TBuf16<256> _message; \

		_message.Format(_L16("EGL Error: %x\n"), eglError); \

		GRAPHICS_LOGD_DEBUG(_message); \

		GRAPHICS_ASSERT_DEBUG(eglError == EGL_SUCCESS, panic);	\

		} \

	}

/**

Populates the config hash map with matching EGL configs, based on the supported pixel types.

@param aDisplay A valid EGL display to retrieve EGL configs for.

@panic DGDIAdapter 24, if no suitable EGL configs are present (debug-only).

@panic DGDIAdapter 25, if no exact matching EGL config can be found.

@panic DGDIAdapter 29, if RSgImage::GetPixelFormats returns pixel count <= 0.

@pre  EGL has been initialised by eglInitialize().

@post The supported EGL configs are stored in the hash map.

@return KErrNoError if successful, KErrNotReady if EGL was not initialised, otherwise one of the 

system-wide error codes.

*/

TInt CDirectGdiDriverImpl::InitializeEglConfigs(EGLDisplay aDisplay)

	{

#ifdef _DEBUG_DIRECTGDI

	GRAPHICS_LOG_DEBUG("InitializeEglConfigs");

#endif

	TInt err = KErrNone;	

	// Get EGL configs upfront and store them in a hash map	

	EGLint configSize = 0;

	EGLConfig *configs = NULL;

	// Query RsgImage for the number of supported target pixel formats. Then we know how much memory should be 

	// allocated to the pixelformats array.

	TInt count = 0;

	TSgImageInfo imageInfo;

	imageInfo.iUsage = ESgUsageDirectGdiTarget;

	imageInfo.iSizeInPixels = TSize(1,1);

	TUidPixelFormat* pixelFormats = NULL;		

	err = RSgImage::GetPixelFormats(imageInfo, NULL, count);

	GRAPHICS_ASSERT_DEBUG(count > 0, EDirectGdiPanicNoValidPixelFormats);

	if (err == KErrNone)

		{

		pixelFormats = new TUidPixelFormat[count];			

		if (pixelFormats == NULL)

			{

			err = KErrNoMemory;

			}

		}

	if (err == KErrNone)

		{

		err = RSgImage::GetPixelFormats(imageInfo, pixelFormats, count);		

		if (!eglGetConfigs(aDisplay, configs, 0, &configSize) && configSize)

			{

			HANDLE_EGL_ERROR(err, EDirectGdiPanicNoAvailableConfigs);

			}

		}

	if (err == KErrNone)

		{

		configs = new EGLConfig[configSize];

		if (configs == NULL)

			{

			err = KErrNoMemory;

			}

		}

	for (TInt i = 0; (i < count) && (err == KErrNone); ++i) 

		{

		// Finds a suitable config to map to this bitmap.

		TInt selPixmapAttribs = TConfigHelper::MatchPixelType(pixelFormats[i]);

		EGLint numConfigs = 0;

		if (!eglChooseConfig(aDisplay, TConfigHelper::KSurfaceAttribs[selPixmapAttribs], configs, configSize, &numConfigs))

			{

			HANDLE_EGL_ERROR(err, EDirectGdiPanicNoMatchingConfig);

			break;

			}

		GRAPHICS_ASSERT_ALWAYS(numConfigs >= 1, EDirectGdiPanicNoAvailableConfigs);

		// Find an exact matching config from the available configs.

		TInt match = TConfigHelper::GetSuitablePixmapConfigIndex(aDisplay, configs, numConfigs, selPixmapAttribs);

		GRAPHICS_ASSERT_ALWAYS(match >= 0, EDirectGdiPanicNoMatchingConfig);

		EGLConfig currentConfig = configs[match];

		// Store this matching config and the pixel type in the hash map.

		err = iPixelConfigMap.Insert(selPixmapAttribs, currentConfig);					

		}		

	delete [] configs;		

	delete [] pixelFormats;

	return err;

	}

/**

Constructor to allocate memory to CDirectGdiDriverImpl object.

@param aInternal On success, will store a pointer to the newly created CDirectGdiDriverImpl.

@param aLibrary

@return KErrNone if successful, otherwise one of the system-wide error codes.

*/

TInt CDirectGdiDriverImpl::New(CDirectGdiDriverInternal*& aInternal, RLibrary aLibrary)

	{

	CDirectGdiDriverImpl* self = new CDirectGdiDriverImpl(aLibrary);

	if(!self)

		return KErrNoMemory;

	TInt err = self->Construct();

	if(err != KErrNone)

		{

		aInternal = NULL;

		delete self;

		return err;

		}

	aInternal = self;

	return err;		

	}

/**

Destructor - frees the memory for the hashmaps and the source and target arrays.

@panic DGDIAdapter 45, if images are still in the source or target image array (debug-only).

*/

CDirectGdiDriverImpl::~CDirectGdiDriverImpl()

	{

	// Check that there are no drawbles left in the drawable array

	GRAPHICS_ASSERT_DEBUG(iSourceArray.Count() == 0, EDirectGdiPanicItemsLeftInImageArray);

	GRAPHICS_ASSERT_DEBUG(iTargetArray.Count() == 0, EDirectGdiPanicItemsLeftInImageArray);

	iSourceArray.Close();

	iTargetArray.Close();

	delete iVgImageCache;

	THashMapIter<TInt, EGLContext> contextIter(iPixelContextMap);

	const EGLContext* context = contextIter.NextValue();

	while (context)

		{

		eglDestroyContext(iDisplay, *context);

		context = contextIter.NextValue();		

		}

	iPixelContextMap.Close();

	iPixelConfigMap.Close();

	delete iGlyphImageStorage;

	eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

	// This will terminate the display if it is the last driver.

	ProcessState().CloseDriver(iDisplay); 

	eglReleaseThread();

	SgDriver::Close();

	}

/**

@see CDirectGdiDriver::Flush()

*/

void CDirectGdiDriverImpl::Flush()

	{

	vgFlush();

	}

/**

 @see CDirectGdiDriver::Finish()

 */

void CDirectGdiDriverImpl::Finish()

	{

	// Call eglWaitClient() instead of vgFinish() because MBX EGL implementation currently 

	// does nothing with a vgFinish().

	if (eglWaitClient() == EGL_FALSE)

		{

		TInt err = KErrNone;

		HANDLE_EGL_ERROR(err, EDirectGdiPanicFinish);

		SetError(err);

		}

	}

/**

@see CDirectGdiDriver::GetError()

If no error has been reported explicitly, or SetError() has not been called, it will instead return

the first (if any) OpenVG error to occur since GetError() was last called.

*/

TInt CDirectGdiDriverImpl::GetError()

	{

	// Call vgGetError() even when iErrorCode is already set, so that any OpenVG error state is 

	// cleared and not reported in future.

	const TInt vgErrorCode = GetVgError();

	if (iErrorCode == KErrNone)

		{

		iErrorCode = vgErrorCode;

		}

	TInt error = iErrorCode;

	iErrorCode = KErrNone;

	return error;

	}

/**

@see CDirectGdiDriver::CreateDrawableSource()

For image resource creates a DirectGDI adaptation-specific resource from the given RSgDrawable resource so 

it can be drawn using the DirectGDI rendering API. Creates an EGLImage, then a VGImage from the 

passed RSgImage and associates the new source with these images. Sources that are successfully created 

are added to an array of sources so that they can be closed and deleted correctly at a later stage.

Note that an image source cannot be created before an image target has been created and activated.

This is a limitation of OpenVG as a VG context must exist before an image source can be created.

@param aHandleRet Handle of newly created drawable source, must be KNullHandle (is checked by generic driver).

@param aSgDrawable The RSgDrawable object to use when creating the drawable source. An attempt is made to 

match the pixel format of the new EGL surface with the pixel format of this RSgImage.

@pre CDirectGdiDriver object has been initialised from the calling thread and a target has been activated.

     aHandleRet is KNullHandle.

@post The DirectGDI adaptation-specific resource that is bound to the given 

drawable resource is created and this handle is now associated with it. The reference 

counter on the drawable resource is incremented. The CDirectGdiDriver for this thread 

is now aware of and owns the adaptation-specific resource.

@return KErrNone if successful, KErrArgument if the drawable resource is not valid, 

KErrNotSupported if the drawable resource is not created with the type (KSgImageTypeUid), 

otherwise one of the system-wide error codes.

*/

TInt CDirectGdiDriverImpl::CreateDrawableSource(TInt& aHandleRet, const RSgDrawable& aSgDrawable)

	{

	TUid typeUid = aSgDrawable.DrawableType();

	if(typeUid != KSgImageTypeUid)

		{

		return KErrNotSupported;

		}

	const RSgImage* image = reinterpret_cast<const RSgImage*>(&aSgDrawable); 

	CDirectGdiImageSourceImpl* imageSource = NULL;

	TInt err = CDirectGdiImageSourceImpl::New(imageSource, *this, *image);

	if (err == KErrNone)

		{

		aHandleRet = reinterpret_cast<TInt>(imageSource);			

		}

	return err;

	}

/**

@see CDirectGdiDriver::CreateDrawableSource()

Destroys the DirectGDI adaptation-specific resource associated with this handle.

Calling this method on a handle that is not associated with any DirectGDI specific 

resource will do nothing. Once Close() is called, this handle can be reused. The handle

is set to KNullHandle.

@param 	aHandle A reference to a valid handle to a RDirectGdiDrawableSource object which is

        to be closed.

@pre 	CDirectGdiDriver object has been initialised from the calling thread.

@post 	The DirectGDI adaptation-specific resource associated with this handle will

be destroyed (at any time preferred by the adaptation). This handle is no longer 

associated with a DirectGDI adaptation-specific resource. The reference counter of 

the underlying drawable resource is decremented. aHandle is set to KNullHandle.

@panic DGDIAdapter 37, if an image source cannot be created from the passed handle.

*/

void CDirectGdiDriverImpl::CloseDrawableSource(TInt& aHandle)

	{	

	CDirectGdiImageSourceImpl* imageSource = GetImageSourceFromHandle(aHandle);

	GRAPHICS_ASSERT_ALWAYS(imageSource, EDirectGdiPanicCloseDrawableHandleFailure);		

	// Decrement the reference count on this image source. If it reaches zero, it will

	// remove itself from the source array and delete itself.

	imageSource->Close();

	aHandle = KNullHandle;

	}

/**

@see CDirectGdiDriver::CreateImageTarget()

Allocates and constructs a CDirectGdiImageTargetImpl object, and associates it with aHandleRet.

@param  aHandleRet Handle of newly created Image Target, must be KNullHandle (is checked by generic driver).

@param aSgImage The RSgImage to associate with the created image target. An attempt is made to match 

the pixel format of the new EGL surface with the pixel format of this RSgImage.

@pre 	CDirectGdiDriver object has been initialised from the calling thread.

The image resource has been fully constructed and created with the correct usage 

that allows it to be used as a DirectGDI target. aHandleRet is KNullHandle.

@post 	The DirectGDI adaptation-specific resource that is bound to the given image 

resource is created and this handle is now associated with it. The reference counter

on the image resource is incremented. 

@return KErrNone if successful, KErrArgument if the image resource is not valid, 

KErrNotSupported if the image resource is not created with the correct 

usage, otherwise one of the system-wide error codes.

*/

TInt CDirectGdiDriverImpl::CreateImageTarget(TInt& aHandleRet, const RSgImage& aSgImage)

	{		

	CDirectGdiImageTargetImpl* imageTarget = NULL;

	TInt err = CDirectGdiImageTargetImpl::New(imageTarget, *this, aSgImage, iPixelContextMap, iPixelConfigMap, iSharedContext);

	if (err == KErrNone)

		{

		// Return the handle to the newly created image target.

		aHandleRet = reinterpret_cast<TInt>(imageTarget);					

		}

	return err;	

	}

/**

Destroys the DirectGDI adaptation-specific resource associated with this handle. 

Calling this method on a handle that is not associated with any DirectGDI adaptation-

specific resource will do nothing. Once Close() is called, this handle can be reused.

@param 	aHandle A handle to a RDirectGdiImageTarget object to be closed.

@pre 	CDirectGdiDriver object has been initialised from the calling thread.

@post 	The DirectGDI specific resource associated with this handle will be destroyed

if the reference count falls to zero. This handle is no longer associated with 

a DirectGDI specific resource. The reference counter of the underlying image 

resource is decremented. aHandle is set to KNullHandle.

@panic DGDIAdapter 37, if the image source associated with aHandle is NULL.

*/

void CDirectGdiDriverImpl::CloseImageTarget(TInt& aHandle)

	{	

	CDirectGdiImageTargetImpl* imageTarget = GetImageTargetFromHandle(aHandle);

	GRAPHICS_ASSERT_ALWAYS(imageTarget, EDirectGdiPanicCloseDrawableHandleFailure);	

	// Decrement the reference count on this image target. If the reference count reaches zero, 

	// it is deleted and removed from the targets array.

	imageTarget->Close();

	aHandle = KNullHandle;

	}

/**

Instantiates an adaptation-specific rendering engine.

@param	aDirectGdiEngine Reference to instantiated engine.

@pre 	CDirectGdiDriver object has been initialised from the calling thread.

@return	KErrNone if the engine is constructed, else KErrNoMemory.

*/

TInt CDirectGdiDriverImpl::CreateEngine(MDirectGdiEngine*& aDirectGdiEngine)

	{

	TInt result = KErrNone;

	aDirectGdiEngine = new CVgEngine(*this);

	if (aDirectGdiEngine == NULL)

		{

		result = KErrNoMemory;

		}

	return result;

	}

/**

Unbinds target from rendering engine and marks it for deletion.

NOTE: Currently this means just deleting the engine.

@param	aDirectGdiEngine Engine to operate on.

@pre CDirectGdiDriver object has been initialised from the calling thread.

@panic DGDIAdapter 38, if the engine is NULL.

*/

void CDirectGdiDriverImpl::DestroyEngine(MDirectGdiEngine* aDirectGdiEngine)

	{

	GRAPHICS_ASSERT_ALWAYS(aDirectGdiEngine, EDirectGdiPanicDestroyNullEngine);	

	CVgEngine* actualEngine = static_cast<CVgEngine*>(aDirectGdiEngine);

	delete actualEngine;

	}

/**

The only extension interface supported by this implementation is MDirectGdiDriverCacheSize.

@see CDirectGdiDriver::GetInterface()

 */

TInt CDirectGdiDriverImpl::GetInterface(TUid aInterfaceId, TAny*& aInterface)

	{

	aInterface = NULL;

	TInt err = KErrNone;

	switch (aInterfaceId.iUid)

		{

		case KDirectGdiDriverCacheSizeUid:

			{

			aInterface = static_cast<MDirectGdiDriverCacheSize*>(this);

			break;	

			}		

		default:

			err = KErrExtensionNotSupported;

			break;

		}

	return err;

	}

CDirectGdiDriverImpl::CDirectGdiDriverImpl(RLibrary aLibrary)

	: CDirectGdiDriverInternal(aLibrary),

	iDisplay(EGL_NO_DISPLAY)

	{

	}

/**

Performs the second phase of construction.

@pre CDirectGdiDriver object has been initialised from the calling thread.

@post EGL has been initialised. SgDriver has been opened.

@panic DGDIAdapter 36, if eglGetDisplay() fails.

@panic DGDIAdapter 35, if eglInitialize() fails.

@panic DGDIAdapter 23, if eglBindAPI() fails.

@return KErrNone if successful, KErrNotFound if no implementation of the Graphics Resource API is found,

        KErrNotSupported if the version of EGL is less than required (1.2), otherwise one of the 

        system-wide error codes.

*/

TInt CDirectGdiDriverImpl::Construct()

	{

	TInt err = KErrNone;

	iSharedContext = EGL_NO_CONTEXT;

	// First thing is to check whether the mutex for the Process State was successfully created.

	// If not, it's a fatal error. If it is, we must increment the reference count on the mutex as 

	// early as possible to make the creation/destruction of the display thread-safe. 

	err = ProcessState().MutexCreationStatus();

	if (err == KErrNone)

		{

		ProcessState().OpenDriver();

		}

	if (err == KErrNone)

		{

		err = SgDriver::Open();

		}

	if (err == KErrNone)

		{

		// Create display object

		iDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

		GRAPHICS_ASSERT_ALWAYS(iDisplay != EGL_NO_DISPLAY, EDirectGdiPanicNoDisplay);			

		// Initialise the display.  If it is already initialised, EGL will return quickly.

		EGLint major, minor;

		if (!eglInitialize(iDisplay, &major, &minor))

			{

			iDisplay = EGL_NO_DISPLAY;

			HANDLE_EGL_ERROR(err, EDirectGdiPanicInitializeDisplay);

			}

		else if (major < 1 || (major == 1 && minor < 2))

			{

			// Atleast EGL 1.2 needs to be available.

			err = KErrNotSupported;

			}

		}

	if (err == KErrNone)

		{

		// Let EGL know we will use it for OpenVG

		if(!eglBindAPI(EGL_OPENVG_API))

			{

			HANDLE_EGL_ERROR(err, EDirectGdiPanicBindApi);

			}

		}

	if (err == KErrNone)

		{

		iGlyphImageStorage = new CFontGlyphImageStorage(KDirectGdiAdapterDefaultMaxGlyphImageCacheSize);

		if(!iGlyphImageStorage)

			{

			err = KErrNoMemory;

			}

		}

	if (err == KErrNone)

		{

		iVgImageCache = new CVgImageCache(KDirectGdiAdapterDefaultMaxImageCacheSize);

		if(!iVgImageCache)

			{

			err = KErrNoMemory;

			}

		}

	if (err == KErrNone)

		{

		err = ProcessState().Initialize(iDisplay);