MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/src/testvideoplayer2.cpp
author sl@SLION-WIN7.fritz.box
Fri, 15 Jun 2012 03:10:57 +0200
changeset 0 bde4ae8d615e
permissions -rw-r--r--
First public contribution. 
     1 // Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15  

    16 #include <e32math.h>

    17 #include "testvideoplayer2.h"

    18 

    19 #ifdef SYMBIAN_BUILD_GCE

    20 #include <graphics/surfacemanager.h>

    21 #endif

    22 

    23 const TInt KSettingsAndAlignmentTest = 3;

    24 

    25 //

    26 // RTestVclntPlayAviFile

    27 //

    28 

    29 /**

    30  * RTestVclnt2PlayFile::Constructor

    31  */

    32 RTestVclnt2PlayFile::RTestVclnt2PlayFile(const TDesC& aTestName, 

    33                                          const TDesC& aSectName, 

    34                                          const TDesC& aKeyName, 

    35                                          TInt aExpectedError)

    36     : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

    37     {

    38     }

    39 

    40 /**

    41  * RTestVclnt2PlayFile::NewL

    42  */

    43 RTestVclnt2PlayFile* RTestVclnt2PlayFile::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)

    44     {

    45     RTestVclnt2PlayFile* self = new (ELeave) RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError);

    46     return self;

    47     }

    48 

    49 /**

    50  * RTestVclnt2PlayFile::DoTestStepPreambleL

    51  */

    52 TVerdict RTestVclnt2PlayFile::DoTestStepPreambleL()

    53     {

    54     return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();

    55     }

    56 

    57 /**

    58  * RTestVclnt2PlayFile::DoTestStepPostambleL

    59  */

    60 TVerdict RTestVclnt2PlayFile::DoTestStepPostambleL()

    61     {

    62     return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();        

    63     }

    64 

    65 /**

    66  * RTestVclnt2PlayFile::FsmL

    67  */

    68 void RTestVclnt2PlayFile::FsmL(TVclntTestPlayEvents aEventCode)

    69     {

    70     if (FsmCheck(aEventCode))

    71         {

    72         switch (aEventCode)

    73             {

    74             case EVPIdle:

    75                 HandleIdleL();

    76                 break;

    77                 

    78             case EVPOpenComplete:

    79                 HandleOpenCompleteL();

    80                 break;

    81                 

    82             case EVPPrepareComplete:                    

    83                 HandlePrepareCompleteL();

    84                 break;

    85                 

    86             case EVPPlayComplete:

    87                 HandlePlayCompleteL();

    88                 break;

    89             }

    90         }

    91     }

    92     

    93 void RTestVclnt2PlayFile::HandleIdleL()

    94 	{

    95 	// Open iVideoPlayer

    96     INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

    97     iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

    98     PrepareState(EVPOpenComplete, KErrNone);

    99 	}

   100 

   101 void RTestVclnt2PlayFile::HandleOpenCompleteL()

   102 	{

   103 	// Prepare iVideoPlayer2

   104     INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));

   105     iVideoPlayer2->Prepare();

   106     PrepareState(EVPPrepareComplete, KErrNone);

   107 	}

   108 	

   109 void RTestVclnt2PlayFile::HandlePrepareCompleteL()

   110 	{

   111 	// Add display window using default values - ie. video extent & window clipping 

   112 	// defaulted to whole window

   113 	INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));

   114 	iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);

   115 

   116     // trigger the video to start playing                

   117     StartPlayback();

   118 	}

   119 

   120 void RTestVclnt2PlayFile::HandlePlayCompleteL()

   121 	{

   122 	iTestStepResult = EPass;

   123 	CActiveScheduler::Stop();

   124 	}

   125 

   126 void RTestVclnt2PlayFile::StartPlayback()

   127 	{

   128     iError = KErrTimedOut;

   129     INFO_PRINTF1(_L("iVideoPlayer2->Play()"));

   130     PrepareState(EVPPlayComplete, KErrNone);

   131     iVideoPlayer2->Play();

   132 	}

   133 	

   134 #ifdef SYMBIAN_BUILD_GCE

   135 //

   136 // RTestMediaClientVideoDisplay

   137 //

   138 

   139 /**

   140  * RTestMediaClientVideoDisplay::Constructor

   141  */

   142 

   143 

   144 RTestMediaClientVideoDisplay::RTestMediaClientVideoDisplay(const TDesC& aTestName, 

   145                                          const TDesC& aSectName, 

   146                                          const TDesC& aKeyName, 

   147                                          TInt aExpectedError)

   148     : RTestVclnt2AviPlayerStep(aTestName, aSectName, aKeyName, aExpectedError)

   149     {

   150     }

   151 

   152 /**

   153  * RTestMediaClientVideoDisplay::NewL

   154  */

   155 

   156 RTestMediaClientVideoDisplay* RTestMediaClientVideoDisplay::NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError)

   157     {

   158     RTestMediaClientVideoDisplay* self = new (ELeave) RTestMediaClientVideoDisplay(aTestName, aSectName, aKeyName, aExpectedError);

   159     return self;

   160     }

   161 

   162 /**

   163  * RTestMediaClientVideoDisplay::DoTestStepPreambleL

   164  */

   165  

   166 TVerdict RTestMediaClientVideoDisplay::DoTestStepPreambleL()

   167     {

   168     return RTestVclnt2AviPlayerStep::DoTestStepPreambleL();

   169     }

   170 

   171 /**

   172  * RTestMediaClientVideoDisplay::DoTestStepPostambleL

   173  */

   174  

   175 TVerdict RTestMediaClientVideoDisplay::DoTestStepPostambleL()

   176     {

   177     return RTestVclnt2AviPlayerStep::DoTestStepPostambleL();        

   178     }

   179 

   180 /**

   181  * RTestMediaClientVideoDisplay::FsmL

   182  */

   183 void RTestMediaClientVideoDisplay::FsmL(TVclntTestPlayEvents aEventCode)

   184     {

   185     if (FsmCheck(aEventCode))

   186         {

   187         switch (aEventCode)

   188             {

   189             case EVPIdle:

   190                 HandleIdleL();

   191                 break;

   192                 

   193             case EVPOpenComplete:

   194                 HandleOpenCompleteL();

   195                 break;

   196                 

   197             case EVPPrepareComplete:                    

   198                 HandlePrepareCompleteL();

   199                 break;

   200                 

   201             case EVPPlayComplete:

   202                 HandlePlayCompleteL();

   203                 break;

   204             }

   205         }

   206     }

   207     

   208 void RTestMediaClientVideoDisplay::HandleIdleL()

   209 	{

   210 	// Open iVideoPlayer

   211     INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

   212     iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

   213     PrepareState(EVPOpenComplete, KErrNone);

   214 	}

   215 

   216 void RTestMediaClientVideoDisplay::HandleOpenCompleteL()

   217 	{

   218 	// Prepare iVideoPlayer2

   219     INFO_PRINTF1(_L("iVideoPlayer2->Prepare()"));

   220     iVideoPlayer2->Prepare();

   221     PrepareState(EVPPrepareComplete, KErrNone);

   222 	}

   223 	

   224 void RTestMediaClientVideoDisplay::HandlePrepareCompleteL()

   225 	{

   226 	// trigger the video to start playing  

   227 	StartPlayback();

   228 	

   229 	TInt displayId = iScreen->GetScreenNumber();

   230 	TRect clipRect = TRect(iWindow->Size());

   231 	TRect cropRegion = clipRect;

   232 	

   233 	// ==========================

   234 	

   235     iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);

   236     

   237  	RSurfaceManager surfaceManager;

   238  	User::LeaveIfError(surfaceManager.Open());

   239 	

   240 	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

   241 	RSurfaceManager::TSurfaceCreationAttributes& b=bf();

   242 	b.iSize.iWidth = 320;

   243 	b.iSize.iHeight = 240;

   244 	b.iBuffers = 1;

   245 	b.iPixelFormat = EUidPixelFormatXRGB_8888;	

   246 	b.iStride = 320 * 4;

   247 	b.iOffsetToFirstBuffer = 0;

   248 	b.iAlignment=4;

   249 	b.iContiguous=ETrue;

   250 	

   251 	TRect cropRect(0, 0, 320, 240);

   252 	TVideoAspectRatio par(1,2);

   253 	TSurfaceId surfaceId;

   254 	

   255 	User::LeaveIfError(surfaceManager.CreateSurface(bf, surfaceId));

   256  	

   257     iMediaClientVideoDisplay->SurfaceCreated(surfaceId, cropRect, par, cropRegion);

   258     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceCreated()"));

   259     

   260     delete iMediaClientVideoDisplay;

   261     iMediaClientVideoDisplay = NULL;

   262     

   263     // ==================

   264     

   265     iMediaClientVideoDisplay = CMediaClientVideoDisplay::NewL(displayId);

   266     

   267 	TRect videoExtent = clipRect;

   268 	TReal32 scaleWidth(100.0f);

   269 	TReal32 scaleHeight(100.0f);

   270 	TInt horizPos(EHorizontalAlignCenter);

   271 	TInt vertPos(EVerticalAlignCenter);	

   272 	

   273 	TReal32 widthPercentage(50.0f); 

   274 	TReal32 heightPercentage(50.0f);

   275 	TReal32 widthP; 

   276 	TReal32 heightP;

   277 	RWindow newWindow;

   278 	

   279 	// Check for invalid rotation when adding new window

   280 	INFO_PRINTF1(_L("Testing invalid rotations for AddDisplayWindowL"));

   281 	TInt err = KErrNone;

   282 	TVideoRotation rotation = static_cast<TVideoRotation>(-1);

   283 	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow));

   284 	if (err != KErrArgument)

   285 		{

   286 		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for negative rotation"));

   287     	iTestStepResult = EFail;

   288     	CActiveScheduler::Stop();

   289     	return;

   290 		}

   291 

   292 	rotation = static_cast<TVideoRotation>(4);

   293 	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow));

   294 	if (err != KErrArgument)

   295 		{

   296 		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for out of range rotation"));

   297     	iTestStepResult = EFail;

   298     	CActiveScheduler::Stop();

   299     	return;

   300 		}

   301 

   302 	rotation = EVideoRotationNone;

   303 

   304 	// Check for invalid autoScaleType when adding new window

   305 	INFO_PRINTF1(_L("Testing invalid autoScaleType for AddDisplayWindowL"));

   306 	TAutoScaleType autoScaleType = static_cast<TAutoScaleType>(-1);

   307 	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, autoScaleType, horizPos, vertPos, iWindow));

   308 	if (err != KErrArgument)

   309 		{

   310 		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for negative scale"));

   311     	iTestStepResult = EFail;

   312     	CActiveScheduler::Stop();

   313     	return;

   314 		}

   315 

   316 	autoScaleType = static_cast<TAutoScaleType>(4);

   317 	TRAP(err, iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, autoScaleType, horizPos, vertPos, iWindow));

   318 	if (err != KErrArgument)

   319 		{

   320 		ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() did not leave with KErrArgument for out of range scale"));

   321     	iTestStepResult = EFail;

   322     	CActiveScheduler::Stop();

   323     	return;

   324 		}

   325 	

   326 	iMediaClientVideoDisplay->AddDisplayWindowL(iWindow, clipRect, cropRegion, videoExtent, scaleWidth, scaleHeight, rotation, EAutoScaleBestFit, horizPos, vertPos, iWindow);

   327 	INFO_PRINTF1(_L("iMediaClientVideoDisplay->AddDisplayWindowL()"));   

   328 

   329 	// Check for invalid rotation when setting rotation for window

   330 	INFO_PRINTF1(_L("Testing invalid rotation for SetRotationL"));

   331 	TVideoRotation videoRotation = static_cast<TVideoRotation>(-1);

   332 	TRAP(err, iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion));

   333 	if (err != KErrArgument)

   334 		{

   335 		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL(window) did not leave with KErrArgument for negative value"));

   336     	iTestStepResult = EFail;

   337     	CActiveScheduler::Stop();

   338     	return;

   339 		}

   340 

   341 	videoRotation = static_cast<TVideoRotation>(4);

   342 	TRAP(err, iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion));

   343 	if (err != KErrArgument)

   344 		{

   345 		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL(window) did not leave with KErrArgument for out of range value"));

   346     	iTestStepResult = EFail;

   347     	CActiveScheduler::Stop();

   348     	return;

   349 		}

   350 

   351 	// Check for invalid rotation when setting rotation for all windows

   352 	videoRotation = static_cast<TVideoRotation>(-1);

   353 	TRAP(err, iMediaClientVideoDisplay->SetRotationL(videoRotation, cropRegion));

   354 	if (err != KErrArgument)

   355 		{

   356 		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL() did not leave with KErrArgument for negative value"));

   357     	iTestStepResult = EFail;

   358     	CActiveScheduler::Stop();

   359     	return;

   360 		}

   361 

   362 	videoRotation = static_cast<TVideoRotation>(4);

   363 	TRAP(err, iMediaClientVideoDisplay->SetRotationL(videoRotation, cropRegion));

   364 	if (err != KErrArgument)

   365 		{

   366 		ERR_PRINTF1(_L("iVideoPlayer2->SetRotationL() did not leave with KErrArgument for out of range value"));

   367     	iTestStepResult = EFail;

   368     	CActiveScheduler::Stop();

   369     	return;

   370 		}

   371 

   372 	videoRotation = EVideoRotationClockwise180;

   373 

   374     iMediaClientVideoDisplay->SetRotationL(*iWindow, videoRotation, cropRegion);

   375     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));

   376     

   377     if (iMediaClientVideoDisplay->RotationL(*iWindow) != videoRotation)

   378         {

   379         ERR_PRINTF1(_L("iMediaClientVideoDisplay->RotationL() returns an unexpected value.  Test aborted."));

   380 

   381 		iTestStepResult = EInconclusive;

   382 		CActiveScheduler::Stop();

   383         }

   384 	else

   385 		{

   386 		INFO_PRINTF1(_L("iMediaClientVideoDisplay->RotationL()"));	

   387 		}

   388     

   389     iMediaClientVideoDisplay->SetScaleFactorL(*iWindow, widthPercentage, heightPercentage, cropRegion);

   390     iMediaClientVideoDisplay->SetScaleFactorL(widthPercentage, heightPercentage, cropRegion);

   391     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetScaleFactorL()"));

   392     

   393     iMediaClientVideoDisplay->SetRotationL(EVideoRotationClockwise90, cropRegion);

   394     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetRotationL()"));

   395     

   396     iMediaClientVideoDisplay->GetScaleFactorL(*iWindow, widthP, heightP);

   397     INFO_PRINTF3(_L("iMediaClientVideoDisplay->GetScaleFactorL() %df %df"), &widthP, &heightP);

   398 

   399     iMediaClientVideoDisplay->SetVideoExtentL(*iWindow, videoExtent, cropRegion);

   400     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetVideoExtentL()"));

   401     

   402     iMediaClientVideoDisplay->SetWindowClipRectL(*iWindow, clipRect, cropRegion);

   403     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetWindowClipRectL()"));

   404 

   405 	// Check for invalid autoScaleType when setting autoScaleType for window

   406 	INFO_PRINTF1(_L("Testing invalid autoScaleType for SetAutoScaleL"));

   407 	autoScaleType = static_cast<TAutoScaleType>(-1);

   408 	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(*iWindow, autoScaleType, horizPos, vertPos, cropRegion));

   409 	if (err != KErrArgument)

   410 		{

   411 		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL(window) did not leave with KErrArgument for negative value"));

   412     	iTestStepResult = EFail;

   413     	CActiveScheduler::Stop();

   414     	return;

   415 		}

   416 

   417 	autoScaleType = static_cast<TAutoScaleType>(4);

   418 	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(*iWindow, autoScaleType, horizPos, vertPos, cropRegion));

   419 	if (err != KErrArgument)

   420 		{

   421 		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL(window) did not leave with KErrArgument for out of range value"));

   422     	iTestStepResult = EFail;

   423     	CActiveScheduler::Stop();

   424     	return;

   425 		}

   426 

   427 	// Check for invalid autoScaleType when setting autoScaleType for all windows

   428 	autoScaleType = static_cast<TAutoScaleType>(-1);

   429 	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(autoScaleType, horizPos, vertPos, cropRegion));

   430 	if (err != KErrArgument)

   431 		{

   432 		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL() did not leave with KErrArgument for negative value"));

   433     	iTestStepResult = EFail;

   434     	CActiveScheduler::Stop();

   435     	return;

   436 		}

   437 

   438 	autoScaleType = static_cast<TAutoScaleType>(4);

   439 	TRAP(err, iMediaClientVideoDisplay->SetAutoScaleL(autoScaleType, horizPos, vertPos, cropRegion));

   440 	if (err != KErrArgument)

   441 		{

   442 		ERR_PRINTF1(_L("iVideoPlayer2->SetAutoScaleL() did not leave with KErrArgument for out of range value"));

   443     	iTestStepResult = EFail;

   444     	CActiveScheduler::Stop();

   445     	return;

   446 		}

   447     

   448     iMediaClientVideoDisplay->SetAutoScaleL(EAutoScaleBestFit, horizPos, vertPos, cropRegion);

   449     INFO_PRINTF1(_L("iMediaClientVideoDisplay->SetAutoScaleL()"));

   450     

   451     iMediaClientVideoDisplay->RedrawWindows(cropRegion);

   452     INFO_PRINTF1(_L("iMediaClientVideoDisplay->RedrawWindows()"));   

   453     

   454 	iMediaClientVideoDisplay->SurfaceParametersChanged(surfaceId, cropRect, par);

   455 	INFO_PRINTF1(_L("iMediaClientVideoDisplay->SurfaceParametersChanged()"));

   456 	

   457 	iMediaClientVideoDisplay->RemoveSurface();

   458     INFO_PRINTF1(_L("iMediaClientVideoDisplay->ReplaceSurface()"));

   459     

   460     iMediaClientVideoDisplay->RemoveDisplayWindow(*iWindow);

   461     INFO_PRINTF1(_L("iMediaClientVideoDisplay->RemoveDisplayWindow()"));

   462     

   463     surfaceManager.CloseSurface(surfaceId);

   464 	surfaceId = TSurfaceId::CreateNullId();

   465 	surfaceManager.Close();

   466     

   467     delete iMediaClientVideoDisplay;  

   468     iMediaClientVideoDisplay = NULL;              

   469    	}

   470 

   471 void RTestMediaClientVideoDisplay::HandlePlayCompleteL()

   472 	{

   473 	iTestStepResult = EPass;

   474 	CActiveScheduler::Stop();

   475 	}

   476 

   477 void RTestMediaClientVideoDisplay::StartPlayback()

   478 	{

   479     iError = KErrTimedOut;

   480     INFO_PRINTF1(_L("iVideoPlayer2->Play()"));

   481     PrepareState(EVPPlayComplete, KErrNone);

   482     iVideoPlayer2->Play();

   483 	}

   484 	

   485 #endif

   486 

   487 //

   488 // RTestVclnt2PerformActionDuringVideoPlayback

   489 //

   490 

   491 /**

   492  * RTestVclnt2PerformActionDuringVideoPlayback::Constructor

   493  */

   494 RTestVclnt2PerformActionDuringVideoPlayback::RTestVclnt2PerformActionDuringVideoPlayback(

   495     const TDesC& aTestName, 

   496     const TDesC& aSectName, 

   497     const TDesC& aKeyName, 

   498     TInt aExpectedError)

   499     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

   500     {

   501     }

   502 

   503 /**

   504  * RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL

   505  */

   506 void RTestVclnt2PerformActionDuringVideoPlayback::HandlePlayCompleteL()

   507     {

   508     if (iActionError != KErrNone)

   509         {

   510         ERR_PRINTF2(_L("Playback event left with error %d."), iActionError);

   511         iTestStepResult = EFail;

   512         }

   513     else 

   514         {

   515         iTestStepResult = EPass;

   516         }

   517 

   518 	CActiveScheduler::Stop();        

   519     }

   520 

   521 /**

   522  * RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback

   523  */     

   524 void RTestVclnt2PerformActionDuringVideoPlayback::StartPlayback()

   525 	{

   526 	RTestVclnt2PlayFile::StartPlayback();

   527 	

   528 	iActionError = KErrNone;

   529     TRAP(iActionError, DoThisActionDuringPlaybackL(*iVideoPlayer2));

   530 	}

   531 

   532 

   533 //

   534 // RTestVclnt2AddWin

   535 //

   536 /**

   537  * RTestVclnt2AddWin::Constructor

   538  */

   539 RTestVclnt2AddWin::RTestVclnt2AddWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   540     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

   541     {

   542     }

   543 

   544 /**

   545  * RTestVclnt2AddWin::NewL

   546  */

   547 RTestVclnt2AddWin* RTestVclnt2AddWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   548     {

   549     RTestVclnt2AddWin* self = new (ELeave) RTestVclnt2AddWin(aTestName, aSectName, aKeyName, aExpectedError);

   550     return self;

   551     }

   552    

   553 /**

   554  * RTestVclnt2AddWin::HandlePrepareCompleteL

   555  */

   556 void RTestVclnt2AddWin::HandlePrepareCompleteL()

   557     {

   558     // retrieve video size

   559     TSize videoSize;

   560     iVideoPlayer2->VideoFrameSizeL(videoSize);                

   561 

   562     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0)

   563         {

   564         // create a clipping rect partially out of screen

   565         TRect windowRect(iWindow->Size());

   566         windowRect.SetWidth(windowRect.Width() * 2);

   567         

   568         // Add the display window with a partially out of screen clipping rect

   569         TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, 

   570                                                     *iScreen, 

   571                                                     *iWindow, 

   572                                                     TRect(iWindow->Size()), 

   573                                                     windowRect));

   574         if (err != iTestExpectedError)

   575             {

   576             ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error.  Test failed."));

   577 

   578     		iTestStepResult = EFail;

   579     		CActiveScheduler::Stop();

   580 

   581     		return;

   582             }

   583 

   584         // create a clipping rect completely out of screen

   585         windowRect.SetRect(TPoint(0, 0), iWindow->Size());

   586         windowRect.Move(windowRect.Width() + 10, 0);

   587         

   588         // Add the display window with a completely out of screen clipping rect

   589         TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs, 

   590                                                    *iScreen, 

   591                                                    *iWindow, 

   592                                                    TRect(iWindow->Size()), 

   593                                                    windowRect));

   594         if (err != iTestExpectedError)

   595             {

   596             ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error.  Test failed."));

   597             

   598     		iTestStepResult = EFail;

   599     		CActiveScheduler::Stop();

   600 

   601     		return;

   602             }

   603         else 

   604             {

   605             // Reset the expected error to KErrNone as all expected failure tests have been completed.  

   606             // Any error that appears after this should fail the test

   607             iTestExpectedError = KErrNone;

   608             }

   609 

   610         // after failing to add window display with a partially & a completely out of screen

   611         // clipping rect, proceed to add a valid clipping rect below            

   612         }    

   613     

   614     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0401")) == 0 ||

   615         iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0505")) == 0) 

   616         {

   617         // shrink both the video & window size by half

   618         TRect videoRect(videoSize);     

   619         videoRect.SetHeight(videoSize.iHeight / 2);

   620         videoRect.SetWidth(videoSize.iWidth / 2); 

   621         

   622         TRect windowRect(iWindow->Size());

   623         windowRect.SetHeight(iWindow->Size().iHeight / 2);

   624         windowRect.SetWidth(iWindow->Size().iWidth / 2); 

   625 

   626         // ensure the rect is within the boundary of the window        

   627         TRect finalRect(windowRect);

   628         finalRect.Intersection(videoRect);

   629 

   630         // add display window using this valid clipping rect 

   631         iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect);

   632         }

   633     else

   634         {

   635         // Invalid test case

   636         User::Panic(_L("RTestVclnt2AddWin"), KErrArgument);        

   637         }

   638 

   639     // Start video playback

   640     StartPlayback();

   641     }

   642 

   643 

   644 //

   645 // RTestVclnt2RemoveWin

   646 //

   647 

   648 /**

   649  * RTestVclnt2RemoveWin::Constructor

   650  */ 

   651 RTestVclnt2RemoveWin::RTestVclnt2RemoveWin(const TDesC& aTestName, 

   652                                            const TDesC& aSectName,

   653                                            const TDesC& aKeyName, 

   654                                            TInt aExpectedError,

   655                                            TBool aAddBack)

   656     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError),

   657       iAddBack(aAddBack)

   658     {

   659     }

   660 

   661 /**

   662  * RTestVclnt2RemoveWin::NewL

   663  */

   664 RTestVclnt2RemoveWin* RTestVclnt2RemoveWin::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TBool aAddBack)

   665     {

   666     RTestVclnt2RemoveWin* self = new (ELeave) RTestVclnt2RemoveWin(aTestName, aSectName, aKeyName, aExpectedError, aAddBack);

   667     return self;

   668     }

   669 

   670 /**

   671  * RTestVclnt2RemoveWin::HandlePrepareCompleteL

   672  */

   673 void RTestVclnt2RemoveWin::HandlePrepareCompleteL()

   674     {

   675     // retrieve video size

   676     TSize videoSize;

   677     iVideoPlayer2->VideoFrameSizeL(videoSize);

   678 

   679     // shrink both the video & window size by half

   680     TRect videoRect(videoSize);     

   681     videoRect.SetHeight(videoSize.iHeight / 2);

   682     videoRect.SetWidth(videoSize.iWidth / 2); 

   683 

   684     TRect windowRect(iWindow->Size());

   685     windowRect.SetHeight(iWindow->Size().iHeight / 2);

   686     windowRect.SetWidth(iWindow->Size().iWidth / 2); 

   687 

   688     // ensure the rect is within the boundary of the window        

   689     TRect finalRect(windowRect);

   690     finalRect.Intersection(videoRect);

   691 

   692     // add display window using this valid clipping rect 

   693     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, finalRect, finalRect);

   694 

   695     // trigger the video to start playing

   696     StartPlayback();    

   697     }

   698 

   699 /**

   700  * RTestVclnt2RemoveWin::DoThisActionDuringPlaybackL

   701  */ 

   702 void RTestVclnt2RemoveWin::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

   703     {

   704     // Play the video clip using a specific display window & video clipping setting 

   705     // first

   706     TTimeIntervalMicroSeconds duration = aPlayer.DurationL();        

   707 

   708     // After a quarter of the clip's duration

   709     User::After(duration.Int64() / 4);

   710 

   711     // remove the original display        

   712     aPlayer.RemoveDisplayWindow(*iWindow);

   713 

   714 

   715     if (iAddBack)

   716     	{

   717 	    // Add the window using default values to continues

   718 	    aPlayer.AddDisplayWindowL(iWs, *iScreen, *iWindow);

   719     	}

   720     }

   721 

   722 

   723 //

   724 // RTestVclnt2WinPos

   725 //

   726 

   727 /**

   728  * RTestVclnt2WinPos::Constructor

   729  */

   730 RTestVclnt2WinPos::RTestVclnt2WinPos(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   731     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

   732     {

   733     }

   734 

   735 /**

   736  * RTestVclnt2WinPos::NewL

   737  */

   738 RTestVclnt2WinPos* RTestVclnt2WinPos::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   739     {

   740     RTestVclnt2WinPos* self = new (ELeave) RTestVclnt2WinPos(aTestName, aSectName, aKeyName, aExpectedError);

   741     return self;

   742     }

   743 

   744 /**

   745  * RTestVclnt2WinPos::DoThisActionDuringPlaybackL

   746  */

   747 void RTestVclnt2WinPos::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

   748     {

   749     TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);

   750             

   751     // shrink the window clipping rect by half the height & width            

   752     aPlayer.SetWindowClipRectL(*iWindow, TRect(windowSize));    

   753     }

   754 

   755 

   756 //

   757 // RTestVclnt2VideoExt

   758 //

   759 

   760 /**

   761  * RTestVclnt2VideoExt::Constructor

   762  */

   763 RTestVclnt2VideoExt::RTestVclnt2VideoExt(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   764     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

   765     {

   766     }

   767 

   768 /**

   769  * RTestVclnt2VideoExt::NewL

   770  */

   771 RTestVclnt2VideoExt* RTestVclnt2VideoExt::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   772     {

   773     RTestVclnt2VideoExt* self = new (ELeave) RTestVclnt2VideoExt(aTestName, aSectName, aKeyName, aExpectedError);

   774     return self;

   775     }

   776 

   777 /**

   778  * RTestVclnt2VideoExt::DoThisActionDuringPlaybackL

   779  */

   780 void RTestVclnt2VideoExt::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

   781     {

   782     TSize windowSize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);

   783             

   784     // shrink the video extent by half the height & width            

   785     aPlayer.SetVideoExtentL(*iWindow, TRect(windowSize));

   786     }

   787 

   788 

   789 //

   790 // RTestVclnt2ClipRect

   791 //

   792 

   793 /**

   794  * RTestVclnt2ClipRect::Constructor

   795  */

   796 RTestVclnt2ClipRect::RTestVclnt2ClipRect(const TDesC& aTestName, 

   797                                          const TDesC& aSectName,

   798                                          const TDesC& aKeyName, 

   799                                          TInt aExpectedError)

   800     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

   801     {

   802     }

   803 

   804 /**

   805  * RTestVclnt2ClipRect::NewL

   806  */

   807 RTestVclnt2ClipRect* RTestVclnt2ClipRect::NewL(const TDesC& aTestName, 

   808                                                const TDesC& aSectName,

   809                                                const TDesC& aKeyName, 

   810                                                TInt aExpectedError)

   811     {

   812     RTestVclnt2ClipRect* self 

   813         = new (ELeave) RTestVclnt2ClipRect(aTestName, aSectName, aKeyName, aExpectedError);

   814     return self;

   815     }

   816 

   817 /**

   818  * RTestVclnt2ClipRect::DoThisActionDuringPlaybackL

   819  */

   820 void RTestVclnt2ClipRect::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

   821     {

   822     TRect clipRect;    

   823     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0405")) == 0)

   824         {

   825         // shrink the current window clipping rect by half the height & width 

   826         clipRect.Resize(iWindow->Size().iWidth / 2, iWindow->Size().iHeight / 2);            

   827         }

   828     else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0503")) == 0)

   829         {

   830         // grow the current window clipping rect by double the width         

   831         clipRect.Resize(iWindow->Size().iWidth * 2, iWindow->Size().iHeight);

   832         }

   833     else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0504")) == 0)

   834         {

   835         // move the current window clipping rect to be out of the window

   836         clipRect.SetSize(iWindow->Size());

   837         clipRect.Move(TPoint(iWindow->Size().iWidth + 1, 0));

   838         }

   839     else

   840         {

   841         User::Panic(_L("RTestVclnt2ClipRect"), KErrArgument);

   842         }

   843     

   844     // change the window clipping of the display window

   845     TRAPD(err, aPlayer.SetWindowClipRectL(*iWindow, clipRect));

   846     if (err != iTestExpectedError)

   847         {

   848         if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0503")) == 0 || 

   849             iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0504")) == 0)

   850             {

   851             // for negative tests, stop the test if the failure is not expected

   852             ERR_PRINTF1(_L("iVideoPlayer2->SetWindowClipRectL() did not failed as expected.  Test failed."));

   853 

   854     		iTestStepResult = EInconclusive;

   855     		CActiveScheduler::Stop();

   856 

   857     		return;

   858             }

   859         else

   860             {

   861             // fail only if error is returned for positive tests

   862             User::LeaveIfError(err);

   863             }

   864         }

   865     else

   866         {        

   867         // Reset the expected error to KErrNone as all expected failure tests have been completed.  

   868         // Any error that appears after this should fail the test

   869         iTestExpectedError = KErrNone;

   870         }

   871     }

   872 

   873 //

   874 // RTestVclnt2Scale

   875 //

   876 

   877 /**

   878  * RTestVclnt2Scale::Constructor

   879  */

   880 RTestVclnt2Scale::RTestVclnt2Scale(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   881     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

   882     {

   883     }

   884 

   885 /**

   886  * RTestVclnt2Scale::NewL

   887  */

   888 RTestVclnt2Scale* RTestVclnt2Scale::NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

   889     {

   890     RTestVclnt2Scale* self = new (ELeave) RTestVclnt2Scale(aTestName, aSectName, aKeyName, aExpectedError);

   891     return self;

   892     }

   893 

   894 /**

   895  * RTestVclnt2Scale::DoThisActionDuringPlaybackL

   896  */

   897 void RTestVclnt2Scale::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

   898     {

   899     // Change the scale factor during playback

   900     aPlayer.SetScaleFactorL(*iWindow, 150, 150);

   901     }

   902 

   903 /**

   904  * RTestVclnt2Scale::HandlePrepareCompleteL

   905  */ 

   906 void RTestVclnt2Scale::HandlePrepareCompleteL()

   907     {

   908     // Continue to setup the video utility and then trigger playback

   909     RTestVclnt2PerformActionDuringVideoPlayback::HandlePrepareCompleteL();

   910     

   911     TReal32 scaleFactor = 50.0;

   912      

   913     // set scale factor to less than 100%

   914     iVideoPlayer2->SetScaleFactorL(*iWindow, scaleFactor, scaleFactor);

   915 

   916     // get scale factor 

   917     TReal32 widthScale;

   918     TReal32 heightScale;

   919     iVideoPlayer2->GetScaleFactorL(*iWindow, widthScale, heightScale);

   920 

   921     if (widthScale != scaleFactor || heightScale != scaleFactor)

   922         {

   923         ERR_PRINTF1(_L("iVideoPlayer2->GetScaleFactorL() returns unexpected values.  Test aborted."));

   924         

   925 		iTestStepResult = EInconclusive;

   926 		CActiveScheduler::Stop();

   927 		

   928 		return;

   929         }    

   930     }

   931 

   932 

   933 //

   934 // RTestVclnt2Viewport

   935 //

   936 

   937 /**

   938  * RTestVclnt2Viewport::Constructor

   939  */

   940 RTestVclnt2Viewport::RTestVclnt2Viewport(const TDesC& aTestName,

   941                                          const TDesC& aSectName,

   942                                          const TDesC& aKeyName, 

   943                                          const TSize& aViewportSize,

   944                                          TInt aExpectedError)

   945     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError),

   946       iViewportSize(aViewportSize)

   947     {

   948     }

   949 

   950 /**

   951  * RTestVclnt2Viewport::NewL

   952  */

   953 RTestVclnt2Viewport* RTestVclnt2Viewport::NewL(const TDesC& aTestName, 

   954                                                const TDesC& aSectName,

   955                                                const TDesC& aKeyName, 

   956                                                const TSize& aViewportSize,

   957                                                TInt aExpectedError)

   958     {

   959     RTestVclnt2Viewport* self = new (ELeave) RTestVclnt2Viewport(aTestName, 

   960                                                                  aSectName, 

   961                                                                  aKeyName, 

   962                                                                  aViewportSize,

   963                                                                  aExpectedError); 

   964     return self;

   965     }

   966 

   967 void RTestVclnt2Viewport::HandlePrepareCompleteL()

   968 	{

   969 	// retrive original video size

   970     TSize videoSize;

   971     iVideoPlayer2->VideoFrameSizeL(videoSize);

   972         

   973     // crop the top left quarter of the video

   974     TRect cropRegion;

   975     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0)

   976         {

   977         // Crop the right half of the video

   978         cropRegion.SetHeight(videoSize.iHeight);        

   979         cropRegion.SetWidth(videoSize.iWidth / 2);

   980         cropRegion.Move(cropRegion.Width(), 0);

   981         }

   982     else

   983         {

   984         cropRegion.SetWidth(iViewportSize.iWidth == -1 ? videoSize.iWidth : iViewportSize.iWidth);

   985         cropRegion.SetHeight(iViewportSize.iHeight == -1 ? videoSize.iHeight : iViewportSize.iHeight);

   986         }

   987     

   988     TRect videoExtentRect;

   989     TRect clipRegion;

   990     

   991     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0)

   992         {

   993         videoExtentRect.SetRect(TPoint(0, 0), videoSize);

   994         clipRegion.SetRect(TPoint(0, 0), videoSize); 

   995         clipRegion.SetWidth(clipRegion.Width() / 2);

   996         clipRegion.Move(clipRegion.Width(), 0);

   997         }

   998     else 

   999         {

  1000         // Calculate the video extent to be exactly the same size as the cropped video picture, 

  1001         // placed at the center of the window

  1002         TInt offsetX = (iWindow->Size().iWidth - cropRegion.Width()) / 2;

  1003         TInt offsetY = (iWindow->Size().iHeight - cropRegion.Height()) / 2;

  1004         videoExtentRect.SetRect(TPoint(offsetX, offsetY), cropRegion.Size());                    

  1005 

  1006         // Set the window clipping region to the top vertical half of the cropped image, originating

  1007         // from the top left corner of the window                    

  1008         clipRegion = videoExtentRect;                    

  1009         clipRegion.SetHeight(videoExtentRect.Height() / 2);

  1010         }

  1011     

  1012     HandlePrepareCompleteL(cropRegion, videoExtentRect, clipRegion);

  1013     

  1014     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0508")) == 0)

  1015     	{

  1016     	// Align the image to the left of the window

  1017         iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, 0);

  1018     	}

  1019     // trigger the video to start playing                

  1020     StartPlayback();

  1021 	}

  1022 

  1023 void RTestVclnt2Viewport::HandlePrepareCompleteL(const TRect& aCropRegion, 

  1024                                                  const TRect& aVideoExtent, 

  1025                                                  const TRect& aClipRect)

  1026     {

  1027     iVideoPlayer2->SetCropRegionL(aCropRegion);

  1028     

  1029     // get the video crop region to ensure the crop region is set

  1030     TRect currentCropRegion;

  1031     iVideoPlayer2->GetCropRegionL(currentCropRegion);

  1032     

  1033     if (currentCropRegion != aCropRegion)

  1034         {

  1035         ERR_PRINTF1(_L("iVideoPlayer2->GetCropRegionL() returns an unexpected value.  Test aborted."));

  1036         

  1037 		iTestStepResult = EInconclusive;

  1038 		CActiveScheduler::Stop();

  1039         }

  1040         

  1041     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, aVideoExtent, aClipRect);                    

  1042     }

  1043 

  1044 //

  1045 // RTestVclnt2InvalidViewport

  1046 //

  1047 

  1048 /**

  1049  * RTestVclnt2InvalidViewport::Constructor

  1050  */

  1051 RTestVclnt2InvalidViewport::RTestVclnt2InvalidViewport(const TDesC& aTestName,

  1052                                                        const TDesC& aSectName,

  1053                                                        const TDesC& aKeyName, 

  1054                                                        TInt aExpectedError)

  1055     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1056     {

  1057     }

  1058 

  1059 /**

  1060  * RTestVclnt2InvalidViewport::NewL

  1061  */

  1062 RTestVclnt2InvalidViewport* RTestVclnt2InvalidViewport::NewL(const TDesC& aTestName, 

  1063                                                              const TDesC& aSectName,

  1064                                                              const TDesC& aKeyName, 

  1065                                                              TInt aExpectedError)

  1066     {

  1067     RTestVclnt2InvalidViewport* self = new (ELeave) RTestVclnt2InvalidViewport(aTestName, 

  1068                                                                                aSectName, 

  1069                                                                                aKeyName, 

  1070                                                                                aExpectedError); 

  1071     return self;

  1072     }

  1073 

  1074 /**

  1075  * RTestVclnt2InvalidViewport::HandlePrepareCompleteL

  1076  */

  1077 void RTestVclnt2InvalidViewport::HandlePrepareCompleteL()

  1078     {

  1079 	// retrive original video size

  1080     TSize videoSize;

  1081     iVideoPlayer2->VideoFrameSizeL(videoSize);

  1082 

  1083     // set the crop region to be completely out of the video image bound 

  1084     TRect cropRegion;

  1085     cropRegion.SetRect(TPoint(videoSize.iWidth, videoSize.iHeight), TSize(100, 100));

  1086 

  1087     // continue playback even if this fails

  1088     TRAPD(err, iVideoPlayer2->SetCropRegionL(cropRegion));

  1089     if (err == iTestExpectedError)

  1090         {

  1091         // the invalid crop area is not supposed to be set 

  1092         INFO_PRINTF1(_L("iVideoPlayer2->SetCropRegionL() returned expected.  Test continues."));

  1093 

  1094         // reset the expected error.  Any error that appears after this should fail the test

  1095         iTestExpectedError = KErrNone;

  1096         }

  1097     else 

  1098         {

  1099         // the invalid crop area is not supposed to be set 

  1100         ERR_PRINTF1(_L("iVideoPlayer2->SetCropRegionL() didn't leave with expected error.  Test cannot be continued."));

  1101 

  1102 		iTestStepResult = EInconclusive;

  1103 		CActiveScheduler::Stop();

  1104 		return;

  1105         }

  1106 

  1107     // get the video crop region to ensure the crop region is set

  1108     TRect currentCropRegion;

  1109     iVideoPlayer2->GetCropRegionL(currentCropRegion);

  1110 

  1111     if (currentCropRegion != cropRegion)

  1112         {

  1113         // the invalid crop area is not supposed to be set 

  1114         ERR_PRINTF1(_L("iVideoPlayer2->GetCropRegionL() returns an unexpected value.  Test cannot be continued."));

  1115         

  1116 		iTestStepResult = EInconclusive;

  1117 		CActiveScheduler::Stop();

  1118 		return;

  1119         }

  1120 

  1121     // setup the display then trigger the video to start playing

  1122     RTestVclnt2PlayFile::HandlePrepareCompleteL();

  1123     }

  1124 

  1125 

  1126 //

  1127 // RTestVclnt2Rotation

  1128 //

  1129 /**

  1130  * RTestVclnt2Rotation::Constructor

  1131  */

  1132 RTestVclnt2Rotation::RTestVclnt2Rotation(const TDesC& aTestName,

  1133                                          const TDesC& aSectName,

  1134                                          const TDesC& aKeyName, 

  1135                                          TInt aExpectedError)

  1136     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1137     {

  1138     }

  1139 

  1140 /**

  1141  * RTestVclnt2Rotation::NewL

  1142  */

  1143 RTestVclnt2Rotation* RTestVclnt2Rotation::NewL(const TDesC& aTestName, 

  1144                                                const TDesC& aSectName,

  1145                                                const TDesC& aKeyName, 

  1146                                                TInt aExpectedError)

  1147     {

  1148     RTestVclnt2Rotation* self = new (ELeave) RTestVclnt2Rotation(aTestName, 

  1149                                                                  aSectName, 

  1150                                                                  aKeyName, 

  1151                                                                  aExpectedError);

  1152     return self;

  1153     }

  1154 

  1155 /**

  1156  * RTestVclnt2Rotation::HandlePrepareCompleteL

  1157  */

  1158 void RTestVclnt2Rotation::HandlePrepareCompleteL()

  1159     {

  1160     // call parent's HandlePrepareCompleteL to finish off all preparation

  1161     RTestVclnt2PlayFile::HandlePrepareCompleteL();

  1162     

  1163     // set the video to be displayed upside-down

  1164     TVideoRotation videoRotation(EVideoRotationClockwise180);

  1165     iVideoPlayer2->SetRotationL(*iWindow, videoRotation);

  1166 

  1167     // retrieve the rotation setting, and check if it's been properly updated

  1168     if (iVideoPlayer2->RotationL(*iWindow) != videoRotation)

  1169         {

  1170         ERR_PRINTF1(_L("iVideoPlayer2->RotationL() returns an unexpected value.  Test aborted."));

  1171 

  1172 		iTestStepResult = EInconclusive;

  1173 		CActiveScheduler::Stop();

  1174 

  1175 		return;

  1176         }

  1177     }

  1178 

  1179 //

  1180 // RTestVclnt2Settings

  1181 //

  1182 /**

  1183  * RTestVclnt2Settings::Constructor

  1184  */

  1185 RTestVclnt2Settings::RTestVclnt2Settings(const TDesC& aTestName,

  1186                                          const TDesC& aSectName,

  1187                                          const TDesC& aKeyName, 

  1188                                          TInt aExpectedError)

  1189     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1190     {

  1191     }

  1192 

  1193 /**

  1194  * RTestVclnt2Settings::NewL

  1195  */

  1196 RTestVclnt2Settings* RTestVclnt2Settings::NewL(const TDesC& aTestName, 

  1197                                                const TDesC& aSectName,

  1198                                                const TDesC& aKeyName, 

  1199                                                TInt aExpectedError)

  1200     {

  1201     RTestVclnt2Settings* self = new (ELeave) RTestVclnt2Settings(aTestName, aSectName, aKeyName, aExpectedError);

  1202     return self;

  1203     }

  1204    

  1205 /**

  1206  * RTestVclnt2Settings::HandlePrepareCompleteL

  1207  */

  1208 void RTestVclnt2Settings::HandlePrepareCompleteL()

  1209     {

  1210     // retrieve the current frame size

  1211     TSize frameSize;

  1212     iVideoPlayer2->VideoFrameSizeL(frameSize);    

  1213     

  1214     TRect cropRegion(frameSize);

  1215     // shrink the crop region to half its original height

  1216     cropRegion.SetHeight(cropRegion.Height() / 2);

  1217     iVideoPlayer2->SetCropRegionL(cropRegion);

  1218     

  1219     TRect videoExtentRect;

  1220     videoExtentRect.SetWidth(cropRegion.Width());

  1221     videoExtentRect.SetHeight(cropRegion.Height());

  1222     

  1223     videoExtentRect.Move((iWindow->Size().iWidth - videoExtentRect.Width()) / 2,

  1224                          (iWindow->Size().iHeight - videoExtentRect.Height()) / 2); 

  1225     

  1226     TRect clippingRect(videoExtentRect);

  1227     clippingRect.SetWidth(clippingRect.Height() / 2);

  1228 

  1229     // add display window using this valid clipping rect 

  1230     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtentRect, clippingRect);

  1231 

  1232  	// Scale the movie with best fit scaling, and vertically center the picture

  1233     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleBestFit);

  1234     

  1235     // Start video playback

  1236     StartPlayback();

  1237     }

  1238 

  1239 

  1240 

  1241 //

  1242 // RTestVclnt2SettingsAndAlignments

  1243 //

  1244 /**

  1245  * RTestVclnt2SettingsAndAlignments::Constructor

  1246  */

  1247 RTestVclnt2SettingsAndAlignments::RTestVclnt2SettingsAndAlignments(const TDesC& aTestName,

  1248                                                                    const TDesC& aSectName,

  1249                                                                    const TDesC& aKeyName, 

  1250                                                                    TInt aExpectedError)

  1251     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1252     {

  1253     }

  1254 

  1255 /**

  1256  * RTestVclnt2SettingsAndAlignments::NewL

  1257  */

  1258 RTestVclnt2SettingsAndAlignments* RTestVclnt2SettingsAndAlignments::NewL(const TDesC& aTestName, 

  1259                                                                          const TDesC& aSectName,

  1260                                                                          const TDesC& aKeyName, 

  1261                                                                          TInt aExpectedError)

  1262     {

  1263     RTestVclnt2SettingsAndAlignments* self = new (ELeave) RTestVclnt2SettingsAndAlignments(aTestName, aSectName, aKeyName, aExpectedError);

  1264     return self;

  1265     }

  1266 

  1267 TVerdict RTestVclnt2SettingsAndAlignments::DoTestStepPreambleL()

  1268 	{

  1269 	iCount = 0;

  1270 	return RTestVclnt2PlayFile::DoTestStepPreambleL();

  1271 	}

  1272 

  1273 /**

  1274  * RTestVclnt2SettingsAndAlignments::HandlePrepareCompleteL

  1275  */

  1276 void RTestVclnt2SettingsAndAlignments::HandlePrepareCompleteL()

  1277     {    

  1278     TRect cropRegion;

  1279     SetCropRegionL(cropRegion);

  1280 

  1281 	AddDisplayWindowL(cropRegion);

  1282     

  1283     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0418")) == 0)

  1284         {            

  1285         SetContentOffsetL();

  1286         }

  1287     else if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0419")) == 0)        

  1288         {

  1289         SetContentAlignmentL();            

  1290         }        

  1291 

  1292     SetScaleFactorL();

  1293        

  1294     // Start video playback

  1295     StartPlayback();

  1296     }

  1297 

  1298 /**

  1299  * RTestVclnt2SettingsAndAlignments::HandlePlayCompleteL

  1300  */

  1301 void RTestVclnt2SettingsAndAlignments::HandlePlayCompleteL()

  1302     {    

  1303     iCount++;

  1304     

  1305     if (iCount == KSettingsAndAlignmentTest)

  1306         {

  1307     	iTestStepResult = EPass;

  1308     	CActiveScheduler::Stop();

  1309         }

  1310     else

  1311         {

  1312         HandlePrepareCompleteL();                                

  1313         }

  1314     }

  1315 

  1316 /**

  1317  * RTestVclnt2SettingsAndAlignments::SetCropRegionL

  1318  */

  1319 void RTestVclnt2SettingsAndAlignments::SetCropRegionL(TRect& aCropRegion)

  1320     {

  1321     // retrieve the current frame size

  1322     TSize frameSize;

  1323     iVideoPlayer2->VideoFrameSizeL(frameSize);    

  1324     

  1325     // Framesize is used in this case as crop region is not returning default values

  1326     aCropRegion.SetRect(TPoint(0, 0), frameSize);

  1327     

  1328     // set the crop region 

  1329     switch (iCount % KSettingsAndAlignmentTest)

  1330         {

  1331         case 0:                

  1332             // set the crop region to the top half of the image

  1333             aCropRegion.SetHeight(aCropRegion.Height() / 2);

  1334             iVideoPlayer2->SetCropRegionL(aCropRegion);

  1335             break;

  1336 

  1337         case 1:

  1338             // set the crop region to the left half of the image

  1339             aCropRegion.SetWidth(aCropRegion.Width() / 2);

  1340             iVideoPlayer2->SetCropRegionL(aCropRegion);

  1341             break;

  1342 

  1343         default:

  1344             // set the crop region to the bottom, right quarter of the image

  1345             aCropRegion.SetHeight(aCropRegion.Height() / 2);

  1346             aCropRegion.SetWidth(aCropRegion.Width() / 2);

  1347             aCropRegion.Move(aCropRegion.Width(), aCropRegion.Height());                        

  1348             iVideoPlayer2->SetCropRegionL(aCropRegion);

  1349             break;

  1350         }

  1351     }

  1352 

  1353 /**

  1354  * RTestVclnt2SettingsAndAlignments::SetContentOffsetL

  1355  */

  1356 void RTestVclnt2SettingsAndAlignments::SetContentOffsetL()

  1357     {

  1358     switch (iCount % KSettingsAndAlignmentTest)

  1359         {

  1360         case 0:

  1361             iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 0, 100);

  1362             break;

  1363         

  1364         case 1:

  1365             iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 0);

  1366             break;

  1367         

  1368         default:

  1369             iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 100);

  1370             break;

  1371         }    

  1372     }

  1373 

  1374 /**

  1375  * RTestVclnt2SettingsAndAlignments::SetContentAlignmentL

  1376  */

  1377 void RTestVclnt2SettingsAndAlignments::SetContentAlignmentL()

  1378     {

  1379     switch (iCount % KSettingsAndAlignmentTest)

  1380         {

  1381         case 0:

  1382             iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 0, EVerticalAlignCenter);

  1383             break;

  1384         

  1385         case 1:

  1386             iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, 0);

  1387             break;

  1388         

  1389         default:

  1390             iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignCenter);

  1391             break;

  1392         }    

  1393     }

  1394     

  1395 /**

  1396  * RTestVclnt2SettingsAndAlignments::SetScaleFactorL

  1397  */

  1398 void RTestVclnt2SettingsAndAlignments::SetScaleFactorL()

  1399     {

  1400     switch (iCount % KSettingsAndAlignmentTest)

  1401         {

  1402         case 0:

  1403             iVideoPlayer2->SetScaleFactorL(*iWindow, 1, 200);

  1404             break;

  1405         

  1406         case 1:

  1407             iVideoPlayer2->SetScaleFactorL(*iWindow, 200, 1);

  1408             break;

  1409         

  1410         default:

  1411             iVideoPlayer2->SetScaleFactorL(*iWindow, 200, 200);

  1412             break;

  1413         }    

  1414     }    

  1415 

  1416 /**

  1417  * RTestVclnt2SettingsAndAlignments::AddDisplayWindowL

  1418  */

  1419 void RTestVclnt2SettingsAndAlignments::AddDisplayWindowL(const TRect& aCropRegion)

  1420     {

  1421     TRect videoExtentRect(iWindow->Size());

  1422     TRect clippingRect(iWindow->Size());

  1423     

  1424     switch (iCount % KSettingsAndAlignmentTest)

  1425         {

  1426         case 0:

  1427             videoExtentRect.SetWidth(aCropRegion.Width());

  1428             if (iWindow->Size().iWidth > videoExtentRect.Width())

  1429                 {                    

  1430                 videoExtentRect.Move((iWindow->Size().iWidth - videoExtentRect.Width()) / 2, 0);

  1431                 }

  1432             clippingRect = videoExtentRect;

  1433             break;

  1434             

  1435         case 1:

  1436             videoExtentRect.SetHeight(aCropRegion.Height());

  1437             if (iWindow->Size().iHeight > videoExtentRect.Height())

  1438                 {                    

  1439                 videoExtentRect.Move(0, (iWindow->Size().iHeight - videoExtentRect.Height()) / 2);

  1440                 }

  1441             clippingRect = videoExtentRect;

  1442             break;

  1443             

  1444         default:

  1445             clippingRect.SetHeight(clippingRect.Height() / 2);

  1446             clippingRect.SetWidth(clippingRect.Width() / 2);            

  1447             clippingRect.Move(clippingRect.Width(), clippingRect.Height());            

  1448             break;                        

  1449         }

  1450     

  1451     iVideoPlayer2->RemoveDisplayWindow(*iWindow);    

  1452     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtentRect, clippingRect);    

  1453     }

  1454        

  1455     

  1456 //

  1457 // RTestVclnt2SecDisplay

  1458 //

  1459 /**

  1460  * RTestVclnt2SecDisplay::Constructor

  1461  */

  1462 RTestVclnt2SecDisplay::RTestVclnt2SecDisplay(const TDesC& aTestName,

  1463                                              const TDesC& aSectName,

  1464                                              const TDesC& aKeyName, 

  1465                                              TInt aExpectedError)

  1466     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1467     {

  1468     }

  1469 

  1470 /**

  1471  * RTestVclnt2SecDisplay::NewL

  1472  */

  1473 RTestVclnt2SecDisplay* RTestVclnt2SecDisplay::NewL(const TDesC& aTestName, 

  1474                                                    const TDesC& aSectName,

  1475                                                    const TDesC& aKeyName, 

  1476                                                    TInt aExpectedError)

  1477     {

  1478     RTestVclnt2SecDisplay* self = new (ELeave) RTestVclnt2SecDisplay(aTestName, aSectName, aKeyName, aExpectedError);

  1479     return self;

  1480     }

  1481    

  1482 /**

  1483  * RTestVclnt2SecDisplay::DoTestStepPreambleL

  1484  */

  1485 TVerdict RTestVclnt2SecDisplay::DoTestStepPreambleL()

  1486     {

  1487     TVerdict verdict = RTestVclnt2PlayFile::DoTestStepPreambleL();    

  1488     if (verdict == EPass)

  1489         {

  1490         // make a 2nd device for this session

  1491         iSecondScreen = new (ELeave) CWsScreenDevice(iWs); 

  1492         User::LeaveIfError(iSecondScreen->Construct()); 

  1493         }

  1494     

  1495     return verdict;

  1496     }

  1497 

  1498 /**

  1499  * RTestVclnt2SecDisplay::DoTestStepPostambleL

  1500  */

  1501 TVerdict RTestVclnt2SecDisplay::DoTestStepPostambleL()

  1502     {

  1503     delete iSecondScreen;

  1504     

  1505     return EPass;

  1506     }

  1507 

  1508 /**

  1509  * RTestVclnt2SecDisplay::HandlePrepareCompleteL

  1510  */

  1511 void RTestVclnt2SecDisplay::HandlePrepareCompleteL()

  1512 	{

  1513 	// Add display window using default values - ie. video extent & window clipping 

  1514 	// defaulted to whole window

  1515 	INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));

  1516 	iVideoPlayer2->AddDisplayWindowL(iWs, *iSecondScreen, *iWindow);

  1517 

  1518     // trigger the video to start playing                

  1519     StartPlayback();

  1520 	}

  1521 

  1522 

  1523 //

  1524 // RTestVclnt2CropRectPause

  1525 //

  1526 /**

  1527  * RTestVclnt2CropRectPause::Constructor

  1528  */

  1529 RTestVclnt2CropRectPause::RTestVclnt2CropRectPause(const TDesC& aTestName, 

  1530                                                    const TDesC& aSectName, 

  1531                                                    const TDesC& aKeyName, 

  1532                                                    TInt aExpectedError)

  1533     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

  1534     {

  1535     }

  1536 

  1537 /**

  1538  * RTestVclnt2CropRectPause::NewL

  1539  */

  1540 RTestVclnt2CropRectPause* RTestVclnt2CropRectPause::NewL(const TDesC& aTestName, 

  1541                                                          const TDesC& aSectName,

  1542                                                          const TDesC& aKeyName, 

  1543                                                          TInt aExpectedError)

  1544     {

  1545     RTestVclnt2CropRectPause* self 

  1546         = new (ELeave) RTestVclnt2CropRectPause(aTestName, aSectName, aKeyName, aExpectedError);

  1547     return self;

  1548     }

  1549 	

  1550 /**

  1551  * RTestVclnt2CropRectPause::DoThisActionDuringPlaybackL

  1552  */

  1553 void RTestVclnt2CropRectPause::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

  1554     {    

  1555     TRect cropRegion;

  1556 	aPlayer.GetCropRegionL(cropRegion);

  1557 	

  1558 	// change the crop region and continue to play the clip

  1559 	cropRegion.SetHeight(cropRegion.Height() / 2);

  1560     aPlayer.SetCropRegionL(cropRegion);    

  1561     }

  1562     

  1563     

  1564     

  1565 //

  1566 // RTestVclnt2Overlay

  1567 //

  1568 /**

  1569  * RTestVclnt2Overlay::Constructor

  1570  */

  1571 RTestVclnt2Overlay::RTestVclnt2Overlay(const TDesC& aTestName,

  1572                                        const TDesC& aSectName,

  1573                                        const TDesC& aKeyName, 

  1574                                        TInt aExpectedError)

  1575     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1576     {

  1577     }

  1578 

  1579 /**

  1580  * RTestVclnt2Overlay::NewL

  1581  */

  1582 RTestVclnt2Overlay* RTestVclnt2Overlay::NewL(const TDesC& aTestName, 

  1583                                              const TDesC& aSectName,

  1584                                              const TDesC& aKeyName, 

  1585                                              TInt aExpectedError)

  1586     {

  1587     RTestVclnt2Overlay* self = new (ELeave) RTestVclnt2Overlay(aTestName, 

  1588                                                                aSectName, 

  1589                                                                aKeyName, 

  1590                                                                aExpectedError);

  1591     return self;

  1592     }

  1593 

  1594 /**

  1595  * RTestVclnt2Overlay::DoTestStepPreambleL

  1596  */

  1597 TVerdict RTestVclnt2Overlay::DoTestStepPreambleL()

  1598     {

  1599     TVerdict verdict = RTestVclnt2PlayFile::DoTestStepPreambleL();    

  1600     if (verdict == EPass)

  1601         {

  1602         TFontSpec fontSpec; // use default fonts

  1603         fontSpec.iHeight = 20;

  1604 

  1605         // Get a font to draw overlay text

  1606         if (iScreen->GetNearestFontToDesignHeightInPixels(iFont, fontSpec) != KErrNone)

  1607             {

  1608             // if no font can be retrieved, abort the test

  1609             ERR_PRINTF1(_L("Cannot retrieve font to perform test.  Test aborted."));

  1610             

  1611     		return EInconclusive;

  1612             }

  1613 

  1614         iGc->Activate(*iWindow);

  1615         iGc->UseFont(iFont);

  1616         }

  1617     

  1618     return verdict;

  1619     }

  1620 

  1621 /**

  1622  * RTestVclnt2Overlay::DoTestStepPostambleL

  1623  */

  1624 TVerdict RTestVclnt2Overlay::DoTestStepPostambleL()

  1625     {

  1626     iGc->DiscardFont();    

  1627     iGc->Deactivate();                    

  1628                

  1629     return RTestVclnt2PlayFile::DoTestStepPostambleL();        

  1630     }

  1631 

  1632 /**

  1633  * RTestVclnt2Overlay::HandlePrepareCompleteL

  1634  */

  1635 void RTestVclnt2Overlay::HandlePrepareCompleteL()

  1636 	{

  1637     TRect rect(iWindow->Size());

  1638     TInt baseline = (rect.Height() + iFont->AscentInPixels()) >> 1;

  1639     

  1640     // Draw the overlay text if needed

  1641     iGc->SetBrushStyle(CGraphicsContext::ENullBrush);

  1642     iGc->SetBrushColor(KRgbRed);

  1643          

  1644     iGc->SetPenStyle(CGraphicsContext::ESolidPen);

  1645     iGc->SetPenColor(KRgbBlue);

  1646     

  1647     iGc->DrawText(_L("Overlay Testing"), rect, baseline, CGraphicsContext::ELeft);

  1648 

  1649     // setup the display window and trigger the video to start playing

  1650     RTestVclnt2PlayFile::HandlePrepareCompleteL();

  1651 	}

  1652 	

  1653 

  1654 //

  1655 // RTestVclnt2AddWin2

  1656 //

  1657 

  1658 /**

  1659  * RTestVclnt2AddWin2::Constructor

  1660  */

  1661 RTestVclnt2AddWin2::RTestVclnt2AddWin2(const TDesC& aTestName,

  1662                                        const TDesC& aSectName,

  1663                                        const TDesC& aKeyName, 

  1664                                        TInt aExpectedError)

  1665     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1666     {

  1667     }

  1668 

  1669 /**

  1670  * RTestVclnt2AddWin2::NewL

  1671  */

  1672 RTestVclnt2AddWin2* RTestVclnt2AddWin2::NewL(const TDesC& aTestName, 

  1673                                              const TDesC& aSectName,

  1674                                              const TDesC& aKeyName, 

  1675                                              TInt aExpectedError)

  1676     {

  1677     RTestVclnt2AddWin2* self = new (ELeave) RTestVclnt2AddWin2(aTestName, 

  1678                                                                aSectName, 

  1679                                                                aKeyName, 

  1680                                                                aExpectedError);

  1681     return self;

  1682     }

  1683 

  1684 /**

  1685  * RTestVclnt2AddWin2::HandlePrepareCompleteL

  1686  */

  1687 void RTestVclnt2AddWin2::HandlePrepareCompleteL()

  1688 	{

  1689     // add the display window for the player to use for displaying the video

  1690     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);

  1691     

  1692     // Add the same display window again

  1693     TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));

  1694     if (err != iTestExpectedError)

  1695         {

  1696         ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error.  Test failed."));

  1697 

  1698 		iTestStepResult = EFail;

  1699 		CActiveScheduler::Stop();

  1700 

  1701 		return;

  1702         }

  1703     else

  1704         {

  1705         INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an expected error.  Test continues."));

  1706 

  1707         // reset the expected error.  Any error that appears after this should fail the test

  1708         iTestExpectedError = KErrNone;        

  1709         }

  1710 

  1711     // trigger the video to start playing

  1712     StartPlayback();

  1713 	}

  1714 

  1715 //

  1716 // RTestVclnt2AddWin2WithSettings

  1717 //

  1718 

  1719 /**

  1720  * RTestVclnt2AddWin2WithSettings::Constructor

  1721  */

  1722 RTestVclnt2AddWin2WithSettings::RTestVclnt2AddWin2WithSettings(const TDesC& aTestName,

  1723                                                                const TDesC& aSectName,

  1724                                                                const TDesC& aKeyName, 

  1725                                                                TInt aExpectedError)

  1726     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1727     {

  1728     }

  1729 

  1730 /**

  1731  * RTestVclnt2AddWin2WithSettings::NewL

  1732  */

  1733 RTestVclnt2AddWin2WithSettings* RTestVclnt2AddWin2WithSettings::NewL(const TDesC& aTestName, 

  1734                                                                      const TDesC& aSectName,

  1735                                                                      const TDesC& aKeyName,     

  1736                                                                      TInt aExpectedError)

  1737     {

  1738     RTestVclnt2AddWin2WithSettings* self = new (ELeave) RTestVclnt2AddWin2WithSettings(aTestName, 

  1739                                                                                        aSectName, 

  1740                                                                                        aKeyName, 

  1741                                                                                        aExpectedError);

  1742     return self;

  1743     }

  1744 

  1745 /**

  1746  * RTestVclnt2AddWin2WithSettings::HandlePrepareCompleteL

  1747  */

  1748 void RTestVclnt2AddWin2WithSettings::HandlePrepareCompleteL()

  1749 	{

  1750 	TRect windowRect(iWindow->Size());

  1751 	windowRect.SetHeight(windowRect.Height() / 2);

  1752 

  1753 	iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, windowRect, windowRect);

  1754 

  1755 	// Add the same display window again with default values

  1756 	TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));

  1757 	if (err != iTestExpectedError)

  1758 	    {

  1759 	    ERR_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an unexpected error.  Test failed."));

  1760 

  1761 		iTestStepResult = EFail;

  1762 		CActiveScheduler::Stop();

  1763 

  1764 		return;

  1765 	    }

  1766     else

  1767         {

  1768         INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL() leaves with an expected error.  Test continues."));

  1769 

  1770         // reset the expected error.  Any error that appears after this should fail the test

  1771         iTestExpectedError = KErrNone;

  1772 	    }

  1773 

  1774 	// trigger the video to start playing

  1775     StartPlayback();

  1776 	}

  1777 

  1778 //

  1779 // RTestVclnt2ContOffset

  1780 //

  1781 

  1782 /**

  1783  * RTestVclnt2ContOffset::Constructor

  1784  */

  1785 RTestVclnt2ContOffset::RTestVclnt2ContOffset(const TDesC& aTestName, 

  1786                                              const TDesC& aSectName, 

  1787                                              const TDesC& aKeyName, 

  1788                                              TInt aExpectedError)

  1789     : RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  1790     {

  1791     iHeapSize = 2000000; //~2MB

  1792     }

  1793 

  1794 /**

  1795  * RTestVclnt2ContOffset::NewL

  1796  */

  1797 RTestVclnt2ContOffset* RTestVclnt2ContOffset::NewL(const TDesC& aTestName, 

  1798                                                    const TDesC& aSectName,

  1799                                                    const TDesC& aKeyName, 

  1800                                                    TInt aExpectedError)

  1801     {

  1802     RTestVclnt2ContOffset* self = new (ELeave) RTestVclnt2ContOffset(aTestName, 

  1803                                                                      aSectName, 

  1804                                                                      aKeyName, 

  1805                                                                      aExpectedError);

  1806     return self;

  1807     }

  1808 

  1809 /**

  1810  * RTestVclnt2ContOffset::HandlePrepareCompleteL

  1811  */

  1812 void RTestVclnt2ContOffset::HandlePrepareCompleteL()

  1813 	{

  1814     // call parent's HandlePrepareCompleteL to finish off all preparation    

  1815 	RTestVclnt2PlayFile::HandlePrepareCompleteL();

  1816     // Set the content offset before starting to play the video.

  1817     INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));

  1818     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 100, 100);

  1819     

  1820     if (iTestStepName.CompareF(_L("MM-MMF-VCLNTAVI-I-0409")) == 0)

  1821         {

  1822         // Set the content alignment after setting the content offset

  1823         iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignTop);

  1824         }

  1825 	}

  1826 

  1827 //

  1828 // RTestVclnt2ContOffsetAtPlay

  1829 //

  1830 /**

  1831  * RTestVclnt2ContOffsetAtPlay::Constructor

  1832  */

  1833 RTestVclnt2ContOffsetAtPlay::RTestVclnt2ContOffsetAtPlay(const TDesC& aTestName, 

  1834                                                          const TDesC& aSectName, 

  1835                                                          const TDesC& aKeyName, 

  1836                                                          TInt aExpectedError)

  1837     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

  1838     {

  1839     iHeapSize = 2000000; //~2MB

  1840     }

  1841 

  1842 /**

  1843  * RTestVclnt2ContOffsetAtPlay::NewL

  1844  */

  1845 RTestVclnt2ContOffsetAtPlay* RTestVclnt2ContOffsetAtPlay::NewL(const TDesC& aTestName, 

  1846                                                                const TDesC& aSectName,

  1847                                                                const TDesC& aKeyName, 

  1848                                                                TInt aExpectedError)

  1849     {

  1850     RTestVclnt2ContOffsetAtPlay* self = new (ELeave) RTestVclnt2ContOffsetAtPlay(aTestName, 

  1851                                                                                  aSectName, 

  1852                                                                                  aKeyName, 

  1853                                                                                  aExpectedError);

  1854     return self;

  1855     }

  1856         

  1857 /**

  1858  * RTestVclnt2ContOffsetAtPlay::DoThisActionDuringPlaybackL

  1859  */

  1860 void RTestVclnt2ContOffsetAtPlay::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& /* aPlayer */)

  1861     {

  1862     // Change the scale factor during playback

  1863 	INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));

  1864 	iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, 10, 10);    

  1865     }

  1866 

  1867 

  1868 //

  1869 // RTestVclnt2Align

  1870 //

  1871 /**

  1872  * RTestVclnt2Align::Constructor

  1873  */

  1874 RTestVclnt2Align::RTestVclnt2Align(const TDesC& aTestName, 

  1875                                    const TDesC& aSectName, 

  1876                                    const TDesC& aKeyName, 

  1877                                    TInt aExpectedError)

  1878     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

  1879     {

  1880     iHeapSize = 2000000; //~2MB

  1881     }

  1882 

  1883 /**

  1884  * RTestVclnt2Align::NewL

  1885  */

  1886 RTestVclnt2Align* RTestVclnt2Align::NewL(const TDesC& aTestName, 

  1887                                          const TDesC& aSectName,

  1888                                          const TDesC& aKeyName, 

  1889                                          TInt aExpectedError)

  1890     {

  1891     RTestVclnt2Align* self = new (ELeave) RTestVclnt2Align(aTestName, aSectName, aKeyName, aExpectedError);

  1892     return self;

  1893     }

  1894 

  1895 /**

  1896  * RTestVclnt2Align::HandlePrepareCompleteL

  1897  */ 

  1898 void RTestVclnt2Align::HandlePrepareCompleteL()

  1899     {

  1900     // Continue to setup the video utility and then trigger playback

  1901     RTestVclnt2PlayFile::HandlePrepareCompleteL();

  1902 	// Set the content offset before starting to play the video.

  1903     INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));

  1904     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignCenter);

  1905     }

  1906     

  1907 /**

  1908  * RTestVclnt2Align::DoThisActionDuringPlaybackL

  1909  */

  1910 void RTestVclnt2Align::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& /* aPlayer */)

  1911     {    

  1912     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignCenter);    

  1913     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1914     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(10, 10, 100, 100), TRect(0, 3, 4, 220));        

  1915     

  1916     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignCenter);    

  1917     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1918     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);        

  1919         

  1920     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignTop);    

  1921     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1922     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(10, 10, 100, 100), TRect(0, 5, 5, 200));        

  1923     

  1924     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignTop);

  1925     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1926     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);        

  1927     

  1928     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignTop);

  1929     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1930     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(0, 0, 100, 100), TRect(0, 5, 5, 200));        

  1931         

  1932     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignCenter, EVerticalAlignBottom);

  1933     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1934     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);        

  1935     

  1936     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignLeft, EVerticalAlignBottom);

  1937     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1938     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, TRect(0, 0, 100, 100), TRect(0, 5, 300, 230));        

  1939     

  1940     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleNone, EHorizontalAlignRight, EVerticalAlignBottom);

  1941     iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  1942     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);        

  1943     }

  1944 

  1945 

  1946 //

  1947 // RTestVclnt2AutoScale

  1948 //

  1949 /**

  1950  * RTestVclnt2AutoScale::Constructor

  1951  */

  1952 RTestVclnt2AutoScale::RTestVclnt2AutoScale(const TDesC& aTestName, 

  1953                                            const TDesC& aSectName, 

  1954                                            const TDesC& aKeyName, 

  1955                                            TInt aExpectedError)

  1956     : RTestVclnt2PerformActionDuringVideoPlayback(aTestName, aSectName, aKeyName, aExpectedError)

  1957     {

  1958     iHeapSize = 2000000; //~2MB

  1959     }

  1960 

  1961 /**

  1962  * RTestVclnt2AutoScale::NewL

  1963  */

  1964 RTestVclnt2AutoScale* RTestVclnt2AutoScale::NewL(const TDesC& aTestName, 

  1965                                                  const TDesC& aSectName,

  1966                                                  const TDesC& aKeyName, 

  1967                                                  TInt aExpectedError)

  1968     {

  1969     RTestVclnt2AutoScale* self = new (ELeave) RTestVclnt2AutoScale(aTestName, aSectName, aKeyName, aExpectedError);

  1970     return self;

  1971     }

  1972 

  1973 /**

  1974  * RTestVclnt2AutoScale::HandlePrepareCompleteL

  1975  */ 

  1976 void RTestVclnt2AutoScale::HandlePrepareCompleteL()

  1977     {

  1978     iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);

  1979 	// Set the content offset before starting to play the video.

  1980     INFO_PRINTF1(_L("iVideoPlayer2->SetAutoScale()"));

  1981     iVideoPlayer2->SetAutoScaleL(*iWindow, EAutoScaleClip);

  1982     

  1983     // trigger the video to start playing                

  1984     StartPlayback();

  1985     }

  1986 	

  1987 /**

  1988  * RTestVclnt2AutoScale::DoThisActionDuringPlaybackL

  1989  */

  1990 void RTestVclnt2AutoScale::DoThisActionDuringPlaybackL(CVideoPlayerUtility2& aPlayer)

  1991     {    

  1992 	aPlayer.SetAutoScaleL(*iWindow, EAutoScaleBestFit);

  1993 	aPlayer.SetAutoScaleL(*iWindow, EAutoScaleNone);

  1994 	aPlayer.SetAutoScaleL(*iWindow, EAutoScaleStretch);

  1995     }

  1996 

  1997 //

  1998 // RTestVclnt2OldController

  1999 //

  2000 

  2001 RTestVclnt2OldController::RTestVclnt2OldController(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2002 	: RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  2003 	{

  2004 	}

  2005 

  2006 /**

  2007  * RTestVclnt2OldController::NewL

  2008  */

  2009 RTestVclnt2OldController* RTestVclnt2OldController::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2010     {

  2011     RTestVclnt2OldController* self = new (ELeave) RTestVclnt2OldController(aTestName, aSectName, aKeyName, aExpectedError);

  2012     return self;

  2013     }

  2014 

  2015 void RTestVclnt2OldController::HandleIdleL()

  2016 	{

  2017 	// Open iVideoPlayer using a controller that does not support surfaces. 

  2018     INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

  2019     iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviNonGcePlayControllerUid);

  2020     PrepareState(EVPOpenComplete, KErrNone);

  2021 	}

  2022 

  2023 void RTestVclnt2OldController::HandlePrepareCompleteL()

  2024 	{

  2025 	TRAPD(err, RTestVclnt2PlayFile::HandlePrepareCompleteL());

  2026 	

  2027 	if (err != KErrNotSupported)

  2028 		{

  2029 		ERR_PRINTF1(_L("AddDisplay did not leave with KErrNotSupported."));

  2030 		iTestStepResult = EFail;

  2031 		}

  2032 	else

  2033 		{

  2034 		iTestStepResult = EPass;

  2035 		}

  2036 	

  2037 	// Stop the test.

  2038 	CActiveScheduler::Stop();

  2039 	}

  2040 //

  2041 // RTestVclnt2NoFile

  2042 //

  2043 

  2044 RTestVclnt2NoFile::RTestVclnt2NoFile(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2045 	: RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  2046 	{

  2047 	}

  2048 

  2049 /**

  2050  * RTestVclnt2NoFile::NewL

  2051  */

  2052 RTestVclnt2NoFile* RTestVclnt2NoFile::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2053     {

  2054     RTestVclnt2NoFile* self = new (ELeave) RTestVclnt2NoFile(aTestName, aSectName, aKeyName, aExpectedError);

  2055     return self;

  2056     }

  2057 

  2058 void RTestVclnt2NoFile::HandleIdleL()

  2059 	{

  2060 	iTestStepResult = EFail;

  2061 	TRAPD(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow));

  2062 	

  2063 	if (err != iTestExpectedError)

  2064 		{

  2065 		ERR_PRINTF1(_L("AddDisplayWindowL did not leave with KErrNotReady."));

  2066 		User::Leave(KErrGeneral);

  2067 		}

  2068 	

  2069 	TSize windowSize = iWindow->Size();

  2070 	TRect videoExtent(-5, -5, windowSize.iWidth + 5, windowSize.iHeight + 5);

  2071 	TRect windowClipRect(5, 5, windowSize.iWidth - 5, windowSize.iHeight - 5);

  2072 	TRAP(err, iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtent, windowClipRect));

  2073 	

  2074 	if (err != iTestExpectedError)

  2075 		{

  2076 		ERR_PRINTF1(_L("AddDisplayWindowL did not leave with KErrNotReady."));

  2077 		User::Leave(KErrGeneral);

  2078 		}

  2079 	

  2080 	TRAP(err, iVideoPlayer2->SetWindowClipRectL(*iWindow, windowClipRect));

  2081 	

  2082 	if (err != iTestExpectedError)

  2083 		{

  2084 		ERR_PRINTF1(_L("SetWindowClipRectL did not leave with KErrNotReady."));

  2085 		User::Leave(KErrGeneral);

  2086 		}

  2087 	

  2088 	TRAP(err, iVideoPlayer2->SetVideoExtentL(*iWindow, videoExtent));

  2089 	

  2090 	if (err != iTestExpectedError)

  2091 		{

  2092 		ERR_PRINTF1(_L("SetVideoExtentL did not leave with KErrNotReady."));

  2093 		User::Leave(KErrGeneral);

  2094 		}

  2095 	

  2096 	// reset the expected error to KErrNone as any error happens after this is unexpected

  2097     iTestExpectedError = KErrNone;	

  2098 	

  2099 	// The video should still play when we try to play the video.  Perform 

  2100 	// the basic play test now.

  2101 	RTestVclnt2PlayFile::HandleIdleL();

  2102 	}

  2103 

  2104 //

  2105 // RTestVclnt2PlayAfterRemoveWin

  2106 //

  2107 

  2108 RTestVclnt2PlayAfterRemoveWin::RTestVclnt2PlayAfterRemoveWin(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2109 	: RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  2110 	{

  2111 	}

  2112 

  2113 /**

  2114  * RTestVclnt2PlayAfterRemoveWin::NewL

  2115  */

  2116 RTestVclnt2PlayAfterRemoveWin* RTestVclnt2PlayAfterRemoveWin::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2117     {

  2118     RTestVclnt2PlayAfterRemoveWin* self = new (ELeave) RTestVclnt2PlayAfterRemoveWin(aTestName, aSectName, aKeyName, aExpectedError);

  2119     return self;

  2120     }

  2121 

  2122 void RTestVclnt2PlayAfterRemoveWin::HandlePrepareCompleteL()

  2123 	{

  2124 	// Don't add a window. Just play the video.

  2125 	StartPlayback();

  2126 	}

  2127 

  2128 void RTestVclnt2PlayAfterRemoveWin::HandlePlayCompleteL()

  2129 	{

  2130 	switch(iPlayAttempt)

  2131 		{

  2132 	case 0:

  2133 		{

  2134 		TSize windowSize = iWindow->Size();

  2135 		TRect videoExtent(-5, -5, windowSize.iWidth + 5, windowSize.iHeight + 5);

  2136 		TRect windowClipRect(5, 5, windowSize.iWidth - 5, windowSize.iHeight - 5);

  2137 		iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow, videoExtent, windowClipRect);

  2138 		iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  2139 		iVideoPlayer2->Play();

  2140 		PrepareState(EVPPlayComplete, KErrNone);

  2141 		break;

  2142 		}

  2143 	case 1:

  2144 		// Removing the window again should have no effect.

  2145 		iVideoPlayer2->RemoveDisplayWindow(*iWindow);

  2146 		iVideoPlayer2->Play();

  2147 		PrepareState(EVPPlayComplete, KErrNone);

  2148 		break;

  2149 	case 2:

  2150 		// The previous play commands should have no effect when we try to add a 

  2151 		// display window and render to surfaces. Use the base class to do this.

  2152 		RTestVclnt2PlayFile::HandlePrepareCompleteL();

  2153 		break;

  2154 	default:

  2155 		// Use the parent handler after we have tried the above play commands.

  2156 		RTestVclnt2PlayFile::HandlePlayCompleteL();

  2157 		break;

  2158 		}

  2159 	

  2160 	iPlayAttempt++;

  2161 	}

  2162 

  2163 //

  2164 // RTestVclnt2NoGce

  2165 //

  2166 

  2167 RTestVclnt2NoGce::RTestVclnt2NoGce(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2168 	: RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  2169 	{

  2170 	}

  2171 

  2172 /**

  2173  * RTestVclnt2NoGce::NewL

  2174  */

  2175 RTestVclnt2NoGce* RTestVclnt2NoGce::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2176     {

  2177     RTestVclnt2NoGce* self = new (ELeave) RTestVclnt2NoGce(aTestName, aSectName, aKeyName, aExpectedError);

  2178     return self;

  2179     }

  2180 

  2181 void RTestVclnt2NoGce::HandleIdleL()

  2182 	{

  2183 	// Open iVideoPlayer

  2184     INFO_PRINTF2(_L("iVideoPlayer2->OpenFileL() %S"), &iFilename);

  2185     iVideoPlayer2->OpenFileL(iFilename, KMmfTestAviPlayControllerUid);

  2186     PrepareState(EVPOpenComplete, KErrNotSupported);

  2187 	}

  2188 

  2189 void RTestVclnt2NoGce::HandleOpenCompleteL()

  2190 	{

  2191 	iTestStepResult = EPass;

  2192 	CActiveScheduler::Stop();

  2193 	}

  2194 	

  2195 //

  2196 // RTestVclnt2Alloc

  2197 //

  2198 

  2199 RTestVclnt2Alloc::RTestVclnt2Alloc(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2200 	: RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  2201 	{

  2202 	}

  2203 

  2204 /**

  2205  * RTestVclnt2Alloc::NewL

  2206  */

  2207 RTestVclnt2Alloc* RTestVclnt2Alloc::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2208     {

  2209     RTestVclnt2Alloc* self = new (ELeave) RTestVclnt2Alloc(aTestName, aSectName, aKeyName, aExpectedError);

  2210     return self;

  2211     }

  2212 

  2213 TVerdict RTestVclnt2Alloc::DoTestStepPreambleL()

  2214 	{

  2215     INFO_PRINTF1(_L("RTestVclnt2Alloc::DoTestStepPreambleL()"));

  2216         

  2217     // Call RTestMmfVclntAviStep::DoTestStepPreambleL instead of the immediate parent's 

  2218     // DoTestStepPreambleL as there is no need for CVideoPlayerUtility setup.

  2219     // Similarly, there is no need to initialize CVideoPlayerUtility2, as it will be

  2220     // created in each alloc iteration.

  2221     return RTestMmfVclntAviStep::DoTestStepPreambleL();

  2222 	}

  2223 

  2224 TVerdict RTestVclnt2Alloc::PerformTestL()

  2225 	{

  2226 	iVideoPlayer2 = CVideoPlayerUtility2::NewL(*this, EMdaPriorityNormal, EMdaPriorityPreferenceTimeAndQuality);

  2227 	ResetState();

  2228 	iError = KErrNone;

  2229 	TVerdict result = RTestVclnt2AviPlayerStep::DoTestStepL();

  2230 	delete iVideoPlayer2;

  2231 	iVideoPlayer2 = NULL;

  2232 	return result;

  2233 	}

  2234 

  2235 /**

  2236  * RTestVclnt2Alloc::DoTestStepL()

  2237  */

  2238 TVerdict RTestVclnt2Alloc::DoTestStepL()

  2239     {

  2240     TVerdict allocTestStepResult = EPass;

  2241     TInt err = KErrNone;

  2242     TBool result = EFalse;

  2243     

  2244     //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<

  2245     if (PerformTestL() != EPass)

  2246         {

  2247         err = iError;

  2248         }

  2249 

  2250     if (err != KErrNone)

  2251         {

  2252         INFO_PRINTF2(_L("Test error, returned error code =  %d"), err);

  2253         User::Leave(err);

  2254         }

  2255     else

  2256         {

  2257         //Check the iAllocTestStepResult

  2258         if (allocTestStepResult != EPass)

  2259             {

  2260             result = ETrue;

  2261             }

  2262         }    

  2263     

  2264     TInt failCount = 1;

  2265     TBool completed = EFalse;

  2266     allocTestStepResult = EPass;

  2267     TBool reachedEnd = EFalse;

  2268     for(;;)    

  2269         {

  2270         __UHEAP_SETFAIL(RHeap::EFailNext, failCount);

  2271         __MM_HEAP_MARK;

  2272 

  2273         //>>>>>>>>>>>>>>>>>>>>>>>>Test Method Call<<<<<<<<<<<<<<<<<<<<<<<<<<

  2274         TVerdict verdict = EFail;

  2275         TRAP(err, verdict = PerformTestL());

  2276         if (err == KErrNone && verdict != EPass)

  2277             {

  2278             err = iError;

  2279             }

  2280 

  2281         completed = EFalse;

  2282         if (err == KErrNone)

  2283             {

  2284             TAny* testAlloc = User::Alloc(1); // when this fails, we passed through all allocs within test

  2285             if (testAlloc == NULL)

  2286                 {

  2287                 reachedEnd = ETrue;

  2288                 failCount -= 1;

  2289                 }

  2290             else

  2291                 {

  2292                 User::Free(testAlloc);    

  2293                 }            

  2294             

  2295             //Check the iAllocTestStepResult

  2296             if (allocTestStepResult != EPass)

  2297                 {

  2298                 result = ETrue;

  2299                 }

  2300             

  2301             completed = reachedEnd || result;

  2302             }

  2303         else if (err != KErrNoMemory) // bad error code

  2304             {

  2305             completed = ETrue;

  2306             result = EFail;

  2307             }            

  2308 

  2309         __MM_HEAP_MARKEND;

  2310         __UHEAP_SETFAIL(RHeap::ENone, 0);

  2311 

  2312         if (completed)

  2313             {

  2314             break; // exit loop

  2315             }

  2316 

  2317         failCount++;

  2318         }

  2319 

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

  2321 

  2322     if (err != KErrNone || result)

  2323         {

  2324         allocTestStepResult = EFail;

  2325         TBuf<80> format;

  2326         if (result)

  2327             {

  2328             format.Format(_L("  Bad result with %d memory allocations tested\n"), failCount);

  2329             }

  2330         else

  2331             {

  2332             format.Format(_L("  Error(%d) with %d memory allocations tested\n"), err, failCount);

  2333             }

  2334         Log(format);

  2335         }

  2336     else 

  2337         {

  2338         TBuf<80> format;

  2339         format.Format(_L("  Completed OK with %d memory allocations tested\n"), failCount);

  2340         Log(format);

  2341         }

  2342 

  2343     return allocTestStepResult;

  2344     }

  2345 

  2346 //

  2347 // RTestVclnt2InvalidScaleFactor

  2348 //

  2349 RTestVclnt2InvalidScaleFactor::RTestVclnt2InvalidScaleFactor(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2350 	: RTestVclnt2PlayFile(aTestName, aSectName, aKeyName, aExpectedError)

  2351 	{

  2352 	}

  2353 

  2354 /**

  2355  * RTestVclnt2InvalidScaleFactor::NewL

  2356  */

  2357 RTestVclnt2InvalidScaleFactor* RTestVclnt2InvalidScaleFactor::NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError)

  2358     {

  2359     RTestVclnt2InvalidScaleFactor* self = new (ELeave) RTestVclnt2InvalidScaleFactor(aTestName, aSectName, aKeyName, aExpectedError);

  2360     return self;

  2361     }

  2362 

  2363 void RTestVclnt2InvalidScaleFactor::HandlePrepareCompleteL()

  2364 	{

  2365 	INFO_PRINTF1(_L("iVideoPlayer2->AddDisplayWindowL()"));

  2366 	iVideoPlayer2->AddDisplayWindowL(iWs, *iScreen, *iWindow);

  2367 

  2368 	// Try to scale the video to an invalid values

  2369 	TRAPD(err, iVideoPlayer2->SetScaleFactorL(*iWindow, 0, 100));

  2370 	if (err != KErrArgument)

  2371 		{

  2372 		User::Leave(err == KErrNone ? KErrGeneral : err); 

  2373 		}

  2374 	

  2375 	TRAP(err, iVideoPlayer2->SetScaleFactorL(*iWindow, 100, -100));

  2376 	if (err != KErrArgument)

  2377 		{

  2378 		User::Leave(err == KErrNone ? KErrGeneral : err); 

  2379 		}

  2380 	

  2381 	// trigger the video to start playing                

  2382     StartPlayback();

  2383 	}
Symaptic