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

//

#include "testrenderer.h"

#include "videoframebuffer.h"

#include "testgceharness.h"

RTestRendererStep* RTestRendererStep::NewL(const TDesC& aStepName, TBool aTimed)

	{

	RTestRendererStep* self = new (ELeave) RTestRendererStep(aStepName, aTimed);

	return self;

	}

RTestRendererStep::RTestRendererStep(const TDesC& aStepName, TBool aTimed) :

	iVideoRenderer(NULL),

	iTimed(aTimed)

	{

	iTestStepName = aStepName;

	// size for buffer created

	iSize.iWidth = 1024;

	iSize.iHeight = 768;

	iVideoFormat.iDataFormat = ERgbRawData;

	iVideoFormat.iRgbFormat = ERgb32bit888;

	}

void RTestRendererStep::MvroVideoBufferAvailable()

	{

	INFO_PRINTF1(_L("MvroVideoBufferAvailable() callback received"));

	TRAPD(err, FsmL(EBufferAvailable));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("FsmL(EBufferAvailable) failed with %d"), err);

		EndTest(EFail);

		}

	}

void RTestRendererStep::MvroBufferDisplayed(TInt aBufferId, const TTime& aTime)

	{

	INFO_PRINTF2(_L("MvroBufferDisplayed() callback received aBufferId=%d"), aBufferId);

	iBufferId = aBufferId;

	iDisplayedTime = aTime;

	TRAPD(err, FsmL(EBufferDisplayed));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("FsmL(EBufferDisplayed) failed with %d"), err);

		EndTest(EFail);

		}

	}

void RTestRendererStep::MvroBufferSkipped(TInt aBufferId)

	{

	INFO_PRINTF2(_L("MvroBufferSkipped() callback received aBufferId=%d"), aBufferId);

	iBufferId = aBufferId;

	TRAPD(err, FsmL(EBufferSkipped));

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("FsmL(EBufferSkipped) failed with %d"), err);

		EndTest(EFail);

		}

	}

TVerdict RTestRendererStep::DoTestStepPreambleL()

	{

    // Install the Active Scheduler

    iActiveScheduler = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(iActiveScheduler);

	iActiveSchedulerStarted = EFalse;

    iBuffAvailCallback = 0;

    iBuffDisplayCallback = 0;

    iBuffSkipCallback = 0;

    // The following is required because of the panic tests.

    // When a thread panics the global pointer is not reset to NULL

    // and the following test fails because the pointer is hanging.

    // When testframework creates a thread to run the test step it also

    // defines a heap and the default process heap is not used. Therefore

    // when the thread dies the heap is no longer available.

	CTestGCEHarness::ResetGlobalPointer();

    // Initialise Window server objects

    InitWservL();

    return EPass;

	}

TVerdict RTestRendererStep::DoTestStepPostambleL()

	{

	CActiveScheduler::Install(NULL);

	delete iActiveScheduler;

    iActiveScheduler = NULL;

    // Destroy Window server objects

    DeInitWserv();

    return EPass;

	}

void RTestRendererStep::InitWservL()

    {

    TInt err = iWs.Connect();

    if (err != KErrNone)

        {

        // Access violation if ws is null

        ERR_PRINTF1(_L("Cannot test, no window server available"));

        User::Leave(err);

        }

    iScreen = new (ELeave) CWsScreenDevice(iWs); // make device for this session

    User::LeaveIfError(iScreen->Construct()); // and complete its construction

    iRootWindow = RWindowGroup(iWs);

    User::LeaveIfError(iRootWindow.Construct((TUint32)this, ETrue));

    iWindow = new(ELeave) RWindow(iWs);

    User::LeaveIfError(((RWindow*)iWindow)->Construct(iRootWindow,((TUint32)(this)) + 1));

    iWindow->SetExtent(TPoint(0,0), TSize(100,100));

    iWindow->SetVisible(ETrue);

    iWindow->SetRequiredDisplayMode(EColor16MA);

    iWindow->Activate();

    }

void RTestRendererStep::DeInitWserv()

    {

    if (iWindow)

        {

        iWindow->Close();

        delete iWindow;

        iWindow = NULL;

        }

    iRootWindow.Close();

    delete iScreen;

    iScreen = NULL;

    iWs.Flush();

    iWs.Close();

    }

TInt RTestRendererStep::SetBackgroundSurface(TSurfaceId& id)

	{

	TInt err = iWindow->SetBackgroundSurface(id);

	iWs.Finish();

	return err;

	}

void RTestRendererStep::RemoveBackgroundSurface()

	{

	iWindow->RemoveBackgroundSurface(ETrue);

	}

TVerdict RTestRendererStep::DoTestStepL()

	{

	__UHEAP_MARK;

    // Call the state handler from IDLE state

    TRAPD(err, FsmL(EStartTest));

    if (err == KErrNone && iTestStepResult == EPass)

        {

        // Start the scheduler - Done only once !

    	iActiveSchedulerStarted = ETrue;

        CActiveScheduler::Start();    

        }

    else if (err != KErrNone)

    	{

        ERR_PRINTF2(_L("FsmL(EStartTest) leave with %d"), err);

    	iTestStepResult = EFail;

    	}

	delete iVideoRenderer;

	iVideoRenderer = NULL;

    // cleanup test harness

    CTestGCEHarness::Remove();

	__UHEAP_MARKEND;

    return iTestStepResult;

	}

void RTestRendererStep::FsmL(TTestRendererEvents aEventCode)

	{

    switch (aEventCode)

        {

        case EStartTest:

        	{

        	iFsmState = EStateCreate;

        	TInt numBuffers = 1;

        	INFO_PRINTF2(_L("CVideoRenderer::NewL() Timed=%d"), iTimed);

        	CTestGCEHarness::NewL(numBuffers);

            iVideoRenderer = CVideoRenderer::NewL(*this, iTimed);

            INFO_PRINTF1(_L("iVideoRenderer->GetSupportedFormatsL()"));

            RArray<TUncompressedVideoFormat> expectedArray;

            CleanupClosePushL(expectedArray);

            TUncompressedVideoFormat format;

            format.iDataFormat = ERgbRawData;

    		format.iRgbFormat = ERgb16bit444;

    		expectedArray.AppendL(format); // append EVideoRendererPixelFormatXRGB_4444

    		format.iDataFormat = ERgbRawData;

    		format.iRgbFormat = ERgb16bit565;

    		expectedArray.AppendL(format); // append EVideoRendererPixelFormatRGB_565

    		format.iDataFormat = ERgbRawData;

    		format.iRgbFormat = ERgb32bit888;

    		expectedArray.AppendL(format); // append EVideoRendererPixelFormatXRGB_8888:

    		RArray<TUncompressedVideoFormat> array;

            CleanupClosePushL(array);

        	iVideoRenderer->GetSupportedFormatsL(array);

        	TInt expectedCount = expectedArray.Count();

        	TESTL(array.Count() == expectedCount);

        	for (TInt i = 0; i < expectedCount; i++)

        		{

        		TESTL(expectedArray[i] == array[i]);

        		}

        	CleanupStack::PopAndDestroy(2, &expectedArray);

        	CreateSurfaceL(numBuffers);

            break;

        	}

        case EBufferAvailable:

        	iBuffAvailCallback++;

        	if (iFsmState == EStateCreate && iBuffAvailCallback == 1)

        		{

	            iFsmState = EStateUpdate;

	        	// map surface to display

	            TInt err = SetBackgroundSurface(iSurfaceId);

	            if (err != KErrNone)

	            	{

		        	ERR_PRINTF2(_L("RWindow::SetBackgroundSurface() returned %d"), err);

                    EndTest(EFail);

                    break;

	            	}

	        	TTime presentationTime;

	        	presentationTime.UniversalTime();

	        	TTimeIntervalMicroSeconds microsec(500000); // use half a second delay

	        	presentationTime += microsec;

	        	GetNextBufferAndSubmitUpdateL(0, KRgbGreen, presentationTime);

        		}

        	else if (iFsmState == EStateUpdate && iBuffAvailCallback == 2)

        		{

	        	iFsmState = EStateReleaseBuffer;

	        	// buffer is available again after update;

        	    // try to get next buffer

        	    TVideoFrameBuffer* buffer;

	            INFO_PRINTF1(_L("iVideoRenderer->NextBuffer() after update"));

	        	buffer = iVideoRenderer->NextBuffer();

	        	TESTL(buffer != NULL);

	            INFO_PRINTF1(_L("iVideoRenderer->ReleaseBuffer()"));

	        	iVideoRenderer->ReleaseBuffer(buffer);

        		}

        	else if (iFsmState == EStateReleaseBuffer)

        		{

        		if (iBuffDisplayCallback == 1)

        			{

            		// both release buffer callback and display callback are received, test complete with pass

                	EndTest(EPass);

        			}

        		// else continue waiting for more callback

        		}

        	else

        		{

        		ERR_PRINTF2(_L("State %d was not expected when handling buffer available event."), iFsmState);

            	EndTest(EFail);

        		}

        	break;

        case EBufferDisplayed:

        	iBuffDisplayCallback++;

        	if ((iFsmState != EStateUpdate && iFsmState != EStateReleaseBuffer) ||

        		iBufferId != 0)

        		{

        		// not in a valid state

        		ERR_PRINTF2(_L("State %d was not expected when handing buffer displayed event."), iFsmState);

            	EndTest(EFail);

        		}

        	if (iFsmState == EStateReleaseBuffer && iBuffAvailCallback == 3)

        		{

        		// both release buffer callback and display callback are received, test complete with pass

        		EndTest(EPass);

        		}

        	// otherwise, haven't received release callback yet, continue waiting

        	break;

        default:

			// unexpected event

			ERR_PRINTF2(_L("Unexpected event code %d in RTestRendererStep::FsmL"), aEventCode);

        	EndTest(EFail);

        	break;

        }

	}

void RTestRendererStep::EndTest(TVerdict aVerdict)

	{

    iTestStepResult = aVerdict;

    if (iActiveSchedulerStarted)

    	{

    	CActiveScheduler::Stop();

    	}

	}

void RTestRendererStep::CreateRendererAndSurfaceL(TInt aNumBuffers)

	{

	INFO_PRINTF2(_L("CVideoRenderer::NewL() Timed=%d"), iTimed);

	CTestGCEHarness::NewL(aNumBuffers);

	iVideoRenderer = CVideoRenderer::NewL(*this, iTimed);

	CreateSurfaceL(aNumBuffers);

	}

void RTestRendererStep::CreateSurfaceL(TInt aNumBuffers)

	{

	INFO_PRINTF1(_L("iVideoRenderer->CreateSurfaceL()"));

	iVideoRenderer->CreateSurfaceL(iSize, aNumBuffers, iVideoFormat, iSurfaceId);

	}

void RTestRendererStep::GetNextBufferAndSubmitUpdateL(TInt aExpectedBufId, TRgb aColor, const TTime& aPresentationTime)

	{

    TVideoFrameBuffer* buffer = GetNextBufferL(aExpectedBufId, aColor);

    INFO_PRINTF1(_L("iVideoRenderer->UpdateBuffer()"));

	iVideoRenderer->UpdateBuffer(buffer, aPresentationTime);

	}

TVideoFrameBuffer* RTestRendererStep::GetNextBufferL(TInt aExpectedBufId, TRgb aColor)

	{

	INFO_PRINTF1(_L("iVideoRenderer->NextBuffer()"));

	TVideoFrameBuffer* buffer;

	buffer = iVideoRenderer->NextBuffer();

	TESTL(buffer != NULL);

	TESTL(buffer->Format() == iVideoFormat);

	TESTL(buffer->Stride() == iSize.iWidth *  4); // 4 bite per pixel for ERgb32bit888

	TESTL(buffer->BufferId() == aExpectedBufId);

	TESTL(buffer->Buffer() != NULL);

	TInt bufSize = buffer->Stride() * iSize.iHeight;

	Mem::Fill(buffer->Buffer(), bufSize, aColor.Internal());

	return buffer;

	}

RTestRendererReplaceStep* RTestRendererReplaceStep::NewL(const TDesC& aStepName, TBool aTimed)

	{

	RTestRendererReplaceStep* self = new (ELeave) RTestRendererReplaceStep(aStepName, aTimed);

	return self;

	}

RTestRendererReplaceStep::RTestRendererReplaceStep(const TDesC& aStepName, TBool aTimed) :

	RTestRendererStep(aStepName, aTimed)

	{

	}

void RTestRendererReplaceStep::FsmL(TTestRendererEvents aEventCode)

	{

	switch (aEventCode)

	    {

	    case EStartTest:

	    	iFsmState = EStateCreate;

	        CreateRendererAndSurfaceL(1);

	        break;

	    case EBufferAvailable:

	    	iBuffAvailCallback++;

	    	if (iFsmState == EStateCreate && iBuffAvailCallback == 1)

	    		{

	            iFsmState = EStateUpdate;

    	    	// received the first callback, map surface to display

	            TInt err = SetBackgroundSurface(iSurfaceId);

	            TESTL(err == KErrNone);

	            // send the buffer

	            TTime presentationTime(0);

	            GetNextBufferAndSubmitUpdateL(0, KRgbGreen, presentationTime);

	    		}

	    	else if (iFsmState == EStateUpdate)

	    		{

	    		if (iBuffDisplayCallback == 1 && iBuffAvailCallback == 2)

	    			{

	    			iFsmState = EStateReplaceSurface;

	    			ReplaceSurfaceL();

	    			}

	    		}

	    	else if (iFsmState == EStateReplaceSurface && iBuffAvailCallback == 1)

	    		{

    	    	// received the first callback, map surface to display

	            TInt err = SetBackgroundSurface(iSurfaceId);

	            if (err != KErrNone)

	            	{

		        	ERR_PRINTF2(_L("RWindow::SetBackgroundSurface() returned %d"), err);

                    EndTest(EFail);

	            	}

	    		}

	    	else if (iFsmState == EStateReplaceSurface && iBuffAvailCallback == 2)

            	{

	            iFsmState = EStateUpdateAfterReplace;

	            // send the buffer

	            TTime presentationTime1;

	            presentationTime1.UniversalTime();

	            TTimeIntervalMicroSeconds delay(500);

	            TTime presentationTime2 = presentationTime1 + delay;

	            GetNextBufferAndSubmitUpdateL(0, KRgbGreen, presentationTime1);

	            GetNextBufferAndSubmitUpdateL(1, KRgbGreen, presentationTime2);

            	}

	    	else if (iFsmState == EStateUpdateAfterReplace)

	    		{

	    		if (iBuffDisplayCallback == 2 && iBuffAvailCallback == 3)

	    			{

	    			EndTest(EPass);

	    			}

	    		// else continue waiting for more callback

	    		}

	    	else

	    		{

	    		// unexpected state, fail test

	    		ERR_PRINTF2(_L("State %d was not expected when handling buffer available event."), iFsmState);

	        	EndTest(EFail);

	    		}

	    	break;

	    case EBufferDisplayed:

	    	iBuffDisplayCallback++;

	    	if (iFsmState == EStateUpdate && iBuffDisplayCallback == 1 && iBufferId == 0)

	    		{

	    		// receive display callback

	        	if (iBuffAvailCallback == 2)

	        		{

	    			iFsmState = EStateReplaceSurface;

	    			ReplaceSurfaceL();

	        		}

	    		}

	    	else if (iFsmState == EStateUpdateAfterReplace && iBuffDisplayCallback == 1 && iBufferId == 0)

	    		{

	    		// receive display callback

	    		}

	    	else if (iFsmState == EStateUpdateAfterReplace && iBuffDisplayCallback == 2 && iBufferId == 1)

	    		{

	        	if (iBuffAvailCallback == 3)

	        		{

	    			EndTest(EPass);

	        		}

	        	// else haven't received all callback, continue waiting

	    		}

	    	else

	    		{

	    		// not in a valid state

	    		ERR_PRINTF2(_L("State %d was not expected when handling buffer displayed event."), iFsmState);

	        	EndTest(EFail);

	    		}

	    	break;

	    case EBufferSkipped:

	    	ERR_PRINTF1(_L("Frame unexpectedly skipped"));

        	EndTest(EFail);

	    	break;

	    }

	}

void RTestRendererReplaceStep::ReplaceSurfaceL()

	{

	// reset the number of callback

	iBuffDisplayCallback = 0;

	iBuffAvailCallback = 0;

	RemoveBackgroundSurface();

	// received all expected callback for update

	// destroy surface and create new one for testing replace surface

	INFO_PRINTF1(_L("iVideoRenderer->DestroySurface()"));

	iVideoRenderer->DestroySurface(iSurfaceId);

	TInt buffers = 2;

	CTestGCEHarness::ResetBuffersL(buffers);

	CreateSurfaceL(buffers);

	}

/**

Standard static NewL() taking a callback function

*/

CCallBackTimer* CCallBackTimer::NewL(TCallBack aCallBack, TPriority aPriority)

	{

	CCallBackTimer* self = new(ELeave) CCallBackTimer(aCallBack, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Private c'tor

*/

CCallBackTimer::CCallBackTimer(TCallBack aCallBack, TPriority aPriority) :

	CTimer(aPriority), iCallBack(aCallBack)

	{

	CActiveScheduler::Add(this);

	}

/*

Callback on timer complete

*/

void CCallBackTimer::RunL()

	{

	iCallBack.CallBack();

	}