// 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 "sgimagecollectionimpl.h"

 #include "sgimageimpl.h"

 TInt XSgImageCollectionImpl::New(XSgImageCollectionImpl*& aPtr, XSgDriverImpl& aDriverImpl,

                                  const TSgImageInfo& aInfo, TInt aImageCount, TBool aIsCached,

                                  TInt aStride, TInt aOffsetToFirstBuffer, TInt aOffsetBetweenBuffers,

                                  TInt aMetaDataIndex, const XSgImageCollectionImpl* aCollection)

 	{

 	aPtr = static_cast<XSgImageCollectionImpl*>(aDriverImpl.Alloc(sizeof(XSgImageCollectionImpl)));

 	if (!aPtr)

 		{

 		return KErrNoMemory;

 		}

 	new(aPtr) XSgImageCollectionImpl(aDriverImpl);

 	TInt err = aPtr->Construct(aInfo, aImageCount, aIsCached, aStride, aOffsetToFirstBuffer, aOffsetBetweenBuffers, aMetaDataIndex, aCollection);

 	if (err != KErrNone)

 		{

 		aPtr->Delete();

 		aPtr = NULL;

 		}

 	return err;

 	}

 TInt XSgImageCollectionImpl::Construct(const TSgImageInfo& aInfo, TInt aImageCount, TBool aIsCached,

                                        TInt aStride, TInt aOffsetToFirstBuffer, TInt aOffsetBetweenBuffers,

                                        TInt aMetaDataIndex, const XSgImageCollectionImpl* aCollection)

 	{

 	TInt maxNumberOfHints;

 	TInt err;

 	err=iDriverImpl.GetSurfaceManagerAttrib(RSurfaceManager::EMaxNumberOfHints,maxNumberOfHints);

 	if (err != KErrNone)

 	    {

 	    return err;

 	    } 

 	if (aInfo.iUserAttributeCount > maxNumberOfHints)

 		{

 		return KErrOverflow;

 		}

 	RSurfaceManager::THintPair* hints = new RSurfaceManager::THintPair[aInfo.iUserAttributeCount];

 	if(!hints)

 		{

 		return KErrNoMemory;

 		}

 	RSurfaceManager::TSurfaceCreationAttributesBuf reqs;

 	reqs().iSize = aInfo.iSizeInPixels;

 	reqs().iBuffers = aImageCount;

 	reqs().iPixelFormat = aInfo.iPixelFormat;

 	reqs().iStride = aStride;

 	reqs().iOffsetToFirstBuffer = aOffsetToFirstBuffer;

 	reqs().iAlignment = 4;

 	reqs().iContiguous = EFalse;

 	reqs().iCacheAttrib = aIsCached ? RSurfaceManager::ECached : RSurfaceManager::ENotCached;

 	reqs().iMappable = ETrue;

 	reqs().iOffsetBetweenBuffers = aOffsetBetweenBuffers;

 	reqs().iSurfaceHints = hints;

 	reqs().iHintCount = aInfo.iUserAttributeCount;

 	for (TInt i = 0; i < aInfo.iUserAttributeCount; ++i)

 		{

 		reqs().iSurfaceHints[i].iKey = aInfo.iUserAttributes[i].iUid;

 		reqs().iSurfaceHints[i].iValue = aInfo.iUserAttributes[i].iValue;

 		reqs().iSurfaceHints[i].iMutable = EFalse;

 		}	

 	TSurfaceId surfaceId;

 	if (!aCollection)

 		{

 		err = iDriverImpl.CreateSurface(reqs, surfaceId);

 		}

 	else

 		{

 		err = iDriverImpl.CreateSurface(reqs, surfaceId, aCollection->iDataChunk);

 		}

 	delete[] hints;

 	hints = NULL;

 	reqs().iSurfaceHints = NULL;

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	iSurfaceId = surfaceId;

 	iCount = aImageCount;

 	RChunk chunk;

 	if (!aCollection)

 		{

 		err = iDriverImpl.MapSurface(surfaceId, chunk);

 		}

 	else

 		{

 		chunk = aCollection->iDataChunk;

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

 		}

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	iDataChunk = chunk;

 	iMetaDataIndex = aMetaDataIndex;

 	new(chunk.Base() + aMetaDataIndex * sizeof(TSgImageMetaData)) TSgImageMetaData(aInfo, iDriverImpl.PixelFormatTable(), aIsCached);

 	return KErrNone;

 	}

 XSgImageCollectionImpl::~XSgImageCollectionImpl()

 	{

 	if (!iSurfaceId.IsNull())

 		{

 		iDriverImpl.CloseSurface(iSurfaceId);

 		iDataChunk.Close();

 		}

 	}

 void XSgImageCollectionImpl::Close()

 	{

 	XSgDriverImpl& driverImpl = iDriverImpl;

 	driverImpl.Wait();

 	if (DecRefCount() == 0)

 		{

 		driverImpl.DeleteImageCollection(this);

 		}

 	driverImpl.Signal();

 	}

 const TSurfaceId& XSgImageCollectionImpl::SurfaceId() const

 	{

 	return iSurfaceId;

 	}

 TInt XSgImageCollectionImpl::GetInfo(TSgImageInfo& aInfo) const

 	{

 	reinterpret_cast<TSgImageMetaData*>(iDataChunk.Base() + iMetaDataIndex * sizeof(TSgImageMetaData))->GetInfo(aInfo);

 	for (TInt i = 0; i < aInfo.iUserAttributeCount; ++i)

 		{

 		RSurfaceManager::THintPair hint;

 		hint.iKey = aInfo.iUserAttributes[i].iUid;

 		TInt err = iDriverImpl.GetSurfaceHint(iSurfaceId, hint);

 		if (err != KErrNone)

 			{

 			return err;

 			}

 		aInfo.iUserAttributes[i].iValue = hint.iValue;

 		}

 	return KErrNone;

 	}

 TInt XSgImageCollectionImpl::Count() const

 	{

 	return iCount;

 	}

 TInt XSgImageCollectionImpl::OpenImage(TInt aIndex, MSgDrawableAdapter*& aResult)

 	{

 	if (aIndex < 0 || aIndex >= iCount)

 		{

 		return KErrArgument;

 		}

 	union

 		{

 		TSgDrawableId id;

 		TSgImageId_SurfaceManager id_SurfaceManager;

 		};

 	id_SurfaceManager.iSurfaceId = iSurfaceId;

 	id_SurfaceManager.iBufferIndex = aIndex;

 	id_SurfaceManager.iMetaDataIndex = iMetaDataIndex;

 	id_SurfaceManager.iFlags = 0;

 	iDriverImpl.Wait();

 	TInt err = iDriverImpl.OpenImage(id, KSgDefaultOpenMode, aResult);

 	iDriverImpl.Signal();

 	return err;

 	}