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

 CSurfaceUtility::CSurfaceUtility(CSurfaceUtility* aClone)

 	:	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();

 	}

 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()

 	{

 	iLocalArray.Close();

 	}

 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()

 	{

 	iUseArray->Reset();

 	}

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

 	{

 	iUseArray->AppendL(anEntry);

 	}

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

 	{

 	return iUseArray->Find(anEntry);

 	}

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

 	{

 	iUseArray->Remove(anIndex);

 	}

 /**

 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;

 	};

 /**

 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();

 	}

 /**

 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();

 	if (aStride<aSize.iWidth*BytesPerPixelL(aPixelFormat))

 	    {

 	    User::Leave(KErrOverflow);

 	    }

 	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;

 	b.iMappable = ETrue;

 	TSurfaceId surface = TSurfaceId::CreateNullId();

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

 	iSurfaces.AppendL(surface);

 	return surface;

 	}

 /**

 A helper function that returns the bytes per pixel for a given pixel format uid

 @param aPixelFormat Pixel format UID to convert

 @return The bytes per pixel

 */

 TInt CSurfaceUtility::BytesPerPixelL(TUidPixelFormat aPixelFormat)

 	{

 	TInt bytesPerPixel = 0;

 	switch (aPixelFormat)

 		{

 		case EUidPixelFormatXRGB_8888:

 		case EUidPixelFormatARGB_8888:

 		case EUidPixelFormatARGB_8888_PRE:

 			{

 			bytesPerPixel = 4;

 			break;

 			}

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 		case EUidPixelFormatRGB_565:

 			{

 			bytesPerPixel = 2;

 			break;

 			}

 		default:

 			{

 			User::Leave(KErrNotSupported);

 			break;

 			}

 		}

 	return bytesPerPixel;

 	}

 /**

 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;

 #endif

 			break;

 			}

 		case EUidPixelFormatARGB_8888:

 			{

 			color = aColor.Color16MA();

 			break;

 			}

 		case EUidPixelFormatARGB_8888_PRE:

 			{

 			color = aColor.Color16MAP();

 			break;

 			}

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 			{

 			color = aColor.Color4K();

 			use16 = ETrue;

 			break;

 			}

 		case EUidPixelFormatRGB_565:

 			{

 			color = aColor.Color64K();

 			use16 = ETrue;

 			break;

 			}

 		default:

 			{

 			User::Leave(KErrNotSupported);

 			break;

 			}

 		}

 	RChunk chunk;

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

 	CleanupClosePushL(chunk);

 	TInt offsetToFirstBuffer;

 	User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));

 	TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;

 	TUint8* linePtr = surfacePtr;

 	if (use16)

 		{

 		if ( info.iSize.iWidth*2>info.iStride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);

 		// Fill first line

 		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

 			{

 			ptr[xx] = (TUint16)color;

 			}

 		}

 	else

 		{

 		if ( info.iSize.iWidth*4>info.iStride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);

 		// Fill first line

 		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

 			{

 			ptr[xx] = color;

 			}

 		}

 	// Now copy that to the other lines

 	for (TInt yy = 1; yy < info.iSize.iHeight; yy++)

 		{

 		linePtr += info.iStride;

 		Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));

 		}

 	TInt err = SubmitUpdate(KAllScreens, aSurface, 0, NULL);

 	if (err!=KErrNone)

 		LOG(("Error submitting update: 0x%X\n", err));

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

 	}

 /**

 Fill the given surface with a color.

 @param aSurface	The surface to be filled.

 @param aBuffer 	The buffer to fill.

 @param aColor	The color to fill it with.

 */

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

 	{

 	RSurfaceManager::TInfoBuf infoBuf;

 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

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

 	TUint32 color = 0;

 	TBool use16 = EFalse;

 	TInt numBuffers = info.iBuffers;

 	if (aBuffer < 0 || aBuffer >= numBuffers)

 		{

 		User::Leave(KErrArgument);

 		}

 	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;

 #endif

 			break;

 			}

 		case EUidPixelFormatARGB_8888:

 			{

 			color = aColor.Color16MA();

 			break;

 			}

 		case EUidPixelFormatARGB_8888_PRE:

 			{

 			color = aColor.Color16MAP();

 			break;

 			}

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 			{

 			color = aColor.Color4K();

 			use16 = ETrue;

 			break;

 			}

 		case EUidPixelFormatRGB_565:

 			{

 			color = aColor.Color64K();

 			use16 = ETrue;

 			break;

 			}

 		default:

 			{

 			User::Leave(KErrNotSupported);

 			break;

 			}

 		}

 	RChunk chunk;

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

 	CleanupClosePushL(chunk);

 	TInt offsetToBuffer;

 	User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBuffer, offsetToBuffer));

 	TUint8* surfacePtr = chunk.Base() + offsetToBuffer;

 	TUint8* linePtr = surfacePtr;

 	if (use16)

 		{

 		if ( info.iSize.iWidth*2>info.iStride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);

 		// Fill first line

 		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

 			{

 			ptr[xx] = (TUint16)color;

 			}

 		}

 	else

 		{

 		if ( info.iSize.iWidth*4>info.iStride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);

 		// Fill first line

 		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

 			{

 			ptr[xx] = color;

 			}

 		}

 	// Now copy that to the other lines

 	for (TInt yy = 1; yy < info.iSize.iHeight; yy++)

 		{

 		linePtr += info.iStride;

 		Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));

 		}

 	TInt err = SubmitUpdate(KAllScreens, aSurface, 0, NULL);

 	if (err!=KErrNone)

 		LOG(("Error submitting update: 0x%X\n", err));

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

 	}

 /**

 Destroy a surface.

 As well as destroying the surface, it is removed from the set held for

 destruction during tear down.

 @param aSurface	The surface to be destroyed.

 */

 void CSurfaceUtility::DestroySurface(TSurfaceId& aSurface)

 	{

 	TInt index = iSurfaces.Find(aSurface);

 	if (index != KErrNotFound)

 		{

 		iSurfaces.Remove(index);

 		}

 	TInt err = iManager.CloseSurface(aSurface);

 	if (err!=KErrNone)

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

 	}

 /**

 Submit an update to a surface to the update server.

 @param aScreenNumber	The screen to be updated where the surface is shown.

 @param aSurface	The surface which has been updated.

 @param aRegion	The area of the surface affected, or NULL for all of it.

 */

 TInt CSurfaceUtility::SubmitUpdate(TInt /* aScreenNumber */, const TSurfaceId& aSurface,TInt aBufferNumber, TInt aNullRegion)

     {

     if (aNullRegion==0)

         {

         return SubmitUpdate(KAllScreens, aSurface, aBufferNumber);

         }

     else

         if (aBufferNumber==0)

             {

             return SubmitUpdate(KAllScreens, aSurface, aNullRegion);

             }

         else

             {

             return KErrNotSupported;

             }

     }

 TInt CSurfaceUtility::SubmitUpdate(TInt /* aScreenNumber */, const TSurfaceId& aSurface, const TRegion* aRegion,TInt aBufferNumber)

     {

     return SubmitUpdate(KAllScreens, aSurface, aBufferNumber, aRegion);

     }

 TInt CSurfaceUtility::SubmitUpdate(TInt /* aScreenNumber */, const TSurfaceId& aSurface,TInt aBufferNumber, const TRegion* aRegion)

 	{

 	if (!iSurfaceUpdateSession.Handle())

 	    {

 	    iSurfaceUpdateSession.Connect();

 	    }

     if (!iSurfaceUpdateSession.Handle())

         {

         LOG(("Error - SUS client not started!"));

         return KErrNotReady;

         }

     else

         {

         TInt err =iSurfaceUpdateSession.SubmitUpdate(KAllScreens, aSurface, aBufferNumber, aRegion); 

         if (err!=KErrNone)

             LOG(("Error submitting update: 0x%X\n", err));

         return err;

         }

 	}

 void CSurfaceUtility::FillNativeStreamSurfaceL(TSurfaceId& aSurface, TUint8* aBufferPtr, 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;

 #endif

 			break;

 			}

 		case EUidPixelFormatARGB_8888:

 			{

 			color = aColor.Color16MA();

 			break;

 			}

 		case EUidPixelFormatARGB_8888_PRE:

 			{

 			color = aColor.Color16MAP();

 			break;

 			}

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 			{

 			color = aColor.Color4K();

 			use16 = ETrue;

 			break;

 			}

 		case EUidPixelFormatRGB_565:

 			{

 			color = aColor.Color64K();

 			use16 = ETrue;

 			break;

 			}

 		default:

 			{

 			User::Leave(KErrNotSupported);

 			break;

 			}

 		}

 	TUint8* surfacePtr = aBufferPtr;

 	TUint8* linePtr = surfacePtr;

 	if (use16)

 		{

 		if ( info.iSize.iWidth*2>info.iStride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);

 		// Fill first line

 		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

 			{

 			ptr[xx] = (TUint16)color;

 			}

 		}

 	else

 		{

 		if ( info.iSize.iWidth*4>info.iStride)

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);

 		// Fill first line

 		for (TInt xx = 0; xx < info.iSize.iWidth; xx++)

 			{

 			ptr[xx] = color;

 			}

 		}

 	// Now copy that to the other lines

 	for (TInt yy = 1; yy < info.iSize.iHeight; yy++)

 		{

 		linePtr += info.iStride;

 		Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));

 		}	

 	}

 TBool CSurfaceUtility::CompareSurfacesL(TSurfaceId& aSurface, TInt aBuffer, TSurfaceId& aStreamSurface, TUint8* aBufferPtr)

 	{

 	RSurfaceManager::TInfoBuf infoBuf1;

 	RSurfaceManager::TSurfaceInfoV01& info1 = infoBuf1();

 	RSurfaceManager::TInfoBuf infoBuf2;

 	RSurfaceManager::TSurfaceInfoV01& info2 = infoBuf2();	

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

 	User::LeaveIfError(iManager.SurfaceInfo(aStreamSurface, infoBuf2));

 	TBool use16 = EFalse;

 	if (aBuffer < 0 || aBuffer >= info1.iBuffers)

 		{

 		User::Leave(KErrArgument);

 		}

 	if (info1.iPixelFormat != info2.iPixelFormat)

 		{

 		User::Leave(KErrArgument);

 		}	

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

 		(info2.iSize.iHeight<0 || info2.iSize.iWidth<0 || info2.iStride<0))

 		{

 		User::Leave(KErrCorrupt);

 		}

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

 		(info2.iSize.iHeight==0 || info2.iSize.iWidth==0 || info2.iStride==0))

 		{

 		User::Leave(KErrNotReady);

 		}

 	if (info1.iSize != info2.iSize)

 		{

 		User::Leave(KErrArgument);

 		}

 	switch (info1.iPixelFormat)

 		{

 		case EUidPixelFormatXRGB_8888:

 		case EUidPixelFormatARGB_8888:

 		case EUidPixelFormatARGB_8888_PRE:

 			{

 			break;

 			}

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatARGB_4444:

 		case EUidPixelFormatRGB_565:

 			{

 			use16 = ETrue;

 			break;

 			}

 		default:

 			{

 			User::Leave(KErrNotSupported);

 			break;

 			}

 		}

 	// Surface

 	RChunk chunk;

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

 	CleanupClosePushL(chunk);

 	TInt offsetToBuffer;

 	User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBuffer, offsetToBuffer));

 	TUint8* surfacePtr1 = chunk.Base() + offsetToBuffer;

 	// Native stream

 	TUint8* surfacePtr2 = aBufferPtr;

 	TUint32 color1 = 0;

 	TUint32 color2 = 0;

 	if (use16)

 		{

 		if ((info1.iSize.iWidth*2>info1.iStride) ||

 			(info2.iSize.iWidth*2>info2.iStride))

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint16* ptr1 = reinterpret_cast<TUint16*>(surfacePtr1);

 		TUint16* ptr2 = reinterpret_cast<TUint16*>(surfacePtr2);

 		// Fill first line

 		for (TInt xx = 0; xx < info1.iSize.iWidth; xx++)

 			{

 			for (TInt yy = 0; yy < info1.iSize.iHeight; yy++)

 				{

 				color1 = (TUint16)ptr1[xx];

 				color2 = (TUint16)ptr2[xx];

 				if (color1 != color2)

 					{

 					return EFalse;

 					}

 				}

 			}

 		}

 	else

 		{

 		if ((info1.iSize.iWidth*4>info1.iStride) ||

 			(info2.iSize.iWidth*4>info2.iStride))

 			{

 			User::Leave(KErrOverflow);

 			}

 		TUint32* ptr1 = reinterpret_cast<TUint32*>(surfacePtr1);

 		TUint32* ptr2 = reinterpret_cast<TUint32*>(surfacePtr2);		

 		// Fill first line

 		for (TInt xx = 0; xx < info1.iSize.iWidth; xx++)

 			{

 			for (TInt yy = 0; yy < info1.iSize.iHeight; yy++)

 				{

 				color1 = ptr1[xx];

 				color2 = ptr2[xx];

 				if (color1 != color2)

 					{

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

 					return EFalse;

 					}

 				}

 			}

 		}	

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

 	return ETrue;

 	}

 void CSurfaceUtility::NotifyWhenDisplayed(TRequestStatus& aStatusDisplayed, TTimeStamp& aTimeStamp)

     {

     iSurfaceUpdateSession.NotifyWhenDisplayed(aStatusDisplayed, aTimeStamp);

     }

 void CSurfaceUtility::NotifyWhenDisplayedXTimes(TInt aCount, TRequestStatus& aStatusDisplayedX)

     {

     iSurfaceUpdateSession.NotifyWhenDisplayedXTimes(aCount, aStatusDisplayedX);

     }

 void CSurfaceUtility::NotifyWhenAvailable(TRequestStatus& aStatusAvailable)

     {

     iSurfaceUpdateSession.NotifyWhenAvailable(aStatusAvailable);

     }