1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18 */

    19 

    20 #include <e32std.h>

    21 #include <imageconversion.h>

    22 #include "surfaceutility.h"

    23 

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

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

    26 	{

    27 	}

    28 	

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

    30 	{

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

    32 	CleanupStack::PushL(utility);

    33 	utility->ConstructL();

    34 	CleanupStack::Pop(utility);

    35 	return utility;

    36 	}

    37 	

    38 void CSurfaceUtility::ConstructL()

    39 	{

    40 	TInt r = iManager.Open();

    41 	if (r != KErrNone)

    42 		{

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

    44 		User::Leave(r);

    45 		}

    46 	

    47 	r = iSurfaceUpdateSession.Connect();

    48 	if (r != KErrNone)

    49 		{

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

    51 		User::Leave(r);

    52 		}

    53 	}

    54 	

    55 CSurfaceUtility::~CSurfaceUtility()

    56 	{

    57 	DestroyAll();

    58 

    59 	iSurfaces.Close();

    60 

    61 	iManager.Close();

    62 

    63 	iSurfaceUpdateSession.Close();

    64 	}

    65 

    66 TBool CSurfaceUtility::DestroyAll()

    67 	{

    68 	TInt err = 	KErrNone;

    69 	TInt jj = iSurfaces.Count() - 1;

    70 	if (jj<0)

    71 		return EFalse;

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

    73 		{

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

    75 		if (err!=KErrNone)

    76 			{

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

    78 			}

    79 		}

    80 	iSurfaces.Reset();

    81 	return ETrue;

    82 	}

    83 

    84 /***************************************

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

    86  ***************************************/

    87 

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

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

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

    91 	{

    92 	

    93 	}

    94 /************************************

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

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

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

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

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

   100  ************************************/

   101 

   102 // PopAndDestroy method to restore the heap

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

   104 	{

   105 	RHeap* heapPtr=(RHeap*)aHeapPtr;

   106 	User::SwitchHeap(heapPtr);

   107 	}

   108 

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

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

   111 	{

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

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

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

   115 	CleanupStack::Pop(3);

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

   117 	delete new char;

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

   119 	}

   120 

   121 

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

   123 	{

   124 	return iUseArray->operator[](aIndex);

   125 	}

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

   127 void CSurfaceUtility::RHeapSurfaceArray::Close()

   128 	{

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

   130 	iLocalArray.Close();

   131 	User::SwitchHeap(oldHeap);

   132 	}

   133 TInt CSurfaceUtility::RHeapSurfaceArray::Count() const

   134 	{

   135 	return iUseArray->Count();

   136 	}

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

   138 inline void CSurfaceUtility::RHeapSurfaceArray::Reset()

   139 	{

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

   141 	iUseArray->Reset();

   142 	User::SwitchHeap(oldHeap);

   143 	}

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

   145 	{

   146 	SwitchHeapLC(&iExternalHeapRef);

   147 	iUseArray->AppendL(anEntry);

   148 	CleanupStack::PopAndDestroy();

   149 	}

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

   151 	{

   152 	return iUseArray->Find(anEntry);

   153 	}

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

   155 	{

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

   157 	iUseArray->Remove(anIndex);

   158 	User::SwitchHeap(oldHeap);

   159 	}

   160 

   161 

   162 

   163 

   164 /**

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

   166 that the standard Close() semantics can be used.

   167 */

   168 class TSurfaceCleanup

   169 	{

   170 public:

   171 	TSurfaceCleanup(CSurfaceUtility& aUtility, TSurfaceId& aSurface)

   172 		: iUtility(aUtility), iSurface(aSurface)

   173 		{}

   174 	void Close()

   175 		{

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

   177 		// the surface reference.

   178 		iUtility.DestroySurface(iSurface);

   179 		}

   180 private:

   181 	CSurfaceUtility& iUtility;

   182 	TSurfaceId& iSurface;

   183 	};

   184 

   185 /**

   186 Read the given image file into a new surface.

   187 

   188 @param aFileName The name of the image file.

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

   190 */

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

   192 	{

   193 	RFs fs;

   194 	

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

   196 	CleanupClosePushL(fs);

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

   198 	CleanupStack::PushL(decoder);

   199 

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

   201 

   202 	TSize size = info.iOverallSizeInPixels;

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

   204 	TDisplayMode bmpFormat = info.iFrameDisplayMode;

   205 	TUidPixelFormat pixelFormat = EUidPixelFormatUnknown;

   206 

   207 	switch (bmpFormat)

   208 		{

   209 		case EGray2:

   210 		case EGray4:

   211 		case EGray16:

   212 		case EGray256:

   213 		case EColor16:

   214 		case EColor256:

   215 		case EColor16M:

   216 		case EColor16MU:

   217 			{

   218 			bmpFormat = EColor16MU;

   219 			pixelFormat = EUidPixelFormatXRGB_8888;

   220 			break;

   221 			}

   222 		case EColor4K:

   223 			{

   224 			stride = size.iWidth << 1;

   225 			pixelFormat = EUidPixelFormatXRGB_4444;

   226 			break;

   227 			}

   228 		case EColor64K:

   229 			{

   230 			stride = size.iWidth << 1;

   231 			pixelFormat = EUidPixelFormatRGB_565;

   232 			break;

   233 			}

   234 		case EColor16MA:

   235 			{

   236 			pixelFormat = EUidPixelFormatARGB_8888;

   237 			break;

   238 			}

   239 		case EColor16MAP:

   240 			{

   241 			pixelFormat = EUidPixelFormatARGB_8888_PRE;

   242 			break;

   243 			}

   244 		default:

   245 			{

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

   247 			User::Leave(KErrNotSupported);

   248 			break;

   249 			}

   250 		}

   251 

   252 	// Create an intermediary bitmap for decoding into

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

   254 	CleanupStack::PushL(bitmap);

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

   256 

   257 	// Create the final surface.

   258 	aSurface = CreateSurfaceL(size, pixelFormat, stride);

   259 	TSurfaceCleanup surfaceCleanup(*this, aSurface);

   260 	CleanupClosePushL(surfaceCleanup);

   261 

   262 	RChunk chunk;

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

   264 	CleanupClosePushL(chunk);

   265 

   266 	// Convert the image file into a Symbian bitmap

   267 	TRequestStatus status;

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

   269 	User::WaitForRequest(status);

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

   271 

   272 	TInt offsetToFirstBuffer;

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

   274 	

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

   276 	TPoint start;

   277 	TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer; 

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

   279 		{

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

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

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

   283 		}

   284 

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

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

   287 	CleanupStack::PopAndDestroy(bitmap);

   288 	CleanupStack::PopAndDestroy(decoder);

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

   290 	}

   291 

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

   293 	{

   294 	RChunk chunk;

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

   296 	CleanupClosePushL(chunk);

   297 	TSize bitmapSize = aBitmap->SizeInPixels();

   298 	TSize size = SurfaceSize(aSurface);

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

   300 

   301 	TInt offsetToFirstBuffer;

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

   303 	

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

   305 	TPoint start;

   306 	TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer; 

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

   308 		{

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

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

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

   312 		}

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

   314 

   315 	}

   316 /**

   317 Copy the bitmap from a file to a surface.

   318 

   319 @param aFileName The name of the image file.

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

   321 */

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

   323 	{

   324 	RFs fs;

   325 	

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

   327 	CleanupClosePushL(fs);

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

   329 	CleanupStack::PushL(decoder);

   330 

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

   332 

   333 	RSurfaceManager::TInfoBuf infoBuf;

   334 	RSurfaceManager::TSurfaceInfoV01& infoSurf = infoBuf();

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

   336 	

   337 	TSize size = infoSurf.iSize;

   338 	TDisplayMode bmpFormat = info.iFrameDisplayMode;

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

   340 

   341 	// Create an intermediary bitmap for decoding into

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

   343 	CleanupStack::PushL(bitmap);

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

   345 

   346 	RChunk chunk;

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

   348 	CleanupClosePushL(chunk);

   349 

   350 	// Convert the image file into a Symbian bitmap

   351 	TRequestStatus status;

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

   353 	User::WaitForRequest(status);

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

   355 

   356 	TInt offsetToFirstBuffer;

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

   358 

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

   360 	TPoint start;

   361 	TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;

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

   363 		{

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

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

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

   367 		}

   368 

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

   370 	CleanupStack::PopAndDestroy(bitmap);

   371 	CleanupStack::PopAndDestroy(decoder);

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

   373 	}

   374 /**

   375 Get the size of a surface.

   376 

   377 @param aSurface The surface to get the size for.

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

   379 */

   380 TSize CSurfaceUtility::SurfaceSize(const TSurfaceId& aSurface)

   381 	{

   382 	RSurfaceManager::TInfoBuf infoBuf;

   383 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

   384 

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

   386 		{

   387 		return info.iSize;

   388 		}

   389 

   390 	return TSize();

   391 	}

   392 

   393 

   394 /**

   395 Create a surface using the surface manager.

   396 

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

   398 

   399 @param aSize Dimensions of the surface.

   400 @param aPixelFormat	UID of the pixel format.

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

   402 @leave May leave due to lack of memory.

   403 @return New surface's ID.

   404 */

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

   406 	{

   407 	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

   408 	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

   409 	

   410 	b.iSize.iWidth = aSize.iWidth;

   411 	b.iSize.iHeight = aSize.iHeight;

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

   413 	b.iPixelFormat = aPixelFormat;

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

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

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

   417 	b.iContiguous = EFalse;

   418 	b.iMappable = ETrue;

   419 

   420 	TSurfaceId surface = TSurfaceId::CreateNullId();

   421 

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

   423 	iSurfaces.AppendL(surface);

   424 	return surface;

   425 	}

   426 

   427 /**

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

   429 

   430 @param aPixelFormat Pixel format UID to convert

   431 @return The bytes per pixel

   432 */

   433 TInt CSurfaceUtility::BytesPerPixelL(TUidPixelFormat aPixelFormat)

   434 	{

   435 	TInt bytesPerPixel = 0;

   436 	switch (aPixelFormat)

   437 		{

   438 		case EUidPixelFormatXRGB_8888:

   439 		case EUidPixelFormatARGB_8888:

   440 		case EUidPixelFormatARGB_8888_PRE:

   441 			{

   442 			bytesPerPixel = 4;

   443 			break;

   444 			}

   445 		case EUidPixelFormatXRGB_4444:

   446 		case EUidPixelFormatARGB_4444:

   447 		case EUidPixelFormatRGB_565:

   448 			{

   449 			bytesPerPixel = 2;

   450 			break;

   451 			}

   452 		default:

   453 			{

   454 			User::Leave(KErrNotSupported);

   455 			break;

   456 			}

   457 		}

   458 	return bytesPerPixel;

   459 	}

   460 

   461 /**

   462 Fill the given surface with a color.

   463 

   464 @param aSurface	The surface to be filled.

   465 @param aColor	The color to fill it with.

   466 */

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

   468 	{

   469 	RSurfaceManager::TInfoBuf infoBuf;

   470 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

   471 

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

   473 	TUint32 color = 0;

   474 	TBool use16 = EFalse;

   475 

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

   477 		{

   478 		User::Leave(KErrCorrupt);

   479 		}

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

   481 		{

   482 		User::Leave(KErrNotReady);

   483 		}

   484 

   485 	switch (info.iPixelFormat)

   486 		{

   487 		case EUidPixelFormatXRGB_8888:

   488 			{

   489 			color = aColor.Color16MU();

   490 #ifdef ALPHA_FIX_24BIT

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

   492 #endif

   493 			break;

   494 			}

   495 		case EUidPixelFormatARGB_8888:

   496 			{

   497 			color = aColor.Color16MA();

   498 			break;

   499 			}

   500 		case EUidPixelFormatARGB_8888_PRE:

   501 			{

   502 			color = aColor.Color16MAP();

   503 			break;

   504 			}

   505 		case EUidPixelFormatXRGB_4444:

   506 		case EUidPixelFormatARGB_4444:

   507 			{

   508 			color = aColor.Color4K();

   509 			use16 = ETrue;

   510 			break;

   511 			}

   512 		case EUidPixelFormatRGB_565:

   513 			{

   514 			color = aColor.Color64K();

   515 			use16 = ETrue;

   516 			break;

   517 			}

   518 		default:

   519 			{

   520 			User::Leave(KErrNotSupported);

   521 			break;

   522 			}

   523 		}

   524 

   525 	RChunk chunk;

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

   527 	CleanupClosePushL(chunk);

   528 

   529 	TInt offsetToFirstBuffer;

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

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

   532 	TUint8* linePtr = surfacePtr;

   533 

   534 	if (use16)

   535 		{

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

   537 			{

   538 			User::Leave(KErrOverflow);

   539 			}

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

   541 

   542 		// Fill first line

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

   544 			{

   545 			ptr[xx] = (TUint16)color;

   546 			}

   547 		}

   548 	else

   549 		{

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

   551 			{

   552 			User::Leave(KErrOverflow);

   553 			}

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

   555 

   556 		// Fill first line

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

   558 			{

   559 			ptr[xx] = color;

   560 			}

   561 		}

   562 

   563 	// Now copy that to the other lines

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

   565 		{

   566 		linePtr += info.iStride;

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

   568 		}

   569 	

   570 	TInt err = iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);

   571 	if (err!=KErrNone)

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

   573 

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

   575 	}

   576 

   577 /**

   578 Fill the given memory chunk with a color.

   579 

   580 @param aSurface	The surface to be filled.

   581 @param aChunk	The surface to be filled.

   582 @param aColor	The color to fill it with.

   583 */

   584 void CSurfaceUtility::FillChunkL(TSurfaceId& aSurface, RChunk& aChunk, const TRgb& aColor, TInt aBufferNumber)

   585 	{

   586 	RSurfaceManager::TInfoBuf infoBuf;

   587 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

   588 

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

   590 	TUint32 color = 0;

   591 	TBool use16 = EFalse;

   592 

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

   594 		{

   595 		User::Leave(KErrCorrupt);

   596 		}

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

   598 		{

   599 		User::Leave(KErrNotReady);

   600 		}

   601 

   602 	switch (info.iPixelFormat)

   603 		{

   604 		case EUidPixelFormatXRGB_8888:

   605 			{

   606 			color = aColor.Color16MU();

   607 #ifdef ALPHA_FIX_24BIT

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

   609 #endif

   610 			break;

   611 			}

   612 		case EUidPixelFormatARGB_8888:

   613 			{

   614 			color = aColor.Color16MA();

   615 			break;

   616 			}

   617 		case EUidPixelFormatARGB_8888_PRE:

   618 			{

   619 			color = aColor.Color16MAP();

   620 			break;

   621 			}

   622 		case EUidPixelFormatXRGB_4444:

   623 		case EUidPixelFormatARGB_4444:

   624 			{

   625 			color = aColor.Color4K();

   626 			use16 = ETrue;

   627 			break;

   628 			}

   629 		case EUidPixelFormatRGB_565:

   630 			{

   631 			color = aColor.Color64K();

   632 			use16 = ETrue;

   633 			break;

   634 			}

   635 		default:

   636 			{

   637 			User::Leave(KErrNotSupported);

   638 			break;

   639 			}

   640 		}

   641 

   642 	User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));

   643 	

   644 	TInt offsetToFirstBuffer;

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

   646 	TInt offsetToBufferNumber;

   647 	User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBufferNumber, offsetToBufferNumber));

   648 	

   649 	TUint8* chunkPtr = aChunk.Base() + offsetToFirstBuffer;

   650 	TUint8* linePtr = aChunk.Base() + offsetToBufferNumber;

   651 	TUint8* surfPlanePtr = linePtr;

   652 

   653 	if (use16)

   654 		{

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

   656 			{

   657 			aChunk.Close();

   658 			User::Leave(KErrOverflow);

   659 			}

   660 		TUint16* ptr = reinterpret_cast<TUint16*>(surfPlanePtr);

   661 

   662 		// Fill first line

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

   664 			{

   665 			ptr[xx] = (TUint16)color;

   666 			}

   667 		}

   668 	else

   669 		{

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

   671 			{

   672 			aChunk.Close();

   673 			User::Leave(KErrOverflow);

   674 			}

   675 		TUint32* ptr = reinterpret_cast<TUint32*>(surfPlanePtr);

   676 

   677 		// Fill first line

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

   679 			{

   680 			ptr[xx] = color;

   681 			}

   682 		}

   683 

   684 	// Now copy that to the other lines

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

   686 		{

   687 		linePtr += info.iStride;

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

   689 		}

   690 

   691 	aChunk.Close();

   692 	}

   693 

   694 /**

   695 Fill a rectangle on the given surface.

   696 

   697 @param aSurface		The surface to be filled.

   698 @param aStartPos	Where to place the rectangle.

   699 @param aSize		Size of the rectangle.

   700 @param aColor		The colour to fill it with.

   701 */

   702 void CSurfaceUtility::FillRectangleL(TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, const TRgb& aColor)

   703 	{

   704 	FillRectangleNoUpdateL(aSurface, aStartPos, aSize, aColor);

   705 	

   706 	TInt err = iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);

   707 	if (err!=KErrNone)

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

   709 	}

   710 

   711 /**

   712 Fill a rectangle on the given surface - does not submit update.

   713 

   714 @param aSurface		The surface to be filled.

   715 @param aStartPos	Where to place the rectangle.

   716 @param aSize		Size of the rectangle.

   717 @param aColor		The colour to fill it with.

   718 */

   719 void CSurfaceUtility::FillRectangleNoUpdateL(TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, const TRgb& aColor)

   720 	{

   721 	RSurfaceManager::TInfoBuf infoBuf;

   722 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

   723 

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

   725 	TUint32 color = 0;

   726 	TBool use16 = EFalse;

   727 

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

   729 		{

   730 		User::Leave(KErrCorrupt);

   731 		}

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

   733 		{

   734 		User::Leave(KErrNotReady);

   735 		}

   736 

   737 	switch (info.iPixelFormat)

   738 		{

   739 		case EUidPixelFormatXRGB_8888:

   740 			{

   741 			color = aColor.Color16MU();

   742 #ifdef ALPHA_FIX_24BIT

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

   744 #endif

   745 			break;

   746 			}

   747 		case EUidPixelFormatARGB_8888:

   748 			{

   749 			color = aColor.Color16MA();

   750 			break;

   751 			}

   752 		case EUidPixelFormatARGB_8888_PRE:

   753 			{

   754 			color = aColor.Color16MAP();

   755 			break;

   756 			}

   757 		case EUidPixelFormatXRGB_4444:

   758 		case EUidPixelFormatARGB_4444:

   759 			{

   760 			color = aColor.Color4K();

   761 			use16 = ETrue;

   762 			break;

   763 			}

   764 		case EUidPixelFormatRGB_565:

   765 			{

   766 			color = aColor.Color64K();

   767 			use16 = ETrue;

   768 			break;

   769 			}

   770 		default:

   771 			{

   772 			User::Leave(KErrNotSupported);

   773 			break;

   774 			}

   775 		}

   776 

   777 	RChunk chunk;

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

   779 	CleanupClosePushL(chunk);

   780 

   781 	TInt offsetToFirstBuffer;

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

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

   784 	

   785 	// Check for out of bounds

   786 	TBool validRect = ETrue;

   787 	TInt surfaceWidth = info.iSize.iWidth;

   788 	TInt surfaceHeight = info.iSize.iHeight;

   789 	

   790 	// Width and Height

   791 	if ((aStartPos.iX + aSize.iWidth) > surfaceWidth)

   792 		validRect = EFalse;

   793 	

   794 	if ((aStartPos.iY + aSize.iHeight) > surfaceHeight)

   795 		validRect = EFalse;

   796 	

   797 	// Starting position

   798 	if ((aStartPos.iX < 0) || (aStartPos.iY < 0))

   799 		validRect = EFalse;

   800 	

   801 	if (!validRect)

   802 		User::Leave(KErrOverflow);

   803 		

   804 	if (use16)

   805 		{

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

   807 			{

   808 			User::Leave(KErrOverflow);

   809 			}

   810 		

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

   812 		

   813 		// Fill the rectangle

   814 		TInt yPos = aStartPos.iY;

   815 		TInt xPos = aStartPos.iX;

   816 		for (TInt yy = 0; yy < aSize.iHeight; ++yy)

   817 			{

   818 			ptr = reinterpret_cast<TUint16*>(surfacePtr+(yPos*info.iStride));

   819 			for (TInt xx = 0; xx < aSize.iWidth; ++xx)

   820 				{

   821 				ptr[xPos] = color;

   822 				xPos++;

   823 				}

   824 			xPos = aStartPos.iX;

   825 			yPos++;

   826 			}

   827 		}

   828 	else

   829 		{

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

   831 			{

   832 			User::Leave(KErrOverflow);

   833 			}

   834 

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

   836 		

   837 		// Fill the rectangle

   838 		TInt yPos = aStartPos.iY;

   839 		TInt xPos = aStartPos.iX;

   840 		for (TInt yy = 0; yy < aSize.iHeight; ++yy)

   841 			{

   842 			ptr = reinterpret_cast<TUint32*>(surfacePtr+(yPos*info.iStride));

   843 			for (TInt xx = 0; xx < aSize.iWidth; ++xx)

   844 				{

   845 				ptr[xPos] = color;

   846 				xPos++;

   847 				}

   848 			xPos = aStartPos.iX;

   849 			yPos++;

   850 			}

   851 		}

   852 	

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

   854 	}

   855 

   856 /**

   857 Fill the given surface with a grid over a solid color.

   858 

   859 Similar to FillSurfaceL(), but with a grid overlayed. The pitch of the grid is

   860 eight pixels.

   861 

   862 @param aSurface	The surface to be filled.

   863 @param aColor	The color to fill it with.

   864 @param aLines	The color of the grid lines.

   865 */

   866 void CSurfaceUtility::GridFillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor, const TRgb& aLines)

   867 	{

   868 	RSurfaceManager::TInfoBuf infoBuf;

   869 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

   870 

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

   872 	TUint32 color = 0;

   873 	TUint32 lines = 0;

   874 	TBool use16 = EFalse;

   875 

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

   877 		{

   878 		User::Leave(KErrCorrupt);

   879 		}

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

   881 		{

   882 		User::Leave(KErrNotReady);

   883 		}

   884 

   885 	switch (info.iPixelFormat)

   886 		{

   887 		case EUidPixelFormatXRGB_8888:

   888 			{

   889 			color = aColor.Color16MU();

   890 			lines = aLines.Color16MU();

   891 #ifdef ALPHA_FIX_24BIT

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

   893 			lines |= ((ALPHA_FIX_24BIT)&0xff)<<24;

   894 #endif

   895 			break;

   896 			}

   897 		case EUidPixelFormatARGB_8888:

   898 			{

   899 			color = aColor.Color16MA();

   900 			lines = aLines.Color16MA();

   901 			break;

   902 			}

   903 		case EUidPixelFormatARGB_8888_PRE:

   904 			{

   905 			color = aColor.Color16MAP();

   906 			lines = aLines.Color16MAP();

   907 			break;

   908 			}

   909 		case EUidPixelFormatXRGB_4444:

   910 		case EUidPixelFormatARGB_4444:

   911 			{

   912 			color = aColor.Color4K();

   913 			lines = aLines.Color4K();

   914 			use16 = ETrue;

   915 			break;

   916 			}

   917 		case EUidPixelFormatRGB_565:

   918 			{

   919 			color = aColor.Color64K();

   920 			lines = aLines.Color64K();

   921 			use16 = ETrue;

   922 			break;

   923 			}

   924 		default:

   925 			{

   926 			User::Leave(KErrNotSupported);

   927 			break;

   928 			}

   929 		}

   930 

   931 	RChunk chunk;

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

   933 	CleanupClosePushL(chunk);

   934 

   935 	TInt offsetToFirstBuffer;

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

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

   938 	TUint8* linePtr = surfacePtr;

   939 

   940 	if (use16)

   941 		{

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

   943 			{

   944 			User::Leave(KErrOverflow);

   945 			}

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

   947 

   948 		// Fill first line

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

   950 			{

   951 			ptr[xx1] = (TUint16)lines;

   952 			}

   953 

   954 		// Fill second line

   955 		ptr = reinterpret_cast<TUint16*>(surfacePtr + info.iStride);

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

   957 			{

   958 			// Vertical line every 8 pixels across

   959 			ptr[xx2] = (TUint16)((xx2 & 7) ? color : lines);

   960 			}

   961 		}

   962 	else

   963 		{

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

   965 			{

   966 			User::Leave(KErrOverflow);

   967 			}

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

   969 

   970 		// Fill first line

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

   972 			{

   973 			ptr[xx3] = lines;

   974 			}

   975 

   976 		// Fill second line

   977 		ptr = reinterpret_cast<TUint32*>(surfacePtr + info.iStride);

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

   979 			{

   980 			// Vertical line every 8 pixels across

   981 			ptr[xx4] = (xx4 & 7) ? color : lines;

   982 			}

   983 		}

   984 	linePtr += info.iStride;

   985 

   986 	// Now copy that to the other lines

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

   988 		{

   989 		linePtr += info.iStride;

   990 		if (yy & 7)

   991 			{

   992 			// Copy second line

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

   994 			}

   995 		else

   996 			{

   997 			// Copy first line

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

   999 			}

  1000 		}

  1001 

  1002 	TInt err =iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);

  1003 	if (err!=KErrNone)

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

  1005 	

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

  1007 	}

  1008 

  1009 

  1010 /**

  1011 Fill the given surface with a pattern suitable for automated testing.

  1012 

  1013 @param aSurface	The surface to be filled.

  1014 */

  1015 void CSurfaceUtility::PatternFillSurfaceL(TSurfaceId& aSurface)

  1016 	{

  1017 	RSurfaceManager::TInfoBuf infoBuf;

  1018 	RSurfaceManager::TSurfaceInfoV01& info = infoBuf();

  1019 

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

  1021 	

  1022 	// Fill the background

  1023 	FillSurfaceL(aSurface, TRgb(0x00000000));

  1024 

  1025 	TInt surfaceWidth = info.iSize.iWidth;

  1026 	TInt surfaceHeight = info.iSize.iHeight;

  1027 	

  1028 	// Create the 4 rectangles in the corners

  1029 	TPoint startPos(0,0);

  1030 	TSize size(15,15);

  1031 	TInt rectWidth = size.iWidth;

  1032 	TInt rectHeight = size.iHeight;

  1033 	// Top left

  1034 	FillRectangleL(aSurface, startPos, size, TRgb(0x0000ff));

  1035 	

  1036 	// Top right

  1037 	startPos.iX = surfaceWidth - rectWidth;

  1038 	startPos.iY = 0;

  1039 	FillRectangleL(aSurface, startPos, size, TRgb(0x00ff00));

  1040 	

  1041 	// Bottom left

  1042 	startPos.iX = 0;

  1043 	startPos.iY = surfaceHeight - rectHeight;

  1044 	FillRectangleL(aSurface, startPos, size, TRgb(0x00ffff));

  1045 	

  1046 	// Bottom right

  1047 	startPos.iX = surfaceWidth - rectWidth;

  1048 	startPos.iY = surfaceHeight - rectHeight;

  1049 	FillRectangleL(aSurface, startPos, size, TRgb(0xffffff));

  1050 	

  1051 	// Create the 4 side bars

  1052 	startPos.iX = 0;

  1053 	startPos.iY = 6;

  1054 	size.iWidth = 5;

  1055 	size.iHeight = surfaceHeight - 12;

  1056 	// Left

  1057 	FillRectangleL(aSurface, startPos, size, TRgb(0x808000));

  1058 	

  1059 	startPos.iX = surfaceWidth - size.iWidth;

  1060 	startPos.iY = 6;

  1061 	// Right

  1062 	FillRectangleL(aSurface, startPos, size, TRgb(0xff00ff));

  1063 	

  1064 	startPos.iX = 6;

  1065 	startPos.iY = surfaceHeight - size.iWidth;

  1066 	size.iWidth = surfaceWidth - 12;

  1067 	size.iHeight = 5;

  1068 	// Top

  1069 	FillRectangleL(aSurface, startPos, size, TRgb(0xaaaaaa));

  1070 	

  1071 	startPos.iX = 6;

  1072 	startPos.iY = 0;

  1073 	// Bottom

  1074 	FillRectangleL(aSurface, startPos, size, TRgb(0x000080));

  1075 	}

  1076 

  1077 

  1078 template <class TIntType> void

  1079 DdaLine(TUint aX1, TUint aY1,TUint aX2,TUint aY2, TUint aPixPerScan, TIntType* aBuffer, TIntType aColor)

  1080 	{

  1081 	TInt dx=aX2-aX1;

  1082 	TInt dy=aY2-aY1;

  1083 	TInt adx=dx,sdx=1;

  1084 	if (adx<0)

  1085 		{	adx=-adx; sdx=-1;	}

  1086 	TInt ady=dy,sdy=aPixPerScan;

  1087 	if (ady<0)

  1088 		{	ady=-ady; sdy=-aPixPerScan;	}

  1089 	//This is simplistic integert DDA.

  1090 	//The vertical cases are handled by this 1/2 accumulator:

  1091 	//	If adx is zero then we step in sdy indefinitely

  1092 	//  If ady is zero then we step in sdx indefinitely

  1093 	TInt accum=adx/2;

  1094 	

  1095 	TIntType* bufferend=aBuffer+aX2+aY2*aPixPerScan;

  1096 	aBuffer+=aX1+aY1*aPixPerScan;

  1097 	*aBuffer=aColor;

  1098 	while (aBuffer!=bufferend)

  1099 		{

  1100 		if (accum>0)

  1101 			{

  1102 			accum-=ady;

  1103 			aBuffer+=sdx;

  1104 			}

  1105 		else

  1106 			{

  1107 			accum+=adx;

  1108 			aBuffer+=sdy;

  1109 			}

  1110 		*aBuffer=aColor;

  1111 		}

  1112 	

  1113 

  1114 	}

  1115 template <class TIntType> void	

  1116 FanFill(const TPoint& aInnerXY,TUint aPixPerScan, TIntType* aSurfacePtr, TIntType aLinesTL, 

  1117 			TIntType aLinesBR, TIntType aLinesTR, TIntType aLinesBL)

  1118 	{

  1119 	

  1120 		DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*180/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);

  1121 		DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*372/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);

  1122 		DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*591/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);

  1123 		DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*859/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);

  1124 

  1125 		DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesTR);

  1126 		DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesTR);

  1127 		DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesTR);

  1128 		DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesTR);

  1129 		

  1130 		DdaLine(0,aInnerXY.iY,aInnerXY.iX*180/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);

  1131 		DdaLine(0,aInnerXY.iY,aInnerXY.iX*372/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);

  1132 		DdaLine(0,aInnerXY.iY,aInnerXY.iX*591/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);

  1133 		DdaLine(0,aInnerXY.iY,aInnerXY.iX*859/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);

  1134 

  1135 		DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesBL);