/*
* 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 "egltest_endpointtearing.h"
#include "egltest_surface.h"
#include <e32atomics.h>


/**
@SYMTestCaseID GRAPHICS-EGL-573

@SYMTestPriority medium

@SYMPREQ 2670

@SYMTestCaseDesc
Image tearing test with raw surface manager surface.
Check that there is no buffer tearing and that locks are implemented correctly.

@SYMTestActions
Create a Raw Surface Manager surface.
1)  Thread B (test application): Fill the buffers with colours mostly red, and 
    mostly blue, and mostly green if triple buffered.  This is done so that 
    there is a value greater than zero in all colour channels.
2)  Thread A (wserve): Create an endpoint from the surface belonging to the window
3)  Thread B: Submit update.
4)  Thread A: Begin streaming block
5)  Thread A in the windows server for ten seconds, as fast as possible:
6)  Thread A: Acquire an EGLImage from this endpoint
7)  Thread A: Check that the resulting image all a solid colour.  Five samples, 
    one at the centre and at the four corners should be sufficient.
8)  Thread A: Release the EGLImage
9)  In thread B, whilst thread A is running: fill surface with different solid 
    colours, and call Submit Update. Run this thread as fast a possible, with the 
    same priority as thread A. The solid colour used should be varied for each 
    iteration.  Do not synchronize threads A and B, but random waits (using delay 
    loops) may be used to give each thread a variation and reduce any 
    synchronization in the EGL code.
10) Thread A: End the streaming block
11) Thread A & B: Close and delete resources.

@SYMTestExpectedResults
Each acquired image from the endpoint is a solid colour, 
calculated by comparing all the corners and the center pixel.
*/


CEglTest_LocalTestStep_EndpointTearing::CEglTest_LocalTestStep_EndpointTearing() :
    CLocalTestStepBase(ETestUidEndpointTearing)
    {
    }


CEglTest_LocalTestStep_EndpointTearing::~CEglTest_LocalTestStep_EndpointTearing()
    {
    }

void CEglTest_LocalTestStep_EndpointTearing::DoPreambleL()
    {
    //Register the test id.
    _LIT(KTestId, "573");
    RegisterTestIdsL(KTestId);
    SetCurrentTestIds(KTestId);
    
    //If this fails, the test will fail in a round about way with EGL_NOT_INITIALIZED.
    eglInitialize(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL);
    
    //Create the fast locaks used for comms between the test thread and the draw thread.
    User::LeaveIfError(iStartDraw.CreateLocal());
    User::LeaveIfError(iFirstDrawDone.CreateLocal());
    }


void CEglTest_LocalTestStep_EndpointTearing::DoPostambleL()
    {
    iStartDraw.Close();
    iFirstDrawDone.Close();
    eglTerminate(eglGetDisplay(EGL_DEFAULT_DISPLAY));
    }


TVerdict CEglTest_LocalTestStep_EndpointTearing::doTestStepL()
    {
    //Acquire the start drawing lock to force the draw thread to wait until we signal.
    iStartDraw.Wait();
    
    //Start drawing thread. When this returns, iSurfaceId
    //contains the surface handle for the surface the thread uses
    //and the draw thread is waiting on iStartDraw.
    StartDrawThreadL();
    
    //Params for the remote test step.
    TRemoteTestParams params;
    params.iEndpointTearing.iSurfaceId = iSurfaceId;
    
    //Setup the remote test step. (creates an endpoint).
    StartRemoteTestStep(params);
    
    //Tell the draw thread to continously fill the surface 
    //with a block colour and submit the buffer, honoring the
    //notifyWhenAvailable semantics. 
    iStartDraw.Signal();
    
    //Wait for the first buffer to be drawn, so that the remote side
    //is guaranteed to be able to begin streaming on the endpoint
    //when we run the remote test case. The remote side continuously
    //checks that each acquired image is a solid colour for a set time.
    iFirstDrawDone.Wait();
    RunRemoteTestCase(0, TRemoteTestParams());
    
    //Stop the drawing thread, so that it does not report a 'not 
    //registered' error when we end the remote test step (destroy ep).
    StopDrawThread();
    EndRemoteTestStep(TRemoteTestParams());
    
    return TestStepResult();
    }


void CEglTest_LocalTestStep_EndpointTearing::StartDrawThreadL()
    {
    //Stack and heap sizes.
    static const TInt KStackSize =   0x2000;      //  8KB
    static const TInt KHeapMinSize = 0x1000;      //  4KB
    static const TInt KHeapMaxSize = 0x1000000;   // 16MB

    //Create draw thread and wait for rendezvous.
    User::LeaveIfError(iDrawThread.Create(KNullDesC, DrawThreadEntryPoint, KStackSize, KHeapMinSize, KHeapMaxSize, this));
    CleanupClosePushL(iDrawThread);
    iDrawThread.Resume();
    TRequestStatus rendezvous;
    iDrawThread.Rendezvous(rendezvous);
    User::WaitForRequest(rendezvous);
    User::LeaveIfError(rendezvous.Int());
    CleanupStack::Pop(&iDrawThread);
    }


void CEglTest_LocalTestStep_EndpointTearing::StopDrawThread()
    {
    TRequestStatus logon;
    iDrawThread.Logon(logon);
    __e32_atomic_store_rel32(&iStopDrawing, ETrue);
    User::WaitForRequest(logon);
    iDrawThread.Close();
    }


TInt CEglTest_LocalTestStep_EndpointTearing::DrawThreadEntryPoint(TAny* aSelf)
    {
    CEglTest_LocalTestStep_EndpointTearing* self = static_cast<CEglTest_LocalTestStep_EndpointTearing*>(aSelf);
    CTrapCleanup* cleanup = CTrapCleanup::New();
    
    TRAPD(err,
        //Create active scheduler.
        CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
        CleanupStack::PushL(scheduler);
        CActiveScheduler::Install(scheduler);

        //Setup the draw loop.
        self->EnterDrawLoopL();

        //Clean up.
        CleanupStack::PopAndDestroy(scheduler);
        );
    
    __ASSERT_ALWAYS(err == KErrNone, User::PanicUnexpectedLeave());
    delete cleanup;
    
    return KErrNone;
    }


void CEglTest_LocalTestStep_EndpointTearing::EnterDrawLoopL()
    {
    //Create a standard surface. 
    CSurface* surface = CSurface::SurfaceFactoryL(ESurfTypeRaw);
    CleanupStack::PushL(surface);
    surface->CreateL(ELargeSurface);
    
    TRequestStatus availableStat[2];
    TInt currentStat = 0;
    TInt currentColour = 0x88CC44;
    
    //Take the FirstDrawDone fast lock, save the surfaceId then rendezvous.
    iFirstDrawDone.Wait();
    iSurfaceId = surface->SurfaceId();
    RThread().Rendezvous(KErrNone);
    
    //Wait for the signal to draw the first buffer.
    iStartDraw.Wait();
    surface->DrawContentL(TRgb(currentColour, 255));
    surface->Notify(ENotifyWhenAvailable, availableStat[currentStat++ & 1], 0);
    // We must wait until the image is copied; the endpoint isn't ready until the ContentUpdated has been processed by GCE BE.
    // It isn't enough to simply call SubmitContentL; there's multiple process/thread boundaries to cross before the endpoint is 'ready'
    User::LeaveIfError(surface->SubmitContent(ETrue));
    iFirstDrawDone.Signal();
    
    //Loop until we are told to stop drawing.
    while(!__e32_atomic_load_acq32(&iStopDrawing))
        {
        //Draw content, ask for notification when the buffer we have drawn to is available and submit.
        surface->DrawContentL(TRgb(currentColour, 255));
        surface->Notify(ENotifyWhenAvailable, availableStat[currentStat++ & 1], 0);
        User::LeaveIfError(surface->SubmitContent(EFalse));
        
        //Wait until the other buffer is free, so we don't tear. There are 2 buffers 
        //in the surface: We asked for ELargeSurface, which is double buffered.
        TUint32 dummyTimeStamp;
        TInt err = surface->WaitFor(ENotifyWhenAvailable, availableStat[currentStat & 1], 1000, dummyTimeStamp);
        User::LeaveIfError(err);
        
        //Modify the colour that we draw.
        currentColour += 16;
        }
    
    CleanupStack::PopAndDestroy(surface);
    }