diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/talphadrawing.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/talphadrawing.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,540 @@ +// 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 "talphadrawing.h" +#include + +// When enabled allows testing with a variable windows size rather than fixed size +#define _TESTWITHVARIABLEWINDOWSIZE + +// Test bitmap file location +_LIT(KAlphaTestBitmap,"z:\\system\\data\\uibench_24bit.mbm"); + +const TInt KIterationsToTest = 100; // Number of iterations to run tests +const TInt KDelay = 100000; // 0.1 seconds +const TInt KRotationGranulatity = 8;// Rotation array granularity + +/** +Clear window to selected colour +*/ +LOCAL_C void ClearWindow(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TRgb aColor) +{ + // clear so we can see bitmap version has completed + aWindow.Invalidate(); + aWindow.BeginRedraw(); + aGc->Activate(aWindow); + aGc->SetBrushColor(aColor); + aGc->Clear(); + aGc->Deactivate(); + aWindow.EndRedraw(); + aSession.Flush(); +} + +/** +Draws a b/w checkerboard onto a RWindow +*/ +LOCAL_C void ChessBoard(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc) + { + const TSize size = aWindow.Size(); + + aGc->Activate(aWindow); + aGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + aGc->SetPenStyle(CGraphicsContext::ENullPen); + + aGc->SetBrushColor(KRgbBlack); + aGc->Clear(); + aGc->SetBrushColor(KRgbWhite); + TInt x0 = 0; + TPoint point; + const TInt checkerSize = 32; + for(point.iY=0; point.iY < size.iHeight; point.iY += checkerSize) + { + for(point.iX=x0; point.iX < size.iWidth; point.iX += checkerSize*2) + { + TRect rect(point, TSize(checkerSize, checkerSize)); + aGc->DrawRect(rect); + } + x0 = checkerSize - x0; + } + aGc->Deactivate(); + aSession.Flush(); + } + +/** +RBlankWindow on top layer gets set visible/invisible to measure timing of drawing the windows below +*/ +void CTAlphaDrawing::DrawBlankWindowL (RWindow& /*aForeGndWin*/, TInt aIters) + { + // Create a blank window that is the size of the screen so that we can set this visible to hide the window underneath + // and then hide it to force redraw of the window underneath + RBlankWindow blankWindow = RBlankWindow(iWsSession); + CleanupClosePushL(blankWindow); + User::LeaveIfError(blankWindow.Construct(iWinGroup, (TInt)this+1)); + blankWindow.SetSize(iScreenDevice->SizeInPixels()); + blankWindow.SetColor(TRgb(0x3399ff)); + blankWindow.Activate(); + +#ifdef _TESTWITHVARIABLEWINDOWSIZE + // Create a small window that moves position + RBlankWindow blankWindow2 = RBlankWindow(iWsSession); + CleanupClosePushL(blankWindow2); + User::LeaveIfError(blankWindow2.Construct(iWinGroup, (TInt)this+2)); + blankWindow2.SetSize(TSize(10,10)); + blankWindow2.SetColor(TRgb(0x99ff33)); + TInt px = iScreenDevice->SizeInPixels().iWidth/2; + TInt py = iScreenDevice->SizeInPixels().iHeight/2; + blankWindow2.SetPosition(TPoint(px, py)); + blankWindow2.Activate(); +#endif + + TBool onoff=ETrue; + + iProfiler->InitResults(); + for(TInt i=aIters; i>=0; i--) + { + blankWindow.SetVisible(onoff=!onoff); + +#ifdef _TESTWITHVARIABLEWINDOWSIZE + blankWindow2.SetSize(TSize(10+i, 10+i)); + blankWindow2.SetPosition(TPoint(px--, py--)); + if (px<0) px=150; + if (py<0) py=150; +#endif + + iWsSession.Flush(); + iProfiler->MarkResultSetL(); + } + +#ifdef _TESTWITHVARIABLEWINDOWSIZE + CleanupStack::PopAndDestroy(&blankWindow2); +#endif + CleanupStack::PopAndDestroy(&blankWindow); + } + +/** +Helper function to calculate processor cycles per pixel as a characteristic number for rendering speed +*/ +TInt CTAlphaDrawing::CyclesPerPixel(TInt64 aDuration, TInt aIters, TInt aWidth, TInt aHeight, TInt aCPUSpeed) + { + TInt64 pixs=aWidth*aHeight; + TInt64 cpuHz=aCPUSpeed; + + TInt64 ret=(aDuration*cpuHz)/pixs/1000/aIters; + return ret; + } + +/* +Helper function that draws a window +*/ +void CTAlphaDrawing::TestDrawWindowL(TDisplayMode aMode, TInt aIters, TTestCase aTestCase, const TDesC& aTestName) + { + RWindow foregndWindow = RWindow(iWsSession); + User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+3)); + + CFbsBitmap * bmpModeDep = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode); + CopyBitmapL(bmpModeDep, iSourceImage); + + foregndWindow.BeginRedraw(); + iWindowGc->Activate(foregndWindow); + iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush); + iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + iWindowGc->DrawBitmap(iScreenDevice->SizeInPixels(), bmpModeDep, bmpModeDep->SizeInPixels()); + iWindowGc->Deactivate(); + foregndWindow.EndRedraw(); + iWsSession.Flush(); + + switch (aTestCase) + { + case EUseOpaqueDraw: + foregndWindow.SetNonTransparent(); + break; + case EUseTransparencyFactor: + User::LeaveIfError(foregndWindow.SetTransparencyFactor(TRgb(0xbbbbbb,128))); + break; + } + + foregndWindow.Activate(); + + // Start performance test and analyse results + DrawBlankWindowL(foregndWindow, aIters); + iProfiler->ResultsAnalysis(aTestName, 0, aMode, 0, aIters); + + foregndWindow.Close(); + + CleanupStack::PopAndDestroy(bmpModeDep); + User::After(KDelay); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0013 + + @SYMTestCaseDesc + The test determines how long it takes to draw an opaque (non-transparent) window composition. + + @SYMTestActions + Compare the results over time, and before and after changes to wserv code. + + @SYMTestExpectedResults + Test should pass and display total test time and cycles per pixel +*/ +void CTAlphaDrawing::DoTestDrawOpaqueWindowL(TDisplayMode aMode, TInt aIters) + { + TestDrawWindowL(aMode, aIters, EUseOpaqueDraw, _L("WinOpaque")); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0014 + + @SYMTestCaseDesc + The test determines how long it takes to draw transparent window compositions with window SetTransparencyFactor. + + @SYMTestActions + Compare the results over time, and before and after changes to wserv code. + + @SYMTestExpectedResults + Test should pass and display total test time and cycles per pixel +*/ +void CTAlphaDrawing::DoTestDrawTransparentWindowFactorL(TDisplayMode aMode, TInt aIters) + { + TestDrawWindowL(aMode, aIters, EUseTransparencyFactor, _L("WinTrFac")); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0015 + + @SYMTestCaseDesc + The test determines how long it takes to draw transparent window compositions with SetTransparencyBitmap. + + @SYMTestActions + Compare the results over time, and before and after changes to wserv code. + + @SYMTestExpectedResults + Test should pass and display total test time and cycles per pixel +*/ +void CTAlphaDrawing::DoTestDrawTransparentWindowBitmapL(TDisplayMode aMode, TInt aIters) + { + RWindow foregndWindow; + foregndWindow = RWindow(iWsSession); + User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+5)); + + CFbsBitmap * sourceAlpha = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), EGray256); + VerticalGradientAlphaL(sourceAlpha, TRgb(0xffffffff), TRgb(0x00000000)); + + CFbsBitmap * bmpModeDep = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode); + CopyBitmapL(bmpModeDep, iSourceImage); + + foregndWindow.BeginRedraw(); + iWindowGc->Activate(foregndWindow); + iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush); + iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + iWindowGc->DrawBitmap(iScreenDevice->SizeInPixels(), bmpModeDep, bmpModeDep->SizeInPixels()); + + // Set transparency bitmap for this window + User::LeaveIfError(foregndWindow.SetTransparencyBitmap(*sourceAlpha)); + + iWindowGc->Deactivate(); + foregndWindow.EndRedraw(); + iWsSession.Flush(); + + foregndWindow.Activate(); + + DrawBlankWindowL(foregndWindow,aIters); + iProfiler->ResultsAnalysis(_L("WinTrBmp"), 0, aMode, 0, aIters); + + foregndWindow.Close(); + + CleanupStack::PopAndDestroy(2, sourceAlpha); + User::After(KDelay); + } + +/** +@SYMTestCaseID GRAPHICS-UI-BENCH-0016 +@SYMTestPriority High +@SYMREQ 0000 +@SYMTestCaseDesc +Test test determines how long it takes to draw transparent window compositions with SetTransparencyAlphaChannel. + +@SYMTestActions +Compare the results over time, and before and after changes to wserv code. + +@SYMTestExpectedResults +Test should pass and display total test time and cycles per pixel +*/ +void CTAlphaDrawing::DoTestDrawTransparentWindowAlphaChannelL(TDisplayMode aMode, TInt aIters) + { + RWindow foregndWindow; + foregndWindow = RWindow(iWsSession); + User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+6)); + + CFbsBitmap * sourceAlpha = CreateSoftwareBitmapLC(iSourceImage->SizeInPixels(), EGray256); + VerticalGradientAlphaL(sourceAlpha, TRgb(0xffffffff), TRgb(0x00000000)); + + CFbsBitmap * bmpModeDep = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode); + CopyBitmapL(bmpModeDep, iSourceImage); + + TPoint point; + TRect rect(iScreenDevice->SizeInPixels()); + + foregndWindow.BeginRedraw(); + iWindowGc->Activate(foregndWindow); + iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush); + iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + + iWindowGc->DrawBitmapMasked(rect, bmpModeDep, bmpModeDep->SizeInPixels(), sourceAlpha, EFalse); + + User::LeaveIfError(foregndWindow.SetTransparencyAlphaChannel()); + + iWindowGc->Deactivate(); + foregndWindow.EndRedraw(); + iWsSession.Flush(); + + foregndWindow.Activate(); + + DrawBlankWindowL(foregndWindow,aIters); + iProfiler->ResultsAnalysis(_L("WinTrAlphaCh"), 0, aMode, 0, aIters); + + foregndWindow.Close(); + CleanupStack::PopAndDestroy(2, sourceAlpha); + User::After(KDelay); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0017 + + @SYMTestCaseDesc + Creates foreground window with alpha channel transparency. + An image with alpha mask is bitblitted to this window. + The test determines how long it takes to create a window + + @SYMTestActions + Compare the results over time, and before and after changes to wserv code. + + @SYMTestExpectedResults + Test should pass and display total test time and cycles per pixel +*/ +void CTAlphaDrawing::DoTestCreateWindowL(TDisplayMode aMode, TInt aIters) + { + RWindow foregndWindow; + + CFbsBitmap * sourceAlpha = CreateSoftwareBitmapLC(iSourceImage->SizeInPixels(), EGray256); + VerticalGradientAlphaL(sourceAlpha, TRgb(0xffffffff), TRgb(0x00000000)); + + CFbsBitmap * bmpModeDep = CreateSoftwareBitmapLC(iScreenDevice->SizeInPixels(), aMode); + CopyBitmapL(bmpModeDep, iSourceImage); + + TPoint point; + TRect rect(iScreenDevice->SizeInPixels()); + iProfiler->InitResults(); + for(TInt i=KIterationsToTest; i>=0; i--) + { + foregndWindow = RWindow(iWsSession); + User::LeaveIfError(foregndWindow.Construct(iWinGroup, (TInt)this+7)); + + foregndWindow.BeginRedraw(); + iWindowGc->Activate(foregndWindow); + iWindowGc->SetBrushStyle(CGraphicsContext::ENullBrush); + iWindowGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + iWindowGc->DrawBitmapMasked(rect, bmpModeDep, bmpModeDep->SizeInPixels(), sourceAlpha, EFalse); + + TInt ret = foregndWindow.SetTransparencyAlphaChannel(); + if (ret == KErrNotSupported) + ERR_PRINTF1(_L("Transparency not enabled - Turn on transparency in wsini.ini file")); + User::LeaveIfError(ret); + + iWindowGc->Deactivate(); + foregndWindow.EndRedraw(); + iWsSession.Flush(); + + foregndWindow.Activate(); + + iWsSession.Flush(); + iProfiler->MarkResultSetL(); + + foregndWindow.Close(); + } + iProfiler->ResultsAnalysis(_L("WinCreation"), 0, aMode, 0, aIters); + CleanupStack::PopAndDestroy(2, sourceAlpha); + User::After(KDelay); + } + +CTAlphaDrawing::~CTAlphaDrawing() + { + delete iSourceImage; + delete iWindowGc; + delete iScreenDevice; + iBackgndWindow.Close(); + iWinGroup.Close(); + iWsSession.Close(); + RFbsSession::Disconnect(); + } + +CTAlphaDrawing::CTAlphaDrawing() + { + SetTestStepName(KTAlphaDrawing); + } + +/** +Override of base class virtual + +@return - TVerdict code +*/ +TVerdict CTAlphaDrawing::doTestStepPreambleL() + { + CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL(); + + HAL::Get(HALData::ECPUSpeed,iCPUSpeed); + + User::LeaveIfError(RFbsSession::Connect()); + User::LeaveIfError(iWsSession.Connect()); + + iScreenDevice = new (ELeave) CWsScreenDevice(iWsSession); + User::LeaveIfError(iScreenDevice->Construct(0)); // screen number (0 is first screen) + + iSourceImage = LoadBitmapL(KAlphaTestBitmap,0); + + iWindowGc = new (ELeave) CWindowGc(iScreenDevice); + User::LeaveIfError(iWindowGc->Construct()); + + TDisplayMode windowMode = iScreenDevice->DisplayMode(); + + iWinGroup = RWindowGroup(iWsSession); + User::LeaveIfError(iWinGroup.Construct(1, EFalse)); + + iBackgndWindow = RWindow(iWsSession); + User::LeaveIfError(iBackgndWindow.Construct(iWinGroup, (TInt)this+8)); + iBackgndWindow.Activate(); + + iBackgndWindow.SetNonTransparent(); + iBackgndWindow.Invalidate(); + + iWsSession.Flush(); + return TestStepResult(); + } + +/** +Override of base class pure virtual +Our implementation only gets called if the base class doTestStepPreambleL() did +not leave. That being the case, the current test result value will be EPass. + +Creates background window with black & white checker board. +This background windows is used for each test case in this file + +@return TVerdict code +*/ +TVerdict CTAlphaDrawing::doTestStepL() + { + TInt iters = KIterationsToTest; + + INFO_PRINTF5(_L("TAlphaDrawing - Iterations:%d, CPUSpeed:%d kHz, Width: %d px, Height: %d px"),iters,iCPUSpeed,iScreenDevice->SizeInPixels().iWidth,iScreenDevice->SizeInPixels().iHeight); + + // tests to execute + TBool iniok; TInt inival; + iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testCreateWindowAlpha"), inival); + TBool testCreateWindowAlpha = ((iniok==EFalse) || (inival > 0)); + iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawOpaqueWindow"), inival); + TBool testDrawOpaqueWindow = ((iniok==EFalse) || (inival > 0)); + iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawTransparentFactorWindow"), inival); + TBool testDrawTransparentFactorWindow = ((iniok==EFalse) || (inival > 0)); + iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawTransparentWindowPerPixel"), inival); + TBool testDrawTransparentWindowPerPixel = ((iniok==EFalse) || (inival > 0)); + iniok = GetIntFromConfig(_L("AlphaDrawingTests"), _L("testDrawTransparentWindowPerPixelAlpha"), inival); + TBool testDrawTransparentWindowPerPixelAlpha = ((iniok==EFalse) || (inival > 0)); + + const TSize iWindowSize=iBackgndWindow.Size(); + + // Initalise test - clear window and create checker board on background windows + ClearWindow(iWsSession, iBackgndWindow, iWindowGc, BLACK_SEMI_TRANSPARENT); + ChessBoard(iWsSession, iBackgndWindow, iWindowGc); + + iWsSession.Flush(); + + TInt screenModesCnt=iScreenDevice->NumScreenModes(); + CArrayFixFlat * rotationList=NULL; + + rotationList = new (ELeave) CArrayFixFlat(KRotationGranulatity); + CleanupStack::PushL(rotationList); + + for (TInt scm=0; scmGetRotationsList(scm,rotationList); + + for (TInt rot = 0; rot < rotationList->Count(); rot++) + { + TPixelsAndRotation pxrot; + pxrot.iPixelSize =iWindowSize; + + iRotation=(CFbsBitGc::TGraphicsOrientation)rotationList->At(rot); + pxrot.iRotation =iRotation; + + iScreenDevice->SetScreenSizeAndRotation(pxrot); + + for(int m=0; m<1; m++) + { + // test drawing speed of window creation and destruction + if ( testCreateWindowAlpha ) + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0017")); + DoTestCreateWindowL(KValidDisplayModes[m],iters); + RecordTestResultL(); + } + + // test drawing speed of an opaque window composition + if ( testDrawOpaqueWindow ) + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0013")); + DoTestDrawOpaqueWindowL(KValidDisplayModes[m],iters); + RecordTestResultL(); + } + + // test drawing speed of a transparent window composition with a transparency factor + if ( testDrawTransparentFactorWindow ) + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0014")); + DoTestDrawTransparentWindowFactorL(KValidDisplayModes[m],iters); + RecordTestResultL(); + } + + // test drawing speed of a transparent window composition with a transparency bitmap + if ( testDrawTransparentWindowPerPixel ) + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0015")); + DoTestDrawTransparentWindowBitmapL(KValidDisplayModes[m],iters); + RecordTestResultL(); + } + + // test drawing speed of a transparent window composition with alpha channel transparency + if ( testDrawTransparentWindowPerPixelAlpha ) + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0016")); + DoTestDrawTransparentWindowAlphaChannelL(KValidDisplayModes[m],iters); + RecordTestResultL(); + } + } // m...Modes + } // rot ... Rotations + } + CleanupStack::PopAndDestroy(rotationList); + TVerdict a = TestStepResult(); + return TestStepResult(); + }