MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/ciu/testdevvideociuplay.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-2009 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 #ifdef SYMBIAN_BUILD_GCE

    17 #include <mmf/common/mmfvideosurfacecustomcommands.h>

    18 #include <mmf/devvideo/devvideoclientbuffersupport.h>

    19 #include "videoframebuffer.h"

    20 #endif // SYMBIAN_BUILD_GCE

    21 

    22 #include "testdevvideociuplay.h"

    23 #include "testdevvideociuplugins/ciudecoder.h"

    24 #include "testdevvideociuplugins/ciupostproc.h"

    25 #include "testdevvideociuplugins/ciudevvideotestinterface.h"

    26 

    27 // DevVideoCiu base class

    28 

    29 CTestDevVideoCiuPlayStep::CTestDevVideoCiuPlayStep(const TDesC& aTestName)

    30 	{

    31 	// store the name of this test case

    32 	// this is the name that is used by the script file

    33 	// Each test step initialises it's own name

    34 	iTestStepName = aTestName;

    35 	}

    36 	

    37 CTestDevVideoCiuPlayStep::~CTestDevVideoCiuPlayStep() 

    38 	{

    39 	}

    40 

    41 TVerdict CTestDevVideoCiuPlayStep::DoTestStepPreambleL()

    42 	{

    43 	TVerdict ret = CTestDevVideoCiuStep::DoTestStepPreambleL();

    44 

    45 	__UHEAP_MARK;

    46 	TRAPD(err, iDevVideoPlay = CMMFDevVideoPlay::NewL( *this ));

    47 	if (err != KErrNone)

    48 		{

    49 		ERR_PRINTF1(_L("Could not create a CMMFDevVideoPlay!"));

    50 		ret = EInconclusive;

    51 		}

    52 	return ret;

    53 	}

    54 

    55 TVerdict CTestDevVideoCiuPlayStep::DoTestStepPostambleL()

    56 	{

    57 	delete iDevVideoPlay;	

    58 	__MM_HEAP_MARKEND;

    59 	

    60 	return EPass;

    61 	}

    62 

    63 TVerdict CTestDevVideoCiuPlayStep::DoTestStepL()

    64 	{

    65 	TVerdict ret = EFail;

    66 

    67 	iDevVideoPlay->Initialize();

    68 

    69 	if (iError == KErrNone)

    70 		{

    71 		INFO_PRINTF1(_L("DevVideo Play initialisation was successful."));

    72 		

    73 		// call the test step

    74 		ret = DoTestL();

    75 		}

    76 	else

    77 		{

    78 		ret = EInconclusive;

    79 		ERR_PRINTF1(_L("Failed to initialise the DevVideo Play"));

    80 		}

    81 		

    82 	return ret;

    83 	}

    84 

    85 // MMMFDevVideoCiuObserver

    86 void CTestDevVideoCiuPlayStep::MdvpoNewBuffers()

    87 	{

    88 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoNewBuffers()"));

    89 	}

    90 

    91 void CTestDevVideoCiuPlayStep::MdvpoReturnPicture(TVideoPicture* /*aPicture*/)

    92 	{

    93 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoReturnPicture()"));

    94 	}

    95 

    96 void CTestDevVideoCiuPlayStep::MdvpoSupplementalInformation(const TDesC8& /*aData*/, 

    97 								  const TTimeIntervalMicroSeconds& /*aTimestamp*/, 

    98 								  const TPictureId& /*aPictureId*/)

    99 	{

   100 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoSupplementalInformation()"));

   101 	}

   102 

   103 void CTestDevVideoCiuPlayStep::MdvpoPictureLoss()

   104 	{

   105 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoPictureLoss()"));

   106 	}

   107 

   108 void CTestDevVideoCiuPlayStep::MdvpoPictureLoss(const TArray<TPictureId>& /*aPictures*/)

   109 	{

   110 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoPictureLoss(TArray)"));

   111 	}

   112 

   113 void CTestDevVideoCiuPlayStep::MdvpoSliceLoss(TUint /*aFirstMacroblock*/, TUint /*aNumMacroblocks*/, const TPictureId& /*aPicture*/)

   114 	{

   115 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoSliceLoss()"));

   116 	}

   117 

   118 void CTestDevVideoCiuPlayStep::MdvpoReferencePictureSelection(const TDesC8& /*aSelectionData*/)

   119 	{

   120 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoReferencePictureSelection()"));

   121 	}

   122 

   123 void CTestDevVideoCiuPlayStep::MdvpoTimedSnapshotComplete(TInt /*aError*/, 

   124 								TPictureData* /*aPictureData*/, 

   125 								const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/, 

   126 								const TPictureId& /*aPictureId*/)

   127 	{

   128 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoTimedSnapshotComplete()"));

   129 	}

   130 

   131 void CTestDevVideoCiuPlayStep::MdvpoNewPictures()

   132 	{

   133 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoNewPictures()"));

   134 	}

   135 

   136 void CTestDevVideoCiuPlayStep::MdvpoFatalError(TInt aError)

   137 	{

   138 	iError = aError;

   139 	INFO_PRINTF2(_L("CTestDevVideoCiuPlayStep::MdvpoFatalError():  Error = %d"), aError);

   140 	}

   141 

   142 void CTestDevVideoCiuPlayStep::MdvpoInitComplete(TInt aError)

   143 	{

   144 	iError = aError;

   145 	INFO_PRINTF2(_L("CTestDevVideoCiuPlayStep::MdvpoInitComplete():  Error = %d"), aError);

   146 	}

   147 

   148 void CTestDevVideoCiuPlayStep::MdvpoStreamEnd()

   149 	{

   150 	INFO_PRINTF1(_L("CTestDevVideoCiuPlayStep::MdvpoStreamEnd()"));

   151 	}

   152 

   153 //

   154 //	Video Window Control Tests

   155 //

   156 CTestDevVideoCiuPlayGetAndSetLogicalWindow::CTestDevVideoCiuPlayGetAndSetLogicalWindow(const TDesC& aTestName)

   157 	:CTestDevVideoCiuPlayStep(aTestName)

   158 	{

   159 	}

   160 

   161 CTestDevVideoCiuPlayGetAndSetLogicalWindow* CTestDevVideoCiuPlayGetAndSetLogicalWindow::NewL(const TDesC& aTestName)

   162 	{

   163 	CTestDevVideoCiuPlayGetAndSetLogicalWindow* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetLogicalWindow(aTestName);

   164 	return self;

   165 	}

   166 

   167 TVerdict CTestDevVideoCiuPlayGetAndSetLogicalWindow::DoTestStepPreambleL()

   168 	{

   169 	// Call the base class first

   170 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   171 	if (ret == EPass)

   172 		{

   173 		// select decoder

   174 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   175 		

   176 		if (err != KErrNone)

   177 			{

   178 			ret = EInconclusive;

   179 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   180 			}

   181 		}

   182 	return ret;

   183 	}

   184 

   185 TVerdict CTestDevVideoCiuPlayGetAndSetLogicalWindow::DoTestL()

   186 	{

   187 	TVerdict ret = EFail;

   188 	

   189 	INFO_PRINTF1(_L("DevVideo CIU Window Control Interface Initialisation"));

   190 	

   191 	// Fetch the CI

   192 	MMmfVideoWindowControl* interface = NULL;

   193 		

   194 	interface = static_cast<MMmfVideoWindowControl*>

   195 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   196 																	KUidMmfVideoWindowControl));

   197 	if (!interface)

   198 		{

   199 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   200 		ret = EFail;

   201 		}

   202 	else

   203 		{

   204 		INFO_PRINTF1(_L("DevVideo CIU Window Control Interface Instantiated"));

   205 		

   206 		TRect logicalWindow(TPoint(0,0), TPoint(300,300));

   207 	

   208 		interface->MmvwcSetLogicalVideoWindow(logicalWindow);

   209 		

   210 		MDevVideoCiuTestInterfaceVideoWindowControl* testInterface = NULL;

   211 

   212 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoWindowControl*>

   213 										(iDevVideoPlay->CustomInterface(iHwDeviceId, KUidDevVideoCiuTestInterfaceVideoWindowControl));

   214 		if (testInterface)

   215 			{

   216 			TRect logicalWindowResult = testInterface->MmvwcLogicalVideoWindow();

   217 			if (logicalWindow == logicalWindowResult)

   218 				{

   219 				ret = EPass;

   220 				INFO_PRINTF1(_L("Set Logical Window method call performed as expected"));

   221 				}

   222 			else

   223 				{

   224 				ret = EFail;					

   225 				ERR_PRINTF1(_L("Set Logical Window method call failed to set the value correctly"));

   226 				}

   227 			}

   228 		else

   229 			{

   230 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

   231 			ret = EInconclusive;

   232 			}

   233 		}

   234 	return ret;

   235 	}

   236 

   237 //------------------------------------------------------------------

   238 

   239 CTestDevVideoCiuPlayGetAndSetContentOffset::CTestDevVideoCiuPlayGetAndSetContentOffset(const TDesC& aTestName)

   240 	:CTestDevVideoCiuPlayStep(aTestName)

   241 	{

   242 	}

   243 

   244 CTestDevVideoCiuPlayGetAndSetContentOffset* CTestDevVideoCiuPlayGetAndSetContentOffset::NewL(const TDesC& aTestName)

   245 	{

   246 	CTestDevVideoCiuPlayGetAndSetContentOffset* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetContentOffset(aTestName);

   247 	return self;

   248 	}

   249 

   250 TVerdict CTestDevVideoCiuPlayGetAndSetContentOffset::DoTestStepPreambleL()

   251 	{

   252 	// Call the base class first

   253 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   254 	if (ret == EPass)

   255 		{

   256 		// select decoder

   257 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   258 		

   259 		if (err != KErrNone)

   260 			{

   261 			ret = EInconclusive;

   262 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   263 			}

   264 		}

   265 	return ret;

   266 	}

   267 

   268 TVerdict CTestDevVideoCiuPlayGetAndSetContentOffset::DoTestL()

   269 	{

   270 	TVerdict ret = EFail;

   271 	

   272 	INFO_PRINTF1(_L("DevVideo CIU Window Control Interface Initialisation"));

   273 	

   274 	// Fetch the CI

   275 	MMmfVideoWindowControl* interface = NULL;

   276 		

   277 	interface = static_cast<MMmfVideoWindowControl*>

   278 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   279 																	KUidMmfVideoWindowControl));

   280 	if (!interface)

   281 		{

   282 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   283 		ret = EFail;

   284 		}

   285 	else

   286 		{

   287 		INFO_PRINTF1(_L("DevVideo CIU Window Control Interface Instantiated"));

   288 		

   289 		TPoint contentOffsetInput(100, 100);

   290 	

   291 		interface->MmvwcSetContentOffsetL(contentOffsetInput);

   292 		

   293 		MDevVideoCiuTestInterfaceVideoWindowControl* testInterface = NULL;

   294 

   295 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoWindowControl*>

   296 										(iDevVideoPlay->CustomInterface(iHwDeviceId, KUidDevVideoCiuTestInterfaceVideoWindowControl));

   297 		if (testInterface)

   298 			{

   299 			TPoint contentOffsetOutput = testInterface->MmvwcContentOffset();

   300 			if (contentOffsetInput == contentOffsetOutput)

   301 				{

   302 				ret = EPass;

   303 				INFO_PRINTF1(_L("Set Content Offset method call performed as expected"));

   304 				}

   305 			else

   306 				{

   307 				ret = EFail;					

   308 				ERR_PRINTF1(_L("Set Content Offset method call failed to set the value correctly"));

   309 				}

   310 			}

   311 		else

   312 			{

   313 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

   314 			ret = EInconclusive;

   315 			}

   316 		}

   317 	return ret;

   318 	}

   319 

   320 //------------------------------------------------------------------

   321 

   322 CTestDevVideoCiuPlayGetAndSetContentAlignment::CTestDevVideoCiuPlayGetAndSetContentAlignment(const TDesC& aTestName)

   323 	:CTestDevVideoCiuPlayStep(aTestName)

   324 	{

   325 	}

   326 

   327 CTestDevVideoCiuPlayGetAndSetContentAlignment* CTestDevVideoCiuPlayGetAndSetContentAlignment::NewL(const TDesC& aTestName)

   328 	{

   329 	CTestDevVideoCiuPlayGetAndSetContentAlignment* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetContentAlignment(aTestName);

   330 	return self;

   331 	}

   332 

   333 TVerdict CTestDevVideoCiuPlayGetAndSetContentAlignment::DoTestStepPreambleL()

   334 	{

   335 	// Call the base class first

   336 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   337 	if (ret == EPass)

   338 		{

   339 		// select decoder

   340 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   341 		

   342 		if (err != KErrNone)

   343 			{

   344 			ret = EInconclusive;

   345 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   346 			}

   347 		}

   348 	return ret;

   349 	}

   350 

   351 TVerdict CTestDevVideoCiuPlayGetAndSetContentAlignment::DoTestL()

   352 	{

   353 	TVerdict ret = EFail;

   354 	

   355 	INFO_PRINTF1(_L("DevVideo CIU Window Control Interface Initialisation"));

   356 	

   357 	// Fetch the CI

   358 	MMmfVideoWindowControl* interface = NULL;

   359 		

   360 	interface = static_cast<MMmfVideoWindowControl*>

   361 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   362 																	KUidMmfVideoWindowControl));

   363 	if (!interface)

   364 		{

   365 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   366 		ret = EFail;

   367 		}

   368 	else

   369 		{

   370 		INFO_PRINTF1(_L("DevVideo CIU Window Control Interface Instantiated"));

   371 		

   372 		MDevVideoCiuTestInterfaceVideoWindowControl::TAlignment alignmentInput = {MMmfVideoWindowControl::EHorizAlignCenter, MMmfVideoWindowControl::EVertAlignTop};

   373 	

   374 		interface->MmvwcSetContentAlignment(alignmentInput.iHorizAlign,alignmentInput.iVertAlign);

   375 		

   376 		MDevVideoCiuTestInterfaceVideoWindowControl* testInterface = NULL;

   377 

   378 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoWindowControl*>

   379 										(iDevVideoPlay->CustomInterface(iHwDeviceId, KUidDevVideoCiuTestInterfaceVideoWindowControl));

   380 		if (testInterface)

   381 			{

   382 			MDevVideoCiuTestInterfaceVideoWindowControl::TAlignment alignmentOutput = testInterface->MmvwcContentAlignment();

   383 			if ((alignmentInput.iHorizAlign == alignmentOutput.iHorizAlign) && (alignmentInput.iVertAlign == alignmentOutput.iVertAlign) )

   384 				{

   385 				ret = EPass;

   386 				INFO_PRINTF1(_L("Set Content Alignment method call performed as expected"));

   387 				}

   388 			else

   389 				{

   390 				ret = EFail;					

   391 				ERR_PRINTF1(_L("Set Content Alignment method call failed to set the value correctly"));

   392 				}

   393 			}

   394 		else

   395 			{

   396 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

   397 			ret = EInconclusive;

   398 			}

   399 		}

   400 	return ret;

   401 	}

   402 

   403 //------------------------------------------------------------------

   404 

   405 //

   406 //	Video Resource Management Tests

   407 //

   408 

   409 CTestDevVideoCiuPlayGetAndSetResourceObserver::CTestDevVideoCiuPlayGetAndSetResourceObserver(const TDesC& aTestName)

   410 	:CTestDevVideoCiuPlayStep(aTestName)

   411 	{

   412 	}

   413 

   414 CTestDevVideoCiuPlayGetAndSetResourceObserver* CTestDevVideoCiuPlayGetAndSetResourceObserver::NewL(const TDesC& aTestName)

   415 	{

   416 	CTestDevVideoCiuPlayGetAndSetResourceObserver* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetResourceObserver(aTestName);

   417 	return self;

   418 	}

   419 

   420 TVerdict CTestDevVideoCiuPlayGetAndSetResourceObserver::DoTestStepPreambleL()

   421 	{

   422 	// Call the base class first

   423 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   424 	if (ret == EPass)

   425 		{

   426 		// select decoder

   427 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   428 		

   429 		if (err != KErrNone)

   430 			{

   431 			ret = EInconclusive;

   432 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   433 			}

   434 		}

   435 	return ret;

   436 	}

   437 

   438 TVerdict CTestDevVideoCiuPlayGetAndSetResourceObserver::DoTestL()

   439 	{

   440 	TVerdict ret = EFail;

   441 	

   442 	INFO_PRINTF1(_L("DevVideo CIU Resource Management Interface Initialisation"));

   443 	

   444 	// Fetch the CI

   445 	MMmfVideoResourceHandler* interface = NULL;

   446 		

   447 	interface = static_cast<MMmfVideoResourceHandler*>

   448 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   449 																	KUidMmfVideoResourceManagement));

   450 	if (!interface)

   451 		{

   452 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   453 		ret = EFail;

   454 		}

   455 	else

   456 		{

   457 		INFO_PRINTF1(_L("DevVideo CIU Resource Management Interface Instantiated"));

   458 	

   459 		MMmfVideoResourceObserver* obs = this;

   460 		interface->MmvrhSetObserver(obs);

   461 		INFO_PRINTF1(_L("SetObserver called"));

   462 		

   463 		// Verify that the observer was set

   464 		MDevVideoCiuTestInterfaceResourceManagement* testInterface = NULL;

   465 		testInterface = static_cast<MDevVideoCiuTestInterfaceResourceManagement*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

   466 																												 KUidDevVideoCiuTestInterfaceResourceManagement));

   467 		if (!testInterface)

   468 			{

   469 			ERR_PRINTF1(_L("Failed to create the test interface."));

   470 			ret = EFail;

   471 			}

   472 		else

   473 			{

   474 			if (obs != testInterface->MdvrmObserver())

   475 				{

   476 				ERR_PRINTF1(_L("Failed to set the observer."));

   477 				ret = EFail;

   478 				}

   479 			else

   480 				{			

   481 				INFO_PRINTF1(_L("SetObserver successfully called"));

   482 				ret = EPass;

   483 				}

   484 			}		

   485 		}

   486 	return ret;

   487 	}

   488 

   489 //from MMmfVideoResourceObserver

   490 void CTestDevVideoCiuPlayGetAndSetResourceObserver::MmvroResourcesLost(TUid /*aMediaDevice*/)

   491 	{}

   492 		

   493 void CTestDevVideoCiuPlayGetAndSetResourceObserver::MmvroResourcesRestored(TUid /*aMediaDevice*/)

   494 	{}

   495 

   496 //------------------------------------------------------------------

   497 

   498 CTestDevVideoCiuPlayResourceLost::CTestDevVideoCiuPlayResourceLost(const TDesC& aTestName)

   499 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

   500 	{

   501 	}

   502 

   503 CTestDevVideoCiuPlayResourceLost* CTestDevVideoCiuPlayResourceLost::NewL(const TDesC& aTestName)

   504 	{

   505 	CTestDevVideoCiuPlayResourceLost* self = new(ELeave) CTestDevVideoCiuPlayResourceLost(aTestName);

   506 	return self;

   507 	}

   508 

   509 TVerdict CTestDevVideoCiuPlayResourceLost::DoTestStepPreambleL()

   510 	{

   511 	// Call the base class first

   512 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   513 	if (ret == EPass)

   514 		{

   515 		// select decoder

   516 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   517 		

   518 		if (err != KErrNone)

   519 			{

   520 			ret = EInconclusive;

   521 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   522 			}

   523 		}

   524 	return ret;

   525 	}

   526 

   527 TVerdict CTestDevVideoCiuPlayResourceLost::DoTestL()

   528 	{

   529 	TVerdict ret = EFail;

   530 	

   531 	INFO_PRINTF1(_L("DevVideo CIU Resource Management Interface Initialisation"));

   532 	

   533 	// Fetch the CI

   534 	MMmfVideoResourceHandler* interface = NULL;

   535 		

   536 	interface = static_cast<MMmfVideoResourceHandler*>

   537 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   538 																	KUidMmfVideoResourceManagement));

   539 	if (!interface)

   540 		{

   541 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   542 		ret = EFail;

   543 		}

   544 	else

   545 		{

   546 		INFO_PRINTF1(_L("DevVideo CIU Resource Management Interface Instantiated"));

   547 

   548 		MDevVideoCiuTestInterfaceResourceManagement* testInterface = NULL;

   549 		testInterface = static_cast<MDevVideoCiuTestInterfaceResourceManagement*>(iDevVideoPlay->

   550 																				CustomInterface(iHwDeviceId,

   551 																								KUidDevVideoCiuTestInterfaceResourceManagement));

   552 		if (!testInterface)

   553 			{

   554 			ERR_PRINTF1(_L("Failed to create the test interface."));

   555 			ret = EFail;

   556 			}

   557 		else

   558 			{

   559 			// Set the observer to callback!

   560 			MMmfVideoResourceObserver* obs = this;

   561 			interface->MmvrhSetObserver(obs);

   562 

   563 			INFO_PRINTF1(_L("Requesting the Resource Lost Callback..."));

   564 			testInterface->MdvrmRequestResourceLostCallback();

   565 

   566 			if ((iError != KErrNone) || (!iCallbackReceived))

   567 				{	

   568 				ERR_PRINTF1(_L("Error receiving the Resource Lost Callback."));

   569 				ret = EFail;

   570 				}

   571 			else

   572 				{

   573 				INFO_PRINTF1(_L("Successfully retrieved the Resource Lost Callback"));

   574 				ret = EPass;

   575 				}

   576 			}

   577 		}

   578 	return ret;

   579 	}

   580 

   581 //from MMmfVideoResourceObserver

   582 void CTestDevVideoCiuPlayResourceLost::MmvroResourcesLost(TUid /*aMediaDevice*/)

   583 	{

   584 	INFO_PRINTF1(_L("Resource Lost callback received."));

   585 	iCallbackReceived = ETrue;

   586 	iError = KErrNone;

   587 	}

   588 		

   589 void CTestDevVideoCiuPlayResourceLost::MmvroResourcesRestored(TUid /*aMediaDevice*/)

   590 	{

   591 	iError = KErrNotSupported;

   592 	}

   593 

   594 //------------------------------------------------------------------

   595 

   596 CTestDevVideoCiuPlayResourceRestored::CTestDevVideoCiuPlayResourceRestored(const TDesC& aTestName)

   597 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

   598 	{

   599 	}

   600 

   601 CTestDevVideoCiuPlayResourceRestored* CTestDevVideoCiuPlayResourceRestored::NewL(const TDesC& aTestName)

   602 	{

   603 	CTestDevVideoCiuPlayResourceRestored* self = new(ELeave) CTestDevVideoCiuPlayResourceRestored(aTestName);

   604 	return self;

   605 	}

   606 

   607 TVerdict CTestDevVideoCiuPlayResourceRestored::DoTestStepPreambleL()

   608 	{

   609 	// Call the base class first

   610 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   611 	if (ret == EPass)

   612 		{

   613 		// select decoder

   614 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   615 		

   616 		if (err != KErrNone)

   617 			{

   618 			ret = EInconclusive;

   619 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   620 			}

   621 		}

   622 	return ret;

   623 	}

   624 

   625 TVerdict CTestDevVideoCiuPlayResourceRestored::DoTestL()

   626 	{

   627 	TVerdict ret = EFail;

   628 	

   629 	INFO_PRINTF1(_L("DevVideo CIU Resource Management Interface Initialisation"));

   630 	

   631 	// Fetch the CI

   632 	MMmfVideoResourceHandler* interface = NULL;

   633 		

   634 	interface = static_cast<MMmfVideoResourceHandler*>

   635 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   636 																	KUidMmfVideoResourceManagement));

   637 	if (!interface)

   638 		{

   639 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   640 		ret = EFail;

   641 		}

   642 	else

   643 		{

   644 		INFO_PRINTF1(_L("DevVideo CIU Resource Management Interface Instantiated"));

   645 

   646 		MDevVideoCiuTestInterfaceResourceManagement* testInterface = NULL;

   647 		testInterface = static_cast<MDevVideoCiuTestInterfaceResourceManagement*>(iDevVideoPlay->

   648 																				CustomInterface(iHwDeviceId,

   649 																								KUidDevVideoCiuTestInterfaceResourceManagement));

   650 		if (!testInterface)

   651 			{

   652 			ERR_PRINTF1(_L("Failed to create the test interface."));

   653 			ret = EFail;

   654 			}

   655 		else

   656 			{

   657 			// Set the observer to callback!

   658 			MMmfVideoResourceObserver* obs = this;

   659 			interface->MmvrhSetObserver(obs);

   660 

   661 			INFO_PRINTF1(_L("Requesting the Resource Restored Callback..."));

   662 			testInterface->MdvrmRequestResourceRestoredCallback();

   663 

   664 			if ((iError != KErrNone) || (!iCallbackReceived))

   665 				{	

   666 				ERR_PRINTF1(_L("Error receiving the Resource Restored Callback."));

   667 				ret = EFail;

   668 				}

   669 			else

   670 				{

   671 				INFO_PRINTF1(_L("Successfully retrieved the Resource Restored Callback"));

   672 				ret = EPass;

   673 				}

   674 			}

   675 		}

   676 	return ret;

   677 	}

   678 

   679 //from MMmfVideoResourceObserver

   680 void CTestDevVideoCiuPlayResourceRestored::MmvroResourcesLost(TUid /*aMediaDevice*/)

   681 	{

   682 	iError = KErrNotSupported;

   683 	}

   684 		

   685 void CTestDevVideoCiuPlayResourceRestored::MmvroResourcesRestored(TUid /*aMediaDevice*/)

   686 	{

   687 	INFO_PRINTF1(_L("Resource Restored callback received."));

   688 	iCallbackReceived = ETrue;

   689 	iError = KErrNone;

   690 	}

   691 

   692 //------------------------------------------------------------------

   693 

   694 CTestDevVideoCiuPlayGetAndSetResourcePriority::CTestDevVideoCiuPlayGetAndSetResourcePriority(const TDesC& aTestName)

   695 	:CTestDevVideoCiuPlayStep(aTestName)

   696 	{

   697 	}

   698 

   699 CTestDevVideoCiuPlayGetAndSetResourcePriority* CTestDevVideoCiuPlayGetAndSetResourcePriority::NewL(const TDesC& aTestName)

   700 	{

   701 	CTestDevVideoCiuPlayGetAndSetResourcePriority* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetResourcePriority(aTestName);

   702 	return self;

   703 	}

   704 

   705 TVerdict CTestDevVideoCiuPlayGetAndSetResourcePriority::DoTestStepPreambleL()

   706 	{

   707 	// Call the base class first

   708 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   709 	if (ret == EPass)

   710 		{

   711 		// select decoder

   712 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   713 		

   714 		if (err != KErrNone)

   715 			{

   716 			ret = EInconclusive;

   717 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   718 			}

   719 		}

   720 	return ret;

   721 	}

   722 

   723 TVerdict CTestDevVideoCiuPlayGetAndSetResourcePriority::DoTestL()

   724 	{

   725 	TVerdict ret = EFail;

   726 	

   727 	INFO_PRINTF1(_L("DevVideo CIU Resource Priority Interface Initialisation"));

   728 	

   729 	// Fetch the CI

   730 	MMmfVideoResourcePriority* interface = NULL;

   731 		

   732 	interface = static_cast<MMmfVideoResourcePriority*>

   733 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   734 																	KUidMmfVideoResourcePriority));

   735 	if (!interface)

   736 		{

   737 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   738 		ret = EFail;

   739 		}

   740 	else

   741 		{

   742 		INFO_PRINTF1(_L("DevVideo CIU Resource Priority Interface Instantiated"));

   743 		

   744 		TInt inputPriority = 100;

   745 			

   746 		interface->MmvpSetResourcePriority(inputPriority);

   747 		

   748 		MDevVideoCiuTestInterfaceResourcePriority* testInterface = NULL;

   749 

   750 		testInterface = static_cast<MDevVideoCiuTestInterfaceResourcePriority*>

   751 										(iDevVideoPlay->CustomInterface(iHwDeviceId, KUidDevVideoCiuTestInterfaceResourcePriority));

   752 		if (testInterface)

   753 			{

   754 			TInt outputPriority = testInterface->MdvrpResourcePriority();

   755 			if (inputPriority == outputPriority)

   756 				{

   757 				ret = EPass;

   758 				INFO_PRINTF1(_L("Set Resource Priority method call performed as expected"));

   759 				}

   760 			else

   761 				{

   762 				ret = EFail;					

   763 				ERR_PRINTF1(_L("Set Resource Priority method call failed to set the value correctly"));

   764 				}

   765 			}

   766 		else

   767 			{

   768 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

   769 			ret = EInconclusive;

   770 			}

   771 		}

   772 	return ret;

   773 	}

   774 

   775 

   776 //

   777 //	Video Properties Management Tests

   778 //

   779 

   780 CTestDevVideoCiuPlaySetAndGetPropertiesObserver::CTestDevVideoCiuPlaySetAndGetPropertiesObserver(const TDesC& aTestName)

   781 	:CTestDevVideoCiuPlayStep(aTestName)

   782 	{

   783 	}

   784 

   785 CTestDevVideoCiuPlaySetAndGetPropertiesObserver* CTestDevVideoCiuPlaySetAndGetPropertiesObserver::NewL(const TDesC& aTestName)

   786 	{

   787 	CTestDevVideoCiuPlaySetAndGetPropertiesObserver* self = new(ELeave) CTestDevVideoCiuPlaySetAndGetPropertiesObserver(aTestName);

   788 	return self;

   789 	}

   790 

   791 TVerdict CTestDevVideoCiuPlaySetAndGetPropertiesObserver::DoTestStepPreambleL()

   792 	{

   793 	// Call the base class first

   794 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   795 	if (ret == EPass)

   796 		{

   797 		// select decoder

   798 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   799 		

   800 		if (err != KErrNone)

   801 			{

   802 			ret = EInconclusive;

   803 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   804 			}

   805 		}

   806 	return ret;

   807 	}

   808 

   809 TVerdict CTestDevVideoCiuPlaySetAndGetPropertiesObserver::DoTestL()

   810 	{

   811 	TVerdict ret = EFail;

   812 	

   813 	INFO_PRINTF1(_L("DevVideo CIU Properties Management Interface Initialisation"));

   814 	

   815 	// Fetch the CI

   816 	MMmfVideoPropertiesNotifier* interface = NULL;

   817 		

   818 	interface = static_cast<MMmfVideoPropertiesNotifier*>

   819 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   820 																	KUidMmfVideoPropertiesManagement));

   821 	if (!interface)

   822 		{

   823 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   824 		ret = EFail;

   825 		}

   826 	else

   827 		{

   828 		INFO_PRINTF1(_L("DevVideo CIU Properties Management Interface Instantiated"));

   829 	

   830 		MMmfVideoPropertiesObserver* obs = this;

   831 		interface->MmvpnSetObserver(obs);

   832 		INFO_PRINTF1(_L("SetObserver called"));

   833 		

   834 		// Verify that the observer was set

   835 		MDevVideoCiuTestInterfacePropertiesManagement* testInterface = NULL;

   836 		testInterface = static_cast<MDevVideoCiuTestInterfacePropertiesManagement*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

   837 																												 KUidDevVideoCiuTestInterfacePropertiesManagement));

   838 		if (!testInterface)

   839 			{

   840 			ERR_PRINTF1(_L("Failed to create the test interface."));

   841 			ret = EFail;

   842 			}

   843 		else

   844 			{

   845 			if (obs != testInterface->MmvpoObserver())

   846 				{

   847 				ERR_PRINTF1(_L("Failed to set the observer."));

   848 				ret = EFail;

   849 				}

   850 			else

   851 				{			

   852 				INFO_PRINTF1(_L("SetObserver successfully called."));

   853 				ret = EPass;

   854 				}

   855 			}		

   856 		}

   857 	return ret;

   858 	}

   859 

   860 //from MMmfVideoPropertiesObserver

   861 void CTestDevVideoCiuPlaySetAndGetPropertiesObserver::MmvpoUpdateVideoProperties(const TYuvFormat& /*aYuvFormat*/, const TSize& /*aPictureSize*/)

   862 	{}

   863 

   864 //------------------------------------------------------------------

   865 CTestDevVideoCiuPlayUpdateProperties::CTestDevVideoCiuPlayUpdateProperties(const TDesC& aTestName)

   866 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

   867 	{

   868 	}

   869 

   870 CTestDevVideoCiuPlayUpdateProperties* CTestDevVideoCiuPlayUpdateProperties::NewL(const TDesC& aTestName)

   871 	{

   872 	CTestDevVideoCiuPlayUpdateProperties* self = new(ELeave) CTestDevVideoCiuPlayUpdateProperties(aTestName);

   873 	return self;

   874 	}

   875 

   876 TVerdict CTestDevVideoCiuPlayUpdateProperties::DoTestStepPreambleL()

   877 	{

   878 	// Call the base class first

   879 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   880 	if (ret == EPass)

   881 		{

   882 		// select decoder

   883 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

   884 		

   885 		if (err != KErrNone)

   886 			{

   887 			ret = EInconclusive;

   888 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

   889 			}

   890 		}

   891 	return ret;

   892 	}

   893 

   894 TVerdict CTestDevVideoCiuPlayUpdateProperties::DoTestL()

   895 	{

   896 	TVerdict ret = EFail;

   897 	

   898 	INFO_PRINTF1(_L("DevVideo CIU Properties Management Interface Initialisation"));

   899 	

   900 	// Fetch the CI

   901 	MMmfVideoPropertiesNotifier* interface = NULL;

   902 		

   903 	interface = static_cast<MMmfVideoPropertiesNotifier*>

   904 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

   905 																	KUidMmfVideoPropertiesManagement));

   906 	if (!interface)

   907 		{

   908 		ERR_PRINTF1(_L("Error - no interface retrieved"));

   909 		ret = EFail;

   910 		}

   911 	else

   912 		{

   913 		INFO_PRINTF1(_L("DevVideo CIU Properties Management Interface Instantiated"));

   914 

   915 		MDevVideoCiuTestInterfacePropertiesManagement* testInterface = NULL;

   916 		testInterface = static_cast<MDevVideoCiuTestInterfacePropertiesManagement*>(iDevVideoPlay->

   917 																				CustomInterface(iHwDeviceId,

   918 																								KUidDevVideoCiuTestInterfacePropertiesManagement));

   919 		if (!testInterface)

   920 			{

   921 			ERR_PRINTF1(_L("Failed to create the test interface."));

   922 			ret = EFail;

   923 			}

   924 		else

   925 			{

   926 			// Set the observer to callback!

   927 			MMmfVideoPropertiesObserver* obs = this;

   928 			interface->MmvpnSetObserver(obs);

   929 

   930 			INFO_PRINTF1(_L("Notifying the Properties Update Callback..."));

   931 			testInterface->MmvpoUpdateVideoPropertiesCallback();

   932 

   933 			if ((iError != KErrNone) || (!iCallbackReceived))

   934 				{	

   935 				ERR_PRINTF1(_L("Error receiving the RProperties Update Callback."));

   936 				ret = EFail;

   937 				}

   938 			else

   939 				{

   940 				INFO_PRINTF1(_L("Successfully retrieved the Properties Update Callback"));

   941 				ret = EPass;

   942 				}

   943 			}

   944 		}

   945 	return ret;

   946 	}

   947 

   948 //from MMmfVideoPropertiesObserver

   949 void CTestDevVideoCiuPlayUpdateProperties::MmvpoUpdateVideoProperties(const TYuvFormat& /*aYuvFormat*/, const TSize& /*aPictureSize*/)

   950 	{	

   951 	INFO_PRINTF1(_L("Properties Update Callback received."));

   952 	iCallbackReceived = ETrue;

   953 	iError = KErrNone;

   954 	}

   955 	

   956 //------------------------------------------------------------------

   957 

   958 CTestDevVideoCiuPlayCreateVideoMediaProtected::CTestDevVideoCiuPlayCreateVideoMediaProtected(const TDesC& aTestName)

   959 	:CTestDevVideoCiuPlayStep(aTestName)

   960 	{

   961 	}

   962 

   963 CTestDevVideoCiuPlayCreateVideoMediaProtected* CTestDevVideoCiuPlayCreateVideoMediaProtected::NewL(const TDesC& aTestName)

   964 	{

   965 	CTestDevVideoCiuPlayCreateVideoMediaProtected* self = new(ELeave) CTestDevVideoCiuPlayCreateVideoMediaProtected(aTestName);

   966 	return self;

   967 	}

   968 

   969 TVerdict CTestDevVideoCiuPlayCreateVideoMediaProtected::DoTestStepPreambleL()

   970 	{

   971 	// Call the base class first

   972 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

   973 

   974 	if (ret == EPass)

   975 		{

   976 		// select post-processor

   977 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectPostProcessorL(KUidDevVideoCiuTestPostProcHwDevice));

   978 		

   979 		if (err != KErrNone)

   980 			{

   981 			ret = EInconclusive;

   982 			ERR_PRINTF1(_L("DevVideo Play Failed to select the post processor."));

   983 			}		

   984 		}

   985 

   986 	return ret;

   987 	}

   988 	

   989 TVerdict CTestDevVideoCiuPlayCreateVideoMediaProtected::DoTestL()

   990 	{

   991 	TVerdict ret = EPass;

   992 	

   993 	INFO_PRINTF1(_L("DevVideo CIU Video Media Protected Initialisation"));

   994 

   995 	// Try to fetch the CI...

   996 	MMmfVideoMediaProtected* interface = NULL;

   997 		

   998 	interface = static_cast<MMmfVideoMediaProtected*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

   999 																					KUidMmfVideoMediaProtected));

  1000 	if (!interface)

  1001 		{

  1002 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1003 		ret = EFail;

  1004 		}

  1005 	else

  1006 		{

  1007 		INFO_PRINTF1(_L("DevVideo CIU Video Media Protected instantiated"));

  1008 		}

  1009 

  1010 	return ret;

  1011 	}

  1012 //------------------------------------------------------------------

  1013 

  1014 //------------------------------------------------------------------

  1015 

  1016 CTestDevVideoCiuPlaySetVideoMediaProtected::CTestDevVideoCiuPlaySetVideoMediaProtected(const TDesC& aTestName)

  1017 	:CTestDevVideoCiuPlayStep(aTestName)

  1018 	{

  1019 	}

  1020 

  1021 CTestDevVideoCiuPlaySetVideoMediaProtected* CTestDevVideoCiuPlaySetVideoMediaProtected::NewL(const TDesC& aTestName)

  1022 	{

  1023 	CTestDevVideoCiuPlaySetVideoMediaProtected* self = new(ELeave) CTestDevVideoCiuPlaySetVideoMediaProtected(aTestName);

  1024 	return self;

  1025 	}

  1026 

  1027 TVerdict CTestDevVideoCiuPlaySetVideoMediaProtected::DoTestStepPreambleL()

  1028 	{

  1029 	// Call the base class first

  1030 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1031 

  1032 	if (ret == EPass)

  1033 		{

  1034 		// select post-processor

  1035 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectPostProcessorL(KUidDevVideoCiuTestPostProcHwDevice));

  1036 		

  1037 		if (err != KErrNone)

  1038 			{

  1039 			ret = EInconclusive;

  1040 			ERR_PRINTF1(_L("DevVideo Play Failed to select the post processor."));

  1041 			}

  1042 		}

  1043 

  1044 	return ret;

  1045 	}

  1046 

  1047 // alternate implementation that uses the test interface to check

  1048 // that the value has been set

  1049 TVerdict CTestDevVideoCiuPlaySetVideoMediaProtected::DoTestL()

  1050 	{

  1051 	TVerdict ret = EFail;

  1052 

  1053 	// Got this far so must have successfully initialised DevVideoPlay

  1054 	// Try to fetch the CI...

  1055 	MMmfVideoMediaProtected* interface = NULL;

  1056 		

  1057 	interface = static_cast<MMmfVideoMediaProtected*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1058 																					KUidMmfVideoMediaProtected));

  1059 	if (!interface)

  1060 		{

  1061 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1062 		ret = EInconclusive;

  1063 		}

  1064 	else

  1065 		{

  1066 		// Try to call a method on the interface

  1067 		TRAPD(err, interface->MmvsoMediaIsProtectedL(ETrue));

  1068 		// Method should have left as not supported

  1069 		if (err != KErrNotSupported)

  1070 			{

  1071 			ERR_PRINTF2(_L("Error - wrong leave code from method call"), err);

  1072 			}

  1073 		else

  1074 			{

  1075 			// Now set up the test interface...

  1076 			MDevVideoCiuTestInterfaceMediaProtected* testInterface = NULL;

  1077 			testInterface = static_cast<MDevVideoCiuTestInterfaceMediaProtected*>

  1078 										(iDevVideoPlay->CustomInterface(iHwDeviceId, KUidDevVideoCiuTestInterfaceMediaProtected));

  1079 			if (testInterface)

  1080 				{

  1081 				if (testInterface->MmvsoMediaIsProtected())

  1082 					{

  1083 					ret = EPass;

  1084 					INFO_PRINTF1(_L("Media protected method call performed as expected"));

  1085 					}

  1086 				else

  1087 					{					

  1088 					ERR_PRINTF1(_L("Media protected method call failed to set the value correctly"));

  1089 					}

  1090 				}

  1091 			else

  1092 				{

  1093 				ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1094 				ret = EInconclusive;

  1095 				}

  1096 			}

  1097 		}

  1098 

  1099 	return ret;

  1100 	}

  1101 //------------------------------------------------------------------

  1102 

  1103 

  1104 //------------------------------------------------------------------

  1105 

  1106 CTestDevVideoCiuPlayCreateColourSpace::CTestDevVideoCiuPlayCreateColourSpace(const TDesC& aTestName)

  1107 	:CTestDevVideoCiuPlayStep(aTestName)

  1108 	{

  1109 	}

  1110 

  1111 CTestDevVideoCiuPlayCreateColourSpace* CTestDevVideoCiuPlayCreateColourSpace::NewL(const TDesC& aTestName)

  1112 	{

  1113 	CTestDevVideoCiuPlayCreateColourSpace* self = new(ELeave) CTestDevVideoCiuPlayCreateColourSpace(aTestName);

  1114 	return self;

  1115 	}

  1116 

  1117 TVerdict CTestDevVideoCiuPlayCreateColourSpace::DoTestStepPreambleL()

  1118 	{

  1119 	// Call the base class first

  1120 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1121 

  1122 	if (ret == EPass)

  1123 		{

  1124 		// select post-processor

  1125 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectPostProcessorL(KUidDevVideoCiuTestPostProcHwDevice));

  1126 

  1127 		if (err != KErrNone)

  1128 			{

  1129 			ret = EInconclusive;

  1130 			ERR_PRINTF1(_L("DevVideo Play Failed to select the post processor."));

  1131 			}

  1132 		}

  1133 	

  1134 	return ret;

  1135 	}

  1136 

  1137 TVerdict CTestDevVideoCiuPlayCreateColourSpace::DoTestL()

  1138 	{

  1139 	TVerdict ret = EPass;

  1140 	

  1141 	INFO_PRINTF1(_L("DevVideo CIU Colour Space Header Interface Initialisation"));

  1142 

  1143 	// Try to fetch the CI...

  1144 	MMmfVideoPlayHWDeviceColourInfoCustomHeader* interface = NULL;

  1145 		

  1146 	interface = static_cast<MMmfVideoPlayHWDeviceColourInfoCustomHeader*>

  1147 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1148 																	KUidMmfVideoPlayHWDeviceColourInfoCustomHeader));

  1149 	if (!interface)

  1150 		{

  1151 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1152 		ret = EFail;

  1153 		}

  1154 	else

  1155 		{

  1156 		INFO_PRINTF1(_L("DevVideo CIU Colour Space Header Interface Instantiated"));

  1157 		}

  1158 				

  1159 	return ret;

  1160 	}

  1161 //------------------------------------------------------------------

  1162 

  1163 //------------------------------------------------------------------

  1164 CTestDevVideoCiuPlayGetColourSpace::CTestDevVideoCiuPlayGetColourSpace(const TDesC& aTestName)

  1165 	: CTestDevVideoCiuPlayStep(aTestName)

  1166 	{

  1167 	}

  1168 

  1169 CTestDevVideoCiuPlayGetColourSpace* CTestDevVideoCiuPlayGetColourSpace::NewL(const TDesC& aTestName)

  1170 	{

  1171 	CTestDevVideoCiuPlayGetColourSpace* self = new(ELeave) CTestDevVideoCiuPlayGetColourSpace(aTestName);

  1172 	return self;

  1173 	}

  1174 

  1175 TVerdict CTestDevVideoCiuPlayGetColourSpace::DoTestStepPreambleL()

  1176 	{

  1177 	// Call the base class first

  1178 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1179 

  1180 	if (ret == EPass)

  1181 		{

  1182 		// select post-processor

  1183 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectPostProcessorL(KUidDevVideoCiuTestPostProcHwDevice));

  1184 

  1185 		if (err != KErrNone)

  1186 			{

  1187 			ret = EInconclusive;

  1188 			ERR_PRINTF1(_L("DevVideo Play Failed to select the post processor."));

  1189 			}

  1190 		}

  1191 		

  1192 	return ret;

  1193 	}

  1194 

  1195 // Implementation that uses the test interface to set data that can be checked

  1196 // in the call to the interface's "get" method.

  1197 TVerdict CTestDevVideoCiuPlayGetColourSpace::DoTestL()

  1198 	{

  1199 	TVerdict ret = EFail;

  1200 

  1201 	// Got this far so must have successfully initialised DevVideoPlay

  1202 	// Try to fetch the CI...

  1203 	MMmfVideoPlayHWDeviceColourInfoCustomHeader* interface = NULL;

  1204 		

  1205 	interface = static_cast<MMmfVideoPlayHWDeviceColourInfoCustomHeader*>

  1206 						(iDevVideoPlay->CustomInterface(iHwDeviceId, 

  1207 														KUidMmfVideoPlayHWDeviceColourInfoCustomHeader));

  1208 	if (!interface)

  1209 		{

  1210 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1211 		ret = EInconclusive;

  1212 		}

  1213 	else

  1214 		{

  1215 		// Setup some test values...

  1216 		TVideoDataUnitType dataUnitType = EDuArbitraryStreamSection;

  1217 		TVideoDataUnitEncapsulation dataUnitEncapsulation = EDuRtpPayload;

  1218 		TYuvFormat yuvFormat;

  1219 		yuvFormat.iCoefficients = ECustomYuvMatrix;

  1220 		yuvFormat.iPattern = EYuv422Chroma2;

  1221 		yuvFormat.iDataLayout = EYuvDataSemiPlanar;

  1222 		yuvFormat.iYuv2RgbMatrix = NULL;

  1223 		yuvFormat.iRgb2YuvMatrix = NULL;

  1224 		yuvFormat.iAspectRatioNum = 666;

  1225 		yuvFormat.iAspectRatioDenom = 999;

  1226 		TVideoInputBuffer* dataUnit = new TVideoInputBuffer();

  1227 

  1228 		if (!dataUnit)

  1229 			{

  1230 			ERR_PRINTF2(_L("Failed to allocate test data."), KErrNoMemory);

  1231 			}

  1232 		else

  1233 			{

  1234 			// just set one member

  1235 			dataUnit->iOptions = 444;

  1236 			// Now set up the test interface...

  1237 			MDevVideoCiuTestInterfaceColourSpace* testInterface = NULL;

  1238 			testInterface = static_cast<MDevVideoCiuTestInterfaceColourSpace*>

  1239 										(iDevVideoPlay->CustomInterface(iHwDeviceId, KUidDevVideoCiuTestInterfaceColourSpace));

  1240 			if (testInterface)

  1241 				{

  1242 				testInterface->MmvpciSetColourSpaceHeaderInfoL(dataUnitType,

  1243 																dataUnitEncapsulation,

  1244 																dataUnit,

  1245 																yuvFormat);

  1246 				INFO_PRINTF1(_L("Set the colour space header info."));

  1247 				

  1248 				TVideoDataUnitType testDataUnitType = TVideoDataUnitType(0);

  1249 				TVideoDataUnitEncapsulation testDataUnitEncapsulation = TVideoDataUnitEncapsulation(0);

  1250 				TVideoInputBuffer* testDataUnit = new TVideoInputBuffer();

  1251 				TYuvFormat testYuvFormat;

  1252 				if (!testDataUnit)

  1253 					{

  1254 					ERR_PRINTF2(_L("Failed to allocate test data."), KErrNoMemory);

  1255 					}

  1256 				else

  1257 					{				

  1258 					// Call the interface's method

  1259 					TRAPD(err, interface->MmvpciGetColourSpaceHeaderInfoL(	testDataUnitType,

  1260 																			testDataUnitEncapsulation,

  1261 																			testDataUnit,

  1262 																			testYuvFormat));

  1263 					if ((err == KErrNone) &&

  1264 						(dataUnitType == testDataUnitType) &&

  1265 						(dataUnitEncapsulation == testDataUnitEncapsulation) &&

  1266 						(dataUnit->iOptions == testDataUnit->iOptions) &&

  1267 						(yuvFormat == testYuvFormat))

  1268 						{

  1269 						INFO_PRINTF1(_L("Succesfully retrieved the colour space header info."));

  1270 						ret = EPass;

  1271 						}

  1272 					else

  1273 						{

  1274 						ERR_PRINTF1(_L("Failed to retrieve the colour space header info."));

  1275 						}

  1276 					}

  1277 				delete testDataUnit;

  1278 				}

  1279 			else

  1280 				{

  1281 				ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1282 				ret = EInconclusive;

  1283 				}

  1284 			}

  1285 		delete dataUnit;

  1286 		}

  1287 

  1288 	return ret;

  1289 	}

  1290 

  1291 //------------------------------------------------------------------

  1292 // Resource control tests implementation

  1293 CTestDevVideoCiuPlayCreatePolicyExtension::CTestDevVideoCiuPlayCreatePolicyExtension(const TDesC& aTestName)

  1294 	: CTestDevVideoCiuPlayStep(aTestName)

  1295 	{

  1296 	}

  1297 

  1298 CTestDevVideoCiuPlayCreatePolicyExtension* CTestDevVideoCiuPlayCreatePolicyExtension::NewL(const TDesC& aTestName)

  1299 	{

  1300 	CTestDevVideoCiuPlayCreatePolicyExtension* self = new(ELeave) CTestDevVideoCiuPlayCreatePolicyExtension(aTestName);

  1301 	return self;

  1302 	}

  1303 

  1304 TVerdict CTestDevVideoCiuPlayCreatePolicyExtension::DoTestStepPreambleL()

  1305 	{

  1306 	// Call the base class first

  1307 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1308 	if (ret == EPass)

  1309 		{

  1310 		// select decoder

  1311 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1312 		

  1313 		if (err != KErrNone)

  1314 			{

  1315 			ret = EInconclusive;

  1316 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1317 			}

  1318 		}

  1319 	return ret;

  1320 	}

  1321 	

  1322 TVerdict CTestDevVideoCiuPlayCreatePolicyExtension::DoTestL()

  1323 	{

  1324 	TVerdict ret = EPass;

  1325 	

  1326 	INFO_PRINTF1(_L("DevVideo CIU Policy Extension Interface Initialisation"));

  1327 	

  1328 	// Try to fetch the CI...

  1329 	MMmfVideoHwDeviceVideoPolicyExtension* interface = NULL;

  1330 		

  1331 	interface = static_cast<MMmfVideoHwDeviceVideoPolicyExtension*>

  1332 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1333 																	KUidMmfVideoHwDevVideoPolicyExtension));

  1334 	if (!interface)

  1335 		{

  1336 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1337 		ret = EFail;

  1338 		}

  1339 	else

  1340 		{

  1341 		INFO_PRINTF1(_L("DevVideo CIU Policy Extension Interface Instantiated"));

  1342 		}

  1343 		

  1344 	return ret;

  1345 	}

  1346 

  1347 //-------------------------------------------------------------------------

  1348 CTestDevVideoCiuPlaySetClientPolicyExtension::CTestDevVideoCiuPlaySetClientPolicyExtension(const TDesC& aTestName)

  1349 	: CTestDevVideoCiuPlayStep(aTestName)

  1350 	{

  1351 	}

  1352 

  1353 CTestDevVideoCiuPlaySetClientPolicyExtension* CTestDevVideoCiuPlaySetClientPolicyExtension::NewL(const TDesC& aTestName)

  1354 	{

  1355 	CTestDevVideoCiuPlaySetClientPolicyExtension* self = new(ELeave) CTestDevVideoCiuPlaySetClientPolicyExtension(aTestName);

  1356 	return self;

  1357 	}

  1358 

  1359 TVerdict CTestDevVideoCiuPlaySetClientPolicyExtension::DoTestStepPreambleL()

  1360 	{

  1361 	// Call the base class first

  1362 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1363 

  1364 	if (ret == EPass)

  1365 		{

  1366 		// select decoder

  1367 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1368 

  1369 		if (err != KErrNone)

  1370 			{

  1371 			ret = EInconclusive;

  1372 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1373 			}

  1374 		}

  1375 

  1376 	return ret;

  1377 	}

  1378 

  1379 // Implementation that uses the test interface to set data that can be checked

  1380 // in the call to the interface's "get" method.

  1381 TVerdict CTestDevVideoCiuPlaySetClientPolicyExtension::DoTestL()

  1382 	{

  1383 	TVerdict ret = EFail;

  1384 

  1385 	// Got this far so must have successfully initialised DevVideoPlay

  1386 	// Try to fetch the CI...

  1387 	MMmfVideoHwDeviceVideoPolicyExtension* interface = NULL;

  1388 		

  1389 	interface = static_cast<MMmfVideoHwDeviceVideoPolicyExtension*>(iDevVideoPlay->CustomInterface(

  1390 																		iHwDeviceId, 

  1391 																		KUidMmfVideoHwDevVideoPolicyExtension));

  1392 	if (!interface)

  1393 		{

  1394 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1395 		ret = EInconclusive;

  1396 		}

  1397 	else

  1398 		{

  1399 		MMmfVideoHwDevClientNotifier* clientNotifier = this;

  1400 		// call the interface's method

  1401 		interface->MmvhvpeSetVideoClient(clientNotifier);

  1402 		

  1403 		// Now set up the test interface...

  1404 		MDevVideoCiuTestInterfaceClientResourceNotifier* testInterface = NULL;

  1405 		testInterface = static_cast<MDevVideoCiuTestInterfaceClientResourceNotifier*>

  1406 									(iDevVideoPlay->CustomInterface( iHwDeviceId,

  1407 																	KUidDevVideoCiuTestInterfaceClientResourceNotifier));

  1408 		if (testInterface)

  1409 			{

  1410 			if (testInterface->McrnVideoClient() == clientNotifier)

  1411 				{

  1412 				INFO_PRINTF1(_L("Succesfully set the client notifier."));

  1413 				ret = EPass;

  1414 				}

  1415 			else

  1416 				{

  1417 				ERR_PRINTF1(_L("Failed to set the client notifier."));

  1418 				}

  1419 			}

  1420 		else

  1421 			{

  1422 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1423 			ret = EInconclusive;

  1424 			}

  1425 		}

  1426 

  1427 	return ret;

  1428 	}

  1429 

  1430 // from MMmfVideoHwDevClientNotifier

  1431 void CTestDevVideoCiuPlaySetClientPolicyExtension::MmvhcnVideoAccessRevoked()

  1432 	{

  1433 	}

  1434 // from MMmfVideoHwDevClientNotifier	

  1435 void CTestDevVideoCiuPlaySetClientPolicyExtension::MmvhcnReleaseVideoResource()

  1436 	{

  1437 	}

  1438 //----------------------------------------------------------------------------

  1439 CTestDevVideoCiuPlaySetPriorityPolicyExtension::CTestDevVideoCiuPlaySetPriorityPolicyExtension(const TDesC& aTestName)

  1440 	: CTestDevVideoCiuPlayStep(aTestName)

  1441 	{

  1442 	}

  1443 

  1444 CTestDevVideoCiuPlaySetPriorityPolicyExtension* CTestDevVideoCiuPlaySetPriorityPolicyExtension::NewL(const TDesC& aTestName)

  1445 	{

  1446 	CTestDevVideoCiuPlaySetPriorityPolicyExtension* self = new(ELeave) CTestDevVideoCiuPlaySetPriorityPolicyExtension(aTestName);

  1447 	return self;

  1448 	}

  1449 

  1450 TVerdict CTestDevVideoCiuPlaySetPriorityPolicyExtension::DoTestStepPreambleL()

  1451 	{

  1452 	// Call the base class first

  1453 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1454 

  1455 	if (ret == EPass)

  1456 		{

  1457 		// select decoder

  1458 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1459 		

  1460 		if (err != KErrNone)

  1461 			{

  1462 			ret = EInconclusive;

  1463 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1464 			}

  1465 		}

  1466 	

  1467 	return ret;

  1468 	}

  1469 

  1470 TVerdict CTestDevVideoCiuPlaySetPriorityPolicyExtension::DoTestL()

  1471 	{

  1472 	TVerdict ret = EFail;

  1473 	

  1474 	INFO_PRINTF1(_L("DevVideo CIU Policy Extension Set Priority"));

  1475 

  1476 	// Try to fetch the CI...

  1477 	MMmfVideoHwDeviceVideoPolicyExtension* interface = NULL;

  1478 		

  1479 	interface = static_cast<MMmfVideoHwDeviceVideoPolicyExtension*>

  1480 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1481 																	KUidMmfVideoHwDevVideoPolicyExtension));

  1482 	if (!interface)

  1483 		{

  1484 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1485 		}

  1486 	else

  1487 		{

  1488 		TInt priority = 666;

  1489 		interface->MmvhvpeSetVideoPriority(priority);

  1490 		

  1491 		// Now set up the test interface...

  1492 		MDevVideoCiuTestInterfaceClientResourceNotifier* testInterface = NULL;

  1493 		testInterface = static_cast<MDevVideoCiuTestInterfaceClientResourceNotifier*>

  1494 									(iDevVideoPlay->CustomInterface( iHwDeviceId,

  1495 																	KUidDevVideoCiuTestInterfaceClientResourceNotifier));

  1496 		if (testInterface)

  1497 			{

  1498 			if (testInterface->McrnVideoPriority() == priority)

  1499 				{

  1500 				INFO_PRINTF1(_L("Succesfully retrieved the video priority."));

  1501 				ret = EPass;

  1502 				}

  1503 			else

  1504 				{

  1505 				ERR_PRINTF1(_L("Failed to retrieve the video priority."));

  1506 				}

  1507 			}

  1508 		else

  1509 			{

  1510 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1511 			ret = EInconclusive;

  1512 			}		

  1513 		}

  1514 	return ret;

  1515 	}

  1516 

  1517 //-------------------------------------------------------------------------

  1518 CTestDevVideoCiuPlayClientNotifierRevoked::CTestDevVideoCiuPlayClientNotifierRevoked(const TDesC& aTestName)

  1519 	: CTestDevVideoCiuPlayStep(aTestName)

  1520 	{

  1521 	}

  1522 

  1523 CTestDevVideoCiuPlayClientNotifierRevoked* CTestDevVideoCiuPlayClientNotifierRevoked::NewL(const TDesC& aTestName)

  1524 	{

  1525 	CTestDevVideoCiuPlayClientNotifierRevoked* self = new(ELeave) CTestDevVideoCiuPlayClientNotifierRevoked(aTestName);

  1526 	return self;

  1527 	}

  1528 

  1529 TVerdict CTestDevVideoCiuPlayClientNotifierRevoked::DoTestStepPreambleL()

  1530 	{

  1531 	// Call the base class first

  1532 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1533 

  1534 	if (ret == EPass)

  1535 		{

  1536 		// select decoder

  1537 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1538 

  1539 		if (err != KErrNone)

  1540 			{

  1541 			ret = EInconclusive;

  1542 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1543 			}

  1544 		}

  1545 	return ret;

  1546 	}

  1547 

  1548 // Implementation that uses the test interface to set data that can be checked

  1549 // in the call to the interface's "get" method.

  1550 TVerdict CTestDevVideoCiuPlayClientNotifierRevoked::DoTestL()

  1551 	{

  1552 	TVerdict ret = EFail;

  1553 

  1554 	// Got this far so must have successfully initialised DevVideoPlay

  1555 	// Try to fetch the CI...

  1556 	MMmfVideoHwDeviceVideoPolicyExtension* interface = NULL;

  1557 		

  1558 	interface = static_cast<MMmfVideoHwDeviceVideoPolicyExtension*>(iDevVideoPlay->CustomInterface(

  1559 																		iHwDeviceId, 

  1560 																		KUidMmfVideoHwDevVideoPolicyExtension));

  1561 	if (!interface)

  1562 		{

  1563 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1564 		ret = EInconclusive;

  1565 		}

  1566 	else

  1567 		{

  1568 		MMmfVideoHwDevClientNotifier* clientNotifier = this;

  1569 		// call the interface's method

  1570 		interface->MmvhvpeSetVideoClient(clientNotifier);

  1571 		

  1572 		// Now set up the test interface...

  1573 		MDevVideoCiuTestInterfaceClientResourceNotifier* testInterface = NULL;

  1574 		testInterface = static_cast<MDevVideoCiuTestInterfaceClientResourceNotifier*>

  1575 									(iDevVideoPlay->CustomInterface( iHwDeviceId,

  1576 																	KUidDevVideoCiuTestInterfaceClientResourceNotifier));

  1577 		if (testInterface)

  1578 			{

  1579 			INFO_PRINTF1(_L("Requesting the revoke callback."));

  1580 			testInterface->McrnRequestRevokeCallback();

  1581 			

  1582 			if (iCallback)

  1583 				{

  1584 				ret = EPass;

  1585 				}

  1586 			else

  1587 				{

  1588 				ERR_PRINTF1(_L("Didn't receive the revoke callback."));

  1589 				}

  1590 			}

  1591 		else

  1592 			{

  1593 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1594 			ret = EInconclusive;

  1595 			}

  1596 		}

  1597 

  1598 	return ret;

  1599 	}

  1600 

  1601 // from MMmfVideoHwDevClientNotifier

  1602 void CTestDevVideoCiuPlayClientNotifierRevoked::MmvhcnVideoAccessRevoked()

  1603 	{

  1604 	INFO_PRINTF1(_L("Access revoked callback received."));

  1605 	iCallback = ETrue;

  1606 	}

  1607 	

  1608 // from MMmfVideoHwDevClientNotifier	

  1609 void CTestDevVideoCiuPlayClientNotifierRevoked::MmvhcnReleaseVideoResource()

  1610 	{

  1611 	}

  1612 

  1613 //----------------------------------------------------------------------------------------

  1614 

  1615 CTestDevVideoCiuPlayClientNotifierResource::CTestDevVideoCiuPlayClientNotifierResource(const TDesC& aTestName)

  1616 	: CTestDevVideoCiuPlayStep(aTestName)

  1617 	{

  1618 	}

  1619 

  1620 CTestDevVideoCiuPlayClientNotifierResource* CTestDevVideoCiuPlayClientNotifierResource::NewL(const TDesC& aTestName)

  1621 	{

  1622 	CTestDevVideoCiuPlayClientNotifierResource* self = new(ELeave) CTestDevVideoCiuPlayClientNotifierResource(aTestName);

  1623 	return self;

  1624 	}

  1625 

  1626 TVerdict CTestDevVideoCiuPlayClientNotifierResource::DoTestStepPreambleL()

  1627 	{

  1628 	// Call the base class first

  1629 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1630 

  1631 	if (ret == EPass)

  1632 		{

  1633 		// select decoder

  1634 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1635 

  1636 		if (err != KErrNone)

  1637 			{

  1638 			ret = EInconclusive;

  1639 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1640 			}

  1641 		}

  1642 

  1643 	return ret;

  1644 	}

  1645 

  1646 // Implementation that uses the test interface to set data that can be checked

  1647 // in the call to the interface's "get" method.

  1648 TVerdict CTestDevVideoCiuPlayClientNotifierResource::DoTestL()

  1649 	{

  1650 	TVerdict ret = EFail;

  1651 

  1652 	// Got this far so must have successfully initialised DevVideoPlay

  1653 	// Try to fetch the CI...

  1654 	MMmfVideoHwDeviceVideoPolicyExtension* interface = NULL;

  1655 		

  1656 	interface = static_cast<MMmfVideoHwDeviceVideoPolicyExtension*>(iDevVideoPlay->CustomInterface(

  1657 																		iHwDeviceId, 

  1658 																		KUidMmfVideoHwDevVideoPolicyExtension));

  1659 	if (!interface)

  1660 		{

  1661 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1662 		ret = EInconclusive;

  1663 		}

  1664 	else

  1665 		{

  1666 		MMmfVideoHwDevClientNotifier* clientNotifier = this;

  1667 		// call the interface's method

  1668 		interface->MmvhvpeSetVideoClient(clientNotifier);

  1669 		

  1670 		// Now set up the test interface...

  1671 		MDevVideoCiuTestInterfaceClientResourceNotifier* testInterface = NULL;

  1672 		testInterface = static_cast<MDevVideoCiuTestInterfaceClientResourceNotifier*>

  1673 									(iDevVideoPlay->CustomInterface( iHwDeviceId,

  1674 																	KUidDevVideoCiuTestInterfaceClientResourceNotifier));

  1675 		if (testInterface)

  1676 			{

  1677 			INFO_PRINTF1(_L("Requesting the resource callback."));

  1678 			testInterface->McrnRequestResourceCallback();

  1679 			

  1680 			if (iCallback)

  1681 				{

  1682 				ret = EPass;

  1683 				}

  1684 			else

  1685 				{

  1686 				ERR_PRINTF1(_L("Didn't receive the resource callback."));

  1687 				}

  1688 			}

  1689 		else

  1690 			{

  1691 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1692 			ret = EInconclusive;

  1693 			}

  1694 		}

  1695 

  1696 	return ret;

  1697 	}

  1698 

  1699 // from MMmfVideoHwDevClientNotifier

  1700 void CTestDevVideoCiuPlayClientNotifierResource::MmvhcnVideoAccessRevoked()

  1701 	{

  1702 	}

  1703 

  1704 // from MMmfVideoHwDevClientNotifier	

  1705 void CTestDevVideoCiuPlayClientNotifierResource::MmvhcnReleaseVideoResource()

  1706 	{

  1707 	INFO_PRINTF1(_L("Release video resource callback received."));

  1708 	iCallback = ETrue;

  1709 	}

  1710 //----------------------------------------------------------------------------------------

  1711 

  1712 //------------------------------------------------------------------

  1713 //			Negative Tests

  1714 //------------------------------------------------------------------

  1715 

  1716 CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder

  1717 	::CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder(const TDesC& aTestName)

  1718 	:CTestDevVideoCiuPlayStep(aTestName)

  1719 	{

  1720 	}

  1721 

  1722 CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder* 

  1723 CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder::NewL(const TDesC& aTestName)

  1724 	{

  1725 	CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder* self = 

  1726 									new(ELeave) CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder(aTestName);

  1727 	return self;

  1728 	}

  1729 

  1730 TVerdict CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder::DoTestStepPreambleL()

  1731 	{

  1732 	// Call the base class first

  1733 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1734 

  1735 	if (ret == EPass)

  1736 		{

  1737 		// select the decoder

  1738 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1739 		

  1740 		if (err != KErrNone)

  1741 			{

  1742 			ret = EInconclusive;

  1743 			ERR_PRINTF1(_L("DevVideo Play Failed to select the Decoder."));

  1744 			}

  1745 		}

  1746 	return ret;

  1747 	}

  1748 

  1749 TVerdict CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder::DoTestL()

  1750 	{

  1751 	TVerdict ret = EPass;

  1752 

  1753 	INFO_PRINTF1(_L("DevVideo CIU Video Media Protected Creation Failure from Decoder"));

  1754 

  1755 	// Got this far so must have successfully initialised DevVideoPlay

  1756 	// Try to fetch the CI...

  1757 	MMmfVideoMediaProtected* interface = NULL;

  1758 	interface = static_cast<MMmfVideoMediaProtected*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1759 																					KUidMmfVideoMediaProtected));

  1760 	if (!interface)

  1761 		{

  1762 		INFO_PRINTF1(_L("No interface retrieved"));

  1763 		}

  1764 	else

  1765 		{

  1766 		ERR_PRINTF1(_L("Error! An interface was retrieved"));

  1767 		ret = EFail;

  1768 		}

  1769 

  1770 	return ret;

  1771 	}

  1772 //------------------------------------------------------------------

  1773 

  1774 

  1775 #ifdef SYMBIAN_BUILD_GCE

  1776 

  1777 //

  1778 //	Video Surface Support Management Tests

  1779 //

  1780 CTestDevVideoCiuPlayGetAndSetUseSurface::CTestDevVideoCiuPlayGetAndSetUseSurface(const TDesC& aTestName)

  1781 	:CTestDevVideoCiuPlayStep(aTestName)

  1782 	{

  1783 	}

  1784 

  1785 CTestDevVideoCiuPlayGetAndSetUseSurface* CTestDevVideoCiuPlayGetAndSetUseSurface::NewL(const TDesC& aTestName)

  1786 	{

  1787 	CTestDevVideoCiuPlayGetAndSetUseSurface* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetUseSurface(aTestName);

  1788 	return self;

  1789 	}

  1790 

  1791 TVerdict CTestDevVideoCiuPlayGetAndSetUseSurface::DoTestStepPreambleL()

  1792 	{

  1793 	// Call the base class first

  1794 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1795 	if (ret == EPass)

  1796 		{

  1797 		// select decoder

  1798 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1799 		

  1800 		if (err != KErrNone)

  1801 			{

  1802 			ret = EInconclusive;

  1803 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1804 			}

  1805 		}

  1806 	return ret;

  1807 	}

  1808 

  1809 TVerdict CTestDevVideoCiuPlayGetAndSetUseSurface::DoTestL()

  1810 	{

  1811 	TVerdict ret = EFail;

  1812 	

  1813 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  1814 	

  1815 	// Fetch the CI

  1816 	MMMFVideoSurfaceSupport* interface = NULL;

  1817 		

  1818 	interface = static_cast<MMMFVideoSurfaceSupport*>

  1819 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1820 											KUidMMFVideoSurfaceSupport));

  1821 	if (!interface)

  1822 		{

  1823 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1824 		ret = EFail;

  1825 		}

  1826 	else

  1827 		{

  1828 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  1829 		

  1830 		TBool useSurface = ETrue; 

  1831 		interface->MmvssUseSurfaces();

  1832 		

  1833 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  1834 

  1835 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>

  1836 										(iDevVideoPlay->CustomInterface(iHwDeviceId, 

  1837 											KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  1838 		if (testInterface)

  1839 			{

  1840 			TBool useSurfaceResult = testInterface->MdvssUseSurface();

  1841 			if (useSurface == useSurfaceResult)

  1842 				{

  1843 				ret = EPass;

  1844 				INFO_PRINTF1(_L("Use Surface call performed as expected"));

  1845 				}

  1846 			else

  1847 				{

  1848 				ret = EFail;					

  1849 				ERR_PRINTF2(_L("Use Surface call failed. Expected: %d"),useSurface);

  1850 				ERR_PRINTF2(_L("Result: %d"),useSurfaceResult);

  1851 				}

  1852 			}

  1853 		else

  1854 			{

  1855 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1856 			ret = EInconclusive;

  1857 			}

  1858 		}

  1859 	return ret;

  1860 	}

  1861 	

  1862 //-----------------------------------------------------------//

  1863 CTestDevVideoCiuPlayGetAndSetSurfaceParameters::CTestDevVideoCiuPlayGetAndSetSurfaceParameters(const TDesC& aTestName)

  1864 	:CTestDevVideoCiuPlayStep(aTestName)

  1865 	{

  1866 	}

  1867 

  1868 CTestDevVideoCiuPlayGetAndSetSurfaceParameters* CTestDevVideoCiuPlayGetAndSetSurfaceParameters::NewL(const TDesC& aTestName)

  1869 	{

  1870 	CTestDevVideoCiuPlayGetAndSetSurfaceParameters* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetSurfaceParameters(aTestName);

  1871 	return self;

  1872 	}

  1873 

  1874 TVerdict CTestDevVideoCiuPlayGetAndSetSurfaceParameters::DoTestStepPreambleL()

  1875 	{

  1876 	// Call the base class first

  1877 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1878 	if (ret == EPass)

  1879 		{

  1880 		// select decoder

  1881 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1882 		

  1883 		if (err != KErrNone)

  1884 			{

  1885 			ret = EInconclusive;

  1886 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1887 			}

  1888 		}

  1889 	return ret;

  1890 	}

  1891 

  1892 TVerdict CTestDevVideoCiuPlayGetAndSetSurfaceParameters::DoTestL()

  1893 	{

  1894 	TVerdict ret = EFail;

  1895 	

  1896 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  1897 	

  1898 	// Fetch the CI

  1899 	MMMFVideoSurfaceSupport* interface = NULL;

  1900 		

  1901 	interface = static_cast<MMMFVideoSurfaceSupport*>

  1902 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  1903 											KUidMMFVideoSurfaceSupport));

  1904 	if (!interface)

  1905 		{

  1906 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  1907 		ret = EFail;

  1908 		}

  1909 	else

  1910 		{

  1911 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  1912 		

  1913 		TSurfaceId surfaceId;

  1914 		TRect getRect;

  1915 		TVideoAspectRatio par;

  1916 		interface->MmvssGetSurfaceParametersL(surfaceId, getRect, par);

  1917 						

  1918 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  1919 

  1920 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>

  1921 										(iDevVideoPlay->CustomInterface(iHwDeviceId, 

  1922 											KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  1923 		if (testInterface)

  1924 			{

  1925 			TMMFVideoSurfaceConfig vsconfResult = testInterface->MdvssSurfaceParameters();

  1926 			

  1927 			if (vsconfResult.iSurfaceId == surfaceId && vsconfResult.iCropRectangle.iTl.iX == getRect.iTl.iX &&

  1928 			vsconfResult.iCropRectangle.iTl.iY == getRect.iTl.iY && vsconfResult.iCropRectangle.iBr.iX == getRect.iBr.iX && 

  1929 			vsconfResult.iCropRectangle.iBr.iY == getRect.iBr.iY &&

  1930 			vsconfResult.iPixelAspectRatio.iNumerator == par.iNumerator && 

  1931 			vsconfResult.iPixelAspectRatio.iDenominator == par.iDenominator)

  1932 				{

  1933 				ret = EPass;

  1934 				INFO_PRINTF1(_L("Get Surface Parameters method call performed as expected"));

  1935 				}

  1936 			else

  1937 				{

  1938 				ret = EFail;					

  1939 				ERR_PRINTF1(_L("Get Surface Parameters method call failed"));

  1940 				INFO_PRINTF5(_L("Expected surfaceId %d %d %d %d"),

  1941 								vsconfResult.iSurfaceId.iInternal[0], vsconfResult.iSurfaceId.iInternal[1],

  1942 								vsconfResult.iSurfaceId.iInternal[2], vsconfResult.iSurfaceId.iInternal[3]);

  1943 				INFO_PRINTF5(_L("surfaceId Available %d %d %d %d"),

  1944 								surfaceId.iInternal[0], surfaceId.iInternal[1], 

  1945 								surfaceId.iInternal[2], surfaceId.iInternal[3]);

  1946 				INFO_PRINTF2(_L("Expected Rect first %d"),vsconfResult.iCropRectangle.iTl.iX);

  1947 				INFO_PRINTF2(_L("Rect first Available %d"),getRect.iTl.iX);

  1948 				INFO_PRINTF2(_L("Expected Rect second %d"),vsconfResult.iCropRectangle.iTl.iY);

  1949 				INFO_PRINTF2(_L("Rect second Available %d"),getRect.iTl.iY);

  1950 				INFO_PRINTF2(_L("Expected Rect third %d"),vsconfResult.iCropRectangle.iBr.iX);

  1951 	

  1952 				INFO_PRINTF2(_L("Rect third Available %d"),getRect.iBr.iX);

  1953 				INFO_PRINTF2(_L("Expected Rect fourth %d"),vsconfResult.iCropRectangle.iBr.iY);

  1954 				INFO_PRINTF2(_L("Rect fourth Available %d"),getRect.iBr.iY);

  1955 				INFO_PRINTF2(_L("Expected TVideoAspectRatio iNumerator %d"),vsconfResult.iPixelAspectRatio.iNumerator);

  1956 				INFO_PRINTF2(_L("TVideoAspectRatio iNumerator Available %d"),par.iNumerator);

  1957 				INFO_PRINTF2(_L("Expected TVideoAspectRatio iDenominator %d"),vsconfResult.iPixelAspectRatio.iDenominator);

  1958 				INFO_PRINTF2(_L("TVideoAspectRatio iDenominator Available %d"),par.iDenominator);

  1959 

  1960 				}

  1961 			}

  1962 		else

  1963 			{

  1964 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  1965 			ret = EInconclusive;

  1966 			}

  1967 		}

  1968 	return ret;

  1969 	}

  1970 	

  1971 //-----------------------------------------------------------//

  1972 CTestDevVideoCiuPlayGetAndSetSurfaceRemoved::CTestDevVideoCiuPlayGetAndSetSurfaceRemoved(const TDesC& aTestName)

  1973 	:CTestDevVideoCiuPlayStep(aTestName)

  1974 	{

  1975 	}

  1976 

  1977 CTestDevVideoCiuPlayGetAndSetSurfaceRemoved* CTestDevVideoCiuPlayGetAndSetSurfaceRemoved::NewL(const TDesC& aTestName)

  1978 	{

  1979 	CTestDevVideoCiuPlayGetAndSetSurfaceRemoved* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetSurfaceRemoved(aTestName);

  1980 	return self;

  1981 	}

  1982 

  1983 TVerdict CTestDevVideoCiuPlayGetAndSetSurfaceRemoved::DoTestStepPreambleL()

  1984 	{

  1985 	// Call the base class first

  1986 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  1987 	if (ret == EPass)

  1988 		{

  1989 		// select decoder

  1990 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  1991 		

  1992 		if (err != KErrNone)

  1993 			{

  1994 			ret = EInconclusive;

  1995 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  1996 			}

  1997 		}

  1998 	return ret;

  1999 	}

  2000 

  2001 TVerdict CTestDevVideoCiuPlayGetAndSetSurfaceRemoved::DoTestL()

  2002 	{

  2003 	TVerdict ret = EFail;

  2004 	

  2005 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  2006 	

  2007 	// Fetch the CI

  2008 	MMMFVideoSurfaceSupport* interface = NULL;

  2009 		

  2010 	interface = static_cast<MMMFVideoSurfaceSupport*>

  2011 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2012 											KUidMMFVideoSurfaceSupport));

  2013 	if (!interface)

  2014 		{

  2015 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2016 		ret = EFail;

  2017 		}

  2018 	else

  2019 		{

  2020 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  2021 		

  2022 		// these values can be anything

  2023 		TSurfaceId surfaceId;

  2024 		surfaceId.iInternal[0] = 37;

  2025 		surfaceId.iInternal[1] = 104;

  2026 		surfaceId.iInternal[2] = 118;

  2027 		surfaceId.iInternal[3] = 1045;

  2028 		

  2029 		interface->MmvssSurfaceRemovedL(surfaceId);

  2030 		

  2031 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  2032 

  2033 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>

  2034 										(iDevVideoPlay->CustomInterface(iHwDeviceId, 

  2035 											KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  2036 		if (testInterface)

  2037 			{

  2038 			TSurfaceId surfaceIdResult = testInterface->MdvssSurfaceRemoved();

  2039 			if (surfaceId == surfaceIdResult)

  2040 				{

  2041 				ret = EPass;

  2042 				INFO_PRINTF1(_L("Surface Removed method call performed as expected"));

  2043 				}

  2044 			else

  2045 				{

  2046 				ret = EFail;					

  2047 				ERR_PRINTF1(_L("Surface Removed method call failed."));

  2048 				INFO_PRINTF5(_L("Expected surfaceId %d %d %d %d"),

  2049 							surfaceId.iInternal[0], surfaceId.iInternal[1],

  2050 							surfaceId.iInternal[2], surfaceId.iInternal[3]);

  2051 				INFO_PRINTF5(_L("surfaceId Available %d %d %d %d"),

  2052 							surfaceIdResult.iInternal[0], surfaceIdResult.iInternal[1], 

  2053 							surfaceIdResult.iInternal[2], surfaceIdResult.iInternal[3]);

  2054 				}

  2055 			}

  2056 		else

  2057 			{

  2058 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  2059 			ret = EInconclusive;

  2060 			}

  2061 		}

  2062 	return ret;

  2063 	}

  2064 	

  2065 //-----------------------------------------------------------//

  2066 CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver(const TDesC& aTestName)

  2067 	:CTestDevVideoCiuPlayStep(aTestName)

  2068 	{

  2069 	}

  2070 

  2071 CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver* CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::NewL(const TDesC& aTestName)

  2072 	{

  2073 	CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver* self = new(ELeave) CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver(aTestName);

  2074 	return self;

  2075 	}

  2076 

  2077 TVerdict CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::DoTestStepPreambleL()

  2078 	{

  2079 	// Call the base class first

  2080 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2081 	if (ret == EPass)

  2082 		{

  2083 		// select decoder

  2084 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2085 		

  2086 		if (err != KErrNone)

  2087 			{

  2088 			ret = EInconclusive;

  2089 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2090 			}

  2091 		}

  2092 	return ret;

  2093 	}

  2094 

  2095 TVerdict CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::DoTestL()

  2096 	{

  2097 	TVerdict ret = EFail;

  2098 	

  2099 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  2100 	

  2101 	// Fetch the CI

  2102 	MMMFVideoSurfaceSupport* interface = NULL;

  2103 		

  2104 	interface = static_cast<MMMFVideoSurfaceSupport*>

  2105 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2106 																	KUidMMFVideoSurfaceSupport));

  2107 	if (!interface)

  2108 		{

  2109 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2110 		ret = EFail;

  2111 		}

  2112 	else

  2113 		{

  2114 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  2115 	

  2116 		MMMFVideoSurfaceObserver* obs = this;

  2117 		interface->MmvssSetObserver(*obs);

  2118 		INFO_PRINTF1(_L("MmvssSetObserver called"));

  2119 		

  2120 		// Verify that the observer was set

  2121 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  2122 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2123 															KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  2124 		if (!testInterface)

  2125 			{

  2126 			ERR_PRINTF1(_L("Failed to create the test interface."));

  2127 			ret = EFail;

  2128 			}

  2129 		else

  2130 			{

  2131 			if (obs != testInterface->MvsoObserver())

  2132 				{

  2133 				ERR_PRINTF1(_L("Failed to set the observer."));

  2134 				ret = EFail;

  2135 				}

  2136 			else

  2137 				{			

  2138 				INFO_PRINTF1(_L("SetObserver successfully called"));

  2139 				ret = EPass;

  2140 				}

  2141 			}		

  2142 		}

  2143 	return ret;

  2144 	}

  2145 

  2146 //from MMMFVideoSurfaceObserver

  2147 void CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::MmvsoSurfaceCreated()

  2148 	{}

  2149 		

  2150 void CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::MmvsoSurfaceParametersChanged()

  2151 	{}

  2152 

  2153 void CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver::MmvsoRemoveSurface()

  2154 	{}

  2155 	

  2156 //------------------------------------------------------------------

  2157 

  2158 CTestDevVideoCiuPlaySurfaceCreated::CTestDevVideoCiuPlaySurfaceCreated(const TDesC& aTestName)

  2159 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

  2160 	{

  2161 	}

  2162 

  2163 CTestDevVideoCiuPlaySurfaceCreated* CTestDevVideoCiuPlaySurfaceCreated::NewL(const TDesC& aTestName)

  2164 	{

  2165 	CTestDevVideoCiuPlaySurfaceCreated* self = new(ELeave) CTestDevVideoCiuPlaySurfaceCreated(aTestName);

  2166 	return self;

  2167 	}

  2168 

  2169 TVerdict CTestDevVideoCiuPlaySurfaceCreated::DoTestStepPreambleL()

  2170 	{

  2171 	// Call the base class first

  2172 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2173 	if (ret == EPass)

  2174 		{

  2175 		// select decoder

  2176 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2177 		

  2178 		if (err != KErrNone)

  2179 			{

  2180 			ret = EInconclusive;

  2181 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2182 			}

  2183 		}

  2184 	return ret;

  2185 	}

  2186 

  2187 TVerdict CTestDevVideoCiuPlaySurfaceCreated::DoTestL()

  2188 	{

  2189 	TVerdict ret = EFail;

  2190 	

  2191 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  2192 	

  2193 	// Fetch the CI

  2194 	MMMFVideoSurfaceSupport* interface = NULL;

  2195 		

  2196 	interface = static_cast<MMMFVideoSurfaceSupport*>

  2197 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2198 																	KUidMMFVideoSurfaceSupport));

  2199 	if (!interface)

  2200 		{

  2201 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2202 		ret = EFail;

  2203 		}

  2204 	else

  2205 		{

  2206 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  2207 	

  2208 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  2209 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2210 															KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  2211 		if (!testInterface)

  2212 			{

  2213 			ERR_PRINTF1(_L("Failed to create the test interface."));

  2214 			ret = EFail;

  2215 			}

  2216 		else

  2217 			{

  2218 			// Set the observer to callback!

  2219 			MMMFVideoSurfaceObserver* obs = this;

  2220 			interface->MmvssSetObserver(*obs);

  2221 		

  2222 			INFO_PRINTF1(_L("Requesting the surface created Callback..."));

  2223 			testInterface->MmvsoSurfaceCreatedCallback();

  2224 

  2225 			if ((iError != KErrNone) || (!iCallbackReceived))

  2226 				{	

  2227 				ERR_PRINTF1(_L("Error receiving the Surface Created Callback."));

  2228 				ret = EFail;

  2229 				}

  2230 			else

  2231 				{

  2232 				INFO_PRINTF1(_L("Successfully retrieved the Surface Support Callback"));

  2233 				ret = EPass;

  2234 				}

  2235 			}

  2236 		}

  2237 	return ret;

  2238 	}

  2239 

  2240 //from MMMFVideoSurfaceObserver

  2241 void CTestDevVideoCiuPlaySurfaceCreated::MmvsoSurfaceCreated()

  2242 	{

  2243 	INFO_PRINTF1(_L("Surface Support callback received."));

  2244 	iCallbackReceived = ETrue;

  2245 	iError = KErrNone;

  2246 	}

  2247 		

  2248 void CTestDevVideoCiuPlaySurfaceCreated::MmvsoSurfaceParametersChanged()

  2249 	{

  2250 	iError = KErrNotSupported;

  2251 	}

  2252 void CTestDevVideoCiuPlaySurfaceCreated::MmvsoRemoveSurface()

  2253 	{

  2254 	iError = KErrNotSupported;

  2255 	}

  2256 

  2257 //------------------------------------------------------------------

  2258 

  2259 CTestDevVideoCiuPlaySurfaceParametersChanged::CTestDevVideoCiuPlaySurfaceParametersChanged(const TDesC& aTestName)

  2260 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

  2261 	{

  2262 	}

  2263 

  2264 CTestDevVideoCiuPlaySurfaceParametersChanged* CTestDevVideoCiuPlaySurfaceParametersChanged::NewL(const TDesC& aTestName)

  2265 	{

  2266 	CTestDevVideoCiuPlaySurfaceParametersChanged* self = new(ELeave) CTestDevVideoCiuPlaySurfaceParametersChanged(aTestName);

  2267 	return self;

  2268 	}

  2269 

  2270 TVerdict CTestDevVideoCiuPlaySurfaceParametersChanged::DoTestStepPreambleL()

  2271 	{

  2272 	// Call the base class first

  2273 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2274 	if (ret == EPass)

  2275 		{

  2276 		// select decoder

  2277 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2278 		

  2279 		if (err != KErrNone)

  2280 			{

  2281 			ret = EInconclusive;

  2282 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2283 			}

  2284 		}

  2285 	return ret;

  2286 	}

  2287 

  2288 TVerdict CTestDevVideoCiuPlaySurfaceParametersChanged::DoTestL()

  2289 	{

  2290 	TVerdict ret = EFail;

  2291 	

  2292 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  2293 	

  2294 	// Fetch the CI

  2295 	MMMFVideoSurfaceSupport* interface = NULL;

  2296 		

  2297 	interface = static_cast<MMMFVideoSurfaceSupport*>

  2298 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2299 																	KUidMMFVideoSurfaceSupport));

  2300 	if (!interface)

  2301 		{

  2302 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2303 		ret = EFail;

  2304 		}

  2305 	else

  2306 		{

  2307 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  2308 	

  2309 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  2310 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2311 															KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  2312 		if (!testInterface)

  2313 			{

  2314 			ERR_PRINTF1(_L("Failed to create the test interface."));

  2315 			ret = EFail;

  2316 			}

  2317 		else

  2318 			{

  2319 			// Set the observer to callback!

  2320 			MMMFVideoSurfaceObserver* obs = this;

  2321 			interface->MmvssSetObserver(*obs);

  2322 		

  2323 			INFO_PRINTF1(_L("Requesting the Surface Parameters Changed Callback..."));

  2324 			testInterface->MmvsoSurfaceParametersChangedCallback();

  2325 

  2326 			if ((iError != KErrNone) || (!iCallbackReceived))

  2327 				{	

  2328 				ERR_PRINTF1(_L("Error receiving Surface Parameters Changed Callback."));

  2329 				ret = EFail;

  2330 				}

  2331 			else

  2332 				{

  2333 				INFO_PRINTF1(_L("Successfully retrieved Surface Parameters Changed Callback"));

  2334 				ret = EPass;

  2335 				}

  2336 			}

  2337 		}

  2338 	return ret;

  2339 	}

  2340 

  2341 //from MMMFVideoSurfaceObserver

  2342 void CTestDevVideoCiuPlaySurfaceParametersChanged::MmvsoSurfaceCreated()

  2343 	{

  2344 	iError = KErrNotSupported;

  2345 	}

  2346 		

  2347 void CTestDevVideoCiuPlaySurfaceParametersChanged::MmvsoSurfaceParametersChanged()

  2348 	{

  2349 	INFO_PRINTF1(_L("Surface Parameters Changed callback received."));

  2350 	iCallbackReceived = ETrue;

  2351 	iError = KErrNone;

  2352 	}

  2353 	

  2354 void CTestDevVideoCiuPlaySurfaceParametersChanged::MmvsoRemoveSurface()

  2355 	{

  2356 	iError = KErrNotSupported;

  2357 	}

  2358 

  2359 //------------------------------------------------------------------

  2360 

  2361 CTestDevVideoCiuRemoveSurface::CTestDevVideoCiuRemoveSurface(const TDesC& aTestName)

  2362 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

  2363 	{

  2364 	}

  2365 

  2366 CTestDevVideoCiuRemoveSurface* CTestDevVideoCiuRemoveSurface::NewL(const TDesC& aTestName)

  2367 	{

  2368 	CTestDevVideoCiuRemoveSurface* self = new(ELeave) CTestDevVideoCiuRemoveSurface(aTestName);

  2369 	return self;

  2370 	}

  2371 

  2372 TVerdict CTestDevVideoCiuRemoveSurface::DoTestStepPreambleL()

  2373 	{

  2374 	// Call the base class first

  2375 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2376 	if (ret == EPass)

  2377 		{

  2378 		// select decoder

  2379 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2380 		

  2381 		if (err != KErrNone)

  2382 			{

  2383 			ret = EInconclusive;

  2384 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2385 			}

  2386 		}

  2387 	return ret;

  2388 	}

  2389 

  2390 TVerdict CTestDevVideoCiuRemoveSurface::DoTestL()

  2391 	{

  2392 	TVerdict ret = EFail;

  2393 	

  2394 	INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Initialisation"));

  2395 	

  2396 	// Fetch the CI

  2397 	MMMFVideoSurfaceSupport* interface = NULL;

  2398 		

  2399 	interface = static_cast<MMMFVideoSurfaceSupport*>

  2400 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2401 																	KUidMMFVideoSurfaceSupport));

  2402 	if (!interface)

  2403 		{

  2404 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2405 		ret = EFail;

  2406 		}

  2407 	else

  2408 		{

  2409 		INFO_PRINTF1(_L("DevVideo CIU Surface Support Interface Instantiated"));

  2410 	

  2411 		MDevVideoCiuTestInterfaceVideoSurfaceSupport* testInterface = NULL;

  2412 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoSurfaceSupport*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2413 															KUidDevVideoCiuTestInterfaceVideoSurfaceSupport));

  2414 		if (!testInterface)

  2415 			{

  2416 			ERR_PRINTF1(_L("Failed to create the test interface."));

  2417 			ret = EFail;

  2418 			}

  2419 		else

  2420 			{

  2421 			// Set the observer to callback!

  2422 			MMMFVideoSurfaceObserver* obs = this;

  2423 			interface->MmvssSetObserver(*obs);

  2424 		

  2425 			INFO_PRINTF1(_L("Requesting Remove Surface Callback..."));

  2426 			testInterface->MmvsoRemoveSurfaceCallback();

  2427 

  2428 			if ((iError != KErrNone) || (!iCallbackReceived))

  2429 				{	

  2430 				ERR_PRINTF1(_L("Error receiving Remove Surface Callback."));

  2431 				ret = EFail;

  2432 				}

  2433 			else

  2434 				{

  2435 				INFO_PRINTF1(_L("Successfully retrieved Remove Surface Callback"));

  2436 				ret = EPass;

  2437 				}

  2438 			}

  2439 		}

  2440 	return ret;

  2441 	}

  2442 

  2443 //from MMMFVideoSurfaceObserver

  2444 void CTestDevVideoCiuRemoveSurface::MmvsoSurfaceCreated()

  2445 	{

  2446 	iError = KErrNotSupported;

  2447 	}

  2448 		

  2449 void CTestDevVideoCiuRemoveSurface::MmvsoSurfaceParametersChanged()

  2450 	{

  2451 	iError = KErrNotSupported;

  2452 	}

  2453 	

  2454 void CTestDevVideoCiuRemoveSurface::MmvsoRemoveSurface()

  2455 	{

  2456 	INFO_PRINTF1(_L("Remove Surface callback received."));

  2457 	iCallbackReceived = ETrue;

  2458 	iError = KErrNone;

  2459 	}

  2460 

  2461 //----------------------------------------------------------------------------

  2462 CTestDevVideoCiuPlayUseClientBuffers::CTestDevVideoCiuPlayUseClientBuffers(const TDesC& aTestName)

  2463 	: CTestDevVideoCiuPlayStep(aTestName)

  2464 	{

  2465 	}

  2466 

  2467 CTestDevVideoCiuPlayUseClientBuffers* CTestDevVideoCiuPlayUseClientBuffers::NewL(const TDesC& aTestName)

  2468 	{

  2469 	CTestDevVideoCiuPlayUseClientBuffers* self = new(ELeave) CTestDevVideoCiuPlayUseClientBuffers(aTestName);

  2470 	return self;

  2471 	}

  2472 

  2473 TVerdict CTestDevVideoCiuPlayUseClientBuffers::DoTestStepPreambleL()

  2474 	{

  2475 	// Call the base class first

  2476 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2477 

  2478 	if (ret == EPass)

  2479 		{

  2480 		// select decoder

  2481 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2482 		

  2483 		if (err != KErrNone)

  2484 			{

  2485 			ret = EInconclusive;

  2486 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2487 			}

  2488 		}

  2489 	

  2490 	return ret;

  2491 	}

  2492 

  2493 TVerdict CTestDevVideoCiuPlayUseClientBuffers::DoTestL()

  2494 	{

  2495 	TVerdict ret = EFail;

  2496 	

  2497 	INFO_PRINTF1(_L("DevVideo CIU use client buffer mode test"));

  2498 

  2499 	// Try to fetch the CI...

  2500 	MMMFVideoClientBufferSupport* interface = NULL;

  2501 		

  2502 	interface = static_cast<MMMFVideoClientBufferSupport*>

  2503 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2504 																	KUidMMFVideoClientBufferSupport));

  2505 	if (!interface)

  2506 		{

  2507 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2508 		}

  2509 	else

  2510 		{

  2511 		TBool clientBuffers = ETrue;

  2512 		interface->MvcbsUseClientBuffers(clientBuffers);

  2513 		

  2514 		// Now set up the test interface...

  2515 		MDevVideoCiuTestInterfaceVideoClientBufferSupport* testInterface = NULL;

  2516 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoClientBufferSupport*>

  2517 							(iDevVideoPlay->CustomInterface( iHwDeviceId,

  2518 									KUidDevVideoCiuTestInterfaceVideoClientBufferSupport));

  2519 		if (testInterface)

  2520 			{

  2521 			if (testInterface->MdvcbsClientBuffers())

  2522 				{

  2523 				INFO_PRINTF1(_L("Succesfully retrieved the video client buffer mode"));

  2524 				ret = EPass;

  2525 				}

  2526 			else

  2527 				{

  2528 				ERR_PRINTF1(_L("Failed to retrieve the video client buffer mode."));

  2529 				}

  2530 			}

  2531 		else

  2532 			{

  2533 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  2534 			ret = EInconclusive;

  2535 			}		

  2536 		}

  2537 	return ret;

  2538 	}

  2539 

  2540 //----------------------------------------------------------------------------

  2541 CTestDevVideoCiuPlaySupplyBuffer::CTestDevVideoCiuPlaySupplyBuffer(const TDesC& aTestName)

  2542 	: CTestDevVideoCiuPlayStep(aTestName)

  2543 	{

  2544 	}

  2545 

  2546 CTestDevVideoCiuPlaySupplyBuffer* CTestDevVideoCiuPlaySupplyBuffer::NewL(const TDesC& aTestName)

  2547 	{

  2548 	CTestDevVideoCiuPlaySupplyBuffer* self = new(ELeave) CTestDevVideoCiuPlaySupplyBuffer(aTestName);

  2549 	return self;

  2550 	}

  2551 

  2552 TVerdict CTestDevVideoCiuPlaySupplyBuffer::DoTestStepPreambleL()

  2553 	{

  2554 	// Call the base class first

  2555 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2556 

  2557 	if (ret == EPass)

  2558 		{

  2559 		// select decoder

  2560 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2561 		

  2562 		if (err != KErrNone)

  2563 			{

  2564 			ret = EInconclusive;

  2565 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2566 			}

  2567 		}

  2568 	

  2569 	return ret;

  2570 	}

  2571 

  2572 TVerdict CTestDevVideoCiuPlaySupplyBuffer::DoTestL()

  2573 	{

  2574 	TVerdict ret = EFail;

  2575 	

  2576 	INFO_PRINTF1(_L("DevVideo CIU supply buffer test"));

  2577 

  2578 	// Try to fetch the CI...

  2579 	MMMFVideoClientBufferSupport* interface = NULL;

  2580 		

  2581 	interface = static_cast<MMMFVideoClientBufferSupport*>

  2582 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2583 																	KUidMMFVideoClientBufferSupport));

  2584 	if (!interface)

  2585 		{

  2586 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2587 		}

  2588 	else

  2589 		{

  2590 		TUncompressedVideoFormat format;

  2591 		format.iDataFormat = ERgbRawData;

  2592 		format.iRgbFormat = ERgb32bit888;		

  2593 		RChunk aChunk;

  2594 

  2595 		// Create a dummy object for testing only

  2596 		TVideoFrameBuffer buffer(format, 1, 1, aChunk, 0);

  2597 		interface->MvcbsSupplyBuffer(buffer);

  2598 		

  2599 		// Now set up the test interface...

  2600 		MDevVideoCiuTestInterfaceVideoClientBufferSupport* testInterface = NULL;

  2601 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoClientBufferSupport*>

  2602 							(iDevVideoPlay->CustomInterface( iHwDeviceId,

  2603 									KUidDevVideoCiuTestInterfaceVideoClientBufferSupport));

  2604 		if (testInterface)

  2605 			{

  2606 			if (testInterface->MdvcbsSupplyBuffer() == &buffer)

  2607 				{

  2608 				INFO_PRINTF1(_L("Succesfully retrieved the video supplied buffer"));

  2609 				ret = EPass;

  2610 				}

  2611 			else

  2612 				{

  2613 				ERR_PRINTF1(_L("Failed to retrieve the video supplied buffer."));

  2614 				}

  2615 			}

  2616 		else

  2617 			{

  2618 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  2619 			ret = EInconclusive;

  2620 			}		

  2621 		}

  2622 	return ret;

  2623 	}

  2624 	

  2625 //----------------------------------------------------------------------------

  2626 CTestDevVideoCiuPlayReleaseBuffers::CTestDevVideoCiuPlayReleaseBuffers(const TDesC& aTestName)

  2627 	: CTestDevVideoCiuPlayStep(aTestName)

  2628 	{

  2629 	}

  2630 

  2631 CTestDevVideoCiuPlayReleaseBuffers* CTestDevVideoCiuPlayReleaseBuffers::NewL(const TDesC& aTestName)

  2632 	{

  2633 	CTestDevVideoCiuPlayReleaseBuffers* self = new(ELeave) CTestDevVideoCiuPlayReleaseBuffers(aTestName);

  2634 	return self;

  2635 	}

  2636 

  2637 TVerdict CTestDevVideoCiuPlayReleaseBuffers::DoTestStepPreambleL()

  2638 	{

  2639 	// Call the base class first

  2640 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2641 

  2642 	if (ret == EPass)

  2643 		{

  2644 		// select decoder

  2645 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2646 		

  2647 		if (err != KErrNone)

  2648 			{

  2649 			ret = EInconclusive;

  2650 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2651 			}

  2652 		}

  2653 	

  2654 	return ret;

  2655 	}

  2656 

  2657 TVerdict CTestDevVideoCiuPlayReleaseBuffers::DoTestL()

  2658 	{

  2659 	TVerdict ret = EFail;

  2660 	

  2661 	INFO_PRINTF1(_L("DevVideo CIU release buffer test"));

  2662 

  2663 	// Try to fetch the CI...

  2664 	MMMFVideoClientBufferSupport* interface = NULL;

  2665 		

  2666 	interface = static_cast<MMMFVideoClientBufferSupport*>

  2667 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2668 																	KUidMMFVideoClientBufferSupport));

  2669 	if (!interface)

  2670 		{

  2671 		ERR_PRINTF1(_L("Error - no interface retrieved"));

  2672 		}

  2673 	else

  2674 		{

  2675 		interface->MvcbsReleaseBuffers();

  2676 		

  2677 		// Now set up the test interface...

  2678 		MDevVideoCiuTestInterfaceVideoClientBufferSupport* testInterface = NULL;

  2679 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoClientBufferSupport*>

  2680 							(iDevVideoPlay->CustomInterface( iHwDeviceId,

  2681 									KUidDevVideoCiuTestInterfaceVideoClientBufferSupport));

  2682 		if (testInterface)

  2683 			{

  2684 			// In the test decoder, we set true when we call release buffer. Here just check it will return true.

  2685 			if (testInterface->MdvcbsReleaseBuffers())

  2686 				{

  2687 				INFO_PRINTF1(_L("Succesfully release buffer."));

  2688 				ret = EPass;

  2689 				}

  2690 			else

  2691 				{

  2692 				ERR_PRINTF1(_L("Failed to release buffer."));

  2693 				}

  2694 			}

  2695 		else

  2696 			{

  2697 			ERR_PRINTF1(_L("Error - no test interface retrieved"));

  2698 			ret = EInconclusive;

  2699 			}		

  2700 		}

  2701 	return ret;

  2702 	}

  2703 

  2704 //------------------------------------------------------------------

  2705 

  2706 CTestDevVideoCiuPlaySurfaceHandleControl::CTestDevVideoCiuPlaySurfaceHandleControl(const TDesC& aTestName)

  2707 	:CTestDevVideoCiuPlayStep(aTestName)

  2708 	{

  2709 	}

  2710 

  2711 CTestDevVideoCiuPlaySurfaceHandleControl* CTestDevVideoCiuPlaySurfaceHandleControl::NewL(const TDesC& aTestName)

  2712 	{

  2713 	CTestDevVideoCiuPlaySurfaceHandleControl* self = new(ELeave) CTestDevVideoCiuPlaySurfaceHandleControl(aTestName);

  2714 	return self;

  2715 	}

  2716 

  2717 TVerdict CTestDevVideoCiuPlaySurfaceHandleControl::DoTestStepPreambleL()

  2718 	{

  2719 	// Call the base class first

  2720 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2721 	if (ret == EPass)

  2722 		{

  2723 		// select decoder

  2724 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2725 		

  2726 		if (err != KErrNone)

  2727 			{

  2728 			ret = EInconclusive;

  2729 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2730 			}

  2731 		}

  2732 	return ret;

  2733 	}

  2734 

  2735 TVerdict CTestDevVideoCiuPlaySurfaceHandleControl::DoTestL()

  2736 	{

  2737 	TVerdict ret = EFail;

  2738 	

  2739 	INFO_PRINTF1(_L("DevVideo CIU Surface Handle Interface Initialisation"));

  2740 	

  2741 	// Fetch the CI

  2742 	MMmfVideoSurfaceHandleControl* interface = NULL;

  2743 	

  2744 	interface = static_cast<MMmfVideoSurfaceHandleControl*>

  2745 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2746 											KUidMMFVideoSurfaceHandleControl));

  2747 	if (!interface)

  2748 		{

  2749 		ERR_PRINTF1(_L("Error - no interface retrieved for SurfaceHandleControl"));

  2750 		ret = EFail;

  2751 		}

  2752 	else

  2753 		{

  2754 		INFO_PRINTF1(_L("DevVideo CIU SurfaceHandle Control Interface Instantiated"));

  2755 		TSurfaceId nullId = TSurfaceId::CreateNullId();

  2756 		INFO_PRINTF1(_L("DevVideo CIU SurfaceHandle Control testing both surfacehandle functions"));

  2757 		interface->MmvshcSetSurfaceHandle(nullId);

  2758 

  2759 		// Fetch test interface

  2760 		MDevVideoCiuTestInterfaceVideoPlaySurfaceHandleControl* testInterface = NULL;

  2761 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlaySurfaceHandleControl*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2762 												KUidDevVideoCiuTestInterfaceVideoPlaySurfaceHandleControl));

  2763 		if (!testInterface)

  2764 			{

  2765 			ERR_PRINTF1(_L("Failed to create the test interface for Play rate control."));

  2766 			ret = EFail;

  2767 			}

  2768 		else

  2769 			{

  2770 			TSurfaceId surfaceId = testInterface->MdvshcGetPlaySurfaceHandle();

  2771 			

  2772 			if (surfaceId == nullId) 

  2773 				{

  2774 				ret = EPass;

  2775 				INFO_PRINTF1(_L("Get play surface handle method call performed as expected"));

  2776 				}

  2777 			else

  2778 				{

  2779 				ret = EFail;					

  2780 				ERR_PRINTF1(_L("Get Play surface handle method call failed"));

  2781 				}

  2782 		  	}

  2783 		}

  2784 	return ret;

  2785 	}

  2786 

  2787 //------------------------------------------------------------------

  2788 

  2789 CTestDevVideoCiuPlaySurfaceRedrawBuffer::CTestDevVideoCiuPlaySurfaceRedrawBuffer(const TDesC& aTestName)

  2790 	:CTestDevVideoCiuPlayStep(aTestName)

  2791 	{

  2792 	}

  2793 

  2794 CTestDevVideoCiuPlaySurfaceRedrawBuffer* CTestDevVideoCiuPlaySurfaceRedrawBuffer::NewL(const TDesC& aTestName)

  2795 	{

  2796 	CTestDevVideoCiuPlaySurfaceRedrawBuffer* self = new(ELeave) CTestDevVideoCiuPlaySurfaceRedrawBuffer(aTestName);

  2797 	return self;

  2798 	}

  2799 

  2800 TVerdict CTestDevVideoCiuPlaySurfaceRedrawBuffer::DoTestStepPreambleL()

  2801 	{

  2802 	// Call the base class first

  2803 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2804 	if (ret == EPass)

  2805 		{

  2806 		// select decoder

  2807 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2808 		

  2809 		if (err != KErrNone)

  2810 			{

  2811 			ret = EInconclusive;

  2812 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2813 			}

  2814 		}

  2815 	return ret;

  2816 	}

  2817 

  2818 TVerdict CTestDevVideoCiuPlaySurfaceRedrawBuffer::DoTestL()

  2819 	{

  2820 	TVerdict ret = EFail;

  2821 	

  2822 	INFO_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - Start"));

  2823 	

  2824 	// Fetch the CI

  2825 	MMmfVideoSurfaceHandleControl* interface = NULL;

  2826 	

  2827 	interface = static_cast<MMmfVideoSurfaceHandleControl*>

  2828 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2829 											KUidMMFVideoSurfaceHandleControl));

  2830 	if (!interface)

  2831 		{

  2832 		ERR_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - No interface"));

  2833 		ret = EFail;

  2834 		}

  2835 	else

  2836 		{

  2837 		INFO_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - Interface Instantiated"));

  2838 		HBufC8* redrawBuffer = HBufC8::NewLC(10);

  2839 		_LIT8(KTestString, "TestString");

  2840 		*redrawBuffer = KTestString();

  2841 		TPtrC8 bufPtr(*redrawBuffer);

  2842 		

  2843 		INFO_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - Setting redraw buffer"));

  2844 		interface->MmvshcRedrawBufferToSurface(bufPtr);

  2845 		CleanupStack::PopAndDestroy(redrawBuffer);

  2846 		redrawBuffer = NULL;

  2847 

  2848 		// Fetch test interface

  2849 		MDevVideoCiuTestInterfaceVideoPlaySurfaceHandleControl* testInterface = NULL;

  2850 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlaySurfaceHandleControl*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2851 												KUidDevVideoCiuTestInterfaceVideoPlaySurfaceHandleControl));

  2852 		if (!testInterface)

  2853 			{

  2854 			ERR_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - Failed to create test interface"));

  2855 			ret = EFail;

  2856 			}

  2857 		else

  2858 			{

  2859 			TDesC8& retrievedBuffer = testInterface->MdvshcGetRedrawBuffer();

  2860 			

  2861 			if (retrievedBuffer.Compare(KTestString()) == 0)

  2862 				{

  2863 				INFO_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - Retrieved correct string"));

  2864 				ret = EPass;

  2865 				}

  2866 			else

  2867 				{

  2868 				INFO_PRINTF1(_L("DevVideo CIU Surface Redraw Buffer - Retrieved incorrect string"));

  2869 				ret = EFail;					

  2870 				}

  2871 			}

  2872 		}

  2873 	return ret;

  2874 	}

  2875 	

  2876 #endif // SYMBIAN_BUILD_GCE

  2877 

  2878 //

  2879 //	Video Play Rate Control Tests

  2880 //

  2881 

  2882 CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities::CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities(const TDesC& aTestName)

  2883 	:CTestDevVideoCiuPlayStep(aTestName)

  2884 	{

  2885 	}

  2886 

  2887 CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities* CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities::NewL(const TDesC& aTestName)

  2888 	{

  2889 	CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities(aTestName);

  2890 	return self;

  2891 	}

  2892 

  2893 TVerdict CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities::DoTestStepPreambleL()

  2894 	{

  2895 	// Call the base class first

  2896 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2897 	if (ret == EPass)

  2898 		{

  2899 		// select decoder

  2900 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2901 		

  2902 		if (err != KErrNone)

  2903 			{

  2904 			ret = EInconclusive;

  2905 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  2906 			}

  2907 		}

  2908 	return ret;

  2909 	}

  2910 

  2911 TVerdict CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities::DoTestL()

  2912 	{

  2913 	TVerdict ret = EFail;

  2914 	

  2915 	INFO_PRINTF1(_L("DevVideo CIU Play Rate Control Interface Initialisation"));

  2916 	

  2917 	// Fetch the CI

  2918 	MMmfVideoPlayRateControl* interface = NULL;

  2919 	

  2920 	interface = static_cast<MMmfVideoPlayRateControl*>

  2921 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2922 											KUidMmfVideoPlayRateControl));

  2923 	if (!interface)

  2924 		{

  2925 		ERR_PRINTF1(_L("Error - no interface retrieved for Play Rate"));

  2926 		ret = EFail;

  2927 		}

  2928 	else

  2929 		{

  2930 		INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Instantiated"));

  2931 		

  2932 		TVideoPlayRateCapabilities videoPlayRateCapabilities;

  2933 		TRAPD(err, interface->MmvprcGetPlayRateCapabilitiesL(videoPlayRateCapabilities));

  2934 		

  2935 		if (err == KErrNone)

  2936 			{

  2937 			// Fetch test interface

  2938 			MDevVideoCiuTestInterfaceVideoPlayRateControl* testInterface = NULL;

  2939 			testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlayRateControl*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  2940 												KUidDevVideoCiuTestInterfaceVideoPlayRateControl));

  2941 			if (!testInterface)

  2942 				{

  2943 				ERR_PRINTF1(_L("Failed to create the test interface for Play rate control."));

  2944 				ret = EFail;

  2945 				}

  2946 			else

  2947 				{

  2948 				TVideoPlayRateCapabilities playRateCapResult = testInterface->MdvproGetPlayRateCapabilities();

  2949 				

  2950 				if (playRateCapResult.iPlayBackward == videoPlayRateCapabilities.iPlayBackward &&

  2951 						playRateCapResult.iPlayForward == videoPlayRateCapabilities.iPlayForward &&

  2952 						playRateCapResult.iStepBackward == videoPlayRateCapabilities.iStepBackward &&

  2953 						playRateCapResult.iStepForward == videoPlayRateCapabilities.iStepForward)

  2954 					{

  2955 					ret = EPass;

  2956 					INFO_PRINTF1(_L("Get Play Rate Capabilities method call performed as expected"));

  2957 					}

  2958 				else

  2959 					{

  2960 					ret = EFail;					

  2961 					ERR_PRINTF1(_L("Get Play Rate Capabilities method call failed"));

  2962 					INFO_PRINTF5(_L("Expected PlayBackward: %d, PlayForward: %d, StepBackward: %d, StepForward: %d"),

  2963 							playRateCapResult.iPlayBackward, playRateCapResult.iPlayForward,

  2964 							playRateCapResult.iStepBackward, playRateCapResult.iStepForward);

  2965 					}

  2966 				}	

  2967 			}

  2968 		else 

  2969 			{

  2970 			ERR_PRINTF2(_L("Failed to get the play rate capabilities: %d."),err);

  2971 			}

  2972 		

  2973 		}

  2974 	return ret;

  2975 	}

  2976 

  2977 //-----------------------------------------------------------//

  2978 CTestDevVideoCiuPlaySetAndGetPlayRate::CTestDevVideoCiuPlaySetAndGetPlayRate(const TDesC& aTestName)

  2979 	:CTestDevVideoCiuPlayStep(aTestName)

  2980 	{

  2981 	}

  2982 

  2983 CTestDevVideoCiuPlaySetAndGetPlayRate* CTestDevVideoCiuPlaySetAndGetPlayRate::NewL(const TDesC& aTestName)

  2984 	{

  2985 	CTestDevVideoCiuPlaySetAndGetPlayRate* self = new(ELeave) CTestDevVideoCiuPlaySetAndGetPlayRate(aTestName);

  2986 	return self;

  2987 	}

  2988 

  2989 TVerdict CTestDevVideoCiuPlaySetAndGetPlayRate::DoTestStepPreambleL()

  2990 	{

  2991 	// Call the base class first

  2992 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  2993 	if (ret == EPass)

  2994 		{

  2995 		// select decoder

  2996 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  2997 		

  2998 		if (err != KErrNone)

  2999 			{

  3000 			ret = EInconclusive;

  3001 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  3002 			}

  3003 		}

  3004 	return ret;

  3005 	}

  3006 

  3007 TVerdict CTestDevVideoCiuPlaySetAndGetPlayRate::DoTestL()

  3008 	{

  3009 	TVerdict ret = EFail;

  3010 	

  3011 	INFO_PRINTF1(_L("DevVideo CIU Play Rate Control Interface Initialisation"));

  3012 	

  3013 	// Fetch the CI

  3014 	MMmfVideoPlayRateControl* interface = NULL;

  3015 	

  3016 	interface = static_cast<MMmfVideoPlayRateControl*>

  3017 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3018 											KUidMmfVideoPlayRateControl));

  3019 	if (!interface)

  3020 		{

  3021 		ERR_PRINTF1(_L("Error - no interface retrieved for Play Rate"));

  3022 		ret = EFail;

  3023 		}

  3024 	else

  3025 		{

  3026 		INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Instantiated"));

  3027 		

  3028 		TInt playRate = 99; // The hardcoded value is for test purpose only

  3029 		TRAPD(err, interface->MmvprcSetPlayRateL(playRate));

  3030 		

  3031 		if (err == KErrNone)

  3032 			{

  3033 			TInt playRateResult = 0;

  3034 			TRAP(err, playRateResult = interface->MmvprcPlayRateL());

  3035 			

  3036 			if (err == KErrNone)

  3037 				{

  3038 				if (playRate == playRateResult)

  3039 					{

  3040 					ret = EPass;

  3041 					INFO_PRINTF1(_L("Set and get Play Rate method calls performed as expected"));

  3042 					}

  3043 				else

  3044 					{

  3045 					ret = EFail;					

  3046 					ERR_PRINTF3(_L("Set and get Play Rate methods call failed. Expected playRate: %d, return is: %d"), playRate, playRateResult);

  3047 					}

  3048 				}

  3049 			else

  3050 				{

  3051 				ERR_PRINTF2(_L("Failed to get the play rate: %d."), err);

  3052 				}

  3053 			}

  3054 		else

  3055 			{

  3056 			ERR_PRINTF2(_L("Failed to set the play rate: %d."), err);

  3057 			}

  3058 		}

  3059 	return ret;

  3060 	}

  3061 

  3062 //-----------------------------------------------------------//

  3063 CTestDevVideoCiuPlayGetAndSetStepFrame::CTestDevVideoCiuPlayGetAndSetStepFrame(const TDesC& aTestName)

  3064 	:CTestDevVideoCiuPlayStep(aTestName)

  3065 	{

  3066 	}

  3067 

  3068 CTestDevVideoCiuPlayGetAndSetStepFrame* CTestDevVideoCiuPlayGetAndSetStepFrame::NewL(const TDesC& aTestName)

  3069 	{

  3070 	CTestDevVideoCiuPlayGetAndSetStepFrame* self = new(ELeave) CTestDevVideoCiuPlayGetAndSetStepFrame(aTestName);

  3071 	return self;

  3072 	}

  3073 

  3074 TVerdict CTestDevVideoCiuPlayGetAndSetStepFrame::DoTestStepPreambleL()

  3075 	{

  3076 	// Call the base class first

  3077 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  3078 	if (ret == EPass)

  3079 		{

  3080 		// select decoder

  3081 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  3082 		

  3083 		if (err != KErrNone)

  3084 			{

  3085 			ret = EInconclusive;

  3086 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  3087 			}

  3088 		}

  3089 	return ret;

  3090 	}

  3091 

  3092 TVerdict CTestDevVideoCiuPlayGetAndSetStepFrame::DoTestL()

  3093 	{

  3094 	TVerdict ret = EFail;

  3095 	

  3096 	INFO_PRINTF1(_L("DevVideo CIU Play Rate Control Interface Initialisation"));

  3097 	

  3098 	// Fetch the CI

  3099 	MMmfVideoPlayRateControl* interface = NULL;

  3100 	

  3101 	interface = static_cast<MMmfVideoPlayRateControl*>

  3102 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3103 											KUidMmfVideoPlayRateControl));

  3104 	if (!interface)

  3105 		{

  3106 		ERR_PRINTF1(_L("Error - no interface retrieved for Play Rate"));

  3107 		ret = EFail;

  3108 		}

  3109 	else

  3110 		{

  3111 		INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Instantiated"));

  3112 		

  3113 		TInt stepFrame = 99; // The hardcoded value is for test purpose only

  3114 		TRAPD(err, interface->MmvprcStepFrameL(stepFrame));

  3115 		

  3116 		if (err == KErrNone)

  3117 			{

  3118 			// Fetch test interface

  3119 			MDevVideoCiuTestInterfaceVideoPlayRateControl* testInterface = NULL;

  3120 			testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlayRateControl*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3121 												KUidDevVideoCiuTestInterfaceVideoPlayRateControl));

  3122 			if (!testInterface)

  3123 				{

  3124 				ERR_PRINTF1(_L("Failed to create the test interface for Play rate control."));

  3125 				ret = EFail;

  3126 				}

  3127 			else

  3128 				{

  3129 				if (stepFrame == testInterface->MdvproStepFrame())

  3130 					{

  3131 					ret = EPass;

  3132 					INFO_PRINTF1(_L("Step frame method call performed as expected"));

  3133 					}

  3134 				else

  3135 					{

  3136 					ret = EFail;					

  3137 					ERR_PRINTF2(_L("Step frame method call failed. Expected stepFrame: %d."), stepFrame);

  3138 					}

  3139 				}	

  3140 			}

  3141 		else

  3142 			{

  3143 			ERR_PRINTF2(_L("Failed to set the step frame: %d."), err);

  3144 			}		

  3145 		}

  3146 	return ret;

  3147 	}

  3148 	

  3149 //------------------------------------------------------------------

  3150 

  3151 CTestDevVideoCiuPlaySetAndGetPlayRateObserver::CTestDevVideoCiuPlaySetAndGetPlayRateObserver(const TDesC& aTestName)

  3152 	:CTestDevVideoCiuPlayStep(aTestName)

  3153 	{

  3154 	}

  3155 

  3156 CTestDevVideoCiuPlaySetAndGetPlayRateObserver* CTestDevVideoCiuPlaySetAndGetPlayRateObserver::NewL(const TDesC& aTestName)

  3157 	{

  3158 	CTestDevVideoCiuPlaySetAndGetPlayRateObserver* self = new(ELeave) CTestDevVideoCiuPlaySetAndGetPlayRateObserver(aTestName);

  3159 	return self;

  3160 	}

  3161 

  3162 TVerdict CTestDevVideoCiuPlaySetAndGetPlayRateObserver::DoTestStepPreambleL()

  3163 	{

  3164 	// Call the base class first

  3165 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  3166 	if (ret == EPass)

  3167 		{

  3168 		// select decoder

  3169 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  3170 		

  3171 		if (err != KErrNone)

  3172 			{

  3173 			ret = EInconclusive;

  3174 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  3175 			}

  3176 		}

  3177 	return ret;

  3178 	}

  3179 

  3180 TVerdict CTestDevVideoCiuPlaySetAndGetPlayRateObserver::DoTestL()

  3181 	{

  3182 	TVerdict ret = EFail;

  3183 	

  3184 	INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Initialisation"));

  3185 	

  3186 	// Fetch the CI

  3187 	MMmfVideoPlayRateControl* interface = NULL;

  3188 		

  3189 	interface = static_cast<MMmfVideoPlayRateControl*>

  3190 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3191 											KUidMmfVideoPlayRateControl));

  3192 	if (!interface)

  3193 		{

  3194 		ERR_PRINTF1(_L("Error - no interface retrieved for Play Rate"));

  3195 		ret = EFail;

  3196 		}

  3197 	else

  3198 		{

  3199 		INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Instantiated"));

  3200 	

  3201 		// Set the observer

  3202 		MMmfVideoPlayRateObserver* obs = this;

  3203 		interface->MmvprcSetObserver(*obs);

  3204 		INFO_PRINTF1(_L("MmvprcSetObserver called"));

  3205 		

  3206 		// Verify that the observer was set

  3207 		MDevVideoCiuTestInterfaceVideoPlayRateControl* testInterface = NULL;

  3208 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlayRateControl*>(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3209 											KUidDevVideoCiuTestInterfaceVideoPlayRateControl));

  3210 		if (!testInterface)

  3211 			{

  3212 			ERR_PRINTF1(_L("Failed to create the test interface for Play rate control."));

  3213 			ret = EFail;

  3214 			}

  3215 		else

  3216 			{

  3217 			if (obs != testInterface->MdvproObserver())

  3218 				{

  3219 				ERR_PRINTF1(_L("Failed to set the observer."));

  3220 				ret = EFail;

  3221 				}

  3222 			else

  3223 				{			

  3224 				INFO_PRINTF1(_L("SetObserver successfully called"));

  3225 				ret = EPass;

  3226 				}

  3227 			}		

  3228 		}

  3229 	return ret;

  3230 	}

  3231 

  3232 //from MMmfVideoPlayRateObserver

  3233 void CTestDevVideoCiuPlaySetAndGetPlayRateObserver::MmvproStepFrameComplete(TTimeIntervalMicroSeconds /*aTimestamp*/)

  3234 	{}

  3235 		

  3236 void CTestDevVideoCiuPlaySetAndGetPlayRateObserver::MmvproKeyFrameModeRequest()

  3237 	{}

  3238 	

  3239 //------------------------------------------------------------------

  3240 

  3241 CTestDevVideoCiuPlayStepFrameComplete::CTestDevVideoCiuPlayStepFrameComplete(const TDesC& aTestName)

  3242 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

  3243 	{

  3244 	}

  3245 

  3246 CTestDevVideoCiuPlayStepFrameComplete* CTestDevVideoCiuPlayStepFrameComplete::NewL(const TDesC& aTestName)

  3247 	{

  3248 	CTestDevVideoCiuPlayStepFrameComplete* self = new(ELeave) CTestDevVideoCiuPlayStepFrameComplete(aTestName);

  3249 	return self;

  3250 	}

  3251 

  3252 TVerdict CTestDevVideoCiuPlayStepFrameComplete::DoTestStepPreambleL()

  3253 	{

  3254 	// Call the base class first

  3255 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  3256 	if (ret == EPass)

  3257 		{

  3258 		// select decoder

  3259 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  3260 		

  3261 		if (err != KErrNone)

  3262 			{

  3263 			ret = EInconclusive;

  3264 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  3265 			}

  3266 		}

  3267 	return ret;

  3268 	}

  3269 

  3270 TVerdict CTestDevVideoCiuPlayStepFrameComplete::DoTestL()

  3271 	{

  3272 	TVerdict ret = EFail;

  3273 	

  3274 	INFO_PRINTF1(_L("DevVideo CIU Play Rate Control Interface Initialisation"));

  3275 	

  3276 	// Fetch the CI

  3277 	MMmfVideoPlayRateControl* interface = NULL;

  3278 	

  3279 	interface = static_cast<MMmfVideoPlayRateControl*>

  3280 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3281 									KUidMmfVideoPlayRateControl));

  3282 	if (!interface)

  3283 		{

  3284 		ERR_PRINTF1(_L("Error - no interface retrieved for Play Rate"));

  3285 		ret = EFail;

  3286 		}

  3287 	else

  3288 		{

  3289 		INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Instantiated"));

  3290 	

  3291 		// Fetch test interface

  3292 		MDevVideoCiuTestInterfaceVideoPlayRateControl* testInterface = NULL;

  3293 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlayRateControl*>

  3294 											(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3295 											KUidDevVideoCiuTestInterfaceVideoPlayRateControl));

  3296 		if (!testInterface)

  3297 			{

  3298 			ERR_PRINTF1(_L("Failed to create the test interface for Play rate control."));

  3299 			ret = EFail;

  3300 			}

  3301 		else

  3302 			{

  3303 			// Set the observer to callback!

  3304 			MMmfVideoPlayRateObserver* obs = this;

  3305 			interface->MmvprcSetObserver(*obs);

  3306 		

  3307 			INFO_PRINTF1(_L("Requesting the step frame complete Callback..."));

  3308 			testInterface->MdvproStepFrameCompleteCallback();

  3309 

  3310 			if ((iError != KErrNone) && (!iCallbackReceived))

  3311 				{	

  3312 				ERR_PRINTF1(_L("Error receiving the step frame complete Callback."));

  3313 				ret = EFail;

  3314 				}

  3315 			else

  3316 				{

  3317 				INFO_PRINTF1(_L("Successfully retrieved the step frame complete Callback"));

  3318 				ret = EPass;

  3319 				}

  3320 			}

  3321 		}

  3322 	return ret;

  3323 	}

  3324 

  3325 //from MMmfVideoPlayRateObserver

  3326 void CTestDevVideoCiuPlayStepFrameComplete::MmvproStepFrameComplete(TTimeIntervalMicroSeconds aTimestamp)

  3327 	{

  3328 	INFO_PRINTF1(_L("Step frame complete callback received. "));

  3329 	// Test h/w sets the time stamp to 10000

  3330 	if (aTimestamp == 10000)

  3331 		{

  3332 		iCallbackReceived = ETrue;

  3333 		iError = KErrNone;

  3334 		}

  3335 	else

  3336 		{

  3337 		iCallbackReceived = ETrue;

  3338 		iError = KErrGeneral;

  3339 		}

  3340 	}

  3341 		

  3342 void CTestDevVideoCiuPlayStepFrameComplete::MmvproKeyFrameModeRequest()

  3343 	{

  3344 	iError = KErrNotSupported;

  3345 	}

  3346 

  3347 //------------------------------------------------------------------

  3348 

  3349 CTestDevVideoCiuPlayKeyFrameModeRequest::CTestDevVideoCiuPlayKeyFrameModeRequest(const TDesC& aTestName)

  3350 	:CTestDevVideoCiuPlayStep(aTestName), iCallbackReceived(EFalse)

  3351 	{

  3352 	}

  3353 

  3354 CTestDevVideoCiuPlayKeyFrameModeRequest* CTestDevVideoCiuPlayKeyFrameModeRequest::NewL(const TDesC& aTestName)

  3355 	{

  3356 	CTestDevVideoCiuPlayKeyFrameModeRequest* self = new(ELeave) CTestDevVideoCiuPlayKeyFrameModeRequest(aTestName);

  3357 	return self;

  3358 	}

  3359 

  3360 TVerdict CTestDevVideoCiuPlayKeyFrameModeRequest::DoTestStepPreambleL()

  3361 	{

  3362 	// Call the base class first

  3363 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  3364 	if (ret == EPass)

  3365 		{

  3366 		// select decoder

  3367 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  3368 		

  3369 		if (err != KErrNone)

  3370 			{

  3371 			ret = EInconclusive;

  3372 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  3373 			}

  3374 		}

  3375 	return ret;

  3376 	}

  3377 

  3378 TVerdict CTestDevVideoCiuPlayKeyFrameModeRequest::DoTestL()

  3379 	{

  3380 	TVerdict ret = EFail;

  3381 	

  3382 	INFO_PRINTF1(_L("DevVideo CIU Play Rate Control Interface Initialisation"));

  3383 	

  3384 	// Fetch the CI

  3385 	MMmfVideoPlayRateControl* interface = NULL;

  3386 	

  3387 	interface = static_cast<MMmfVideoPlayRateControl*>

  3388 									(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3389 									KUidMmfVideoPlayRateControl));

  3390 	if (!interface)

  3391 		{

  3392 		ERR_PRINTF1(_L("Error - no interface retrieved for Play Rate"));

  3393 		ret = EFail;

  3394 		}

  3395 	else

  3396 		{

  3397 		INFO_PRINTF1(_L("DevVideo CIU Play Rate Interface Instantiated"));

  3398 	

  3399 		// Fetch test interface

  3400 		MDevVideoCiuTestInterfaceVideoPlayRateControl* testInterface = NULL;

  3401 		testInterface = static_cast<MDevVideoCiuTestInterfaceVideoPlayRateControl*>

  3402 											(iDevVideoPlay->CustomInterface(iHwDeviceId,

  3403 											KUidDevVideoCiuTestInterfaceVideoPlayRateControl));

  3404 		if (!testInterface)

  3405 			{

  3406 			ERR_PRINTF1(_L("Failed to create the test interface for Play rate control."));

  3407 			ret = EFail;

  3408 			}

  3409 		else

  3410 			{

  3411 			// Set the observer to callback!

  3412 			MMmfVideoPlayRateObserver* obs = this;

  3413 			interface->MmvprcSetObserver(*obs);

  3414 		

  3415 			INFO_PRINTF1(_L("Requesting the key frame mode request Callback..."));

  3416 			testInterface->MdvproKeyFrameModeRequestCallback();

  3417 

  3418 			if ((iError != KErrNone) && (!iCallbackReceived))

  3419 				{	

  3420 				ERR_PRINTF1(_L("Error receiving the key frame mode request Callback."));

  3421 				ret = EFail;

  3422 				}

  3423 			else

  3424 				{

  3425 				INFO_PRINTF1(_L("Successfully retrieved the key frame mode request Callback"));

  3426 				ret = EPass;

  3427 				}

  3428 			}

  3429 		}

  3430 	return ret;

  3431 	}

  3432 

  3433 //from MMmfVideoPlayRateObserver

  3434 void CTestDevVideoCiuPlayKeyFrameModeRequest::MmvproStepFrameComplete(TTimeIntervalMicroSeconds /*aTimestamp*/)

  3435 	{

  3436 	iError = KErrNotSupported;

  3437 	}

  3438 		

  3439 void CTestDevVideoCiuPlayKeyFrameModeRequest::MmvproKeyFrameModeRequest()

  3440 	{

  3441 	INFO_PRINTF1(_L("Key frame mode request callback received."));

  3442 	iCallbackReceived = ETrue;

  3443 	iError = KErrNone;

  3444 	}

  3445 

  3446 

  3447 //------------------------------------------------------------------

  3448 

  3449 CTestDevVideoCiuHwDeviceTunnel* CTestDevVideoCiuHwDeviceTunnel::NewL(const TDesC& aTestName)

  3450 	{

  3451 	CTestDevVideoCiuHwDeviceTunnel* self = new(ELeave) CTestDevVideoCiuHwDeviceTunnel(aTestName);

  3452 	return self;

  3453 	}

  3454 

  3455 CTestDevVideoCiuHwDeviceTunnel::CTestDevVideoCiuHwDeviceTunnel(const TDesC& aTestName)

  3456 	:CTestDevVideoCiuPlayStep(aTestName)

  3457 	{

  3458 	}

  3459 

  3460 TVerdict CTestDevVideoCiuHwDeviceTunnel::DoTestStepPreambleL()

  3461 	{

  3462 	// Call the base class first

  3463 	TVerdict ret = CTestDevVideoCiuPlayStep::DoTestStepPreambleL();

  3464 	if (ret == EPass)

  3465 		{

  3466 		// select decoder

  3467 		TRAPD(err, iHwDeviceId = iDevVideoPlay->SelectDecoderL(KUidDevVideoCiuTestDecodeHwDevice));

  3468 

  3469 		if (err != KErrNone)

  3470 			{

  3471 			ret = EInconclusive;

  3472 			ERR_PRINTF1(_L("DevVideo Play Failed to select the decoder."));

  3473 			}

  3474 		}

  3475 	return ret;

  3476 	}

  3477 

  3478 TVerdict CTestDevVideoCiuHwDeviceTunnel::DoTestL()

  3479 	{

  3480 	INFO_PRINTF1(_L("DevVideo CIU HwDeviceTunnel Initialisation"));

  3481 

  3482 	// Fetch the CI

  3483 	MMmfVideoHwDeviceTunnel* interface = static_cast<MMmfVideoHwDeviceTunnel*>

  3484 	  (iDevVideoPlay->CustomInterface(iHwDeviceId, KUidMmfVideoHwDeviceTunnel));

  3485 

  3486 	if (!interface)

  3487 		{

  3488 		ERR_PRINTF1(_L("Failed to create interface for HwDevice Tunnel"));

  3489 		return EFail;

  3490 		}

  3491 

  3492 	INFO_PRINTF1(_L("Created interface for HwDevice Tunnel"));

  3493 

  3494 	// Fetch test interface

  3495 	MDevVideoCiuTestInterfaceHwDeviceTunnel* testInterface =

  3496 	  static_cast<MDevVideoCiuTestInterfaceHwDeviceTunnel*>

  3497 	    (iDevVideoPlay->CustomInterface(iHwDeviceId,

  3498 	                                    KUidDevVideoCiuTestInterfaceHwDeviceTunnel));

  3499 	if (!testInterface)

  3500 		{

  3501 		ERR_PRINTF1(_L("Failed to create test interface for HwDevice Tunnel"));

  3502 		return EFail;

  3503 		}

  3504 

  3505 	INFO_PRINTF1(_L("Created test interface for HwDevice Tunnel"));

  3506 

  3507 	CMMFVideoHwDevice* hwDevice = interface->MmvhdtHwDevice();

  3508 	if (hwDevice != reinterpret_cast<CMMFVideoHwDevice*>(0x11111111))

  3509 		{

  3510 		INFO_PRINTF1(_L("MmvhdtHwDevice() failed"));

  3511 		return EFail;

  3512 		}

  3513 

  3514 	INFO_PRINTF1(_L("MmvhdtHwDevice() succeeded"));

  3515 

  3516 	interface->MmvhdtSetupTunnelL(reinterpret_cast<CMMFVideoHwDevice*>(0x22222222));

  3517 

  3518 	hwDevice = testInterface->MhdtHwDevice();

  3519 	if (hwDevice != reinterpret_cast<CMMFVideoHwDevice*>(0x22222222))

  3520 		{

  3521 		INFO_PRINTF1(_L("MmvhdtSetupTunnelL() failed"));

  3522 		return EFail;

  3523 		}

  3524 

  3525 	INFO_PRINTF1(_L("MmvhdtSetupTunnelL() succeeded"));

  3526 

  3527 	return EPass;

  3528 	}
Symaptic