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

//

/**

 * @file

*/

#include <e32std.h>

#include <imageconversion.h>

#include "surfaceutility.h"

#include <BitmapTransforms.h> 

//_LIT(KFileName,"surfacemanager");

CSurfaceUtility::CSurfaceUtility(CSurfaceUtility* aClone/*=NULL*/)

	:	iSurfaces(aClone?&(aClone->iSurfaces):NULL)

	{

	}

CSurfaceUtility* CSurfaceUtility::NewL(CSurfaceUtility* aClone/*=NULL*/)

	{

	CSurfaceUtility* utility = new (ELeave)CSurfaceUtility(aClone);

	CleanupStack::PushL(utility);

	utility->ConstructL();

	CleanupStack::Pop(utility);

	return utility;

	}

void CSurfaceUtility::ConstructL()

	{

	TInt r = iManager.Open();

	if (r != KErrNone)

		{

		LOG(("Surface manager failed to open: %d", r));

		User::Leave(r);

		}

	r = iSurfaceUpdateSession.Connect();

	if (r != KErrNone)

		{

		LOG(("Failed to connect to update server: %d", r));

		User::Leave(r);

		}

	}

CSurfaceUtility::~CSurfaceUtility()

	{

	DestroyAll();

	iSurfaces.Close();

	iManager.Close();

	iSurfaceUpdateSession.Close();

	// the following call is needed because of a bug in CImageDecoder that 

	// leaks heap memory

	REComSession::FinalClose();

	}

TBool CSurfaceUtility::DestroyAll()

	{

	TInt err = 	KErrNone;

	TInt jj = iSurfaces.Count() - 1;

	if (jj<0)

		return EFalse;

	for (; jj >= 0; jj--)

		{

		err = iManager.CloseSurface(iSurfaces[jj]);

		if (err!=KErrNone)

			{

			LOG(("Error closing surface: 0x%X\n", err));

			}

		}

	iSurfaces.Reset();

	return ETrue;

	}

/***************************************

 * The aim of the THeapSurfaceArray is to locally switch in the specified heap for any array operation

 ***************************************/

CSurfaceUtility::RHeapSurfaceArray::RHeapSurfaceArray(RHeapSurfaceArray* aUseExternalArray)

	:	iUseArray(aUseExternalArray?aUseExternalArray->iUseArray:&this->iLocalArray),

	iExternalHeapRef(aUseExternalArray?aUseExternalArray->iExternalHeapRef:User::Heap())

	{

	}

/************************************

 * The following methods have been used by the surfaceutility... some require the heap wrapping, and some don't

 * I actually need three different startegies (count em) for 7 methods...

 * Some methods only read the existing objects, so don't need a heap swap at all

 * Leaving methods have to use PopAndDestroy strategy to restore the heap on leaving or success

 * Non-leaving methods must not call PushL, so directly make SwitchHeap calls!

 ************************************/

// PopAndDestroy method to restore the heap

/*static*/ void	CSurfaceUtility::RHeapSurfaceArray::PopHeap(void* aHeapPtr)

	{

	RHeap* heapPtr=(RHeap*)aHeapPtr;

	User::SwitchHeap(heapPtr);

	}

// Switches and pushes the previous heap so it can be restored with PopAndDestroy

/*static*/ void CSurfaceUtility::RHeapSurfaceArray::SwitchHeapLC(RHeap* aNewHeap)

	{

	CleanupStack::PushL(TCleanupItem(PopHeap,NULL));

	CleanupStack::PushL(TCleanupItem(PopHeap,NULL));

	CleanupStack::PushL(TCleanupItem(PopHeap,NULL));

	CleanupStack::Pop(3);

	RHeap* oldHeap=User::SwitchHeap(aNewHeap);

	delete new char;

	CleanupStack::PushL(TCleanupItem(PopHeap,oldHeap));

	}

TSurfaceId& CSurfaceUtility::RHeapSurfaceArray::operator[](TUint aIndex)

	{

	return iUseArray->operator[](aIndex);

	}

// Close only closes the local array, while Reset resets the active array (may be external)

void CSurfaceUtility::RHeapSurfaceArray::Close()

	{

	RHeap* oldHeap=User::SwitchHeap(&iExternalHeapRef);

	iLocalArray.Close();

	User::SwitchHeap(oldHeap);

	}

TInt CSurfaceUtility::RHeapSurfaceArray::Count() const

	{

	return iUseArray->Count();

	}

// Close only closes the local array, while Reset resets the active array (may be external)

inline void CSurfaceUtility::RHeapSurfaceArray::Reset()

	{

	RHeap* oldHeap=User::SwitchHeap(&iExternalHeapRef);

	iUseArray->Reset();

	User::SwitchHeap(oldHeap);

	}

void CSurfaceUtility::RHeapSurfaceArray::AppendL(const TSurfaceId &anEntry)

	{

	SwitchHeapLC(&iExternalHeapRef);

	iUseArray->AppendL(anEntry);

	CleanupStack::PopAndDestroy();

	}

TInt CSurfaceUtility::RHeapSurfaceArray::Find(const TSurfaceId &anEntry) const

	{

	return iUseArray->Find(anEntry);

	}

void CSurfaceUtility::RHeapSurfaceArray::Remove(TInt anIndex)

	{

	RHeap* oldHeap=User::SwitchHeap(&iExternalHeapRef);

	iUseArray->Remove(anIndex);

	User::SwitchHeap(oldHeap);

	}

/**

Cleanup stack helper object, holding references to both utility and surface, so

that the standard Close() semantics can be used.

*/

class TSurfaceCleanup

	{

public:

	TSurfaceCleanup(CSurfaceUtility& aUtility, TSurfaceId& aSurface)

		: iUtility(aUtility), iSurface(aSurface)

		{}

	void Close()

		{

		// Removes the surface from the list of surfaces to clean up, and closes

		// the surface reference.

		iUtility.DestroySurface(iSurface);

		}

private:

	CSurfaceUtility& iUtility;

	TSurfaceId& iSurface;

	};

/**

Read the given image file into a new surface.

@param aFileName The name of the image file.

@param aSurface Filled with the surface ID for the surface containing the pixels.

*/

void CSurfaceUtility::CreateSurfaceFromFileL(const TDesC& aFileName, TSurfaceId& aSurface)

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	CImageDecoder* decoder = CImageDecoder::FileNewL(fs, aFileName, CImageDecoder::EOptionAlwaysThread);

	CleanupStack::PushL(decoder);

	const TFrameInfo& info = decoder->FrameInfo();

	TSize size = info.iOverallSizeInPixels;

	TInt stride = size.iWidth << 2;		// Default to four bytes per pixel

	TDisplayMode bmpFormat = info.iFrameDisplayMode;

	TUidPixelFormat pixelFormat = EUidPixelFormatUnknown;

	switch (bmpFormat)

		{

		case EGray2:

		case EGray4:

		case EGray16:

		case EGray256:

		case EColor16:

		case EColor256:

		case EColor16M:

		case EColor16MU:

			{

			bmpFormat = EColor16MU;

			pixelFormat = EUidPixelFormatXRGB_8888;

			break;

			}

		case EColor4K:

			{

			stride = size.iWidth << 1;

			pixelFormat = EUidPixelFormatXRGB_4444;

			break;

			}

		case EColor64K:

			{

			stride = size.iWidth << 1;

			pixelFormat = EUidPixelFormatRGB_565;

			break;

			}

		case EColor16MA:

			{

			pixelFormat = EUidPixelFormatARGB_8888;

			break;

			}

		case EColor16MAP:

			{

			pixelFormat = EUidPixelFormatARGB_8888_PRE;

			break;

			}

		default:

			{

			LOG(("Unsupported display mode: %d", bmpFormat));

			User::Leave(KErrNotSupported);

			break;

			}

		}

	// Create an intermediary bitmap for decoding into

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Create(size, info.iFrameDisplayMode));

	// Create the final surface.

	aSurface = CreateSurfaceL(size, pixelFormat, stride);

	TSurfaceCleanup surfaceCleanup(*this, aSurface);

	CleanupClosePushL(surfaceCleanup);

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	// Convert the image file into a Symbian bitmap

	TRequestStatus status;

	decoder->Convert(&status, *bitmap);

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	// Copy the data from the bitmap into the surface.

	TPoint start;

	for (start.iY = 0; start.iY < size.iHeight; start.iY++)

		{

		// Set up a descriptor for the current line in the surface and get pixels.

		TPtr8 ptr(chunk.Base() + start.iY * stride, stride);

		bitmap->GetScanLine(ptr, start, size.iWidth, bmpFormat);

		}

	CleanupStack::PopAndDestroy(/* chunk */);

	CleanupStack::Pop(/* surfaceCleanup */);

	CleanupStack::PopAndDestroy(bitmap);

	CleanupStack::PopAndDestroy(decoder);

	CleanupStack::PopAndDestroy(/* fs */);

	}

void CSurfaceUtility::CopyBitmapSurfaceL(const CFbsBitmap* aBitmap, TSurfaceId& aSurface)

	{

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	TSize bitmapSize = aBitmap->SizeInPixels();

	TSize size = SurfaceSize(aSurface);

	TInt stride = size.iWidth*4;		// Default to four bytes per pixel

	// Copy the data from the bitmap into the surface.

	TPoint start;

	for (start.iY = 0; start.iY < bitmapSize.iHeight; start.iY++)

		{

		// Set up a descriptor for the current line in the surface and get pixels.

		TPtr8 ptr(chunk.Base() + start.iY * stride, stride);

		aBitmap->GetScanLine(ptr, start, bitmapSize.iWidth, EColor16MU);

		}

	CleanupStack::PopAndDestroy(/* chunk */);

	}

/**

Copy the bitmap from a file to a surface.

@param aFileName The name of the image file.

@param aSurface Filled with the surface ID for the surface containing the pixels.

*/

void CSurfaceUtility::CopyBitmapFromFileToSurfaceL(const TDesC& aFileName, const TSurfaceId& aSurface)

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	CImageDecoder* decoder = CImageDecoder::FileNewL(fs, aFileName, CImageDecoder::EOptionAlwaysThread);

	CleanupStack::PushL(decoder);

	const TFrameInfo& info = decoder->FrameInfo();

	TSize size = SurfaceSize(aSurface);

	TDisplayMode bmpFormat = info.iFrameDisplayMode;

	TInt stride = size.iWidth << 2;		// Default to four bytes per pixel

	// Create an intermediary bitmap for decoding into

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Create(size, info.iFrameDisplayMode));

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	// Convert the image file into a Symbian bitmap

	TRequestStatus status;

	decoder->Convert(&status, *bitmap);

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	// Copy the data from the bitmap into the surface.

	TPoint start;

	for (start.iY = 0; start.iY < size.iHeight; start.iY++)

		{

		// Set up a descriptor for the current line in the surface and get pixels.

		TPtr8 ptr(chunk.Base() + start.iY * stride, stride);

		bitmap->GetScanLine(ptr, start, size.iWidth, bmpFormat);

		}

	CleanupStack::PopAndDestroy(/* chunk */);

	CleanupStack::PopAndDestroy(bitmap);

	CleanupStack::PopAndDestroy(decoder);

	CleanupStack::PopAndDestroy(/* fs */);

	}

/**

Copy the bitmap from a file to a surface scaling the original image to cover the entire surface.

@param aFileName The name of the image file.

@param aSurface Filled with the surface ID for the surface containing the pixels.

*/

void CSurfaceUtility::ScaleBitmapFromFileToSurfaceL(const TDesC& aFileName, const TSurfaceId& aSurface)

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	CImageDecoder* decoder = CImageDecoder::FileNewL(fs, aFileName, CImageDecoder::EOptionAlwaysThread);

	CleanupStack::PushL(decoder);

	const TFrameInfo& info = decoder->FrameInfo();

	TSize size = SurfaceSize(aSurface);

	TInt stride = size.iWidth << 2;		// Default to four bytes per pixel

	// Create an intermediary bitmap for decoding into

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap();

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Create(info.iOverallSizeInPixels, info.iFrameDisplayMode));

	RChunk chunk;

	User::LeaveIfError(iManager.MapSurface(aSurface, chunk));

	CleanupClosePushL(chunk);

	TUint8* surfacePixelData = chunk.Base() + PixelDataOffet(aSurface);

	// Convert the image file into a Symbian bitmap

	// CImageDecoder::EOptionAlwaysThread setting above avoids need for Active Object

	TRequestStatus status;

	decoder->Convert(&status, *bitmap);

	User::WaitForRequest(status);

	User::LeaveIfError(status.Int());

	// scale to fit surface

	CBitmapScaler* scaler = CBitmapScaler::NewL();

	CleanupStack::PushL(scaler);

	scaler->SetQualityAlgorithm(CBitmapScaler::EMaximumQuality);

	CActiveListener* activeListener = CActiveListener::NewLC();

	activeListener->Initialize();

	scaler->Scale(&activeListener->iStatus, *bitmap, size, EFalse);

	CActiveScheduler::Start();

	User::LeaveIfError(activeListener->iStatus.Int());

	// Copy the data from the bitmap into the surface.

	TPoint start;

	for (start.iY = 0; start.iY < size.iHeight; start.iY++)

		{

		// Set up a descriptor for the current line in the surface and get pixels.

		TPtr8 ptr(surfacePixelData + start.iY * stride, stride);

		bitmap->GetScanLine(ptr, start, size.iWidth, EColor16MA);

		}

	CleanupStack::PopAndDestroy(activeListener);

	CleanupStack::PopAndDestroy(scaler);

	CleanupStack::PopAndDestroy(/* chunk */);

	CleanupStack::PopAndDestroy(bitmap);

	CleanupStack::PopAndDestroy(decoder);

	CleanupStack::PopAndDestroy(/* fs */);	

	}

/**

Get the size of a surface.

@param aSurface The surface to get the size for.

@return The size in pixels, or empty on failure.

*/

TSize CSurfaceUtility::SurfaceSize(const TSurfaceId& aSurface)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	if (iManager.SurfaceInfo(aSurface, infoBuf) == KErrNone)

		{

		return info.iSize;

		}

	return TSize();

	}

/**

Get the offset into the chunk of the start of pixel data.

@param aSurface The surface to get the size for.

@return The offset bytes, or empty on failure.

*/

TInt CSurfaceUtility::PixelDataOffet(const TSurfaceId& aSurface)

	{

	TInt offsetToFirstBuffer = 0;

	iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer);

	return offsetToFirstBuffer;

	}

/**

Create a surface using the surface manager.

Stores the ID for tear down, as well as returning it.

@param aSize Dimensions of the surface.

@param aPixelFormat	UID of the pixel format.

@param aStride	Stride value for the surface (usually bytes per pixel * width)

@leave May leave due to lack of memory.

@return New surface's ID.

*/

TSurfaceId CSurfaceUtility::CreateSurfaceL(const TSize& aSize, TUidPixelFormat aPixelFormat, TInt aStride, TInt aBuffers)

	{

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

	b.iSize.iWidth = aSize.iWidth;

	b.iSize.iHeight = aSize.iHeight;

	b.iBuffers = aBuffers;				// number of buffers in the surface

	b.iPixelFormat = aPixelFormat;

	b.iStride = aStride;		// Number of bytes between start of one line and start of next

	b.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

	b.iAlignment = 4;			// alignment, 1,2,4,8 byte aligned

	b.iContiguous=EFalse;

	TSurfaceId surface = TSurfaceId::CreateNullId();

	User::LeaveIfError(iManager.CreateSurface(bf, surface));

	iSurfaces.AppendL(surface);

	return surface;

	}

/**

Fill the given surface with a color.

@param aSurface	The surface to be filled.

@param aColor	The color to fill it with.

*/

void CSurfaceUtility::FillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor)

	{

	RSurfaceManager::TInfoBuf infoBuf;

	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

	User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));

	TUint32 color = 0;

	TBool use16 = EFalse;

	if (info.iSize.iHeight<0 || info.iSize.iWidth<0 || info.iStride<0)

		{

		User::Leave(KErrCorrupt);

		}

	if (info.iSize.iHeight==0 || info.iSize.iWidth==0 || info.iStride==0)

		{

		User::Leave(KErrNotReady);

		}

	switch (info.iPixelFormat)

		{

		case EUidPixelFormatXRGB_8888:

			{

			color = aColor.Color16MU();

#ifdef ALPHA_FIX_24BIT

			color |= ((ALPHA_FIX_24BIT)&0xff)<<24;