// Copyright (c) 2005-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 "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()));
        }
    
    // Position is negative, so check that the value is clipped.
    else if (I64INT(iPosition.Int64()) < 0)
        {
        INFO_PRINTF2(_L("Negative value : 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_PRINTF2(_L("Set : position = %d (if clipped : 0)"), I64INT(pos.Int64()));
        }
    else
        {
        INFO_PRINTF2(_L("Normal : 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(iPosition.Int64()));
        }

    INFO_PRINTF1(_L("iVideoPlayer->Play()"));
    PrepareState(EVPPlayComplete, KErrNone);
    aPlayer->Play();
    
    
    TRAP(err, pos = aPlayer->PositionL());
    if (err != KErrNone)
        {
        INFO_PRINTF2(_L("PositionL() left with Error - %d"), err);
        ret = EFail;
        }
    
    return ret;
    }


//
// RTestVclntPriority
//

/**
 * RTestVclntPriority::Constructor
 */
RTestVclntPriority::RTestVclntPriority(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aPriority)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iPriority = aPriority;
    }

/**
 * RTestVclntRecordAviFile::Constructor
 */
RTestVclntPriority* RTestVclntPriority::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aPriority)
    {
    RTestVclntPriority* self = new (ELeave) RTestVclntPriority(aTestName, aSectName, aKeyName, aExpectedError, aPriority);
    return self;
    }

/**
 * RTestVclntRecordAviFile::Constructor
 */
TVerdict RTestVclntPriority::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;

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

    aPlayer->SetPriorityL(iPriority, EMdaPriorityPreferenceNone);    
    TInt thePriority = 0;
    TMdaPriorityPreference thePref;
    aPlayer->PriorityL(thePriority, thePref);
    INFO_PRINTF3(_L("Priority = %d (expecting %d)"), thePriority, iPriority);
    INFO_PRINTF3(_L("Pref = %d (expecting %d)"), thePref, EMdaPriorityPreferenceNone);
    
    if( (thePriority == iPriority) && (thePref == EMdaPriorityPreferenceNone) )
        {
        ret = EPass;
        }
        
    CActiveScheduler::Stop();
    
    return ret;
    }


//
// RTestVclntDuration
//

/**
 * RTestVclntDuration::Constructor
 */
RTestVclntDuration::RTestVclntDuration(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aDuration)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iDuration = aDuration;
    }

/**
 * RTestVclntDuration::Constructor
 */
RTestVclntDuration* RTestVclntDuration::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aDuration)
    {
    RTestVclntDuration* self = new (ELeave) RTestVclntDuration(aTestName, aSectName, aKeyName, aExpectedError, aDuration);
    return self;
    }

/**
 * RTestVclntDuration::Constructor
 */
TVerdict RTestVclntDuration::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;
    
    INFO_PRINTF1(_L("Test : Video Player - Duration"));

    if (I64INT(iDuration.Int64()) == 0)
        {
        TInt duration = I64INT(aPlayer->DurationL().Int64());
        INFO_PRINTF1(_L("iVideoPlayer->Play()"));
        PrepareState(EVPPlayComplete, KErrNone);
        aPlayer->Play();
        TTime start;
        start.HomeTime();
        CActiveScheduler::Start();
        TTime stop;
        stop.HomeTime();

        TUint actualDuration = I64INT(stop.MicroSecondsFrom(start).Int64());

        INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d Duration = %d ActualDuration = %d"),
            iError, I64INT(start.Int64()), I64INT(stop.Int64()), duration, actualDuration);
        if((iError == KErrNone) && (TimeComparison(actualDuration, duration, KExpectedDeviation)))
            {
            ret = EPass;
            }
        }
    else
        {
        if(aPlayer->DurationL() == iDuration)
            {
            ret = EPass;
            }
        }
    
    CActiveScheduler::Stop();
    TInt error=UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)iCurrentCacheSize.iMinSize,(TAny*)iCurrentCacheSize.iMaxSize);
    if(CheckCacheError(error)==EInconclusive)
    	{
    	return EInconclusive;
    	}
    INFO_PRINTF3(_L("Setting Cache Min Size to %d,Setting Cache Max Size is %d"),iCurrentCacheSize.iMinSize,iCurrentCacheSize.iMaxSize);
    return ret;
    }

TVerdict RTestVclntDuration::SetCacheSize()
	{
	TVerdict ret=EPass;
	//save the default cache sizes, set the cache size back these values after the test
	TInt error=UserSvr::HalFunction(EHalGroupVM,EVMHalGetCacheSize,&iCurrentCacheSize,0);
	ret=CheckCacheError(error);
	if(ret==EPass)
		{
		error=UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)KCacheSize,(TAny*)KMaxCacheSize);
		ret=CheckCacheError(error);
		}
	return ret;
	}

TVerdict RTestVclntDuration::CheckCacheError(TInt aError)
	{
	TVerdict verdict=EPass;
	#ifdef __WINSCW__
	//Winscw does not support getting cache size. Ignoring -5 error
	if(aError!=KErrNone)
		{
		if(aError!=KErrNotSupported)
			{
			INFO_PRINTF2(_L("Could not get the cache size  %d"),aError);
			return EInconclusive;
			}
		}
	#else
	if(aError!=KErrNone)
		{//For ARMV5 we stop for all errors
		INFO_PRINTF2(_L("Could not get the cache size  %d"),aError);
		return EInconclusive;
		}
	#endif
	return verdict;
	}

//
// RTestVclntVolume
//

/**
 * RTestVclntVolume::Constructor
 */
RTestVclntVolume::RTestVclntVolume(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aVolume)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iVolume = aVolume;
    }

/**
 * RTestVclntVolume::Constructor
 */
RTestVclntVolume* RTestVclntVolume::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aVolume)
    {
    RTestVclntVolume* self = new (ELeave) RTestVclntVolume(aTestName, aSectName, aKeyName, aExpectedError, aVolume);
    return self;
    }

/**
 * RTestVclntVolume::Constructor
 */
TVerdict RTestVclntVolume::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;
    TInt err;
    
    INFO_PRINTF1(_L("Test : Video Player - Volume"));
    
    // see if audio is enabled
    if (aPlayer->AudioEnabledL())
        {
        INFO_PRINTF1(_L("AudioEnabledL() returned True"));
        }
    else
        {
        INFO_PRINTF1(_L("AudioEnabledL() returned False"));   
        }
    
    // Check maxvolume function
    if(iVolume == -1)
        {
        iVolume = aPlayer->MaxVolume();
        TRAP(err, aPlayer->SetVolumeL(iVolume));
        INFO_PRINTF2(_L("Volume should be set to Max Volume. Returned with %d"), err);
        INFO_PRINTF3(_L("Volume = %d (expecting %d)"), aPlayer->Volume(), aPlayer->MaxVolume());
        if(aPlayer->Volume() == aPlayer->MaxVolume())
            {
            ret = EPass;
            }
        }
    // Volume should truncated to maxvolume
    else if(iVolume > aPlayer->MaxVolume())
        {
        TRAP(err, aPlayer->SetVolumeL(iVolume));
        INFO_PRINTF2(_L("Volume should be set to Max Volume. Returned with %d"), err);
        INFO_PRINTF3(_L("Volume = %d, MaxVolume = %d"), aPlayer->Volume(), aPlayer->MaxVolume());
        if(aPlayer->Volume() == aPlayer->MaxVolume())
            {
            ret = EPass;
            }
        }
    // Volume is truncated to 0
    else if(iVolume < 0)
        {
        TRAP(err, aPlayer->SetVolumeL(iVolume));
        INFO_PRINTF2(_L("Volume should be set to Min Volume.Returned with %d"), err);
        INFO_PRINTF2(_L("Volume = %d (expecting 0)"), aPlayer->Volume());
        if(aPlayer->Volume() == 0)
            {
            ret = EPass;
            }
        }
    // Set volume and check
    else
        {
        TRAP(err, aPlayer->SetVolumeL(iVolume));
        INFO_PRINTF2(_L("Volume should be set to the desired value. Retuned with %d"), err);
        INFO_PRINTF3(_L("Volume = %d (expecting %d)"), aPlayer->Volume(), iVolume);
        if(aPlayer->Volume() == iVolume)
            {
            ret = EPass;
            }
        }
    
    CActiveScheduler::Stop();
    
    return ret;
    }

//
// RTestVclntCloseOpen
//

/**
 * RTestVclntCloseOpen::Constructor
 */
RTestVclntCloseOpen::RTestVclntCloseOpen(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iOpenCount = 1;
    }

/**
 * RTestVclntCloseOpen::Constructor
 */
RTestVclntCloseOpen* RTestVclntCloseOpen::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntCloseOpen* self = new (ELeave) RTestVclntCloseOpen(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntCloseOpen::DoTestStepL
 */
TVerdict RTestVclntCloseOpen::DoTestStepL()
    {
    // Call the state handler from IDLE state
    FsmL(EVPIdle);
    
    // Start the scheduler - Done only once !
    CActiveScheduler::Start();
    
    return iTestStepResult;
    }

/**
 * RTestVclntCloseOpen::FsmL
 */
void RTestVclntCloseOpen::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        switch (aEventCode)
            {
            case EVPIdle:
                // Open iVideoPlayer First time
                iOpenCount = 1;
                INFO_PRINTF2(_L("iVideoPlayer->OpenFileL(%S)"), &iFilename);
                TRAP(iError,iVideoPlayer->OpenFileL(iFilename, ControllerUid()));
                PrepareState(EVPOpenComplete, KErrNone);
                break;
            case EVPOpenComplete:
                if (iOpenCount == 1)
                    {
                    // Prepare iVideoPlayer
                    INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));
                    iVideoPlayer->Prepare();
                    PrepareState(EVPPrepareComplete, KErrNone);    
                    }
                else
                    {
                    CActiveScheduler::Stop();
                    iTestStepResult = EPass;
                    break;
                    }
                break;
            case EVPPrepareComplete:
                // Close iVideoPlayer
                CActiveScheduler::Stop();
                INFO_PRINTF1(_L("iVideoPlayer->Close()"));
                iVideoPlayer->Close();
                User::After(KOneSecond);
                // Open iVideoPlayer Second time
                iOpenCount = 2;
                INFO_PRINTF2(_L("iVideoPlayer->OpenFileL(%S)"), &iFilename);
                iVideoPlayer->OpenFileL(iFilename, ControllerUid());
                PrepareState(EVPOpenComplete, KErrNone);
                CActiveScheduler::Start();
                break;
            }
        }
    }

//
// RTestVclntPause
//

/**
 * RTestVclntPause::Constructor
 */
RTestVclntPause::RTestVclntPause(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {}

/**
 * RTestVclntPause::NewL
 */
RTestVclntPause* RTestVclntPause::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntPause* self = new (ELeave) RTestVclntPause(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntPause::DoTestStepL
 */
TVerdict RTestVclntPause::DoTestStepL()
    {
    // Call the state handler from IDLE state
    FsmL(EVPIdle);
    
    // Start the scheduler - Done only once !
    CActiveScheduler::Start();
    
    return iTestStepResult;
    }

/**
 * RTestVclntPause::FsmL
 */
void RTestVclntPause::FsmL(TVclntTestPlayEvents aEventCode)
    {
    TTime stop;
    TTime start = NULL;
    
    if (FsmCheck(aEventCode))
        {
        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:
                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                PrepareState(EVPPlayComplete, KErrNone);
                iVideoPlayer->Play();
                // Pause iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Pause()"));
                TRAPD(err,iVideoPlayer->PauseL());
                if (err == KErrNotSupported)
                    {
                    INFO_PRINTF1(_L("Pause not supported presently"));
                    }
                else
                    {
                    INFO_PRINTF2(_L("Pause() returns with error :  %d"),err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    break;
                    }
                // Stop iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Stop()"));
                iVideoPlayer->Stop();
                // Get the duration of the file.
                iPlayerDuration = I64INT(iVideoPlayer->DurationL().Int64());
                // Resume play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                // Note the start time
                start.HomeTime();    
                break;
            case EVPPlayComplete:
                // Note the stop time
                stop.HomeTime();
                // Get the actual duration
                iActualDuration = I64INT(stop.MicroSecondsFrom(start).Int64());
                INFO_PRINTF6(_L("Error : %d Start = %d Stop = %d PlayerDuration = %d ActualDuration = %d"),
                    iError, I64INT(start.Int64()), I64INT(stop.Int64()), iPlayerDuration, iActualDuration);
                // Check the results
                if((iError == KErrNone) && (TimeComparison(iActualDuration, iPlayerDuration, KExpectedDeviation)))
                    {
                    iTestStepResult = EPass;
                    }
                CActiveScheduler::Stop();
                break;
            }
        }
    }

//
// RTestVclntBalance
//

/**
 * RTestVclntBalance::Constructor
 */
RTestVclntBalance::RTestVclntBalance(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aBalance)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iBalance = aBalance;
    }

/**
 * RTestVclntBalance::NewL
 */
RTestVclntBalance* RTestVclntBalance::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aBalance)
    {
    RTestVclntBalance* self = new (ELeave) RTestVclntBalance(aTestName, aSectName, aKeyName, aExpectedError, aBalance);
    return self;
    }

/**
 * RTestVclntBalance::DoTestL
 */
TVerdict RTestVclntBalance::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;
    TInt err = KErrNone;
    
    INFO_PRINTF1(_L("Test : Video Player - Balance"));
    
    // see if audio is enabled
    if (aPlayer->AudioEnabledL())
        {
        INFO_PRINTF1(_L("AudioEnabledL() returned True"));
        }
    else
        {
        INFO_PRINTF1(_L("AudioEnabledL() returned False"));   
        }
    
    // set the balance
    TRAP(err, aPlayer->SetBalanceL(iBalance));
    INFO_PRINTF2(_L("SetBalanceL() left with Error - %d"), err);
    
    // check for the valid balance    
    if (iBalance < KMinBalance)
        {
        INFO_PRINTF3(_L("Balance = %d (expecting %d)"), aPlayer->Balance(), KMinBalance);
        if(aPlayer->Balance() == KMinBalance)
            {
            ret = EPass;
            }
        }
    else if (iBalance > KMaxBalance)
        {
        INFO_PRINTF3(_L("Balance = %d (expecting %d)"), aPlayer->Balance(), KMaxBalance);
        if(aPlayer->Balance() == KMaxBalance)
            {
            ret = EPass;
            }
        }
    else
        {
        INFO_PRINTF3(_L("Balance = %d (expecting %d)"), aPlayer->Balance(), iBalance);
        if(aPlayer->Balance() == iBalance)
            {
            ret = EPass;
            }
        }
    
    CActiveScheduler::Stop();
    
    return ret;
    }


//
// RTestVclntPlayWindow
//

/**
 * RTestVclntPlayWindow::Constructor
 */
RTestVclntPlayWindow::RTestVclntPlayWindow(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aStart, const TTimeIntervalMicroSeconds aEnd)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iStart = aStart;
    iEnd = aEnd;
    }

/**
 * RTestVclntPlayWindow::Constructor
 */
RTestVclntPlayWindow* RTestVclntPlayWindow::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aStart, const TTimeIntervalMicroSeconds aEnd)
    {
    RTestVclntPlayWindow* self = new (ELeave) RTestVclntPlayWindow(aTestName, aSectName, aKeyName, aExpectedError, aStart, aEnd);
    return self;
    }

/**
 * RTestVclntPlayWindow::Constructor
 */
TVerdict RTestVclntPlayWindow::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;

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

    TPoint rectOrigin(10, 10);
    TSize rectSize(176, 144);
    TRect rect(rectOrigin, rectSize);
    
    TPoint clipOrigin(10, 10);
    TSize clipSize(176, 144);
    TRect clipRect(clipOrigin, clipSize);
    
    TRAPD(err, aPlayer->SetDisplayWindowL(iWs, *iScreen, *iWindow, rect, clipRect));
    if(err)
        {
        ERR_PRINTF2(_L("SetDisplayWindowL() failed, error %d"), err);
        ret = EFail;
        }
    else
        {
        ret = EPass;
        }

    CActiveScheduler::Stop();
        
    return ret;
    }


//
// RTestVclntMeta
//

/**
 * RTestVclntMeta::Constructor
 */
RTestVclntMeta::RTestVclntMeta(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {}

/**
 * RTestVclntMeta::Constructor
 */
RTestVclntMeta* RTestVclntMeta::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntMeta* self = new (ELeave) RTestVclntMeta(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntMeta::Constructor
 */
TVerdict RTestVclntMeta::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    INFO_PRINTF1(_L("Test : Video Player - Metadata"));
    
    CActiveScheduler::Stop();
    
    // there are zero meta entries now.
    TInt numOfMeta = -1;
    TRAPD(err, numOfMeta = aPlayer->NumberOfMetaDataEntriesL() );
    INFO_PRINTF3(_L("Error : %d Entries = %d"), err, numOfMeta);
    if (err != KErrNotSupported || numOfMeta != -1)
        {
        return EFail;
        }
    
    // attempt to get an entry when no entry exists.
    CMMFMetaDataEntry* theEntry=NULL;
    TRAP(err, theEntry = aPlayer->MetaDataEntryL(1));
    INFO_PRINTF2(_L("Error : %d"), err);
    if (err != KErrNotSupported)
        {
        return EFail;
        }
    else 
        {
        delete theEntry;
        return EPass;
        }
    }


//
// RTestVclntFrameSize
//

/**
 * RTestVclntFrameSize::Constructor
 */
RTestVclntFrameSize::RTestVclntFrameSize(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse)
    {
    iFrameSize.iWidth = 0;
    iFrameSize.iHeight = 0;
    }

/**
 * RTestVclntFrameSize::NewL
 */
RTestVclntFrameSize* RTestVclntFrameSize::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntFrameSize* self = new (ELeave) RTestVclntFrameSize(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntFrameSize::DoTestL
 */
TVerdict RTestVclntFrameSize::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;

    INFO_PRINTF1(_L("Test : Video Player - Get Frame Size"));
    TInt err;
    TRAP(err, aPlayer->VideoFrameSizeL(iFrameSize));

    INFO_PRINTF4(_L("Error : %d, Frame size : (%d, %d)"), err, iFrameSize.iWidth, iFrameSize.iHeight);
    if (err == KErrNone && iFrameSize.iWidth >= 0 && iFrameSize.iHeight >= 0 )
        {
        ret = EPass;
        }
    
    CActiveScheduler::Stop();
    
    return ret;
    }

//
// RTestVclntMimeType
//

/**
 * RTestVclntMimeType::Constructor
 */
RTestVclntMimeType::RTestVclntMimeType(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {
    }

/**
 * RTestVclntMimeType::Constructor
 */
RTestVclntMimeType* RTestVclntMimeType::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntMimeType* self = new (ELeave) RTestVclntMimeType(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntMimeType::Constructor
 */
TVerdict RTestVclntMimeType::DoTestL(CVideoPlayerUtility* aPlayer)
    {
        
    TVerdict ret = EFail;
    
    INFO_PRINTF1(_L("Test : Video Player - MimeType"));

    // Get the Video Mime type
    TPtrC8 mimeType = aPlayer->VideoFormatMimeType();

    // take it to a 16-bit string
    TBuf<64> mimeType16;
    mimeType16.Copy(mimeType);
    INFO_PRINTF2(_L("Mime type : \'%S\'"), &mimeType16);
    
    // Check if its valid
    if (mimeType16.Compare(_L("XVID")) == 0)
        {
        INFO_PRINTF1(_L("MIME Types match"));
        ret = EPass;
        }
    
    CActiveScheduler::Stop();
    
    return ret;
    }

//
// RTestVclntScale
//

/**
 * RTestVclntScale::Constructor
 */
RTestVclntScale::RTestVclntScale(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {
    }

/**
 * RTestVclntScale::Constructor
 */
RTestVclntScale* RTestVclntScale::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntScale* self = new (ELeave) RTestVclntScale(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntScale::Constructor
 */
TVerdict RTestVclntScale::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    INFO_PRINTF1(_L("Test : Video Player - Scale Values test"));
    
    CActiveScheduler::Stop();
    
    // Set the scale factor using values set #1
    INFO_PRINTF1(_L("iVideoPlayer->SetScaleFactorL() #1"));
    TRAPD(err, aPlayer->SetScaleFactorL(100, 100, ETrue));

#ifdef SYMBIAN_BUILD_GCE
	TInt expected = iBinaryCompatibility || !GCEAvailable() ? KErrNotSupported : KErrNone;
#else
	TInt expected = KErrNotSupported;
#endif

    if (err != expected)
        {       
        ERR_PRINTF2(_L("iVideoPlayer->SetScaleFactorL() encountered error : %d"), err);
        return EFail;
        }

    return EPass;
    }

//
// RTestVclntCrop
//

/**
 * RTestVclntCrop::Constructor
 */
RTestVclntCrop::RTestVclntCrop(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {
    }

/**
 * RTestVclntCrop::Constructor
 */
RTestVclntCrop* RTestVclntCrop::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntCrop* self = new (ELeave) RTestVclntCrop(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntCrop::Constructor
 */
TVerdict RTestVclntCrop::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TRect cropRegion(KCropRegionRectLeft, KCropRegionRectTop, KCropRegionRectRight, KCropRegionRectBottom);
    TRect region;
    
    INFO_PRINTF1(_L("Test : Video Player - Crop Values"));
    
    CActiveScheduler::Stop();

    // Set the Crop Region
    INFO_PRINTF1(_L("iVideoPlayer->SetCropRegionL()"));
    TRAPD(err, aPlayer->SetCropRegionL(cropRegion));
    
#ifdef SYMBIAN_BUILD_GCE
	TInt expected = iBinaryCompatibility || !GCEAvailable() ? KErrNotSupported : KErrNone;
#else
	TInt expected = KErrNotSupported;
#endif

    if (err != expected)
        {       
        ERR_PRINTF2(_L("iVideoPlayer->SetCropRegionL() encountered error : %d"), err);
        return EFail;
        }

    return EPass;
    }
    
#ifdef SYMBIAN_BUILD_GCE

RTestVclntAutoScale::RTestVclntAutoScale(const TDesC& aTestName)
    : RTestVclntPlayAviFile(aTestName, KNullDesC, KNullDesC, KErrNone, EFalse)
    {
    }

/**
 * RTestVclntCrop::Constructor
 */
RTestVclntAutoScale* RTestVclntAutoScale::NewL(const TDesC& aTestName)
    {
    RTestVclntAutoScale* self = new (ELeave) RTestVclntAutoScale(aTestName);
    return self;
    }

/**
 * RTestVclntCrop::Constructor
 */
TVerdict RTestVclntAutoScale::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    INFO_PRINTF1(_L("Test : Video Player - AutoScale Values"));
    
    CActiveScheduler::Stop();

    // Set auto scale
    INFO_PRINTF1(_L("iVideoPlayer->SetAutoScaleL()"));
    TRAPD(err, aPlayer->SetAutoScaleL(EAutoScaleBestFit));

    if (err != KErrNone)
        {
        ERR_PRINTF2(_L("iVideoPlayer->SetAutoScaleL() encountered error : %d"), err);
        return EFail;
        }

    TRAP(err, aPlayer->SetAutoScaleL(EAutoScaleNone));

    if (err != KErrNone)
        {
        ERR_PRINTF2(_L("iVideoPlayer->SetAutoScaleL() encountered error : %d"), err);
        return EFail;
        }

    TRAP(err, aPlayer->SetAutoScaleL(EAutoScaleClip));

    if (err != KErrNone)
        {
        ERR_PRINTF2(_L("iVideoPlayer->SetAutoScaleL() encountered error : %d"), err);
        return EFail;
        }

    TRAP(err, aPlayer->SetAutoScaleL(EAutoScaleStretch, EHorizontalAlignLeft, EVerticalAlignBottom));

    if (err != KErrNone)
        {
        ERR_PRINTF2(_L("iVideoPlayer->SetAutoScaleL() encountered error : %d"), err);
        return EFail;
        }

    return EPass;
    }

#endif // SYMBIAN_BUILD_GCE

//
// RTestVclntGetFrame
//

/**
 * RTestVclntGetFrame::Constructor
 */
RTestVclntGetFrame::RTestVclntGetFrame(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TBool aUseIntentAPI)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError, EFalse), iUseIntentAPI(aUseIntentAPI)
    {
    }

/**
 * RTestVclntGetFrame::Constructor
 */
RTestVclntGetFrame* RTestVclntGetFrame::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TBool aUseIntentAPI)
    {
    RTestVclntGetFrame* self = new (ELeave) RTestVclntGetFrame(aTestName, aSectName, aKeyName, aExpectedError, aUseIntentAPI);
    return self;
    }

/**
 * RTestVclntGetFrame::DoTestStepL
 */
TVerdict RTestVclntGetFrame::DoTestStepL()
    {
    // Call the state handler from IDLE state
    FsmL(EVPIdle);
    
    // Start the scheduler - Done only once !
    CActiveScheduler::Start();
    
    return iTestStepResult;
    }

/**
 * RTestVclntGetFrame::FsmL
 */
void RTestVclntGetFrame::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        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:
                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                // Call GetFrameL
                if (iUseIntentAPI)
                    {
                    INFO_PRINTF1(_L("iVideoPlayer->GetFrameL() with EPeek Intent"));
                    TRAP(iError, iVideoPlayer->GetFrameL(EColor16M, ContentAccess::EPeek));
                    INFO_PRINTF2(_L("iVideoPlayer->GetFrameL() left with error - %d"), iError);
                    }
                else 
                    {
                    INFO_PRINTF1(_L("iVideoPlayer->GetFrameL()"));
                    TRAP(iError, iVideoPlayer->GetFrameL(EColor16M));
                    INFO_PRINTF2(_L("iVideoPlayer->GetFrameL() left with error - %d"), iError);
                    }
                PrepareState(EVPFrameReady, KErrNone);
            case EVPFrameReady:
                // Stop iVideoPlayer
                iVideoPlayer->Stop();
                CActiveScheduler::Stop();
                iTestStepResult = EPass;
                break;
            }
        }
    }

/**
 * RTestVclntGetFrame::MvpuoFrameReady
 * Overriding the callback method here, to check the bitmap..
 */
void RTestVclntGetFrame::MvpuoFrameReady(CFbsBitmap& aFrame, TInt aError)
    {
    if (aError!=KErrNone)
        {
        iError = aError;
        }
    else if (aFrame.Handle() == NULL || aFrame.SizeInPixels() != TSize(KFrameWidth, KFrameHeight) )
        {
        iError = KErrArgument;
        ERR_PRINTF1(_L("The Frame returned is either NULL or there is a mismatch in the size.."));
        }
    TRAP(iError, FsmL(EVPFrameReady));
    INFO_PRINTF2(_L("Error code : %d"),iError);
    }

    
//
// RTestVclntRebuffering
//

/**
 * RTestVclntRebuffering::Constructor
 */
RTestVclntRebuffering::RTestVclntRebuffering(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {
    }

/**
 * RTestVclntRebuffering::NewL
 */
RTestVclntRebuffering* RTestVclntRebuffering::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntRebuffering* self = new (ELeave) RTestVclntRebuffering(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntRebuffering::DoTestL
 */
TVerdict RTestVclntRebuffering::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    INFO_PRINTF1(_L("Test : Video Player - Rebuffering"));

    aPlayer->RegisterForVideoLoadingNotification(*this);

    INFO_PRINTF1(_L("Rebuffering request completed"));
    
    CActiveScheduler::Stop();
    
    return EPass;
    }

/**
 * RTestVclntRebuffering::MvloLoadingStarted
 */
void RTestVclntRebuffering::MvloLoadingStarted()
    {
    INFO_PRINTF1(_L("RTestVclntRebuffering::MvloLoadingStarted"));
    }

/**
 * RTestVclntRebuffering::MvloLoadingComplete
 */
void RTestVclntRebuffering::MvloLoadingComplete()
    {
    INFO_PRINTF1(_L("RTestVclntRebuffering::MvloLoadingComplete"));
    }

//
// RTestVclntRepeat
//

/**
 * RTestVclntRepeat::Constructor
 */
RTestVclntRepeat::RTestVclntRepeat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TInt aRepeat)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {
    iRepeat = aRepeat;
    }

/**
 * RTestVclntRepeat::NewL
 */
RTestVclntRepeat* RTestVclntRepeat::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TInt aRepeat)
    {
    RTestVclntRepeat* self = new (ELeave) RTestVclntRepeat(aTestName, aSectName, aKeyName, aExpectedError, aRepeat);
    return self;
    }

/**
 * RTestVclntRepeat::DoTestL
  */
  //The commented lines are kept for future implementation
  
TVerdict RTestVclntRepeat::DoTestL(CVideoPlayerUtility* aPlayer)
    {
    TVerdict ret = EFail;

    INFO_PRINTF1(_L("Test : Video Player - Repeats"));
    iRepeat = 1;
    INFO_PRINTF1(_L("Warning : SetRepeats() does not exist in iVideoPlayer API. Repeat count set to 1"));
    
    INFO_PRINTF1(_L("iVideoPlayer->Play()"));
    PrepareState(EVPPlayComplete, KErrNone);
    aPlayer->Play();
    
    CActiveScheduler::Start();
    
    if(iError == KErrNotSupported || iRepeat == 1) 
        {
        ret = EPass;    
        INFO_PRINTF2(_L("Repeat not supported currently : err : %d"),iError);   
        }
    else
        {
        ret = EFail;
        INFO_PRINTF2(_L("Returned with : err : %d"),iError);   
        }    
        
    CActiveScheduler::Stop();
    
    return ret;
    }

//
// RTestVclntDelete
//

/**
 * RTestVclntDelete::Constructor
 */
RTestVclntDelete::RTestVclntDelete(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntPlayAviFile(aTestName, aSectName, aKeyName, aExpectedError,EFalse)
    {}

/**
 * RTestVclntDelete::NewL
 */
RTestVclntDelete* RTestVclntDelete::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
    {
    RTestVclntDelete* self = new (ELeave) RTestVclntDelete(aTestName, aSectName, aKeyName, aExpectedError);
    return self;
    }

/**
 * RTestVclntDelete::DoTestStepL
 */
TVerdict RTestVclntDelete::DoTestStepL()
    {
    // Call the state handler from IDLE state
    FsmL(EVPIdle);
    
    // Start the scheduler - Done only once !
    CActiveScheduler::Start();
    
    return iTestStepResult;
    }

/**
 * RTestVclntDelete::FsmL
 */
void RTestVclntDelete::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        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:
                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                PrepareState(EVPPlayComplete, KErrNone);
                INFO_PRINTF1(_L("delete iVideoPlayer before Play completes"));
                
                iVideoPlayer = NULL;
                delete iVideoPlayer; // destroy iVideoPlayer before play has completed
                
                CActiveScheduler::Stop();
                iTestStepResult = EPass;
                break;
            }
        }
    }

//
// RTestVclntPlayAviFileHandle
//

/**
 * RTestVclntPlayAviFileHandle::Constructor
 */
RTestVclntPlayAviFileHandle::RTestVclntPlayAviFileHandle(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, const TBool aAlloc)
    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError), iAlloc(aAlloc)
    {
    iIsOpen = EFalse;
    }

/**
 * RTestVclntPlayAviFileHandle::NewL
 */
RTestVclntPlayAviFileHandle* RTestVclntPlayAviFileHandle::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aAlloc)
    {
    RTestVclntPlayAviFileHandle* self = new (ELeave) RTestVclntPlayAviFileHandle(aTestName, aSectName, aKeyName, aExpectedError, aAlloc);
    return self;
    }

/**
 * RTestVclntPlayAviFileHandle::NewLC
 */
RTestVclntPlayAviFileHandle* RTestVclntPlayAviFileHandle::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aAlloc)
    {
    RTestVclntPlayAviFileHandle* self = new (ELeave) RTestVclntPlayAviFileHandle(aTestName, aSectName, aKeyName, aExpectedError, aAlloc);
    CleanupStack::PushL(self);
    return self;
    }

/**
 * RTestVclntPlayAviFileHandle::DoTestStepL()
 */
TVerdict RTestVclntPlayAviFileHandle::DoTestStepL()
    {
	if(SetCacheSize()!=KErrNone)
    	{
    	return EInconclusive;
    	}

    if (iAlloc)
        {
        TVerdict iAllocTestStepResult=EPass;
        TInt err = KErrNone;
        TBool result = EFalse;
        
        //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<
        if( PerformTestStepL() != EPass )
            {
            err = iError;
            }

        if (err != KErrNone)
            {
            INFO_PRINTF2(_L("Test error, returned error code =  %d"), err);
            User::Leave(err);
            }
        else
            {
            //Check the iAllocTestStepResult
            if (iAllocTestStepResult != EPass)
                {
                result = ETrue;
                }
            }    
        
        TInt failCount = 1;
        TBool completed = EFalse;
        iAllocTestStepResult = EPass; // TODO check?? assume pass
        TBool reachedEnd = EFalse; // Note: declare outside loop to help with debugging
        for(;;)    
            {
            __UHEAP_SETFAIL(RHeap::EFailNext, failCount);
            __MM_HEAP_MARK;
            
             //INFO_PRINTF2(_L("CVideoPlayerUtility: Alloc Test Loop: %d"), failCount);
            //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<
            TVerdict verdict = EFail;
            TRAP(err, verdict = PerformTestStepL());
            if (err == KErrNone && verdict != EPass)
                {
                err = iError;
                }

            completed = EFalse;
            if (err == KErrNone)
                {
                TAny *testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test
                if (testAlloc == NULL)
                    {
                    reachedEnd = ETrue;
                    failCount -= 1;
                    }
                else
                    {
                    User::Free(testAlloc);    
                    }            
                
                //Check the iAllocTestStepResult
                if (iAllocTestStepResult != EPass)
                    {
                    result = ETrue;
                    }
                
                completed = reachedEnd || result;
                }
            else if (err != KErrNoMemory) // bad error code
                {
                completed = ETrue;
                result = EFail;
                }            

            __MM_HEAP_MARKEND;
            __UHEAP_SETFAIL(RHeap::ENone, 0);

            if (completed)
                {
                break; // exit loop
                }

            failCount++;
            }

        failCount -= 1; // Failcount of 1 equates to 0 successful allocs, etc

        if (err != KErrNone || result)
            {
            iAllocTestStepResult = EFail;
            TBuf<80> format;
            if (result)
                {
                format.Format(_L("  Bad result with %d memory allocations tested\n"), failCount);
                }
            else
                {
                format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);
                }
            Log(format);
            }
        else 
            {
            TBuf<80> format;
            format.Format(_L("  Completed OK with %d memory allocations tested\n"), failCount);
            Log(format);
            }
    	TUint defaultCacheSize = 0; 
    	//Done with the test. Setting 0 makes the cache size revert back to boot up values
    	TInt error=UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)defaultCacheSize,(TAny*)defaultCacheSize);
        if(CheckCacheError(error)!=KErrNone)
        	{
        	INFO_PRINTF1(_L("Could not revert the cache size to default"));
        	iAllocTestStepResult=EInconclusive;
        	}
        return iAllocTestStepResult;
        }
    else
        {
        return( PerformTestStepL() );    
        }
    }

/**
 * RTestVclntPlayAviFileHandle::PerformTestStepL()
 */
TVerdict RTestVclntPlayAviFileHandle::PerformTestStepL()
    {
    INFO_PRINTF1(_L("Test : Video Player - OpenFileL(RFile&)"));
    
    // Connect to RFs
    User::LeaveIfError(iFs.Connect());
    User::LeaveIfError(iFs.ShareProtected());
    CleanupClosePushL(iFs);
    
    // Open RFile
    User::LeaveIfError(iFile.Open(iFs, iFilename, EFileRead));
    CleanupClosePushL(iFile);
    
    // Call the state handler from IDLE state
    iError = KErrNone;
    PrepareState(EVPIdle, KErrNone);
    FsmL(EVPIdle);
    
    // Start the scheduler - Done only once !
    CActiveScheduler::Start();
    
    CleanupStack::PopAndDestroy(2);
    
    // Leave if the Expected error is KErrNone    
    if (iTestExpectedError == KErrNone)
        {
        User::LeaveIfError(iError);
        }

    return iTestStepResult;
    }


/**
 * RTestVclntPlayAviFileHandle::FsmL()
 */
void RTestVclntPlayAviFileHandle::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        switch (aEventCode)
            {
            case EVPIdle:
                // Open iVideoPlayer
                if ((iTestStepName.Compare(_L("MM-MMF-VCLNTAVI-I-1013-HP")) == 0) ||
                	(iTestStepName.Compare(_L("MM-MMF-VCLNTAVI-I-9113-HP")) == 0))
                    {
                    INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S with Invalid Controller UID"), &iFilename);
                    TRAP(iError, iVideoPlayer->OpenFileL(iFile, KVideoInvalidControllerUid));
                    INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() returned error - %d"), iError);
                    PrepareState(EVPOpenComplete, KErrNone);
                    }
                else
                    {
                    INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);
                	iVideoPlayer->OpenFileL(iFile, ControllerUid());
                    PrepareState(EVPOpenComplete, KErrNone);
                    }
                break;
            case EVPOpenComplete:
                iIsOpen = ETrue; //-set iIsOpen flag (for closing Player, in case of Underflow)...
                // Prepare iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));
                PrepareState(EVPPrepareComplete, KErrNone);
                iVideoPlayer->Prepare();
                break;
            case EVPPrepareComplete:
                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                PrepareState(EVPPlayComplete, KErrNone);
                break;
            case EVPPlayComplete:
                iVideoPlayer->Stop();
                iVideoPlayer->Close();
                CActiveScheduler::Stop();
                iTestStepResult = EPass;
                break;
            }
        }
    else if(iIsOpen)
        {
        iVideoPlayer->Close();
        }
    }

TInt RTestVclntPlayAviFileHandle::SetCacheSize()
	{
	TInt error=UserSvr::HalFunction(EHalGroupVM,EVMHalSetCacheSize,(TAny*)KCacheSize,(TAny*)KMaxCacheSize);
	TInt ret=CheckCacheError(error);
		
	return ret;
	}

TInt RTestVclntPlayAviFileHandle::CheckCacheError(TInt aError)
	{
	TInt ret=KErrNone;
	#ifdef __WINSCW__
	//Winscw does not support getting cache size. Ignoring -5 error
	if(aError!=KErrNone)
		{
		if(aError!=KErrNotSupported)
			{
			INFO_PRINTF2(_L("Could not get the cache size  %d"),aError);
			ret=aError;
			}
		}
	#else
	if(aError!=KErrNone)
		{//For ARMV5 we stop for all errors
		INFO_PRINTF2(_L("Could not get the cache size  %d"),aError);
		ret=aError;
		}
	#endif
	return ret;
	}


//
// RTestVideoPlayCapabilityVelocity
//

/**
RTestVideoPlayCapabilityVelocity::Constructor
*/
RTestVideoPlayCapabilityVelocity::RTestVideoPlayCapabilityVelocity(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)
    { ;
    }

/**
RTestVideoPlayCapabilityVelocity::NewL
*/
RTestVideoPlayCapabilityVelocity* RTestVideoPlayCapabilityVelocity::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
	{
    RTestVideoPlayCapabilityVelocity* self = new (ELeave) RTestVideoPlayCapabilityVelocity(aTestName, aSectName, aKeyName, aExpectedError);
    return self;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
    }

/**
RTestVideoPlayCapabilityVelocity::DoTestStepL()
*/
TVerdict RTestVideoPlayCapabilityVelocity::DoTestStepL()
    {
    // Call the state handler from IDLE state
    TRAPD(err, FsmL(EVPIdle));
    if (err == KErrNone)
        {
        // Start the scheduler - Done only once !
        CActiveScheduler::Start();    
        }
    return iTestStepResult;  
    }
/**
RTestVideoPlayCapabilityVelocity::FsmL()
*/
void RTestVideoPlayCapabilityVelocity::FsmL(TVclntTestPlayEvents aEventCode)
    {
    const TUint KVelocityDefault = 100;
    const TUint KVelocityMinPositive = 1;
    const TInt KVelocityMinNegative = -1;
    const TUint KVelocityPositive = 200;
    const TUint KVelocityBigPositive = 500;
    const TInt KVelocityNegative = -200;
    const TInt KVelocityBigNegative= -500;
    //Set default value for PlayRateCapability
    iVideoPlayRateCapabilities.iStepForward = 1;
    iVideoPlayRateCapabilities.iPlayBackward = 0;
    if (FsmCheck(aEventCode))
        {
        TInt err;
        switch (aEventCode)
            {
            case EVPIdle:
	        	//Calling GetPlayRateCapabilitiesL() before opening should return KErrNotReady.
	        	INFO_PRINTF1(_L("iVideoPlayer->GetPlayRateCapabilitiesL()"));            	
	            TRAP(err,iVideoPlayer->GetPlayRateCapabilitiesL(iVideoPlayRateCapabilities));
	            if( err != KErrNotReady)
	            	{
	            	INFO_PRINTF2(_L("GetPlayRateCapabilitiesL returned wrong err= %d"), err);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;                	
	            	}
	            iPlayVelocity = KVelocityDefault;
	        	//Calling SetPlayVelocityL() before opening should return KErrNotReady.
	        	INFO_PRINTF2(_L("iVideoPlayer->SetPlayVelocityL(%d)"),iPlayVelocity);
                TRAP(err, iVideoPlayer->SetPlayVelocityL(iPlayVelocity));
                if(KErrNotReady != err)
                	{
                	INFO_PRINTF2(_L("SetPlayVelocityL returned wrong err= %d"), err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
                	}

                //calling PlayVelocityL before opening should result in error KErrNotReady
            	INFO_PRINTF1(_L("iVideoPlayer->PlayVelocityL()"));            	
                TRAP(err, iPlayVelocity = iVideoPlayer->PlayVelocityL());
                if( err != KErrNotReady)
                	{
                	INFO_PRINTF2(_L("PlayVelocityL returned wrong err= %d"), err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
                	}
                
                // Open iVideoPlayer
                INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);
                iVideoPlayer->OpenFileL(iFilename);
                PrepareState(EVPOpenComplete, KErrNone);
                break;
            case EVPOpenComplete:
            	//Get playrate capabilities
            	INFO_PRINTF1(_L("iVideoPlayer->GetPlayRateCapabilitiesL()"));            	
                TRAP(err,iVideoPlayer->GetPlayRateCapabilitiesL(iVideoPlayRateCapabilities));
                if( err != KErrNone)
                	{
                	INFO_PRINTF2(_L("GetPlayRateCapabilitiesL returned err= %d"), err);
                	INFO_PRINTF1(_L("invalid TPlayRateCapabilities"));
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;                	
                	}
            	INFO_PRINTF2(_L("iVideoPlayRateCapabilities.iPlayForward= %d"), iVideoPlayRateCapabilities.iPlayForward);
                INFO_PRINTF2(_L("iVideoPlayRateCapabilities.iPlayBackward= %d"), iVideoPlayRateCapabilities.iPlayBackward);
                INFO_PRINTF2(_L("iVideoPlayRateCapabilities.iStepForward= %d"), iVideoPlayRateCapabilities.iStepForward);
                INFO_PRINTF2(_L("iVideoPlayRateCapabilities.iStepBackward= %d"), iVideoPlayRateCapabilities.iStepBackward);                
                if ((iVideoPlayRateCapabilities.iPlayForward != 0) && (iVideoPlayRateCapabilities.iPlayForward != 1)||
                	(iVideoPlayRateCapabilities.iPlayBackward != 0) && (iVideoPlayRateCapabilities.iPlayBackward != 1)||
                	(iVideoPlayRateCapabilities.iStepForward != 0) && (iVideoPlayRateCapabilities.iStepForward != 1)||
                	(iVideoPlayRateCapabilities.iStepBackward != 0) && (iVideoPlayRateCapabilities.iStepBackward != 1) )
                	{
                	INFO_PRINTF1(_L("invalid TPlayRateCapabilities"));
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
                	}
                
                //Get default play velocity, it shall be 100.
            	INFO_PRINTF1(_L("iVideoPlayer->PlayVelocityL()"));            	
                TRAP(err, iPlayVelocity = iVideoPlayer->PlayVelocityL());
                if( err != KErrNone)
                	{
                	INFO_PRINTF2(_L("PlayVelocityL returned err= %d"), err);
                	INFO_PRINTF1(_L("invalid TPlayRateCapabilities"));
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;                	
                	}
            	
            	if( iPlayVelocity != KVelocityDefault )
            		{
                	INFO_PRINTF2(_L("invalid default play velocity =%d"), iPlayVelocity);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
            		}
            	
                // Prepare iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));
                PrepareState(EVPPrepareComplete, KErrNone);
                iVideoPlayer->Prepare();
                break;
            case EVPPrepareComplete:
            	//Try to set different play velocities and play.
	        	INFO_PRINTF2(_L("iVideoPlayer->SetPlayVelocityL(%d)"),iPlayVelocity);
                TRAP(err, iVideoPlayer->SetPlayVelocityL(iPlayVelocity));
                if(KErrNotSupported == err)
                	{
                	if(iVideoPlayRateCapabilities.iPlayForward || iVideoPlayRateCapabilities.iPlayBackward)
                		{
	                	INFO_PRINTF2(_L("SetPlayVelocityL returned err= %d"), err);
	                    iTestStepResult = EFail;
	                    CActiveScheduler::Stop();
	                    return;                	
                		}
                	INFO_PRINTF1(_L("SetPlayVelocityL returned err KErrNotSupported"));
                	}
                else if( err != KErrNone)
                	{
                	INFO_PRINTF2(_L("SetPlayVelocityL returned err= %d"), err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;                	
                	}	        	
                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                PrepareState(EVPPlayComplete, KErrNone);
                break;
            case EVPPlayComplete:
                //Try to set different play velocities and play.
                if (iVideoPlayRateCapabilities.iPlayForward )
                	{
	                if (iPlayVelocity == KVelocityDefault)
	                	{
	                	iPlayVelocity = KVelocityMinPositive;
	                	}
	                else if(iPlayVelocity == KVelocityMinPositive)
	                	{
	                	iPlayVelocity = KVelocityPositive;
	                	}
	                else if(iPlayVelocity == KVelocityPositive)
	                	{
	                	iPlayVelocity = KVelocityBigPositive;
	                	}
                	}
                if (iVideoPlayRateCapabilities.iPlayBackward )
                	{
	                if (iPlayVelocity == KVelocityBigPositive)
	                	{
	                	iPlayVelocity = KVelocityMinNegative;
	                	}
	                else if(iPlayVelocity == KVelocityMinNegative)
	                	{
	                	iPlayVelocity = KVelocityNegative;
	                	}
	                else if(iPlayVelocity == KVelocityNegative)
	                	{
	                	iPlayVelocity = KVelocityBigNegative;
	                	}
	                else if(iPlayVelocity == KVelocityBigNegative)
	                	{
		                iVideoPlayer->Close();
		                CActiveScheduler::Stop();
		                iTestStepResult = EPass;
		                return;
	                	}
                	}

                //Set next velocity
                INFO_PRINTF2(_L("iVideoPlayer->SetPlayVelocityL(%d)"),iPlayVelocity);
                TRAP(err,iVideoPlayer->SetPlayVelocityL(iPlayVelocity));
                if ( err == KErrNotSupported )
                	{
                		INFO_PRINTF1(_L("iVideoPlayer->SetPlayVelocityL returned KErrNotSupported"));
                		if( (iPlayVelocity >0) && iVideoPlayRateCapabilities.iPlayForward)
                			{
                    		INFO_PRINTF1(_L("PlayVelocity and capabilities are valid, still returned KErrNotSupported!!"));
                        	User::Leave(err);
                			}
                		else if( (iPlayVelocity <0) && iVideoPlayRateCapabilities.iPlayBackward)
                			{
                    		INFO_PRINTF1(_L("PlayVelocity and capabilities are valid still returned KErrNotSupported!!"));                			
                        	User::Leave(err);                			
                			}
                		else
                			{
                            // Play The file once again to test with different play velocity.
                            INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                            iVideoPlayer->Play();
                            PrepareState(EVPPlayComplete, KErrNone);             			
                			}
                	}
                else if (err != KErrNone)
                	{
                    INFO_PRINTF2(_L("iVideoPlayer->SetPlayVelocityL returned (%d)"),err);                	
                	User::Leave(err);
                	}
                else //Success case
                	{
                    // Play The file once again to test with different play velocity.
                    INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                    iVideoPlayer->Play();
                    PrepareState(EVPPlayComplete, KErrNone);                	
                	}
                
                if ((!iVideoPlayRateCapabilities.iPlayForward ) && (!iVideoPlayRateCapabilities.iPlayBackward ))
                	{
                    INFO_PRINTF1(_L("Both forward and backward is not supported"));
                    INFO_PRINTF1(_L("Pass the test, error checking for API SetPlayVelocity is already done."));
	                iVideoPlayer->Close();
	                CActiveScheduler::Stop();
	                iTestStepResult = EPass;
	                return;                	
                	}
                break;
            }
        }
    }


//
// RTestVideoPlayStepFrame
//

/**
RTestVideoPlayStepFrame::Constructor
*/
RTestVideoPlayStepFrame::RTestVideoPlayStepFrame(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError), iTimer(NULL)
    {
    }

/**
RTestVideoPlayStepFrame::NewL
*/
RTestVideoPlayStepFrame* RTestVideoPlayStepFrame::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
	{
    RTestVideoPlayStepFrame* self = new (ELeave) RTestVideoPlayStepFrame(aTestName, aSectName, aKeyName, aExpectedError);
    return self;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
    }

/**
RTestVideoPlayStepFrame::DoTestStepL()
*/
TVerdict RTestVideoPlayStepFrame::DoTestStepL()
    {
	iTimer = CPeriodic::NewL(CActive::EPriorityHigh);
    // Call the state handler from IDLE state
    TRAPD(err, FsmL(EVPIdle));
    if (err == KErrNone)
        {
        // Start the scheduler - Done only once !
        CActiveScheduler::Start();    
        }
	delete iTimer;    
    return iTestStepResult;
    }

/**
RTestVideoPlayStepFrame::FsmL()
*/
void RTestVideoPlayStepFrame::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        TInt err = KErrNone;
    	TInt frame = 0xff;
    	TBool pauseSupported = ETrue;    	
        const TUint KStepForwardZeroFrame = 0;            	
        const TUint KStepForwardOneFrame = 1;
        const TInt KStepBackwardOneFrame = -1;
        const TUint KStepForwardFourFrames = 4;
        const TInt KStepBackwardFourFrames = -4;  
        
        switch (aEventCode)
            {
            case EVPIdle:
	            // Calling StepFrameL() before Opeing file should result KErrNotReady.
	            INFO_PRINTF2(_L("iVideoPlayer->StepFrameL(%d)"),1);
	            TRAP(err,iVideoPlayer->StepFrameL(1));
	            if(err != KErrNotReady)
	            	{
	            	INFO_PRINTF2(_L("StepFrameL returned wrong err= %d"), KErrNotReady);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;	            	
	            	}
            
                // Open iVideoPlayer
                INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);
                iVideoPlayer->OpenFileL(iFilename);
                PrepareState(EVPOpenComplete, KErrNone);
                break;
            case EVPOpenComplete:
            	//Get playrate capabilities
            	INFO_PRINTF1(_L("iVideoPlayer->GetPlayRateCapabilitiesL()"));            	
                TRAP(err,iVideoPlayer->GetPlayRateCapabilitiesL(iVideoPlayRateCapabilities));
                if( err != KErrNone)
                	{
                	INFO_PRINTF2(_L("GetPlayRateCapabilitiesL returned err= %d"), err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
                	}
                // Calling StepFrameL() in non-pause state should result KErrNotReady.
                INFO_PRINTF2(_L("iVideoPlayer->StepFrameL(%d)"),1);
	            TRAP(err,iVideoPlayer->StepFrameL(1));
	            if(err != KErrNotReady)
	            	{
                	INFO_PRINTF2(_L("StepFrameL returned wrong err= %d"), KErrNotReady);	            	
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;	            	
	            	}
	            	
                // Prepare iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));
                PrepareState(EVPPrepareComplete, KErrNone);
                iVideoPlayer->Prepare();
                break;
            case EVPPrepareComplete:
	            // Play iVideoPlayer
	            INFO_PRINTF1(_L("iVideoPlayer->Play()"));
	            iVideoPlayer->Play();

                //wait for 1Second to pause the playback.
                INFO_PRINTF1(_L("calling User::After(KOneSecond);"));
                User::After(KOneSecond);
                
            	/* 
				Pause the playback, if pause is not supported wait for play to complete.
				In case of any other err fail the test with appropriate error code.
				*/
			    TRAP(err, iVideoPlayer->PauseL());

			    if( err == KErrNotSupported)
			    	{
			    	pauseSupported = EFalse;			    	
			    	PrepareState(EVPPlayComplete, KErrNone);
			    	}
			    else if( err != KErrNone)
			    	{
				    INFO_PRINTF2(_L("PauseL has returned error =%d"), err);
		            iVideoPlayer->Stop();
		            iVideoPlayer->Close();
		            CActiveScheduler::Stop();
		            iTestStepResult = EFail;			    	
		            return;
			    	}                
			    
			    INFO_PRINTF1(_L("Playback paused"));
         	
            	//Call StepFrameL with different step values.
            	while(1)
            		{
            		if( frame == 0xff)
            			frame = KStepForwardZeroFrame;
            		else if (frame == KStepForwardZeroFrame)
            			frame = KStepForwardOneFrame;
            		else if (frame == KStepForwardOneFrame)
            			frame = KStepForwardFourFrames;
            		else if (frame == KStepForwardFourFrames)
            			frame = KStepBackwardOneFrame;
            		else if (frame == KStepBackwardOneFrame)
            			frame = KStepBackwardFourFrames;
            		else if (frame == KStepBackwardFourFrames)
            			{
                        INFO_PRINTF1(_L("iVideoPlayer->Stop"));
                        iVideoPlayer->Stop();
                        iVideoPlayer->Close();
                        CActiveScheduler::Stop();
                        iTestStepResult = EPass;
            			return; //Break the while loop
            			}
	            	INFO_PRINTF2(_L("iVideoPlayer->StepFrameL(%d)"),frame);
		            TRAP(err,iVideoPlayer->StepFrameL(frame));
		            if(err == KErrNotSupported)
		            	{
		            	if( ((iVideoPlayRateCapabilities.iStepForward) && (frame>0)) ||
	            			((iVideoPlayRateCapabilities.iStepBackward) && (frame<0))   )
		            		{
			            	INFO_PRINTF2(_L("StepFrameL returned wrong err= %d"), err);
			                iTestStepResult = EFail;
			                CActiveScheduler::Stop();
			                return;
		            		}
		            	INFO_PRINTF1(_L("StepFrameL returned KErrNotSupported"));
		            	continue;
		            	}
		            else if( (err == KErrNotReady) && (!pauseSupported) )
		            	{
		            	INFO_PRINTF1(_L("pause is not supported in controller plugin. Returned correct err(KErrNotReady)"));
		            	continue;
		            	}
		            else if( err != KErrNone)
                    	{
                    	INFO_PRINTF2(_L("StepFrameL returned err= %d"), err);
                        iTestStepResult = EFail;
                        CActiveScheduler::Stop();
                        break;
                    	}            		
            		}
                break;
            case EVPPlayComplete:
            	INFO_PRINTF1(_L("Plyback completed before pausing!!"));
            	INFO_PRINTF1(_L("Video clip is too small to run this test step"));
	            INFO_PRINTF1(_L("iVideoPlayer->Stop"));
	            iVideoPlayer->Stop();
	            iVideoPlayer->Close();
	            CActiveScheduler::Stop();
	            iTestStepResult = EInconclusive;
	            return;
            }
        }
    }

//
// RTestVideoPlayAudVidEnable.
//

/**
 * RTestVideoPlayAudVidEnable::Constructor
 */
RTestVideoPlayAudVidEnable::RTestVideoPlayAudVidEnable(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)
    {
    }

/**
 * RTestVideoPlayAudVidEnable::NewL
 */
RTestVideoPlayAudVidEnable* RTestVideoPlayAudVidEnable::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
	{
    RTestVideoPlayAudVidEnable* self = new (ELeave) RTestVideoPlayAudVidEnable(aTestName, aSectName, aKeyName, aExpectedError);
    return self;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
    }

/**
 * RTestVideoPlayAudVidEnable::DoTestStepL()
 */
TVerdict RTestVideoPlayAudVidEnable::DoTestStepL()
    {
    // Call the state handler from IDLE state
    TRAPD(err, FsmL(EVPIdle));
    if (err == KErrNone)
        {
        // Start the scheduler - Done only once !
        CActiveScheduler::Start();    
        }
    return iTestStepResult;  
    }
/**
 * RTestVideoPlayAudVidEnable::FsmL()
 */
void RTestVideoPlayAudVidEnable::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        TInt err = KErrNone;
    	TBool enableFlag = EFalse;
    	
        switch (aEventCode)
            {
            case EVPIdle:
	            //Calling SetAudioEnabledL() before opening file should return KErrNotReady
	        	INFO_PRINTF1(_L("iVideoPlayer->SetAudioEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetAudioEnabledL(ETrue));
	            if (err != KErrNotReady)
	            	{
	            	INFO_PRINTF2(_L("SetAudioEnabledL returned wrong error code= %d"), err);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;
	            	}
	            //Calling SetVideoEnabledL() before opening file should return KErrNotReady
	        	INFO_PRINTF1(_L("iVideoPlayer->SetVideoEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetVideoEnabledL(ETrue));
	            if (err != KErrNotReady)
	            	{
	            	INFO_PRINTF2(_L("SetVideoEnabledL returned wrong error code= %d"), err);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;
	            	}
	            //Calling VideoEnabledL() before opening file should return KErrNotReady
	        	INFO_PRINTF1(_L("iVideoPlayer->VideoEnabledL()"));            	
	            TRAP(err, iVideoPlayer->VideoEnabledL());
	            if(err != KErrNotReady)
	            	{
	            	INFO_PRINTF2(_L("VideoEnabledL returned wrong error code= %d"), err);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;
	            	}
                // Open iVideoPlayer
                INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);
                iVideoPlayer->OpenFileL(iFilename);
                PrepareState(EVPOpenComplete, KErrNone);
                break;
            case EVPOpenComplete:
            	//Check that by default audio is enabled.
	        	INFO_PRINTF1(_L("iVideoPlayer->AudioEnabledL()"));            	
	            TRAP(err,enableFlag = iVideoPlayer->AudioEnabledL());
	            if( (err != KErrNone) || (enableFlag != (TBool)ETrue) )
	            	{
                	INFO_PRINTF3(_L("AudioEnabledL Leave err= %d, returned:%d"), err,enableFlag);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
	            	}

            	//Check that by default video is enabled.
	        	INFO_PRINTF1(_L("iVideoPlayer->VideoEnabledL()"));            	
	            TRAP(err,enableFlag = iVideoPlayer->VideoEnabledL());
	            if( (err != KErrNone) || (enableFlag != (TBool)ETrue) )
	            	{
                	INFO_PRINTF3(_L("VideoEnabledL Leave err= %d, returned:%d"), err,enableFlag);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
	            	}
            	
	            //Try to disable audio, It shall leave with notsupported error.
	        	INFO_PRINTF1(_L("iVideoPlayer->SetAudioEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetAudioEnabledL(ETrue));
	            if (err != KErrNotSupported)
	            	{
                	INFO_PRINTF2(_L("SetAudioEnabledL returned wrong error code= %d"), err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
	            	}

	            //Try to disable video, It shall leave with notsupported error.
	        	INFO_PRINTF1(_L("iVideoPlayer->SetVideoEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetVideoEnabledL(ETrue));
	            if (err != KErrNotSupported)
	            	{
                	INFO_PRINTF2(_L("SetVideoEnabledL returned wrong error code= %d"), err);
                    iTestStepResult = EFail;
                    CActiveScheduler::Stop();
                    return;
	            	}
	            
                // Prepare iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));
                PrepareState(EVPPrepareComplete, KErrNone);
                iVideoPlayer->Prepare();
                break;
            case EVPPrepareComplete:
	            //Enabling/disabling audio after prepare() shall return KErrNotSupported error.
	        	INFO_PRINTF1(_L("iVideoPlayer->SetAudioEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetAudioEnabledL(ETrue));
	            if(err != KErrNotSupported)
	            	{
	            	INFO_PRINTF2(_L("SetAudioEnabledL returned wrong error code= %d"), err);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;
	            	}

	            //Enabling/disabling video after prepare() shll return KErrNotSupported error.
	        	INFO_PRINTF1(_L("iVideoPlayer->SetVideoEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetVideoEnabledL(ETrue));
	            if(err != KErrNotSupported)
	            	{
	            	INFO_PRINTF2(_L("SetVideoEnabledL returned wrong error code= %d"), err);
	                iTestStepResult = EFail;
	                CActiveScheduler::Stop();
	                return;
	            	}

                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                PrepareState(EVPPlayComplete, KErrNone);

                //calling SetAudioEnabledL while playing should return KErrNotReady
	        	INFO_PRINTF1(_L("iVideoPlayer->SetAudioEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetAudioEnabledL(ETrue));
	            if (err != KErrNotReady)
	            	{
                	INFO_PRINTF2(_L("SetAudioEnabledL returned wrong error code= %d"), err);
                    iTestStepResult = EFail;
                    iVideoPlayer->Stop();
                    iVideoPlayer->Close();                    
                    CActiveScheduler::Stop();
                    return;
	            	}

	            //calling SetVideoEnabledL while playing should return KErrNotReady
	        	INFO_PRINTF1(_L("iVideoPlayer->SetVideoEnabledL()"));            	
	            TRAP(err, iVideoPlayer->SetVideoEnabledL(ETrue));
	            if (err != KErrNotReady)
	            	{
                	INFO_PRINTF2(_L("SetVideoEnabledL returned wrong error code= %d"), err);
                    iTestStepResult = EFail;
                    iVideoPlayer->Stop();
                    iVideoPlayer->Close();                    
                    CActiveScheduler::Stop();
                    return;
	            	}

	            break;
            case EVPPlayComplete:
                INFO_PRINTF1(_L("iVideoPlayer->Stop"));
                iVideoPlayer->Stop();
                iVideoPlayer->Close();
                CActiveScheduler::Stop();
                iTestStepResult = EPass;
                break;
            }
        }
    }


//
// RTestVideoPlayAutoScale.
//

/**
 * RTestVideoPlayAutoScale::Constructor
 */
RTestVideoPlayAutoScale::RTestVideoPlayAutoScale(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
    : RTestVclntAviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)
    {
    }

/**
 * RTestVideoPlayAutoScale::NewL
 */
RTestVideoPlayAutoScale* RTestVideoPlayAutoScale::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
	{
    RTestVideoPlayAutoScale* self = new (ELeave) RTestVideoPlayAutoScale(aTestName, aSectName, aKeyName, aExpectedError);
    return self;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
    }

/**
 * RTestVideoPlayAutoScale::DoTestStepL()
 */
TVerdict RTestVideoPlayAutoScale::DoTestStepL()
    {
    // Call the state handler from IDLE state
    TRAPD(err, FsmL(EVPIdle));
    if (err == KErrNone)
        {
        // Start the scheduler - Done only once !
        CActiveScheduler::Start();    
        }
    return iTestStepResult;  
    }
/**
 * RTestVideoPlayAutoScale::FsmL()
 */
void RTestVideoPlayAutoScale::FsmL(TVclntTestPlayEvents aEventCode)
    {
    if (FsmCheck(aEventCode))
        {
        TInt err = KErrNone;
        TAutoScaleType scaleType = EAutoScaleNone;
        THorizontalAlign horizontalAlign = EHorizontalAlignCenter;
        TVerticalAlign verticalAlign = EVerticalAlignCenter;
        
        switch (aEventCode)
            {
            case EVPIdle:
            	//Calling SetAutoScaleL() before opening file should return KErrNotReady error.
	            INFO_PRINTF1(_L("Calling SetAutoScaleL(EAutoScaleNone);"));
	            TRAP(err, iVideoPlayer->SetAutoScaleL(EAutoScaleNone));
	            if( err != KErrNotReady)
	            	{
	                INFO_PRINTF2(_L("SetAutoScaleL() returned wrong error=%d"),err);
                    CActiveScheduler::Stop();
                    iTestStepResult = EFail;	    	                        
                    return;	                
	            	}
	            
                // Open iVideoPlayer
                INFO_PRINTF2(_L("iVideoPlayer->OpenFileL() %S"), &iFilename);
                iVideoPlayer->OpenFileL(iFilename);
                PrepareState(EVPOpenComplete, KErrNone);
                break;
            case EVPOpenComplete:
                // Prepare iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Prepare()"));
                PrepareState(EVPPrepareComplete, KErrNone);
                iVideoPlayer->Prepare();
                break;
            case EVPPrepareComplete:
                // Play iVideoPlayer
                INFO_PRINTF1(_L("iVideoPlayer->Play()"));
                iVideoPlayer->Play();
                PrepareState(EVPPlayComplete, KErrNone);

                /*
                Wait for 1/4th of a second each time and call SetAutoScaleL multiple times
                with different scale parameters.
                This loop tests only "void SetAutoScaleL(TAutoScaleType aScaleType);"
                */
               
                while(1)
                	{
    	            switch(scaleType)
		            	{
		            	case EAutoScaleNone:
		            		scaleType = EAutoScaleBestFit;
		            		break;
		            	case EAutoScaleBestFit:
		            		scaleType = EAutoScaleClip;
		            		break;
		            	case EAutoScaleClip:
		            		scaleType = EAutoScaleStretch;
		            		break;
		            	case EAutoScaleStretch:
		            		scaleType = EAutoScaleNone;		            		
		            		break;
		            	}
                    INFO_PRINTF1(_L("calling User::After(KOneSecond/4);"));
                    User::After(KOneSecond/4);
                    
                    INFO_PRINTF1(_L("Calling SetAutoScaleL();"));
    	            TRAP(err, iVideoPlayer->SetAutoScaleL(scaleType));
    	            
#ifdef SYMBIAN_BUILD_GCE
    	            const TInt KExpected = GCEAvailable() ? KErrNone : KErrNotSupported;
#else
					const TInt KExpected = KErrNotSupported;
#endif
    	            
    	            if( err == KExpected)
    	            	{
                        INFO_PRINTF3(_L("SetAutoScaleL(%d) successfully returned %d"), scaleType, err);
    	            	}
    	            else
    	            	{
                        INFO_PRINTF4(_L("SetAutoScaleL(%d) returned error= %d.  Expected %d"),scaleType, err, KExpected);
                        INFO_PRINTF1(_L("iVideoPlayer->Stop"));
                        iVideoPlayer->Stop();
                        iVideoPlayer->Close();
                        CActiveScheduler::Stop();
                        iTestStepResult = EFail;	    	                        
                        return;
    	            	}
    	            if( scaleType == EAutoScaleNone )
    	            	{
    	            	break;//Break the forever while loop;
    	            	}
                	}

                /*
                Wait for half second each time and call SetAutoScaleL multiple times
                with all combinations of TAutoScaleType, THorizontalAlign, and TVerticalAlign.
                */
                
                while(1)
                	{
    	            switch(scaleType)
		            	{
		            	case EAutoScaleNone:
		            		scaleType = EAutoScaleBestFit;
		            		break;
		            	case EAutoScaleBestFit:
		            		scaleType = EAutoScaleClip;
		            		break;
		            	case EAutoScaleClip:
		            		scaleType = EAutoScaleStretch;
		            		break;
		            	case EAutoScaleStretch:
		            		scaleType = EAutoScaleNone;		            		
		            		break;
		            	}
                    while(1)
                    	{
		            	if( horizontalAlign == EHorizontalAlignCenter)
		            		{
		            		horizontalAlign = EHorizontalAlignLeft;
		            		}
		            	else if( horizontalAlign == EHorizontalAlignLeft)
		            		{
		            		horizontalAlign = EHorizontalAlignRight;
		            		}
		            	else if( horizontalAlign == EHorizontalAlignRight)
		            		{
		            		horizontalAlign = EHorizontalAlignCenter;
		            		}
		                while(1)
	                    	{
    		            	if( verticalAlign == EVerticalAlignCenter)
    		            		{
    		            		verticalAlign = EVerticalAlignTop;
    		            		}
    		            	else if( verticalAlign == EVerticalAlignTop)
    		            		{
    		            		verticalAlign = EVerticalAlignBottom;
    		            		}
    		            	else if( verticalAlign == EVerticalAlignBottom)
    		            		{
    		            		verticalAlign = EVerticalAlignCenter;
    		            		}
    		            	
	    		            	INFO_PRINTF1(_L("calling User::After(KOneSecond/4);"));
	    	                    User::After(KOneSecond/4);
								err = KErrNone;
	    	                    
	    	                    INFO_PRINTF1(_L("Calling SetAutoScaleL();"));
	    	    	            TRAP(err, iVideoPlayer->SetAutoScaleL(scaleType,horizontalAlign,verticalAlign));
	    	    	            if( err == KErrNotSupported)
	    	    	            	{
	    	                        INFO_PRINTF4(_L("SetAutoScaleL(%d,%d, %d) returned KErrNotSupported"),scaleType, horizontalAlign,verticalAlign);
	    	    	            	}
    							else if( err == KErrNone)
    	            				{
									INFO_PRINTF1(_L("Success calling SetAutoScaleL()"));
	    	    	            	}
	    	    	            else
	    	    	            	{
	    	                        INFO_PRINTF3(_L("SetAutoScaleL(%d) returned error= %d"),scaleType, err);
	    	                        INFO_PRINTF1(_L("iVideoPlayer->Stop"));
	    	                        iVideoPlayer->Stop();
	    	                        iVideoPlayer->Close();
	    	                        CActiveScheduler::Stop();
	    	                        iTestStepResult = EFail;	    	                        
	    	                        return;	    	                        
	    	    	            	}
    	    	            
    		            	if( verticalAlign == EVerticalAlignCenter )
    	    	            	{
    	    	            	break;//Break the forever while loop;
    	    	            	}
	    		            }    		            	
		            	if( horizontalAlign == EHorizontalAlignCenter )
	    	            	{
	    	            	break;//Break the forever while loop;
	    	            	}    		            	
    		            }
      	            if( scaleType == EAutoScaleNone )
    	            	{
    	            	break;//Break the forever while loop;
    	            	}
                	}
                
                INFO_PRINTF1(_L("iVideoPlayer->Stop"));
                iVideoPlayer->Stop();
                iVideoPlayer->Close();
                CActiveScheduler::Stop();
                iTestStepResult = EPass;
                break;
            case EVPPlayComplete:
            	INFO_PRINTF1(_L("Clip is too small to run the test"));
                INFO_PRINTF1(_L("iVideoPlayer->Stop"));
                iVideoPlayer->Stop();
                iVideoPlayer->Close();
                CActiveScheduler::Stop();
                iTestStepResult = EInconclusive;
                break;
            }
        }
    }
