--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/vclnt/src/TestPlayer.cpp Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,1208 @@
+// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include "TestPlayer.h"
+
+#include <e32math.h>
+
+/**
+ * Constructor
+ */
+CTestVclntVideoFile::CTestVclntVideoFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ :iPlay (aPlay)
+ {
+ // store the name of this test case
+ // this is the name that is used by the script file
+ // Each test step initialises it's own name
+ iTestStepName = aTestName;
+ iSectName = aSectName;
+ iKeyName = aKeyName;
+
+ // expand heap, so we can load 80k video
+ iHeapSize = 150000;
+ }
+
+CTestVclntVideoFile* CTestVclntVideoFile::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ {
+ CTestVclntVideoFile* self = new (ELeave) CTestVclntVideoFile(aTestName,aSectName,aKeyName,aPlay);
+ return self;
+ }
+
+CTestVclntVideoFile* CTestVclntVideoFile::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ {
+ CTestVclntVideoFile* self = CTestVclntVideoFile::NewLC(aTestName,aSectName,aKeyName,aPlay);
+ CleanupStack::PushL(self);
+ return self;
+ }
+
+void CTestVclntVideoFile::MvpuoOpenComplete(TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Open Complete callback"));
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoFile::MvpuoPrepareComplete(TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Open Complete callback"));
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoFile::MvpuoFrameReady(CFbsBitmap& /*aFrame*/, TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Frame Ready callback"));
+ }
+
+void CTestVclntVideoFile::MvpuoPlayComplete(TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Play Complete callback"));
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoFile::MvpuoEvent(const TMMFEvent& /*aEvent*/)
+ {
+ }
+
+
+/**
+ * Load and initialise an audio file.
+ */
+TVerdict CTestVclntVideoFile::DoTestStepL()
+ {
+ TVerdict ret = EFail;
+ iError = KErrTimedOut;
+
+ INFO_PRINTF1(_L("Test : Video Player - File"));
+
+ TPtrC filename;
+ if(!GetStringFromConfig(iSectName,iKeyName,filename))
+ return EInconclusive;
+
+ InitWservL();
+
+ TRect rect, clipRect;
+ CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,
+ EMdaPriorityPreferenceTimeAndQuality,
+ iWs, *iScreen, *iWindow, rect, clipRect);
+ CleanupStack::PushL(player);
+ TRAP(iError,player->OpenFileL(filename));
+
+ if(iError == KErrNone)
+ {
+ // Wait for initialisation callback
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Opening file"));
+ CActiveScheduler::Start();
+ }
+
+ // Until JetStream
+#ifndef JETSTREAM_TESTS
+ if(iError == KErrNotSupported)
+ ret = EPass;
+#endif
+
+ // Check for errors.
+ if (iError == KErrNone && player != NULL)
+ {
+ player->Prepare();
+ CActiveScheduler::Start();
+ }
+
+ // Check for errors.
+ if (iError == KErrNone && player != NULL)
+ ret = DoTestL(player);
+
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));
+ CleanupStack::PopAndDestroy(player);
+ if(iError != KErrNone)
+ ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );
+ return ret;
+ }
+
+TVerdict CTestVclntVideoFile::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+// #ifdef JETSTREAM_TESTS
+ if(iPlay)
+ {
+ iError = KErrTimedOut;
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing file"));
+ // Wait for init callback
+ CActiveScheduler::Start();
+ if(iError == KErrNone)
+ ret = EPass;
+ }
+ else
+ ret = EPass;
+// #else
+// aPlayer->Stop();
+// #endif
+
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+/**
+ * Constructor
+ */
+CTestVclntVideoDes::CTestVclntVideoDes(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, const TBool aPlay)
+ :iPlay (aPlay)
+
+ {
+ // store the name of this test case
+ // this is the name that is used by the script file
+ // Each test step initialises it's own name
+ iTestStepName = aTestName;
+ iSectName = aSectName;
+ iKeyName = aKeyName;
+
+ // *** Jim : expand heap, so we can load 80k video
+ iHeapSize = 150000;
+ }
+
+CTestVclntVideoDes* CTestVclntVideoDes::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ {
+ CTestVclntVideoDes* self = new (ELeave) CTestVclntVideoDes(aTestName,aSectName,aKeyName,aPlay);
+ return self;
+ }
+
+CTestVclntVideoDes* CTestVclntVideoDes::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ {
+ CTestVclntVideoDes* self = CTestVclntVideoDes::NewLC(aTestName,aSectName,aKeyName,aPlay);
+ CleanupStack::PushL(self);
+ return self;
+ }
+
+void CTestVclntVideoDes::MvpuoOpenComplete(TInt aError)
+ {
+ iError = aError;
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoDes::MvpuoPrepareComplete(TInt aError)
+ {
+ iError = aError;
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoDes::MvpuoFrameReady(CFbsBitmap& /*aFrame*/,TInt aError)
+ {
+ iError = aError;
+ // Will this function require a Active Scheduler Stop?
+ }
+
+void CTestVclntVideoDes::MvpuoPlayComplete(TInt aError)
+ {
+ iError = aError;
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoDes::MvpuoEvent(const TMMFEvent& /*aEvent*/)
+ {
+ }
+
+
+TVerdict CTestVclntVideoDes::DoTestStepPreambleL()
+ {
+ TPtrC filename;
+ if(!GetStringFromConfig(iSectName, iKeyName, filename))
+ return EInconclusive;
+
+ RFs fs;
+ RFile file;
+ TInt size = 0;
+
+ // connect to file system and open file
+ User::LeaveIfError(fs.Connect());
+ User::LeaveIfError(file.Open(fs,filename,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(); //file
+ return CTestMmfVclntStep::DoTestStepPreambleL();
+ }
+
+TVerdict CTestVclntVideoDes::DoTestStepPostambleL()
+ {
+ delete iVideo;
+ iVideo = NULL;
+ return CTestMmfVclntStep::DoTestStepPostambleL();
+ }
+
+/**
+ * Load and initialise an audio descriptor.
+ */
+TVerdict CTestVclntVideoDes::DoTestStepL()
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Descriptor"));
+
+ iError = KErrTimedOut;
+
+ InitWservL();
+
+ TRect rect, clipRect;
+ CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,
+ EMdaPriorityPreferenceTimeAndQuality,
+ iWs, *iScreen, *iWindow, rect, clipRect);
+ CleanupStack::PushL(player);
+
+
+ TRAP(iError, player->OpenDesL(iVideo->Des()));
+
+ if(iError == KErrNone)
+ {
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Opening descriptor"));
+ // Wait for init callback
+ CActiveScheduler::Start();
+ }
+
+ // Until JetStream
+#ifndef JETSTREAM_TESTS
+ if(iError == KErrNotSupported)
+ ret = EPass;
+#endif
+
+ if (iError == KErrNone && player != NULL)
+ {
+ player->Prepare();
+ CActiveScheduler::Start();
+ }
+
+
+ if ((iError == KErrNone) && (player != NULL))
+ ret = DoTestL(player);
+
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));
+ CleanupStack::PopAndDestroy(player);
+ if(iError != KErrNone)
+ ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );
+ return ret;
+ }
+
+TVerdict CTestVclntVideoDes::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+// #ifdef JETSTREAM_TESTS
+
+ if(iPlay)
+ {
+ iError = KErrTimedOut;
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing descriptor"));
+ // Wait for init callback
+ CActiveScheduler::Start();
+ if(iError == KErrNone)
+ ret = EPass;
+ }
+ else
+ ret = EPass;
+//#else
+// aPlayer->Stop();
+//#endif
+ return ret;
+ }
+
+
+//------------------------------------------------------------------
+
+/**
+ * Constructor
+ */
+CTestVclntVideoUrl::CTestVclntVideoUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ :iPlay (aPlay)
+ {
+ // store the name of this test case
+ // this is the name that is used by the script file
+ // Each test step initialises it's own name
+ iTestStepName = aTestName;
+ iSectName = aSectName;
+ iKeyName = aKeyName;
+ }
+
+CTestVclntVideoUrl* CTestVclntVideoUrl::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ {
+ CTestVclntVideoUrl* self = CTestVclntVideoUrl::NewLC(aTestName,aSectName,aKeyName,aPlay);
+ CleanupStack::Pop();
+ return self;
+ }
+
+CTestVclntVideoUrl* CTestVclntVideoUrl::NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TBool aPlay)
+ {
+ CTestVclntVideoUrl* self = new (ELeave) CTestVclntVideoUrl(aTestName,aSectName,aKeyName,aPlay);
+ CleanupStack::PushL(self);
+ return self;
+ }
+
+void CTestVclntVideoUrl::MvpuoOpenComplete(TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Open complete callback"));
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoUrl::MvpuoPrepareComplete(TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Open complete callback"));
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoUrl::MvpuoFrameReady(CFbsBitmap& /*aFrame*/, TInt aError)
+ {
+ iError = aError;
+ // ???
+ INFO_PRINTF1(_L("Frame Ready callback"));
+ }
+
+void CTestVclntVideoUrl::MvpuoPlayComplete(TInt aError)
+ {
+ iError = aError;
+ INFO_PRINTF1(_L("Play complete callback"));
+ CActiveScheduler::Stop();
+ }
+
+void CTestVclntVideoUrl::MvpuoEvent(const TMMFEvent& /*aEvent*/)
+ {
+ }
+
+
+/**
+ * Open audio from a URL and play.
+ */
+TVerdict CTestVclntVideoUrl::DoTestStepL()
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - URL"));
+
+ iError = KErrTimedOut;
+
+ TPtrC urlname;
+ if(!GetStringFromConfig(iSectName,iKeyName,urlname))
+ return EInconclusive;
+
+ InitWservL();
+
+ TRect rect, clipRect;
+ CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,
+ EMdaPriorityPreferenceTimeAndQuality,
+ iWs, *iScreen, *iWindow, rect, clipRect);
+ // wait for init to complete
+ CleanupStack::PushL(player);
+ player->OpenUrlL(urlname);
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Opening URL"));
+ CActiveScheduler::Start();
+
+ // Until JetStream
+#ifndef JETSTREAM_TESTS
+ if(iError == KErrNotSupported)
+ ret = EPass;
+#endif
+
+ if (iError == KErrNone)
+ {
+ player->Prepare();
+ CActiveScheduler::Start();
+ }
+
+ if (iError == KErrNone)
+ ret = DoTestL(player);
+
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying"));
+ CleanupStack::PopAndDestroy(player);
+ if(iError != KErrNone)
+ ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );
+ return ret;
+ }
+
+TVerdict CTestVclntVideoUrl::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+//#ifdef JETSTREAM_TESTS
+
+ iError = KErrTimedOut;
+
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing URL"));
+ // Wait for play to complete
+ CActiveScheduler::Start();
+
+ if(iError == KErrNone)
+ ret = EPass;
+//#else
+// aPlayer->Stop();
+//#endif
+
+ return ret;
+ }
+
+
+//------------------------------------------------------------------
+
+
+CTestVclntEnqFrameRate::CTestVclntEnqFrameRate(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aFrameRate)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iFrameRate = aFrameRate;
+ }
+
+CTestVclntEnqFrameRate* CTestVclntEnqFrameRate::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aFrameRate)
+ {
+ CTestVclntEnqFrameRate* self = new (ELeave) CTestVclntEnqFrameRate(aTestName,aSectName,aKeyName,aFrameRate);
+ return self;
+ }
+
+TVerdict CTestVclntEnqFrameRate::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ INFO_PRINTF1(_L("Test : Video Player - Enquire Frame Rate"));
+
+ TVerdict ret = EFail;
+
+ TInt32 theFrameRate;
+ Math::Int(theFrameRate, aPlayer->VideoFrameRateL());
+ INFO_PRINTF2(_L("(Frame rate : %d)"), theFrameRate);
+
+ // if we get here, we pass. The player does not have a SetVideoFrameRate()
+ ret = EPass;
+
+ return ret;
+ }
+
+
+//------------------------------------------------------------------
+
+CTestVclntPosition::CTestVclntPosition(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iPosition = aPosition;
+ }
+
+CTestVclntPosition* CTestVclntPosition::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTimeIntervalMicroSeconds aPosition)
+ {
+ CTestVclntPosition* self = new (ELeave) CTestVclntPosition(aTestName,aSectName,aKeyName,aPosition);
+ return self;
+ }
+
+TVerdict CTestVclntPosition::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ // NB test video controller is stubbing certain functions. May have to rewrite this
+ // for Jet Stream
+
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Position"));
+
+ TBool validPosition = EFalse;
+
+ 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()));
+ aPlayer->SetPositionL(iPosition);
+ INFO_PRINTF3(_L("Set : position = %d (if clipped : %d)"),
+ I64INT(aPlayer->PositionL().Int64()), I64INT(aPlayer->DurationL().Int64()));
+ if(aPlayer->PositionL() == aPlayer->DurationL())
+ validPosition = ETrue;
+ }
+ // 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()));
+ aPlayer->SetPositionL(iPosition);
+ INFO_PRINTF2(_L("Set : position = %d (if clipped : 0)"), I64INT(aPlayer->PositionL().Int64()));
+ if (I64INT(aPlayer->PositionL().Int64()) == 0)
+ validPosition = ETrue;
+ }
+ else
+ {
+ INFO_PRINTF2(_L("Normal : Setting position to %d"), I64INT(iPosition.Int64()));
+ aPlayer->SetPositionL(iPosition);
+ INFO_PRINTF3(_L("Set : position = %d (if clipped : %d)"),
+ I64INT(aPlayer->PositionL().Int64()), I64INT(iPosition.Int64()));
+ if(aPlayer->PositionL() == iPosition)
+ validPosition = ETrue;
+ }
+
+ // Position was set to a valid value.
+ if(validPosition)
+ {
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
+ // wait for play to complete
+ CActiveScheduler::Start();
+
+ INFO_PRINTF2(_L("Error : %d"), iError);
+ if (iError == KErrNone)
+ ret = EPass;
+ }
+ else
+ {
+ // We've got an invalid position, attempt to play anyway...
+ // the test controller should handle it
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing from invalid position"));
+ // wait for play to complete
+ CActiveScheduler::Start();
+
+ INFO_PRINTF2(_L("Error : %d"), iError);
+ if (iError == KErrNone)
+ ret = EPass;
+
+ }
+
+ return ret;
+ }
+
+
+//------------------------------------------------------------------
+
+CTestVclntPriority::CTestVclntPriority(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aPriority)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iPriority = aPriority;
+ }
+
+CTestVclntPriority* CTestVclntPriority::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aPriority)
+ {
+ CTestVclntPriority* self = new (ELeave) CTestVclntPriority(aTestName,aSectName,aKeyName,aPriority);
+ return self;
+ }
+
+TVerdict CTestVclntPriority::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Priority"));
+
+ aPlayer->SetPriorityL(iPriority, EMdaPriorityPreferenceNone);
+ TInt thePriority;
+ 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) )
+ return EPass;
+ return ret;
+ }
+
+
+//------------------------------------------------------------------
+
+CTestVclntDuration::CTestVclntDuration(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTimeIntervalMicroSeconds aDuration)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iDuration = aDuration;
+ }
+
+CTestVclntDuration* CTestVclntDuration::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTimeIntervalMicroSeconds aDuration)
+ {
+ CTestVclntDuration* self = new (ELeave) CTestVclntDuration(aTestName,aSectName,aKeyName,aDuration);
+ return self;
+ }
+
+TVerdict CTestVclntDuration::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Duration"));
+
+ if (I64INT(iDuration.Int64()) == 0)
+ {
+ TInt duration = I64INT(aPlayer->DurationL().Int64());
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
+ 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;
+ }
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntVolume::CTestVclntVolume(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aVolume)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iVolume = aVolume;
+ }
+
+CTestVclntVolume* CTestVclntVolume::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aVolume)
+ {
+ CTestVclntVolume* self = new (ELeave) CTestVclntVolume(aTestName,aSectName,aKeyName,aVolume);
+ return self;
+ }
+
+TVerdict CTestVclntVolume::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ // NB : test video controller does not adjust invalid volumes
+ // comment the checks back in for JS
+
+ INFO_PRINTF1(_L("Test : Video Player - Volume"));
+
+ INFO_PRINTF1(_L("Warning : test video controller does not adjust invalid volumes"));
+
+ // Check maxvolume function
+ if(iVolume == -1)
+ {
+ iVolume = aPlayer->MaxVolume();
+ INFO_PRINTF3(_L("Volume = %d MaxVolume = %d"), iVolume, KMaxVolume);
+ //if(iVolume == KMaxVolume)
+ ret = EPass;
+ }
+ // Volume is truncated to maxvolume
+ else if(iVolume > aPlayer->MaxVolume())
+ {
+ aPlayer->SetVolumeL(iVolume);
+ 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)
+ {
+ aPlayer->SetVolumeL(iVolume);
+ INFO_PRINTF2(_L("Volume = %d (expecting 0)"), aPlayer->Volume());
+ //if(aPlayer->Volume() == 0)
+ ret = EPass;
+ }
+ // Set volume and check
+ else
+ {
+ aPlayer->SetVolumeL(iVolume);
+ INFO_PRINTF3(_L("Volume = %d (expecting %d)"), aPlayer->Volume(), iVolume);
+ if(aPlayer->Volume() == iVolume)
+ ret = EPass;
+ }
+
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntCloseOpen::CTestVclntCloseOpen(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {}
+
+CTestVclntCloseOpen* CTestVclntCloseOpen::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ {
+ CTestVclntCloseOpen* self = new (ELeave) CTestVclntCloseOpen(aTestName,aSectName,aKeyName);
+ return self;
+ }
+
+TVerdict CTestVclntCloseOpen::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Close/Open"));
+
+//#ifdef JETSTREAM_TESTS
+
+ TPtrC filename;
+ if(!GetStringFromConfig(iSectName,iKeyName,filename))
+ return EInconclusive;
+
+ aPlayer->Close();
+ User::After(KOneSecond);
+
+ TRAP(iError,aPlayer->OpenFileL(filename));
+ if(iError == KErrNone)
+ {
+ // Wait for initialisation callback
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Opening file"));
+ ret = EPass;
+ }
+
+//#else
+// aPlayer->Stop();
+//#endif
+
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntPause::CTestVclntPause(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {}
+
+CTestVclntPause* CTestVclntPause::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ {
+ CTestVclntPause* self = new (ELeave) CTestVclntPause(aTestName,aSectName,aKeyName);
+ return self;
+ }
+
+TVerdict CTestVclntPause::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Pause"));
+
+ // Tests pause functionality
+ // NB : not implemented in test controller
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
+ aPlayer->Play();
+ CActiveScheduler::Start();
+ aPlayer->PauseL();
+
+#ifdef JETSTREAM_TESTS
+ TInt duration = I64INT(aPlayer->DurationL().Int64());
+
+ iError = KErrTimedOut;
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
+ 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
+ INFO_PRINTF1(_L("Warning : PauseL() functionality not supported in test controller"));
+ aPlayer->Stop();
+ ret = EPass;
+#endif
+
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntBalance::CTestVclntBalance(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aBalance)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iBalance = aBalance;
+ }
+
+CTestVclntBalance* CTestVclntBalance::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TInt aBalance)
+ {
+ CTestVclntBalance* self = new (ELeave) CTestVclntBalance(aTestName,aSectName,aKeyName,aBalance);
+ return self;
+ }
+
+TVerdict CTestVclntBalance::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ INFO_PRINTF1(_L("Test : Video Player - Balance"));
+
+#ifdef JETSTREAM_TESTS
+ if (iBalance < KMinBalance)
+ {
+ aPlayer->SetBalanceL(iBalance);
+ INFO_PRINTF3(_L("Balance = %d (expecting %d)"), aPlayer->Balance(), KMinBalance);
+ if(aPlayer->Balance() == KMinBalance)
+ return EPass;
+ }
+ else if (iBalance > KMaxBalance)
+ {
+ aPlayer->SetBalanceL(iBalance);
+ INFO_PRINTF3(_L("Balance = %d (expecting %d)"), aPlayer->Balance(), KMaxBalance);
+ if(aPlayer->Balance() == KMaxBalance)
+ return EPass;
+ }
+ else
+ {
+ aPlayer->SetBalanceL(iBalance);
+ INFO_PRINTF3(_L("Balance = %d (expecting %d)"), aPlayer->Balance(), iBalance);
+ if(aPlayer->Balance() == iBalance)
+ return EPass;
+ }
+#else
+ // the test video controller returns 1 for all calls of Balance()
+ // call SetBalanceL() to show it doesn't leave
+ aPlayer->SetBalanceL(iBalance);
+ INFO_PRINTF1(_L("Test controller should return 1 for all calls of Balance()"));
+ INFO_PRINTF2(_L("Balance = %d (expecting 1)"), aPlayer->Balance());
+ if(aPlayer->Balance() == 1)
+ return EPass;
+#endif
+
+ return EFail;
+ }
+
+
+//------------------------------------------------------------------
+
+CTestVclntPlayWindow::CTestVclntPlayWindow(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTimeIntervalMicroSeconds aStart, const TTimeIntervalMicroSeconds aEnd)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iStart = aStart;
+ iEnd = aEnd;
+ }
+
+CTestVclntPlayWindow* CTestVclntPlayWindow::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTimeIntervalMicroSeconds aStart, const TTimeIntervalMicroSeconds aEnd)
+ {
+ CTestVclntPlayWindow* self = new (ELeave) CTestVclntPlayWindow(aTestName,aSectName,aKeyName,aStart,aEnd);
+ return self;
+ }
+
+TVerdict CTestVclntPlayWindow::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Window"));
+
+// InitWservL();
+
+ TRect rect, clipRect;
+ TRAPD(err, aPlayer->SetDisplayWindowL(iWs, *iScreen, *iWindow, rect, clipRect));
+ if(err)
+ {
+ ERR_PRINTF2(_L("SetDisplayWindowL() failed, error %d"), err);
+ ret = EFail;
+ }
+ else
+ {
+ ret = EPass;
+ }
+
+ // removed an attempt at opening a window server manually - it seemed to work, but a RWsSession
+ // couldn't Connect(), connectL() claimed no asynchronous operation...
+
+ // we have no window server, so the test can't run -
+ // so call it with dummy parameters and add explanatory note to the test
+
+ // NB ws.Connect() will panic on the target, hence don't run it
+/*
+#if defined (__WINS__)
+ TBool testInvalid = EFalse;
+ RWsSession ws;
+ if(ws.Connect() != KErrNone)
+ testInvalid = ETrue;
+
+ // we can't call it at all - SetDisplayWindowL() will cause an access violation if ws is null
+ if(testInvalid)
+ {
+ INFO_PRINTF1(_L("Warning : SetDisplayWindowL() cannot be tested, no window server available"));
+ ret = EPass;
+ }
+ else
+ {
+ // TBD - arguments to be correctly set
+ CWsScreenDevice sd;
+ RBlankWindow window;
+ TRect rect, clipRect;
+
+ TRAPD(err, aPlayer->SetDisplayWindowL(ws, sd, window, rect, clipRect));
+ if(err)
+ {
+ ERR_PRINTF2(_L("SetDisplayWindowL() failed, error %d"), err);
+ ret = EFail;
+ }
+ else
+ ret = EPass;
+
+ }
+#else
+ INFO_PRINTF1(_L("Warning : SetDisplayWindowL() cannot be tested on target"));
+ ret = EPass;
+#endif
+*/
+ aPlayer->Stop();
+ return ret;
+ }
+
+
+//------------------------------------------------------------------
+
+CTestVclntMeta::CTestVclntMeta(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {}
+
+CTestVclntMeta* CTestVclntMeta::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ {
+ CTestVclntMeta* self = new (ELeave) CTestVclntMeta(aTestName,aSectName,aKeyName);
+ return self;
+ }
+
+TVerdict CTestVclntMeta::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ INFO_PRINTF1(_L("Test : Video Player - Metadata"));
+
+ TInt numOfMeta = -1;
+ TRAPD(err, numOfMeta = aPlayer->NumberOfMetaDataEntriesL() );
+ INFO_PRINTF3(_L("Error : %d Entries = %d"), err, numOfMeta);
+ if (err != KErrNone || numOfMeta != 0)
+ return EFail;
+ // call that goes to the dummy controller
+ // NB we expect zero metadata entries
+ CMMFMetaDataEntry* theEntry=NULL;
+ TRAP(err, theEntry = aPlayer->MetaDataEntryL(1));
+ INFO_PRINTF2(_L("Error : %d"), err);
+ if (err != KErrNone)
+ return EFail;
+ else
+ {
+ delete theEntry;
+ return EPass;
+ }
+ }
+
+
+//------------------------------------------------------------------
+
+CTestVclntFrameSize::CTestVclntFrameSize(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TInt aFrameSize)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iFrameSize = aFrameSize;
+ }
+
+CTestVclntFrameSize* CTestVclntFrameSize::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TInt aFrameSize)
+ {
+ CTestVclntFrameSize* self = new (ELeave) CTestVclntFrameSize(aTestName,aSectName,aKeyName,aFrameSize);
+ return self;
+ }
+
+TVerdict CTestVclntFrameSize::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Frame Size"));
+
+ TSize frameSize;
+ TRAPD(err, aPlayer->VideoFrameSizeL(frameSize) );
+
+ INFO_PRINTF4(_L("Error : %d, Frame size : (%d, %d)"), err, frameSize.iWidth, frameSize.iHeight);
+ if (err == KErrNone &&
+ frameSize.iWidth >= 0 && frameSize.iHeight >= 0 )
+ return EPass;
+
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntMimeType::CTestVclntMimeType(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ }
+
+CTestVclntMimeType* CTestVclntMimeType::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ {
+ CTestVclntMimeType* self = new (ELeave) CTestVclntMimeType(aTestName,aSectName,aKeyName);
+ return self;
+ }
+
+TVerdict CTestVclntMimeType::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ INFO_PRINTF1(_L("Test : Video Player - MimeType"));
+
+ // NB we cannot check whether the mime type returned is valid, or even exists.
+ TPtrC8 mimeType = aPlayer->VideoFormatMimeType();
+
+ // take it to a 16-bit string
+ TBuf<64> mimeType16;
+ mimeType16.Copy(mimeType);
+ INFO_PRINTF2(_L("Mime type : \'%S\'"), &mimeType16);
+ return EPass;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntRebuffering::CTestVclntRebuffering(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ }
+
+CTestVclntRebuffering* CTestVclntRebuffering::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ {
+ CTestVclntRebuffering* self = new (ELeave) CTestVclntRebuffering(aTestName,aSectName,aKeyName);
+ return self;
+ }
+
+TVerdict CTestVclntRebuffering::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ INFO_PRINTF1(_L("Test : Video Player - Rebuffering"));
+
+ aPlayer->RegisterForVideoLoadingNotification(*this);
+
+ INFO_PRINTF1(_L("Rebuffering request completed"));
+ return EPass;
+ }
+
+// from MRebufferCallback
+void CTestVclntRebuffering::MvloLoadingStarted()
+ {
+ INFO_PRINTF1(_L("CTestVclntRebuffering::MvloLoadingStarted"));
+ }
+
+void CTestVclntRebuffering::MvloLoadingComplete()
+ {
+ INFO_PRINTF1(_L("CTestVclntRebuffering::MvloLoadingComplete"));
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntRepeat::CTestVclntRepeat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TInt aRepeat)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {
+ iRepeat = aRepeat;
+ }
+
+CTestVclntRepeat* CTestVclntRepeat::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName,const TInt aRepeat)
+ {
+ CTestVclntRepeat* self = new (ELeave) CTestVclntRepeat(aTestName,aSectName,aKeyName,aRepeat);
+ return self;
+ }
+
+TVerdict CTestVclntRepeat::DoTestL(CVideoPlayerUtility* aPlayer)
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Repeats"));
+
+ TInt duration = I64INT(aPlayer->DurationL().Int64());
+
+ // SetRepeats() doesn't exist in the video controller, so set iRepeat to 1
+ iRepeat = 1;
+ INFO_PRINTF1(_L("Warning : SetRepeats() does not exist in player API. Repeat count set to 1"));
+
+ aPlayer->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
+ 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 * (iRepeat + 1),
+ KExpectedDeviation * iRepeat)))
+ ret = EPass;
+
+ return ret;
+ }
+
+//------------------------------------------------------------------
+
+CTestVclntDelete::CTestVclntDelete(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ : CTestVclntVideoFile(aTestName,aSectName,aKeyName,EFalse)
+ {}
+
+CTestVclntDelete* CTestVclntDelete::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName)
+ {
+ CTestVclntDelete* self = new (ELeave) CTestVclntDelete(aTestName,aSectName,aKeyName);
+ return self;
+ }
+
+TVerdict CTestVclntDelete::DoTestL(CVideoPlayerUtility* /* aPlayer */)
+ {
+ // this is never called
+ return EFail;
+ }
+
+TVerdict CTestVclntDelete::DoTestStepL()
+ {
+ TVerdict ret = EFail;
+
+ INFO_PRINTF1(_L("Test : Video Player - Delete"));
+
+ TPtrC filename;
+ if(!GetStringFromConfig(iSectName,iKeyName,filename))
+ return EInconclusive;
+
+ InitWservL();
+
+ TRect rect, clipRect;
+ CVideoPlayerUtility* player = CVideoPlayerUtility::NewL(*this, EMdaPriorityNormal,
+ EMdaPriorityPreferenceTimeAndQuality,
+ iWs, *iScreen, *iWindow, rect, clipRect);
+ CleanupStack::PushL(player);
+
+ iError = KErrTimedOut;
+ INFO_PRINTF2(_L("Attempting to open file %S"), &filename);
+ TRAP(iError,player->OpenFileL(filename));
+
+ if(iError == KErrNone)
+ {
+ // Wait for initialisation callback
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Opening file"));
+ CActiveScheduler::Start();
+ }
+
+ if (iError == KErrNone)
+ {
+ player->Prepare();
+ CActiveScheduler::Start();
+ }
+
+ if(iError == KErrNone)
+ {
+ player->Play();
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Playing"));
+ INFO_PRINTF1(_L("CVideoPlayerUtility: Destroying before play complete"));
+ CleanupStack::Pop(player); // destroy player before play has completed
+
+ User::Heap().Check();
+ return EPass;
+ }
+
+ CleanupStack::Pop(player);
+ ERR_PRINTF2( _L("CVideoPlayerUtility failed with error %d"),iError );
+ return ret;
+ }
+