// 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 <e32math.h>

#include "sgdriverimpl.h"

#include "sgimageimpl.h"

#include "sgimagecollectionimpl.h"

TInt SgAlignedDataStride(TInt aWidthInPixels, TUidPixelFormat 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 a 32 pixel alignment. 

	aWidthInPixels = (aWidthInPixels + 31) & ~31;

#endif

	return Align4(SgMinDataStride(aWidthInPixels, aPixelFormat));

	}

TInt SgOffsetToFirstBuffer(TInt aMetaDataSize)

	{

#if defined(SYMBIAN_GRAPHICS_USE_MBX) || defined(SYMBIAN_GRAPHICS_USE_SGX)

	return (aMetaDataSize + 127) & ~127;

#else

	return Align4(aMetaDataSize);

#endif

	}

TInt SgOffsetBetweenBuffers(TInt aDataStride, TInt aScanLineCount)

	{

#if defined(SYMBIAN_GRAPHICS_USE_MBX)

	for (TInt count = 16; count & KMaxTInt; count <<= 1)

		{

		if (count >= aScanLineCount)

			{

			aScanLineCount = count;

			break;

			}

		}

#endif

	return aDataStride * aScanLineCount;

	}

TBool SgIsValidImageInfo(const TSgImageInfo& aInfo)

	{

	return aInfo.iSizeInPixels.iWidth > 0 && aInfo.iSizeInPixels.iHeight > 0

		&& (aInfo.iUsage & ESgUsageScreenSource ? aInfo.iScreenId >= KSgScreenIdMain : aInfo.iScreenId >= KSgScreenIdAny)

		&& (aInfo.iUserAttributes ? aInfo.iUserAttributeCount > 0 : aInfo.iUserAttributeCount == 0);

	}

TBool SgIsMutableImage(const TSgImageInfo& aInfo)

	{

	return (aInfo.iCpuAccess & ESgCpuAccessWritable) || (aInfo.iUsage & KSgUsageAllTargets);

	}

TBool SgIsCachedImage(const TSgImageInfo& aInfo)

	{

#ifdef SYMBIAN_GRAPHICS_USE_GPU

#ifdef SYMBIAN_GRAPHICS_USE_CACHE

	return aInfo.iCpuAccess != ESgCpuAccessNone;

#else

	(void)aInfo;

	return EFalse;

#endif

#else

	(void)aInfo;

	return ETrue;

#endif

	}

// TSgPixelFormatTableEntry

TBool TSgPixelFormatTableEntry::IsMatch(const TSgImageInfo& aInfo) const

	{

	return iPixelFormat == aInfo.iPixelFormat

		&& !(~iUsage & aInfo.iUsage)

		&& !(~iCpuAccess & aInfo.iCpuAccess)

		&& (iScreenId == KSgScreenIdAny || iScreenId == aInfo.iScreenId);

	}

TBool TSgPixelFormatTableEntry::IsMatchIgnoringPixelFormat(const TSgImageInfo& aInfo) const

	{

	return !(~iUsage & aInfo.iUsage)

		&& !(~iCpuAccess & aInfo.iCpuAccess)

		&& (iScreenId == KSgScreenIdAny || iScreenId == aInfo.iScreenId);

	}

TBool TSgPixelFormatTableEntry::IsMatchIgnoringUsage(const TSgImageInfo& aInfo) const

	{

	return iPixelFormat == aInfo.iPixelFormat

		&& !(~iCpuAccess & aInfo.iCpuAccess)

		&& (iScreenId == KSgScreenIdAny || iScreenId == aInfo.iScreenId);

	}

// XSgBase

XSgBase::~XSgBase()

	{

	__ASSERT_DEBUG(iDriverImpl.IsMutexHeld(), Panic(ESgPanicMutexNotHeld));

	__ASSERT_DEBUG(iRefCount == 0, Panic(ESgPanicBadReferenceCount));

	}

void XSgBase::Delete()

	{

	XSgDriverImpl& driverImpl = iDriverImpl;

	this->~XSgBase();

	driverImpl.Free(this);

	}

// XSgDriverImpl

TInt XSgDriverImpl::Construct()

	{

	TInt err = iMutex.CreateLocal();

	if (err != KErrNone)

		{

		return err;

		}

	err = iSurfaceManager.Open();

	if (err != KErrNone)

		{

		return err;

		}

	return ConstructPixelFormatTable();

	}

XSgDriverImpl::~XSgDriverImpl()

	{

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

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

	iMutex.Close();

	iSurfaceManager.Close();

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

	iPixelFormatTable.Close();

	iLastPixelFormats.Close();

	User::SwitchHeap(prevHeap);

	}

void XSgDriverImpl::Delete()

	{

	RHeap* heap = iHeap;

	this->~XSgDriverImpl();

	heap->Free(this);

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

	heap->Close();

	}

TInt XSgDriverImpl::MapSurface(const TSurfaceId& aSurfaceId, RChunk& aChunk)

	{

	RChunk chunk;

	TInt err = iSurfaceManager.MapSurface(aSurfaceId, chunk);

	if (err != KErrNone)

		{

		return err;

		}

	aChunk = chunk;

	err = aChunk.Duplicate(RThread()); // Get a process-wide handle

	chunk.Close();

	return err;

	}

TArray<TSgPixelFormatTableEntry> XSgDriverImpl::PixelFormatTable() const

	{

	return iPixelFormatTable.Array();

	}

TInt XSgDriverImpl::CanCreateImage(const TSgImageInfo& aInfo) const

	{

	__ASSERT_DEBUG(SgIsValidImageInfo(aInfo), Panic(ESgPanicBadImageInfo));

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

		{

		return KErrTooBig;

		}

	TArray<TSgPixelFormatTableEntry> pixelFormatTable = PixelFormatTable();

	TInt n = pixelFormatTable.Count();

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

		{

		if (pixelFormatTable[i].IsMatch(aInfo))

			{

			return SgMinDataStride(aInfo.iSizeInPixels.iWidth, aInfo.iPixelFormat) > 0 ? KErrNone : KErrNotSupported;

			}

		}

	return KErrNotSupported;

	}

TInt XSgDriverImpl::GetPixelFormats(const TSgImageInfo& aInfo, TUidPixelFormat* aPixelFormats, TInt& aCount)

	{

	if (!SgIsValidImageInfo(aInfo) || (aPixelFormats && aCount < 0))

		{

		return KErrArgument;

		}

	iMutex.Wait();

	if (aInfo.iSizeInPixels != iLastSizeInPixels

		|| aInfo.iUsage != iLastUsage

		|| aInfo.iCpuAccess != iLastCpuAccess

		|| aInfo.iScreenId != iLastScreenId)

		{

		iLastSizeInPixels = aInfo.iSizeInPixels;

		iLastUsage = aInfo.iUsage;

		iLastCpuAccess = aInfo.iCpuAccess;

		iLastScreenId = aInfo.iScreenId;

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

		iLastPixelFormats.Reset();

		User::SwitchHeap(prevHeap);

		TArray<TSgPixelFormatTableEntry> pixelFormatTable = PixelFormatTable();

		TInt n = pixelFormatTable.Count();

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

			{

			const TSgPixelFormatTableEntry& entry = pixelFormatTable[i];

			if (entry.IsMatchIgnoringPixelFormat(aInfo) && iLastPixelFormats.Find(entry.iPixelFormat) == KErrNotFound)

				{

				User::SwitchHeap(iHeap);

				TInt err = iLastPixelFormats.Append(entry.iPixelFormat);

				User::SwitchHeap(prevHeap);

				if (err != KErrNone)

					{

					iLastSizeInPixels = TSize(0, 0);

					iLastUsage = ESgUsageNone;

					iLastCpuAccess = ESgCpuAccessNone;

					iLastScreenId = KSgScreenIdMain;

					User::SwitchHeap(iHeap);

					iLastPixelFormats.Reset();

					User::SwitchHeap(prevHeap);

					iMutex.Signal();

					return err;

					}

				}

			}

		}

	TInt err = KErrNone;

	if (aPixelFormats)

		{

		TInt n = Min(aCount, iLastPixelFormats.Count());

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

			{

			aPixelFormats[i] = iLastPixelFormats[i];

			}

		if (aCount < iLastPixelFormats.Count())

			{

			err = KErrOverflow;

			}

		}

	aCount = iLastPixelFormats.Count();

	iMutex.Signal();

	return err;

	}

TInt XSgDriverImpl::CreateImage(const TSgImageInfo& aInfo, const TAny* aDataAddress, TInt aDataStride, MSgDrawableAdapter*& aResult)

	{

	if (!SgIsValidImageInfo(aInfo))

		{

		return KErrArgument;

		}

	if (aResult)

		{

		return KErrInUse;

		}

	if (!aDataAddress && !SgIsMutableImage(aInfo))

		{

		return KErrNoInitializationData;

		}

	TInt err = CanCreateImage(aInfo);

	if (err != KErrNone)

		{

		return err;

		}

#if !defined(SYMBIAN_GRAPHICS_USE_GPU) && !defined(__WINS__)

	if (!aInfo.iShareable)

		{

		iMutex.Wait();

		union

			{

			TSgDrawableId id;

			TSgImageId_SwLocal id_SwLocal;

			};

		do

			{

			id_SwLocal.iProcessId = RProcess().Id();

			id_SwLocal.iRandom[0] = Math::Random();

			id_SwLocal.iRandom[1] = Math::Random();

			id_SwLocal.iMinusOne = KErrNotFound;

			id_SwLocal.iFlags = 0;

			}

		while (iImages.FindInOrder(id, XSgImageImplBase::Compare) != KErrNotFound);

		XSgImageImpl_SwLocal* impl;

		err = XSgImageImpl_SwLocal::New(impl, *this, id, aInfo, aDataAddress, aDataStride);

		if (err != KErrNone)

			{

			iMutex.Signal();

			return err;

			}

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

		err = iImages.InsertInOrder(impl, XSgImageImplBase::Compare);

		User::SwitchHeap(prevHeap);

		if (err != KErrNone)

			{

			impl->Delete();

			iMutex.Signal();

			return err;

			}

		impl->IncRefCount();

		aResult = impl;

		iMutex.Signal();

		return KErrNone;

		}

#endif

	iMutex.Wait();

	XSgImageImpl_SurfaceManager* impl;

	err = XSgImageImpl_SurfaceManager::New(impl, *this, aInfo, SgIsCachedImage(aInfo), aDataAddress, aDataStride);

	if (err != KErrNone)

		{

		iMutex.Signal();

		return err;

		}

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

	err = iImages.InsertInOrder(impl, XSgImageImplBase::Compare);

	User::SwitchHeap(prevHeap);

	if (err != KErrNone)

		{

		impl->Delete();

		iMutex.Signal();

		return err;

		}

	impl->IncRefCount();

	aResult = impl;

	iMutex.Signal();

	return KErrNone;

	}

TInt XSgDriverImpl::CreateImage(const TSgImageInfo& aInfo, MSgImageAdapter* aImage, MSgDrawableAdapter*& aResult)

	{

	if (!aImage)

		{

		return KErrArgument;

		}

	__ASSERT_DEBUG(CheckImage(*aImage), Panic(ESgPanicBadImageHandle));

	XSgImageImplBase& impl = static_cast<XSgImageImplBase&>(*aImage);

	if (aInfo.iSizeInPixels != impl.MetaData().iSizeInPixels

		|| aInfo.iPixelFormat != impl.MetaData().iPixelFormat)

		{

		return KErrNotSupported;

		}

	TInt err = impl.BeginDataAccess(ESgCpuAccessReadOnly);

	if (err != KErrNone)

		{

		return err;

		}

	err = CreateImage(aInfo, impl.DataAddress(), impl.DataStride(), aResult);

	impl.EndDataAccess();

	return err;

	}

TInt XSgDriverImpl::CreateImageCollection(const TSgImageInfo& aInfo, TInt aImageCount, MSgImageCollectionAdapter*& aResult)

	{

	if (!SgIsValidImageInfo(aInfo) || aImageCount <= 0)

		{

		return KErrArgument;

		}

	if (aResult)

		{

		return KErrInUse;

		}

	if (!SgIsMutableImage(aInfo))

		{

		return KErrNotSupported;

		}

	TInt err = CanCreateImage(aInfo);

	if (err != KErrNone)

		{

		return err;

		}

	iMutex.Wait();

	XSgImageCollectionImpl* impl;

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

	const TInt offsetToFirst = SgOffsetToFirstBuffer(sizeof(TSgImageMetaData));

	const TInt offsetBetween = SgOffsetBetweenBuffers(stride, aInfo.iSizeInPixels.iHeight);

	err = XSgImageCollectionImpl::New(impl, *this, aInfo, aImageCount, SgIsCachedImage(aInfo), stride, offsetToFirst, offsetBetween);

	if (err != KErrNone)

		{

		iMutex.Signal();

		return err;

		}

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

	err = iImageCollections.InsertInAddressOrder(impl);

	User::SwitchHeap(prevHeap);

	if (err != KErrNone)

		{

		impl->Delete();

		iMutex.Signal();

		return err;

		}

	impl->IncRefCount();

	aResult = impl;

	iMutex.Signal();

	return KErrNone;

	}

TInt XSgDriverImpl::GetBufferOffset(const TSurfaceId& aSurfaceID, TInt aBuffer, TInt &aOffset)

	{

	return iSurfaceManager.GetBufferOffset(aSurfaceID,aBuffer,aOffset);

	}

TInt XSgDriverImpl::GetSurfaceManagerAttrib(RSurfaceManager::TSurfaceManagerAttrib aAttrib, TInt& aValue)

	{

	return iSurfaceManager.GetSurfaceManagerAttrib(aAttrib,aValue);

	}

TInt XSgDriverImpl::CreateImageCollections(const TSgImageInfo aInfos[], TInt aImageCount,

                                           MSgImageCollectionAdapter* aCollections[], TInt aCollectionCount)

	{

	if (aImageCount <= 0 || aCollectionCount <= 0)

		{

		return KErrArgument;

		}

	TBool isCached = EFalse;

	TInt offsetToFirstBuffer = SgOffsetToFirstBuffer(aCollectionCount * sizeof(TSgImageMetaData));

	TInt maxOffsetBetweenBuffers = 0;

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

		{

		const TSgImageInfo& info = aInfos[i];

		if (!SgIsValidImageInfo(info))

			{

			return KErrArgument;

			}

		if (aCollections[i])

			{

			return KErrInUse;

			}

		if (!SgIsMutableImage(info))

			{

			return KErrNotSupported;

			}

		TInt err = CanCreateImage(info);

		if (err != KErrNone)

			{

			return err;

			}

		if (SgIsCachedImage(info))

			{

			isCached = ETrue;

			}

		TInt stride = SgAlignedDataStride(info.iSizeInPixels.iWidth, info.iPixelFormat);

		TInt offsetBetweenBuffers = SgOffsetBetweenBuffers(stride, info.iSizeInPixels.iHeight);

		if (offsetBetweenBuffers > maxOffsetBetweenBuffers)

			{

			maxOffsetBetweenBuffers = offsetBetweenBuffers;

			}

		}

	iMutex.Wait();

	XSgImageCollectionImpl* firstImpl = NULL;

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

		{

		const TInt stride = SgAlignedDataStride(aInfos[i].iSizeInPixels.iWidth, aInfos[i].iPixelFormat);

		XSgImageCollectionImpl* impl;

		TInt err = XSgImageCollectionImpl::New(impl, *this, aInfos[i], aImageCount, isCached,

		                                       stride, offsetToFirstBuffer, maxOffsetBetweenBuffers, i, firstImpl);

		if (err == KErrNone)

			{

			if (i == 0)

				{

				firstImpl = impl;

				RSurfaceManager::TInfoBuf info;

				TSurfaceId surface=impl->SurfaceId();

				err = SurfaceInfo(surface, info);

				if (err == KErrNone)

				    {

				    // get the actual value used for offset to first buffer

				    err = iSurfaceManager.GetBufferOffset(surface, 0, offsetToFirstBuffer);

				    // get the actual value used for offset between buffers

				    if (aImageCount>1)

				    	{

				    	TInt offsetToSecondBuffer;

				    	err = iSurfaceManager.GetBufferOffset(surface, 1, offsetToSecondBuffer);

				    	maxOffsetBetweenBuffers = offsetToSecondBuffer - offsetToFirstBuffer;

				    	}

				    else

				    	{

				    	maxOffsetBetweenBuffers = 0;

				    	}

				    }       

				if (err != KErrNone)

				    {

				    impl->Delete();

				    iMutex.Signal();

				    return err;

				    } 					

				}

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

			err = iImageCollections.InsertInAddressOrder(impl);

			User::SwitchHeap(prevHeap);

			if (err == KErrNone)

				{

				impl->IncRefCount();

				aCollections[i] = impl;

				}

			else

				{

				impl->Delete();

				}

			}

		if (err != KErrNone)

			{

			while (--i >= 0)

				{

				aCollections[i]->Close();

				aCollections[i] = NULL;

				}

			iMutex.Signal();

			return err;

			}

		}

	iMutex.Signal();

	return KErrNone;

	}

TInt XSgDriverImpl::OpenDrawable(const TSgDrawableId& aId, TUint32 aMode, TUid aHandleType, MSgDrawableAdapter*& aResult)

	{

	if (aHandleType == KSgImageTypeUid || aHandleType == KSgDrawableTypeUid)

		{

		return OpenImage(aId, aMode, aResult);

		}

	return KErrNotSupported;

	}

TInt XSgDriverImpl::OpenImage(const TSgDrawableId& aId, TUint32 aMode, MSgDrawableAdapter*& aResult)

	{

	if (aResult)

		{

		return KErrInUse;

		}

	iMutex.Wait();

	TSgDrawableId id = aId;

	id.iId[KSgImageIdFlagsIndex] |= aMode;

	TInt i = iImages.FindInOrder(id, XSgImageImplBase::CompareIgnoringFlags);

	if (i != KErrNotFound)

		{

		XSgImageImplBase* impl;

		TInt j = iImages.FindInOrder(id, XSgImageImplBase::Compare);

		if (j != KErrNotFound)

			{

			impl = iImages[j];

			}

		else

			{

			impl = iImages[i];

#ifndef SYMBIAN_GRAPHICS_USE_GPU

			if (TSgImageId_SwLocal::IsMatch(id))

				{

				XSgImageImpl_SwLocal* impl2;

				TInt err = XSgImageImpl_SwLocal::New(impl2, *static_cast<XSgImageImpl_SwLocal*>(impl), id.iId[KSgImageIdFlagsIndex]);

				if (err != KErrNone)

					{

					iMutex.Signal();

					return err;

					}

				impl = impl2;

				}

			else

#endif

			if (TSgImageId_SurfaceManager::IsMatch(id))

				{

				XSgImageImpl_SurfaceManager* impl2;

				TInt err = XSgImageImpl_SurfaceManager::New(impl2, *static_cast<XSgImageImpl_SurfaceManager*>(impl), id.iId[KSgImageIdFlagsIndex]);

				if (err != KErrNone)

					{

					iMutex.Signal();

					return err;

					}

				impl = impl2;

				}

			else

				{

				iMutex.Signal();

				return KErrNotFound;

				}

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

			TInt err = iImages.InsertInOrder(impl, XSgImageImplBase::Compare);

			User::SwitchHeap(prevHeap);

			if (err != KErrNone)

				{

				impl->Delete();

				iMutex.Signal();

				return err;

				}

			}

		impl->IncRefCount();

		aResult = impl;

		iMutex.Signal();

		return KErrNone;

		}

	TInt err = KErrNotFound;

	if (TSgImageId_SurfaceManager::IsMatch(id))

		{

		XSgImageImpl_SurfaceManager* impl;

		err = XSgImageImpl_SurfaceManager::New(impl, *this, id);

		if (err != KErrNone)

			{

			iMutex.Signal();

			return err;

			}

		if (!impl->MetaData().iShareable && impl->MetaData().iCreatorProcess != RProcess().Id())

			{

			impl->Delete();

			iMutex.Signal();

			return KErrPermissionDenied;

			}

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

		err = iImages.InsertInOrder(impl, XSgImageImplBase::Compare);

		User::SwitchHeap(prevHeap);

		if (err != KErrNone)

			{

			impl->Delete();

			iMutex.Signal();

			return err;

			}

		impl->IncRefCount();

		aResult = impl;

		}

	iMutex.Signal();

	return err;

	}

void XSgDriverImpl::DeleteImage(XSgImageImplBase* aImage)

	{

	__ASSERT_DEBUG(iMutex.IsHeld(), Panic(ESgPanicMutexNotHeld));

	TInt i = iImages.FindInOrder(aImage, XSgImageImplBase::Compare);

	__ASSERT_DEBUG(i != KErrNotFound, Panic(ESgPanicBadImageHandle));

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

	iImages.Remove(i);

	iImages.GranularCompress();

	User::SwitchHeap(prevHeap);

	aImage->Delete();

	}

void XSgDriverImpl::DeleteImageCollection(XSgImageCollectionImpl* aImageCollection)

	{

	__ASSERT_DEBUG(iMutex.IsHeld(), Panic(ESgPanicMutexNotHeld));

	TInt i = iImageCollections.FindInAddressOrder(aImageCollection);

	__ASSERT_DEBUG(i != KErrNotFound, Panic(ESgPanicBadImageCollectionHandle));

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

	iImageCollections.Remove(i);

	iImageCollections.GranularCompress();

	User::SwitchHeap(prevHeap);

	aImageCollection->Delete();

	}

TBool XSgDriverImpl::CheckDrawable(const MSgResourceAdapter& aDrawable) const

	{

	iMutex.Wait();

	TInt i = iImages.Find(&static_cast<const XSgImageImplBase&>(aDrawable));

	iMutex.Signal();

	return i != KErrNotFound;

	}

TBool XSgDriverImpl::CheckImage(const MSgResourceAdapter& aImage) const

	{

	iMutex.Wait();

	TInt i = iImages.Find(&static_cast<const XSgImageImplBase&>(aImage));

	iMutex.Signal();

	return i != KErrNotFound;

	}

TBool XSgDriverImpl::CheckImageCollection(const MSgResourceAdapter& aImageCollection) const

	{

	iMutex.Wait();

	TInt i = iImageCollections.Find(&static_cast<const XSgImageCollectionImpl&>(aImageCollection));

	iMutex.Signal();

	return i != KErrNotFound;

	}

TInt XSgDriverImpl::ResourceCount() const

	{

	iMutex.Wait();

	TInt count = 0;

	for (TInt i = 0; i < iImages.Count(); ++i)

		{

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

		}

	for (TInt i = 0; i < iImageCollections.Count(); ++i)

		{

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

		}

	iMutex.Signal();

	return count;

	}

#ifdef _DEBUG

void XSgDriverImpl::AllocMarkStart()

	{

	iMutex.Wait();

	iHeap->__DbgMarkStart();

	iMutex.Signal();

	}

void XSgDriverImpl::AllocMarkEnd(TInt aCount)

	{

	iMutex.Wait();

	TUint32 badCell = iHeap->__DbgMarkEnd(aCount);

	iMutex.Signal();

	if (badCell != 0)

		{

		_LIT(KPanicCategoryFormat, "SGALLOC:%08x");

		TBuf<0x10> category;

		category.Format(KPanicCategoryFormat, badCell);

		User::Panic(category, 0);

		}

	}

void XSgDriverImpl::SetAllocFail(RAllocator::TAllocFail aType, TInt aRate)

	{

	iMutex.Wait();

	iHeap->__DbgSetAllocFail(aType, aRate);

	iMutex.Signal();

	}

#else

void XSgDriverImpl::AllocMarkStart()

	{

	}

void XSgDriverImpl::AllocMarkEnd(TInt /*aCount*/)

	{

	}

void XSgDriverImpl::SetAllocFail(RAllocator::TAllocFail /*aType*/, TInt /*aRate*/)

	{

	}

#endif

// MSgDriverAdapter::New()

EXPORT_C TInt MSgDriverAdapter::New(MSgDriverAdapter*& aPtr)

	{

	RHeap* heap = UserHeap::ChunkHeap(NULL, 0, KSgMaxLocalChunkSize);

	if (!heap)

		{

		return KErrNoMemory;

		}

	XSgDriverImpl* driverImpl = static_cast<XSgDriverImpl*>(heap->Alloc(sizeof(XSgDriverImpl)));

	if (!driverImpl)

		{

		heap->Close();

		return KErrNoMemory;

		}

	new(driverImpl) XSgDriverImpl(heap);

	TInt err = driverImpl->Construct();

	if (err != KErrNone)

		{

		driverImpl->Delete();

		return err;

		}

	aPtr = driverImpl;

	return KErrNone;

	}