diff -r 000000000000 -r bde4ae8d615e os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,2949 @@ +// Copyright (c) 2005-2010 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 +#include +#include "u32hal.h" + +#ifdef SYMBIAN_BUILD_GCE +#include +#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); + + // first call tests creation of display instance + TRAPD(err, aPlayer->SetDisplayWindowL(iWs, *iScreen, *iWindow, rect, clipRect)); + INFO_PRINTF1(_L("Test : Made first call to SetDisplayWindowL()")); + if(err) + { + ERR_PRINTF2(_L("First call to SetDisplayWindowL() failed, error %d"), err); + CActiveScheduler::Stop(); + return EFail; + } + + // second call tests update of display instance + TRAP(err, aPlayer->SetDisplayWindowL(iWs, *iScreen, *iWindow, rect, clipRect)); + INFO_PRINTF1(_L("Test : Made second call to SetDisplayWindowL()")); + if(err) + { + ERR_PRINTF2(_L("Second call to 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; // XXX 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; + } + } + }