// 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);
    }