diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/talphablend.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/talphablend.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,905 @@ +// 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 +#include "talphablend.h" + +const TInt KIterationsToTest = 100; +const TInt KDrawRectIterationsToTest = KIterationsToTest*5; // More as faster simpler drawing than bitblits +const TInt KDrawVertLineIterationsToTest = KIterationsToTest*5; +const TInt KDrawTextIterationsToTest = KIterationsToTest*2;// More as drawing fewer pixels than blits. +const TInt KDrawVertTextIterationsToTest = KIterationsToTest;// Slow, less iterations. + + _LIT(KFontTypeface,"DejaVu Sans Condensed"); +// +// We have two overloads of this test, the normal version that runs all tests except... +// + +CAlphaBlendTestNormal::CAlphaBlendTestNormal() + { + SetTestStepName(KAlphaBlendTest); + } + +TVerdict CAlphaBlendTestNormal::doTestStepL() + { + return(CAlphaBlendTest::doTestStepL(EFalse)); + } + +/* +...the iType font variant, this needs the rom configured differently so can not be run with the other tests +to configure the rom for iType fonts you need to use: + +..\iType\binaries\ityperast install + +and to remove them and swich back to normal + + ..\iType\binaries\ityperast uninstall +*/ + +CAlphaBlendTestIType::CAlphaBlendTestIType() + { + SetTestStepName(KAlphaBlendTestIType); + } + +TVerdict CAlphaBlendTestIType::doTestStepL() + { + return(CAlphaBlendTest::doTestStepL(ETrue)); + } + +/** +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. + +@return - TVerdict code +*/ +TVerdict CAlphaBlendTest::doTestStepL(TBool aIType) + { + RWsSession wsSession; + User::LeaveIfError(wsSession.Connect()); + CleanupClosePushL(wsSession); + + // + // Uncomment to debug WSERV redraw problems. + // wsSession.SetAutoFlush(ETrue); + + CWsScreenDevice* windowDevice = new (ELeave) CWsScreenDevice(wsSession); + CleanupStack::PushL(windowDevice); + User::LeaveIfError(windowDevice->Construct()); + CWindowGc* windowGc=NULL; + User::LeaveIfError(windowDevice->CreateContext(windowGc)); // create graphics context + CleanupStack::PushL(windowGc); + + RWindowGroup group; + group = RWindowGroup(wsSession); + CleanupClosePushL(group); + User::LeaveIfError(group.Construct(1, EFalse)); + + RWindow background; + background = RWindow(wsSession); + CleanupClosePushL(background); + User::LeaveIfError(background.Construct(group, 2)); + + RWindow window; + window = RWindow(wsSession); + CleanupClosePushL(window); + User::LeaveIfError(window.Construct(group, 3)); + + TSize windowSize = windowDevice->SizeInPixels(); + TDisplayMode windowMode = windowDevice->DisplayMode(); + + background.Activate(); + background.Invalidate(); + + ClearWindow(wsSession, background, windowGc, BLACK_SEMI_TRANSPARENT); + ClearWindow(wsSession, window, windowGc, BLACK_SEMI_TRANSPARENT); + + window.SetTransparencyAlphaChannel(); + window.Activate(); + window.Invalidate(); + if (aIType) + { + if (CheckMonoTypeInstalledL()) + DoDrawBlendedTestsL(EBlendTestDrawTextIType,wsSession, KDrawVertTextIterationsToTest); + else + { + INFO_PRINTF1(_L("Monotype fonts not installed, skipping test")); + } + } + else + { +/* +Test speed of blended draw rects on all modes supporting alpha blending +*/ + DoDrawBlendedTestsL(EBlendTestDrawRect,wsSession, KDrawRectIterationsToTest); +/* +Test speed of blended draw vertical line calls on all modes supporting alpha blending +*/ + DoDrawBlendedTestsL(EBlendTestVerticalLine,wsSession, KDrawVertLineIterationsToTest); +/* +Test speed of blended draw text calls on all modes supporting alpha blending +*/ + DoDrawBlendedTestsL(EBlendTestDrawText,wsSession, KDrawTextIterationsToTest); + DoDrawBlendedTestsL(EBlendTestDrawTextAntiAliased,wsSession, KDrawVertTextIterationsToTest); + DoDrawBlendedTestsL(EBlendTestDrawVerticalText,wsSession, KDrawVertTextIterationsToTest); +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0022 + + @SYMTestCaseDesc + Alphablend test BITBLT with EColor16MA source and EColor16MU destination. + + @SYMTestActions + Compare the results over time + + @SYMTestExpectedResults +*/ + RDebug::Printf("Alpha Tests: EColor16MU, EColor16MA"); + RDebug::Printf("Alpha Blend"); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0022")); + DoAlphaBlendBitmapsBitmapTestL(EColor16MA, EColor16MU, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0023 + + @SYMTestCaseDesc + Test BITBLT with EColor16MA source and EColor16MU destination. + + @SYMTestActions + Compare the results over time + + @SYMTestExpectedResults +*/ + RDebug::Printf("BitBlt Alpha"); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0023")); + DoBitBltAlphaBitmapTestL(EColor16MA, EColor16MU, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0024 + + @SYMTestCaseDesc + Alpha blend test BITBLT with EColor16MA source and EColor16MA destination. + + @SYMTestActions + Compare the results over time + + @SYMTestExpectedResults +*/ + RDebug::Printf("Alpha Tests: EColor16MA, EColor16MA"); + RDebug::Printf("Alpha Blend"); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0024")); + DoAlphaBlendBitmapsBitmapTestL(EColor16MA,EColor16MA, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0025 + + @SYMTestCaseDesc + Test BITBLT with EColor16MA source and EColor16MA destination. + + @SYMTestActions + Compare the results over time + + @SYMTestExpectedResults +*/ + RDebug::Printf("BitBlt Alpha"); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0025")); + DoBitBltAlphaBitmapTestL(EColor16MA, EColor16MA, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0063 + + @SYMTestCaseDesc + Test BITBLT with EColor16MAP source and EColor16MAP destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0063")); + DoNormalBitBltL(EFalse, EColor16MAP,EColor16MAP, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0064 + + @SYMTestCaseDesc + Test BITBLT with EColor16MA source and EColor16MA destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0064")); + DoNormalBitBltL(EFalse, EColor16MA,EColor16MA, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0065 + + @SYMTestCaseDesc + Test BITBLT with EColor16MAP source and EColor16MA destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0065")); + DoNormalBitBltL(EFalse, EColor16MAP,EColor16MA, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0066 + + @SYMTestCaseDesc + Test BITBLT with EColor16MA source and EColor16MAP destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0066")); + DoNormalBitBltL(EFalse, EColor16MA,EColor16MAP, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0067 + + @SYMTestCaseDesc + Test BITBLT with EColor16MU source and EColor16MU destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0067")); + DoNormalBitBltL(EFalse, EColor16MU,EColor16MU, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0068 + + @SYMTestCaseDesc + Test BITBLT with EColor16MAP source and EColor16MU destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0068")); + DoNormalBitBltL(EFalse, EColor16MAP,EColor16MU, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0069 + + @SYMTestCaseDesc + Test BITBLT with EColor16MU source and EColor16MAP destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0069")); + DoNormalBitBltL(EFalse, EColor16MU,EColor16MAP, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0070 + + @SYMTestCaseDesc + Test BITBLT with EColor64K source and EColor16MU destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0070")); + DoNormalBitBltL(ETrue, EColor64K,EColor16MU, wsSession, window, windowGc, KIterationsToTest); + + RecordTestResultL(); +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0071 + + @SYMTestCaseDesc + Test DrawBitmap with different sizes (STRETCHED) with EColor16MAP source and EColor16MAP destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0071")); + DoDrawBitmapL(EFalse, EColor16MAP, EColor16MAP, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0072 + + @SYMTestCaseDesc + Test DrawBitmap with different sizes (STRETCHED) with EColor16MA source and EColor16MA destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + + SetTestStepID(_L("GRAPHICS-UI-BENCH-0072")); + DoDrawBitmapL(EFalse, EColor16MA, EColor16MA, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0073 + + @SYMTestCaseDesc + Test DrawBitmap (using alpha mask) with different sizes (STRETCHED) with EColor16MU source and EColor16MU destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0073")); + DoDrawBitmapL(ETrue, EColor16MU, EColor16MU, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0057 + + @SYMTestCaseDesc + Test DrawBitmap (using alpha mask) with different sizes (STRETCHED) with EColor16MAP source and EColor16MAP destination. + + @SYMTestActions + Compare the results over several iterations over time. + + @SYMTestExpectedResults +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0057")); + DoDrawBitmapL(ETrue, EColor16MAP, EColor16MAP, wsSession, window, windowGc, KIterationsToTest); + RecordTestResultL(); + } + CleanupStack::PopAndDestroy(6, &wsSession); + return TestStepResult(); + } + +void CAlphaBlendTest::DoDrawBlendedTestsL(TBlendTestFunc aTestFunc, RWsSession& aSession, TInt aNumIterations) + { + TDisplayMode blendModes[]={EColor16MAP,EColor16MA,EColor16MU,EColor64K}; + const TInt KNumBlendTestModes=sizeof(blendModes)/sizeof(TDisplayMode); + for(TInt modeIndex=0;modeIndexSizeInPixels(); + // For fair back to back tests of rotated mode we need graphics clipped to a square test area. + // Although if we aren't going to be comparing rotated results against each other it might be better + // to allow the tests to use the full available area. + TSize testSize; + testSize.iWidth=Min(devSize.iWidth,devSize.iHeight); + testSize.iHeight=testSize.iWidth; + + TFontSpec testFontSpec; + if (aTestFunc==EBlendTestDrawTextAntiAliased || aTestFunc==EBlendTestDrawTextIType) + { + testFontSpec.iTypeface.iName=KFontTypeface; + if (aTestFunc==EBlendTestDrawTextAntiAliased) + { + testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + } + else + { + testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + testFontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue); + testFontSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue); + } + } + testFontSpec.iHeight=12; + // Set bold because sets more pixels, so tests blending code more + testFontSpec.iFontStyle.SetStrokeWeight(EStrokeWeightBold); + _LIT(KTestBlendTextString,"BLENDTESTWITHBIGSOLIDCHARACTERS0123456789HAVEWERUNOUTOFSCREENYET?OKAFEWMORECHARACTERSJUSTTOMAKESURE"); + const TInt maxTextLen=KTestBlendTextString().Length(); +// + TBool orientations[4]; + iGc->OrientationsAvailable(orientations); +// Use for loop to test across multiple rotations, however the implementation hardly varies at the moment +// so very little point in testing the differences, if in future an optimised route is added for normal +// rotation this test would be worth switching back to looping upto EGraphicsOrientationRotated270. +// +// const TInt KMaxOrientation=CFbsBitGc::EGraphicsOrientationRotated270; + const TInt KMaxOrientation=CFbsBitGc::EGraphicsOrientationNormal; + for (TInt orient = CFbsBitGc::EGraphicsOrientationNormal; orient <= KMaxOrientation; orient++) + { + if (orientations[orient]) + { + iGc->SetOrientation((CFbsBitGc::TGraphicsOrientation)orient); + User::After(100000); // Let rotate sort itself out + iGc->Reset(); + iGc->SetClippingRect(TRect(testSize)); + iGc->SetPenStyle(CGraphicsContext::ESolidPen); + iGc->SetBrushColor(TRgb(0x80,0x80,0xFF)); + iGc->Clear(); + iGc->SetBrushColor(TRgb(10,128,240,aAlpha)); + iGc->SetPenColor(TRgb(240,128,10,aAlpha)); + iGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + aSession.Flush(); + + CFbsFont* font=NULL; + TInt fontHeight=0; + TInt testParam=0; + TSize orientatedTestSize=testSize; + TBuf <32> testName; + TGlyphBitmapType checkGlyphBitmapType=EDefaultGlyphBitmap; + TGlyphBitmapType actualGlyphBitmapType=EDefaultGlyphBitmap; + TPtrC textPtr; + switch(aTestFunc) + { + case EBlendTestVerticalLine: + _LIT(KDrawRectVerticalLine,"DrawRectVertLine"); + testName=KDrawRectVerticalLine; + break; + case EBlendTestDrawRect: + _LIT(KDrawRectAlpha,"DrawRectAlpha"); + testName=KDrawRectAlpha; + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetPenStyle(CGraphicsContext::ENullPen); + break; + case EBlendTestDrawTextIType: + _LIT(KDrawTextIType,"DrawTextIT"); + testName=KDrawTextIType; + testParam=testSize.iHeight; + checkGlyphBitmapType=EFourColourBlendGlyphBitmap; + goto drawTextTest; + case EBlendTestDrawTextAntiAliased: + _LIT(KDrawTextAA,"DrawTextAA"); + testName=KDrawTextAA; + testParam=testSize.iHeight; + checkGlyphBitmapType=EAntiAliasedGlyphBitmap; + goto drawTextTest; + case EBlendTestDrawVerticalText: + _LIT(KDrawTextVert,"DrawTextVert"); + orientatedTestSize.SetSize(orientatedTestSize.iHeight,orientatedTestSize.iWidth); + testName=KDrawTextVert; + testParam=testSize.iWidth; + checkGlyphBitmapType=EMonochromeGlyphBitmap; + goto drawTextTest; + case EBlendTestDrawText: + _LIT(KDrawText,"DrawText"); + testParam=testSize.iHeight; + testName=KDrawText; + checkGlyphBitmapType=EMonochromeGlyphBitmap; +drawTextTest: User::LeaveIfError(iScreenDevice->BitmapDevice().GetNearestFontInPixels((CFont* &)font,testFontSpec)); + fontHeight=font->HeightInPixels(); + iGc->UseFont(font); + actualGlyphBitmapType=font->FontSpecInTwips().iFontStyle.BitmapType(); + TInt displayLen=Min(font->TextCount(KTestBlendTextString,orientatedTestSize.iWidth)+1,maxTextLen); + textPtr.Set(KTestBlendTextString().Left(displayLen)); + iScreenDevice->BitmapDevice().ReleaseFont(font); + break; + } + if (checkGlyphBitmapType!=EDefaultGlyphBitmap) + { + if (actualGlyphBitmapType!=checkGlyphBitmapType) + { + INFO_PRINTF3(_L("Failed to load correct glyph type font, wanted %d, got %d"),checkGlyphBitmapType, actualGlyphBitmapType); + break; + } + } + _LIT(KAppendAlphaTxt,"[A=0x%02x]"); + testName.AppendFormat(KAppendAlphaTxt,aAlpha); + iProfiler->InitResults(); + for(TInt iter=0; iterDrawLine(TPoint(xpos,0),TPoint(xpos,testSize.iHeight)); + break; + case EBlendTestDrawRect: + iGc->DrawRect(TRect(testSize)); + break; + case EBlendTestDrawText: + case EBlendTestDrawVerticalText: + case EBlendTestDrawTextAntiAliased: + case EBlendTestDrawTextIType: + { + for(TInt pos=0;posDrawTextVertical(textPtr,TPoint(pos,0),EFalse); + else + iGc->DrawText(textPtr,TPoint(0,pos)); + } + break; + } + } + iProfiler->MarkResultSetL(); + } + INFO_PRINTF3(_L("%S %S"), &testName, &ColorModeName(aDisplayMode)); + iProfiler->ResultsAnalysis(testName, orient, aDisplayMode, aDisplayMode, aNumIterations); + } + } + iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal); + } + +TBool CAlphaBlendTest::CheckMonoTypeInstalledL() + { + SetScreenModeL(EColor16MU); +// + TFontSpec fontSpec; + fontSpec.iTypeface.iName = KFontTypeface; + fontSpec.iHeight = 20; + fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + fontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue); + fontSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue); + CFont* font; + User::LeaveIfError(iScreenDevice->BitmapDevice().GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec)); + TBool monoTypeInstalled=font->FontSpecInTwips().iFontStyle.BitmapType()==EFourColourBlendGlyphBitmap; + iScreenDevice->BitmapDevice().ReleaseFont(font); + return(monoTypeInstalled); + } + +/** +Bitblt test + +@param aSrcMode is the source display mode +@param aDstMode is the destination display mode +@param aSession is the windows server session +@param aWindow is a reference to the window +@param aGc is the graphics context of the window +@param aNumIterations is the number of iterations to run the test +*/ +void CAlphaBlendTest::DoBitBltAlphaBitmapTestL(TDisplayMode aSrcMode,TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) + { + const TSize bitmapSize = aWindow.Size(); + + CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); + CleanupStack::PushL(bitmapDevice); + CFbsBitGc* bitmapGc = NULL; + User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); + CleanupStack::PushL(bitmapGc); + + CFbsBitmap* source = CreateSoftwareBitmapLC(bitmapSize, aSrcMode); + CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(bitmapSize, EGray256); // match size to src + VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); + VerticalGradientAlphaL(source, TRgb(0x00000000), TRgb(0xffffffff)); + + TPoint point(0,0); + + bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); + bitmapGc->SetBrushColor(TRANSPARENT_BLACK); + + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + bitmapGc->Clear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + bitmapGc->BitBlt(point, source); + + aGc->Activate(aWindow); + aGc->BitBlt(point, bitmapTarget); + aGc->Deactivate(); + aSession.Flush(); + + iProfiler->InitResults(); + for(TInt i=0; iSetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + bitmapGc->Clear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + bitmapGc->BitBlt(point, source); + iProfiler->MarkResultSetL(); + } + + iProfiler->ResultsAnalysis(_L("DoBitBltAlphaBitmapTestL"), 0, aSrcMode, aDstMode, aNumIterations); + + // copy up to screen for sanity check + aGc->Activate(aWindow); + aGc->BitBlt(TPoint(), bitmapTarget); + aGc->Deactivate(); + CleanupStack::PopAndDestroy(5, bitmapTarget); //sourceAlpha, source, bitmapGc, bitmapDevice, bitmapTarget + } + + +/** +Clears the window to a colour + +@param aSession is the windows server session +@param aWindow is a reference to the window +@param aGc is the graphics context of the window +@param aColor is the colour to clear the window with +*/ +void CAlphaBlendTest::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(); +} + +/** +BitBlts a bitmap to the windows GC. + +@param aSession is the windows server session +@param aWindow is a reference to the window +@param aGc is the graphics context of the window +@param aImage is the bitmap to bitblt +*/ +void CAlphaBlendTest::BitBlt(RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, CFbsBitmap& aImage) + { + aWindow.Invalidate(); + aWindow.BeginRedraw(); + aGc->Activate(aWindow); + aGc->BitBlt(TPoint(0,0), &aImage); + aGc->Deactivate(); + aWindow.EndRedraw(); + aSession.Flush(); + } + +/** +Alpha blends two bitmaps together + +@param aDisplayMode1 is the source display mode +@param aDisplayMode2 is the destination display mode +@param aSession is the windows server session +@param aWindow is a reference to the window +@param aGc is the graphics context of the window +@param aNumIterations is the number of iterations to run the test +*/ +void CAlphaBlendTest::DoAlphaBlendBitmapsBitmapTestL(TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) + { + const TSize bitmapSize = aWindow.Size(); + + CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); + CleanupStack::PushL(bitmapDevice); + + CFbsBitGc* bitmapGc=NULL; + User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); + CleanupStack::PushL(bitmapGc); + + CFbsBitmap* sourceUnder = CreateSoftwareBitmapLC(bitmapSize, aDstMode); + CFbsBitmap* sourceOver = CreateSoftwareBitmapLC(bitmapSize, aSrcMode); + CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(bitmapSize, EGray256); + + VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); + VerticalGradientAlphaL(sourceUnder, TRgb(0xff000000), TRgb(0x00ffffff)); + VerticalGradientAlphaL(sourceOver, TRgb(0x00ffffff), TRgb(0xff000000)); + RDebug::Printf("DABBBT 2"); + + TPoint point(0,0); + TRect rect(bitmapSize); + + bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); + bitmapGc->SetBrushColor(TRANSPARENT_BLACK); + + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + bitmapGc->Clear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + bitmapGc->AlphaBlendBitmaps(point, sourceUnder, sourceOver, rect, point, sourceAlpha, point); + + aGc->Activate(aWindow); + aGc->BitBlt(point, bitmapTarget); + aGc->Deactivate(); + aSession.Flush(); + + iProfiler->InitResults(); + // blend sourceUnder with sourceOver using alpha mask + for(TInt i=0; iSetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + bitmapGc->Clear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + bitmapGc->AlphaBlendBitmaps(point, sourceUnder, sourceOver, rect, point, sourceAlpha, point); + iProfiler->MarkResultSetL(); + } + iProfiler->ResultsAnalysis(_L("DoAlphaBlendBitmapsBitmapTestL"), 0, aSrcMode, aDstMode, aNumIterations); + + // copy up to screen for sanity check + BitBlt(aSession, aWindow, aGc, *bitmapTarget); + CleanupStack::PopAndDestroy(6, bitmapTarget); // sourceAlpha, sourceOver, sourceUnder, bitmapGc, bitmapDevice, bitmapTarget + } + +/** +Draws a stretched bitmap with or without a mask. + +@param aUseMask set to ETrue to use a alpha mask. Normally used for 16MU display modes that do not store the alpha. +@param aSrcMode is the source display mode +@param aDstMode is the destination display mode +@param aSession is the windows server session +@param aWindow is a reference to the window +@param aGc is the graphics context of the window +@param aNumIterations is the number of iterations to run the test +*/ +void CAlphaBlendTest::DoDrawBitmapL(TBool aUseMask, TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) + { + const TSize bitmapSize = aWindow.Size(); + + // Construct target bitmap. + CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); + CleanupStack::PushL(bitmapDevice); + + // Construct GC. + CFbsBitGc* bitmapGc = NULL; + User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); + CleanupStack::PushL(bitmapGc); + + // Construct source bitmap. + TSize smallerSize(bitmapSize.iWidth/2, bitmapSize.iHeight/2); + CFbsBitmap* source = CreateSoftwareBitmapLC(smallerSize, aSrcMode); + VerticalGradientAlphaL(source, TRgb(0x00000000), TRgb(0xffffffff)); + CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(smallerSize, EGray256); // match size to src + VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); + + bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); + bitmapGc->SetBrushColor(TRANSPARENT_BLACK); + bitmapGc->Clear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + aGc->Activate(aWindow); + TPoint point(0,0); + bitmapGc->BitBlt(point, bitmapTarget); + aGc->Deactivate(); + aSession.Flush(); + + TBuf <20> testName; + if (!aUseMask) + { + testName=_L("DrawBitmap"); + iProfiler->InitResults(); + for(int i=0; iDrawBitmap(TRect(point, bitmapSize), source); + iProfiler->MarkResultSetL(); + } + } + else + { + testName=_L("DrawBitmapMasked"); + iProfiler->InitResults(); + for(int i=0; iDrawBitmapMasked(TRect(point, bitmapSize), source,TRect(point, smallerSize), sourceAlpha, EFalse); + iProfiler->MarkResultSetL(); + } + } + INFO_PRINTF4(_L("%S(Stretched) with src = %S, dst = %S"), &testName, &ColorModeName(aSrcMode), &ColorModeName(aDstMode)); + iProfiler->ResultsAnalysis(testName, 0, aSrcMode, aDstMode, aNumIterations); + // copy up to screen for sanity check + BitBlt(aSession, aWindow, aGc, *bitmapTarget); + CleanupStack::PopAndDestroy(5, bitmapTarget); + } + +/** +Performs a BitBlt with or without a mask + +@param aUseMask set to ETrue to use a alpha mask. Normally used for 16MU display modes that do not store the alpha. +@param aSrcMode is the source display mode +@param aDstMode is the destination display mode +@param aSession is the windows server session +@param aWindow is a reference to the window +@param aGc is the graphics context of the window +@param aNumIterations is the number of iterations to run the test +*/ +void CAlphaBlendTest::DoNormalBitBltL(TBool aUseMask, TDisplayMode aSrcMode, TDisplayMode aDstMode, RWsSession& aSession, RWindow& aWindow, CWindowGc* aGc, TInt aNumIterations) + { + const TSize bitmapSize = aWindow.Size(); + + // Construct target bitmap + CFbsBitmap* bitmapTarget = CreateSoftwareBitmapLC(bitmapSize, aDstMode); + CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(bitmapTarget); + CleanupStack::PushL(bitmapDevice); + + // Construct GC + CFbsBitGc* bitmapGc = NULL; + User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc)); + CleanupStack::PushL(bitmapGc); + + // Construct source bitmap + CFbsBitmap* source = CreateSoftwareBitmapLC(bitmapSize, aSrcMode); + VerticalGradientAlphaL(source, TRgb(0x00000000), TRgb(0xffffffff)); + CFbsBitmap* sourceAlpha = CreateSoftwareBitmapLC(bitmapSize, EGray256); // match size to src + VerticalGradientAlphaL(sourceAlpha, TRgb(0x01010101), TRgb(0xfefefefe)); + + bitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush); + bitmapGc->SetBrushColor(TRANSPARENT_BLACK); + bitmapGc->Clear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TPoint point(0,0); + TRect rect(bitmapSize); + if (aUseMask) + bitmapGc->AlphaBlendBitmaps(point, source, rect, sourceAlpha, point); + else + bitmapGc->BitBlt(point, source); // BitBlt source to target bitmap + + aGc->Activate(aWindow); + aGc->BitBlt(point, bitmapTarget); // BitBlt bitmapTarget to screen + aGc->Deactivate(); + aSession.Flush(); + + TBuf <20> testName; + if (aUseMask) + { + testName=_L("AlphaBlendBitmaps"); + // blend sourceUnder with sourceOver using alpha mask + iProfiler->InitResults(); + for(TInt i=0; iClear(); + bitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + bitmapGc->AlphaBlendBitmaps(point, source, rect, sourceAlpha, point); + iProfiler->MarkResultSetL(); + } + } + else + { + testName=_L("Normal BitBlt"); + iProfiler->InitResults(); + for(TInt i=0; iBitBlt(point, source); + iProfiler->MarkResultSetL(); + } + } + + INFO_PRINTF4(_L("%S with src = %S, dst = %S"), &testName, &ColorModeName(aSrcMode), &ColorModeName(aDstMode)); + iProfiler->ResultsAnalysis(testName, 0, aSrcMode, aDstMode, aNumIterations); + // copy up to screen for sanity check + BitBlt(aSession, aWindow, aGc, *bitmapTarget); + CleanupStack::PopAndDestroy(5, bitmapTarget); + }