// 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:
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code 
*/

#include <graphics/directgdidriver.h>
#include <hal.h> 
#include "tflipframerate.h"

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
const TInt KWindowGroupHandle = 1;
const TInt KWindowHandle = 2;

const TInt KTextPhraseFontSize = 40;
const TReal KTextPhraseSpeed = 200.f;

const TRgb KBackgroundColour    = TRgb(255, 127, 0); // Orange
const TRgb KBrushColour         = TRgb(255, 255, 0); // Yellow
const TRgb KPenColour           = TRgb(0, 0, 255, 255); // Blue

const TUint KMinFrames = 51;// uibench, needs more than 50 results for the trimmed mean

_LIT(KTextPhrase, "Flip Performance");

TVerdict CTFlipFramerate::doTestStepPreambleL()
    {    
    // Window related Setup
    // Connect to windows server session    
    TESTL(KErrNone==iWs.Connect());
       
     // Make device for this session
    iScreenDev = new (ELeave) CWsScreenDevice(iWs);
    TESTL(KErrNone==iScreenDev->Construct(KSgScreenIdMain));

    // Create a window group
    iWinGroup = RWindowGroup(iWs);
    TESTL(KErrNone==iWinGroup.Construct(KWindowGroupHandle));

    // Create a window with the window group as a parent
    iWindow = RWindow(iWs);
    TESTL(KErrNone==iWindow.Construct(iWinGroup, KWindowHandle));
    
    // Activate window and set visible
    iWindow.Activate();
    iWindow.SetVisible(ETrue);

    // Connect to surface update session
    TESTL(KErrNone==iUpdateSession.Connect());   
    CTDirectGdiTestBase::doTestStepPreambleL();  
    iContext = CDirectGdiContext::NewL(*iDGdiDriver);
    
    // Image Related Setup
    // Setup off screen image
    iSurfaceSize=iWindow.Size();
    iImageInfo.iSizeInPixels = iSurfaceSize;    
    iImageInfo.iPixelFormat = EUidPixelFormatXRGB_8888;
    iImageInfo.iCpuAccess = ESgCpuAccessNone;
    iImageInfo.iUsage = ESgUsageOpenGlesTarget| ESgUsageDirectGdiSource | ESgUsageDirectGdiTarget;
    iImageInfo.iShareable = ETrue;
    iImageInfo.iScreenId = iScreenDev->GetScreenNumber();   
    
    TESTL(KErrNone==iImgCol.Create(iImageInfo, 1));
    TESTL(KErrNone==iImgCol.OpenImage(0, iImage));
    
    TESTL(KErrNone==iDGdiImageTarget->Create(iImage)); 

    TESTL(KErrNone==iSurfaceConfiguration.SetSurfaceId(iImgCol.SurfaceId()));
    TESTL(KErrNone==iSurfaceConfiguration.SetExtent(iWindow.Size()));

    GetFontL();
    
    TInt fastCounterFrequency;
    TESTL(KErrNone==HAL::Get(HALData::EFastCounterFrequency, fastCounterFrequency));
    
    // Initialise text scrolling variables
    iTextPhraseSpeed = KTextPhraseSpeed / fastCounterFrequency;  
    iLastFrameTime = User::FastCounter();
    
    return TestStepResult();
    }

TVerdict CTFlipFramerate::doTestStepPostambleL()
    {
    iImage.Close();
    iImgCol.Close();
    
    CTDirectGdiTestBase::doTestStepPostambleL();
    
    delete iContext;
    iWindow.Close();
    iWinGroup.Close();
    
    iUpdateSession.Close();
    delete iScreenDev;
    iWs.Close();
    
    iTsStore->ReleaseFont(iFont);
    delete iTsStore;
    iTsStore = NULL;
    return TestStepResult();    
    }

/**
Set-up a font to be used in the rendering
*/
void CTFlipFramerate::GetFontL()
    {
    _LIT(KFontFamily, "NewCourier");
    iTsStore = CFbsTypefaceStore::NewL(NULL);
    TFontSpec spec(KFontFamily, KTextPhraseFontSize);
    spec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
    spec.iFontStyle.SetStrokeWeight(EStrokeWeightBold);
    TESTL(KErrNone==iTsStore->GetNearestFontInPixels(iFont, spec));
    
    iTextPhraseLength = iFont->MeasureText(KTextPhrase, NULL, NULL);
    }

/**
Draw some content
*/
void CTFlipFramerate::RenderL()
    {
    iContext->Activate(*iDGdiImageTarget);
    iContext->SetBrushColor(KBackgroundColour);
    iContext->Clear(); 
    
    // Draw Text  
    iContext->SetFont(iFont);
    iContext->SetBrushStyle(DirectGdi::ENullBrush);
    TPoint textPos(iTextPos,iSurfaceSize.iHeight/2);
    
    TReal fastCounter = User::FastCounter();
    
    if(fastCounter<iLastFrameTime)
        {
        // Handle single roll-over of fastcounter        
        TReal actualCount = static_cast<TReal>(KMaxTUint) + fastCounter;                
        iTextPos+=(iTextPhraseSpeed * (actualCount-iLastFrameTime));        
        }
    else
        {        
        iTextPos+=(iTextPhraseSpeed * (fastCounter-iLastFrameTime));
        }
    
    iContext->SetBrushColor(KBrushColour);
    iContext->SetPenColor(KPenColour);
    iContext->DrawText(KTextPhrase,NULL, textPos);
 
    // Update the last frame time, used to animate that which is drawn in RenderL()
    iLastFrameTime = User::FastCounter();
    
    iDGdiDriver->Finish();
    }

/*
Set the size of the displayed window as a fraction of the screens size.

@param aWindowSizeDivisor  Controls the displayed window size
*/
void CTFlipFramerate::SetSizeL(const TScreenSizeDivisors aWindowSizeDivisor)
    {
    TSize size = iScreenDev->SizeInPixels();    
    size.iHeight/=aWindowSizeDivisor;
    size.iWidth/=aWindowSizeDivisor;
    iWindow.SetSize(size);    
    iImageInfo.iSizeInPixels = size;
    TESTL(KErrNone==iSurfaceConfiguration.SetExtent(size));    
    }

/*
Time how long it takes to display a submitted update

@param aIsFlipped  Whether or not the surface is to be vertically flipped before it it displayed
@param aWindowSizeDivisor  Controls the displayed window size to be tested
@param aOrientation  The surface rotation to be tested
@param aStepName  The name of the test, for logging.
*/
void CTFlipFramerate::TestFramerateOrientationL(   const TFlipped aIsFlipped,
                                        const TScreenSizeDivisors aWindowSizeDivisor,
                                        const CFbsBitGc::TGraphicsOrientation aOrientation)
    {    
    // Simulate small sized window (e.g. like video call) and implicitly disable fast pathing.
    SetSizeL(aWindowSizeDivisor);
    
    // Set-up the timer
    iProfiler->InitResults();
    
    TESTL(KErrNone==iSurfaceConfiguration.SetOrientation(aOrientation));
    TESTL(KErrNone==iSurfaceConfiguration.SetFlip(aIsFlipped));
    TESTL(KErrNone==iWindow.SetBackgroundSurface(iSurfaceConfiguration, ETrue));
        
    TRequestStatus availabilityStatus;
    TRequestStatus displayedStatus;
    TTimeStamp dummyTimeStamp;    
    TInt framesDone=0;
    
    iUpdateSession.NotifyWhenAvailable(availabilityStatus);
    TESTL(KErrNone==iUpdateSession.SubmitUpdate(KSgScreenIdMain, iImgCol.SurfaceId(), 0));      
    
    // uibench, needs more than 50 results for the trimmed mean, so repeat as required.
    while(framesDone < KMinFrames)
        {
        iTextPos = -iTextPhraseLength;  // enter stage left
        
        // scroll the text from left to right across the surface.
        while(iTextPos<=iSurfaceSize.iWidth)
            {              
            User::WaitForRequest(availabilityStatus);
            // Draw something
            RenderL();     
    
            // Request Notifications
            iUpdateSession.NotifyWhenAvailable(availabilityStatus);
            iUpdateSession.NotifyWhenDisplayed(displayedStatus, dummyTimeStamp);        
    
            // Start Timer & Submit Update
            iProfiler->StartTimer();        
            TESTL(KErrNone==iUpdateSession.SubmitUpdate(KSgScreenIdMain, iImgCol.SurfaceId(), 0));
            
            // Wait for the update to have been displayed and stop the timer
            User::WaitForRequest(displayedStatus);        
            iProfiler->MarkResultSetL();       
            framesDone++;
            }        
        }
    iProfiler->ResultsAnalysis(KTFlipFramerate,aOrientation,ENone,iScreenDev->CurrentScreenMode(),framesDone);    
    }

void CTFlipFramerate::TestStepFramerateL(   const TFlipped aIsFlipped,
                                            const TScreenSizeDivisors aWindowSizeDivisor,
                                            const TDesC& aStepName)
    {
    SetTestStepID(aStepName);
    TestFramerateOrientationL(aIsFlipped, aWindowSizeDivisor, CFbsBitGc::EGraphicsOrientationNormal);
    TestFramerateOrientationL(aIsFlipped, aWindowSizeDivisor, CFbsBitGc::EGraphicsOrientationRotated90);
    TestFramerateOrientationL(aIsFlipped, aWindowSizeDivisor, CFbsBitGc::EGraphicsOrientationRotated180);
    TestFramerateOrientationL(aIsFlipped, aWindowSizeDivisor, CFbsBitGc::EGraphicsOrientationRotated270);
    RecordTestResultL();
    }
#endif

TVerdict CTFlipFramerate::doTestStepL()
    {
#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
    INFO_PRINTF1(_L("CTBitBltPerfDirectGdi can only be run with RSgImage legacy"));
    return TestStepResult();
#else
    // Test to allow comparison between flipped and non-flipped performance
    // This is because camera data needs to be flipped abuot vertical axis to show the user what they expect,
    // e.g. during a voice call.
    // No API exists for a flip about a vertical axis so this is achieved by a flip about horizontal axis,
    // and a 180degree rotation.
    // Therefore this test generates results for flipped and non-flipped performance at all four orientations.
    // Additionally it tests at both full screen and quarter screen.  It does this for two reasons :-
    // 1) Full screen, non-flipped, non-rotated can be (and at the time of writing is) fast-pathed.
    //    This makes it awkward to use as a comparison.
    // 2) Some use-cases are likely to use a non-fullscreen window, e.g. voice call.
#ifdef __WINS__  
    INFO_PRINTF1(_L("Fullscreen, NotFlipped"));
    TestStepFramerateL(ENotFlipped,EScreensizeFull,_L("GRAPHICS-UI-BENCH-0173"));
    INFO_PRINTF1(_L("Fullscreen, Flipped"));
    TestStepFramerateL(EFlipped,EScreensizeFull,_L("GRAPHICS-UI-BENCH-0174"));
    INFO_PRINTF1(_L("Quarterscreen, NotFlipped"));
    TestStepFramerateL(ENotFlipped,EScreenSizeQuarter,_L("GRAPHICS-UI-BENCH-0175"));
    INFO_PRINTF1(_L("Quarterscreen, Flipped"));
    TestStepFramerateL(EFlipped,EScreenSizeQuarter,_L("GRAPHICS-UI-BENCH-0176"));    
    
    CloseTMSGraphicsStep();
    return TestStepResult();
#else
    INFO_PRINTF1(_L("Flip tests are running on emulator only, tests skipped."));
    return TestStepResult();
#endif
#endif   //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE 
    }