Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayThree.cpp@bde4ae8d615e

     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 void CTestDevVideoPlayResume::MdvpoInitComplete(TInt aError)

    26 	{

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

    29 	iError = aError;

    30 	}

    32 CTestDevVideoPlayResume::CTestDevVideoPlayResume(const TDesC& aTestName, TTestType aTestType)

    33 	:CTestDevVideoPlayStep(aTestName, aTestType)

    34 	{

    35 	}

    37 CTestDevVideoPlayResume* CTestDevVideoPlayResume::NewL(const TDesC& aTestName, TTestType aTestType)

    38 	{

    39 	CTestDevVideoPlayResume* self = new(ELeave) CTestDevVideoPlayResume(aTestName, aTestType);

    40 	return self;

    41 	}

    43 TVerdict CTestDevVideoPlayResume::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

    44 	{

    45 	TVerdict ret = EPass;

    46 //	TInt expErr = KErrNone;

    47 	TBool selDec = ETrue;

    48 	TBool selPost = ETrue;

    50 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Resume"));

    52 	// expected results

    53 	switch(iTestType)

    54 		{

    55 		case ETestValid:

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

    57 			break;

    58 		case ETestDecoderOnly:

    59 			selPost = EFalse;

    60 			break;

    61 		case ETestPostProcOnly:

    62 			selDec = EFalse;

    63 			break;

    64 		default:

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

    66 			return EInconclusive;

    67 		}

    69 	TInt err = KErrNone;

    71 //	THwDeviceId hwDecoder = 0;

    72 //	THwDeviceId hwPostProc = 0;

    74 	// select decoder

    75 	if (selDec)

    76 		{

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

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

    79 		if (err != KErrNone)

    80 			{

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

    82 			return EInconclusive;

    83 			}

    84 		}

    86 	// select post-processor

    87 	if (selPost)

    88 		{

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

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

    91 		if (err != KErrNone)

    92 			{

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

    94 			return EInconclusive;

    95 			}

    96 		}

    98 	// initialize CDevVideoPlay and wait for response

    99 	// iError is set by the MdvpoInitComplete callback

   100 	aDevVideoPlay.Initialize();

   102 	if (iError != KErrNone)

   103 		{

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

   105 		return EInconclusive;

   106 		}

   108 	// check not already playing

   109 	TBool playing = aDevVideoPlay.IsPlaying();

   110 	if (playing)

   111 		{

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

   113 		return EInconclusive;

   114 		}

   116 	// call resume on DevVideoPlay then check IsPlaying()

   117 	aDevVideoPlay.Resume();

   118 	playing = aDevVideoPlay.IsPlaying();

   120 	if (!playing)

   121 		{

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

   123 		ret = EFail;

   124 		}

   125 	else

   126 		INFO_PRINTF1(_L("Resume() called successfully"));

   128 	return ret;

   129 	}

   130 //------------------------------------------------------------------

   132 void CTestDevVideoPlaySetPosition::MdvpoInitComplete(TInt aError)

   133 	{

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

   136 	iError = aError;

   137 	}

   139 CTestDevVideoPlaySetPosition::CTestDevVideoPlaySetPosition(const TDesC& aTestName, TTestType aTestType)

   140 	:CTestDevVideoPlayStep(aTestName, aTestType)

   141 	{

   142 	}

   144 CTestDevVideoPlaySetPosition* CTestDevVideoPlaySetPosition::NewL(const TDesC& aTestName, TTestType aTestType)

   145 	{

   146 	CTestDevVideoPlaySetPosition* self = new(ELeave) CTestDevVideoPlaySetPosition(aTestName, aTestType);

   147 	return self;

   148 	}

   150 TVerdict CTestDevVideoPlaySetPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   151 	{

   152 	TVerdict ret = EPass;

   153 	TInt expErr = KErrNone;

   154 	TBool selDec = ETrue;

   155 	TBool selPost = ETrue;

   156 	TInt testPos = KTestPosition;

   158 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetPosition"));

   160 	// expected results

   161 	switch(iTestType)

   162 		{

   163 		case ETestValid:

   164 			expErr = KErrNone;

   165 			break;

   166 		case ETestBothFatal:

   167 			expErr = KErrDied;

   168 			testPos = KTestPositionFatal;

   169 			break;

   170 		case ETestDecoderFatal:

   171 			expErr = KErrDied;

   172 			testPos = KTestPositionFatal;

   173 			// fall through to set post proc to false;

   174 		case ETestDecoderOnly:

   175 			selPost = EFalse;

   176 			break;

   177 		case ETestPostProcFatal:

   178 			expErr = KErrDied;

   179 			testPos = KTestPositionFatal;

   180 			// fall through to set decoder to false;

   181 		case ETestPostProcOnly:

   182 			selDec = EFalse;

   183 			break;

   184 		default:

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

   186 			return EInconclusive;

   187 		}

   189 	TInt err = KErrNone;

   191 //	THwDeviceId hwDecoder = 0;

   192 //	THwDeviceId hwPostProc = 0;

   194 	// select decoder

   195 	if (selDec)

   196 		{

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

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

   199 		if (err != KErrNone)

   200 			{

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

   202 			return EInconclusive;

   203 			}

   204 		}

   206 	// select post-processor

   207 	if (selPost)

   208 		{

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

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

   211 		if (err != KErrNone)

   212 			{

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

   214 			return EInconclusive;

   215 			}

   216 		}

   218 	// initialize CDevVideoPlay and wait for response

   219 	// iError is set by the MdvpoInitComplete callback

   220 	aDevVideoPlay.Initialize();

   222 	if (iError != KErrNone)

   223 		{

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

   225 		return EInconclusive;

   226 		}

   228 	TTimeIntervalMicroSeconds pos(testPos);

   230 	// call SetPosition

   231 	aDevVideoPlay.SetPosition(pos);

   233 	// if no PANIC and iError is as expected then test has passed

   234 	// if performing a fatal test then expect iError = KErrDied

   235 	if (iError == expErr)

   236 		{

   237 		ERR_PRINTF3(_L("SetPosition() got error %d;  Expected %d"), iError, expErr);

   238 		}

   239 	else

   240 		{

   241 		INFO_PRINTF1(_L("SetPosition() called successfully"));

   242 		}

   243 	return ret;

   244 	}

   245 //------------------------------------------------------------------

   247 void CTestDevVideoPlayFreezePicture::MdvpoInitComplete(TInt aError)

   248 	{

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

   251 	iError = aError;

   252 	}

   254 CTestDevVideoPlayFreezePicture::CTestDevVideoPlayFreezePicture(const TDesC& aTestName, TTestType aTestType)

   255 	:CTestDevVideoPlayStep(aTestName, aTestType)

   256 	{

   257 	}

   259 CTestDevVideoPlayFreezePicture* CTestDevVideoPlayFreezePicture::NewL(const TDesC& aTestName, TTestType aTestType)

   260 	{

   261 	CTestDevVideoPlayFreezePicture* self = new(ELeave) CTestDevVideoPlayFreezePicture(aTestName, aTestType);

   262 	return self;

   263 	}

   265 TVerdict CTestDevVideoPlayFreezePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   266 	{

   267 	TVerdict ret = EPass;

   269 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  FreezePicture"));

   271 	// expected results

   272 	if (iTestType != ETestValid)

   273 		{

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

   275 		return EInconclusive;

   276 		}

   278 	TInt err = KErrNone;

   280 //	THwDeviceId hwDecoder = 0;

   281 //	THwDeviceId hwPostProc = 0;

   283 	// select decoder

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

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

   286 	if (err != KErrNone)

   287 		{

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

   289 		return EInconclusive;

   290 		}

   292 	// select post-processor

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

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

   295 	if (err != KErrNone)

   296 		{

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

   298 		return EInconclusive;

   299 		}

   301 	// initialize CDevVideoPlay and wait for response

   302 	// iError is set by the MdvpoInitComplete callback

   303 	aDevVideoPlay.Initialize();

   305 	if (iError != KErrNone)

   306 		{

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

   308 		return EInconclusive;

   309 		}

   311 	TTimeIntervalMicroSeconds pos(KTestPosition);

   313 	// call FreezePicture

   314 	aDevVideoPlay.FreezePicture(pos);

   316 	// if no PANIC then test has passed

   318 	INFO_PRINTF1(_L("FreezePicture() called successfully"));

   320 	return ret;

   321 	}

   322 //------------------------------------------------------------------

   324 void CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete(TInt aError)

   325 	{

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

   328 	iError = aError;

   329 	}

   331 CTestDevVideoPlayReleaseFreeze::CTestDevVideoPlayReleaseFreeze(const TDesC& aTestName, TTestType aTestType)

   332 	:CTestDevVideoPlayStep(aTestName, aTestType)

   333 	{

   334 	}

   336 CTestDevVideoPlayReleaseFreeze* CTestDevVideoPlayReleaseFreeze::NewL(const TDesC& aTestName, TTestType aTestType)

   337 	{

   338 	CTestDevVideoPlayReleaseFreeze* self = new(ELeave) CTestDevVideoPlayReleaseFreeze(aTestName, aTestType);

   339 	return self;

   340 	}

   342 TVerdict CTestDevVideoPlayReleaseFreeze::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   343 	{

   344 	TVerdict ret = EPass;

   346 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  ReleaseFreeze"));

   348 	// expected results

   349 	if (iTestType != ETestValid)

   350 		{

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

   352 		return EInconclusive;

   353 		}

   355 	TInt err = KErrNone;

   357 //	THwDeviceId hwDecoder = 0;

   358 //	THwDeviceId hwPostProc = 0;

   360 	// select decoder

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

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

   363 	if (err != KErrNone)

   364 		{

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

   366 		return EInconclusive;

   367 		}

   369 	// select post-processor

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

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

   372 	if (err != KErrNone)

   373 		{

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

   375 		return EInconclusive;

   376 		}

   378 	// initialize CDevVideoPlay and wait for response

   379 	// iError is set by the MdvpoInitComplete callback

   380 	aDevVideoPlay.Initialize();

   382 	if (iError != KErrNone)

   383 		{

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

   385 		return EInconclusive;

   386 		}

   388 	TTimeIntervalMicroSeconds pos(KTestPosition);

   390 	// call ReleaseFreeze

   391 	aDevVideoPlay.ReleaseFreeze(pos);

   393 	// if no PANIC then test has passed

   395 	INFO_PRINTF1(_L("ReleaseFreeze() called successfully"));

   397 	return ret;

   398 	}

   399 //------------------------------------------------------------------

   401 void CTestDevVideoPlayDecodingPosition::MdvpoInitComplete(TInt aError)

   402 	{

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

   405 	iError = aError;

   406 		}

   408 CTestDevVideoPlayDecodingPosition::CTestDevVideoPlayDecodingPosition(const TDesC& aTestName, TTestType aTestType)

   409 	:CTestDevVideoPlayStep(aTestName, aTestType)

   410 	{

   411 	}

   413 CTestDevVideoPlayDecodingPosition* CTestDevVideoPlayDecodingPosition::NewL(const TDesC& aTestName, TTestType aTestType)

   414 	{

   415 	CTestDevVideoPlayDecodingPosition* self = new(ELeave) CTestDevVideoPlayDecodingPosition(aTestName, aTestType);

   416 	return self;

   417 	}

   419 TVerdict CTestDevVideoPlayDecodingPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   420 	{

   421 	TVerdict ret = EPass;

   423 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  DecodingPosition"));

   425 	// expected results

   426 	if (iTestType != ETestValid)

   427 		{

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

   429 		return EInconclusive;

   430 		}

   432 	TInt err = KErrNone;

   434 //	THwDeviceId hwDecoder = 0;

   435 //	THwDeviceId hwPostProc = 0;

   437 	// select decoder

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

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

   440 	if (err != KErrNone)

   441 		{

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

   443 		return EInconclusive;

   444 		}

   446 	// select post-processor

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

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

   449 	if (err != KErrNone)

   450 		{

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

   452 		return EInconclusive;

   453 		}

   455 	// initialize CDevVideoPlay and wait for response

   456 	// iError is set by the MdvpoInitComplete callback

   457 	aDevVideoPlay.Initialize();

   459 	if (iError != KErrNone)

   460 		{

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

   462 		return EInconclusive;

   463 		}

   465 	// get decoding position

   466 	TTimeIntervalMicroSeconds decPos = aDevVideoPlay.DecodingPosition();

   468 	// check against test data

   469 	TTimeIntervalMicroSeconds testTime(KTestDecodePosition);

   470 	if (decPos != testTime)

   471 		{

   472 		ERR_PRINTF3(_L("DecodingPosition() incorrect - gave %d (expected %d)"),

   473 			I64LOW(decPos.Int64()), KTestDecodePosition);

   474 		ret = EFail;

   475 		}

   476 	else

   477 		INFO_PRINTF1(_L("DecodingPosition() called successfully"));

   479 	return ret;

   480 	}

   481 //------------------------------------------------------------------

   483 void CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete(TInt aError)

   484 	{

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

   487 	iError = aError;

   488 	}

   490 CTestDevVideoPlayPlaybackPosition::CTestDevVideoPlayPlaybackPosition(const TDesC& aTestName, TTestType aTestType)

   491 	:CTestDevVideoPlayStep(aTestName, aTestType)

   492 	{

   493 	}

   495 CTestDevVideoPlayPlaybackPosition* CTestDevVideoPlayPlaybackPosition::NewL(const TDesC& aTestName, TTestType aTestType)

   496 	{

   497 	CTestDevVideoPlayPlaybackPosition* self = new(ELeave) CTestDevVideoPlayPlaybackPosition(aTestName, aTestType);

   498 	return self;

   499 	}

   501 TVerdict CTestDevVideoPlayPlaybackPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   502 	{

   503 	TVerdict ret = EPass;

   505 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  PlaybackPosition"));

   507 	// expected results

   508 	if (iTestType != ETestValid)

   509 		{

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

   511 		return EInconclusive;

   512 		}

   514 	TInt err = KErrNone;

   516 //	THwDeviceId hwDecoder = 0;

   517 //	THwDeviceId hwPostProc = 0;

   519 	// select decoder

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

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

   522 	if (err != KErrNone)

   523 		{

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

   525 		return EInconclusive;

   526 		}

   528 	// select post-processor

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

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

   531 	if (err != KErrNone)

   532 		{

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

   534 		return EInconclusive;

   535 		}

   537 	// initialize CDevVideoPlay and wait for response

   538 	// iError is set by the MdvpoInitComplete callback

   539 	aDevVideoPlay.Initialize();

   541 	if (iError != KErrNone)

   542 		{

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

   544 		return EInconclusive;

   545 		}

   547 	// get playback position

   548 	TTimeIntervalMicroSeconds playPos = aDevVideoPlay.PlaybackPosition();

   550 	// check against test data

   551 	TTimeIntervalMicroSeconds testTime(KTestPlayPosition);

   552 	if (playPos != testTime)

   553 		{

   554 		ERR_PRINTF3(_L("PlaybackPosition() incorrect - gave %d (expected %d)"),

   555 			I64LOW(playPos.Int64()), KTestPlayPosition);

   556 		ret = EFail;

   557 		}

   558 	else

   559 		INFO_PRINTF1(_L("PlaybackPosition() called successfully"));

   561 	return ret;

   562 	}

   563 //------------------------------------------------------------------

   565 void CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete(TInt aError)

   566 	{

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

   569 	iError = aError;

   570 	}

   572 CTestDevVideoPlayPreDecoderBufferBytes::CTestDevVideoPlayPreDecoderBufferBytes(const TDesC& aTestName, TTestType aTestType)

   573 	:CTestDevVideoPlayStep(aTestName, aTestType)

   574 	{

   575 	}

   577 CTestDevVideoPlayPreDecoderBufferBytes* CTestDevVideoPlayPreDecoderBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType)

   578 	{

   579 	CTestDevVideoPlayPreDecoderBufferBytes* self = new(ELeave) CTestDevVideoPlayPreDecoderBufferBytes(aTestName, aTestType);

   580 	return self;

   581 	}

   583 TVerdict CTestDevVideoPlayPreDecoderBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   584 	{

   585 	TVerdict ret = EPass;

   587 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  PreDecoderBufferBytes"));

   589 	// expected results

   590 	if (iTestType != ETestValid)

   591 		{

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

   593 		return EInconclusive;

   594 		}

   596 	TInt err = KErrNone;

   598 //	THwDeviceId hwDecoder = 0;

   599 //	THwDeviceId hwPostProc = 0;

   601 	// select decoder

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

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

   604 	if (err != KErrNone)

   605 		{

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

   607 		return EInconclusive;

   608 		}

   610 	// select post-processor

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

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

   613 	if (err != KErrNone)

   614 		{

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

   616 		return EInconclusive;

   617 		}

   619 	// initialize CDevVideoPlay and wait for response

   620 	// iError is set by the MdvpoInitComplete callback

   621 	aDevVideoPlay.Initialize();

   623 	if (iError != KErrNone)

   624 		{

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

   626 		return EInconclusive;

   627 		}

   629 	// get pre-decoder buffer bytes

   630 	TUint decBytes = aDevVideoPlay.PreDecoderBufferBytes();

   632 	// check against test data

   633 	if (decBytes != KTestPreDecoderBytes)

   634 		{

   635 		ERR_PRINTF3(_L("PreDecoderBufferBytes() incorrect - gave %d (expected %d)"),

   636 			decBytes, KTestPreDecoderBytes);

   637 		ret = EFail;

   638 		}

   639 	else

   640 		INFO_PRINTF1(_L("PreDecoderBufferBytes() called successfully"));

   642 	return ret;

   643 	}

   644 //------------------------------------------------------------------

   646 void CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete(TInt aError)

   647 	{

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

   650 	iError = aError;

   651 	}

   653 CTestDevVideoPlayPictureBufferBytes::CTestDevVideoPlayPictureBufferBytes(const TDesC& aTestName, TTestType aTestType)

   654 	:CTestDevVideoPlayStep(aTestName, aTestType)

   655 	{

   656 	}

   658 CTestDevVideoPlayPictureBufferBytes* CTestDevVideoPlayPictureBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType)

   659 	{

   660 	CTestDevVideoPlayPictureBufferBytes* self = new(ELeave) CTestDevVideoPlayPictureBufferBytes(aTestName, aTestType);

   661 	return self;

   662 	}

   664 TVerdict CTestDevVideoPlayPictureBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   665 	{

   666 	TVerdict ret = EPass;

   668 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  PictureBufferBytes"));

   670 	// expected results

   671 	if (iTestType != ETestValid)

   672 		{

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

   674 		return EInconclusive;

   675 		}

   677 	TInt err = KErrNone;

   679 //	THwDeviceId hwDecoder = 0;

   680 //	THwDeviceId hwPostProc = 0;

   682 	// select decoder

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

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

   685 	if (err != KErrNone)

   686 		{

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

   688 		return EInconclusive;

   689 		}

   691 	// select post-processor

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

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

   694 	if (err != KErrNone)

   695 		{

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

   697 		return EInconclusive;

   698 		}

   700 	// initialize CDevVideoPlay and wait for response

   701 	// iError is set by the MdvpoInitComplete callback

   702 	aDevVideoPlay.Initialize();

   704 	if (iError != KErrNone)

   705 		{

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

   707 		return EInconclusive;

   708 		}

   710 	// get picture buffer bytes

   711 	TUint picBytes = aDevVideoPlay.PictureBufferBytes();

   713 	// check against test data

   714 	if (picBytes != KTestPictureBytes)

   715 		{

   716 		ERR_PRINTF3(_L("PictureBufferBytes() incorrect - gave %d (expected %d)"),

   717 			picBytes, KTestPictureBytes);

   718 		ret = EFail;

   719 		}

   720 	else

   721 		INFO_PRINTF1(_L("PictureBufferBytes() called successfully"));

   723 	return ret;

   724 	}

   725 //------------------------------------------------------------------

   727 void CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete(TInt aError)

   728 	{

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

   731 	iError = aError;

   732 	}

   734 CTestDevVideoPlayGetPictureCounters::CTestDevVideoPlayGetPictureCounters(const TDesC& aTestName, TTestType aTestType)

   735 	:CTestDevVideoPlayStep(aTestName, aTestType)

   736 	{

   737 	}

   739 CTestDevVideoPlayGetPictureCounters* CTestDevVideoPlayGetPictureCounters::NewL(const TDesC& aTestName, TTestType aTestType)

   740 	{

   741 	CTestDevVideoPlayGetPictureCounters* self = new(ELeave) CTestDevVideoPlayGetPictureCounters(aTestName, aTestType);

   742 	return self;

   743 	}

   745 TVerdict CTestDevVideoPlayGetPictureCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   746 	{

   747 	TVerdict ret = EPass;

   748 	TInt expErr = KErrNone;

   749 	TBool selDec = ETrue;

   750 	TBool selPost = ETrue;

   752 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetPictureCounters"));

   754 	// expected results

   755 	switch(iTestType)

   756 		{

   757 		case ETestValid:

   758 			expErr = KErrNone;

   759 			break;

   760 		case ETestDecoderOnly:

   761 			selPost = EFalse;

   762 			break;

   763 		case ETestPostProcOnly:

   764 			selDec = EFalse;

   765 			break;

   766 		default:

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

   768 			return EInconclusive;

   769 		}

   771 	TInt err = KErrNone;

   773 	THwDeviceId hwDecoder = 0;

   774 	THwDeviceId hwPostProc = 0;

   776 	// select decoder

   777 	if (selDec)

   778 		{

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

   780 		if (err != KErrNone)

   781 			{

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

   783 			return EInconclusive;

   784 			}

   785 		}

   787 	// select post-processor

   788 	if (selPost)

   789 		{

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

   791 		if (err != KErrNone)

   792 			{

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

   794 			return EInconclusive;

   795 			}

   796 		}

   798 	// initialize CDevVideoPlay and wait for response

   799 	// iError is set by the MdvpoInitComplete callback

   800 	aDevVideoPlay.Initialize();

   802 	if (iError != KErrNone)

   803 		{

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

   805 		return EInconclusive;

   806 		}

   808 	CMMFDevVideoPlay::TPictureCounters picCounts;

   810 	// get picture counters from DevVideoPlay

   811 	aDevVideoPlay.GetPictureCounters(picCounts);

   813 	// N.B. PicturesSkipped is sum of decoder and post processor so

   814 	// we have to add these

   815 	CMMFDevVideoPlay::TPictureCounters testCounts = GetTestPictureCounters();

   816 	if (hwDecoder && hwPostProc)

   817 		{

   818 		// account for both decoder and post processor

   819 		testCounts.iPicturesSkipped *= 2;

   820 		}

   821 	else if (hwPostProc)

   822 		{

   823 		// no decoded samples from a post processor

   824 		testCounts.iPicturesDecoded = 0;

   825 		}

   827 	if (!ComparePictureCounters(picCounts, testCounts))

   828 		{

   829 		ERR_PRINTF1(_L("GetPictureCounters() comparison with test data failed!"));

   830 		ret = EFail;

   831 		}

   832 	else

   833 		{

   834 		INFO_PRINTF1(_L("GetPictureCounters() comparison with test data passed."));

   835 		INFO_PRINTF3(_L("GetPictureCounters(), %d = %d"), err, expErr);

   836 		}

   838 	return ret;

   839 	}

   840 //------------------------------------------------------------------

   842 void CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete(TInt aError)

   843 	{

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

   846 	iError = aError;

   847 	}

   849 CTestDevVideoPlayGetBitstreamCounters::CTestDevVideoPlayGetBitstreamCounters(const TDesC& aTestName, TTestType aTestType)

   850 	:CTestDevVideoPlayStep(aTestName, aTestType)

   851 	{

   852 	}

   854 CTestDevVideoPlayGetBitstreamCounters* CTestDevVideoPlayGetBitstreamCounters::NewL(const TDesC& aTestName, TTestType aTestType)

   855 	{

   856 	CTestDevVideoPlayGetBitstreamCounters* self = new(ELeave) CTestDevVideoPlayGetBitstreamCounters(aTestName, aTestType);

   857 	return self;

   858 	}

   860 TVerdict CTestDevVideoPlayGetBitstreamCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   861 	{

   862 	TVerdict ret = EPass;

   863 	TInt expErr = KErrNone;

   865 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBitstreamCounters"));

   867 	// expected results

   868 	if (iTestType != ETestValid)

   869 		{

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

   871 		return EInconclusive;

   872 		}

   874 	TInt err = KErrNone;

   876 //	THwDeviceId hwDecoder = 0;

   877 //	THwDeviceId hwPostProc = 0;

   879 	// select decoder

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

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

   882 	if (err != KErrNone)

   883 		{

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

   885 		return EInconclusive;

   886 		}

   888 	// select post-processor

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

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

   891 	if (err != KErrNone)

   892 		{

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

   894 		return EInconclusive;

   895 		}

   897 	// initialize CDevVideoPlay and wait for response

   898 	// iError is set by the MdvpoInitComplete callback

   899 	aDevVideoPlay.Initialize();

   901 	if (iError != KErrNone)

   902 		{

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

   904 		return EInconclusive;

   905 		}

   907 	CMMFDevVideoPlay::TBitstreamCounters bitCounts;

   909 	// get bitstream counters from DevVideoPlay

   910 	aDevVideoPlay.GetBitstreamCounters(bitCounts);

   912 	if (!CompareBitstreamCounters(bitCounts, GetTestBitstreamCounters()))

   913 		{

   914 		ERR_PRINTF1(_L("GetBitstreamCounters() comparison with test data failed!"));

   915 		ret = EFail;

   916 		}

   917 	else

   918 		{

   919 		INFO_PRINTF1(_L("GetBitstreamCounters() comparison with test data passed."));

   920 		INFO_PRINTF3(_L("GetBitstreamCounters(), %d = %d"), err, expErr);

   921 		}

   923 	return ret;

   924 	}

   925 //------------------------------------------------------------------

   927 void CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete(TInt aError)

   928 	{

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

   931 	iError = aError;

   932 	}

   934 CTestDevVideoPlayNumFreeBuffers::CTestDevVideoPlayNumFreeBuffers(const TDesC& aTestName, TTestType aTestType)

   935 	:CTestDevVideoPlayStep(aTestName, aTestType)

   936 	{

   937 	}

   939 CTestDevVideoPlayNumFreeBuffers* CTestDevVideoPlayNumFreeBuffers::NewL(const TDesC& aTestName, TTestType aTestType)

   940 	{

   941 	CTestDevVideoPlayNumFreeBuffers* self = new(ELeave) CTestDevVideoPlayNumFreeBuffers(aTestName, aTestType);

   942 	return self;

   943 	}

   945 TVerdict CTestDevVideoPlayNumFreeBuffers::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

   946 	{

   947 	TVerdict ret = EPass;

   949 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  NumFreeBuffers"));

   951 	// expected results

   952 	if (iTestType != ETestValid)

   953 		{

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

   955 		return EInconclusive;

   956 		}

   958 	TInt err = KErrNone;

   960 //	THwDeviceId hwDecoder = 0;

   961 //	THwDeviceId hwPostProc = 0;

   963 	// select decoder

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

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

   966 	if (err != KErrNone)

   967 		{

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

   969 		return EInconclusive;

   970 		}

   972 	// select post-processor

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

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

   975 	if (err != KErrNone)

   976 		{

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

   978 		return EInconclusive;

   979 		}

   981 	// initialize CDevVideoPlay and wait for response

   982 	// iError is set by the MdvpoInitComplete callback

   983 	aDevVideoPlay.Initialize();

   985 	if (iError != KErrNone)

   986 		{

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

   988 		return EInconclusive;

   989 		}

   991 	TUint numBuffers = 0;

   993 	// get number of free buffers from DevVideoPlay

   994 	numBuffers = aDevVideoPlay.NumFreeBuffers();

   996 	if (numBuffers != KTestNumFreeBuffers)

   997 		{

   998 		ERR_PRINTF1(_L("NumFreeBuffers() comparison with test data failed!"));

   999 		ret = EFail;

  1000 		}

  1001 	else

  1002 		{

  1003 		INFO_PRINTF1(_L("NumFreeBuffers() comparison with test data passed."));

  1004 		INFO_PRINTF3(_L("NumFreeBuffers(), %d = %d"), numBuffers, KTestNumFreeBuffers);

  1005 		}

  1006 	return ret;

  1007 	}

  1008 //------------------------------------------------------------------

  1010 void CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete(TInt aError)

  1011 	{

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

  1014 	iError = aError;

  1015 	}

  1017 CTestDevVideoPlaySetComplexityLevel::CTestDevVideoPlaySetComplexityLevel(const TDesC& aTestName, TTestType aTestType)

  1018 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1019 	{

  1020 	}

  1022 CTestDevVideoPlaySetComplexityLevel* CTestDevVideoPlaySetComplexityLevel::NewL(const TDesC& aTestName, TTestType aTestType)

  1023 	{

  1024 	CTestDevVideoPlaySetComplexityLevel* self = new(ELeave) CTestDevVideoPlaySetComplexityLevel(aTestName, aTestType);

  1025 	return self;

  1026 	}

  1028 TVerdict CTestDevVideoPlaySetComplexityLevel::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1029 	{

  1030 	TVerdict ret = EPass;

  1032 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetComplexityLevel"));

  1034 	// expected results

  1035 	if (iTestType != ETestValid)

  1036 		{

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

  1038 		return EInconclusive;

  1039 		}

  1041 	TInt err = KErrNone;

  1043 	THwDeviceId hwDecoder = 0;

  1044 	THwDeviceId hwPostProc = 0;

  1046 	// select decoder

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

  1048 	if (err != KErrNone)

  1049 		{

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

  1051 		return EInconclusive;

  1052 		}

  1054 	// select post-processor

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

  1056 	if (err != KErrNone)

  1057 		{

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

  1059 		return EInconclusive;

  1060 		}

  1062 	// initialize CDevVideoPlay and wait for response

  1063 	// iError is set by the MdvpoInitComplete callback

  1064 	aDevVideoPlay.Initialize();

  1066 	if (iError != KErrNone)

  1067 		{

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

  1069 		return EInconclusive;

  1070 		}

  1072 	// set complexity level on decoder

  1073 	aDevVideoPlay.SetComplexityLevel(hwDecoder, KTestComplexityLevel1);

  1075 	// set complexity level on post-processor

  1076 	aDevVideoPlay.SetComplexityLevel(hwPostProc, KTestComplexityLevel2);

  1078 	// if no PANIC then test has passed

  1079 	INFO_PRINTF3(_L("SetComplexityLevel(), %d, %d"), KTestComplexityLevel1, KTestComplexityLevel2);

  1081 	return ret;

  1082 	}

  1083 //------------------------------------------------------------------

  1085 void CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete(TInt aError)

  1086 	{

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

  1089 	iError = aError;

  1090 	}

  1092 CTestDevVideoPlayNumComplexityLevels::CTestDevVideoPlayNumComplexityLevels(const TDesC& aTestName, TTestType aTestType)

  1093 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1094 	{

  1095 	}

  1097 CTestDevVideoPlayNumComplexityLevels* CTestDevVideoPlayNumComplexityLevels::NewL(const TDesC& aTestName, TTestType aTestType)

  1098 	{

  1099 	CTestDevVideoPlayNumComplexityLevels* self = new(ELeave) CTestDevVideoPlayNumComplexityLevels(aTestName, aTestType);

  1100 	return self;

  1101 	}

  1103 TVerdict CTestDevVideoPlayNumComplexityLevels::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1104 	{

  1105 	TVerdict ret = EPass;

  1107 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  NumComplexityLevels"));

  1109 	// expected results

  1110 	if (iTestType != ETestValid)

  1111 		{

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

  1113 		return EInconclusive;

  1114 		}

  1116 	TInt err = KErrNone;

  1118 	THwDeviceId hwDecoder = 0;

  1119 	THwDeviceId hwPostProc = 0;

  1121 	// select decoder

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

  1123 	if (err != KErrNone)

  1124 		{

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

  1126 		return EInconclusive;

  1127 		}

  1129 	// select post-processor

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

  1131 	if (err != KErrNone)

  1132 		{

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

  1134 		return EInconclusive;

  1135 		}

  1137 	// initialize CDevVideoPlay and wait for response

  1138 	// iError is set by the MdvpoInitComplete callback

  1139 	aDevVideoPlay.Initialize();

  1141 	if (iError != KErrNone)

  1142 		{

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

  1144 		return EInconclusive;

  1145 		}

  1147 	// get num complexity levels on decoder

  1148 	TUint levs1 = aDevVideoPlay.NumComplexityLevels(hwDecoder);

  1150 	// get num complexity levels on post-processor

  1151 	TUint levs2 = aDevVideoPlay.NumComplexityLevels(hwPostProc);

  1153 	// check return values against test data

  1154 	if (levs1 != KTestNumComplexityLevels1 || levs2 != KTestNumComplexityLevels2)

  1155 		{

  1156 		ERR_PRINTF3(_L("Error - comparison against test data failed! (%d, %d)"), levs1, levs2);

  1157 		}

  1158 	else

  1159 		{

  1160 		INFO_PRINTF3(_L("NumComplexityLevels(), %d, %d"), levs1, levs2);

  1161 		}

  1163 	return ret;

  1164 	}

  1165 //------------------------------------------------------------------

  1167 void CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete(TInt aError)

  1168 	{

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

  1171 	iError = aError;

  1172 	}

  1174 CTestDevVideoPlayGetComplexityLevelInfo::CTestDevVideoPlayGetComplexityLevelInfo(const TDesC& aTestName, TTestType aTestType)

  1175 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1176 	{

  1177 	}

  1179 CTestDevVideoPlayGetComplexityLevelInfo* CTestDevVideoPlayGetComplexityLevelInfo::NewL(const TDesC& aTestName, TTestType aTestType)

  1180 	{

  1181 	CTestDevVideoPlayGetComplexityLevelInfo* self = new(ELeave) CTestDevVideoPlayGetComplexityLevelInfo(aTestName, aTestType);

  1182 	return self;

  1183 	}

  1185 TVerdict CTestDevVideoPlayGetComplexityLevelInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1186 	{

  1187 	TVerdict ret = EPass;

  1189 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetComplexityLevelInfo"));

  1191 	// expected results

  1192 	if (iTestType != ETestValid)

  1193 		{

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

  1195 		return EInconclusive;

  1196 		}

  1198 	TInt err = KErrNone;

  1200 	THwDeviceId hwDecoder = 0;

  1201 	THwDeviceId hwPostProc = 0;

  1203 	// select decoder

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

  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 	if (err != KErrNone)

  1214 		{

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

  1216 		return EInconclusive;

  1217 		}

  1219 	// initialize CDevVideoPlay and wait for response

  1220 	// iError is set by the MdvpoInitComplete callback

  1221 	aDevVideoPlay.Initialize();

  1223 	if (iError != KErrNone)

  1224 		{

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

  1226 		return EInconclusive;

  1227 		}

  1229 	CMMFDevVideoPlay::TComplexityLevelInfo levInfo1;

  1230 	CMMFDevVideoPlay::TComplexityLevelInfo levInfo2;

  1232 	// get complexity level info on decoder

  1233 	aDevVideoPlay.GetComplexityLevelInfo(hwDecoder, KTestComplexityLevel1, levInfo1);

  1235 	// get complexity level info on post-processor

  1236 	aDevVideoPlay.GetComplexityLevelInfo(hwPostProc, KTestComplexityLevel2, levInfo2);

  1238 	CMMFDevVideoPlay::TComplexityLevelInfo testInfo1 = GetTestLevelInfo(KTestComplexityLevel1);

  1239 	CMMFDevVideoPlay::TComplexityLevelInfo testInfo2 = GetTestLevelInfo(KTestComplexityLevel2);

  1241 	// check return values against test data

  1242 	if (!CompareLevelInfos(levInfo1, testInfo1) || !CompareLevelInfos(levInfo2, testInfo2))

  1243 		{

  1244 		ERR_PRINTF1(_L("Error - comparison against test data failed!"));

  1245 		}

  1246 	else

  1247 		{

  1248 		INFO_PRINTF1(_L("Comparison against test data passed ok."));

  1249 		INFO_PRINTF1(_L("GetComplexityLevelInfo() called successfully"));

  1250 		}

  1252 	return ret;

  1253 	}

  1254 //------------------------------------------------------------------

  1256 void CTestDevVideoPlayGetBuffer::MdvpoInitComplete(TInt aError)

  1257 	{

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

  1260 	iError = aError;

  1261 	}

  1263 void CTestDevVideoPlayGetBuffer::MdvpoNewBuffers()

  1264 	{

  1265 	INFO_PRINTF1(_L("CTestDevVideoPlayGetBuffer::MdvpoNewBuffers()"));

  1266 	iCalledBack = ETrue;

  1267 	}

  1269 CTestDevVideoPlayGetBuffer::CTestDevVideoPlayGetBuffer(const TDesC& aTestName, TTestType aTestType)

  1270 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1271 	{

  1272 	}

  1274 CTestDevVideoPlayGetBuffer* CTestDevVideoPlayGetBuffer::NewL(const TDesC& aTestName, TTestType aTestType)

  1275 	{

  1276 	CTestDevVideoPlayGetBuffer* self = new(ELeave) CTestDevVideoPlayGetBuffer(aTestName, aTestType);

  1277 	return self;

  1278 	}

  1280 TVerdict CTestDevVideoPlayGetBuffer::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1281 	{

  1282 	TVerdict ret = EPass;

  1283 	TInt expErr = KErrNone;

  1285 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBuffer"));

  1287 	// expected results

  1288 	if (iTestType != ETestValid)

  1289 		{

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

  1291 		return EInconclusive;

  1292 		}

  1294 	TInt err = KErrNone;

  1296 //	THwDeviceId hwDecoder = 0;

  1297 //	THwDeviceId hwPostProc = 0;

  1299 	// select decoder

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

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

  1302 	if (err != KErrNone)

  1303 		{

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

  1305 		return EInconclusive;

  1306 		}

  1308 	// select post-processor

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

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

  1311 	if (err != KErrNone)

  1312 		{

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

  1314 		return EInconclusive;

  1315 		}

  1317 	// initialize CDevVideoPlay and wait for response

  1318 	// iError is set by the MdvpoInitComplete callback

  1319 	aDevVideoPlay.Initialize();

  1321 	if (iError != KErrNone)

  1322 		{

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

  1324 		return EInconclusive;

  1325 		}

  1327 	TVideoInputBuffer* newBuff = NULL;

  1329 	// get a buffer of a certain size from DevVideoPlay

  1330 	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) );

  1331 	// callback will occur and newBuff will be set to new buffer

  1333 	if (err != expErr)

  1334 		{

  1335 		ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr);

  1336 		ret = EFail;

  1337 		}

  1338 	else

  1339 		{

  1340 		TBool buffSuccess = EFalse;

  1342 		// check callback has been called and buffer is correct

  1343 		if (newBuff && iCalledBack)

  1344 			{

  1345 			TTimeIntervalMicroSeconds testTime(KTestBufferSize);

  1346 			if ( (newBuff->iDecodingTimestamp == testTime) &&

  1347 				 (newBuff->iOptions == KTestBufferOptions) &&

  1348 				 (newBuff->iData == KTestBufferString) )

  1349 				{

  1350 				buffSuccess = ETrue;

  1351 				}

  1352 			}

  1354 		if (!buffSuccess)

  1355 			{

  1356 			ERR_PRINTF1(_L("Received buffer is corrupt!"));

  1357 			ret = EFail;

  1358 			}

  1359 		else

  1360 			{

  1361 			INFO_PRINTF1(_L("Buffer received correctly"));

  1362 			INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr);

  1363 			}

  1364 		}

  1365 	return ret;

  1366 	}

  1367 //------------------------------------------------------------------

  1369 void CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(TInt aError)

  1370 	{

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

  1373 	iError = aError;

  1374 	}

  1376 CTestDevVideoPlayWriteCodedData::CTestDevVideoPlayWriteCodedData(const TDesC& aTestName, TTestType aTestType)

  1377 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1378 	{

  1379 	}

  1381 CTestDevVideoPlayWriteCodedData* CTestDevVideoPlayWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType)

  1382 	{

  1383 	CTestDevVideoPlayWriteCodedData* self = new(ELeave) CTestDevVideoPlayWriteCodedData(aTestName, aTestType);

  1384 	return self;

  1385 	}

  1387 TVerdict CTestDevVideoPlayWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1388 	{

  1389 	TVerdict ret = EPass;

  1390 	TInt expErr = KErrNone;

  1392 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  WriteCodedData"));

  1394 	// expected results

  1395 	if (iTestType != ETestValid)

  1396 		{

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

  1398 		return EInconclusive;

  1399 		}

  1401 	TInt err = KErrNone;

  1403 //	THwDeviceId hwDecoder = 0;

  1404 //	THwDeviceId hwPostProc = 0;

  1406 	// select decoder

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

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

  1409 	if (err != KErrNone)

  1410 		{

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

  1412 		return EInconclusive;

  1413 		}

  1415 	// select post-processor

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

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

  1418 	if (err != KErrNone)

  1419 		{

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

  1421 		return EInconclusive;

  1422 		}

  1424 	// initialize CDevVideoPlay and wait for response

  1425 	// iError is set by the MdvpoInitComplete callback

  1426 	aDevVideoPlay.Initialize();

  1428 	if (iError != KErrNone)

  1429 		{

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

  1431 		return EInconclusive;

  1432 		}

  1434 	// construct a video input buffer structure with a valid timestamp and

  1435 	// write this DevVideoPlay.  Call will leave on error.

  1436 	TVideoInputBuffer* newBuff = NULL;

  1437 	TPtrC8 testBufferStringPtr(KTestBufferString);

  1438 	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length()));

  1439 	if (err)

  1440 		{

  1441 		ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay"));

  1442 		return EInconclusive;

  1443 		}

  1445 	// initialize newBuff with test data

  1446 	newBuff->iOptions = KTestBufferOptions;

  1447 	newBuff->iDecodingTimestamp = KTestBufferSize;

  1448 	newBuff->iData.Zero();

  1449 	newBuff->iData.Append(testBufferStringPtr);

  1451 	// write buffer to DevVideoPlay

  1452 	TRAP(err, aDevVideoPlay.WriteCodedDataL(newBuff) )

  1454 	if (err != expErr)

  1455 		{

  1456 		ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr);

  1457 		ret = EFail;

  1458 		}

  1459 	else

  1460 		{

  1461 		INFO_PRINTF1(_L("Coded data sent successfully"));

  1462 		INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr);

  1463 		}

  1464 	return ret;

  1465 	}

  1466 //------------------------------------------------------------------

  1468 void CTestDevVideoPlayScanAndCopyCodedData::MdvpoInitComplete(TInt aError)

  1469 	{

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

  1472 	iError = aError;

  1473 	}

  1475 CTestDevVideoPlayScanAndCopyCodedData::CTestDevVideoPlayScanAndCopyCodedData(const TDesC& aTestName, TTestType aTestType)

  1476 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1477 	{

  1478 	}

  1480 CTestDevVideoPlayScanAndCopyCodedData* CTestDevVideoPlayScanAndCopyCodedData::NewL(const TDesC& aTestName, TTestType aTestType)

  1481 	{

  1482 	CTestDevVideoPlayScanAndCopyCodedData* self = new(ELeave) CTestDevVideoPlayScanAndCopyCodedData(aTestName, aTestType);

  1483 	return self;

  1484 	}

  1486 TVerdict CTestDevVideoPlayScanAndCopyCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1487 	{

  1488 	TVerdict ret = EPass;

  1489 	TInt expErr = KErrNone;

  1491 	INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy:  ScanAndCopyCodedDataL"));

  1493 	// expected results

  1494 	if (iTestType != ETestValid)

  1495 		{

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

  1497 		return EInconclusive;

  1498 		}

  1500 	TInt err = KErrNone;

  1502 	THwDeviceId hwDecoder = 0;

  1504     // select decoder

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

  1506 	if (err != KErrNone)

  1507 		{

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

  1509 		return EInconclusive;

  1510 		}

  1512 	// select post-processor

  1513 	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

  1514 	if (err != KErrNone)

  1515 		{

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

  1517 		return EInconclusive;

  1518 		}

  1520 	// initialize CDevVideoPlay and wait for response

  1521 	// iError is set by the MdvpoInitComplete callback

  1522 	aDevVideoPlay.Initialize();

  1524 	if (iError != KErrNone)

  1525 		{

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

  1527 		return EInconclusive;

  1528 		}

  1531 	// construct a video input buffer structure with a valid timestamp and

  1532 	// write this DevVideoPlay.  Call will leave on error.

  1533 	TVideoInputBuffer* newBuff = NULL;

  1534 	TPtrC8 testBufferStringPtr(KTestBufferString);

  1535 	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length()));

  1536 	if (err)

  1537 		{

  1538 		ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay"));

  1539 		return EInconclusive;

  1540 		}

  1542 	//clean out pre-set stuff from buffer

  1543 	newBuff->iData.Zero();

  1544 	//set ptr to test data

  1545 	TPtrC8 testBufferString(KTestBufferString);

  1546 	HBufC8* bufferDataArea = testBufferString.AllocL();

  1547 	CleanupStack::PushL(bufferDataArea);

  1548 	TPtr8 dataAreaPtr = bufferDataArea->Des();

  1549 	TFramePortion framePortion = EFramePortionEndFragment;

  1551 	MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast<MMMFVideoPlayHwDeviceExtensionScanCopy*>(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy));

  1553 	TInt consumed = 0;

  1554 	// write buffer to DevVideoPlay using new interface

  1555 	TRAP(err, ciOne->ScanAndCopyCodedDataL(dataAreaPtr, newBuff, consumed, framePortion));

  1557 	//compare buffer to test data

  1558 	if ((newBuff->iData != KTestBufferString) || consumed != newBuff->iData.Length())

  1559 		{

  1560 		err = KErrCorrupt;

  1561 		}

  1563 	if (err != expErr)

  1564 		{

  1565 		ERR_PRINTF3(_L("ScanAndCopyCodedDataL() gave error %d (expected %d)"),err, expErr);

  1566 		ret = EFail;

  1567 		}

  1568 	else

  1569 		{

  1570 		INFO_PRINTF1(_L("Coded data sent successfully"));

  1571 		INFO_PRINTF3(_L("ScanAndCopyCodedDataL(), %d = %d"), err, expErr);

  1572 		}

  1573 	CleanupStack::PopAndDestroy(bufferDataArea);

  1574 	return ret;

  1575 	}

  1577 //------------------------------------------------------------------

  1579 void CTestDevVideoPlayExtensionWriteCodedData::MdvpoInitComplete(TInt aError)

  1580 	{

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

  1583 	iError = aError;

  1584 	}

  1586 CTestDevVideoPlayExtensionWriteCodedData::CTestDevVideoPlayExtensionWriteCodedData(const TDesC& aTestName, TTestType aTestType)

  1587 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1588 	{

  1589 	}

  1591 CTestDevVideoPlayExtensionWriteCodedData* CTestDevVideoPlayExtensionWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType)

  1592 	{

  1593 	CTestDevVideoPlayExtensionWriteCodedData* self = new(ELeave) CTestDevVideoPlayExtensionWriteCodedData(aTestName, aTestType);

  1594 	return self;

  1595 	}

  1597 TVerdict CTestDevVideoPlayExtensionWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1598 	{

  1599 	TVerdict ret = EPass;

  1600 	TInt expErr = KErrNone;

  1602 	INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy:  WriteCodedData"));

  1604 	// expected results

  1605 	if (iTestType != ETestValid)

  1606 		{

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

  1608 		return EInconclusive;

  1609 		}

  1611 	TInt err = KErrNone;

  1613 	THwDeviceId hwDecoder = 0;

  1615 	// select decoder

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

  1618 	if (err != KErrNone)

  1619 		{

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

  1621 		return EInconclusive;

  1622 		}

  1624 	// select post-processor

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

  1626 	if (err != KErrNone)

  1627 		{

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

  1629 		return EInconclusive;

  1630 		}

  1632 	// initialize CDevVideoPlay and wait for response

  1633 	// iError is set by the MdvpoInitComplete callback

  1634 	aDevVideoPlay.Initialize();

  1636 	if (iError != KErrNone)

  1637 		{

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

  1639 		return EInconclusive;

  1640 		}

  1642 	// construct a video input buffer structure with a valid timestamp and

  1643 	// write this DevVideoPlay.  Call will leave on error.

  1644 	TVideoInputBuffer* newBuff = NULL;

  1645 	TPtrC8 testBufferStringPtr(KTestBufferString);

  1646 	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length()));

  1647 	if (err)

  1648 		{

  1649 		ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay"));

  1650 		return EInconclusive;

  1651 		}

  1653 	// initialize newBuff with test data

  1654 	newBuff->iOptions = KTestBufferOptions;

  1655 	newBuff->iDecodingTimestamp = KTestBufferSize;

  1656 	newBuff->iData.Zero();

  1657 	newBuff->iData.Append(testBufferStringPtr);

  1659 	TFramePortion framePortion = EFramePortionEndFragment;

  1661 	MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast<MMMFVideoPlayHwDeviceExtensionScanCopy*>(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy));

  1663 	// write buffer to DevVideoPlay using new interface

  1664 	TRAP(err, ciOne->WriteCodedDataL(newBuff, framePortion));

  1666 	if (err != expErr)

  1667 		{

  1668 		ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr);

  1669 		ret = EFail;

  1670 		}

  1671 	else

  1672 		{

  1673 		INFO_PRINTF1(_L("Coded data sent successfully"));

  1674 		INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr);

  1675 		}

  1676 	return ret;

  1677 	}

  1679 //------------------------------------------------------------------

  1681 void CTestDevVideoPlayWritePicture::MdvpoInitComplete(TInt aError)

  1682 	{

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

  1685 	iError = aError;

  1686 	}

  1688 void CTestDevVideoPlayWritePicture::MdvpoReturnPicture(TVideoPicture* aPicture)

  1689 	{

  1690 	INFO_PRINTF1(_L("CTestDevVideoPlayWritePicture::MdvpoReturnPicture()"));

  1692 	iPicture = aPicture;

  1693 	}

  1695 CTestDevVideoPlayWritePicture::CTestDevVideoPlayWritePicture(const TDesC& aTestName, TTestType aTestType)

  1696 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1697 	{

  1698 	}

  1700 CTestDevVideoPlayWritePicture* CTestDevVideoPlayWritePicture::NewL(const TDesC& aTestName, TTestType aTestType)

  1701 	{

  1702 	CTestDevVideoPlayWritePicture* self = new(ELeave) CTestDevVideoPlayWritePicture(aTestName, aTestType);

  1703 	return self;

  1704 	}

  1706 TVerdict CTestDevVideoPlayWritePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1707 	{

  1708 	TVerdict ret = EPass;

  1709 	TInt expErr = KErrNone;

  1711 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  WritePicture"));

  1713 	// expected results

  1714 	if (iTestType != ETestValid)

  1715 		{

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

  1717 		return EInconclusive;

  1718 		}

  1720 	TInt err = KErrNone;

  1722 //	THwDeviceId hwDecoder = 0;

  1723 //	THwDeviceId hwPostProc = 0;

  1725 	// select decoder

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

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

  1728 	if (err != KErrNone)

  1729 		{

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

  1731 		return EInconclusive;

  1732 		}

  1734 	// select post-processor

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

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

  1737 	if (err != KErrNone)

  1738 		{

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

  1740 		return EInconclusive;

  1741 		}

  1743 	// initialize CDevVideoPlay and wait for response

  1744 	// iError is set by the MdvpoInitComplete callback

  1745 	aDevVideoPlay.Initialize();

  1747 	if (iError != KErrNone)

  1748 		{

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

  1750 		return EInconclusive;

  1751 		}

  1753 	// construct a video picture structure with a valid timestamp and

  1754 	// write this DevVideoPlay.  If the same picture comes back through the

  1755 	// MdvpoReturnPicture() callback then test has passed.

  1756 	TVideoPicture picture;

  1757 	TTimeIntervalMicroSeconds picTime(KTestPictureTimestamp);

  1758 	picture.iTimestamp = picTime;

  1759 	picture.iOptions = TVideoPicture::ETimestamp;

  1761 	// write picture to DevVideoPlay

  1762 	TRAP(err, aDevVideoPlay.WritePictureL(&picture) )

  1764 	if (err != expErr)

  1765 		{

  1766 		ERR_PRINTF3(_L("WritePicture() gave error %d (expected %d)"),err, expErr);

  1767 		ret = EFail;

  1768 		}

  1769 	else

  1770 		{

  1771 		TBool picSuccess = EFalse;

  1773 		// check callback has been called and picture is correct

  1774 		if (iPicture)

  1775 			{

  1776 			if ( (iPicture->iTimestamp == picTime) &&

  1777 				 (iPicture->iOptions == TVideoPicture::ETimestamp) )

  1778 				{

  1779 				picSuccess = ETrue;

  1780 				}

  1781 			}

  1783 		if (!picSuccess)

  1784 			{

  1785 			ERR_PRINTF1(_L("Received picture is corrupt!"));

  1786 			ret = EFail;

  1787 			}

  1788 		else

  1789 			{

  1790 			INFO_PRINTF1(_L("Original picture received correctly"));

  1791 			INFO_PRINTF3(_L("WritePicture(), %d = %d"), err, expErr);

  1792 			}

  1793 		}

  1795 	return ret;

  1796 	}

  1797 //------------------------------------------------------------------

  1799 void CTestDevVideoPlayInputEnd::MdvpoInitComplete(TInt aError)

  1800 	{

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

  1803 	iError = aError;

  1804 	}

  1806 void CTestDevVideoPlayInputEnd::MdvpoStreamEnd()

  1807 	{

  1808 	INFO_PRINTF1(_L("CTestDevVideoPlayInputEnd::MdvpoStreamEnd()"));

  1810 	// keep track on number of times this callback is called

  1811 	iEndCount++;

  1812 	}

  1814 CTestDevVideoPlayInputEnd::CTestDevVideoPlayInputEnd(const TDesC& aTestName, TTestType aTestType)

  1815 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1816 	{

  1817 	}

  1819 CTestDevVideoPlayInputEnd* CTestDevVideoPlayInputEnd::NewL(const TDesC& aTestName, TTestType aTestType)

  1820 	{

  1821 	CTestDevVideoPlayInputEnd* self = new(ELeave) CTestDevVideoPlayInputEnd(aTestName, aTestType);

  1822 	return self;

  1823 	}

  1825 TVerdict CTestDevVideoPlayInputEnd::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1826 	{

  1827 	TVerdict ret = EPass;

  1828 //	TInt expErr = KErrNone;

  1829 	TBool selDec = ETrue;

  1830 	TBool selPost = ETrue;

  1832 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  InputEnd"));

  1834 	// expected results

  1835 	switch(iTestType)

  1836 		{

  1837 		case ETestValid:

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

  1839 			break;

  1840 		case ETestDecoderOnly:

  1841 			selPost = EFalse;

  1842 			break;

  1843 		case ETestPostProcOnly:

  1844 			selDec = EFalse;

  1845 			break;

  1846 		default:

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

  1848 			return EInconclusive;

  1849 		}

  1851 	TInt err = KErrNone;

  1853 //	THwDeviceId hwDecoder = 0;

  1854 //	THwDeviceId hwPostProc = 0;

  1856 	// select decoder

  1857 	if (selDec)

  1858 		{

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

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

  1861 		if (err != KErrNone)

  1862 			{

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

  1864 			return EInconclusive;

  1865 			}

  1866 		}

  1868 	// select post-processor

  1869 	if (selPost)

  1870 		{

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

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

  1873 		if (err != KErrNone)

  1874 			{

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

  1876 			return EInconclusive;

  1877 			}

  1878 		}

  1879 	// initialize CDevVideoPlay and wait for response

  1880 	// iError is set by the MdvpoInitComplete callback

  1881 	aDevVideoPlay.Initialize();

  1883 	if (iError != KErrNone)

  1884 		{

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

  1886 		return EInconclusive;

  1887 		}

  1889 	// call input end on DevVideoPlay and check callback counter == 1

  1890 	aDevVideoPlay.InputEnd();

  1892 	if (iEndCount != 1)

  1893 		{

  1894 		ERR_PRINTF2(_L("Error - MdvpoStreamEnd only called %d times!"), iEndCount);

  1895 		ret = EFail;

  1896 		}

  1897 	else

  1898 		INFO_PRINTF1(_L("InputEnd() called successfully"));

  1900 	return ret;

  1901 	}

  1902 //-------------------------------------------------------------------

  1904 void CTestDevVideoGetBufferWithoutInitialize::MdvpoInitComplete(TInt aError)

  1905 	{

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

  1908 	iError = aError;

  1909 	}

  1911 void CTestDevVideoGetBufferWithoutInitialize::MdvpoNewBuffers()

  1912 	{

  1913 	INFO_PRINTF1(_L("CTestGetBufferWithoutInitialize::MdvpoNewBuffers()"));

  1914 	iCalledBack = ETrue;

  1915 	}

  1917 CTestDevVideoGetBufferWithoutInitialize::CTestDevVideoGetBufferWithoutInitialize(const TDesC& aTestName, TTestType aTestType)

  1918 	:CTestDevVideoPlayStep(aTestName, aTestType)

  1919 	{

  1920 	}

  1922 CTestDevVideoGetBufferWithoutInitialize* CTestDevVideoGetBufferWithoutInitialize::NewL(const TDesC& aTestName, TTestType aTestType)

  1923 	{

  1924 	CTestDevVideoGetBufferWithoutInitialize* self = new(ELeave) CTestDevVideoGetBufferWithoutInitialize(aTestName, aTestType);

  1925 	return self;

  1926 	}

  1928 TVerdict CTestDevVideoGetBufferWithoutInitialize::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

  1929 	{

  1930 	TVerdict ret = EPass;

  1931 	TInt expErr = KErrNone;

  1933 	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBuffer"));

  1934 	INFO_PRINTF1(_L("To test the scenario wherein GetBufferL is called without calling initialize"));

  1935 	// expected results

  1936 	if (iTestType != ETestValid)

  1937 		{

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

  1939 		return EInconclusive;

  1940 		}

  1942 	TInt err = KErrNone;

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

  1945 	if (err != KErrNone)

  1946 		{

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

  1948 		return EInconclusive;

  1949 		}

  1951 	// select post-processor

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

  1953 	if (err != KErrNone)

  1954 		{

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

  1956 		return EInconclusive;

  1957 		}

  1958 	TVideoInputBuffer* newBuff = NULL;

  1959 	// iError is set by the MdvpoInitComplete callback

  1960 	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) );

  1961 	// callback will occur and newBuff will be set to new buffer

  1962 	if (err != expErr)

  1963 		{

  1964 		ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr);

  1965 		ret = EFail;

  1966 		}

  1967 	else

  1968 		{

  1969 		TBool buffSuccess = EFalse;

  1971 		// check callback has been called and buffer is correct

  1972 		if (newBuff && iCalledBack)

  1973 			{

  1974 			TTimeIntervalMicroSeconds testTime(KTestBufferSize);

  1975 			if ( (newBuff->iDecodingTimestamp == testTime) &&

  1976 				 (newBuff->iOptions == KTestBufferOptions) &&

  1977 				 (newBuff->iData == KTestBufferString) )

  1978 				{

  1979 				buffSuccess = ETrue;

  1980 				}

  1981 			}

  1983 		if (!buffSuccess)

  1984 			{

  1985 			ERR_PRINTF1(_L("Received buffer is corrupt!"));

  1986 			ret = EFail;

  1987 			}

  1988 		else

  1989 			{

  1990 			INFO_PRINTF1(_L("Buffer received correctly"));

  1991 			INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr);

  1992 			}

  1993 		}

  1995 	return ret;

  1996 	}

  1997 //-----------------------------------------------------------------------

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--