--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer2.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,2250 @@
+// Copyright (c) 2007-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 <e32math.h>
+#include "testvideoplayer2.h"
+
+#ifdef SYMBIAN_BUILD_GCE
+#include <graphics/surfacemanager.h>
+#endif
+
+const TInt KSettingsAndAlignmentTest = 3;
+
+//
+// RTestVclntPlayAviFile
+//
+
+/**
+ * RTestVclnt2PlayFile::Constructor
+ */
+RTestVclnt2PlayFile::RTestVclnt2PlayFile(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2PlayFile::NewL
+ */
+RTestVclnt2PlayFile* RTestVclnt2PlayFile::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2PlayFile* self = new (ELeave) RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2PlayFile::DoTestStepPreambleL
+ */
+TVerdict RTestVclnt2PlayFile::DoTestStepPreambleL()
+ {
+ return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();
+ }
+
+/**
+ * RTestVclnt2PlayFile::DoTestStepPostambleL
+ */
+TVerdict RTestVclnt2PlayFile::DoTestStepPostambleL()
+ {
+ return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();
+ }
+
+/**
+ * RTestVclnt2PlayFile::FsmL
+ */
+void RTestVclnt2PlayFile::FsmL(TVclntTestPlayEvents aEventCode)
+ {
+ if (FsmCheck(aEventCode))
+ {
+ switch (aEventCode)
+ {
+ case EVPIdle:
+ HandleIdleL();
+ break;
+
+ case EVPOpenComplete:
+ HandleOpenCompleteL();
+ break;
+
+ case EVPPrepareComplete:
+ HandlePrepareCompleteL();
+ break;
+
+ case EVPPlayComplete:
+ HandlePlayCompleteL();
+ break;
+ }
+ }
+ }
+
+void RTestVclnt2PlayFile::HandleIdleL()
+ {
+ // Open iVideoPlayer
+ INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);
+ iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);
+ PrepareState(EVPOpenComplete, KErrNone);
+ }
+
+void RTestVclnt2PlayFile::HandleOpenCompleteL()
+ {
+ // Prepare iVideoPlayer2
+ INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));
+ iVideoPlayer2->Prepare();
+ PrepareState(EVPPrepareComplete, KErrNone);
+ }
+
+void RTestVclnt2PlayFile::HandlePrepareCompleteL()
+ {
+ // Add display window using default values - ie. video extent & window clipping
+ // defaulted to whole window
+ INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+void RTestVclnt2PlayFile::HandlePlayCompleteL()
+ {
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ }
+
+void RTestVclnt2PlayFile::StartPlayback()
+ {
+ iError = KErrTimedOut;
+ INFO_PRINTF1(_L("iVideoPlayer2->Play()"));
+ PrepareState(EVPPlayComplete, KErrNone);
+ iVideoPlayer2->Play();
+ }
+
+#ifdef SYMBIAN_BUILD_GCE
+//
+// RTestMediaClientVideoDisplay
+//
+
+/**
+ * RTestMediaClientVideoDisplay::Constructor
+ */
+
+
+RTestMediaClientVideoDisplay::RTestMediaClientVideoDisplay(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestMediaClientVideoDisplay::NewL
+ */
+
+RTestMediaClientVideoDisplay* RTestMediaClientVideoDisplay::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestMediaClientVideoDisplay* self = new (ELeave) RTestMediaClientVideoDisplay(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestMediaClientVideoDisplay::DoTestStepPreambleL
+ */
+
+TVerdict RTestMediaClientVideoDisplay::DoTestStepPreambleL()
+ {
+ return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();
+ }
+
+/**
+ * RTestMediaClientVideoDisplay::DoTestStepPostambleL
+ */
+
+TVerdict RTestMediaClientVideoDisplay::DoTestStepPostambleL()
+ {
+ return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();
+ }
+
+/**
+ * RTestMediaClientVideoDisplay::FsmL
+ */
+void RTestMediaClientVideoDisplay::FsmL(TVclntTestPlayEvents aEventCode)
+ {
+ if (FsmCheck(aEventCode))
+ {
+ switch (aEventCode)
+ {
+ case EVPIdle:
+ HandleIdleL();
+ break;
+
+ case EVPOpenComplete:
+ HandleOpenCompleteL();
+ break;
+
+ case EVPPrepareComplete:
+ HandlePrepareCompleteL();
+ break;
+
+ case EVPPlayComplete:
+ HandlePlayCompleteL();
+ break;
+ }
+ }
+ }
+
+void RTestMediaClientVideoDisplay::HandleIdleL()
+ {
+ // Open iVideoPlayer
+ INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);
+ iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);
+ PrepareState(EVPOpenComplete, KErrNone);
+ }
+
+void RTestMediaClientVideoDisplay::HandleOpenCompleteL()
+ {
+ // Prepare iVideoPlayer2
+ INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));
+ iVideoPlayer2->Prepare();
+ PrepareState(EVPPrepareComplete, KErrNone);
+ }
+
+void RTestMediaClientVideoDisplay::HandlePrepareCompleteL()
+ {
+ // trigger the video to start playing
+ StartPlayback();
+
+ TInt displayId = iScreen->GetScreenNumber();
+ TRect clipRect = TRect(iWindow->Size());
+ TRect cropRegion = clipRect;
+
+ // ==========================
+
+ iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);
+
+ RSurfaceManager surfaceManager;
+ User::LeaveIfError(surfaceManager.Open());
+
+ RSurfaceManager::TSurfaceCreationAttributesBuf bf;
+ RSurfaceManager::TSurfaceCreationAttributes& b=bf();
+ b.iSize.iWidth = 320;
+ b.iSize.iHeight = 240;
+ b.iBuffers = 1;
+ b.iPixelFormat = EUidPixelFormatXRGB_8888;
+ b.iStride = 320 * 4;
+ b.iOffsetToFirstBuffer = 0;
+ b.iAlignment=4;
+ b.iContiguous=ETrue;
+
+ TRect cropRect(0, 0, 320, 240);
+ TVideoAspectRatio par(1,2);
+ TSurfaceId surfaceId;
+
+ User::LeaveIfError(surfaceManager.CreateSurface(bf, surfaceId));
+
+ iMediaClientVideoDisplay->SurfaceCreated(surfaceId, cropRect, par, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceCreated()"));
+
+ delete iMediaClientVideoDisplay;
+ iMediaClientVideoDisplay = NULL;
+
+ // ==================
+
+ iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);
+
+ TRect videoExtent = clipRect;
+ TVideoRotation rotation = EVideoRotationNone;
+ TReal32 scaleWidth(100.0f);
+ TReal32 scaleHeight(100.0f);
+ TInt horizPos(EHorizontalAlignCenter);
+ TInt vertPos(EVerticalAlignCenter);
+
+ TReal32 widthPercentage(50.0f);
+ TReal32 heightPercentage(50.0f);
+ TReal32 widthP;
+ TReal32 heightP;
+ RWindow newWindow;
+ TVideoRotation videoRotation(EVideoRotationClockwise180);
+
+ iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->AddDisplayWindowL()"));
+
+ iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));
+
+ if (iMediaClientVideoDisplay->RotationL(*iWindow) != videoRotation)
+ {
+ ERR_PRINTF1(_L("iMediaClientVideoDisplay->RotationL() returns an unexpected value. Test aborted."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->RotationL()"));
+ }
+
+ iMediaClientVideoDisplay->SetScaleFactorL(*iWindow, widthPercentage, heightPercentage, cropRegion);
+ iMediaClientVideoDisplay->SetScaleFactorL(widthPercentage, heightPercentage, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetScaleFactorL()"));
+
+ iMediaClientVideoDisplay->SetRotationL(EVideoRotationClockwise90, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));
+
+ iMediaClientVideoDisplay->GetScaleFactorL(*iWindow, widthP, heightP);
+ INFO_PRINTF3(_L("iMediaClientVideoDisplay->GetScaleFactorL() %df %df"), &widthP, &heightP);
+
+ iMediaClientVideoDisplay->SetVideoExtentL(*iWindow, videoExtent, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetVideoExtentL()"));
+
+ iMediaClientVideoDisplay->SetWindowClipRectL(*iWindow, clipRect, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetWindowClipRectL()"));
+
+ iMediaClientVideoDisplay->SetAutoScaleL(EAutoScaleBestFit, horizPos, vertPos, cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetAutoScaleL()"));
+
+ iMediaClientVideoDisplay->RedrawWindows(cropRegion);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->RedrawWindows()"));
+
+ iMediaClientVideoDisplay->SurfaceParametersChanged(surfaceId, cropRect, par);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceParametersChanged()"));
+
+ iMediaClientVideoDisplay->RemoveSurface();
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->ReplaceSurface()"));
+
+ iMediaClientVideoDisplay->RemoveDisplayWindow(*iWindow);
+ INFO_PRINTF1(_L("iMediaClientVideoDisplay->RemoveDisplayWindow()"));
+
+ surfaceManager.CloseSurface(surfaceId);
+ surfaceId = TSurfaceId::CreateNullId();
+ surfaceManager.Close();
+
+ delete iMediaClientVideoDisplay;
+ iMediaClientVideoDisplay = NULL;
+ }
+
+void RTestMediaClientVideoDisplay::HandlePlayCompleteL()
+ {
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ }
+
+void RTestMediaClientVideoDisplay::StartPlayback()
+ {
+ iError = KErrTimedOut;
+ INFO_PRINTF1(_L("iVideoPlayer2->Play()"));
+ PrepareState(EVPPlayComplete, KErrNone);
+ iVideoPlayer2->Play();
+ }
+
+#endif
+
+//
+// RTestVclnt2PerformActionDuringVideoPlayback
+//
+
+/**
+ * RTestVclnt2PerformActionDuringVideoPlayback::Constructor
+ */
+RTestVclnt2PerformActionDuringVideoPlayback::RTestVclnt2PerformActionDuringVideoPlayback(
+ const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL
+ */
+void RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL()
+ {
+ if (iActionError != KErrNone)
+ {
+ ERR_PRINTF2(_L("Playback event left with error %d."), iActionError);
+ iTestStepResult = EFail;
+ }
+ else
+ {
+ iTestStepResult = EPass;
+ }
+
+ CActiveScheduler::Stop();
+ }
+
+/**
+ * RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback
+ */
+void RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback()
+ {
+ RTestVclnt2PlayFile::StartPlayback();
+
+ iActionError = KErrNone;
+ TRAP(iActionError, DoThisActionDuringPlaybackL(*iVideoPlayer2));
+ }
+
+
+//
+// RTestVclnt2AddWin
+//
+/**
+ * RTestVclnt2AddWin::Constructor
+ */
+RTestVclnt2AddWin::RTestVclnt2AddWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2AddWin::NewL
+ */
+RTestVclnt2AddWin* RTestVclnt2AddWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2AddWin* self = new (ELeave) RTestVclnt2AddWin(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2AddWin::HandlePrepareCompleteL
+ */
+void RTestVclnt2AddWin::HandlePrepareCompleteL()
+ {
+ // retrieve video size
+ TSize videoSize;
+ iVideoPlayer2->VideoFrameSizeL(videoSize);
+
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0)
+ {
+ // create a clipping rect partially out of screen
+ TRect windowRect(iWindow->Size());
+ windowRect.SetWidth(windowRect.Width() * 2);
+
+ // Add the display window with a partially out of screen clipping rect
+ TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs,
+ *iScreen,
+ *iWindow,
+ TRect(iWindow->Size()),
+ windowRect));
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed."));
+
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+
+ // create a clipping rect completely out of screen
+ windowRect.SetRect(TPoint(0, 0), iWindow->Size());
+ windowRect.Move(windowRect.Width() + 10, 0);
+
+ // Add the display window with a completely out of screen clipping rect
+ TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs,
+ *iScreen,
+ *iWindow,
+ TRect(iWindow->Size()),
+ windowRect));
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed."));
+
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+ else
+ {
+ // Reset the expected error to KErrNone as all expected failure tests have been completed.
+ // Any error that appears after this should fail the test
+ iTestExpectedError = KErrNone;
+ }
+
+ // after failing to add window display with a partially & a completely out of screen
+ // clipping rect, proceed to add a valid clipping rect below
+ }
+
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0401")) == 0 ||
+ iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0)
+ {
+ // shrink both the video & window size by half
+ TRect videoRect(videoSize);
+ videoRect.SetHeight(videoSize.iHeight / 2);
+ videoRect.SetWidth(videoSize.iWidth / 2);
+
+ TRect windowRect(iWindow->Size());
+ windowRect.SetHeight(iWindow->Size().iHeight / 2);
+ windowRect.SetWidth(iWindow->Size().iWidth / 2);
+
+ // ensure the rect is within the boundary of the window
+ TRect finalRect(windowRect);
+ finalRect.Intersection(videoRect);
+
+ // add display window using this valid clipping rect
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect);
+ }
+ else
+ {
+ // Invalid test case
+ User::Panic(_L("RTestVclnt2AddWin"), KErrArgument);
+ }
+
+ // Start video playback
+ StartPlayback();
+ }
+
+
+//
+// RTestVclnt2RemoveWin
+//
+
+/**
+ * RTestVclnt2RemoveWin::Constructor
+ */
+RTestVclnt2RemoveWin::RTestVclnt2RemoveWin(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError,
+ TBool aAddBack)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError),
+ iAddBack(aAddBack)
+ {
+ }
+
+/**
+ * RTestVclnt2RemoveWin::NewL
+ */
+RTestVclnt2RemoveWin* RTestVclnt2RemoveWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TBool aAddBack)
+ {
+ RTestVclnt2RemoveWin* self = new (ELeave) RTestVclnt2RemoveWin(aTestName, aSectName, aKeyName, aExpectedError, aAddBack);
+ return self;
+ }
+
+/**
+ * RTestVclnt2RemoveWin::HandlePrepareCompleteL
+ */
+void RTestVclnt2RemoveWin::HandlePrepareCompleteL()
+ {
+ // retrieve video size
+ TSize videoSize;
+ iVideoPlayer2->VideoFrameSizeL(videoSize);
+
+ // shrink both the video & window size by half
+ TRect videoRect(videoSize);
+ videoRect.SetHeight(videoSize.iHeight / 2);
+ videoRect.SetWidth(videoSize.iWidth / 2);
+
+ TRect windowRect(iWindow->Size());
+ windowRect.SetHeight(iWindow->Size().iHeight / 2);
+ windowRect.SetWidth(iWindow->Size().iWidth / 2);
+
+ // ensure the rect is within the boundary of the window
+ TRect finalRect(windowRect);
+ finalRect.Intersection(videoRect);
+
+ // add display window using this valid clipping rect
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect);
+
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+/**
+ * RTestVclnt2RemoveWin::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2RemoveWin::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ // Play the video clip using a specific display window & video clipping setting
+ // first
+ TTimeIntervalMicroSeconds duration = aPlayer.DurationL();
+
+ // After a quarter of the clip's duration
+ User::After(duration.Int64() / 4);
+
+ // remove the original display
+ aPlayer.RemoveDisplayWindow(*iWindow);
+
+
+ if (iAddBack)
+ {
+ // Add the window using default values to continues
+ aPlayer.AddDisplayWindowL(iWs, *iScreen, *iWindow);
+ }
+ }
+
+
+//
+// RTestVclnt2WinPos
+//
+
+/**
+ * RTestVclnt2WinPos::Constructor
+ */
+RTestVclnt2WinPos::RTestVclnt2WinPos(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2WinPos::NewL
+ */
+RTestVclnt2WinPos* RTestVclnt2WinPos::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2WinPos* self = new (ELeave) RTestVclnt2WinPos(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2WinPos::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2WinPos::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);
+
+ // shrink the window clipping rect by half the height & width
+ aPlayer.SetWindowClipRectL(*iWindow, TRect(windowSize));
+ }
+
+
+//
+// RTestVclnt2VideoExt
+//
+
+/**
+ * RTestVclnt2VideoExt::Constructor
+ */
+RTestVclnt2VideoExt::RTestVclnt2VideoExt(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2VideoExt::NewL
+ */
+RTestVclnt2VideoExt* RTestVclnt2VideoExt::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2VideoExt* self = new (ELeave) RTestVclnt2VideoExt(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2VideoExt::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2VideoExt::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);
+
+ // shrink the video extent by half the height & width
+ aPlayer.SetVideoExtentL(*iWindow, TRect(windowSize));
+ }
+
+
+//
+// RTestVclnt2ClipRect
+//
+
+/**
+ * RTestVclnt2ClipRect::Constructor
+ */
+RTestVclnt2ClipRect::RTestVclnt2ClipRect(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2ClipRect::NewL
+ */
+RTestVclnt2ClipRect* RTestVclnt2ClipRect::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2ClipRect* self
+ = new (ELeave) RTestVclnt2ClipRect(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2ClipRect::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2ClipRect::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ TRect clipRect;
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0405")) == 0)
+ {
+ // shrink the current window clipping rect by half the height & width
+ clipRect.Resize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);
+ }
+ else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0503")) == 0)
+ {
+ // grow the current window clipping rect by double the width
+ clipRect.Resize(iWindow->Size().iWidth * 2, iWindow->Size().iHeight);
+ }
+ else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0504")) == 0)
+ {
+ // move the current window clipping rect to be out of the window
+ clipRect.SetSize(iWindow->Size());
+ clipRect.Move(TPoint(iWindow->Size().iWidth + 1, 0));
+ }
+ else
+ {
+ User::Panic(_L("RTestVclnt2ClipRect"), KErrArgument);
+ }
+
+ // change the window clipping of the display window
+ TRAPD(err, aPlayer.SetWindowClipRectL(*iWindow, clipRect));
+ if (err != iTestExpectedError)
+ {
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0503")) == 0 ||
+ iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0504")) == 0)
+ {
+ // for negative tests, stop the test if the failure is not expected
+ ERR_PRINTF1(_L("iVideoPlayer2->SetWindowClipRectL() did not failed as expected. Test failed."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+ else
+ {
+ // fail only if error is returned for positive tests
+ User::LeaveIfError(err);
+ }
+ }
+ else
+ {
+ // Reset the expected error to KErrNone as all expected failure tests have been completed.
+ // Any error that appears after this should fail the test
+ iTestExpectedError = KErrNone;
+ }
+ }
+
+//
+// RTestVclnt2Scale
+//
+
+/**
+ * RTestVclnt2Scale::Constructor
+ */
+RTestVclnt2Scale::RTestVclnt2Scale(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2Scale::NewL
+ */
+RTestVclnt2Scale* RTestVclnt2Scale::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2Scale* self = new (ELeave) RTestVclnt2Scale(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2Scale::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2Scale::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ // Change the scale factor during playback
+ aPlayer.SetScaleFactorL(*iWindow, 150, 150);
+ }
+
+/**
+ * RTestVclnt2Scale::HandlePrepareCompleteL
+ */
+void RTestVclnt2Scale::HandlePrepareCompleteL()
+ {
+ // Continue to setup the video utility and then trigger playback
+ RTestVclnt2PerformActionDuringVideoPlayback::HandlePrepareCompleteL();
+
+ TReal32 scaleFactor = 50.0;
+
+ // set scale factor to less than 100%
+ iVideoPlayer2->SetScaleFactorL(*iWindow, scaleFactor, scaleFactor);
+
+ // get scale factor
+ TReal32 widthScale;
+ TReal32 heightScale;
+ iVideoPlayer2->GetScaleFactorL(*iWindow, widthScale, heightScale);
+
+ if (widthScale != scaleFactor || heightScale != scaleFactor)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->GetScaleFactorL() returns unexpected values. Test aborted."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+ }
+
+
+//
+// RTestVclnt2Viewport
+//
+
+/**
+ * RTestVclnt2Viewport::Constructor
+ */
+RTestVclnt2Viewport::RTestVclnt2Viewport(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ const TSize& aViewportSize,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError),
+ iViewportSize(aViewportSize)
+ {
+ }
+
+/**
+ * RTestVclnt2Viewport::NewL
+ */
+RTestVclnt2Viewport* RTestVclnt2Viewport::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ const TSize& aViewportSize,
+ TInt aExpectedError)
+ {
+ RTestVclnt2Viewport* self = new (ELeave) RTestVclnt2Viewport(aTestName,
+ aSectName,
+ aKeyName,
+ aViewportSize,
+ aExpectedError);
+ return self;
+ }
+
+void RTestVclnt2Viewport::HandlePrepareCompleteL()
+ {
+ // retrive original video size
+ TSize videoSize;
+ iVideoPlayer2->VideoFrameSizeL(videoSize);
+
+ // crop the top left quarter of the video
+ TRect cropRegion;
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0)
+ {
+ // Crop the right half of the video
+ cropRegion.SetHeight(videoSize.iHeight);
+ cropRegion.SetWidth(videoSize.iWidth / 2);
+ cropRegion.Move(cropRegion.Width(), 0);
+ }
+ else
+ {
+ cropRegion.SetWidth(iViewportSize.iWidth == -1 ? videoSize.iWidth : iViewportSize.iWidth);
+ cropRegion.SetHeight(iViewportSize.iHeight == -1 ? videoSize.iHeight : iViewportSize.iHeight);
+ }
+
+ TRect videoExtentRect;
+ TRect clipRegion;
+
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0)
+ {
+ videoExtentRect.SetRect(TPoint(0, 0), videoSize);
+ clipRegion.SetRect(TPoint(0, 0), videoSize);
+ clipRegion.SetWidth(clipRegion.Width() / 2);
+ clipRegion.Move(clipRegion.Width(), 0);
+ }
+ else
+ {
+ // Calculate the video extent to be exactly the same size as the cropped video picture,
+ // placed at the center of the window
+ TInt offsetX = (iWindow->Size().iWidth - cropRegion.Width()) / 2;
+ TInt offsetY = (iWindow->Size().iHeight - cropRegion.Height()) / 2;
+ videoExtentRect.SetRect(TPoint(offsetX, offsetY), cropRegion.Size());
+
+ // Set the window clipping region to the top vertical half of the cropped image, originating
+ // from the top left corner of the window
+ clipRegion = videoExtentRect;
+ clipRegion.SetHeight(videoExtentRect.Height() / 2);
+ }
+
+ HandlePrepareCompleteL(cropRegion, videoExtentRect, clipRegion);
+
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0)
+ {
+ // Align the image to the left of the window
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, 0);
+ }
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+void RTestVclnt2Viewport::HandlePrepareCompleteL(const TRect& aCropRegion,
+ const TRect& aVideoExtent,
+ const TRect& aClipRect)
+ {
+ iVideoPlayer2->SetCropRegionL(aCropRegion);
+
+ // get the video crop region to ensure the crop region is set
+ TRect currentCropRegion;
+ iVideoPlayer2->GetCropRegionL(currentCropRegion);
+
+ if (currentCropRegion != aCropRegion)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->GetCropRegionL() returns an unexpected value. Test aborted."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+ }
+
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, aVideoExtent, aClipRect);
+ }
+
+//
+// RTestVclnt2InvalidViewport
+//
+
+/**
+ * RTestVclnt2InvalidViewport::Constructor
+ */
+RTestVclnt2InvalidViewport::RTestVclnt2InvalidViewport(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2InvalidViewport::NewL
+ */
+RTestVclnt2InvalidViewport* RTestVclnt2InvalidViewport::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2InvalidViewport* self = new (ELeave) RTestVclnt2InvalidViewport(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2InvalidViewport::HandlePrepareCompleteL
+ */
+void RTestVclnt2InvalidViewport::HandlePrepareCompleteL()
+ {
+ // retrive original video size
+ TSize videoSize;
+ iVideoPlayer2->VideoFrameSizeL(videoSize);
+
+ // set the crop region to be completely out of the video image bound
+ TRect cropRegion;
+ cropRegion.SetRect(TPoint(videoSize.iWidth, videoSize.iHeight), TSize(100, 100));
+
+ // continue playback even if this fails
+ TRAPD(err, iVideoPlayer2->SetCropRegionL(cropRegion));
+ if (err == iTestExpectedError)
+ {
+ // the invalid crop area is not supposed to be set
+ INFO_PRINTF1(_L("iVideoPlayer2->SetCropRegionL() returned expected. Test continues."));
+
+ // reset the expected error. Any error that appears after this should fail the test
+ iTestExpectedError = KErrNone;
+ }
+ else
+ {
+ // the invalid crop area is not supposed to be set
+ ERR_PRINTF1(_L("iVideoPlayer2->SetCropRegionL() didn't leave with expected error. Test cannot be continued."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+ return;
+ }
+
+ // get the video crop region to ensure the crop region is set
+ TRect currentCropRegion;
+ iVideoPlayer2->GetCropRegionL(currentCropRegion);
+
+ if (currentCropRegion != cropRegion)
+ {
+ // the invalid crop area is not supposed to be set
+ ERR_PRINTF1(_L("iVideoPlayer2->GetCropRegionL() returns an unexpected value. Test cannot be continued."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+ return;
+ }
+
+ // setup the display then trigger the video to start playing
+ RTestVclnt2PlayFile::HandlePrepareCompleteL();
+ }
+
+
+//
+// RTestVclnt2Rotation
+//
+/**
+ * RTestVclnt2Rotation::Constructor
+ */
+RTestVclnt2Rotation::RTestVclnt2Rotation(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2Rotation::NewL
+ */
+RTestVclnt2Rotation* RTestVclnt2Rotation::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2Rotation* self = new (ELeave) RTestVclnt2Rotation(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2Rotation::HandlePrepareCompleteL
+ */
+void RTestVclnt2Rotation::HandlePrepareCompleteL()
+ {
+ // call parent's HandlePrepareCompleteL to finish off all preparation
+ RTestVclnt2PlayFile::HandlePrepareCompleteL();
+
+ // set the video to be displayed upside-down
+ TVideoRotation videoRotation(EVideoRotationClockwise180);
+ iVideoPlayer2->SetRotationL(*iWindow, videoRotation);
+
+ // retrieve the rotation setting, and check if it's been properly updated
+ if (iVideoPlayer2->RotationL(*iWindow) != videoRotation)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->RotationL() returns an unexpected value. Test aborted."));
+
+ iTestStepResult = EInconclusive;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+ }
+
+//
+// RTestVclnt2Settings
+//
+/**
+ * RTestVclnt2Settings::Constructor
+ */
+RTestVclnt2Settings::RTestVclnt2Settings(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2Settings::NewL
+ */
+RTestVclnt2Settings* RTestVclnt2Settings::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2Settings* self = new (ELeave) RTestVclnt2Settings(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2Settings::HandlePrepareCompleteL
+ */
+void RTestVclnt2Settings::HandlePrepareCompleteL()
+ {
+ // retrieve the current frame size
+ TSize frameSize;
+ iVideoPlayer2->VideoFrameSizeL(frameSize);
+
+ TRect cropRegion(frameSize);
+ // shrink the crop region to half its original height
+ cropRegion.SetHeight(cropRegion.Height() / 2);
+ iVideoPlayer2->SetCropRegionL(cropRegion);
+
+ TRect videoExtentRect;
+ videoExtentRect.SetWidth(cropRegion.Width());
+ videoExtentRect.SetHeight(cropRegion.Height());
+
+ videoExtentRect.Move((iWindow->Size().iWidth - videoExtentRect.Width()) / 2,
+ (iWindow->Size().iHeight - videoExtentRect.Height()) / 2);
+
+ TRect clippingRect(videoExtentRect);
+ clippingRect.SetWidth(clippingRect.Height() / 2);
+
+ // add display window using this valid clipping rect
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtentRect, clippingRect);
+
+ // Scale the movie with best fit scaling, and vertically center the picture
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleBestFit);
+
+ // Start video playback
+ StartPlayback();
+ }
+
+
+
+//
+// RTestVclnt2SettingsAndAlignments
+//
+/**
+ * RTestVclnt2SettingsAndAlignments::Constructor
+ */
+RTestVclnt2SettingsAndAlignments::RTestVclnt2SettingsAndAlignments(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::NewL
+ */
+RTestVclnt2SettingsAndAlignments* RTestVclnt2SettingsAndAlignments::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2SettingsAndAlignments* self = new (ELeave) RTestVclnt2SettingsAndAlignments(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+TVerdict RTestVclnt2SettingsAndAlignments::DoTestStepPreambleL()
+ {
+ iCount = 0;
+ return RTestVclnt2PlayFile::DoTestStepPreambleL();
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::HandlePrepareCompleteL
+ */
+void RTestVclnt2SettingsAndAlignments::HandlePrepareCompleteL()
+ {
+ TRect cropRegion;
+ SetCropRegionL(cropRegion);
+
+ AddDisplayWindowL(cropRegion);
+
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0418")) == 0)
+ {
+ SetContentOffsetL();
+ }
+ else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0419")) == 0)
+ {
+ SetContentAlignmentL();
+ }
+
+ SetScaleFactorL();
+
+ // Start video playback
+ StartPlayback();
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::HandlePlayCompleteL
+ */
+void RTestVclnt2SettingsAndAlignments::HandlePlayCompleteL()
+ {
+ iCount++;
+
+ if (iCount == KSettingsAndAlignmentTest)
+ {
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ }
+ else
+ {
+ HandlePrepareCompleteL();
+ }
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::SetCropRegionL
+ */
+void RTestVclnt2SettingsAndAlignments::SetCropRegionL(TRect& aCropRegion)
+ {
+ // retrieve the current frame size
+ TSize frameSize;
+ iVideoPlayer2->VideoFrameSizeL(frameSize);
+
+ // Framesize is used in this case as crop region is not returning default values
+ aCropRegion.SetRect(TPoint(0, 0), frameSize);
+
+ // set the crop region
+ switch (iCount % KSettingsAndAlignmentTest)
+ {
+ case 0:
+ // set the crop region to the top half of the image
+ aCropRegion.SetHeight(aCropRegion.Height() / 2);
+ iVideoPlayer2->SetCropRegionL(aCropRegion);
+ break;
+
+ case 1:
+ // set the crop region to the left half of the image
+ aCropRegion.SetWidth(aCropRegion.Width() / 2);
+ iVideoPlayer2->SetCropRegionL(aCropRegion);
+ break;
+
+ default:
+ // set the crop region to the bottom, right quarter of the image
+ aCropRegion.SetHeight(aCropRegion.Height() / 2);
+ aCropRegion.SetWidth(aCropRegion.Width() / 2);
+ aCropRegion.Move(aCropRegion.Width(), aCropRegion.Height());
+ iVideoPlayer2->SetCropRegionL(aCropRegion);
+ break;
+ }
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::SetContentOffsetL
+ */
+void RTestVclnt2SettingsAndAlignments::SetContentOffsetL()
+ {
+ switch (iCount % KSettingsAndAlignmentTest)
+ {
+ case 0:
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 0, 100);
+ break;
+
+ case 1:
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 0);
+ break;
+
+ default:
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 100);
+ break;
+ }
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::SetContentAlignmentL
+ */
+void RTestVclnt2SettingsAndAlignments::SetContentAlignmentL()
+ {
+ switch (iCount % KSettingsAndAlignmentTest)
+ {
+ case 0:
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 0, EVerticalAlignCenter);
+ break;
+
+ case 1:
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, 0);
+ break;
+
+ default:
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignCenter);
+ break;
+ }
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::SetScaleFactorL
+ */
+void RTestVclnt2SettingsAndAlignments::SetScaleFactorL()
+ {
+ switch (iCount % KSettingsAndAlignmentTest)
+ {
+ case 0:
+ iVideoPlayer2->SetScaleFactorL(*iWindow, 1, 200);
+ break;
+
+ case 1:
+ iVideoPlayer2->SetScaleFactorL(*iWindow, 200, 1);
+ break;
+
+ default:
+ iVideoPlayer2->SetScaleFactorL(*iWindow, 200, 200);
+ break;
+ }
+ }
+
+/**
+ * RTestVclnt2SettingsAndAlignments::AddDisplayWindowL
+ */
+void RTestVclnt2SettingsAndAlignments::AddDisplayWindowL(const TRect& aCropRegion)
+ {
+ TRect videoExtentRect(iWindow->Size());
+ TRect clippingRect(iWindow->Size());
+
+ switch (iCount % KSettingsAndAlignmentTest)
+ {
+ case 0:
+ videoExtentRect.SetWidth(aCropRegion.Width());
+ if (iWindow->Size().iWidth > videoExtentRect.Width())
+ {
+ videoExtentRect.Move((iWindow->Size().iWidth - videoExtentRect.Width()) / 2, 0);
+ }
+ clippingRect = videoExtentRect;
+ break;
+
+ case 1:
+ videoExtentRect.SetHeight(aCropRegion.Height());
+ if (iWindow->Size().iHeight > videoExtentRect.Height())
+ {
+ videoExtentRect.Move(0, (iWindow->Size().iHeight - videoExtentRect.Height()) / 2);
+ }
+ clippingRect = videoExtentRect;
+ break;
+
+ default:
+ clippingRect.SetHeight(clippingRect.Height() / 2);
+ clippingRect.SetWidth(clippingRect.Width() / 2);
+ clippingRect.Move(clippingRect.Width(), clippingRect.Height());
+ break;
+ }
+
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtentRect, clippingRect);
+ }
+
+
+//
+// RTestVclnt2SecDisplay
+//
+/**
+ * RTestVclnt2SecDisplay::Constructor
+ */
+RTestVclnt2SecDisplay::RTestVclnt2SecDisplay(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2SecDisplay::NewL
+ */
+RTestVclnt2SecDisplay* RTestVclnt2SecDisplay::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2SecDisplay* self = new (ELeave) RTestVclnt2SecDisplay(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2SecDisplay::DoTestStepPreambleL
+ */
+TVerdict RTestVclnt2SecDisplay::DoTestStepPreambleL()
+ {
+ TVerdict verdict = RTestVclnt2PlayFile::DoTestStepPreambleL();
+ if (verdict == EPass)
+ {
+ // make a 2nd device for this session
+ iSecondScreen = new (ELeave) CWsScreenDevice(iWs);
+ User::LeaveIfError(iSecondScreen->Construct());
+ }
+
+ return verdict;
+ }
+
+/**
+ * RTestVclnt2SecDisplay::DoTestStepPostambleL
+ */
+TVerdict RTestVclnt2SecDisplay::DoTestStepPostambleL()
+ {
+ delete iSecondScreen;
+
+ return EPass;
+ }
+
+/**
+ * RTestVclnt2SecDisplay::HandlePrepareCompleteL
+ */
+void RTestVclnt2SecDisplay::HandlePrepareCompleteL()
+ {
+ // Add display window using default values - ie. video extent & window clipping
+ // defaulted to whole window
+ INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iSecondScreen, *iWindow);
+
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+
+//
+// RTestVclnt2CropRectPause
+//
+/**
+ * RTestVclnt2CropRectPause::Constructor
+ */
+RTestVclnt2CropRectPause::RTestVclnt2CropRectPause(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2CropRectPause::NewL
+ */
+RTestVclnt2CropRectPause* RTestVclnt2CropRectPause::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2CropRectPause* self
+ = new (ELeave) RTestVclnt2CropRectPause(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2CropRectPause::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2CropRectPause::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ TRect cropRegion;
+ aPlayer.GetCropRegionL(cropRegion);
+
+ // change the crop region and continue to play the clip
+ cropRegion.SetHeight(cropRegion.Height() / 2);
+ aPlayer.SetCropRegionL(cropRegion);
+ }
+
+
+
+//
+// RTestVclnt2Overlay
+//
+/**
+ * RTestVclnt2Overlay::Constructor
+ */
+RTestVclnt2Overlay::RTestVclnt2Overlay(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2Overlay::NewL
+ */
+RTestVclnt2Overlay* RTestVclnt2Overlay::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2Overlay* self = new (ELeave) RTestVclnt2Overlay(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2Overlay::DoTestStepPreambleL
+ */
+TVerdict RTestVclnt2Overlay::DoTestStepPreambleL()
+ {
+ TVerdict verdict = RTestVclnt2PlayFile::DoTestStepPreambleL();
+ if (verdict == EPass)
+ {
+ TFontSpec fontSpec; // use default fonts
+ fontSpec.iHeight = 20;
+
+ // Get a font to draw overlay text
+ if (iScreen->GetNearestFontToDesignHeightInPixels(iFont, fontSpec) != KErrNone)
+ {
+ // if no font can be retrieved, abort the test
+ ERR_PRINTF1(_L("Cannot retrieve font to perform test. Test aborted."));
+
+ return EInconclusive;
+ }
+
+ iGc->Activate(*iWindow);
+ iGc->UseFont(iFont);
+ }
+
+ return verdict;
+ }
+
+/**
+ * RTestVclnt2Overlay::DoTestStepPostambleL
+ */
+TVerdict RTestVclnt2Overlay::DoTestStepPostambleL()
+ {
+ iGc->DiscardFont();
+ iGc->Deactivate();
+
+ return RTestVclnt2PlayFile::DoTestStepPostambleL();
+ }
+
+/**
+ * RTestVclnt2Overlay::HandlePrepareCompleteL
+ */
+void RTestVclnt2Overlay::HandlePrepareCompleteL()
+ {
+ TRect rect(iWindow->Size());
+ TInt baseline = (rect.Height() + iFont->AscentInPixels()) >> 1;
+
+ // Draw the overlay text if needed
+ iGc->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iGc->SetBrushColor(KRgbRed);
+
+ iGc->SetPenStyle(CGraphicsContext::ESolidPen);
+ iGc->SetPenColor(KRgbBlue);
+
+ iGc->DrawText(_L("Overlay Testing"), rect, baseline, CGraphicsContext::ELeft);
+
+ // setup the display window and trigger the video to start playing
+ RTestVclnt2PlayFile::HandlePrepareCompleteL();
+ }
+
+
+//
+// RTestVclnt2AddWin2
+//
+
+/**
+ * RTestVclnt2AddWin2::Constructor
+ */
+RTestVclnt2AddWin2::RTestVclnt2AddWin2(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2AddWin2::NewL
+ */
+RTestVclnt2AddWin2* RTestVclnt2AddWin2::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2AddWin2* self = new (ELeave) RTestVclnt2AddWin2(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2AddWin2::HandlePrepareCompleteL
+ */
+void RTestVclnt2AddWin2::HandlePrepareCompleteL()
+ {
+ // add the display window for the player to use for displaying the video
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+
+ // Add the same display window again
+ TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed."));
+
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an expected error. Test continues."));
+
+ // reset the expected error. Any error that appears after this should fail the test
+ iTestExpectedError = KErrNone;
+ }
+
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+//
+// RTestVclnt2AddWin2WithSettings
+//
+
+/**
+ * RTestVclnt2AddWin2WithSettings::Constructor
+ */
+RTestVclnt2AddWin2WithSettings::RTestVclnt2AddWin2WithSettings(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2AddWin2WithSettings::NewL
+ */
+RTestVclnt2AddWin2WithSettings* RTestVclnt2AddWin2WithSettings::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2AddWin2WithSettings* self = new (ELeave) RTestVclnt2AddWin2WithSettings(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2AddWin2WithSettings::HandlePrepareCompleteL
+ */
+void RTestVclnt2AddWin2WithSettings::HandlePrepareCompleteL()
+ {
+ TRect windowRect(iWindow->Size());
+ windowRect.SetHeight(windowRect.Height() / 2);
+
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, windowRect, windowRect);
+
+ // Add the same display window again with default values
+ TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error. Test failed."));
+
+ iTestStepResult = EFail;
+ CActiveScheduler::Stop();
+
+ return;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an expected error. Test continues."));
+
+ // reset the expected error. Any error that appears after this should fail the test
+ iTestExpectedError = KErrNone;
+ }
+
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+//
+// RTestVclnt2ContOffset
+//
+
+/**
+ * RTestVclnt2ContOffset::Constructor
+ */
+RTestVclnt2ContOffset::RTestVclnt2ContOffset(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ iHeapSize = 2000000; //~2MB
+ }
+
+/**
+ * RTestVclnt2ContOffset::NewL
+ */
+RTestVclnt2ContOffset* RTestVclnt2ContOffset::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2ContOffset* self = new (ELeave) RTestVclnt2ContOffset(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2ContOffset::HandlePrepareCompleteL
+ */
+void RTestVclnt2ContOffset::HandlePrepareCompleteL()
+ {
+ // call parent's HandlePrepareCompleteL to finish off all preparation
+ RTestVclnt2PlayFile::HandlePrepareCompleteL();
+ // Set the content offset before starting to play the video.
+ INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 100);
+
+ if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0409")) == 0)
+ {
+ // Set the content alignment after setting the content offset
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignTop);
+ }
+ }
+
+//
+// RTestVclnt2ContOffsetAtPlay
+//
+/**
+ * RTestVclnt2ContOffsetAtPlay::Constructor
+ */
+RTestVclnt2ContOffsetAtPlay::RTestVclnt2ContOffsetAtPlay(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ iHeapSize = 2000000; //~2MB
+ }
+
+/**
+ * RTestVclnt2ContOffsetAtPlay::NewL
+ */
+RTestVclnt2ContOffsetAtPlay* RTestVclnt2ContOffsetAtPlay::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2ContOffsetAtPlay* self = new (ELeave) RTestVclnt2ContOffsetAtPlay(aTestName,
+ aSectName,
+ aKeyName,
+ aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2ContOffsetAtPlay::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2ContOffsetAtPlay::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& /* aPlayer */)
+ {
+ // Change the scale factor during playback
+ INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 10, 10);
+ }
+
+
+//
+// RTestVclnt2Align
+//
+/**
+ * RTestVclnt2Align::Constructor
+ */
+RTestVclnt2Align::RTestVclnt2Align(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ iHeapSize = 2000000; //~2MB
+ }
+
+/**
+ * RTestVclnt2Align::NewL
+ */
+RTestVclnt2Align* RTestVclnt2Align::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2Align* self = new (ELeave) RTestVclnt2Align(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2Align::HandlePrepareCompleteL
+ */
+void RTestVclnt2Align::HandlePrepareCompleteL()
+ {
+ // Continue to setup the video utility and then trigger playback
+ RTestVclnt2PlayFile::HandlePrepareCompleteL();
+ // Set the content offset before starting to play the video.
+ INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignCenter);
+ }
+
+/**
+ * RTestVclnt2Align::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2Align::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& /* aPlayer */)
+ {
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignCenter);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(10, 10, 100, 100), TRect(0, 3, 4, 220));
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignCenter);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignTop);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(10, 10, 100, 100), TRect(0, 5, 5, 200));
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignTop);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignTop);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(0, 0, 100, 100), TRect(0, 5, 5, 200));
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignBottom);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignBottom);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(0, 0, 100, 100), TRect(0, 5, 300, 230));
+
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignBottom);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+ }
+
+
+//
+// RTestVclnt2AutoScale
+//
+/**
+ * RTestVclnt2AutoScale::Constructor
+ */
+RTestVclnt2AutoScale::RTestVclnt2AutoScale(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ iHeapSize = 2000000; //~2MB
+ }
+
+/**
+ * RTestVclnt2AutoScale::NewL
+ */
+RTestVclnt2AutoScale* RTestVclnt2AutoScale::NewL(const TDesC& aTestName,
+ const TDesC& aSectName,
+ const TDesC& aKeyName,
+ TInt aExpectedError)
+ {
+ RTestVclnt2AutoScale* self = new (ELeave) RTestVclnt2AutoScale(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+/**
+ * RTestVclnt2AutoScale::HandlePrepareCompleteL
+ */
+void RTestVclnt2AutoScale::HandlePrepareCompleteL()
+ {
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+ // Set the content offset before starting to play the video.
+ INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));
+ iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleClip);
+
+ // trigger the video to start playing
+ StartPlayback();
+ }
+
+/**
+ * RTestVclnt2AutoScale::DoThisActionDuringPlaybackL
+ */
+void RTestVclnt2AutoScale::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)
+ {
+ aPlayer.SetAutoScaleL(*iWindow, EAutoScaleBestFit);
+ aPlayer.SetAutoScaleL(*iWindow, EAutoScaleNone);
+ aPlayer.SetAutoScaleL(*iWindow, EAutoScaleStretch);
+ }
+
+//
+// RTestVclnt2OldController
+//
+
+RTestVclnt2OldController::RTestVclnt2OldController(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2OldController::NewL
+ */
+RTestVclnt2OldController* RTestVclnt2OldController::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2OldController* self = new (ELeave) RTestVclnt2OldController(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+void RTestVclnt2OldController::HandleIdleL()
+ {
+ // Open iVideoPlayer using a controller that does not support surfaces.
+ INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);
+ iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviNonGcePlayControllerUid);
+ PrepareState(EVPOpenComplete, KErrNone);
+ }
+
+void RTestVclnt2OldController::HandlePrepareCompleteL()
+ {
+ TRAPD(err, RTestVclnt2PlayFile::HandlePrepareCompleteL());
+
+ if (err != KErrNotSupported)
+ {
+ ERR_PRINTF1(_L("AddDisplay did not leave with KErrNotSupported."));
+ iTestStepResult = EFail;
+ }
+ else
+ {
+ iTestStepResult = EPass;
+ }
+
+ // Stop the test.
+ CActiveScheduler::Stop();
+ }
+//
+// RTestVclnt2NoFile
+//
+
+RTestVclnt2NoFile::RTestVclnt2NoFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2NoFile::NewL
+ */
+RTestVclnt2NoFile* RTestVclnt2NoFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2NoFile* self = new (ELeave) RTestVclnt2NoFile(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+void RTestVclnt2NoFile::HandleIdleL()
+ {
+ iTestStepResult = EFail;
+ TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));
+
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("AddDisplayWindowL did not leave with KErrNotReady."));
+ User::Leave(KErrGeneral);
+ }
+
+ TSize windowSize = iWindow->Size();
+ TRect videoExtent(-5, -5, windowSize.iWidth + 5, windowSize.iHeight + 5);
+ TRect windowClipRect(5, 5, windowSize.iWidth - 5, windowSize.iHeight - 5);
+ TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtent, windowClipRect));
+
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("AddDisplayWindowL did not leave with KErrNotReady."));
+ User::Leave(KErrGeneral);
+ }
+
+ TRAP(err, iVideoPlayer2->SetWindowClipRectL(*iWindow, windowClipRect));
+
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("SetWindowClipRectL did not leave with KErrNotReady."));
+ User::Leave(KErrGeneral);
+ }
+
+ TRAP(err, iVideoPlayer2->SetVideoExtentL(*iWindow, videoExtent));
+
+ if (err != iTestExpectedError)
+ {
+ ERR_PRINTF1(_L("SetVideoExtentL did not leave with KErrNotReady."));
+ User::Leave(KErrGeneral);
+ }
+
+ // reset the expected error to KErrNone as any error happens after this is unexpected
+ iTestExpectedError = KErrNone;
+
+ // The video should still play when we try to play the video. Perform
+ // the basic play test now.
+ RTestVclnt2PlayFile::HandleIdleL();
+ }
+
+//
+// RTestVclnt2PlayAfterRemoveWin
+//
+
+RTestVclnt2PlayAfterRemoveWin::RTestVclnt2PlayAfterRemoveWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2PlayAfterRemoveWin::NewL
+ */
+RTestVclnt2PlayAfterRemoveWin* RTestVclnt2PlayAfterRemoveWin::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2PlayAfterRemoveWin* self = new (ELeave) RTestVclnt2PlayAfterRemoveWin(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+void RTestVclnt2PlayAfterRemoveWin::HandlePrepareCompleteL()
+ {
+ // Don't add a window. Just play the video.
+ StartPlayback();
+ }
+
+void RTestVclnt2PlayAfterRemoveWin::HandlePlayCompleteL()
+ {
+ switch(iPlayAttempt)
+ {
+ case 0:
+ {
+ TSize windowSize = iWindow->Size();
+ TRect videoExtent(-5, -5, windowSize.iWidth + 5, windowSize.iHeight + 5);
+ TRect windowClipRect(5, 5, windowSize.iWidth - 5, windowSize.iHeight - 5);
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtent, windowClipRect);
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->Play();
+ PrepareState(EVPPlayComplete, KErrNone);
+ break;
+ }
+ case 1:
+ // Removing the window again should have no effect.
+ iVideoPlayer2->RemoveDisplayWindow(*iWindow);
+ iVideoPlayer2->Play();
+ PrepareState(EVPPlayComplete, KErrNone);
+ break;
+ case 2:
+ // The previous play commands should have no effect when we try to add a
+ // display window and render to surfaces. Use the base class to do this.
+ RTestVclnt2PlayFile::HandlePrepareCompleteL();
+ break;
+ default:
+ // Use the parent handler after we have tried the above play commands.
+ RTestVclnt2PlayFile::HandlePlayCompleteL();
+ break;
+ }
+
+ iPlayAttempt++;
+ }
+
+//
+// RTestVclnt2NoGce
+//
+
+RTestVclnt2NoGce::RTestVclnt2NoGce(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2NoGce::NewL
+ */
+RTestVclnt2NoGce* RTestVclnt2NoGce::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2NoGce* self = new (ELeave) RTestVclnt2NoGce(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+void RTestVclnt2NoGce::HandleIdleL()
+ {
+ // Open iVideoPlayer
+ INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);
+ iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);
+ PrepareState(EVPOpenComplete, KErrNotSupported);
+ }
+
+void RTestVclnt2NoGce::HandleOpenCompleteL()
+ {
+ iTestStepResult = EPass;
+ CActiveScheduler::Stop();
+ }
+
+//
+// RTestVclnt2Alloc
+//
+
+RTestVclnt2Alloc::RTestVclnt2Alloc(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2Alloc::NewL
+ */
+RTestVclnt2Alloc* RTestVclnt2Alloc::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2Alloc* self = new (ELeave) RTestVclnt2Alloc(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+TVerdict RTestVclnt2Alloc::DoTestStepPreambleL()
+ {
+ INFO_PRINTF1(_L("RTestVclnt2Alloc::DoTestStepPreambleL()"));
+
+ // Call RTestMmfVclntAviStep::DoTestStepPreambleL instead of the immediate parent's
+ // DoTestStepPreambleL as there is no need for CVideoPlayerUtility setup.
+ // Similarly, there is no need to initialize CVideoPlayerUtility2, as it will be
+ // created in each alloc iteration.
+ return RTestMmfVclntAviStep::DoTestStepPreambleL();
+ }
+
+TVerdict RTestVclnt2Alloc::PerformTestL()
+ {
+ iVideoPlayer2 = CVideoPlayerUtility2::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);
+ ResetState();
+ iError = KErrNone;
+ TVerdict result = RTestVclnt2AviPlayerStep::DoTestStepL();
+ delete iVideoPlayer2;
+ iVideoPlayer2 = NULL;
+ return result;
+ }
+
+/**
+ * RTestVclnt2Alloc::DoTestStepL()
+ */
+TVerdict RTestVclnt2Alloc::DoTestStepL()
+ {
+ TVerdict allocTestStepResult = EPass;
+ TInt err = KErrNone;
+ TBool result = EFalse;
+
+ //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<
+ if (PerformTestL() != EPass)
+ {
+ err = iError;
+ }
+
+ if (err != KErrNone)
+ {
+ INFO_PRINTF2(_L("Test error, returned error code = %d"), err);
+ User::Leave(err);
+ }
+ else
+ {
+ //Check the iAllocTestStepResult
+ if (allocTestStepResult != EPass)
+ {
+ result = ETrue;
+ }
+ }
+
+ TInt failCount = 1;
+ TBool completed = EFalse;
+ allocTestStepResult = EPass;
+ TBool reachedEnd = EFalse;
+ for(;;)
+ {
+ __UHEAP_SETFAIL(RHeap::EFailNext, failCount);
+ __MM_HEAP_MARK;
+
+ //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<
+ TVerdict verdict = EFail;
+ TRAP(err, verdict = PerformTestL());
+ 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 (allocTestStepResult != 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)
+ {
+ allocTestStepResult = 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);
+ }
+
+ return allocTestStepResult;
+ }
+
+//
+// RTestVclnt2InvalidScaleFactor
+//
+RTestVclnt2InvalidScaleFactor::RTestVclnt2InvalidScaleFactor(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)
+ {
+ }
+
+/**
+ * RTestVclnt2InvalidScaleFactor::NewL
+ */
+RTestVclnt2InvalidScaleFactor* RTestVclnt2InvalidScaleFactor::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)
+ {
+ RTestVclnt2InvalidScaleFactor* self = new (ELeave) RTestVclnt2InvalidScaleFactor(aTestName, aSectName, aKeyName, aExpectedError);
+ return self;
+ }
+
+void RTestVclnt2InvalidScaleFactor::HandlePrepareCompleteL()
+ {
+ INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));
+ iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);
+
+ // Try to scale the video to an invalid values
+ TRAPD(err, iVideoPlayer2->SetScaleFactorL(*iWindow, 0, 100));
+ if (err != KErrArgument)
+ {
+ User::Leave(err == KErrNone ? KErrGeneral : err);
+ }
+
+ TRAP(err, iVideoPlayer2->SetScaleFactorL(*iWindow, 100, -100));
+ if (err != KErrArgument)
+ {
+ User::Leave(err == KErrNone ? KErrGeneral : err);
+ }
+
+ // trigger the video to start playing
+ StartPlayback();
+ }