--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer.cpp Thu Oct 07 22:34:12 2010 +0100
@@ -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 <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);
+
+ // 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;
+ }
+ }
+ }