/*

 * 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);

     }