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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Header file: DevVideoPlay tests.

    15 // 

    16 //

    17 

    18 /**

    19  @file TestDevVideoPlay.h

    20 */

    21 

    22 #ifndef __TESTDEVVIDEOPLAY_H__

    23 #define __TESTDEVVIDEOPLAY_H__

    24 

    25 #include "TSU_MMF_DevVideo.h"

    26 

    27 /**

    28  * DevVideoPlay test base class

    29  *

    30  * @class CTestDevVideoPlayStep

    31  *

    32  * Req. under test REQ1931.3

    33  */

    34 

    35 class CTestDevVideoPlayStep : public CTestDevVideoStep, public MMMFDevVideoPlayObserver

    36 	{

    37 public:

    38 	CTestDevVideoPlayStep(const TDesC& aTestName, TTestType aTestType);

    39 	~CTestDevVideoPlayStep();

    40 	virtual TVerdict DoTestStepL();

    41 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay) = 0;

    42 

    43 	// MMMFDevVideoPlayObserver

    44     virtual void MdvpoNewBuffers();

    45     virtual void MdvpoReturnPicture(TVideoPicture* aPicture);

    46     virtual void MdvpoSupplementalInformation(const TDesC8& aData, 

    47 											  const TTimeIntervalMicroSeconds& aTimestamp, 

    48 											  const TPictureId& aPictureId);

    49 	virtual void MdvpoPictureLoss();

    50 	virtual void MdvpoPictureLoss(const TArray<TPictureId>& aPictures);

    51 	virtual void MdvpoSliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture);

    52 	virtual void MdvpoReferencePictureSelection(const TDesC8& aSelectionData);

    53     virtual void MdvpoTimedSnapshotComplete(TInt aError, 

    54 											TPictureData* aPictureData, 

    55 											const TTimeIntervalMicroSeconds& aPresentationTimestamp, 

    56 											const TPictureId& aPictureId);

    57     virtual void MdvpoNewPictures();

    58     virtual void MdvpoFatalError(TInt aError);

    59     virtual void MdvpoInitComplete(TInt aError);

    60     virtual void MdvpoStreamEnd();

    61 

    62 protected:

    63 	TInt iError;

    64 	TTestType iTestType;					// Type of test

    65 	CMMFDevVideoPlay* iDevVideoPlay;

    66 	};

    67 

    68 

    69 //

    70 

    71 class CTestDevVideoPlayCommonFormat : public CTestDevVideoPlayStep

    72 	{

    73 public:

    74 	static CTestDevVideoPlayCommonFormat* NewL(const TDesC& aTestName, TTestType aTestType);

    75 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

    76 private:

    77 	CTestDevVideoPlayCommonFormat(const TDesC& aTestName, TTestType aTestType);

    78 	~CTestDevVideoPlayCommonFormat() {};

    79 	};

    80 

    81 //

    82 

    83 class CTestDevVideoPlayFindDecoders : public CTestDevVideoPlayStep

    84 	{

    85 public:

    86 	static CTestDevVideoPlayFindDecoders* NewL(const TDesC& aTestName, TTestType aTestType);

    87 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

    88 private:

    89 	CTestDevVideoPlayFindDecoders(const TDesC& aTestName, TTestType aTestType);

    90 	~CTestDevVideoPlayFindDecoders() {};

    91 	TInt CheckDecoders(const RArray<TUid>& aFoundDecoders, const RArray<TUid>& aExpectedDecoders, const RArray<TUid>& aUnExpectedDecoders);

    92 	};

    93 

    94 

    95 //

    96 

    97 class CTestDevVideoPlayFindPostProc : public CTestDevVideoPlayStep

    98 	{

    99 public:

   100 	static CTestDevVideoPlayFindPostProc* NewL(const TDesC& aTestName, TTestType aTestType);

   101 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   102 private:

   103 	CTestDevVideoPlayFindPostProc(const TDesC& aTestName, TTestType aTestType);

   104 	~CTestDevVideoPlayFindPostProc() {};

   105 	TInt CheckPostProx(const RArray<TUid>& aFoundPostProx, const RArray<TUid>& aExpectedPostProx, const RArray<TUid>& aUnExpectedPostProx);

   106 	};

   107 

   108 

   109 //

   110 

   111 class CTestDevVideoPlayListDecoders : public CTestDevVideoPlayStep

   112 	{

   113 public:

   114 	static CTestDevVideoPlayListDecoders* NewL(const TDesC& aTestName, TTestType aTestType);

   115 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   116 private:

   117 	CTestDevVideoPlayListDecoders(const TDesC& aTestName, TTestType aTestType);

   118 	~CTestDevVideoPlayListDecoders() {};

   119 	};

   120 

   121 

   122 //

   123 

   124 class CTestDevVideoPlayListPostProc : public CTestDevVideoPlayStep

   125 	{

   126 public:

   127 	static CTestDevVideoPlayListPostProc* NewL(const TDesC& aTestName, TTestType aTestType);

   128 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   129 private:

   130 	CTestDevVideoPlayListPostProc(const TDesC& aTestName, TTestType aTestType);

   131 	~CTestDevVideoPlayListPostProc() {};

   132 	};

   133 

   134 

   135 //

   136 

   137 class CTestDevVideoPlayGetDecoderInfo : public CTestDevVideoPlayStep

   138 	{

   139 public:

   140 	static CTestDevVideoPlayGetDecoderInfo* NewL(const TDesC& aTestName, TTestType aTestType);

   141 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   142 private:

   143 	CTestDevVideoPlayGetDecoderInfo(const TDesC& aTestName, TTestType aTestType);

   144 	~CTestDevVideoPlayGetDecoderInfo() {};

   145 	TBool ValidDecoderInfo(CVideoDecoderInfo* aInfo);

   146 	};

   147 

   148 

   149 //

   150 

   151 class CTestDevVideoPlayGetPostProcInfo : public CTestDevVideoPlayStep

   152 	{

   153 public:

   154 	static CTestDevVideoPlayGetPostProcInfo* NewL(const TDesC& aTestName, TTestType aTestType);

   155 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   156 private:

   157 	CTestDevVideoPlayGetPostProcInfo(const TDesC& aTestName, TTestType aTestType);

   158 	~CTestDevVideoPlayGetPostProcInfo() {};

   159 	TBool ValidPostProcInfo(CPostProcessorInfo* aInfo);

   160 	};

   161 

   162 

   163 //

   164 

   165 class CTestDevVideoPlaySelectDecoder : public CTestDevVideoPlayStep

   166 	{

   167 public:

   168 	static CTestDevVideoPlaySelectDecoder* NewL(const TDesC& aTestName, TTestType aTestType);

   169 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   170 private:

   171 	CTestDevVideoPlaySelectDecoder(const TDesC& aTestName, TTestType aTestType);

   172 	~CTestDevVideoPlaySelectDecoder() {};

   173 	};

   174 

   175 //

   176 

   177 class CTestDevVideoPlaySelectPostProc : public CTestDevVideoPlayStep

   178 	{

   179 public:

   180 	static CTestDevVideoPlaySelectPostProc* NewL(const TDesC& aTestName, TTestType aTestType);

   181 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   182 private:

   183 	CTestDevVideoPlaySelectPostProc(const TDesC& aTestName, TTestType aTestType);

   184 	~CTestDevVideoPlaySelectPostProc() {};

   185 	};

   186 

   187 //

   188 

   189 class CTestDevVideoPlayGetHeaderInfo : public CTestDevVideoPlayStep

   190 	{

   191 public:

   192 	static CTestDevVideoPlayGetHeaderInfo* NewL(const TDesC& aTestName, TTestType aTestType);

   193 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   194 private:

   195 	CTestDevVideoPlayGetHeaderInfo(const TDesC& aTestName, TTestType aTestType);

   196 	~CTestDevVideoPlayGetHeaderInfo() {};

   197 	TBool ValidPictureHeader(const TVideoPictureHeader* aPictureHeader);

   198 	};

   199 

   200 //

   201 

   202 class CTestDevVideoPlayReturnHeader : public CTestDevVideoPlayStep

   203 	{

   204 public:

   205 	static CTestDevVideoPlayReturnHeader* NewL(const TDesC& aTestName, TTestType aTestType);

   206 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   207 private:

   208 	CTestDevVideoPlayReturnHeader(const TDesC& aTestName, TTestType aTestType);

   209 	~CTestDevVideoPlayReturnHeader() {};

   210 	};

   211 

   212 //

   213 

   214 class CTestDevVideoPlayConfigureDecoder: public CTestDevVideoPlayStep

   215 	{

   216 public:

   217 	static CTestDevVideoPlayConfigureDecoder* NewL(const TDesC& aTestName, TTestType aTestType);

   218 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   219 private:

   220 	CTestDevVideoPlayConfigureDecoder(const TDesC& aTestName, TTestType aTestType);

   221 	~CTestDevVideoPlayConfigureDecoder() {};

   222 	};

   223 

   224 //

   225 

   226 class CTestDevVideoPlaySetInputFormatUC : public CTestDevVideoPlayStep

   227 	{

   228 public:

   229 	static CTestDevVideoPlaySetInputFormatUC* NewL(const TDesC& aTestName, TTestType aTestType);

   230 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   231 private:

   232 	CTestDevVideoPlaySetInputFormatUC(const TDesC& aTestName, TTestType aTestType);

   233 	~CTestDevVideoPlaySetInputFormatUC() {};

   234 	};

   235 

   236 //

   237 

   238 class CTestDevVideoPlaySetInputFormat : public CTestDevVideoPlayStep

   239 	{

   240 public:

   241 	static CTestDevVideoPlaySetInputFormat* NewL(const TDesC& aTestName, TTestType aTestType);

   242 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   243 private:

   244 	CTestDevVideoPlaySetInputFormat(const TDesC& aTestName, TTestType aTestType);

   245 	~CTestDevVideoPlaySetInputFormat() {};

   246 	};

   247 

   248 //

   249 

   250 class CTestDevVideoPlayGetOutputFormatList : public CTestDevVideoPlayStep

   251 	{

   252 public:

   253 	static CTestDevVideoPlayGetOutputFormatList* NewL(const TDesC& aTestName, TTestType aTestType);

   254 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   255 private:

   256 	CTestDevVideoPlayGetOutputFormatList(const TDesC& aTestName, TTestType aTestType);

   257 	~CTestDevVideoPlayGetOutputFormatList() {};

   258 	};

   259 

   260 //

   261 

   262 class CTestDevVideoPlaySetOutputFormat : public CTestDevVideoPlayStep

   263 	{

   264 public:

   265 	static CTestDevVideoPlaySetOutputFormat* NewL(const TDesC& aTestName, TTestType aTestType);

   266 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   267 private:

   268 	CTestDevVideoPlaySetOutputFormat(const TDesC& aTestName, TTestType aTestType);

   269 	~CTestDevVideoPlaySetOutputFormat() {};

   270 	};

   271 

   272 //

   273 

   274 class CTestDevVideoPlaySetPostProcTypes : public CTestDevVideoPlayStep

   275 	{

   276 public:

   277 	static CTestDevVideoPlaySetPostProcTypes* NewL(const TDesC& aTestName, TTestType aTestType);

   278 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   279 private:

   280 	CTestDevVideoPlaySetPostProcTypes(const TDesC& aTestName, TTestType aTestType);

   281 	~CTestDevVideoPlaySetPostProcTypes() {};

   282 	};

   283 

   284 //

   285 

   286 class CTestDevVideoPlaySetInputCrop : public CTestDevVideoPlayStep

   287 	{

   288 public:

   289 	static CTestDevVideoPlaySetInputCrop* NewL(const TDesC& aTestName, TTestType aTestType);

   290 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   291 private:

   292 	CTestDevVideoPlaySetInputCrop(const TDesC& aTestName, TTestType aTestType);

   293 	~CTestDevVideoPlaySetInputCrop() {};

   294 	};

   295 

   296 //

   297 

   298 class CTestDevVideoPlaySetYuvToRgbOptionsFormat : public CTestDevVideoPlayStep

   299 	{

   300 public:

   301 	static CTestDevVideoPlaySetYuvToRgbOptionsFormat* NewL(const TDesC& aTestName, TTestType aTestType);

   302 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   303 private:

   304 	CTestDevVideoPlaySetYuvToRgbOptionsFormat(const TDesC& aTestName, TTestType aTestType);

   305 	~CTestDevVideoPlaySetYuvToRgbOptionsFormat() {};

   306 	};

   307 

   308 //

   309 

   310 class CTestDevVideoPlaySetYuvToRgbOptions : public CTestDevVideoPlayStep

   311 	{

   312 public:

   313 	static CTestDevVideoPlaySetYuvToRgbOptions* NewL(const TDesC& aTestName, TTestType aTestType);

   314 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   315 private:

   316 	CTestDevVideoPlaySetYuvToRgbOptions(const TDesC& aTestName, TTestType aTestType);

   317 	~CTestDevVideoPlaySetYuvToRgbOptions() {};

   318 	};

   319 

   320 //

   321 

   322 class CTestDevVideoPlaySetRotate : public CTestDevVideoPlayStep

   323 	{

   324 public:

   325 	static CTestDevVideoPlaySetRotate* NewL(const TDesC& aTestName, TTestType aTestType);

   326 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   327 private:

   328 	CTestDevVideoPlaySetRotate(const TDesC& aTestName, TTestType aTestType);

   329 	~CTestDevVideoPlaySetRotate() {};

   330 	};

   331 

   332 //

   333 

   334 class CTestDevVideoPlaySetScale : public CTestDevVideoPlayStep

   335 	{

   336 public:

   337 	static CTestDevVideoPlaySetScale* NewL(const TDesC& aTestName, TTestType aTestType);

   338 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   339 private:

   340 	CTestDevVideoPlaySetScale(const TDesC& aTestName, TTestType aTestType);

   341 	~CTestDevVideoPlaySetScale() {};

   342 	};

   343 

   344 //

   345 

   346 class CTestDevVideoPlaySetCrop : public CTestDevVideoPlayStep

   347 	{

   348 public:

   349 	static CTestDevVideoPlaySetCrop* NewL(const TDesC& aTestName, TTestType aTestType);

   350 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   351 private:

   352 	CTestDevVideoPlaySetCrop(const TDesC& aTestName, TTestType aTestType);

   353 	~CTestDevVideoPlaySetCrop() {};

   354 	};

   355 

   356 //

   357 

   358 class CTestDevVideoPlaySetPostProcOptions : public CTestDevVideoPlayStep

   359 	{

   360 public:

   361 	static CTestDevVideoPlaySetPostProcOptions* NewL(const TDesC& aTestName, TTestType aTestType);

   362 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   363 private:

   364 	CTestDevVideoPlaySetPostProcOptions(const TDesC& aTestName, TTestType aTestType);

   365 	~CTestDevVideoPlaySetPostProcOptions() {};

   366 	};

   367 

   368 //

   369 

   370 class CTestDevVideoPlaySetClockSource : public CTestDevVideoPlayStep

   371 	{

   372 public:

   373 	static CTestDevVideoPlaySetClockSource* NewL(const TDesC& aTestName, TTestType aTestType);

   374 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   375 private:

   376 	CTestDevVideoPlaySetClockSource(const TDesC& aTestName, TTestType aTestType);

   377 	~CTestDevVideoPlaySetClockSource() {};

   378 	};

   379 

   380 //

   381 

   382 class CTestDevVideoPlaySetVideoOutput : public CTestDevVideoPlayStep

   383 	{

   384 public:

   385 	static CTestDevVideoPlaySetVideoOutput* NewL(const TDesC& aTestName, TTestType aTestType);

   386 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   387 private:

   388 	CTestDevVideoPlaySetVideoOutput(const TDesC& aTestName, TTestType aTestType);

   389 	~CTestDevVideoPlaySetVideoOutput() {};

   390 	};

   391 

   392 //

   393 

   394 class CTestDevVideoPlaySynchronizeDecoding : public CTestDevVideoPlayStep

   395 	{

   396 public:

   397 	static CTestDevVideoPlaySynchronizeDecoding* NewL(const TDesC& aTestName, TTestType aTestType);

   398 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   399 private:

   400 	CTestDevVideoPlaySynchronizeDecoding(const TDesC& aTestName, TTestType aTestType);

   401 	~CTestDevVideoPlaySynchronizeDecoding() {};

   402 	};

   403 

   404 //

   405 

   406 class CTestDevVideoPlaySetBufferOptions : public CTestDevVideoPlayStep

   407 	{

   408 public:

   409 	static CTestDevVideoPlaySetBufferOptions* NewL(const TDesC& aTestName, TTestType aTestType);

   410 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   411 private:

   412 	CTestDevVideoPlaySetBufferOptions(const TDesC& aTestName, TTestType aTestType);

   413 	~CTestDevVideoPlaySetBufferOptions() {};

   414 	};

   415 

   416 //

   417 

   418 class CTestDevVideoPlayGetBufferOptions : public CTestDevVideoPlayStep

   419 	{

   420 public:

   421 	static CTestDevVideoPlayGetBufferOptions* NewL(const TDesC& aTestName, TTestType aTestType);

   422 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   423 private:

   424 	CTestDevVideoPlayGetBufferOptions(const TDesC& aTestName, TTestType aTestType);

   425 	~CTestDevVideoPlayGetBufferOptions() {};

   426 	};

   427 

   428 //

   429 

   430 class CTestDevVideoPlaySetHrdVbv : public CTestDevVideoPlayStep

   431 	{

   432 public:

   433 	static CTestDevVideoPlaySetHrdVbv* NewL(const TDesC& aTestName, TTestType aTestType);

   434 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   435 private:

   436 	CTestDevVideoPlaySetHrdVbv(const TDesC& aTestName, TTestType aTestType);

   437 	~CTestDevVideoPlaySetHrdVbv() {};

   438 	};

   439 

   440 //

   441 

   442 class CTestDevVideoPlayInit : public CTestDevVideoPlayStep

   443 	{

   444 public:

   445 	static CTestDevVideoPlayInit* NewL(const TDesC& aTestName, TTestType aTestType);

   446 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   447 	virtual void MdvpoInitComplete(TInt aError);

   448 private:

   449 	CTestDevVideoPlayInit(const TDesC& aTestName, TTestType aTestType);

   450 	~CTestDevVideoPlayInit() {};

   451 	};

   452 

   453 //

   454 

   455 class CTestDevVideoPlayStartDSA : public CTestDevVideoPlayStep

   456 	{

   457 public:

   458 	static CTestDevVideoPlayStartDSA* NewL(const TDesC& aTestName, TTestType aTestType);

   459 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   460 	virtual void MdvpoInitComplete(TInt aError);

   461 private:

   462 	CTestDevVideoPlayStartDSA(const TDesC& aTestName, TTestType aTestType);

   463 	~CTestDevVideoPlayStartDSA() {};

   464 	};

   465 

   466 //

   467 

   468 class CTestDevVideoPlaySetClipRegion : public CTestDevVideoPlayStep

   469 	{

   470 public:

   471 	static CTestDevVideoPlaySetClipRegion* NewL(const TDesC& aTestName, TTestType aTestType);

   472 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   473 	virtual void MdvpoInitComplete(TInt aError);

   474 private:

   475 	CTestDevVideoPlaySetClipRegion(const TDesC& aTestName, TTestType aTestType);

   476 	~CTestDevVideoPlaySetClipRegion() {};

   477 	};

   478 

   479 //

   480 

   481 class CTestDevVideoPlaySetPauseClipFail : public CTestDevVideoPlayStep

   482 	{

   483 public:

   484 	static CTestDevVideoPlaySetPauseClipFail* NewL(const TDesC& aTestName, TTestType aTestType);

   485 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   486 	virtual void MdvpoInitComplete(TInt aError);

   487 private:

   488 	CTestDevVideoPlaySetPauseClipFail(const TDesC& aTestName, TTestType aTestType);

   489 	~CTestDevVideoPlaySetPauseClipFail() {};

   490 	};

   491 

   492 //

   493 

   494 class CTestDevVideoPlayAbortDSA : public CTestDevVideoPlayStep

   495 	{

   496 public:

   497 	static CTestDevVideoPlayAbortDSA* NewL(const TDesC& aTestName, TTestType aTestType);

   498 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   499 	virtual void MdvpoInitComplete(TInt aError);

   500 private:

   501 	CTestDevVideoPlayAbortDSA(const TDesC& aTestName, TTestType aTestType);

   502 	~CTestDevVideoPlayAbortDSA() {};

   503 	};

   504 

   505 //

   506 

   507 class CTestDevVideoPlayIsPlaying : public CTestDevVideoPlayStep

   508 	{

   509 public:

   510 	static CTestDevVideoPlayIsPlaying* NewL(const TDesC& aTestName, TTestType aTestType);

   511 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   512 	virtual void MdvpoInitComplete(TInt aError);

   513 private:

   514 	CTestDevVideoPlayIsPlaying(const TDesC& aTestName, TTestType aTestType);

   515 	~CTestDevVideoPlayIsPlaying() {};

   516 	};

   517 

   518 //

   519 

   520 class CTestDevVideoPlayRedraw : public CTestDevVideoPlayStep

   521 	{

   522 public:

   523 	static CTestDevVideoPlayRedraw* NewL(const TDesC& aTestName, TTestType aTestType);

   524 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   525 	virtual void MdvpoInitComplete(TInt aError);

   526 private:

   527 	CTestDevVideoPlayRedraw(const TDesC& aTestName, TTestType aTestType);

   528 	~CTestDevVideoPlayRedraw() {};

   529 	};

   530 

   531 //

   532 

   533 class CTestDevVideoPlayStart : public CTestDevVideoPlayStep

   534 	{

   535 public:

   536 	static CTestDevVideoPlayStart* NewL(const TDesC& aTestName, TTestType aTestType);

   537 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   538 	virtual void MdvpoInitComplete(TInt aError);

   539 private:

   540 	CTestDevVideoPlayStart(const TDesC& aTestName, TTestType aTestType);

   541 	~CTestDevVideoPlayStart() {};

   542 	};

   543 

   544 //

   545 

   546 class CTestDevVideoPlayStop : public CTestDevVideoPlayStep

   547 	{

   548 public:

   549 	static CTestDevVideoPlayStop* NewL(const TDesC& aTestName, TTestType aTestType);

   550 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   551 	virtual void MdvpoInitComplete(TInt aError);

   552 private:

   553 	CTestDevVideoPlayStop(const TDesC& aTestName, TTestType aTestType);

   554 	~CTestDevVideoPlayStop() {};

   555 	};

   556 

   557 //

   558 

   559 class CTestDevVideoPlayPause : public CTestDevVideoPlayStep

   560 	{

   561 public:

   562 	static CTestDevVideoPlayPause* NewL(const TDesC& aTestName, TTestType aTestType);

   563 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   564 	virtual void MdvpoInitComplete(TInt aError);

   565 private:

   566 	CTestDevVideoPlayPause(const TDesC& aTestName, TTestType aTestType);

   567 	~CTestDevVideoPlayPause() {};

   568 	};

   569 

   570 //

   571 

   572 class CTestDevVideoPlayResume : public CTestDevVideoPlayStep

   573 	{

   574 public:

   575 	static CTestDevVideoPlayResume* NewL(const TDesC& aTestName, TTestType aTestType);

   576 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   577 	virtual void MdvpoInitComplete(TInt aError);

   578 private:

   579 	CTestDevVideoPlayResume(const TDesC& aTestName, TTestType aTestType);

   580 	~CTestDevVideoPlayResume() {};

   581 	};

   582 

   583 //

   584 

   585 class CTestDevVideoPlaySetPosition : public CTestDevVideoPlayStep

   586 	{

   587 public:

   588 	static CTestDevVideoPlaySetPosition* NewL(const TDesC& aTestName, TTestType aTestType);

   589 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   590 	virtual void MdvpoInitComplete(TInt aError);

   591 private:

   592 	CTestDevVideoPlaySetPosition(const TDesC& aTestName, TTestType aTestType);

   593 	~CTestDevVideoPlaySetPosition() {};

   594 	};

   595 

   596 //

   597 

   598 class CTestDevVideoPlayFreezePicture : public CTestDevVideoPlayStep

   599 	{

   600 public:

   601 	static CTestDevVideoPlayFreezePicture* NewL(const TDesC& aTestName, TTestType aTestType);

   602 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   603 	virtual void MdvpoInitComplete(TInt aError);

   604 private:

   605 	CTestDevVideoPlayFreezePicture(const TDesC& aTestName, TTestType aTestType);

   606 	~CTestDevVideoPlayFreezePicture() {};

   607 	};

   608 

   609 //

   610 

   611 class CTestDevVideoPlayReleaseFreeze : public CTestDevVideoPlayStep

   612 	{

   613 public:

   614 	static CTestDevVideoPlayReleaseFreeze* NewL(const TDesC& aTestName, TTestType aTestType);

   615 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   616 	virtual void MdvpoInitComplete(TInt aError);

   617 private:

   618 	CTestDevVideoPlayReleaseFreeze(const TDesC& aTestName, TTestType aTestType);

   619 	~CTestDevVideoPlayReleaseFreeze() {};

   620 	};

   621 

   622 //

   623 

   624 class CTestDevVideoPlayDecodingPosition : public CTestDevVideoPlayStep

   625 	{

   626 public:

   627 	static CTestDevVideoPlayDecodingPosition* NewL(const TDesC& aTestName, TTestType aTestType);

   628 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   629 	virtual void MdvpoInitComplete(TInt aError);

   630 private:

   631 	CTestDevVideoPlayDecodingPosition(const TDesC& aTestName, TTestType aTestType);

   632 	~CTestDevVideoPlayDecodingPosition() {};

   633 	};

   634 

   635 //

   636 

   637 class CTestDevVideoPlayPlaybackPosition : public CTestDevVideoPlayStep

   638 	{

   639 public:

   640 	static CTestDevVideoPlayPlaybackPosition* NewL(const TDesC& aTestName, TTestType aTestType);

   641 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   642 	virtual void MdvpoInitComplete(TInt aError);

   643 private:

   644 	CTestDevVideoPlayPlaybackPosition(const TDesC& aTestName, TTestType aTestType);

   645 	~CTestDevVideoPlayPlaybackPosition() {};

   646 	};

   647 

   648 //

   649 

   650 class CTestDevVideoPlayPreDecoderBufferBytes : public CTestDevVideoPlayStep

   651 	{

   652 public:

   653 	static CTestDevVideoPlayPreDecoderBufferBytes* NewL(const TDesC& aTestName, TTestType aTestType);

   654 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   655 	virtual void MdvpoInitComplete(TInt aError);

   656 private:

   657 	CTestDevVideoPlayPreDecoderBufferBytes(const TDesC& aTestName, TTestType aTestType);

   658 	~CTestDevVideoPlayPreDecoderBufferBytes() {};

   659 	};

   660 

   661 //

   662 

   663 class CTestDevVideoPlayPictureBufferBytes : public CTestDevVideoPlayStep

   664 	{

   665 public:

   666 	static CTestDevVideoPlayPictureBufferBytes* NewL(const TDesC& aTestName, TTestType aTestType);

   667 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   668 	virtual void MdvpoInitComplete(TInt aError);

   669 private:

   670 	CTestDevVideoPlayPictureBufferBytes(const TDesC& aTestName, TTestType aTestType);

   671 	~CTestDevVideoPlayPictureBufferBytes() {};

   672 	};

   673 

   674 //

   675 

   676 class CTestDevVideoPlayGetPictureCounters : public CTestDevVideoPlayStep

   677 	{

   678 public:

   679 	static CTestDevVideoPlayGetPictureCounters* NewL(const TDesC& aTestName, TTestType aTestType);

   680 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   681 	virtual void MdvpoInitComplete(TInt aError);

   682 private:

   683 	CTestDevVideoPlayGetPictureCounters(const TDesC& aTestName, TTestType aTestType);

   684 	~CTestDevVideoPlayGetPictureCounters() {};

   685 	};

   686 

   687 //

   688 

   689 class CTestDevVideoPlayGetBitstreamCounters : public CTestDevVideoPlayStep

   690 	{

   691 public:

   692 	static CTestDevVideoPlayGetBitstreamCounters* NewL(const TDesC& aTestName, TTestType aTestType);

   693 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   694 	virtual void MdvpoInitComplete(TInt aError);

   695 private:

   696 	CTestDevVideoPlayGetBitstreamCounters(const TDesC& aTestName, TTestType aTestType);

   697 	~CTestDevVideoPlayGetBitstreamCounters() {};

   698 	};

   699 

   700 //

   701 

   702 class CTestDevVideoPlayNumFreeBuffers : public CTestDevVideoPlayStep

   703 	{

   704 public:

   705 	static CTestDevVideoPlayNumFreeBuffers* NewL(const TDesC& aTestName, TTestType aTestType);

   706 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   707 	virtual void MdvpoInitComplete(TInt aError);

   708 private:

   709 	CTestDevVideoPlayNumFreeBuffers(const TDesC& aTestName, TTestType aTestType);

   710 	~CTestDevVideoPlayNumFreeBuffers() {};

   711 	};

   712 

   713 //

   714 

   715 class CTestDevVideoPlaySetComplexityLevel : public CTestDevVideoPlayStep

   716 	{

   717 public:

   718 	static CTestDevVideoPlaySetComplexityLevel* NewL(const TDesC& aTestName, TTestType aTestType);

   719 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   720 	virtual void MdvpoInitComplete(TInt aError);

   721 private:

   722 	CTestDevVideoPlaySetComplexityLevel(const TDesC& aTestName, TTestType aTestType);

   723 	~CTestDevVideoPlaySetComplexityLevel() {};

   724 	};

   725 

   726 //

   727 

   728 class CTestDevVideoPlayNumComplexityLevels : public CTestDevVideoPlayStep

   729 	{

   730 public:

   731 	static CTestDevVideoPlayNumComplexityLevels* NewL(const TDesC& aTestName, TTestType aTestType);

   732 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   733 	virtual void MdvpoInitComplete(TInt aError);

   734 private:

   735 	CTestDevVideoPlayNumComplexityLevels(const TDesC& aTestName, TTestType aTestType);

   736 	~CTestDevVideoPlayNumComplexityLevels() {};

   737 	};

   738 

   739 //

   740 

   741 class CTestDevVideoPlayGetComplexityLevelInfo : public CTestDevVideoPlayStep

   742 	{

   743 public:

   744 	static CTestDevVideoPlayGetComplexityLevelInfo* NewL(const TDesC& aTestName, TTestType aTestType);

   745 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   746 	virtual void MdvpoInitComplete(TInt aError);

   747 private:

   748 	CTestDevVideoPlayGetComplexityLevelInfo(const TDesC& aTestName, TTestType aTestType);

   749 	~CTestDevVideoPlayGetComplexityLevelInfo() {};

   750 	};

   751 

   752 //

   753 

   754 class CTestDevVideoPlayGetBuffer : public CTestDevVideoPlayStep

   755 	{

   756 public:

   757 	static CTestDevVideoPlayGetBuffer* NewL(const TDesC& aTestName, TTestType aTestType);

   758 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   759 	virtual void MdvpoInitComplete(TInt aError);

   760 	virtual void MdvpoNewBuffers();

   761 private:

   762 	CTestDevVideoPlayGetBuffer(const TDesC& aTestName, TTestType aTestType);

   763 	~CTestDevVideoPlayGetBuffer() {};

   764 	TBool iCalledBack;

   765 	};

   766 

   767 //

   768 

   769 class CTestDevVideoPlayWriteCodedData : public CTestDevVideoPlayStep

   770 	{

   771 public:

   772 	static CTestDevVideoPlayWriteCodedData* NewL(const TDesC& aTestName, TTestType aTestType);

   773 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   774 	virtual void MdvpoInitComplete(TInt aError);

   775 private:

   776 	CTestDevVideoPlayWriteCodedData(const TDesC& aTestName, TTestType aTestType);

   777 	~CTestDevVideoPlayWriteCodedData() {};

   778 	};

   779 

   780 //

   781 

   782 class CTestDevVideoPlayScanAndCopyCodedData : public CTestDevVideoPlayStep

   783 	{

   784 public:

   785 	static CTestDevVideoPlayScanAndCopyCodedData* NewL(const TDesC& aTestName, TTestType aTestType);

   786 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   787 	virtual void MdvpoInitComplete(TInt aError);

   788 private:

   789 	CTestDevVideoPlayScanAndCopyCodedData(const TDesC& aTestName, TTestType aTestType);

   790 	~CTestDevVideoPlayScanAndCopyCodedData() {};

   791 	};

   792 

   793 //

   794 

   795 class CTestDevVideoPlayExtensionWriteCodedData : public CTestDevVideoPlayStep

   796 	{

   797 public:

   798 	static CTestDevVideoPlayExtensionWriteCodedData* NewL(const TDesC& aTestName, TTestType aTestType);

   799 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   800 	virtual void MdvpoInitComplete(TInt aError);

   801 private:

   802 	CTestDevVideoPlayExtensionWriteCodedData(const TDesC& aTestName, TTestType aTestType);

   803 	~CTestDevVideoPlayExtensionWriteCodedData() {};

   804 	};

   805 

   806 //

   807 

   808 class CTestDevVideoPlayWritePicture : public CTestDevVideoPlayStep

   809 	{

   810 public:

   811 	static CTestDevVideoPlayWritePicture* NewL(const TDesC& aTestName, TTestType aTestType);

   812 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   813 	virtual void MdvpoInitComplete(TInt aError);

   814 	virtual void MdvpoReturnPicture(TVideoPicture* aPicture);

   815 private:

   816 	CTestDevVideoPlayWritePicture(const TDesC& aTestName, TTestType aTestType);

   817 	~CTestDevVideoPlayWritePicture() {};

   818 	TVideoPicture *iPicture;

   819 	};

   820 

   821 //

   822 

   823 class CTestDevVideoPlayInputEnd : public CTestDevVideoPlayStep

   824 	{

   825 public:

   826 	static CTestDevVideoPlayInputEnd* NewL(const TDesC& aTestName, TTestType aTestType);

   827 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   828 	virtual void MdvpoInitComplete(TInt aError);

   829 	virtual void MdvpoStreamEnd();

   830 private:

   831 	CTestDevVideoPlayInputEnd(const TDesC& aTestName, TTestType aTestType);

   832 	~CTestDevVideoPlayInputEnd() {};

   833 	TUint iEndCount;

   834 	};

   835 

   836 //

   837 

   838 class CTestDevVideoPlayGetNewPictureInfo : public CTestDevVideoPlayStep

   839 	{

   840 public:

   841 	static CTestDevVideoPlayGetNewPictureInfo* NewL(const TDesC& aTestName, TTestType aTestType);

   842 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   843 	virtual void MdvpoInitComplete(TInt aError);

   844 private:

   845 	CTestDevVideoPlayGetNewPictureInfo(const TDesC& aTestName, TTestType aTestType);

   846 	~CTestDevVideoPlayGetNewPictureInfo() {};

   847 	};

   848 

   849 //

   850 

   851 class CTestDevVideoPlayNextPicture : public CTestDevVideoPlayStep

   852 	{

   853 public:

   854 	static CTestDevVideoPlayNextPicture* NewL(const TDesC& aTestName, TTestType aTestType);

   855 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   856 	virtual void MdvpoInitComplete(TInt aError);

   857     virtual void MdvpoNewPictures();

   858 	void CheckNewPictureInfoL(TUint aNumPictures, const TTimeIntervalMicroSeconds& aFirst, const TTimeIntervalMicroSeconds& aLast);

   859 	void DoNewPicturesL();

   860 private:

   861 	CTestDevVideoPlayNextPicture(const TDesC& aTestName, TTestType aTestType);

   862 	~CTestDevVideoPlayNextPicture() {};

   863 private:

   864 	TInt iCurrentPictureNumber;

   865 	CMMFDevVideoPlay* iDevVideoPlay;

   866 	};

   867 

   868 

   869 //

   870 

   871 class CTestDevVideoPlayGetSnapshot : public CTestDevVideoPlayStep

   872 	{

   873 public:

   874 	static CTestDevVideoPlayGetSnapshot* NewL(const TDesC& aTestName, TTestType aTestType);

   875 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   876 	virtual void MdvpoInitComplete(TInt aError);

   877 private:

   878 	CTestDevVideoPlayGetSnapshot(const TDesC& aTestName, TTestType aTestType);

   879 	~CTestDevVideoPlayGetSnapshot() {};

   880 	};

   881 

   882 //

   883 

   884 class CTestDevVideoPlayGetTimedSnapshotTimestamp : public CTestDevVideoPlayStep

   885 	{

   886 public:

   887 	static CTestDevVideoPlayGetTimedSnapshotTimestamp* NewL(const TDesC& aTestName, TTestType aTestType);

   888 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   889 	virtual void MdvpoInitComplete(TInt aError);

   890 	virtual void MdvpoTimedSnapshotComplete(TInt aError, 

   891 											TPictureData* aPictureData, 

   892 											const TTimeIntervalMicroSeconds& aPresentationTimestamp, 

   893 											const TPictureId& aPictureId);

   894 private:

   895 	CTestDevVideoPlayGetTimedSnapshotTimestamp(const TDesC& aTestName, TTestType aTestType);

   896 	~CTestDevVideoPlayGetTimedSnapshotTimestamp() {};

   897 	TTimeIntervalMicroSeconds iTimestamp;

   898 	TPictureData* iPictureData;

   899 	};

   900 

   901 //

   902 

   903 class CTestDevVideoPlayGetTimedSnapshotID : public CTestDevVideoPlayStep

   904 	{

   905 public:

   906 	static CTestDevVideoPlayGetTimedSnapshotID* NewL(const TDesC& aTestName, TTestType aTestType);

   907 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   908 	virtual void MdvpoInitComplete(TInt aError);

   909 	virtual void MdvpoTimedSnapshotComplete(TInt aError, 

   910 											TPictureData* aPictureData, 

   911 											const TTimeIntervalMicroSeconds& aPresentationTimestamp, 

   912 											const TPictureId& aPictureId);

   913 private:

   914 	CTestDevVideoPlayGetTimedSnapshotID(const TDesC& aTestName, TTestType aTestType);

   915 	~CTestDevVideoPlayGetTimedSnapshotID() {};

   916 	TPictureId iPictureId;

   917 	TPictureData* iPictureData;

   918 	};

   919 

   920 //

   921 

   922 class CTestDevVideoPlayCancelTimedSnapshot : public CTestDevVideoPlayStep

   923 	{

   924 public:

   925 	static CTestDevVideoPlayCancelTimedSnapshot* NewL(const TDesC& aTestName, TTestType aTestType);

   926 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   927 	virtual void MdvpoInitComplete(TInt aError);

   928 	virtual void MdvpoTimedSnapshotComplete(TInt aError, 

   929 											TPictureData* aPictureData, 

   930 											const TTimeIntervalMicroSeconds& aPresentationTimestamp, 

   931 											const TPictureId& aPictureId);

   932 private:

   933 	CTestDevVideoPlayCancelTimedSnapshot(const TDesC& aTestName, TTestType aTestType);

   934 	~CTestDevVideoPlayCancelTimedSnapshot() {};

   935 	};

   936 

   937 //

   938 

   939 class CTestDevVideoPlayGetSupportedSnapshotFormats : public CTestDevVideoPlayStep

   940 	{

   941 public:

   942 	static CTestDevVideoPlayGetSupportedSnapshotFormats* NewL(const TDesC& aTestName, TTestType aTestType);

   943 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   944 	virtual void MdvpoInitComplete(TInt aError);

   945 private:

   946 	CTestDevVideoPlayGetSupportedSnapshotFormats(const TDesC& aTestName, TTestType aTestType);

   947 	~CTestDevVideoPlayGetSupportedSnapshotFormats() {};

   948 	};

   949 

   950 //

   951 

   952 class CTestDevVideoPlayClock : public CTestDevVideoStep, public MMMFClockSourcePeriodicUtilityObserver

   953 	{

   954 public:

   955 	static CTestDevVideoPlayClock* NewL(const TDesC& aTestName);

   956 	CTestDevVideoPlayClock(const TDesC& aTestName);

   957 	~CTestDevVideoPlayClock();

   958 	void ConstructL();

   959 

   960 	virtual TVerdict DoTestStepL();

   961 	static TInt StartThread(TAny* aAny);

   962 	void RunThread();

   963 

   964 	// from MMMFClockSourcePeriodicUtilityObserver

   965 	virtual void MmcspuoTick(const TTimeIntervalMicroSeconds& aTime);

   966 protected:

   967 	TInt iError;

   968 	CSystemClockSource* iClockSource;

   969 	CMMFClockSourcePeriodicUtility* iPeriodicUtility;

   970 	TUint iPeriodicUtilityIteration;

   971 	TBool iShutdownSubthread;

   972 	TVerdict iPeriodicUtilityTestVerdict;

   973 	};

   974 

   975 //

   976 

   977 class CTestDevVideoPlayCommit : public CTestDevVideoPlayStep

   978 	{

   979 public:

   980 	static CTestDevVideoPlayCommit* NewL(const TDesC& aTestName, TTestType aTestType);

   981 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   982 	virtual void MdvpoInitComplete(TInt aError);

   983 private:

   984 	CTestDevVideoPlayCommit(const TDesC& aTestName, TTestType aTestType);

   985 	~CTestDevVideoPlayCommit() {};

   986 	};

   987 

   988 //

   989 

   990 class CTestDevVideoPlayRevert : public CTestDevVideoPlayStep

   991 	{

   992 public:

   993 	static CTestDevVideoPlayRevert* NewL(const TDesC& aTestName, TTestType aTestType);

   994 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

   995 	virtual void MdvpoInitComplete(TInt aError);

   996 private:

   997 	CTestDevVideoPlayRevert(const TDesC& aTestName, TTestType aTestType);

   998 	~CTestDevVideoPlayRevert() {};

   999 	};

  1000 

  1001 //

  1002 

  1003 class CTestDevVideoPlayCustomInterface : public CTestDevVideoPlayStep

  1004 	{

  1005 public:

  1006 	static CTestDevVideoPlayCustomInterface* NewL(const TDesC& aTestName, TTestType aTestType);

  1007 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

  1008 private:

  1009 	CTestDevVideoPlayCustomInterface(const TDesC& aTestName, TTestType aTestType);

  1010 	~CTestDevVideoPlayCustomInterface() {};

  1011 	};

  1012   

  1013 //

  1014 /*

  1015 class CTestDevVideoPlayXXX : public CTestDevVideoPlayStep

  1016 	{

  1017 public:

  1018 	static CTestDevVideoPlayXXX* NewL(const TDesC& aTestName, TTestType aTestType);

  1019 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

  1020 private:

  1021 	CTestDevVideoPlayXXX(const TDesC& aTestName, TTestType aTestType);

  1022 	~CTestDevVideoPlayXXX() {};

  1023 	};

  1024 */

  1025 //

  1026 class CTestDevVideoGetBufferWithoutInitialize : public CTestDevVideoPlayStep

  1027 	{

  1028 public:

  1029 	static CTestDevVideoGetBufferWithoutInitialize* NewL(const TDesC& aTestName, TTestType aTestType);

  1030 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

  1031 	virtual void MdvpoInitComplete(TInt aError);

  1032 	virtual void MdvpoNewBuffers();

  1033 private:

  1034 	CTestDevVideoGetBufferWithoutInitialize(const TDesC& aTestName, TTestType aTestType);

  1035 	~CTestDevVideoGetBufferWithoutInitialize() {};

  1036 	TBool iCalledBack;

  1037 	};

  1038 

  1039 //

  1040 

  1041 class CTestDevVideoPlayGetDecoderPostProcInfo : public CTestDevVideoPlayStep

  1042 	{

  1043 public:

  1044 	static CTestDevVideoPlayGetDecoderPostProcInfo* NewL(const TDesC& aTestName, TTestType aTestType);

  1045 	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

  1046 private:

  1047 	CTestDevVideoPlayGetDecoderPostProcInfo(const TDesC& aTestName, TTestType aTestType);

  1048 	~CTestDevVideoPlayGetDecoderPostProcInfo() {};

  1049 	TBool ValidPostProcInfo(CPostProcessorInfo* aInfo);

  1050 	};

  1051 

  1052 #endif	// TESTDEVVIDEOPLAY_H__