// Copyright (c) 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: 

// This class does performance tests for eglSwapBuffers() and eglSwapBuffersRegionNOK().

// The function eglSwapBuffersRegionNOK() is a vendor specific EGL extension and allows users to 

// perform region based surface updates. The test should show how the performance of the

// extension function compares to the default one. 

// 

/**

 @file

 @test 

*/

#include "egltest_benchmark_swapbuffers.h"

#include <VG/openvg.h>

#include <test/tprofiler.h>

#include <test/egltestcommonutils.h>

#include <test/egltestcommoninisettings.h>

_LIT(KSwapBuffersSection, "SwapBuffers");

// The test draws alternating backgrounds to show the affect

// of different swapBuffer functions 

static const TInt KMaxClearColors = 2;

static const VGfloat KClearColors[KMaxClearColors][4] = 

    {

        {0.5f, 0.5f, 0.5f, 1.0f}, // gray

        {0.1f, 0.2f, 0.4f, 1.0f}  // blue

    };

// Number of iterations, it defines how often the swapBuffer function is called

static const TInt KIterationsToTest = 10;

// Maximum number of rectangles for eglSwapBuffersRegionNOK() stress test

static const TInt KStressTestMaxNoRects = 100;

// Defines the increase of number of rectangles for each iteration

static const TInt KStressTestNoRectsStepSize = 5;

// Gap between the dirty Rectangles

static const TInt KStressTestRectGap = 3;

// This test step meassures the performance of eglSwapBuffers()

_LIT(KTestStep0528,"GRAPHICS-EGL-0528");

// This test step meassures the performance of eglSwapBuffersRegionNOK()

_LIT(KTestStep0529,"GRAPHICS-EGL-0529");

// This test step meassures the performance of eglSwapBuffersRegionNOK() with a lot of dirty rectangles

_LIT(KTestStep0530,"GRAPHICS-EGL-0530");

_LIT(KErrEglConfigNotSupported, "EGL config is not supported.");

_LIT(KInfoRectangles, "Number of dirty rectangles: %d");

_LIT(KWarnStressTestRectCount, "Dirty rectangles for stress test don't fit onto window surface (%d of %d).");

_LIT(KEglSwapBuffersRegionNokMsg, "eglSwapBuffersRegionNOK extension is not supported.");

CEglTest_Benchmark_SwapBuffers::CEglTest_Benchmark_SwapBuffers()

	{

	SetTestStepName(KBenchmark_SwapBuffers);

	}

CEglTest_Benchmark_SwapBuffers::~CEglTest_Benchmark_SwapBuffers()	

	{

    // empty

	}

/**

 * It's called by the test framework before the actual test. It's used

 * to do the preparation for the test. It's important to call the

 * baseclass implementation also.

 * 

 * @return test framework code

 * @leave Standard system errors

 */

TVerdict CEglTest_Benchmark_SwapBuffers::doTestStepPreambleL()

    {

    CEglTestStep::doTestStepPreambleL();

    iProfiler = CTProfiler::NewL(*this);

    //read parameters from config (WindowSize)

    CEglTestCommonIniSettings* iniParser = CEglTestCommonIniSettings::NewL();

    CleanupStack::PushL(iniParser);

    iWindowSize = iniParser->GetWindowSize(KSwapBuffersSection);

    if(iWindowSize == TSize(0,0))

        {

        ERR_PRINTF1(_L("The window size whether is not specified in INI file or is TSize(0,0), the test will not be executed!"));

        User::Leave(KErrArgument);      

        }

    CleanupStack::PopAndDestroy(iniParser);

    // Establish the connection to the window server and create

    // a WindowGroup and a Window object

    TESTL(iWs.Connect() == KErrNone);    

    iWindowGroup = RWindowGroup(iWs);

    TESTL(iWindowGroup.Construct(0) == KErrNone);  

    iWindow = RWindow(iWs);

    // The window is automatically fullscreen if it's a child of a window group

    TESTL(iWindow.Construct(iWindowGroup, reinterpret_cast<TUint32>(this)) == KErrNone);

    iWindow.SetSize(iWindowSize);

    // Window dimensions

    const TPoint KWindowPosition(30, 30);

    iWindow.SetPosition(KWindowPosition);

    iWindow.Activate();

    // Create display object

    CEglTestStep::GetDisplayL();

    ASSERT_EGL_TRUE(eglInitialize(iDisplay, 0, 0));

    // Choose EGL config

    EGLConfig matchingConfigs[1];

    EGLint numConfigs = 0;

    eglChooseConfig(iDisplay, KConfigAttribs[2], matchingConfigs, 1, &numConfigs);

    if (numConfigs <= 0) // Abort the test if the EGL config is not supported

        {

        ERR_PRINTF1(KErrEglConfigNotSupported);

        SetTestStepError(KErrNotSupported);

        return TestStepResult();

        }

    // Use OpenVG to draw

    ASSERT_EGL_TRUE(eglBindAPI(EGL_OPENVG_API));

    // Create the window surface and the egl context and make them current

    iEglSurface = eglCreateWindowSurface(iDisplay, matchingConfigs[0], &iWindow, KPixmapAttribsVgAlphaFormatPre);

    ASSERT_EGL_TRUE(iEglSurface != EGL_NO_SURFACE);

    iEglContext = eglCreateContext(iDisplay, matchingConfigs[0], EGL_NO_CONTEXT, NULL);

    ASSERT_EGL_TRUE(iEglContext != EGL_NO_CONTEXT);

    ASSERT_EGL_TRUE(eglMakeCurrent(iDisplay, iEglSurface, iEglSurface, iEglContext));

    // Get the function pointer for eglSwapBuffersRegionNOK()

    iPfnEglSwapBuffersRegionNok = reinterpret_cast<PFNEGLSWAPBUFFERSREGIONNOKPROC>(eglGetProcAddress("eglSwapBuffersRegionNOK"));

    return TestStepResult();

    }

TVerdict CEglTest_Benchmark_SwapBuffers::doTestStepPostambleL()

    {

    // Make sure that this EGL status is active

    eglMakeCurrent(iDisplay, iEglSurface, iEglSurface, iEglContext);

    // Call eglMakeCurrent() to ensure the surfaces and contexts are truly destroyed

    eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

    if (iEglContext != EGL_NO_CONTEXT)

        {

        eglDestroyContext(iDisplay, iEglContext);

        }

    if (iEglSurface != EGL_NO_SURFACE)

        {

        eglDestroySurface(iDisplay, iEglSurface);

        }   

    eglTerminate(iDisplay);

    eglReleaseThread();

    iWindow.Close();

    iWindowGroup.Close();

    iWs.Close();

    delete iProfiler;

    iProfiler = NULL;

    return CEglTestStep::doTestStepPostambleL();

    }

/**

 * Override of base class pure virtual function.

 * This implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value should be EPass.

 *

 * @return test framework code

 */

TVerdict CEglTest_Benchmark_SwapBuffers::doTestStepL()

    {

    // Tests  the performance of eglSwapBuffers()

    SetTestStepID(KTestStep0528);    

    TRAPD(err, EglSwapBufferL());

    if (err != KErrNone)

        {

        SetTestStepResult(EAbort);

        }    

    RecordTestResultL();

    // We only perform swap region benchmark test if eglSwapBuffersRegionNOK extension is supported

    if (iPfnEglSwapBuffersRegionNok != NULL)

        {

        // Tests the maximum performance of eglSwapBuffersRegionNOK()

        SetTestStepID(KTestStep0529);    

        TRAP(err, EglSwapBufferRegionL());

        if (err != KErrNone)

            {

            SetTestStepResult(EAbort);

            }    

        RecordTestResultL();

        // Stress tests the performance of eglSwapBuffersRegionNOK()

        SetTestStepID(KTestStep0530);    

        for (TInt noRects = KStressTestNoRectsStepSize; noRects <= KStressTestMaxNoRects; noRects += KStressTestNoRectsStepSize)

            {

            // TRAP here is on purpose, normally you shouldn't use it in loops

            TRAP(err, EglSwapBufferRegionStressL(noRects));

            if (err != KErrNone)

                {

                ERR_PRINTF2(_L("EglSwapBufferRegionStressL (leave code: %d)."), err);

                SetTestStepResult(EAbort);

                }

            }

        RecordTestResultL();

        }

    else

        {

        INFO_PRINTF1(KEglSwapBuffersRegionNokMsg);

        }

    // Close the test and return result to the testframework

    CloseTMSGraphicsStep();    

    return TestStepResult();

	}

/**

@SYMTestCaseID GRAPHICS-EGL-0528

@SYMTestPriority 1

@SYMPREQ 2677

@SYMTestCaseDesc

Tests how long it takes to swap window surface buffers if the whole surface is updated.

@SYMTestActions

Clear the window surface with alternating background colors, swap the surface buffers 

(using eglSwapBuffers extension)and measure how long it takes.

@SYMTestExpectedResults

Test should pass and print the average framerate to a log file.

*/

void CEglTest_Benchmark_SwapBuffers::EglSwapBufferL()

    {    

    //-------   start profiling

    iProfiler->InitResults();

    // Perform the test

    for(TInt i = KIterationsToTest; i > 0; --i)

        {

        // Clean the surface with the background color

        vgSetfv(VG_CLEAR_COLOR, 4, KClearColors[i % KMaxClearColors]);

        vgClear(0, 0, iWindowSize.iWidth, iWindowSize.iHeight);

        // Swap the surface buffers

        ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSurface));

        }

    // Mark the time and print the results to the log file

    iProfiler->MarkResultSetL();

    iProfiler->ResultsAnalysisFrameRate(KTestStep0528, 0, 0, 0,

            KIterationsToTest, iWindowSize.iWidth * iWindowSize.iHeight);   

    }

/**

@SYMTestCaseID GRAPHICS-EGL-0529

@SYMTestPriority 1

@SYMPREQ 2677

@SYMTestCaseDesc

Tests how long it takes to swap window surface buffers if only a small region is updated. This

test should show the maximum possible performance increase.

@SYMTestActions

Clear the window surface with alternating background colors, swap the surface buffers

and measure how long it takes.

@SYMTestExpectedResults

Test should pass and print the average framerate to a log file.

The average time shall be made available in an easy-to-use format for further 

analysis and comparison.

*/

void CEglTest_Benchmark_SwapBuffers::EglSwapBufferRegionL()

    {

    // Region dimensions (top left hand corner and bottom right hand corner)

    const TRect KRegionRect(50, 50, 60, 60);

    // Rectangle for partial swap buffer function

    const EGLint rects[] = {KRegionRect.iTl.iX, KRegionRect.iTl.iY, KRegionRect.Width(), KRegionRect.Height()};

    // Number of rectangles (one rectangle consist of 4 values)

    const EGLint count = (sizeof(rects) / (sizeof(rects[0] * 4)));

    // We obtain the func ptr in doTestStepPreambleL and only execute this test if it is not null

    TESTL(iPfnEglSwapBuffersRegionNok != NULL);

    // Clear the surface

    vgSetfv(VG_CLEAR_COLOR, 4, KClearColors[0]);

    vgClear(0, 0, iWindowSize.iWidth, iWindowSize.iHeight);

    ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSurface));

    // Initialise uibench and reset the timer

    iProfiler->InitResults();

    // Perform the test

    for(TInt i = KIterationsToTest; i > 0; --i)

        {

        // Clean the surface with the background color

        vgSetfv(VG_CLEAR_COLOR, 4, KClearColors[i % KMaxClearColors]);

        vgClear(0, 0, iWindowSize.iWidth, iWindowSize.iHeight);

        // Swap the surface buffers

        ASSERT_EGL_TRUE(iPfnEglSwapBuffersRegionNok(iDisplay, iEglSurface, count, rects));

        }

    // Mark the time and print the results to the log file

    iProfiler->MarkResultSetL();

    iProfiler->ResultsAnalysisFrameRate(KTestStep0529, 0, 0, 0,

            KIterationsToTest, iWindowSize.iWidth * iWindowSize.iHeight);

    }

/**

@SYMTestCaseID GRAPHICS-EGL-0530

@SYMTestPriority 1

@SYMPREQ 2677

@SYMTestCaseDesc

Stress test to show maximum possible performance increase when adding Rectangles to the region i.e. adding 100 rectangles with step size 5 

@SYMTestActions

Clear the window surface with alternating background colors, swap the surface buffers

and measure how long it takes.

@SYMTestExpectedResults

Test should pass and print the average framerate to a log file.

@Param aCount

Number of rectangles to add to the region

*/

void CEglTest_Benchmark_SwapBuffers::EglSwapBufferRegionStressL(EGLint aCount)

    {

    TInt* rects = static_cast<TInt*>(User::AllocLC(sizeof(TInt) * 4 * aCount));

    TInt actualRectCount = 0;

    TInt idx = 0;

    // Size of the dirty rectangles for the stress test

    const TSize KStressTestRectSize(10, 10);

    for (TInt y = 0; (y < iWindowSize.iHeight - KStressTestRectSize.iHeight - 1) && (actualRectCount < aCount); y += KStressTestRectSize.iHeight + KStressTestRectGap)

        {

        for (TInt x = 0; (x < iWindowSize.iWidth - KStressTestRectSize.iWidth - 1) && (actualRectCount < aCount); x += KStressTestRectSize.iWidth + KStressTestRectGap)

            {

            rects[idx++] = x;

            rects[idx++] = y;

            rects[idx++] = KStressTestRectSize.iWidth;

            rects[idx++] = KStressTestRectSize.iHeight;

            actualRectCount++;

            }

        }

    TESTL(actualRectCount > 0);

    if (actualRectCount != aCount)

        {

        WARN_PRINTF3(KWarnStressTestRectCount, actualRectCount, aCount);

        }

    // We obtain the func ptr in doTestStepPreambleL and only execute this test if it is not null

    TESTL(iPfnEglSwapBuffersRegionNok != NULL);

    // Clear the surface

    vgSetfv(VG_CLEAR_COLOR, 4, KClearColors[0]);

    vgClear(0, 0, iWindowSize.iWidth, iWindowSize.iHeight);

    ASSERT_EGL_TRUE(eglSwapBuffers(iDisplay, iEglSurface));

    // Initialise uibench and reset the timer

    iProfiler->InitResults();

    // Perform the test

    for(TInt i = KIterationsToTest; i > 0; --i)

        {

        // Clean the surface with the background color

        vgSetfv(VG_CLEAR_COLOR, 4, KClearColors[i % KMaxClearColors]);

        vgClear(0, 0, iWindowSize.iWidth, iWindowSize.iHeight);

        // Swap the surface buffers

        ASSERT_EGL_TRUE(iPfnEglSwapBuffersRegionNok(iDisplay, iEglSurface, actualRectCount, rects));

        }

    // Mark the time and print the results to the log file

    iProfiler->MarkResultSetL();

    INFO_PRINTF2(KInfoRectangles, aCount);

    iProfiler->ResultsAnalysisFrameRate(KTestStep0530, 0, 0, 0,

            KIterationsToTest, iWindowSize.iWidth * iWindowSize.iHeight);

    CleanupStack::PopAndDestroy(rects);

    }