// 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 "testvideoplayer.h"

#include <e32math.h>

#include <mmf/common/mmfvideo.h>

#include "u32hal.h"

#ifdef SYMBIAN_BUILD_GCE

#include <gceavailable.h>

#endif

const TInt KFrameWidth = 100;

const TInt KFrameHeight = 50;

const TInt KCropRegionRectTop = 1;

const TInt KCropRegionRectLeft = 3;

const TInt KCropRegionRectRight = 5;

const TInt KCropRegionRectBottom = 7;

const TUint KCacheSize = 1000000; //1MB

const TUint KMaxCacheSize = 30000000; //30MB

//

// RTestVclntPlayAviFile

//

/**

 * RTestVclntPlayAviFile::Constructor

 */

RTestVclntPlayAviFile::RTestVclntPlayAviFile(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay)

    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError), iPlay(aPlay)

    {

    iHeapSize = 2000000; //-2MB

    }

/**

 * RTestVclntPlayAviFile::NewL

 */

RTestVclntPlayAviFile* RTestVclntPlayAviFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    {

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

    return self;

    }

/**

 * RTestVclntPlayAviFile::NewLC

 */

RTestVclntPlayAviFile* RTestVclntPlayAviFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    {

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

    CleanupStack::PushL(self);

    return self;

    }

/**

 * RTestVclntPlayAviFile::DoTestStepL

 */

TVerdict RTestVclntPlayAviFile::DoTestStepL()

    {

	 // WDP:We are going to start the test now

	 // Ensure we set paging memory to appropriate cache size for tests which need it

	 //ignore other tests

    TVerdict verdict=SetCacheSize();

    if(verdict!=EPass)

    	{

    	return verdict;

    	}

    // Call the state handler from IDLE state

    FsmL(EVPIdle);

    User::LeaveIfError(iError);

    // Start the scheduler - Done only once !

    CActiveScheduler::Start();

    return iTestStepResult;

    }

//Default SetCache size

TVerdict RTestVclntPlayAviFile::SetCacheSize()

	{

	//Do not try to increase cache size for tests which dont need it

	return EPass;

	}

/**

 * RTestVclntPlayAviFile::FsmL

 */

void RTestVclntPlayAviFile::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        //TInt err = KErrNone;

        switch (aEventCode)

            {

            case EVPIdle:

                // Open iVideoPlayer

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

                TRAP(iError, iVideoPlayer->OpenFileL(iFilename, ControllerUid()));

                PrepareState(EVPOpenComplete, KErrNone);

                break;

            case EVPOpenComplete:

                // Prepare iVideoPlayer

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

                iVideoPlayer->Prepare();

                PrepareState(EVPPrepareComplete, KErrNone);

                break;

            case EVPPrepareComplete:

                iTestStepResult = DoTestL(iVideoPlayer);

                break;

            case EVPPlayComplete:

                iTestStepResult = EPass;

                CActiveScheduler::Stop();

                break;

            }

        }

    }

/**

 * RTestVclntPlayAviFile::DoTestL

 */

TVerdict RTestVclntPlayAviFile::DoTestL(CVideoPlayerUtility* /*aPlayer*/)

    {

    TVerdict ret = EFail;

    if(iPlay)

        {

        iError = KErrTimedOut;

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

        PrepareState(EVPPlayComplete, KErrNone);

        iVideoPlayer->Play();

        }

    else

        {

        CActiveScheduler::Stop();

        ret = EPass;

        }

    return ret;

    }

//

// RTestVclntPlayAviDes

//

/**

 * RTestVclntPlayAviDes::Constructor

 */

RTestVclntPlayAviDes::RTestVclntPlayAviDes(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay)

    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError), iPlay(aPlay)

    {

    iHeapSize = 500000;

    }

/**

 * RTestVclntPlayAviDes::NewL

 */

RTestVclntPlayAviDes* RTestVclntPlayAviDes::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    {

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

    return self;

    }

/**

 * RTestVclntPlayAviDes::NewLC

 */

RTestVclntPlayAviDes* RTestVclntPlayAviDes::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    {

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

    CleanupStack::PushL(self);

    return self;

    }

/**

 * RTestVclntPlayAviDes::DoTestStepPreambleL

 */

TVerdict  RTestVclntPlayAviDes::DoTestStepPreambleL()

    {

    TVerdict preamRes;

    preamRes = EPass;

    // Base DoTestStepPreambleL

    preamRes = RTestVclntAviPlayerStep::DoTestStepPreambleL();

    if (preamRes != EPass)

        {

        return preamRes;

        }

    RFs fs;

    RFile file;

    TInt size = 0;

    // connect to file system and open file

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    User::LeaveIfError(file.Open(fs,iFilename,EFileRead));

    CleanupClosePushL(file);

    // Set HBuf size

    User::LeaveIfError(file.Size(size));

    INFO_PRINTF2(_L("size of file = %d\n"),size);//Statement Changed under DEF105143

	iVideo = HBufC8::NewMaxL(size);

    // read data into Hbuf

    TPtr8 bufferDes(iVideo->Des());

    User::LeaveIfError(file.Read(bufferDes));

    CleanupStack::PopAndDestroy(2); //fs, file

    return preamRes;

    }

/**

 * RTestVclntPlayAviDes::DoTestStepPostambleL

 */

TVerdict RTestVclntPlayAviDes::DoTestStepPostambleL()

    {

    delete iVideo;

    iVideo = NULL;

    return RTestVclntAviPlayerStep::DoTestStepPostambleL();

    }

/**

 * Load and initialise an video descriptor.

 */

TVerdict RTestVclntPlayAviDes::DoTestStepL()

    {

    iTestStepResult = EFail;

    // Call the state handler from IDLE state

    TRAPD(err, FsmL(EVPIdle));

    if (err == KErrNone)

        {

        CActiveScheduler::Start();    

        }

    // Start the scheduler - Done only once !

    return iTestStepResult;

    }

/**

 * RTestVclntPlayAviDes::FsmL

 */

void RTestVclntPlayAviDes::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        //TInt err = KErrNone;

        switch (aEventCode)

            {

            case EVPIdle:

                // Open iVideoPlayer

                INFO_PRINTF2(_L("iVideoPlayer->OpenDesL() %S"), &iFilename);

                TRAP(iError, iVideoPlayer->OpenDesL(iVideo->Des(), ControllerUid()));

                PrepareState(EVPOpenComplete, KErrNone);

                break;

            case EVPOpenComplete:

                // Prepare iVideoPlayer

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

                iVideoPlayer->Prepare();

                PrepareState(EVPPrepareComplete, KErrNone);

                break;

            case EVPPrepareComplete:

                iTestStepResult = DoTestL(iVideoPlayer);

                break;

            case EVPPlayComplete:

                iTestStepResult = EPass;

                CActiveScheduler::Stop();

                break;

            }

        }

    }

/**

 * RTestVclntPlayAviDes::DoTestL

 */

TVerdict RTestVclntPlayAviDes::DoTestL(CVideoPlayerUtility* aPlayer)

    {

    TVerdict ret = EFail;

    if(iPlay)

        {

        iError = KErrTimedOut;

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

        PrepareState(EVPPlayComplete, KErrNone);

        aPlayer->Play();

        }

    else

        {

        CActiveScheduler::Stop();

        ret = EPass;

        }

    return ret;

    }

//

// RTestVclntPlayAviUrl

//

/**

 * RTestVclntPlayAviUrl::Constructor

 */

RTestVclntPlayAviUrl::RTestVclntPlayAviUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError), iPlay(aPlay)

    {

    }

/**

 * RTestVclntPlayAviUrl::NewL

 */

RTestVclntPlayAviUrl* RTestVclntPlayAviUrl::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    {

    RTestVclntPlayAviUrl* self = RTestVclntPlayAviUrl::NewLC(aTestName, aSectName, aKeyName, aExpectedError, aPlay);

    CleanupStack::Pop();

    return self;

    }

/**

 * RTestVclntPlayAviUrl::NewLC

 */

RTestVclntPlayAviUrl* RTestVclntPlayAviUrl::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay)

    {

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

    CleanupStack::PushL(self);

    return self;

    }

/**

 * RTestVclntPlayAviUrl::Constructor

 */

TVerdict RTestVclntPlayAviUrl::DoTestStepL()

    {

    // Call the state handler from IDLE state

    FsmL(EVPIdle);

    // Start the scheduler - Done only once !

    CActiveScheduler::Start();

    return iTestStepResult;

    }

/**

 * RTestVclntPlayAviUrl::FsmL

 */

void RTestVclntPlayAviUrl::FsmL(TVclntTestPlayEvents aEventCode)

    {

    if (FsmCheck(aEventCode))

        {

        switch (aEventCode)

            {

            case EVPIdle:

                // Open iVideoPlayer

                INFO_PRINTF2(_L("iVideoPlayer->OpenUrlL() %S"), &iFilename);

                TRAP(iError,iVideoPlayer->OpenUrlL(iFilename, KUseDefaultIap, KNullDesC8, ControllerUid()));

                PrepareState(EVPOpenComplete, KErrNone);

                break;

            case EVPOpenComplete:

                // Prepare iVideoPlayer

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

                iVideoPlayer->Prepare();

                PrepareState(EVPPrepareComplete, KErrNone);

                break;

            case EVPPrepareComplete:

                iTestStepResult = DoTestL(iVideoPlayer);

                break;

            case EVPPlayComplete:

                CActiveScheduler::Stop();

                iTestStepResult = EPass;

                break;

            }

        }

    }

/**

 * RTestVclntPlayAviUrl::Constructor

 */

TVerdict RTestVclntPlayAviUrl::DoTestL(CVideoPlayerUtility* aPlayer)

    {

    TVerdict ret = EFail;

    if(iPlay)

        {

        iError = KErrTimedOut;

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

        PrepareState(EVPPlayComplete, KErrNone);

        aPlayer->Play();

        }

    else

        {

        CActiveScheduler::Stop();

        ret = EPass;

        }

    return ret;

    }

//

// RTestVclntEnqFrameRate

//

/**

 * RTestVclntEnqFrameRate::Constructor

 */

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

    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)

    {

    iFrameRate = aFrameRate;

    }

/**

 * RTestVclntEnqFrameRate::Constructor

 */

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

    {

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

    return self;

    }

/**

 * RTestVclntEnqFrameRate::Constructor

 */

TVerdict RTestVclntEnqFrameRate::DoTestL(CVideoPlayerUtility* aPlayer)

    {

    INFO_PRINTF1(_L("Test : Video Player - Enquire Frame Rate"));

    TVerdict ret = EFail;

    TReal32 theFrameRate = 0.0;

    TRAPD(err, theFrameRate = aPlayer->VideoFrameRateL());

    INFO_PRINTF3(_L("iVideoPlayer->VideoFrameRateL() = %d...error =%d"), TInt(theFrameRate), err);

    // if we get here, we pass. The iVideoPlayer does not have a SetVideoFrameRate()

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

    PrepareState(EVPPlayComplete, KErrNone);

    aPlayer->Play();

    return ret;

    }

//

// RTestVclntPosition

//

/**

 * RTestVclntPosition::Constructor

 */

RTestVclntPosition::RTestVclntPosition(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aPosition)

    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)

    {

    iPosition = aPosition;

    }

/**

 * RTestVclntPosition::NewL

 */

RTestVclntPosition* RTestVclntPosition::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aPosition)

    {

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

    return self;

    }

/**

 * RTestVclntPosition::DoTestL

 */

TVerdict RTestVclntPosition::DoTestL(CVideoPlayerUtility* aPlayer)

    {

    // NB test video controller is stubbing certain functions. May have to rewrite this

    // for AVI Controller

    TVerdict ret = EFail;

    TInt err = KErrNone;

    TTimeIntervalMicroSeconds pos;

    INFO_PRINTF1(_L("Test : Video Player - Position"));

    INFO_PRINTF3(_L("Set Position = %d, Duration = %d"), I64INT(iPosition.Int64()), I64INT(aPlayer->DurationL().Int64()));

    //  Set position: middle of clip.

    if (I64INT(iPosition.Int64()) == 0)

        {

        iPosition = I64INT(aPlayer->DurationL().Int64()) / 2;

        }

    // Set position: end of clip.

    if (I64INT(iPosition.Int64()) == -1)

        {

        iPosition = aPlayer->DurationL();

        }

    // Position is beyond the end of the clips duration, so check that the value is clipped.

    if(aPlayer->DurationL() < iPosition)

        {

        INFO_PRINTF2(_L("Longer than duration : Setting position to %d"), I64INT(iPosition.Int64()));

        TRAP(err, aPlayer->SetPositionL(iPosition));

        if (err == KErrNotSupported)

            {

            INFO_PRINTF1(_L("SetPositionL() left with Error - KErrNotSupported"));

            }

        TRAP(err, pos = aPlayer->PositionL());

        if (err == KErrNotReady)

            {

            INFO_PRINTF1(_L("PositionL() left with Error - KErrNotReady"));

            }

        INFO_PRINTF3(_L("Set Position = %d (if clipped : %d)"), I64INT(pos.Int64()), I64INT(aPlayer->DurationL().Int64()));

        }