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

// Graphics Resource - driver implementation

//

#include "sgdriver.h"

const TInt KSgMaxLocalChunkSize = 0x100000;

const TInt KSgLocalChunkAlignment = 0x40;

EXPORT_C TInt RSgDriver::Open()

	{

	if (iImpl)

		{

		return KErrInUse;

		}

	if (gPls.iError != KErrNone)

		{

		return gPls.iError;

		}

	gPls.iMutex.Wait();

	if (gPls.iDriver)

		{

		++gPls.iOpenCount;

		iImpl = gPls.iDriver;

		gPls.iMutex.Signal();

		return KErrNone;

		}

	RChunk chunk;

	TInt err = chunk.CreateLocal(KMinHeapGrowBy, KSgMaxLocalChunkSize, EOwnerProcess);

	if (err != KErrNone)

		{

		gPls.iMutex.Signal();

		return err;

		}

	RHeap* heap = UserHeap::ChunkHeap(chunk, 0, KMinHeapGrowBy, KSgMaxLocalChunkSize, KSgLocalChunkAlignment, ETrue);

	__ASSERT_DEBUG(heap, Panic(ESgPanicResourceImplGeneral));

	XSgDriver* driver = static_cast<XSgDriver*>(heap->Alloc(sizeof(XSgDriver)));

	__ASSERT_DEBUG(driver, Panic(ESgPanicResourceImplGeneral));

	new(driver) XSgDriver(heap);

	err = driver->Construct();

	if (err != KErrNone)

		{

		driver->Delete();

		gPls.iMutex.Signal();

		return err;

		}

	gPls.iOpenCount = 1;

	iImpl = gPls.iDriver = driver;

	gPls.iMutex.Signal();

	return KErrNone;

	}

EXPORT_C void RSgDriver::Close()

	{

	if (iImpl)

		{

		__ASSERT_DEBUG(gPls.iError == KErrNone, Panic(ESgPanicResourceImplGeneral));

		gPls.iMutex.Wait();

		__ASSERT_DEBUG(gPls.iOpenCount > 0, Panic(ESgPanicResourceImplGeneral));

		if (--gPls.iOpenCount == 0)

			{

			gPls.iDriver->Delete();

			gPls.iDriver = NULL;

			}

		iImpl = NULL;

		gPls.iMutex.Signal();

		}

	}

EXPORT_C TInt RSgDriver::GetInterface(TUid aInterfaceUid, TAny*& aInterfacePtr) const

	{

	aInterfacePtr = NULL;

	if (!iImpl)

		{

		return KErrBadHandle;

		}

	return static_cast<XSgDriver*>(iImpl)->GetInterface(aInterfaceUid, aInterfacePtr);

	}

EXPORT_C TVersion RSgDriver::Version()

	{

	return TVersion(1, 1, 1);

	}

_LIT(KSgResourceImplPanicCategory, "SGRES-IMPL");

void Panic(TSgResourceImplPanicReason aReason)

	{

	User::Panic(KSgResourceImplPanicCategory, aReason);

	}

#ifdef SYMBIAN_GRAPHICS_USE_GPU

const TUint32 KSgResourceAttributes = 0;

#else

const TUint32 KSgResourceAttributes = ESgResourceAttrCpuCached;

#endif

LOCAL_C TInt SgMinDataStride(TInt aWidthInPixels, TInt aPixelFormat)

	{

	switch (aPixelFormat)

		{

	case ESgPixelFormatA_8:

		return aWidthInPixels;

	case ESgPixelFormatRGB_565:

		return aWidthInPixels << 1;

	case ESgPixelFormatXRGB_8888:

	case ESgPixelFormatARGB_8888:

	case ESgPixelFormatARGB_8888_PRE:

		return aWidthInPixels << 2;

	default:

#ifdef _DEBUG

		Panic(ESgPanicResourceImplGeneral);

#endif

		return 0;

		}

	}

LOCAL_C TInt SgAlignedDataStride(TInt aWidthInPixels, TInt aPixelFormat)

	{

#if defined(SYMBIAN_GRAPHICS_USE_MBX)

	// MBX requires 2^n stride

	for (TInt width = 8; width & KMaxTInt; width <<= 1)

		{

		if (width >= aWidthInPixels)

			{

			aWidthInPixels = width;

			break;

			}

		}

#elif defined(SYMBIAN_GRAPHICS_USE_SGX)

	// SGX requires 32-pixel alignment

	aWidthInPixels = (aWidthInPixels + 31) & ~31;

#endif

	return Align4(SgMinDataStride(aWidthInPixels, aPixelFormat));

	}

XSgDriverPls::XSgDriverPls()

	{

	iError = iMutex.CreateLocal();

	iOpenCount = 0;

	iDriver = NULL;

	}

XSgDriver::XSgDriver(RHeap* aHeap)

	: iHeap(aHeap), iHasOpenVg(EFalse), iHasOpenGles(EFalse), iHasOpenGles2(EFalse)

	{

	}

XSgDriver::~XSgDriver()

	{

	iMutex.Close();

	iDevice.Close();

	__ASSERT_DEBUG(iImagesByAddress.Count() == 0, Panic(ESgPanicUnclosedResources));

	__ASSERT_DEBUG(iImagesById.Count() == 0, Panic(ESgPanicUnclosedResources));

	}

TInt XSgDriver::Construct()

	{

	TInt err = iMutex.CreateLocal();

	if (err != KErrNone)

		{

		return err;

		}

	err = User::LoadLogicalDevice(KSgDeviceName);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		return err;

		}

	err = iDevice.Connect();

	if (err != KErrNone)

		{

		return err;

		}

	_LIT(KLibOpenVg, "libOpenVG.dll");

	_LIT(KLibOpenGles, "libGLESv1_CM.dll");

	_LIT(KLibOpenGles2, "libGLESv2.dll");

	RLibrary lib;

	if (lib.Load(KLibOpenVg) == KErrNone)

		{

		lib.Close();

		iHasOpenVg = ETrue;

		}

	if (lib.Load(KLibOpenGles) == KErrNone)

		{

		lib.Close();

		iHasOpenGles = ETrue;

		}

	if (lib.Load(KLibOpenGles2) == KErrNone)

		{

		lib.Close();

		iHasOpenGles2 = ETrue;

		}

	return KErrNone;

	}

void XSgDriver::Delete()

	{

	RHeap* heap = iHeap;

	this->~XSgDriver();

	heap->Free(this);

	__ASSERT_DEBUG(heap->Count() == 0, Panic(ESgPanicUnclosedResources));

	heap->Close();

	}

TInt XSgDriver::CreateImage(const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride, const TSgAttributeArrayBase* aAttributes, TAny*& aResult)

	{

	TInt err = CheckImageInfo(aInfo);

	if (err != KErrNone)

		{

		return err;

		}

	TInt minDataStride = SgMinDataStride(aInfo.iSizeInPixels.iWidth, aInfo.iPixelFormat);

	if (aDataAddress && Abs(aDataStride) < minDataStride)

		{

		return KErrArgument;

		}

	if (aAttributes)

		{

		return KErrNotSupported;

		}

	TUint32 attribs = KSgResourceAttributes | MatchingEglConfigUsage(aInfo.iUsage);

	TPckgBuf<TSgImageMetaData> metaDataPckg;

	metaDataPckg().iSizeInPixels = aInfo.iSizeInPixels;

	metaDataPckg().iPixelFormat = aInfo.iPixelFormat;

	TInt dataStride = SgAlignedDataStride(aInfo.iSizeInPixels.iWidth, aInfo.iPixelFormat);

	TInt dataSize = dataStride * aInfo.iSizeInPixels.iHeight;

	TSgDrawableId id;

	err = iDevice.CreateResource(attribs, metaDataPckg, dataSize, id.iId);

	if (err != KErrNone)

		{

		return err;

		}

	iMutex.Wait();

	XSgImage* imageImpl = static_cast<XSgImage*>(iHeap->Alloc(sizeof(XSgImage)));

	if (!imageImpl)

		{

		(void)iDevice.CloseResource(id.iId);

		iMutex.Signal();

		return KErrNoMemory;

		}

	new(imageImpl) XSgImage(id, attribs, metaDataPckg(), iDevice.ResourceDataAddress(id.iId), dataStride);

	RHeap* prevHeap = User::SwitchHeap(iHeap);

	err = iImagesByAddress.InsertInAddressOrder(imageImpl);

	if (err == KErrNone)

		{

		err = iImagesById.InsertInOrder(imageImpl, XSgImage::Compare);

		if (err != KErrNone)

			{

			iImagesByAddress.Remove(iImagesByAddress.FindInAddressOrder(imageImpl));

			iImagesByAddress.GranularCompress();

			}

		}

	User::SwitchHeap(prevHeap);

	if (err == KErrNone)

		{

		if (aDataAddress)

			{

			const TAny* src = aDataStride > 0 ? aDataAddress : PtrAdd(aDataAddress, -aDataStride * (aInfo.iSizeInPixels.iHeight - 1));

			TAny* trg = imageImpl->DataAddress();

			for (TInt y = 0; y < aInfo.iSizeInPixels.iHeight; ++y)

				{

				Mem::Copy(trg, src, minDataStride);

				src = PtrAdd(src, aDataStride);

				trg = PtrAdd(trg, dataStride);

				}

			}

		aResult = imageImpl;

		}

	else

		{

		(void)iDevice.CloseResource(id.iId);

		iHeap->Free(imageImpl);

		}

	iMutex.Signal();

	return err;

	}

TInt XSgDriver::CreateImage(const TSgImageInfo& aInfo, const XSgImage* aImageImpl, const TSgAttributeArrayBase* aAttributes, TAny*& aResult)

	{

	if (!aImageImpl)

		{

		return KErrArgument;

		}

	__ASSERT_ALWAYS(CheckImage(aImageImpl), Panic(ESgPanicBadDrawableHandle));

	TSgImageInfo info;

	aImageImpl->GetInfo(info);

	if (aInfo.iSizeInPixels != info.iSizeInPixels || aInfo.iPixelFormat != info.iPixelFormat)

		{

		return KErrNotSupported;

		}

	return CreateImage(aInfo, aImageImpl->DataAddress(), aImageImpl->DataStride(), aAttributes, aResult);

	}

TInt XSgDriver::FindAndOpenImage(TSgDrawableId aId, const TSgAttributeArrayBase* aAttributes, TAny*& aResult)

	{

	if (aId == KSgNullDrawableId)

		{

		return KErrArgument;

		}

	if (aAttributes)

		{

		return KErrNotSupported;

		}

	TInt err;

	iMutex.Wait();

	TInt indexById = iImagesById.FindInOrder(aId, XSgImage::Compare);

	if (indexById >= 0)

		{

		XSgImage* imageImpl = iImagesById[indexById];

		err = imageImpl->Open();

		if (err == KErrNone)

			{

			aResult = imageImpl;

			}

		}

	else

		{

		err = iDevice.OpenResource(aId.iId);

		if (err != KErrNone)

			{

			iMutex.Signal();

			return err;

			}

		TPckgBuf<TSgImageMetaData> metaDataPckg;

		err = iDevice.GetResourceMetaData(aId.iId, metaDataPckg);

		if (metaDataPckg.Size() != sizeof(TSgImageMetaData))

			{

			err = KErrGeneral;

			}

		TUint32 attribs;

		if (err == KErrNone)

			{

			attribs = iDevice.ResourceAttributes(aId.iId);

			TSgImageInfo info(metaDataPckg().iSizeInPixels, metaDataPckg().iPixelFormat, attribs & KSgUsageBitMask);

			if (CheckImageInfo(info) != KErrNone)

				{

				err = KErrGeneral;

				}

			}

		TInt dataStride;

		if (err == KErrNone)

			{

			dataStride = SgAlignedDataStride(metaDataPckg().iSizeInPixels.iWidth, metaDataPckg().iPixelFormat);

			if (iDevice.ResourceDataSize(aId.iId) != dataStride * metaDataPckg().iSizeInPixels.iHeight)

				{

				err = KErrGeneral;

				}

			}

		if (err != KErrNone)

			{

			(void)iDevice.CloseResource(aId.iId);

			iMutex.Signal();

			return err;

			}

		XSgImage* imageImpl = static_cast<XSgImage*>(iHeap->Alloc(sizeof(XSgImage)));

		if (!imageImpl)

			{

			(void)iDevice.CloseResource(aId.iId);

			iMutex.Signal();

			return KErrNoMemory;

			}

		new(imageImpl) XSgImage(aId, attribs, metaDataPckg(), iDevice.ResourceDataAddress(aId.iId), dataStride);

		RHeap* prevHeap = User::SwitchHeap(iHeap);

		err = iImagesByAddress.InsertInAddressOrder(imageImpl);

		if (err == KErrNone)

			{

			err = iImagesById.InsertInOrder(imageImpl, XSgImage::Compare);

			if (err != KErrNone)

				{

				iImagesByAddress.Remove(iImagesByAddress.FindInAddressOrder(imageImpl));

				iImagesByAddress.GranularCompress();

				}

			}

		User::SwitchHeap(prevHeap);

		if (err == KErrNone)

			{

			aResult = imageImpl;

			}

		else

			{

			(void)iDevice.CloseResource(aId.iId);

			iHeap->Free(imageImpl);

			}

		}

	iMutex.Signal();

	return err;

	}

void XSgDriver::DeleteImage(XSgImage* aImageImpl)

	{

	iMutex.Wait();

	TInt indexByAddress = iImagesByAddress.FindInAddressOrder(aImageImpl);

	TInt indexById = iImagesById.FindInOrder(aImageImpl, XSgImage::Compare);

	__ASSERT_DEBUG(indexByAddress >= 0 && indexById >= 0, Panic(ESgPanicBadImagePointer));

	RHeap* prevHeap = User::SwitchHeap(iHeap);

	iImagesByAddress.Remove(indexByAddress);

	iImagesById.Remove(indexById);

	iImagesByAddress.GranularCompress();

	iImagesById.GranularCompress();

	User::SwitchHeap(prevHeap);

	(void)iDevice.CloseResource(aImageImpl->Id().iId);

	aImageImpl->~XSgImage();

	iHeap->Free(aImageImpl);

	iMutex.Signal();

	}

TUint32 XSgDriver::MatchingEglConfigUsage(TUint32 aUsage) const

	{

	if (aUsage & KSgUsageAllSurfaceTypes)

		{

		if (iHasOpenVg)

			{

			aUsage |= ESgUsageBitOpenVgSurface;

			}

		if (iHasOpenGles)

			{

			aUsage |= ESgUsageBitOpenGlesSurface;

			}

		if (iHasOpenGles2)

			{

			aUsage |= ESgUsageBitOpenGles2Surface;

			}

		}

	return aUsage;

	}

TInt XSgDriver::CheckImageInfo(const TSgImageInfo& aInfo) const

	{

	if (aInfo.iSizeInPixels.iWidth <= 0 || aInfo.iSizeInPixels.iHeight <= 0

		|| aInfo.iPixelFormat == EUidPixelFormatUnknown || aInfo.iUsage == 0)

		{

		return KErrArgument;

		}

	if (aInfo.iSizeInPixels.iWidth > KMaxTInt16 / 2 || aInfo.iSizeInPixels.iHeight > KMaxTInt16 / 2)

		{

		return KErrTooBig;

		}

	if (aInfo.iUsage & ~KSgUsageAll)

		{

		return KErrNotSupported;

		}

	if ((aInfo.iUsage & (ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface)) && !iHasOpenVg

		|| (aInfo.iUsage & (ESgUsageBitOpenGlesTexture2D | ESgUsageBitOpenGlesSurface)) && !iHasOpenGles

		|| (aInfo.iUsage & (ESgUsageBitOpenGles2Texture2D | ESgUsageBitOpenGles2Surface)) && !iHasOpenGles2)

		{

		return KErrNotSupported;

		}

	switch (aInfo.iPixelFormat)

		{

	case ESgPixelFormatA_8:

		if (aInfo.iUsage & KSgUsageAllSurfaceTypes)

			{

			return KErrNotSupported;

			}

		// coverity[fallthrough]

	case ESgPixelFormatRGB_565:

	case ESgPixelFormatXRGB_8888:

	case ESgPixelFormatARGB_8888:

	case ESgPixelFormatARGB_8888_PRE:

		return KErrNone;

	default:

		return KErrNotSupported;

		}

	}

TBool XSgDriver::CheckImage(const TAny* aImageImpl) const

	{

	iMutex.Wait();

	TInt indexByAddress = iImagesByAddress.FindInAddressOrder(static_cast<const XSgImage*>(aImageImpl));

	iMutex.Signal();

	return indexByAddress >= 0;

	}

TInt XSgDriver::GetInterface(TUid aInterfaceUid, TAny*& aInterfacePtr)

	{

	if (aInterfaceUid == KNullUid)

		{

		return KErrArgument;

		}

	if (aInterfaceUid.iUid == MSgDriver_Profiling::EInterfaceUid)

		{

		aInterfacePtr = static_cast<MSgDriver_Profiling*>(this);

		return KErrNone;

		}

#ifdef _DEBUG

	if (aInterfaceUid.iUid == MSgDriver_Test::EInterfaceUid)

		{

		aInterfacePtr = static_cast<MSgDriver_Test*>(this);

		return KErrNone;

		}

#endif

	return KErrExtensionNotSupported;

	}

TInt XSgDriver::LocalResourceCount() const

	{

	TInt count = 0;

	iMutex.Wait();

	TInt n = iImagesByAddress.Count();

	for (TInt i = 0; i < n; ++i)

		{

		count += iImagesByAddress[i]->RefCount();

		}

	iMutex.Signal();

	return count;

	}

TInt XSgDriver::GlobalResourceCount() const

	{

	return iDevice.GlobalResourceCount();

	}

TInt XSgDriver::LocalGraphicsMemoryUsed() const

	{

	return iDevice.LocalGraphicsMemoryUsed();

	}