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

	}