Add MMP files to build libOpenVG_sw.lib which uses LINKAS to redirect to libOpenVG.dll (and
the same for libEGL_sw.lib and libOpenVGU_sw.lib).
Only the libEGL_sw.lib redirection isn't activated - this can't happen until there is a merged
libEGL.dll which supports the OpenWF synchronisation and also implements the graphical support functions.
The overall aim is to eliminate the *_sw.dll implementations, at least as a compile-time way of choosing
a software-only implementation.The correct way to choose is to put the right set of libraries into a ROM
with suitable renaming, and in the emulator to use the "switching DLL" technique to pick the right set.
As the Symbian Foundation doesn't have any alternative implementations, we don't need the switching DLLs
and we can build directly to the correct name.
// 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/*=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();
}
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());
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
// Copy the data from the bitmap into the surface.
TPoint start;
TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
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(pSurfStart + 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
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
// Copy the data from the bitmap into the surface.
TPoint start;
TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
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(pSurfStart + 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, 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();
RSurfaceManager::TInfoBuf infoBuf;
RSurfaceManager::TSurfaceInfoV01& infoSurf = infoBuf();
User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
TSize size = infoSurf.iSize;
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());
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
// Copy the data from the bitmap into the surface.
TPoint start;
TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
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(pSurfStart + start.iY * stride, stride);
bitmap->GetScanLine(ptr, start, size.iWidth, bmpFormat);
}
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();
}
/**
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;
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 = iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
if (err!=KErrNone)
LOG(("Error submitting update: 0x%X\n", err));
CleanupStack::PopAndDestroy(/* chunk */);
}
/**
Fill the given memory chunk with a color.
@param aSurface The surface to be filled.
@param aChunk The surface to be filled.
@param aColor The color to fill it with.
*/
void CSurfaceUtility::FillChunkL(TSurfaceId& aSurface, RChunk& aChunk, const TRgb& aColor, TInt aBufferNumber)
{
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;
}
}
User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
TInt offsetToBufferNumber;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, aBufferNumber, offsetToBufferNumber));
TUint8* chunkPtr = aChunk.Base() + offsetToFirstBuffer;
TUint8* linePtr = aChunk.Base() + offsetToBufferNumber;
TUint8* surfPlanePtr = linePtr;
if (use16)
{
if ( info.iSize.iWidth*2>info.iStride)
{
aChunk.Close();
User::Leave(KErrOverflow);
}
TUint16* ptr = reinterpret_cast<TUint16*>(surfPlanePtr);
// Fill first line
for (TInt xx = 0; xx < info.iSize.iWidth; xx++)
{
ptr[xx] = (TUint16)color;
}
}
else
{
if ( info.iSize.iWidth*4>info.iStride)
{
aChunk.Close();
User::Leave(KErrOverflow);
}
TUint32* ptr = reinterpret_cast<TUint32*>(surfPlanePtr);
// 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, surfPlanePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
}
aChunk.Close();
}
/**
Fill a rectangle on the given surface.
@param aSurface The surface to be filled.
@param aStartPos Where to place the rectangle.
@param aSize Size of the rectangle.
@param aColor The colour to fill it with.
*/
void CSurfaceUtility::FillRectangleL(TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, const TRgb& aColor)
{
FillRectangleNoUpdateL(aSurface, aStartPos, aSize, aColor);
TInt err = iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
if (err!=KErrNone)
LOG(("Error submitting update: 0x%X\n", err));
}
/**
Fill a rectangle on the given surface - does not submit update.
@param aSurface The surface to be filled.
@param aStartPos Where to place the rectangle.
@param aSize Size of the rectangle.
@param aColor The colour to fill it with.
*/
void CSurfaceUtility::FillRectangleNoUpdateL(TSurfaceId& aSurface, const TPoint& aStartPos, const TSize& aSize, 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;
// Check for out of bounds
TBool validRect = ETrue;
TInt surfaceWidth = info.iSize.iWidth;
TInt surfaceHeight = info.iSize.iHeight;
// Width and Height
if ((aStartPos.iX + aSize.iWidth) > surfaceWidth)
validRect = EFalse;
if ((aStartPos.iY + aSize.iHeight) > surfaceHeight)
validRect = EFalse;
// Starting position
if ((aStartPos.iX < 0) || (aStartPos.iY < 0))
validRect = EFalse;
if (!validRect)
User::Leave(KErrOverflow);
if (use16)
{
if ( info.iSize.iWidth*2>info.iStride)
{
User::Leave(KErrOverflow);
}
TUint16* ptr = reinterpret_cast<TUint16*>(surfacePtr);
// Fill the rectangle
TInt yPos = aStartPos.iY;
TInt xPos = aStartPos.iX;
for (TInt yy = 0; yy < aSize.iHeight; ++yy)
{
ptr = reinterpret_cast<TUint16*>(surfacePtr+(yPos*info.iStride));
for (TInt xx = 0; xx < aSize.iWidth; ++xx)
{
ptr[xPos] = color;
xPos++;
}
xPos = aStartPos.iX;
yPos++;
}
}
else
{
if ( info.iSize.iWidth*4>info.iStride)
{
User::Leave(KErrOverflow);
}
TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);
// Fill the rectangle
TInt yPos = aStartPos.iY;
TInt xPos = aStartPos.iX;
for (TInt yy = 0; yy < aSize.iHeight; ++yy)
{
ptr = reinterpret_cast<TUint32*>(surfacePtr+(yPos*info.iStride));
for (TInt xx = 0; xx < aSize.iWidth; ++xx)
{
ptr[xPos] = color;
xPos++;
}
xPos = aStartPos.iX;
yPos++;
}
}
CleanupStack::PopAndDestroy(/* chunk */);
}
/**
Fill the given surface with a grid over a solid color.
Similar to FillSurfaceL(), but with a grid overlayed. The pitch of the grid is
eight pixels.
@param aSurface The surface to be filled.
@param aColor The color to fill it with.
@param aLines The color of the grid lines.
*/
void CSurfaceUtility::GridFillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor, const TRgb& aLines)
{
RSurfaceManager::TInfoBuf infoBuf;
RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
TUint32 color = 0;
TUint32 lines = 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();
lines = aLines.Color16MU();
#ifdef ALPHA_FIX_24BIT
color |= ((ALPHA_FIX_24BIT)&0xff)<<24;
lines |= ((ALPHA_FIX_24BIT)&0xff)<<24;
#endif
break;
}
case EUidPixelFormatARGB_8888:
{
color = aColor.Color16MA();
lines = aLines.Color16MA();
break;
}
case EUidPixelFormatARGB_8888_PRE:
{
color = aColor.Color16MAP();
lines = aLines.Color16MAP();
break;
}
case EUidPixelFormatXRGB_4444:
case EUidPixelFormatARGB_4444:
{
color = aColor.Color4K();
lines = aLines.Color4K();
use16 = ETrue;
break;
}
case EUidPixelFormatRGB_565:
{
color = aColor.Color64K();
lines = aLines.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 xx1 = 0; xx1 < info.iSize.iWidth; xx1++)
{
ptr[xx1] = (TUint16)lines;
}
// Fill second line
ptr = reinterpret_cast<TUint16*>(surfacePtr + info.iStride);
for (TInt xx2 = 0; xx2 < info.iSize.iWidth; xx2++)
{
// Vertical line every 8 pixels across
ptr[xx2] = (TUint16)((xx2 & 7) ? color : lines);
}
}
else
{
if ( info.iSize.iWidth*4>info.iStride)
{
User::Leave(KErrOverflow);
}
TUint32* ptr = reinterpret_cast<TUint32*>(surfacePtr);
// Fill first line
for (TInt xx3 = 0; xx3 < info.iSize.iWidth; xx3++)
{
ptr[xx3] = lines;
}
// Fill second line
ptr = reinterpret_cast<TUint32*>(surfacePtr + info.iStride);
for (TInt xx4 = 0; xx4 < info.iSize.iWidth; xx4++)
{
// Vertical line every 8 pixels across
ptr[xx4] = (xx4 & 7) ? color : lines;
}
}
linePtr += info.iStride;
// Now copy that to the other lines
for (TInt yy = 2; yy < info.iSize.iHeight; yy++)
{
linePtr += info.iStride;
if (yy & 7)
{
// Copy second line
Mem::Copy(linePtr, surfacePtr + info.iStride, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
}
else
{
// Copy first line
Mem::Copy(linePtr, surfacePtr, info.iSize.iWidth * BytesPerPixelL(info.iPixelFormat));
}
}
TInt err =iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
if (err!=KErrNone)
LOG(("Error submitting update: 0x%X\n", err));
CleanupStack::PopAndDestroy(/* chunk */);
}
/**
Fill the given surface with a pattern suitable for automated testing.
@param aSurface The surface to be filled.
*/
void CSurfaceUtility::PatternFillSurfaceL(TSurfaceId& aSurface)
{
RSurfaceManager::TInfoBuf infoBuf;
RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
// Fill the background
FillSurfaceL(aSurface, TRgb(0x00000000));
TInt surfaceWidth = info.iSize.iWidth;
TInt surfaceHeight = info.iSize.iHeight;
// Create the 4 rectangles in the corners
TPoint startPos(0,0);
TSize size(15,15);
TInt rectWidth = size.iWidth;
TInt rectHeight = size.iHeight;
// Top left
FillRectangleL(aSurface, startPos, size, TRgb(0x0000ff));
// Top right
startPos.iX = surfaceWidth - rectWidth;
startPos.iY = 0;
FillRectangleL(aSurface, startPos, size, TRgb(0x00ff00));
// Bottom left
startPos.iX = 0;
startPos.iY = surfaceHeight - rectHeight;
FillRectangleL(aSurface, startPos, size, TRgb(0x00ffff));
// Bottom right
startPos.iX = surfaceWidth - rectWidth;
startPos.iY = surfaceHeight - rectHeight;
FillRectangleL(aSurface, startPos, size, TRgb(0xffffff));
// Create the 4 side bars
startPos.iX = 0;
startPos.iY = 6;
size.iWidth = 5;
size.iHeight = surfaceHeight - 12;
// Left
FillRectangleL(aSurface, startPos, size, TRgb(0x808000));
startPos.iX = surfaceWidth - size.iWidth;
startPos.iY = 6;
// Right
FillRectangleL(aSurface, startPos, size, TRgb(0xff00ff));
startPos.iX = 6;
startPos.iY = surfaceHeight - size.iWidth;
size.iWidth = surfaceWidth - 12;
size.iHeight = 5;
// Top
FillRectangleL(aSurface, startPos, size, TRgb(0xaaaaaa));
startPos.iX = 6;
startPos.iY = 0;
// Bottom
FillRectangleL(aSurface, startPos, size, TRgb(0x000080));
}
template <class TIntType> void
DdaLine(TUint aX1, TUint aY1,TUint aX2,TUint aY2, TUint aPixPerScan, TIntType* aBuffer, TIntType aColor)
{
TInt dx=aX2-aX1;
TInt dy=aY2-aY1;
TInt adx=dx,sdx=1;
if (adx<0)
{ adx=-adx; sdx=-1; }
TInt ady=dy,sdy=aPixPerScan;
if (ady<0)
{ ady=-ady; sdy=-aPixPerScan; }
//This is simplistic integert DDA.
//The vertical cases are handled by this 1/2 accumulator:
// If adx is zero then we step in sdy indefinitely
// If ady is zero then we step in sdx indefinitely
TInt accum=adx/2;
TIntType* bufferend=aBuffer+aX2+aY2*aPixPerScan;
aBuffer+=aX1+aY1*aPixPerScan;
*aBuffer=aColor;
while (aBuffer!=bufferend)
{
if (accum>0)
{
accum-=ady;
aBuffer+=sdx;
}
else
{
accum+=adx;
aBuffer+=sdy;
}
*aBuffer=aColor;
}
}
template <class TIntType> void
FanFill(const TPoint& aInnerXY,TUint aPixPerScan, TIntType* aSurfacePtr, TIntType aLinesTL,
TIntType aLinesBR, TIntType aLinesTR, TIntType aLinesBL)
{
DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*180/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*372/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*591/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,aInnerXY.iX-aInnerXY.iX*859/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(aInnerXY.iX,0,0,aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesTR);
DdaLine(0,aInnerXY.iY,aInnerXY.iX*180/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX*372/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX*591/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX*859/1024,0,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,aInnerXY.iY,aInnerXY.iX,aInnerXY.iY-aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesBL);
DdaLine(0,0,aInnerXY.iX*180/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX*372/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX*591/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX*859/1024,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*180/1024,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*372/1024,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*591/1024,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,0,aInnerXY.iX,aInnerXY.iY*859/1024,aPixPerScan,aSurfacePtr,aLinesTL);
DdaLine(0,aInnerXY.iY-aInnerXY.iY*180/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(0,aInnerXY.iY-aInnerXY.iY*372/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(0,aInnerXY.iY-aInnerXY.iY*591/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(0,aInnerXY.iY-aInnerXY.iY*859/1024,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(aInnerXY.iX-aInnerXY.iX*180/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(aInnerXY.iX-aInnerXY.iX*372/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(aInnerXY.iX-aInnerXY.iX*591/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
DdaLine(aInnerXY.iX-aInnerXY.iX*859/1024,0,aInnerXY.iX,aInnerXY.iY,aPixPerScan,aSurfacePtr,aLinesBR);
}
/**
Fill the given surface with a fan of lines over a solid color.
Similar to FillSurfaceL(), but with a fan of lines overlayed.
One fan is drawn about the top-left, and second fan at bottom-right.
The fan contains 8 segments.
@param aSurface The surface to be filled.
@param aColor The color to fill it with.
@param aLines The color of the grid lines.
*/
void CSurfaceUtility::FanFillSurfaceL(TSurfaceId& aSurface, const TRgb& aColor, const TRgb& aLinesTL, const TRgb& aLinesBR)
{
FillSurfaceL(aSurface,aColor);
RSurfaceManager::TInfoBuf infoBuf;
RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
TUint32 linesTL = 0;
TUint32 linesBR = 0;
TUint32 linesTR = 0;
TUint32 linesBL = 0;
TBool use16 = EFalse;
TRgb rgbLinesTR(0,0,0);
TRgb rgbLinesBL(255,255,255);
switch (info.iPixelFormat)
{
case EUidPixelFormatXRGB_8888:
{
linesBR = aLinesBR.Color16MU();
linesTL = aLinesTL.Color16MU();
linesTR = rgbLinesTR.Color16MU();
linesBL = rgbLinesBL.Color16MU();
#ifdef ALPHA_FIX_24BIT
linesBR |= ((ALPHA_FIX_24BIT)&0xff)<<24;
linesTL |= ((ALPHA_FIX_24BIT)&0xff)<<24;
linesTR |= ((ALPHA_FIX_24BIT)&0xff)<<24;
linesBL |= ((ALPHA_FIX_24BIT)&0xff)<<24;
#endif
break;
}
case EUidPixelFormatARGB_8888:
{
linesBR = aLinesBR.Color16MA();
linesTL = aLinesTL.Color16MA();
linesTR = rgbLinesTR.Color16MA();
linesBL = rgbLinesBL.Color16MA();
break;
}
case EUidPixelFormatARGB_8888_PRE:
{
linesBR = aLinesBR.Color16MAP();
linesTL = aLinesTL.Color16MAP();
linesTR = rgbLinesTR.Color16MAP();
linesBL = rgbLinesBL.Color16MAP();
break;
}
case EUidPixelFormatXRGB_4444:
case EUidPixelFormatARGB_4444:
{
linesBR = aLinesBR.Color4K();
linesTL = aLinesTL.Color4K();
linesTR = rgbLinesTR.Color4K();
linesBL = rgbLinesBL.Color4K();
use16 = ETrue;
break;
}
case EUidPixelFormatRGB_565:
{
linesBR = aLinesBR.Color64K();
linesTL = aLinesTL.Color64K();
linesTR = rgbLinesTR.Color64K();
linesBL = rgbLinesBL.Color64K();
use16 = ETrue;
break;
}
default:
{
User::Leave(KErrNotSupported);
break;
}
}
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);
}
RChunk chunk;
User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
CleanupClosePushL(chunk);
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
TPoint innerXY(info.iSize.iWidth-1,info.iSize.iHeight-1);
if (use16)
{
if ( info.iSize.iWidth*2>info.iStride)
{
User::Leave(KErrOverflow);
}
FanFill<TUint16>(innerXY,info.iStride/2,(TUint16*)surfacePtr,linesTL,linesBR,linesBL,linesTR);
}
else
{
if ( info.iSize.iWidth*4>info.iStride)
{
User::Leave(KErrOverflow);
}
FanFill<TUint>(innerXY,info.iStride/4,(TUint*)surfacePtr,linesTL,linesBR,linesBL,linesTR);
}
iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
CleanupStack::PopAndDestroy(/* chunk */);
}
/**
Fill the given surface with vertical line at the given position
Similar to FillSurfaceL(), but with a vertical line overlayed.
The position along the surface is given as a percentage from the left
@param aSurface The surface to be filled.
@param aColor The color to fill it with.
@param aLine The color of the line.
@param aPosition Position of the vertical line given as a percentage across the surface from the left edge
*/
void CSurfaceUtility::LineFillSurfaceL(TSurfaceId& aSurface, const TRgb& aBackColor, const TRgb& aLineColor, TInt aPosition)
{
if (aPosition<0 || aPosition>100)
{
aPosition=0;
}
FillSurfaceL(aSurface,aBackColor);
RSurfaceManager::TInfoBuf infoBuf;
RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
TUint32 lineColor = 0;
TBool use16 = EFalse;
switch (info.iPixelFormat)
{
case EUidPixelFormatXRGB_8888:
{
lineColor = aLineColor.Color16MU();
#ifdef ALPHA_FIX_24BIT
lineColor |= ((ALPHA_FIX_24BIT)&0xff)<<24;
#endif
break;
}
case EUidPixelFormatARGB_8888:
{
lineColor = aLineColor.Color16MA();
break;
}
case EUidPixelFormatARGB_8888_PRE:
{
lineColor = aLineColor.Color16MAP();
break;
}
case EUidPixelFormatXRGB_4444:
case EUidPixelFormatARGB_4444:
{
lineColor = aLineColor.Color4K();
use16 = ETrue;
break;
}
case EUidPixelFormatRGB_565:
{
lineColor = aLineColor.Color64K();
use16 = ETrue;
break;
}
default:
{
User::Leave(KErrNotSupported);
break;
}
}
RChunk chunk;
User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
if (use16)
{
DdaLine<TUint16>((info.iSize.iWidth*aPosition)/100,0,(info.iSize.iWidth*aPosition)/100,
info.iSize.iHeight-1,info.iStride/2,(TUint16*)surfacePtr,lineColor);
}
else
{
DdaLine<TUint>((info.iSize.iWidth*aPosition)/100,0,(info.iSize.iWidth*aPosition)/100,
info.iSize.iHeight-1,info.iStride/4,(TUint*)surfacePtr,lineColor);
}
chunk.Close();
iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
}
/**
* Generates a bitmap equivalent to the surface.
* Can reuse an existing bitmap or create a new bitmap.
* The existing bitmap must be an exact match (eg previously generated by this method)
**/
CFbsBitmap* CSurfaceUtility::EquivalentBitmapL(TSurfaceId& aSurface,CFbsBitmap* aCopyToMayBeNull)
{
RSurfaceManager::TInfoBuf infoBuf;
RSurfaceManager::TSurfaceInfoV01& info = infoBuf();
User::LeaveIfError(iManager.SurfaceInfo(aSurface, infoBuf));
TInt bytesPerPixel=0;
TDisplayMode bitmapMode = ENone;
switch (info.iPixelFormat)
{
case EUidPixelFormatXRGB_8888:
{
bitmapMode = EColor16MU;
bytesPerPixel = 4;
break;
}
case EUidPixelFormatARGB_8888:
{
bitmapMode=EColor16MA;
bytesPerPixel = 4;
break;
}
case EUidPixelFormatARGB_8888_PRE:
{
bitmapMode=EColor16MAP;
bytesPerPixel = 4;
break;
}
case EUidPixelFormatXRGB_4444:
case EUidPixelFormatARGB_4444:
{
bitmapMode=EColor4K;
bytesPerPixel = 2;
break;
}
case EUidPixelFormatRGB_565:
{
bitmapMode=EColor64K;
bytesPerPixel = 2;
break;
}
default:
{
User::Leave(KErrNotSupported);
break;
}
}
CFbsBitmap* retVal=NULL;
if (aCopyToMayBeNull)
{
retVal=aCopyToMayBeNull;
if (retVal->SizeInPixels()!=info.iSize)
User::Leave(KErrCorrupt);
if (retVal->DisplayMode()!=bitmapMode)
User::Leave(KErrCorrupt);
}
else
{
retVal=new CFbsBitmap;
CleanupStack::PushL(retVal);
User::LeaveIfError(retVal->Create(info.iSize,bitmapMode));
}
RChunk chunk;
CleanupClosePushL(chunk);
User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
TUint8* surfacePtr = chunk.Base() + offsetToFirstBuffer;
TUint8* bitmapPtr = (TUint8*)retVal->DataAddress();
TInt copyBytes=info.iSize.iWidth*bytesPerPixel;
for (TInt y=0;y<info.iSize.iHeight;y++)
{
Mem::Copy(bitmapPtr,surfacePtr,copyBytes);
surfacePtr+=info.iStride;
bitmapPtr+=retVal->DataStride();
}
CleanupStack::PopAndDestroy(&chunk);
if (!aCopyToMayBeNull)
CleanupStack::Pop(retVal);
return retVal;
}
/**
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.*/
void CSurfaceUtility::SubmitUpdate(TInt aScreenNumber, const TSurfaceId& aSurface, const TRegion* aRegion,TInt aBufferNumber)
{
TInt err =iSurfaceUpdateSession.SubmitUpdate(aScreenNumber, aSurface, aBufferNumber, aRegion);
if (err!=KErrNone)
LOG(("Error submitting update: 0x%X\n", err));
}
/**
Map and submit an update to a surface to the update server.
@param aChunk The chunk of memory to be mapped
@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.*/
void CSurfaceUtility::MapAndSubmitUpdateL(RChunk& aChunk,
TInt aScreenNumber,
const TSurfaceId& aSurface,
const TRegion* aRegion)
{
User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));
aChunk.Close();
TInt err =iSurfaceUpdateSession.SubmitUpdate(aScreenNumber, aSurface, 0, aRegion);
if (err!=KErrNone)
LOG(("Error submitting update: 0x%X\n", err));
}
void CSurfaceUtility::MapSurfaceL(const TSurfaceId& aSurface, RChunk& aChunk)
{
User::LeaveIfError(iManager.MapSurface(aSurface, aChunk));
}
void CSurfaceUtility::CopyBitmapToSurfaceL(TSurfaceId& aSurface, const CFbsBitmap& aBitmap)
{
TSize size = SurfaceSize(aSurface);
TDisplayMode bmpFormat = aBitmap.DisplayMode();
TInt stride = size.iWidth * 4; // Default to four bytes per pixel
RChunk chunk;
User::LeaveIfError(iManager.MapSurface(aSurface, chunk));
CleanupClosePushL(chunk);
TInt offsetToFirstBuffer;
User::LeaveIfError(iManager.GetBufferOffset(aSurface, 0, offsetToFirstBuffer));
// Copy the data from the bitmap into the surface.
TPoint start;
TUint8 *pSurfStart = chunk.Base() + offsetToFirstBuffer;
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(pSurfStart + start.iY * stride, stride);
aBitmap.GetScanLine(ptr, start, size.iWidth, bmpFormat);
}
TInt err =iSurfaceUpdateSession.SubmitUpdate(0, aSurface, 0, NULL);
if (err!=KErrNone)
{
LOG(("Error submitting update: 0x%X\n", err));
}
CleanupStack::PopAndDestroy(/* chunk */);
}