diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/te_graphicsperformanceSuiteStepBase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/te_graphicsperformanceSuiteStepBase.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,710 @@ +// Copyright (c) 2005-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 + @test + @internalComponent - Internal Symbian test code +*/ + +#include "te_graphicsperformanceSuiteStepBase.h" +#include "te_graphicsperformanceSuiteDefs.h" +#include +#include +#include +#include +#include +#include +#include + +#ifdef _USE_PROFILER +#include +#endif + +#ifdef __WINS__ +_LIT(KBitmapDrive, "c:"); +#else +_LIT(KBitmapDrive, "e:"); +#endif +_LIT(KBitmapPath, "\\uibench_sanity\\%S.mbm"); + +/** +Gets the size of the hardware display in pixels +@return TSize object containing the screen size +*/ +TSize GetDisplaySizeInPixels() + { + TInt x; + HAL::Get(HALData::EDisplayXPixels, x); // Get number x pixel of screen + TInt y; + HAL::Get(HALData::EDisplayYPixels, y); // Get number y pixel of screen + return TSize(x,y); + } + +/** +Returns the size of the target used for off-screen drawing +@return TSize object containing the pixmap size. +*/ +TSize GetPixmapSizeInPixels() + { + return TSize(1000, 1000); + } + +/** +Create a new virtual bitmap device +*/ +CVirtualBitmapDevice* CVirtualBitmapDevice::NewL(TDisplayMode aDisplayMode, TBool aForceOffscreen) + { + CVirtualBitmapDevice* self = new(ELeave) CVirtualBitmapDevice(); + CleanupStack::PushL(self); + self->ConstructL(aDisplayMode, aForceOffscreen); + CleanupStack::Pop(self); + return self; + } + +/* +@param aDisplayMode The displaymode of the bitmap to create. +@param aForceOffscreen If ETrue, a bitmap device is created instead of a screen device, regardless + of whether the screen supports the display mode. +*/ +void CVirtualBitmapDevice::ConstructL(TDisplayMode aDisplayMode, TBool aForceOffscreen) + { + // Attempt to create a screen device if not asked to use offscreen bitmap. + CFbsScreenDevice* screenDevice = NULL; + TInt ret = KErrNone; + + if (!aForceOffscreen) + { + TRAP(ret, screenDevice = CFbsScreenDevice::NewL(_L("scdv"), aDisplayMode)); + } + + if (aForceOffscreen || ret != KErrNone) + { + // Screen device cannot be created, or we didn't want one, so create an off screen bitmap device + iBitmap = new(ELeave) CFbsBitmap; + TSize scsize= (aForceOffscreen) ? GetPixmapSizeInPixels() : GetDisplaySizeInPixels(); + iBitmap->Create(scsize, aDisplayMode); + iBitmapDevice = CFbsBitmapDevice::NewL(iBitmap); + iIsScreenDevice = EFalse; + } + else + { + screenDevice->SetAutoUpdate(ETrue); + iBitmapDevice = screenDevice; + iIsScreenDevice = ETrue; + } + } + +int CVirtualBitmapDevice::CreateContext(CGraphicsContext *&aGc) + { + return iBitmapDevice->CreateContext(aGc); + } + +TSize CVirtualBitmapDevice::SizeInPixels() const + { + return iBitmapDevice->SizeInPixels(); + } + + +TInt CVirtualBitmapDevice::isScreenDevice() + { + return iIsScreenDevice; + } + +CVirtualBitmapDevice::~CVirtualBitmapDevice() + { + delete iBitmapDevice; + delete iBitmap; + } + + +/** +Implements the same method on CFbsScreenDevice to Update the screen. This only works on a screen device. +Off screen bitmaps do not have to be updated and no action will be taken in this case. +*/ +void CVirtualBitmapDevice::Update() + { + if (iIsScreenDevice) + { + CFbsScreenDevice* screenDevice = static_cast(iBitmapDevice); + if (screenDevice) + screenDevice->Update(); + } + } + +/** +Returns the actual bitmap device +*/ +CBitmapDevice& CVirtualBitmapDevice::BitmapDevice() + { + return *iBitmapDevice; + } + +/** +Returns the actual bitmap +*/ +CFbsBitmap& CVirtualBitmapDevice::Bitmap() + { + return *iBitmap; + } + +/** +Create a new virtual draw device +*/ +CVirtualDrawDevice* CVirtualDrawDevice::NewL(TDisplayMode aDisplayMode) + { + CVirtualDrawDevice* self = new(ELeave) CVirtualDrawDevice(); + CleanupStack::PushL(self); + self->ConstructL(aDisplayMode); + CleanupStack::Pop(self); + return self; + } + +void CVirtualDrawDevice::ConstructL(TDisplayMode aDisplayMode) + { + // Attempt to create a screen device + CFbsDrawDevice* drawDevice = NULL; + TRAPD(ret, drawDevice = CFbsDrawDevice::NewScreenDeviceL(KDefaultScreenNo, aDisplayMode)); + if (ret != KErrNone) + { + // Screen device cannot be created so create an off screen bitmap draw device + iSize = GetDisplaySizeInPixels(); + iDrawDevice = CFbsDrawDevice::NewBitmapDeviceL(iSize, aDisplayMode, ByteSize(iSize, aDisplayMode) / iSize.iHeight); + iDeviceMemory = new (ELeave) TUint8[ByteSize(iSize, aDisplayMode)]; + iDrawDevice->SetBits(iDeviceMemory); + iIsDrawDevice = EFalse; + } + else + { + iDrawDevice = drawDevice; + iSize = iDrawDevice->SizeInPixels(); + iDrawDevice->SetAutoUpdate(ETrue); + iIsDrawDevice = ETrue; + } + } + +TInt CVirtualDrawDevice::ByteSize(const TSize& aSize, TDisplayMode aDisplayMode) + { + TInt wordSize = aSize.iWidth; + switch(aDisplayMode) + { + case EGray2: + wordSize = (wordSize + 31) / 32; + break; + case EGray4: + wordSize = (wordSize + 15) / 16; + break; + case EGray16: + case EColor16: + wordSize = (wordSize + 7) / 8; + break; + case EGray256: + case EColor256: + wordSize = (wordSize + 3) / 4; + break; + case EColor4K: + case EColor64K: + wordSize = (wordSize + 1) / 2; + break; + case EColor16M: + wordSize = (((wordSize * 3) + 11) / 12) * 3; + break; + case EColor16MU: + case EColor16MA: + //Should not be changed! + break; + default: + break; + }; + return wordSize * aSize.iHeight * 4; + } + +CFbsDrawDevice& CVirtualDrawDevice::DrawDevice() + { + return *iDrawDevice; + } + +CVirtualDrawDevice::~CVirtualDrawDevice() + { + delete iDrawDevice; + delete[] iDeviceMemory; + } + +TBool CVirtualDrawDevice::IsDrawDevice() + { + return iIsDrawDevice; + } + +const TDesC& CTe_graphicsperformanceSuiteStepBase::ColorModeName(TDisplayMode aMode) + { + _LIT(KColor4K,"Color4K"); + _LIT(KColor64K,"Color64K"); + _LIT(KColor16M,"Color16M"); + _LIT(KColor16MU,"Color16MU"); + _LIT(KColor16MA,"Color16MA"); + _LIT(KColor16MAP,"Color16MAP"); + _LIT(KUnknown,"Unknown"); + switch(aMode) + { + case EColor4K: + return KColor4K; + case EColor64K: + return KColor64K; + case EColor16M: + return KColor16M; + case EColor16MU: + return KColor16MU; + case EColor16MA: + return KColor16MA; + case EColor16MAP: + return KColor16MAP; + default: + return KUnknown; + } + } + +/** +Implementation of CTestStep base class virtual +It is used for doing all initialisation common to derived classes in here. +Make it being able to leave if there are any errors here as there's no point in +trying to run a test step if anything fails. +The leave will be picked up by the framework. + +@return - TVerdict +*/ +TVerdict CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL() + { + SetTestStepResult(EPass); + + // Create and install Active Scheduler in case tests require active objects + iScheduler = new(ELeave) CActiveScheduler; + CActiveScheduler::Install(iScheduler); + + FbsStartup(); + TESTNOERRORL(RFbsSession::Connect()); + HAL::Get(HALData::ECPUSpeed,iCPUSpeed); + INFO_PRINTF2(_L("CPUSpeed: %i kHz"),iCPUSpeed); + + // get input for tests from .ini file + TEST(GetIntFromConfig(_L("Profiling"), _L("DoProfiling"), iDoProfiling)); + TEST(GetBoolFromConfig(_L("SanityCheck"), _L("Bitmaps"), iShowBitmaps)); + + if (iDoProfiling>0) + { + __INITPROFILER + } + + iProfiler = CTProfiler::NewL(*this); + __UHEAP_MARK; + return TestStepResult(); + } + +/** +Implementation of CTestStep base class virtual +It is used for doing all after test treatment common to derived classes in here. +Make it being able to leave +The leave will be picked up by the framework. + +@return - TVerdict +*/ + TVerdict CTe_graphicsperformanceSuiteStepBase::doTestStepPostambleL() + { + delete iScheduler; + iScheduler = NULL; + delete iProfiler; + iProfiler = NULL; + return TestStepResult(); + } + +CTe_graphicsperformanceSuiteStepBase::~CTe_graphicsperformanceSuiteStepBase() + { + if (iDoProfiling>0) + { + __CLEANUPPROFILER + } + delete iScreenDevice; + delete iGc; + delete iDrawDevice; + RFbsSession::Disconnect(); + __UHEAP_MARKEND; + } + +CTe_graphicsperformanceSuiteStepBase::CTe_graphicsperformanceSuiteStepBase() + { + } + +CVirtualBitmapDevice* CTe_graphicsperformanceSuiteStepBase::ScreenDevice() + { + TEST(iScreenDevice!=NULL); // Ensure it is valid + return iScreenDevice; + } + +/** +Destroys and recreates the current target device. + +@param aScreenMode The display mode of the target being created +@param aForceOffscreen If ETrue, an offscreen buffer is used as the target instead of the screen. The + dimensions of the buffer are retrieved from GetPixmapSizeInPixels. +*/ +void CTe_graphicsperformanceSuiteStepBase::SetScreenModeL(TDisplayMode aScreenMode, TBool aForceOffscreen) + { + delete iScreenDevice; + iScreenDevice = NULL; + + iScreenDevice = CVirtualBitmapDevice::NewL(aScreenMode, aForceOffscreen); + if (iScreenDevice->isScreenDevice()) + { + INFO_PRINTF2(_L("SetScreenMode - supported: %S"),&ColorModeName(aScreenMode)); + } + else + { + if (!aForceOffscreen) + { + INFO_PRINTF2(_L("SetScreenMode - not supported(using off screen bitmap instead): %S"),&ColorModeName(aScreenMode)); + } + else + { + INFO_PRINTF2(_L("SetScreenMode - using off screen bitmap as requested: %S"),&ColorModeName(aScreenMode)); + } + } + delete iGc; + iGc = NULL; + User::LeaveIfError(iScreenDevice->CreateContext((CGraphicsContext*&)iGc)); + iScreenSize = iScreenDevice->SizeInPixels(); + } + +void CTe_graphicsperformanceSuiteStepBase::SetDrawDeviceModeL(TDisplayMode aScreenMode) + { + delete iDrawDevice; + iDrawDevice = NULL; + + iDrawDevice = CVirtualDrawDevice::NewL(aScreenMode); + if (iDrawDevice->IsDrawDevice()) + { + INFO_PRINTF2(_L("SetDrawDeviceMode - supported: %S"),&ColorModeName(aScreenMode)); + } + else + { + INFO_PRINTF2(_L("SetDrawDeviceMode - not supported(using off screen bitmap instead): %S"),&ColorModeName(aScreenMode)); + } + } + +TInt CTe_graphicsperformanceSuiteStepBase::GetDrawDeviceInterfaceL(TInt aInterfaceId, TAny*& aInterface) + { + User::LeaveIfNull(iDrawDevice); + return iDrawDevice->DrawDevice().GetInterface(aInterfaceId, aInterface); + } + +void CTe_graphicsperformanceSuiteStepBase::ClearDrawDeviceL(TRgb aColor) + { + User::LeaveIfNull(iDrawDevice); + CFbsDrawDevice& drawDevice = iDrawDevice->DrawDevice(); + TSize size = drawDevice.SizeInPixels(); + drawDevice.SetShadowMode(CFbsDrawDevice::ENoShadow); + drawDevice.WriteRgbMulti(0,0,size.iWidth,size.iHeight,aColor,CGraphicsContext::EDrawModePEN); + } + +/** +Creates a bitmap for given size and display mode and leaves it on the cleanup stack + +@return pointer to a created CFbsBitmap +*/ +CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::CreateSoftwareBitmapLC(const TSize& aSize, TDisplayMode aMode) + { + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Create(aSize, aMode)); + return bitmap; + } + +/** +Copy a bitmap into another bitmap (generally in a different displaymode) +tiles destination bitmap with source +*/ +void CTe_graphicsperformanceSuiteStepBase::CopyBitmapL(CFbsBitmap* aDst, CFbsBitmap* aSrc) + { + TSize srcSize = aSrc->SizeInPixels(); + TSize dstSize = aDst->SizeInPixels(); + CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL(aDst); + CleanupStack::PushL(dev); + CFbsBitGc* gc = NULL; + if ( 0 == dev->CreateContext(gc) ) + { + CleanupStack::PushL(gc); + TPoint point; + gc->SetBrushColor(TRANSPARENT_BLACK); + gc->SetBrushStyle(CGraphicsContext::ENullBrush); + gc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + gc->Clear(); + gc->SetDrawMode(CGraphicsContext::EDrawModePEN); + for(point.iY=0; point.iYBitBlt(point, aSrc); + } + } + CleanupStack::PopAndDestroy(gc); + } + CleanupStack::PopAndDestroy(dev); + } + +/** +Copy a source bitmap into a new bitmap with the specified display mode +*/ +CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::CopyIntoNewBitmapL(CFbsBitmap* aSrc, TDisplayMode aDisplayMode) + { + CFbsBitmap* dstBmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(dstBmp); + TInt ret=dstBmp->Create(aSrc->SizeInPixels(), aDisplayMode); + User::LeaveIfError(ret); + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(dstBmp); + CleanupStack::PushL(bitmapDevice); + CFbsBitGc* gc; + ret = bitmapDevice->CreateContext(gc); + User::LeaveIfError(ret); + CleanupStack::PushL(gc); + gc->BitBlt(TPoint(0,0), aSrc); + CleanupStack::PopAndDestroy(2, bitmapDevice); // gc, bitmapDevice + CleanupStack::Pop(dstBmp); + return dstBmp; + } + +/** +Loads a bitmap from a file + +@param aName the filename of the bitmap to load +@param aIndex the index of the bitmap to load in the file +*/ +CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::LoadBitmapL(const TDesC& aName, TInt aIndex) + { + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + User::LeaveIfError(bitmap->Load(aName, aIndex)); + CleanupStack::Pop(bitmap); + return bitmap; + } + +/** +Interpolates between the two TRgb values aHi and aLo including alpha channel, with the value aX and the denoinator aN +*/ +TRgb CTe_graphicsperformanceSuiteStepBase::InterpolateColour(TRgb aLo, TRgb aHi, TInt aX, TInt aN) + { + TInt y = aN - aX; + + TUint8 a = (TUint8)( (aHi.Alpha()*aX + aLo.Alpha()*y)/aN ); + TUint8 r = (TUint8)( (aHi.Red()*aX + aLo.Red()*y)/aN ); + TUint8 g = (TUint8)( (aHi.Green()*aX + aLo.Green()*y)/aN ); + TUint8 b = (TUint8)( (aHi.Blue()*aX + aLo.Blue()*y)/aN ); + + return TRgb(r, g, b, a); + } + +/** +Draws a VerticalGradient onto a CFbsBitmap from top/color aLo to bottom/aHi +*/ +void CTe_graphicsperformanceSuiteStepBase::VerticalGradientAlphaL(CFbsBitmap* aBitmap, TRgb aLo, TRgb aHi) + { + const TSize size = aBitmap->SizeInPixels(); + const TDisplayMode mode = aBitmap->DisplayMode(); + const TInt scanLineLength = CFbsBitmap::ScanLineLength(size.iWidth, mode); + HBufC8* buffer = HBufC8::NewL(scanLineLength); + CleanupStack::PushL(buffer); + TPtr8 des = buffer->Des(); + des.SetLength(scanLineLength); + for(TInt i=0; iSetScanLine(des, i); + } + CleanupStack::PopAndDestroy(buffer); + } + +/** +Create a checked board +@param aPixelFormat The pixel format for create the target bitmap +@param aSize The size of the bitmap +@param aChecksPerAxis Number of checks on X and Y. + */ +CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::CreateCheckedBoardL(TDisplayMode aDisplayMode, TSize aSize, TSize aChecksPerAxis) const + { + + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + bitmap->Create(aSize, aDisplayMode); + + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmap); + CleanupStack::PushL(bitmapDevice); + + CFbsBitGc* bitGc = NULL; + User::LeaveIfError(bitmapDevice->CreateContext(bitGc)); + CleanupStack::PushL(bitGc); + + bitGc->Clear(); + bitGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + bitGc->SetPenStyle(CGraphicsContext::ENullPen); + TPoint point(0,0); + const TSize checkerSize((TReal)aSize.iWidth/aChecksPerAxis.iWidth,(TReal)aSize.iHeight/aChecksPerAxis.iHeight); + TInt brushColour = 0; + for(point.iY = 0; point.iY < aSize.iHeight; point.iY += checkerSize.iHeight) + { + for(point.iX = 0; point.iX < aSize.iWidth; point.iX += checkerSize.iWidth) + { + bitGc->SetBrushColor(KColor16Table[brushColour++ & 0x0F]); + TRect rect(point, checkerSize); + bitGc->DrawRect(rect); + } + } + + CleanupStack::PopAndDestroy(2, bitmapDevice); + CleanupStack::Pop(bitmap); + + return bitmap; + } + +/* +Creates a new CFbsBitmap representing the screen/off-screen bitmap. It is the client's +responsibility to delete it. + +@see CTDirectGdiTestBase::GetTargetAsBitmapL. +@return A pointer to the newly created bitmap. +@leave If there was a problem copying from the source to the target. +*/ +CFbsBitmap* CTe_graphicsperformanceSuiteStepBase::GetTargetAsBitmapL() + { + iScreenDevice->Update(); + CFbsBitmap* bitmapCopy = CopyIntoNewBitmapL(&(iScreenDevice->Bitmap()), iScreenDevice->BitmapDevice().DisplayMode()); + return bitmapCopy; + } + +/** +Creates an mbm file showing the state of the target. + +@param aName The name of the mbm file to produce. Any spaces are replaced by underscores + for easier parsing. +@return KErrNone if bitmap output has been turned off in the config file, or if it was successful. + KErrNoMemory if there is not enough memory to create the bitmap. +*/ +TInt CTe_graphicsperformanceSuiteStepBase::WriteTargetOutput(TPtrC aName) + { + if (!iShowBitmaps) + { + return KErrNone; + } + + CFbsBitmap* target = NULL; + TRAPD(err, target = GetTargetAsBitmapL();) + + if (err != KErrNone) + { + return err; + } + + TBuf fileName; + fileName.Append(aName); + + // replace spaces with underscores. + TInt pos = fileName.Locate(TChar(' ')); + while(pos != KErrNotFound) + { + fileName[pos] = TChar('_'); + pos = fileName.Locate(TChar(' ')); + } + + TFileName mbmFile; + mbmFile.Append(KBitmapDrive); + mbmFile.AppendFormat(KBitmapPath, &fileName); + + err = target->Save(mbmFile); + delete target; + return err; + } + + + +void CTe_graphicsperformanceSuiteStepBase::ExtractListL(TPtrC aList, RArray& aListItems) + { + TPtrC tempBuf = aList; + TInt position = tempBuf.Find(_L(",")); + + while(position != KErrNotFound) + { + aListItems.AppendL(tempBuf.Left(position)); + tempBuf.Set(tempBuf.Mid(position + 2)); + position = tempBuf.Find(_L(",")); + } + + if (position == KErrNotFound) + { + aListItems.AppendL(tempBuf); + } + } +