Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayTwo.cpp@260cb5ec6c19

     2 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 // All rights reserved.

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

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

     6 // which accompanies this distribution, and is available

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

     8 //

     9 // Initial Contributors:

    10 // Nokia Corporation - initial contribution.

    11 //

    12 // Contributors:

    13 //

    14 // Description:

    15 // TestDevVideoPlay.cpp

    16 //

    17 //

    19 #include "TestDevVideoPlay.h"

    20 #include "TestDevVideoPlayTestData.h"

    21 #include "TestDevVideoPlugins/decoder.h"

    22 #include "TestDevVideoPlugins/postproc.h"

    23 #include <e32math.h>

    25 CTestDevVideoPlaySetInputCrop::CTestDevVideoPlaySetInputCrop(const TDesC& aTestName, TTestType aTestType)

    26 	:CTestDevVideoPlayStep(aTestName, aTestType)

    27 	{

    28 	}

    30 CTestDevVideoPlaySetInputCrop* CTestDevVideoPlaySetInputCrop::NewL(const TDesC& aTestName, TTestType aTestType)

    31 	{

    32 	CTestDevVideoPlaySetInputCrop* self = new(ELeave) CTestDevVideoPlaySetInputCrop(aTestName, aTestType);

    33 	return self;

    34 	}

    36 TVerdict CTestDevVideoPlaySetInputCrop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

    37 	{

    38 	TVerdict ret = EPass;

    39 	TInt expErr = KErrNone;

    41 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetInputCrop"));

    43 	// expected results

    44 	if (iTestType != ETestValid)

    45 		{

    46 		ERR_PRINTF1(_L("Error - invalid test step type"));

    47 		return EInconclusive;

    48 		}

    50 	TInt err = KErrNone;

    51 	TInt err2 = KErrNone;

    53 	THwDeviceId hwDecoder = 0;

    54 	THwDeviceId hwPostProc = 0;

    56 	// select decoder

    57 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

    58 	if (err != KErrNone)

    59 		{

    60 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

    61 			return EInconclusive;

    62 		}

    64 	// select post-processor

    65 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

    66 	if (err != KErrNone)

    67 		{

    68 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

    69 			return EInconclusive;

    70 		}

    72 	// set input crop on decoder

    73 	TRect testRect1(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD);

    74 	TRAP(err, aDevVideoPlay.SetInputCropOptionsL(hwDecoder, testRect1) )

    76 	// set input crop on post-processor

    77 	TRect testRect2(KTestInputCropRectD, KTestInputCropRectC, KTestInputCropRectB, KTestInputCropRectA);

    78 	TRAP(err2, aDevVideoPlay.SetInputCropOptionsL(hwPostProc, testRect2) )

    81 	if ((err != expErr) || (err2 != expErr))

    82 		{

    83 		ERR_PRINTF3(_L("SetInputCropOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

    84 		ERR_PRINTF3(_L("SetInputCropOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

    85 		ret = EFail;

    86 		}

    87 	else

    88 		INFO_PRINTF4(_L("SetInputCropOptionsL(), %d, %d= %d"), err, err2, expErr);

    90 	return ret;

    91 	}

    92 //------------------------------------------------------------------

    94 CTestDevVideoPlaySetYuvToRgbOptionsFormat::CTestDevVideoPlaySetYuvToRgbOptionsFormat(const TDesC& aTestName, TTestType aTestType)

    95 	:CTestDevVideoPlayStep(aTestName, aTestType)

    96 	{

    97 	}

    99 CTestDevVideoPlaySetYuvToRgbOptionsFormat* CTestDevVideoPlaySetYuvToRgbOptionsFormat::NewL(const TDesC& aTestName, TTestType aTestType)

   100 	{

   101 	CTestDevVideoPlaySetYuvToRgbOptionsFormat* self = new(ELeave) CTestDevVideoPlaySetYuvToRgbOptionsFormat(aTestName, aTestType);

   102 	return self;

   103 	}

   105 TVerdict CTestDevVideoPlaySetYuvToRgbOptionsFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   106 	{

   107 	TVerdict ret = EPass;

   108 	TInt expErr = KErrNone;

   110 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetYuvToRgbOptionsFormat"));

   112 	// expected results

   113 	if (iTestType != ETestValid)

   114 		{

   115 		ERR_PRINTF1(_L("Error - invalid test step type"));

   116 		return EInconclusive;

   117 		}

   119 	TInt err = KErrNone;

   120 	TInt err2 = KErrNone;

   122 	THwDeviceId hwDecoder = 0;

   123 	THwDeviceId hwPostProc = 0;

   125 	// select decoder

   126 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   127 	if (err != KErrNone)

   128 		{

   129 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   130 			return EInconclusive;

   131 		}

   133 	// select post-processor

   134 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   135 	if (err != KErrNone)

   136 		{

   137 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   138 			return EInconclusive;

   139 		}

   141 	// set YUV to RGB options with formats on decoder

   142 	TRAP(err, aDevVideoPlay.SetYuvToRgbOptionsL(hwDecoder, KTestYuvToRgb1, KTestYuvFormat1, KTestRgbFormat1) );

   144 	// set YUV to RGB options with formats on post-processor

   145 	TRAP(err2, aDevVideoPlay.SetYuvToRgbOptionsL(hwPostProc, KTestYuvToRgb2, KTestYuvFormat2, KTestRgbFormat2) );

   148 	if ((err != expErr) || (err2 != expErr))

   149 		{

   150 		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

   151 		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

   152 		ret = EFail;

   153 		}

   154 	else

   155 		INFO_PRINTF4(_L("SetYuvToRgbOptionsL(), %d, %d= %d"), err, err2, expErr);

   157 	return ret;

   158 	}

   159 //------------------------------------------------------------------

   161 CTestDevVideoPlaySetYuvToRgbOptions::CTestDevVideoPlaySetYuvToRgbOptions(const TDesC& aTestName, TTestType aTestType)

   162 	:CTestDevVideoPlayStep(aTestName, aTestType)

   163 	{

   164 	}

   166 CTestDevVideoPlaySetYuvToRgbOptions* CTestDevVideoPlaySetYuvToRgbOptions::NewL(const TDesC& aTestName, TTestType aTestType)

   167 	{

   168 	CTestDevVideoPlaySetYuvToRgbOptions* self = new(ELeave) CTestDevVideoPlaySetYuvToRgbOptions(aTestName, aTestType);

   169 	return self;

   170 	}

   172 TVerdict CTestDevVideoPlaySetYuvToRgbOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   173 	{

   174 	TVerdict ret = EPass;

   175 	TInt expErr = KErrNone;

   177 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetYuvToRgbOptions"));

   179 	// expected results

   180 	if (iTestType != ETestValid)

   181 		{

   182 		ERR_PRINTF1(_L("Error - invalid test step type"));

   183 		return EInconclusive;

   184 		}

   186 	TInt err = KErrNone;

   187 	TInt err2 = KErrNone;

   189 	THwDeviceId hwDecoder = 0;

   190 	THwDeviceId hwPostProc = 0;

   192 	// select decoder

   193 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   194 	if (err != KErrNone)

   195 		{

   196 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   197 			return EInconclusive;

   198 		}

   200 	// select post-processor

   201 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   202 	if (err != KErrNone)

   203 		{

   204 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   205 			return EInconclusive;

   206 		}

   208 	// set YUV to RGB options with formats on decoder

   209 	TRAP(err, aDevVideoPlay.SetYuvToRgbOptionsL(hwDecoder, KTestYuvToRgb1) );

   211 	// set YUV to RGB options with formats on post-processor

   212 	TRAP(err2, aDevVideoPlay.SetYuvToRgbOptionsL(hwPostProc, KTestYuvToRgb2) );

   215 	if ((err != expErr) || (err2 != expErr))

   216 		{

   217 		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

   218 		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

   219 		ret = EFail;

   220 		}

   221 	else

   222 		INFO_PRINTF4(_L("SetYuvToRgbOptionsL(), %d, %d= %d"), err, err2, expErr);

   224 	return ret;

   225 	}

   226 //------------------------------------------------------------------

   228 CTestDevVideoPlaySetRotate::CTestDevVideoPlaySetRotate(const TDesC& aTestName, TTestType aTestType)

   229 	:CTestDevVideoPlayStep(aTestName, aTestType)

   230 	{

   231 	}

   233 CTestDevVideoPlaySetRotate* CTestDevVideoPlaySetRotate::NewL(const TDesC& aTestName, TTestType aTestType)

   234 	{

   235 	CTestDevVideoPlaySetRotate* self = new(ELeave) CTestDevVideoPlaySetRotate(aTestName, aTestType);

   236 	return self;

   237 	}

   239 TVerdict CTestDevVideoPlaySetRotate::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   240 	{

   241 	TVerdict ret = EPass;

   242 	TInt expErr = KErrNone;

   244 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetRotate"));

   246 	// expected results

   247 	if (iTestType != ETestValid)

   248 		{

   249 		ERR_PRINTF1(_L("Error - invalid test step type"));

   250 		return EInconclusive;

   251 		}

   253 	TInt err = KErrNone;

   254 	TInt err2 = KErrNone;

   256 	THwDeviceId hwDecoder = 0;

   257 	THwDeviceId hwPostProc = 0;

   259 	// select decoder

   260 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   261 	if (err != KErrNone)

   262 		{

   263 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   264 			return EInconclusive;

   265 		}

   267 	// select post-processor

   268 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   269 	if (err != KErrNone)

   270 		{

   271 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   272 			return EInconclusive;

   273 		}

   275 	// set rotate options on decoder

   276 	TRAP(err, aDevVideoPlay.SetRotateOptionsL(hwDecoder, KTestRotate1) );

   278 	// set rotate options on post-processor

   279 	TRAP(err2, aDevVideoPlay.SetRotateOptionsL(hwPostProc, KTestRotate2) );

   282 	if ((err != expErr) || (err2 != expErr))

   283 		{

   284 		ERR_PRINTF3(_L("SetRotateOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

   285 		ERR_PRINTF3(_L("SetRotateOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

   286 		ret = EFail;

   287 		}

   288 	else

   289 		INFO_PRINTF4(_L("SetRotateOptionsL(), %d, %d= %d"), err, err2, expErr);

   291 	return ret;

   292 	}

   293 //------------------------------------------------------------------

   295 CTestDevVideoPlaySetScale::CTestDevVideoPlaySetScale(const TDesC& aTestName, TTestType aTestType)

   296 	:CTestDevVideoPlayStep(aTestName, aTestType)

   297 	{

   298 	}

   300 CTestDevVideoPlaySetScale* CTestDevVideoPlaySetScale::NewL(const TDesC& aTestName, TTestType aTestType)

   301 	{

   302 	CTestDevVideoPlaySetScale* self = new(ELeave) CTestDevVideoPlaySetScale(aTestName, aTestType);

   303 	return self;

   304 	}

   306 TVerdict CTestDevVideoPlaySetScale::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   307 	{

   308 	TVerdict ret = EPass;

   309 	TInt expErr = KErrNone;

   311 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetScale"));

   313 	// expected results

   314 	if (iTestType != ETestValid)

   315 		{

   316 		ERR_PRINTF1(_L("Error - invalid test step type"));

   317 		return EInconclusive;

   318 		}

   320 	TInt err = KErrNone;

   321 	TInt err2 = KErrNone;

   323 	THwDeviceId hwDecoder = 0;

   324 	THwDeviceId hwPostProc = 0;

   326 	// select decoder

   327 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   328 	if (err != KErrNone)

   329 		{

   330 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   331 			return EInconclusive;

   332 		}

   334 	// select post-processor

   335 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   336 	if (err != KErrNone)

   337 		{

   338 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   339 			return EInconclusive;

   340 		}

   342 	// set scale options on decoder

   343 	TSize testScale1(KTestScaleX, KTestScaleY);

   344 	TRAP(err, aDevVideoPlay.SetScaleOptionsL(hwDecoder, testScale1, ETrue) );

   346 	TSize testScale2(KTestScaleY, KTestScaleX);

   347 	// set scale options on post-processor

   348 	TRAP(err2, aDevVideoPlay.SetScaleOptionsL(hwPostProc, testScale2, ETrue) );

   351 	if ((err != expErr) || (err2 != expErr))

   352 		{

   353 		ERR_PRINTF3(_L("SetScaleOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

   354 		ERR_PRINTF3(_L("SetScaleOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

   355 		ret = EFail;

   356 		}

   357 	else

   358 		INFO_PRINTF4(_L("SetScaleOptionsL(), %d, %d= %d"), err, err2, expErr);

   360 	return ret;

   361 	}

   362 //------------------------------------------------------------------

   364 CTestDevVideoPlaySetCrop::CTestDevVideoPlaySetCrop(const TDesC& aTestName, TTestType aTestType)

   365 	:CTestDevVideoPlayStep(aTestName, aTestType)

   366 	{

   367 	}

   369 CTestDevVideoPlaySetCrop* CTestDevVideoPlaySetCrop::NewL(const TDesC& aTestName, TTestType aTestType)

   370 	{

   371 	CTestDevVideoPlaySetCrop* self = new(ELeave) CTestDevVideoPlaySetCrop(aTestName, aTestType);

   372 	return self;

   373 	}

   375 TVerdict CTestDevVideoPlaySetCrop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   376 	{

   377 	TVerdict ret = EPass;

   378 	TInt expErr = KErrNone;

   380 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetCrop"));

   382 	// expected results

   383 	if (iTestType != ETestValid)

   384 		{

   385 		ERR_PRINTF1(_L("Error - invalid test step type"));

   386 		return EInconclusive;

   387 		}

   389 	TInt err = KErrNone;

   390 	TInt err2 = KErrNone;

   392 	THwDeviceId hwDecoder = 0;

   393 	THwDeviceId hwPostProc = 0;

   395 	// select decoder

   396 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   397 	if (err != KErrNone)

   398 		{

   399 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   400 			return EInconclusive;

   401 		}

   403 	// select post-processor

   404 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   405 	if (err != KErrNone)

   406 		{

   407 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   408 			return EInconclusive;

   409 		}

   411 	// set output crop options on decoder

   412 	TRect testRect1(KTestOutputCropRectA, KTestOutputCropRectB, KTestOutputCropRectC, KTestOutputCropRectD);

   413 	TRAP(err, aDevVideoPlay.SetOutputCropOptionsL(hwDecoder, testRect1) );

   415 	// set output crop options on post-processor

   416 	TRect testRect2(KTestOutputCropRectD, KTestOutputCropRectC, KTestOutputCropRectB, KTestOutputCropRectA);

   417 	TRAP(err2, aDevVideoPlay.SetOutputCropOptionsL(hwPostProc, testRect2) );

   420 	if ((err != expErr) || (err2 != expErr))

   421 		{

   422 		ERR_PRINTF3(_L("SetOutputCropOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

   423 		ERR_PRINTF3(_L("SetOutputCropOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

   424 		ret = EFail;

   425 		}

   426 	else

   427 		INFO_PRINTF4(_L("SetOutputCropOptionsL(), %d, %d= %d"), err, err2, expErr);

   429 	return ret;

   430 	}

   431 //------------------------------------------------------------------

   433 CTestDevVideoPlaySetPostProcOptions::CTestDevVideoPlaySetPostProcOptions(const TDesC& aTestName, TTestType aTestType)

   434 	:CTestDevVideoPlayStep(aTestName, aTestType)

   435 	{

   436 	}

   438 CTestDevVideoPlaySetPostProcOptions* CTestDevVideoPlaySetPostProcOptions::NewL(const TDesC& aTestName, TTestType aTestType)

   439 	{

   440 	CTestDevVideoPlaySetPostProcOptions* self = new(ELeave) CTestDevVideoPlaySetPostProcOptions(aTestName, aTestType);

   441 	return self;

   442 	}

   444 TVerdict CTestDevVideoPlaySetPostProcOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   445 	{

   446 	TVerdict ret = EPass;

   447 	TInt expErr = KErrNone;

   449 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetPostProcOptions"));

   451 	// expected results

   452 	if (iTestType != ETestValid)

   453 		{

   454 		ERR_PRINTF1(_L("Error - invalid test step type"));

   455 		return EInconclusive;

   456 		}

   458 	TInt err = KErrNone;

   459 	TInt err2 = KErrNone;

   461 	THwDeviceId hwDecoder = 0;

   462 	THwDeviceId hwPostProc = 0;

   464 	// select decoder

   465 	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   466 	if (err != KErrNone)

   467 		{

   468 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   469 			return EInconclusive;

   470 		}

   472 	// select post-processor

   473 	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   474 	if (err != KErrNone)

   475 		{

   476 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   477 			return EInconclusive;

   478 		}

   480 	// set post-processor options on decoder

   481 	TRAP(err, aDevVideoPlay.SetPostProcSpecificOptionsL(hwDecoder, KTestPostProcOptions1) );

   483 	// set post-processor options on post-processor

   484 	TRAP(err2, aDevVideoPlay.SetPostProcSpecificOptionsL(hwPostProc, KTestPostProcOptions2) );

   487 	if ((err != expErr) || (err2 != expErr))

   488 		{

   489 		ERR_PRINTF3(_L("SetPostProcSpecificOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

   490 		ERR_PRINTF3(_L("SetPostProcSpecificOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

   491 		ret = EFail;

   492 		}

   493 	else

   494 		INFO_PRINTF4(_L("SetPostProcSpecificOptionsL(), %d, %d= %d"), err, err2, expErr);

   496 	return ret;

   497 	}

   498 //------------------------------------------------------------------

   500 CTestDevVideoPlaySetClockSource::CTestDevVideoPlaySetClockSource(const TDesC& aTestName, TTestType aTestType)

   501 	:CTestDevVideoPlayStep(aTestName, aTestType)

   502 	{

   503 	}

   505 CTestDevVideoPlaySetClockSource* CTestDevVideoPlaySetClockSource::NewL(const TDesC& aTestName, TTestType aTestType)

   506 	{

   507 	CTestDevVideoPlaySetClockSource* self = new(ELeave) CTestDevVideoPlaySetClockSource(aTestName, aTestType);

   508 	return self;

   509 	}

   511 TVerdict CTestDevVideoPlaySetClockSource::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   512 	{

   513 	TVerdict ret = EPass;

   514 //	TInt expErr = KErrNone;

   515 	TBool selDec = ETrue;

   516 	TBool selPost = ETrue;

   518 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetClockSource"));

   520 	// expected results

   521 	switch(iTestType)

   522 		{

   523 		case ETestValid:

   524 //			expErr = KErrNone;	// EABI warning removal

   525 			break;

   526 		case ETestDecoderOnly:

   527 			selPost = EFalse;

   528 			break;

   529 		case ETestPostProcOnly:

   530 			selDec = EFalse;

   531 			break;

   532 		default:

   533 			ERR_PRINTF1(_L("Error - invalid test step type"));

   534 			return EInconclusive;

   535 		}

   537 	TInt err = KErrNone;

   539 //	THwDeviceId hwDecoder = 0;

   540 //	THwDeviceId hwPostProc = 0;

   542 	// select decoder

   543 	if (selDec)

   544 		{

   545 //		TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   546 		TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

   547 		if (err != KErrNone)

   548 			{

   549 			ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   550 				return EInconclusive;

   551 			}

   552 		}

   554 	// select post-processor

   555 	if (selPost)

   556 		{

   557 		TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

   558 //		TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   559 		if (err != KErrNone)

   560 			{

   561 			ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   562 				return EInconclusive;

   563 			}

   564 		}

   566 	CSystemClockSource *time1 = NULL;

   568 	// no parameters so no need to have a separate 'test clock source'

   569 	TRAP(err, time1 = CSystemClockSource::NewL());

   570 	if (err != KErrNone)

   571 		{

   572 		ERR_PRINTF1(_L("Error - couldn't construct system clock class"));

   574 		return EInconclusive;

   575 		}

   577 	// set clock source

   578 	aDevVideoPlay.SetClockSource(time1);

   580 	// if there is no panic then test has passed

   582 	INFO_PRINTF1(_L("SetClockSourceL() called correctly on HW Devices."));

   584 	// delete clock source

   585 	delete time1; time1 = NULL;

   587 	return ret;

   588 	}

   589 //------------------------------------------------------------------

   591 CTestDevVideoPlaySetVideoOutput::CTestDevVideoPlaySetVideoOutput(const TDesC& aTestName, TTestType aTestType)

   592 	:CTestDevVideoPlayStep(aTestName, aTestType)

   593 	{

   594 	}

   596 CTestDevVideoPlaySetVideoOutput* CTestDevVideoPlaySetVideoOutput::NewL(const TDesC& aTestName, TTestType aTestType)

   597 	{

   598 	CTestDevVideoPlaySetVideoOutput* self = new(ELeave) CTestDevVideoPlaySetVideoOutput(aTestName, aTestType);

   599 	return self;

   600 	}

   602 TVerdict CTestDevVideoPlaySetVideoOutput::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   603 	{

   604 	TVerdict ret = EPass;

   605 	TInt expErr = KErrNone;

   607 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetVideoOutput"));

   609 	// expected results

   610 	if (iTestType != ETestValid)

   611 		{

   612 		ERR_PRINTF1(_L("Error - invalid test step type"));

   613 		return EInconclusive;

   614 		}

   616 	TInt err = KErrNone;

   618 //	THwDeviceId hwDecoder = 0;

   619 //	THwDeviceId hwPostProc = 0;

   621 	// select decoder

   622 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   623 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

   624 	if (err != KErrNone)

   625 		{

   626 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   627 			return EInconclusive;

   628 		}

   630 	// select post-processor

   631 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   632 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

   633 	if (err != KErrNone)

   634 		{

   635 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   636 			return EInconclusive;

   637 		}

   639 	expErr = KErrHardwareNotAvailable;//Post processor plugin will leave with this if it gets

   640 									  //the method call correctly

   642 	TRAP(err, aDevVideoPlay.SetVideoDestScreenL(ETrue) )

   644 	if (err != expErr)

   645 		{

   646 		ERR_PRINTF3(_L("SetVideoDestScreenL() gave error %d (expected %d)"),err, expErr);

   647 		ret = EFail;

   648 		}

   649 	else

   650 		INFO_PRINTF3(_L("SetVideoDestScreenL(), %d = %d"), err, expErr);

   652 	return ret;

   653 	}

   654 //------------------------------------------------------------------

   656 CTestDevVideoPlaySynchronizeDecoding::CTestDevVideoPlaySynchronizeDecoding(const TDesC& aTestName, TTestType aTestType)

   657 	:CTestDevVideoPlayStep(aTestName, aTestType)

   658 	{

   659 	}

   661 CTestDevVideoPlaySynchronizeDecoding* CTestDevVideoPlaySynchronizeDecoding::NewL(const TDesC& aTestName, TTestType aTestType)

   662 	{

   663 	CTestDevVideoPlaySynchronizeDecoding* self = new(ELeave) CTestDevVideoPlaySynchronizeDecoding(aTestName, aTestType);

   664 	return self;

   665 	}

   667 TVerdict CTestDevVideoPlaySynchronizeDecoding::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   668 	{

   669 	TVerdict ret = EPass;

   671 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SynchronizeDecoding"));

   673 	// expected results

   674 	if (iTestType != ETestValid)

   675 		{

   676 		ERR_PRINTF1(_L("Error - invalid test step type"));

   677 		return EInconclusive;

   678 		}

   680 	TInt err = KErrNone;

   682 //	THwDeviceId hwDecoder = 0;

   683 //	THwDeviceId hwPostProc = 0;

   685 	// select decoder

   686 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   687 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// eABI warning removal

   688 	if (err != KErrNone)

   689 		{

   690 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   691 			return EInconclusive;

   692 		}

   694 	// select post-processor

   695 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   696 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// eABI warning removal

   697 	if (err != KErrNone)

   698 		{

   699 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   700 			return EInconclusive;

   701 		}

   703 	// call synchronize decoding on Decoder

   704 	aDevVideoPlay.SynchronizeDecoding(ETrue);

   705 	// if this doesn't panic then test passes

   707 	INFO_PRINTF1(_L("SynchronizeDecoding() called successfully."));

   709 	return ret;

   710 	}

   711 //------------------------------------------------------------------

   713 CTestDevVideoPlaySetBufferOptions::CTestDevVideoPlaySetBufferOptions(const TDesC& aTestName, TTestType aTestType)

   714 	:CTestDevVideoPlayStep(aTestName, aTestType)

   715 	{

   716 	}

   718 CTestDevVideoPlaySetBufferOptions* CTestDevVideoPlaySetBufferOptions::NewL(const TDesC& aTestName, TTestType aTestType)

   719 	{

   720 	CTestDevVideoPlaySetBufferOptions* self = new(ELeave) CTestDevVideoPlaySetBufferOptions(aTestName, aTestType);

   721 	return self;

   722 	}

   724 TVerdict CTestDevVideoPlaySetBufferOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   725 	{

   726 	TVerdict ret = EPass;

   727 	TInt expErr = KErrNone;

   729 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetBufferOptions"));

   731 	// expected results

   732 	if (iTestType != ETestValid)

   733 		{

   734 		ERR_PRINTF1(_L("Error - invalid test step type"));

   735 		return EInconclusive;

   736 		}

   738 	TInt err = KErrNone;

   740 //	THwDeviceId hwDecoder = 0;

   741 //	THwDeviceId hwPostProc = 0;

   743 	// select decoder

   744 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   745 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

   746 	if (err != KErrNone)

   747 		{

   748 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   749 			return EInconclusive;

   750 		}

   752 	// select post-processor

   753 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   754 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

   755 	if (err != KErrNone)

   756 		{

   757 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   758 			return EInconclusive;

   759 		}

   761 	// initialize buffer options to the test data

   762 	CMMFDevVideoPlay::TBufferOptions buffOptions = GetTestBufferOptions();

   764 	// set buffer options on decoder [will leave on error]

   765 	TRAP(err, aDevVideoPlay.SetBufferOptionsL(buffOptions) );

   767 	if (err != expErr)

   768 		{

   769 		ERR_PRINTF3(_L("SetBufferOptionsL() gave error %d (expected %d)"),err, expErr);

   770 		ret = EFail;

   771 		}

   772 	else

   773 		INFO_PRINTF3(_L("SetBufferOptions(), %d = %d"), err, expErr);

   775 	return ret;

   776 	}

   777 //------------------------------------------------------------------

   779 CTestDevVideoPlayGetBufferOptions::CTestDevVideoPlayGetBufferOptions(const TDesC& aTestName, TTestType aTestType)

   780 	:CTestDevVideoPlayStep(aTestName, aTestType)

   781 	{

   782 	}

   784 CTestDevVideoPlayGetBufferOptions* CTestDevVideoPlayGetBufferOptions::NewL(const TDesC& aTestName, TTestType aTestType)

   785 	{

   786 	CTestDevVideoPlayGetBufferOptions* self = new(ELeave) CTestDevVideoPlayGetBufferOptions(aTestName, aTestType);

   787 	return self;

   788 	}

   790 TVerdict CTestDevVideoPlayGetBufferOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   791 	{

   792 	TVerdict ret = EPass;

   793 	TInt expErr = KErrNone;

   795 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBufferOptions"));

   797 	// expected results

   798 	if (iTestType != ETestValid)

   799 		{

   800 		ERR_PRINTF1(_L("Error - invalid test step type"));

   801 		return EInconclusive;

   802 		}

   804 	TInt err = KErrNone;

   806 //	THwDeviceId hwDecoder = 0;

   807 //	THwDeviceId hwPostProc = 0;

   809 	// select decoder

   810 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   811 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

   812 	if (err != KErrNone)

   813 		{

   814 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   815 			return EInconclusive;

   816 		}

   818 	// select post-processor

   819 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   820 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

   821 	if (err != KErrNone)

   822 		{

   823 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   824 			return EInconclusive;

   825 		}

   827 	// get buffer options from the decoder

   828 	CMMFDevVideoPlay::TBufferOptions buffOptions;

   829 	aDevVideoPlay.GetBufferOptions(buffOptions);

   831 	// compare this to the test data

   832 	if ( !CompareBufferOptions(buffOptions, GetTestBufferOptions()) )

   833 		{

   834 		ERR_PRINTF1(_L("GetBufferOptions() comparison with test data failed!"));

   835 		ret = EFail;

   836 		}

   837 	else

   838 		{

   839 		INFO_PRINTF1(_L("GetBufferOptions() comparison with test data passed."));

   840 		INFO_PRINTF3(_L("GetBufferOptions(), %d = %d"), err, expErr);

   841 		}

   843 	return ret;

   844 	}

   845 //------------------------------------------------------------------

   847 CTestDevVideoPlaySetHrdVbv::CTestDevVideoPlaySetHrdVbv(const TDesC& aTestName, TTestType aTestType)

   848 	:CTestDevVideoPlayStep(aTestName, aTestType)

   849 	{

   850 	}

   852 CTestDevVideoPlaySetHrdVbv* CTestDevVideoPlaySetHrdVbv::NewL(const TDesC& aTestName, TTestType aTestType)

   853 	{

   854 	CTestDevVideoPlaySetHrdVbv* self = new(ELeave) CTestDevVideoPlaySetHrdVbv(aTestName, aTestType);

   855 	return self;

   856 	}

   858 TVerdict CTestDevVideoPlaySetHrdVbv::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   859 	{

   860 	TVerdict ret = EPass;

   862 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetHrdVbv"));

   864 	// expected results

   865 	if (iTestType != ETestValid)

   866 		{

   867 		ERR_PRINTF1(_L("Error - invalid test step type"));

   868 		return EInconclusive;

   869 		}

   871 	TInt err = KErrNone;

   873 //	THwDeviceId hwDecoder = 0;

   874 //	THwDeviceId hwPostProc = 0;

   876 	// select decoder

   877 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   878 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

   879 	if (err != KErrNone)

   880 		{

   881 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   882 			return EInconclusive;

   883 		}

   885 	// select post-processor

   886 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   887 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

   888 	if (err != KErrNone)

   889 		{

   890 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   891 			return EInconclusive;

   892 		}

   894 	HBufC8* hrdVbvParams = NULL;

   895 	TRAP(err, hrdVbvParams = KTestHrdVbvParams().AllocL());

   896 	if (err != KErrNone)

   897 		{

   898 		ERR_PRINTF1(_L("Error - couldn't initialize hrd/vbv params"));

   899 			return EInconclusive;

   900 		}

   902 	// set hrd/vbv spec on decoder

   903 	aDevVideoPlay.SetHrdVbvSpec(KTestHrdVbvSpec, *hrdVbvParams);

   904 	// if this doesn't panic then test has passed

   906 	// delete copy

   907 	delete hrdVbvParams; hrdVbvParams = NULL;

   909 	INFO_PRINTF1(_L("SetHrdVbvSpec() called successfully."));

   911 	return ret;

   912 	}

   914 //------------------------------------------------------------------

   916 void CTestDevVideoPlayInit::MdvpoInitComplete(TInt aError)

   917 	{

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

   920 	iError = aError;

   921 	}

   923 CTestDevVideoPlayInit::CTestDevVideoPlayInit(const TDesC& aTestName, TTestType aTestType)

   924 	:CTestDevVideoPlayStep(aTestName, aTestType)

   925 	{

   926 	}

   928 CTestDevVideoPlayInit* CTestDevVideoPlayInit::NewL(const TDesC& aTestName, TTestType aTestType)

   929 	{

   930 	CTestDevVideoPlayInit* self = new(ELeave) CTestDevVideoPlayInit(aTestName, aTestType);

   931 	return self;

   932 	}

   934 TVerdict CTestDevVideoPlayInit::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   935 	{

   936 	TVerdict ret = EPass;

   937 	TInt expErr = KErrNone;

   939 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Init"));

   941 	// expected results

   942 	if (iTestType != ETestValid)

   943 		{

   944 		ERR_PRINTF1(_L("Error - invalid test step type"));

   945 		return EInconclusive;

   946 		}

   948 	TInt err = KErrNone;

   950 //	THwDeviceId hwDecoder = 0;

   951 //	THwDeviceId hwPostProc = 0;

   953 	// select decoder

   954 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

   955 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

   956 	if (err != KErrNone)

   957 		{

   958 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

   959 			return EInconclusive;

   960 		}

   962 	// select post-processor

   963 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

   964 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

   965 	if (err != KErrNone)

   966 		{

   967 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

   968 			return EInconclusive;

   969 		}

   971 	// initialize CDevVideoPlay and wait for response in iError

   972 	// iError is set by the MdvpoInitComplete callback

   973 	aDevVideoPlay.Initialize();

   975 	if (iError != expErr)

   976 		{

   977 		ERR_PRINTF3(_L("Initialize() gave error %d (expected %d)"),iError, expErr);

   978 		ret = EFail;

   979 		}

   980 	else

   981 		INFO_PRINTF3(_L("Initialize(), %d = %d"), iError, expErr);

   983 	return ret;

   984 	}

   986 //------------------------------------------------------------------

   988 void CTestDevVideoPlayStartDSA::MdvpoInitComplete(TInt aError)

   989 	{

   990 	INFO_PRINTF2(_L("CTestDevVideoPlayStartDSA::MdvpoInitComplete():  Error = %d"), aError);

   992 	iError = aError;

   993 	}

   995 CTestDevVideoPlayStartDSA::CTestDevVideoPlayStartDSA(const TDesC& aTestName, TTestType aTestType)

   996 	:CTestDevVideoPlayStep(aTestName, aTestType)

   997 	{

   998 	}

  1000 CTestDevVideoPlayStartDSA* CTestDevVideoPlayStartDSA::NewL(const TDesC& aTestName, TTestType aTestType)

  1001 	{

  1002 	CTestDevVideoPlayStartDSA* self = new(ELeave) CTestDevVideoPlayStartDSA(aTestName, aTestType);

  1003 	return self;

  1004 	}

  1006 TVerdict CTestDevVideoPlayStartDSA::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1007 	{

  1008 	TVerdict ret = EPass;

  1009 	TInt expErr = KErrNone;

  1011 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  StartDSA"));

  1013 	// expected results

  1014 	if (iTestType != ETestValid)

  1015 		{

  1016 		ERR_PRINTF1(_L("Error - invalid test step type"));

  1017 		return EInconclusive;

  1018 		}

  1020 	TInt err = KErrNone;

  1022 //	THwDeviceId hwDecoder = 0;

  1023 //	THwDeviceId hwPostProc = 0;

  1025 	// select decoder

  1026 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1027 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1028 	if (err != KErrNone)

  1029 		{

  1030 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1031 			return EInconclusive;

  1032 		}

  1034 	// select post-processor

  1035 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1036 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1037 	if (err != KErrNone)

  1038 		{

  1039 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1040 			return EInconclusive;

  1041 		}

  1043 	// initialize CDevVideoPlay and wait for response

  1044 	// iError is set by the MdvpoInitComplete callback

  1045 	aDevVideoPlay.Initialize();

  1046 	if (iError != KErrNone)

  1047 		{

  1048 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1049 			return EInconclusive;

  1050 		}

  1052 	// screen device is independant of DevVideo so we can construct one here

  1053 	// and just check that it is non NULL at the plugin

  1054 	CFbsScreenDevice *screenDev = NULL;

  1055 	TRAP(err, screenDev = CFbsScreenDevice::NewL(_L("scdv"), EColor16));

  1056 	if (err != KErrNone)

  1057 		{

  1058 		ERR_PRINTF1(_L("Error - couldn't initialize screen device"));

  1059 		//return EInconclusive;

  1060 		}

  1062 	TRect dsaRect(KTestDSARectA, KTestDSARectB, KTestDSARectC, KTestDSARectD);

  1063 	TRegionFix<1> reg1(dsaRect);

  1065 	// start direct screen access

  1066 	TRAP(err, aDevVideoPlay.StartDirectScreenAccessL(dsaRect, *screenDev, reg1) );

  1068 	// delete screen device and rect

  1069 	delete screenDev;

  1070 	screenDev = NULL;

  1072 	reg1.Clear();

  1074 	if (err != expErr)

  1075 		{

  1076 		ERR_PRINTF3(_L("StartDirectScreenAccessL() gave error %d (expected %d)"),err, expErr);

  1077 		ret = EFail;

  1078 		}

  1079 	else

  1080 		INFO_PRINTF3(_L("StartDirectScreenAccessL(), %d = %d"), err, expErr);

  1082 	return ret;

  1083 	}

  1084 //------------------------------------------------------------------

  1086 void CTestDevVideoPlaySetClipRegion::MdvpoInitComplete(TInt aError)

  1087 	{

  1088 	INFO_PRINTF2(_L("CTestDevVideoPlaySetClipRegion::MdvpoInitComplete():  Error = %d"), aError);

  1090 	iError = aError;

  1091 	}

  1093 CTestDevVideoPlaySetClipRegion::CTestDevVideoPlaySetClipRegion(const TDesC& aTestName, TTestType aTestType)

  1094 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1095 	{

  1096 	}

  1098 CTestDevVideoPlaySetClipRegion* CTestDevVideoPlaySetClipRegion::NewL(const TDesC& aTestName, TTestType aTestType)

  1099 	{

  1100 	CTestDevVideoPlaySetClipRegion* self = new(ELeave) CTestDevVideoPlaySetClipRegion(aTestName, aTestType);

  1101 	return self;

  1102 	}

  1104 TVerdict CTestDevVideoPlaySetClipRegion::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1105 	{

  1106 	TVerdict ret = EPass;

  1108 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetClipRegion"));

  1110 	// expected results

  1111 	if (iTestType != ETestValid)

  1112 		{

  1113 		ERR_PRINTF1(_L("Error - invalid test step type"));

  1114 		return EInconclusive;

  1115 		}

  1117 	TInt err = KErrNone;

  1119 //	THwDeviceId hwDecoder = 0;

  1120 //	THwDeviceId hwPostProc = 0;

  1122 	// select decoder

  1123 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1124 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// eABI warning removal

  1125 	if (err != KErrNone)

  1126 		{

  1127 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1128 			return EInconclusive;

  1129 		}

  1131 	// select post-processor

  1132 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1133 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1134 	if (err != KErrNone)

  1135 		{

  1136 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1137 			return EInconclusive;

  1138 		}

  1140 	// initialize CDevVideoPlay and wait for response

  1141 	// iError is set by the MdvpoInitComplete callback

  1142 	aDevVideoPlay.Initialize();

  1144 	if (iError != KErrNone)

  1145 		{

  1146 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1147 			return EInconclusive;

  1148 		}

  1150 	TRect dsaRect(KTestDSARectA, KTestDSARectB, KTestDSARectC, KTestDSARectD);

  1151 	TRegionFix<1> reg1(dsaRect);

  1153 	// set clip region

  1154 	aDevVideoPlay.SetScreenClipRegion(reg1);

  1156 	// clear region

  1157 	reg1.Clear();

  1159 	// if no PANIC then test has passed

  1160 	INFO_PRINTF1(_L("SetScreenClipRegion() called successfully"));

  1162 	return ret;

  1163 	}

  1164 //------------------------------------------------------------------

  1166 void CTestDevVideoPlaySetPauseClipFail::MdvpoInitComplete(TInt aError)

  1167 	{

  1168 	INFO_PRINTF2(_L("CTestDevVideoPlaySetPauseClipFail::MdvpoInitComplete():  Error = %d"), aError);

  1170 	iError = aError;

  1171 	}

  1173 CTestDevVideoPlaySetPauseClipFail::CTestDevVideoPlaySetPauseClipFail(const TDesC& aTestName, TTestType aTestType)

  1174 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1175 	{

  1176 	}

  1178 CTestDevVideoPlaySetPauseClipFail* CTestDevVideoPlaySetPauseClipFail::NewL(const TDesC& aTestName, TTestType aTestType)

  1179 	{

  1180 	CTestDevVideoPlaySetPauseClipFail* self = new(ELeave) CTestDevVideoPlaySetPauseClipFail(aTestName, aTestType);

  1181 	return self;

  1182 	}

  1184 TVerdict CTestDevVideoPlaySetPauseClipFail::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1185 	{

  1186 	TVerdict ret = EPass;

  1188 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetPauseClipFail"));

  1190 	// expected results

  1191 	if (iTestType != ETestValid)

  1192 		{

  1193 		ERR_PRINTF1(_L("Error - invalid test step type"));

  1194 		return EInconclusive;

  1195 		}

  1197 	TInt err = KErrNone;

  1199 //	THwDeviceId hwDecoder = 0;

  1200 //	THwDeviceId hwPostProc = 0;

  1202 	// select decoder

  1203 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1204 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1205 	if (err != KErrNone)

  1206 		{

  1207 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1208 			return EInconclusive;

  1209 		}

  1211 	// select post-processor

  1212 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1213 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1214 	if (err != KErrNone)

  1215 		{

  1216 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1217 			return EInconclusive;

  1218 		}

  1220 	// initialize CDevVideoPlay and wait for response

  1221 	// iError is set by the MdvpoInitComplete callback

  1222 	aDevVideoPlay.Initialize();

  1224 	if (iError != KErrNone)

  1225 		{

  1226 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1227 			return EInconclusive;

  1228 		}

  1230 	// set pause on clip fail to ETrue

  1231 	aDevVideoPlay.SetPauseOnClipFail(ETrue);

  1233 	// if no PANIC then test has passed

  1234 	INFO_PRINTF1(_L("SetPauseClipFail() called successfully"));

  1236 	return ret;

  1237 	}

  1238 //------------------------------------------------------------------

  1240 void CTestDevVideoPlayAbortDSA::MdvpoInitComplete(TInt aError)

  1241 	{

  1242 	INFO_PRINTF2(_L("CTestDevVideoPlayAbortDSA::MdvpoInitComplete():  Error = %d"), aError);

  1244 	iError = aError;

  1245 	}

  1247 CTestDevVideoPlayAbortDSA::CTestDevVideoPlayAbortDSA(const TDesC& aTestName, TTestType aTestType)

  1248 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1249 	{

  1250 	}

  1252 CTestDevVideoPlayAbortDSA* CTestDevVideoPlayAbortDSA::NewL(const TDesC& aTestName, TTestType aTestType)

  1253 	{

  1254 	CTestDevVideoPlayAbortDSA* self = new(ELeave) CTestDevVideoPlayAbortDSA(aTestName, aTestType);

  1255 	return self;

  1256 	}

  1258 TVerdict CTestDevVideoPlayAbortDSA::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1259 	{

  1260 	TVerdict ret = EPass;

  1262 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  AbortDSA"));

  1264 	// expected results

  1265 	if (iTestType != ETestValid)

  1266 		{

  1267 		ERR_PRINTF1(_L("Error - invalid test step type"));

  1268 		return EInconclusive;

  1269 		}

  1271 	TInt err = KErrNone;

  1273 //	THwDeviceId hwDecoder = 0;

  1274 //	THwDeviceId hwPostProc = 0;

  1276 	// select decoder

  1277 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1278 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1279 	if (err != KErrNone)

  1280 		{

  1281 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1282 			return EInconclusive;

  1283 		}

  1285 	// select post-processor

  1286 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1287 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// eABI warning removal

  1288 	if (err != KErrNone)

  1289 		{

  1290 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1291 			return EInconclusive;

  1292 		}

  1294 	// initialize CDevVideoPlay and wait for response

  1295 	// iError is set by the MdvpoInitComplete callback

  1296 	aDevVideoPlay.Initialize();

  1298 	if (iError != KErrNone)

  1299 		{

  1300 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1301 			return EInconclusive;

  1302 		}

  1304 	// abort direct screen access [is there a way to check this?]

  1305 	aDevVideoPlay.AbortDirectScreenAccess();

  1307 	INFO_PRINTF1(_L("AbortDirectScreenAccess() called successfully"));

  1309 	return ret;

  1310 	}

  1311 //------------------------------------------------------------------

  1313 void CTestDevVideoPlayIsPlaying::MdvpoInitComplete(TInt aError)

  1314 	{

  1315 	INFO_PRINTF2(_L("CTestDevVideoPlayIsPlaying::MdvpoInitComplete():  Error = %d"), aError);

  1317 	iError = aError;

  1318 	}

  1320 CTestDevVideoPlayIsPlaying::CTestDevVideoPlayIsPlaying(const TDesC& aTestName, TTestType aTestType)

  1321 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1322 	{

  1323 	}

  1325 CTestDevVideoPlayIsPlaying* CTestDevVideoPlayIsPlaying::NewL(const TDesC& aTestName, TTestType aTestType)

  1326 	{

  1327 	CTestDevVideoPlayIsPlaying* self = new(ELeave) CTestDevVideoPlayIsPlaying(aTestName, aTestType);

  1328 	return self;

  1329 	}

  1331 TVerdict CTestDevVideoPlayIsPlaying::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1332 	{

  1333 	TVerdict ret = EPass;

  1335 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  IsPlaying"));

  1337 	// expected results

  1338 	if (iTestType != ETestValid)

  1339 		{

  1340 		ERR_PRINTF1(_L("Error - invalid test step type"));

  1341 		return EInconclusive;

  1342 		}

  1344 	TInt err = KErrNone;

  1346 //	THwDeviceId hwDecoder = 0;

  1347 //	THwDeviceId hwPostProc = 0;

  1349 	// select decoder

  1350 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1351 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1352 	if (err != KErrNone)

  1353 		{

  1354 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1355 			return EInconclusive;

  1356 		}

  1358 	// select post-processor

  1359 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1360 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1361 	if (err != KErrNone)

  1362 		{

  1363 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1364 			return EInconclusive;

  1365 		}

  1367 	// initialize CDevVideoPlay and wait for response

  1368 	// iError is set by the MdvpoInitComplete callback

  1369 	aDevVideoPlay.Initialize();

  1371 	if (iError != KErrNone)

  1372 		{

  1373 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1374 			return EInconclusive;

  1375 		}

  1377 	TBool playing = ETrue;

  1379 	// check DevVideoPlay is not playing

  1380 	playing = aDevVideoPlay.IsPlaying();

  1382 	if (playing)

  1383 		{

  1384 		ERR_PRINTF1(_L("IsPlaying() reported ETrue - expected EFalse!"));

  1385 		ret = EFail;

  1386 		}

  1387 	else

  1388 		INFO_PRINTF1(_L("IsPlaying() returned EFalse as expected"));

  1390 	return ret;

  1391 	}

  1392 //------------------------------------------------------------------

  1394 void CTestDevVideoPlayRedraw::MdvpoInitComplete(TInt aError)

  1395 	{

  1396 	INFO_PRINTF2(_L("CTestDevVideoPlayRedraw::MdvpoInitComplete():  Error = %d"), aError);

  1398 	iError = aError;

  1399 	}

  1401 CTestDevVideoPlayRedraw::CTestDevVideoPlayRedraw(const TDesC& aTestName, TTestType aTestType)

  1402 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1403 	{

  1404 	}

  1406 CTestDevVideoPlayRedraw* CTestDevVideoPlayRedraw::NewL(const TDesC& aTestName, TTestType aTestType)

  1407 	{

  1408 	CTestDevVideoPlayRedraw* self = new(ELeave) CTestDevVideoPlayRedraw(aTestName, aTestType);

  1409 	return self;

  1410 	}

  1412 TVerdict CTestDevVideoPlayRedraw::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1413 	{

  1414 	TVerdict ret = EPass;

  1416 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Redraw"));

  1418 	// expected results

  1419 	if (iTestType != ETestValid)

  1420 		{

  1421 		ERR_PRINTF1(_L("Error - invalid test step type"));

  1422 		return EInconclusive;

  1423 		}

  1425 	TInt err = KErrNone;

  1427 //	THwDeviceId hwDecoder = 0;

  1428 //	THwDeviceId hwPostProc = 0;

  1430 	// select decoder

  1431 //	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1432 	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1433 	if (err != KErrNone)

  1434 		{

  1435 		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1436 			return EInconclusive;

  1437 		}

  1439 	// select post-processor

  1440 //	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1441 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1442 	if (err != KErrNone)

  1443 		{

  1444 		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1445 			return EInconclusive;

  1446 		}

  1448 	// initialize CDevVideoPlay and wait for response

  1449 	// iError is set by the MdvpoInitComplete callback

  1450 	aDevVideoPlay.Initialize();

  1452 	if (iError != KErrNone)

  1453 		{

  1454 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1455 			return EInconclusive;

  1456 		}

  1458 	// call redraw [is there a way to check this?]

  1459 	aDevVideoPlay.Redraw();

  1461 	INFO_PRINTF1(_L("Redraw() called successfully"));

  1463 	return ret;

  1464 	}

  1465 //------------------------------------------------------------------

  1467 void CTestDevVideoPlayStart::MdvpoInitComplete(TInt aError)

  1468 	{

  1469 	INFO_PRINTF2(_L("CTestDevVideoPlayStart::MdvpoInitComplete():  Error = %d"), aError);

  1471 	iError = aError;

  1472 	}

  1474 CTestDevVideoPlayStart::CTestDevVideoPlayStart(const TDesC& aTestName, TTestType aTestType)

  1475 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1476 	{

  1477 	}

  1479 CTestDevVideoPlayStart* CTestDevVideoPlayStart::NewL(const TDesC& aTestName, TTestType aTestType)

  1480 	{

  1481 	CTestDevVideoPlayStart* self = new(ELeave) CTestDevVideoPlayStart(aTestName, aTestType);

  1482 	return self;

  1483 	}

  1485 TVerdict CTestDevVideoPlayStart::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1486 	{

  1487 	TVerdict ret = EPass;

  1488 //	TInt expErr = KErrNone;

  1489 	TBool selDec = ETrue;

  1490 	TBool selPost = ETrue;

  1492 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Start"));

  1494 	// expected results

  1495 	switch(iTestType)

  1496 		{

  1497 		case ETestValid:

  1498 //			expErr = KErrNone;	// EABI warning removal

  1499 			break;

  1500 		case ETestDecoderOnly:

  1501 			selPost = EFalse;

  1502 			break;

  1503 		case ETestPostProcOnly:

  1504 			selDec = EFalse;

  1505 			break;

  1506 		default:

  1507 			ERR_PRINTF1(_L("Error - invalid test step type"));

  1508 			return EInconclusive;

  1509 		}

  1511 	TInt err = KErrNone;

  1513 //	THwDeviceId hwDecoder = 0;

  1514 //	THwDeviceId hwPostProc = 0;

  1516 	// select decoder

  1517 	if (selDec)

  1518 		{

  1519 //		TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1520 		TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1521 		if (err != KErrNone)

  1522 			{

  1523 			ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1524 				return EInconclusive;

  1525 			}

  1526 		}

  1528 	// select post-processor

  1529 	if (selPost)

  1530 		{

  1531 //		TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1532 		TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABIO warning removal

  1533 		if (err != KErrNone)

  1534 			{

  1535 			ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1536 				return EInconclusive;

  1537 			}

  1538 		}

  1540 	// initialize CDevVideoPlay and wait for response

  1541 	// iError is set by the MdvpoInitComplete callback

  1542 	aDevVideoPlay.Initialize();

  1544 	if (iError != KErrNone)

  1545 		{

  1546 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1547 			return EInconclusive;

  1548 		}

  1550 	// check not already playing

  1551 	TBool playing = aDevVideoPlay.IsPlaying();

  1552 	if (playing)

  1553 		{

  1554 		ERR_PRINTF1(_L("Error - DevVideoPlay already playing!"));

  1555 			return EInconclusive;

  1556 		}

  1558 	// call start on DevVideoPlay then check IsPlaying()

  1559 	aDevVideoPlay.Start();

  1560 	playing = aDevVideoPlay.IsPlaying();

  1562 	if (!playing)

  1563 		{

  1564 		ERR_PRINTF1(_L("IsPlaying() returned EFalse - expected ETrue"));

  1565 		ret = EFail;

  1566 		}

  1567 	else

  1568 		INFO_PRINTF1(_L("Start() called successfully"));

  1570 	return ret;

  1571 	}

  1572 //------------------------------------------------------------------

  1574 void CTestDevVideoPlayStop::MdvpoInitComplete(TInt aError)

  1575 	{

  1576 	INFO_PRINTF2(_L("CTestDevVideoPlayStop::MdvpoInitComplete():  Error = %d"), aError);

  1578 	iError = aError;

  1579 	}

  1581 CTestDevVideoPlayStop::CTestDevVideoPlayStop(const TDesC& aTestName, TTestType aTestType)

  1582 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1583 	{

  1584 	}

  1586 CTestDevVideoPlayStop* CTestDevVideoPlayStop::NewL(const TDesC& aTestName, TTestType aTestType)

  1587 	{

  1588 	CTestDevVideoPlayStop* self = new(ELeave) CTestDevVideoPlayStop(aTestName, aTestType);

  1589 	return self;

  1590 	}

  1592 TVerdict CTestDevVideoPlayStop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1593 	{

  1594 	TVerdict ret = EPass;

  1595 //	TInt expErr = KErrNone;

  1596 	TBool selDec = ETrue;

  1597 	TBool selPost = ETrue;

  1599 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Stop"));

  1601 	// expected results

  1602 	switch(iTestType)

  1603 		{

  1604 		case ETestValid:

  1605 //			expErr = KErrNone;	// EABI warning removal

  1606 			break;

  1607 		case ETestDecoderOnly:

  1608 			selPost = EFalse;

  1609 			break;

  1610 		case ETestPostProcOnly:

  1611 			selDec = EFalse;

  1612 			break;

  1613 		default:

  1614 			ERR_PRINTF1(_L("Error - invalid test step type"));

  1615 			return EInconclusive;

  1616 		}

  1618 	TInt err = KErrNone;

  1620 //	THwDeviceId hwDecoder = 0;

  1621 //	THwDeviceId hwPostProc = 0;

  1623 	// select decoder

  1624 	if (selDec)

  1625 		{

  1626 //		TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1627 		TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1628 		if (err != KErrNone)

  1629 			{

  1630 			ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1631 				return EInconclusive;

  1632 			}

  1633 		}

  1635 	// select post-processor

  1636 	if (selPost)

  1637 		{

  1638 //		TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1639 		TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1640 		if (err != KErrNone)

  1641 			{

  1642 			ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1643 				return EInconclusive;

  1644 			}

  1645 		}

  1646 	// initialize CDevVideoPlay and wait for response

  1647 	// iError is set by the MdvpoInitComplete callback

  1648 	aDevVideoPlay.Initialize();

  1650 	if (iError != KErrNone)

  1651 		{

  1652 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1653 			return EInconclusive;

  1654 		}

  1656 	// check DevVideoPlay has started playing then call stop

  1657 	aDevVideoPlay.Start();

  1658 	TBool playing = aDevVideoPlay.IsPlaying();

  1660 	if (!playing)

  1661 		{

  1662 		ERR_PRINTF1(_L("Error - couldn't start playback!"));

  1663 			return EInconclusive;

  1664 		}

  1666 	// call stop

  1667 	aDevVideoPlay.Stop();

  1668 	playing = aDevVideoPlay.IsPlaying();

  1670 	if (playing)

  1671 		{

  1672 		ERR_PRINTF1(_L("IsPlaying() returned ETrue - expected EFalse"));

  1673 		ret = EFail;

  1674 		}

  1675 	else

  1676 		INFO_PRINTF1(_L("Stop() called successfully"));

  1678 	return ret;

  1679 	}

  1680 //------------------------------------------------------------------

  1682 void CTestDevVideoPlayPause::MdvpoInitComplete(TInt aError)

  1683 	{

  1684 	INFO_PRINTF2(_L("CTestDevVideoPlayPause::MdvpoInitComplete():  Error = %d"), aError);

  1686 	iError = aError;

  1687 	}

  1689 CTestDevVideoPlayPause::CTestDevVideoPlayPause(const TDesC& aTestName, TTestType aTestType)

  1690 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1691 	{

  1692 	}

  1694 CTestDevVideoPlayPause* CTestDevVideoPlayPause::NewL(const TDesC& aTestName, TTestType aTestType)

  1695 	{

  1696 	CTestDevVideoPlayPause* self = new(ELeave) CTestDevVideoPlayPause(aTestName, aTestType);

  1697 	return self;

  1698 	}

  1700 TVerdict CTestDevVideoPlayPause::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1701 	{

  1702 	TVerdict ret = EPass;

  1703 //	TInt expErr = KErrNone;

  1704 	TBool selDec = ETrue;

  1705 	TBool selPost = ETrue;

  1707 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Pause"));

  1709 	// expected results

  1710 	switch(iTestType)

  1711 		{

  1712 		case ETestValid:

  1713 //			expErr = KErrNone;	// EABI warning removal

  1714 			break;

  1715 		case ETestDecoderOnly:

  1716 			selPost = EFalse;

  1717 			break;

  1718 		case ETestPostProcOnly:

  1719 			selDec = EFalse;

  1720 			break;

  1721 		default:

  1722 			ERR_PRINTF1(_L("Error - invalid test step type"));

  1723 			return EInconclusive;

  1724 		}

  1726 	TInt err = KErrNone;

  1728 //	THwDeviceId hwDecoder = 0;

  1729 //	THwDeviceId hwPostProc = 0;

  1731 	// select decoder

  1732 	if (selDec)

  1733 		{

  1734 //		TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

  1735 		TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal

  1736 		if (err != KErrNone)

  1737 			{

  1738 			ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

  1739 				return EInconclusive;

  1740 			}

  1741 		}

  1743 	// select post-processor

  1744 	if (selPost)

  1745 		{

  1746 //		TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1747 		TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal

  1748 		if (err != KErrNone)

  1749 			{

  1750 			ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

  1751 				return EInconclusive;

  1752 			}

  1753 		}

  1755 	// initialize CDevVideoPlay and wait for response

  1756 	// iError is set by the MdvpoInitComplete callback

  1757 	aDevVideoPlay.Initialize();

  1759 	if (iError != KErrNone)

  1760 		{

  1761 		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));

  1762 			return EInconclusive;

  1763 		}

  1765 	// check DevVideoPlay has started playing then call pause

  1766 	aDevVideoPlay.Start();

  1767 	TBool playing = aDevVideoPlay.IsPlaying();

  1769 	if (!playing)

  1770 		{

  1771 		ERR_PRINTF1(_L("Error - couldn't start playback!"));

  1772 			return EInconclusive;

  1773 		}

  1775 	// call pause

  1776 	aDevVideoPlay.Pause();

  1777 	playing = aDevVideoPlay.IsPlaying();

  1779 	if (playing)

  1780 		{

  1781 		ERR_PRINTF1(_L("IsPlaying() returned ETrue - expected EFalse"));

  1782 		ret = EFail;

  1783 		}

  1784 	else

  1785 		INFO_PRINTF1(_L("Pause() called successfully"));

  1787 	return ret;

  1788 	}

  1789 //------------------------------------------------------------------

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200 (2014-06-10)
changeset 1	260cb5ec6c19
permissions	-rw-r--r--