// 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 <e32math.h>

#include "testvideoplayer2.h"

#ifdef SYMBIAN_BUILD_GCE

#include <graphics/surfacemanager.h>

#endif

const TInt KSettingsAndAlignmentTest = 3;

//

// RTestVclntPlayAviFile

//

/**

 * RTestVclnt2PlayFile::Constructor

 */

RTestVclnt2PlayFile::RTestVclnt2PlayFile(const TDesC& aTestName, 

                                         const TDesC& aSectName, 

                                         const TDesC& aKeyName, 

                                         TInt aExpectedError)

    : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestVclnt2PlayFile::NewL

 */

RTestVclnt2PlayFile* RTestVclnt2PlayFile::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)

    {

    RTestVclnt2PlayFile* self = new (ELeave) RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError);

    return self;

    }

/**

 * RTestVclnt2PlayFile::DoTestStepPreambleL

 */

TVerdict RTestVclnt2PlayFile::DoTestStepPreambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();

    }

/**

 * RTestVclnt2PlayFile::DoTestStepPostambleL

 */

TVerdict RTestVclnt2PlayFile::DoTestStepPostambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();        

    }

/**

 * RTestVclnt2PlayFile::FsmL

 */

void RTestVclnt2PlayFile::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        switch (aEventCode)

            {

            case EVPIdle:

                HandleIdleL();

                break;

            case EVPOpenComplete:

                HandleOpenCompleteL();

                break;

            case EVPPrepareComplete:                    

                HandlePrepareCompleteL();

                break;

            case EVPPlayComplete:

                HandlePlayCompleteL();

                break;

            }

        }

    }

void RTestVclnt2PlayFile::HandleIdleL()

	{

	// Open iVideoPlayer

    INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

    iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

    PrepareState(EVPOpenComplete, KErrNone);

	}

void RTestVclnt2PlayFile::HandleOpenCompleteL()

	{

	// Prepare iVideoPlayer2

    INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));

    iVideoPlayer2->Prepare();

    PrepareState(EVPPrepareComplete, KErrNone);

	}

void RTestVclnt2PlayFile::HandlePrepareCompleteL()

	{

	// Add display window using default values - ie. video extent & window clipping 

	// defaulted to whole window

	INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));

	iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);

    // trigger the video to start playing                

    StartPlayback();

	}

void RTestVclnt2PlayFile::HandlePlayCompleteL()

	{

	iTestStepResult = EPass;

	CActiveScheduler::Stop();

	}

void RTestVclnt2PlayFile::StartPlayback()

	{

    iError = KErrTimedOut;

    INFO_PRINTF1(_L("iVideoPlayer2->Play()"));

    PrepareState(EVPPlayComplete, KErrNone);

    iVideoPlayer2->Play();

	}

#ifdef SYMBIAN_BUILD_GCE

//

// RTestMediaClientVideoDisplay

//

/**

 * RTestMediaClientVideoDisplay::Constructor

 */

RTestMediaClientVideoDisplay::RTestMediaClientVideoDisplay(const TDesC& aTestName, 

                                         const TDesC& aSectName, 

                                         const TDesC& aKeyName, 

                                         TInt aExpectedError)

    : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestMediaClientVideoDisplay::NewL

 */

RTestMediaClientVideoDisplay* RTestMediaClientVideoDisplay::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)

    {

    RTestMediaClientVideoDisplay* self = new (ELeave) RTestMediaClientVideoDisplay(aTestName, aSectName, aKeyName, aExpectedError);

    return self;

    }

/**

 * RTestMediaClientVideoDisplay::DoTestStepPreambleL

 */

TVerdict RTestMediaClientVideoDisplay::DoTestStepPreambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();

    }

/**

 * RTestMediaClientVideoDisplay::DoTestStepPostambleL

 */

TVerdict RTestMediaClientVideoDisplay::DoTestStepPostambleL()

    {

    return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();        

    }

/**

 * RTestMediaClientVideoDisplay::FsmL

 */

void RTestMediaClientVideoDisplay::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        switch (aEventCode)

            {

            case EVPIdle:

                HandleIdleL();

                break;

            case EVPOpenComplete:

                HandleOpenCompleteL();

                break;

            case EVPPrepareComplete:                    

                HandlePrepareCompleteL();

                break;

            case EVPPlayComplete:

                HandlePlayCompleteL();

                break;

            }

        }

    }

void RTestMediaClientVideoDisplay::HandleIdleL()

	{

	// Open iVideoPlayer

    INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

    iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

    PrepareState(EVPOpenComplete, KErrNone);

	}

void RTestMediaClientVideoDisplay::HandleOpenCompleteL()

	{

	// Prepare iVideoPlayer2

    INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));

    iVideoPlayer2->Prepare();

    PrepareState(EVPPrepareComplete, KErrNone);

	}

void RTestMediaClientVideoDisplay::HandlePrepareCompleteL()

	{

	// trigger the video to start playing  

	StartPlayback();

	TInt displayId = iScreen->GetScreenNumber();

	TRect clipRect = TRect(iWindow->Size());

	TRect cropRegion = clipRect;

	// ==========================

    iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);

 	RSurfaceManager surfaceManager;

 	User::LeaveIfError(surfaceManager.Open());

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b=bf();

	b.iSize.iWidth = 320;

	b.iSize.iHeight = 240;

	b.iBuffers = 1;

	b.iPixelFormat = EUidPixelFormatXRGB_8888;	

	b.iStride = 320 * 4;

	b.iOffsetToFirstBuffer = 0;

	b.iAlignment=4;

	b.iContiguous=ETrue;

	TRect cropRect(0, 0, 320, 240);

	TVideoAspectRatio par(1,2);

	TSurfaceId surfaceId;

	User::LeaveIfError(surfaceManager.CreateSurface(bf, surfaceId));

    iMediaClientVideoDisplay->SurfaceCreated(surfaceId, cropRect, par, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceCreated()"));

    delete iMediaClientVideoDisplay;

    iMediaClientVideoDisplay = NULL;

    // ==================

    iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);

	TRect videoExtent = clipRect;

	TVideoRotation rotation = EVideoRotationNone;

	TReal32 scaleWidth(100.0f);

	TReal32 scaleHeight(100.0f);

	TInt horizPos(EHorizontalAlignCenter);

	TInt vertPos(EVerticalAlignCenter);	

	TReal32 widthPercentage(50.0f); 

	TReal32 heightPercentage(50.0f);

	TReal32 widthP; 

	TReal32 heightP;

	RWindow newWindow;

	TVideoRotation videoRotation(EVideoRotationClockwise180);

	iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow);

	INFO_PRINTF1(_L("iMediaClientVideoDisplay->AddDisplayWindowL()"));   

    iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));

    if (iMediaClientVideoDisplay->RotationL(*iWindow) != videoRotation)

        {

        ERR_PRINTF1(_L("iMediaClientVideoDisplay->RotationL() returns an unexpected value.  Test aborted."));

		iTestStepResult = EInconclusive;

		CActiveScheduler::Stop();

        }

	else

		{

		INFO_PRINTF1(_L("iMediaClientVideoDisplay->RotationL()"));	

		}

    iMediaClientVideoDisplay->SetScaleFactorL(*iWindow, widthPercentage, heightPercentage, cropRegion);

    iMediaClientVideoDisplay->SetScaleFactorL(widthPercentage, heightPercentage, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetScaleFactorL()"));

    iMediaClientVideoDisplay->SetRotationL(EVideoRotationClockwise90, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));

    iMediaClientVideoDisplay->GetScaleFactorL(*iWindow, widthP, heightP);

    INFO_PRINTF3(_L("iMediaClientVideoDisplay->GetScaleFactorL() %df %df"), &widthP, &heightP);

    iMediaClientVideoDisplay->SetVideoExtentL(*iWindow, videoExtent, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetVideoExtentL()"));

    iMediaClientVideoDisplay->SetWindowClipRectL(*iWindow, clipRect, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetWindowClipRectL()"));

    iMediaClientVideoDisplay->SetAutoScaleL(EAutoScaleBestFit, horizPos, vertPos, cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetAutoScaleL()"));

    iMediaClientVideoDisplay->RedrawWindows(cropRegion);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->RedrawWindows()"));   

	iMediaClientVideoDisplay->SurfaceParametersChanged(surfaceId, cropRect, par);

	INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceParametersChanged()"));

	iMediaClientVideoDisplay->RemoveSurface();

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->ReplaceSurface()"));

    iMediaClientVideoDisplay->RemoveDisplayWindow(*iWindow);

    INFO_PRINTF1(_L("iMediaClientVideoDisplay->RemoveDisplayWindow()"));

    surfaceManager.CloseSurface(surfaceId);

	surfaceId = TSurfaceId::CreateNullId();

	surfaceManager.Close();

    delete iMediaClientVideoDisplay;  

    iMediaClientVideoDisplay = NULL;              

   	}

void RTestMediaClientVideoDisplay::HandlePlayCompleteL()

	{

	iTestStepResult = EPass;

	CActiveScheduler::Stop();

	}

void RTestMediaClientVideoDisplay::StartPlayback()

	{

    iError = KErrTimedOut;

    INFO_PRINTF1(_L("iVideoPlayer2->Play()"));

    PrepareState(EVPPlayComplete, KErrNone);

    iVideoPlayer2->Play();

	}

#endif

//

// RTestVclnt2PerformActionDuringVideoPlayback

//

/**

 * RTestVclnt2PerformActionDuringVideoPlayback::Constructor

 */

RTestVclnt2PerformActionDuringVideoPlayback::RTestVclnt2PerformActionDuringVideoPlayback(

    const TDesC& aTestName, 

    const TDesC& aSectName, 

    const TDesC& aKeyName, 

    TInt aExpectedError)

    : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL

 */

void RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL()

    {

    if (iActionError != KErrNone)

        {

        ERR_PRINTF2(_L("Playback event left with error %d."), iActionError);

        iTestStepResult = EFail;

        }

    else 

        {

        iTestStepResult = EPass;

        }

	CActiveScheduler::Stop();        

    }

/**

 * RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback

 */     

void RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback()

	{

	RTestVclnt2PlayFile::StartPlayback();

	iActionError = KErrNone;

    TRAP(iActionError, DoThisActionDuringPlaybackL(*iVideoPlayer2));

	}

//

// RTestVclnt2AddWin

//

/**

 * RTestVclnt2AddWin::Constructor

 */

RTestVclnt2AddWin::RTestVclnt2AddWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

    : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

    {

    }

/**

 * RTestVclnt2AddWin::NewL

 */

RTestVclnt2AddWin* RTestVclnt2AddWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

    {

    RTestVclnt2AddWin* self = new (ELeave) RTestVclnt2AddWin(aTestName, aSectName, aKeyName, aExpectedError);

    return self;

    }

/**

 * RTestVclnt2AddWin::HandlePrepareCompleteL

 */

void RTestVclnt2AddWin::HandlePrepareCompleteL()

    {

    // retrieve video size

    TSize videoSize;

    iVideoPlayer2->VideoFrameSizeL(videoSize);                

    if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0)

        {

        // create a clipping rect partially out of screen

        TRect windowRect(iWindow->Size());

        windowRect.SetWidth(windowRect.Width() * 2);

        // Add the display window with a partially out of screen clipping rect

        TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, 

                                                    *iScreen, 

                                                    *iWindow, 

                                                    TRect(iWindow->Size()), 

                                                    windowRect));

        if (err != iTestExpectedError)

            {

            ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error.  Test failed."));

    		iTestStepResult = EFail;

    		CActiveScheduler::Stop();

    		return;

            }

        // create a clipping rect completely out of screen

        windowRect.SetRect(TPoint(0, 0), iWindow->Size());

        windowRect.Move(windowRect.Width() + 10, 0);

        // Add the display window with a completely out of screen clipping rect

        TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs, 

                                                   *iScreen, 

                                                   *iWindow, 

                                                   TRect(iWindow->Size()), 

                                                   windowRect));

        if (err != iTestExpectedError)

            {

            ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error.  Test failed."));

    		iTestStepResult = EFail;

    		CActiveScheduler::Stop();

    		return;

            }

        else 

            {

            // Reset the expected error to KErrNone as all expected failure tests have been completed.  

            // Any error that appears after this should fail the test

            iTestExpectedError = KErrNone;

            }

        // after failing to add window display with a partially & a completely out of screen

        // clipping rect, proceed to add a valid clipping rect below            

        }    

    if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0401")) == 0 ||

        iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0) 

        {

        // shrink both the video & window size by half

        TRect videoRect(videoSize);     

        videoRect.SetHeight(videoSize.iHeight / 2);

        videoRect.SetWidth(videoSize.iWidth / 2); 

        TRect windowRect(iWindow->Size());

        windowRect.SetHeight(iWindow->Size().iHeight / 2);

        windowRect.SetWidth(iWindow->Size().iWidth / 2); 

        // ensure the rect is within the boundary of the window        

        TRect finalRect(windowRect);

        finalRect.Intersection(videoRect);

        // add display window using this valid clipping rect 

        iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect);

        }

    else

        {

        // Invalid test case

        User::Panic(_L("RTestVclnt2AddWin"), KErrArgument);        

        }

    // Start video playback

    StartPlayback();

    }

//

// RTestVclnt2RemoveWin

//

/**

 * RTestVclnt2RemoveWin::Constructor

 */ 

RTestVclnt2RemoveWin::RTestVclnt2RemoveWin(const TDesC& aTestName, 

                                           const TDesC& aSectName,

                                           const TDesC& aKeyName, 

                                           TInt aExpectedError,

                                           TBool aAddBack)

    : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError),

      iAddBack(aAddBack)

    {

    }

/**