Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/ciu/testdevvideociuplay.h@260cb5ec6c19

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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Header file: DevVideoCiuPlay tests.

    15 //

    16 //

    18 /**

    19  @file testdevvideociuplay.h

    20 */

    22 #ifndef TESTDEVVIDEOCIUPLAY_H

    23 #define TESTDEVVIDEOCIUPLAY_H

    25 #include <mmf/devvideo/devvideostandardcustominterfaces.h>

    26 #include <mmf/devvideo/videoplayhwdevice.h>

    27 #include <mmf/devvideo/devvideoconstants.h>

    28 #include <mmf/devvideo/devvideoplayratecustominterface.h>

    30 #ifdef SYMBIAN_BUILD_GCE

    31 #include <mmf/devvideo/devvideosurfacehandlecustominterface.h>

    32 #include <mmf/devvideo/devvideovideosurfacecustominterface.h>

    33 #endif // SYMBIAN_BUILD_GCE

    35 #include "tsu_mmf_devvideociu.h"

    37 /**

    38  * DevVideoPlay test base class

    39  *

    40  * @class CTestDevVideoCiuPlayStep

    41 */

    42 class CTestDevVideoCiuPlayStep : public CTestDevVideoCiuStep, public MMMFDevVideoPlayObserver

    43 	{

    44 public:

    45 	CTestDevVideoCiuPlayStep(const TDesC& aTestName);

    46 	~CTestDevVideoCiuPlayStep();

    47 	virtual TVerdict DoTestStepL();

    48 	virtual TVerdict DoTestL() = 0;

    50 	virtual TVerdict DoTestStepPreambleL();

    51 	virtual TVerdict DoTestStepPostambleL();

    53 	// MMMFDevVideoPlayObserver

    54     virtual void MdvpoNewBuffers();

    55     virtual void MdvpoReturnPicture(TVideoPicture* aPicture);

    56     virtual void MdvpoSupplementalInformation(const TDesC8& aData,

    57 											  const TTimeIntervalMicroSeconds& aTimestamp,

    58 											  const TPictureId& aPictureId);

    59 	virtual void MdvpoPictureLoss();

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

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

    62 	virtual void MdvpoReferencePictureSelection(const TDesC8& aSelectionData);

    63     virtual void MdvpoTimedSnapshotComplete(TInt aError,

    64 											TPictureData* aPictureData,

    65 											const TTimeIntervalMicroSeconds& aPresentationTimestamp,

    66 											const TPictureId& aPictureId);

    67     virtual void MdvpoNewPictures();

    68     virtual void MdvpoFatalError(TInt aError);

    69     virtual void MdvpoInitComplete(TInt aError);

    70     virtual void MdvpoStreamEnd();

    72 protected:

    73 	TInt iError;

    74 	THwDeviceId iHwDeviceId;

    75 	CMMFDevVideoPlay* iDevVideoPlay;

    76 	};

    78 //

    79 //	Video Window Control Tests

    80 //

    82 class CTestDevVideoCiuPlayGetAndSetLogicalWindow : public CTestDevVideoCiuPlayStep

    83 	{

    84 public:

    85 	static CTestDevVideoCiuPlayGetAndSetLogicalWindow* NewL(const TDesC& aTestName);

    86 	virtual TVerdict DoTestL();

    87 	virtual TVerdict DoTestStepPreambleL();

    88 private:

    89 	CTestDevVideoCiuPlayGetAndSetLogicalWindow(const TDesC& aTestName);

    90 	~CTestDevVideoCiuPlayGetAndSetLogicalWindow() {};

    91 	};

    93 //

    95 class CTestDevVideoCiuPlayGetAndSetContentOffset : public CTestDevVideoCiuPlayStep

    96 	{

    97 public:

    98 	static CTestDevVideoCiuPlayGetAndSetContentOffset* NewL(const TDesC& aTestName);

    99 	virtual TVerdict DoTestL();

   100 	virtual TVerdict DoTestStepPreambleL();

   101 private:

   102 	CTestDevVideoCiuPlayGetAndSetContentOffset(const TDesC& aTestName);

   103 	~CTestDevVideoCiuPlayGetAndSetContentOffset() {};

   104 	};

   106 //

   108 class CTestDevVideoCiuPlayGetAndSetContentAlignment : public CTestDevVideoCiuPlayStep

   109 	{

   110 public:

   111 	static CTestDevVideoCiuPlayGetAndSetContentAlignment* NewL(const TDesC& aTestName);

   112 	virtual TVerdict DoTestL();

   113 	virtual TVerdict DoTestStepPreambleL();

   114 private:

   115 	CTestDevVideoCiuPlayGetAndSetContentAlignment(const TDesC& aTestName);

   116 	~CTestDevVideoCiuPlayGetAndSetContentAlignment() {};

   117 	};

   119 //

   120 //	Video Resource Management Tests

   121 //

   123 class CTestDevVideoCiuPlayGetAndSetResourceObserver : public CTestDevVideoCiuPlayStep,

   124 													  public MMmfVideoResourceObserver

   125 	{

   126 public:

   127 	static CTestDevVideoCiuPlayGetAndSetResourceObserver* NewL(const TDesC& aTestName);

   128 	virtual TVerdict DoTestL();

   129 	virtual TVerdict DoTestStepPreambleL();

   131 	//from MMmfVideoResourceObserver

   132 	void MmvroResourcesLost(TUid aMediaDevice);

   133 	void MmvroResourcesRestored(TUid aMediaDevice);

   135 private:

   136 	CTestDevVideoCiuPlayGetAndSetResourceObserver(const TDesC& aTestName);

   137 	~CTestDevVideoCiuPlayGetAndSetResourceObserver() {};

   138 	};

   140 //

   142 class CTestDevVideoCiuPlayResourceLost : public CTestDevVideoCiuPlayStep,

   143 										 public MMmfVideoResourceObserver

   144 	{

   145 public:

   146 	static CTestDevVideoCiuPlayResourceLost* NewL(const TDesC& aTestName);

   147 	virtual TVerdict DoTestL();

   148 	virtual TVerdict DoTestStepPreambleL();

   150 	//from MMmfVideoResourceObserver

   151 	void MmvroResourcesLost(TUid aMediaDevice);

   152 	void MmvroResourcesRestored(TUid aMediaDevice);

   154 private:

   155 	CTestDevVideoCiuPlayResourceLost(const TDesC& aTestName);

   156 	~CTestDevVideoCiuPlayResourceLost() {};

   157 private:

   158 	TBool iCallbackReceived;

   159 	};

   161 //

   163 class CTestDevVideoCiuPlayResourceRestored : public CTestDevVideoCiuPlayStep,

   164 										     public MMmfVideoResourceObserver

   165 	{

   166 public:

   167 	static CTestDevVideoCiuPlayResourceRestored* NewL(const TDesC& aTestName);

   168 	virtual TVerdict DoTestL();

   169 	virtual TVerdict DoTestStepPreambleL();

   171 	//from MMmfVideoResourceObserver

   172 	void MmvroResourcesLost(TUid aMediaDevice);

   173 	void MmvroResourcesRestored(TUid aMediaDevice);

   175 private:

   176 	CTestDevVideoCiuPlayResourceRestored(const TDesC& aTestName);

   177 	~CTestDevVideoCiuPlayResourceRestored() {};

   178 private:

   179 	TBool iCallbackReceived;

   180 	};

   182 //

   184 class CTestDevVideoCiuPlayGetAndSetResourcePriority : public CTestDevVideoCiuPlayStep

   185 	{

   186 public:

   187 	static CTestDevVideoCiuPlayGetAndSetResourcePriority* NewL(const TDesC& aTestName);

   188 	virtual TVerdict DoTestL();

   189 	virtual TVerdict DoTestStepPreambleL();

   190 private:

   191 	CTestDevVideoCiuPlayGetAndSetResourcePriority(const TDesC& aTestName);

   192 	~CTestDevVideoCiuPlayGetAndSetResourcePriority() {};

   193 	};

   195 //

   196 //	Video Properties Management Tests

   197 //

   199 class CTestDevVideoCiuPlaySetAndGetPropertiesObserver : public CTestDevVideoCiuPlayStep,

   200 													  public MMmfVideoPropertiesObserver

   201 	{

   202 public:

   203 	static CTestDevVideoCiuPlaySetAndGetPropertiesObserver* NewL(const TDesC& aTestName);

   204 	virtual TVerdict DoTestL();

   205 	virtual TVerdict DoTestStepPreambleL();

   207 	//from MMmfVideoPropertiesObserver

   208 	void MmvpoUpdateVideoProperties(const TYuvFormat& aYuvFormat, const TSize& aPictureSize);

   210 private:

   211 	CTestDevVideoCiuPlaySetAndGetPropertiesObserver(const TDesC& aTestName);

   212 	~CTestDevVideoCiuPlaySetAndGetPropertiesObserver() {};

   213 	};

   215 //

   217 class CTestDevVideoCiuPlayUpdateProperties : public CTestDevVideoCiuPlayStep,

   218 										     public MMmfVideoPropertiesObserver

   219 	{

   220 public:

   221 	static CTestDevVideoCiuPlayUpdateProperties* NewL(const TDesC& aTestName);

   222 	virtual TVerdict DoTestL();

   223 	virtual TVerdict DoTestStepPreambleL();

   225 	//from MMmfVideoPropertiesObserver

   226 	void MmvpoUpdateVideoProperties(const TYuvFormat& aYuvFormat, const TSize& aPictureSize);

   228 private:

   229 	CTestDevVideoCiuPlayUpdateProperties(const TDesC& aTestName);

   230 	~CTestDevVideoCiuPlayUpdateProperties() {};

   231 private:

   232 	TBool iCallbackReceived;

   233 	};

   235 //

   236 //	Video Media Protected Tests

   237 //

   239 class CTestDevVideoCiuPlayCreateVideoMediaProtected : public CTestDevVideoCiuPlayStep

   240 	{

   241 public:

   242 	static CTestDevVideoCiuPlayCreateVideoMediaProtected* NewL(const TDesC& aTestName);

   243 	virtual TVerdict DoTestL();

   244 	virtual TVerdict DoTestStepPreambleL();

   245 private:

   246 	CTestDevVideoCiuPlayCreateVideoMediaProtected(const TDesC& aTestName);

   247 	~CTestDevVideoCiuPlayCreateVideoMediaProtected() {};

   248 	};

   250 //

   252 class CTestDevVideoCiuPlaySetVideoMediaProtected : public CTestDevVideoCiuPlayStep

   253 	{

   254 public:

   255 	static CTestDevVideoCiuPlaySetVideoMediaProtected* NewL(const TDesC& aTestName);

   256 	virtual TVerdict DoTestL();

   257 	TVerdict DoTestStepPreambleL();

   258 private:

   259 	CTestDevVideoCiuPlaySetVideoMediaProtected(const TDesC& aTestName);

   260 	~CTestDevVideoCiuPlaySetVideoMediaProtected() {};

   261 	};

   263 //

   264 //	Colour Space Header Info Tests

   265 //

   267 class CTestDevVideoCiuPlayCreateColourSpace : public CTestDevVideoCiuPlayStep

   268 	{

   269 public:

   270 	static CTestDevVideoCiuPlayCreateColourSpace* NewL(const TDesC& aTestName);

   271 	virtual TVerdict DoTestL();

   272 	virtual TVerdict DoTestStepPreambleL();

   273 private:

   274 	CTestDevVideoCiuPlayCreateColourSpace(const TDesC& aTestName);

   275 	~CTestDevVideoCiuPlayCreateColourSpace() {};

   276 	};

   278 //

   280 class CTestDevVideoCiuPlayGetColourSpace : public CTestDevVideoCiuPlayStep

   281 	{

   282 public:

   283 	static CTestDevVideoCiuPlayGetColourSpace* NewL(const TDesC& aTestName);

   284 	virtual TVerdict DoTestL();

   285 	TVerdict DoTestStepPreambleL();

   286 private:

   287 	CTestDevVideoCiuPlayGetColourSpace(const TDesC& aTestName);

   288 	~CTestDevVideoCiuPlayGetColourSpace() {};

   289 	};

   292 //

   293 // Resource Control tests

   294 //

   296 class CTestDevVideoCiuPlayCreatePolicyExtension : public CTestDevVideoCiuPlayStep

   297 	{

   298 public:

   299 	static CTestDevVideoCiuPlayCreatePolicyExtension* NewL(const TDesC& aTestName);

   300 	virtual TVerdict DoTestL();

   301 	virtual TVerdict DoTestStepPreambleL();

   302 private:

   303 	CTestDevVideoCiuPlayCreatePolicyExtension(const TDesC& aTestName);

   304 	~CTestDevVideoCiuPlayCreatePolicyExtension() {};

   305 	};

   307 //

   309 class CTestDevVideoCiuPlaySetClientPolicyExtension : public CTestDevVideoCiuPlayStep,

   310 														public MMmfVideoHwDevClientNotifier

   311 	{

   312 public:

   313 	static CTestDevVideoCiuPlaySetClientPolicyExtension* NewL(const TDesC& aTestName);

   314 	virtual TVerdict DoTestL();

   315 	TVerdict DoTestStepPreambleL();

   317 	// from MMmfVideoHwDevClientNotifier

   318 	virtual void MmvhcnVideoAccessRevoked();

   319 	virtual void MmvhcnReleaseVideoResource();

   320 private:

   321 	CTestDevVideoCiuPlaySetClientPolicyExtension(const TDesC& aTestName);

   322 	~CTestDevVideoCiuPlaySetClientPolicyExtension() {};

   323 	};

   325 //

   327 class CTestDevVideoCiuPlaySetPriorityPolicyExtension : public CTestDevVideoCiuPlayStep

   328 	{

   329 public:

   330 	static CTestDevVideoCiuPlaySetPriorityPolicyExtension* NewL(const TDesC& aTestName);

   331 	virtual TVerdict DoTestL();

   332 	virtual TVerdict DoTestStepPreambleL();

   333 private:

   334 	CTestDevVideoCiuPlaySetPriorityPolicyExtension(const TDesC& aTestName);

   335 	~CTestDevVideoCiuPlaySetPriorityPolicyExtension() {};

   336 	};

   338 //

   340 class CTestDevVideoCiuPlayClientNotifierRevoked : public CTestDevVideoCiuPlayStep,

   341 													public MMmfVideoHwDevClientNotifier

   342 	{

   343 public:

   344 	static CTestDevVideoCiuPlayClientNotifierRevoked* NewL(const TDesC& aTestName);

   345 	virtual TVerdict DoTestL();

   346 	TVerdict DoTestStepPreambleL();

   348 	// from MMmfVideoHwDevClientNotifier

   349 	virtual void MmvhcnVideoAccessRevoked();

   350 	virtual void MmvhcnReleaseVideoResource();

   352 private:

   353 	CTestDevVideoCiuPlayClientNotifierRevoked(const TDesC& aTestName);

   354 	~CTestDevVideoCiuPlayClientNotifierRevoked() {};

   356 private:

   357 	TBool iCallback;

   358 	};

   360 //

   362 class CTestDevVideoCiuPlayClientNotifierResource : public CTestDevVideoCiuPlayStep,

   363 													public MMmfVideoHwDevClientNotifier

   364 	{

   365 public:

   366 	static CTestDevVideoCiuPlayClientNotifierResource* NewL(const TDesC& aTestName);

   367 	virtual TVerdict DoTestL();

   368 	TVerdict DoTestStepPreambleL();

   370 	// from MMmfVideoHwDevClientNotifier

   371 	virtual void MmvhcnVideoAccessRevoked();

   372 	virtual void MmvhcnReleaseVideoResource();

   374 private:

   375 	CTestDevVideoCiuPlayClientNotifierResource(const TDesC& aTestName);

   376 	~CTestDevVideoCiuPlayClientNotifierResource() {};

   378 private:

   379 	TBool iCallback;

   380 	};

   382 //

   383 //							NEGATIVE TESTS

   384 //

   385 class CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder : public CTestDevVideoCiuPlayStep

   386 	{

   387 public:

   388 	static CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder* NewL(const TDesC& aTestName);

   389 	virtual TVerdict DoTestL();

   390 	TVerdict DoTestStepPreambleL();

   391 private:

   392 	CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder(const TDesC& aTestName);

   393 	~CTestDevVideoCiuPlayCreateVideoMediaProtectedDecoder() {};

   394 	};

   396 //

   397 //	Video Surface Support Management Tests

   398 //

   400 class CTestDevVideoCiuPlayGetAndSetUseSurface : public CTestDevVideoCiuPlayStep

   401 	{

   402 public:

   403 	static CTestDevVideoCiuPlayGetAndSetUseSurface* NewL(const TDesC& aTestName);

   404 	virtual TVerdict DoTestL();

   405 	virtual TVerdict DoTestStepPreambleL();

   406 private:

   407 	CTestDevVideoCiuPlayGetAndSetUseSurface(const TDesC& aTestName);

   408 	~CTestDevVideoCiuPlayGetAndSetUseSurface() {};

   409 	};

   411 //

   413 class CTestDevVideoCiuPlayGetAndSetSurfaceParameters : public CTestDevVideoCiuPlayStep

   414 	{

   415 public:

   416 	static CTestDevVideoCiuPlayGetAndSetSurfaceParameters* NewL(const TDesC& aTestName);

   417 	virtual TVerdict DoTestL();

   418 	virtual TVerdict DoTestStepPreambleL();

   419 private:

   420 	CTestDevVideoCiuPlayGetAndSetSurfaceParameters(const TDesC& aTestName);

   421 	~CTestDevVideoCiuPlayGetAndSetSurfaceParameters() {};

   422 	};

   424 //

   426 class CTestDevVideoCiuPlayGetAndSetSurfaceRemoved : public CTestDevVideoCiuPlayStep

   427 	{

   428 public:

   429 	static CTestDevVideoCiuPlayGetAndSetSurfaceRemoved* NewL(const TDesC& aTestName);

   430 	virtual TVerdict DoTestL();

   431 	virtual TVerdict DoTestStepPreambleL();

   432 private:

   433 	CTestDevVideoCiuPlayGetAndSetSurfaceRemoved(const TDesC& aTestName);

   434 	~CTestDevVideoCiuPlayGetAndSetSurfaceRemoved() {};

   435 	};

   437 //

   439 #ifdef SYMBIAN_BUILD_GCE

   441 class CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver : public CTestDevVideoCiuPlayStep,

   442 													  public MMMFVideoSurfaceObserver

   443 	{

   444 public:

   445 	static CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver* NewL(const TDesC& aTestName);

   446 	virtual TVerdict DoTestL();

   447 	virtual TVerdict DoTestStepPreambleL();

   449 	//from MMMFVideoSurfaceObserver

   450 	void MmvsoSurfaceCreated();

   451 	void MmvsoSurfaceParametersChanged();

   452 	void MmvsoRemoveSurface();

   454 private:

   455 	CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver(const TDesC& aTestName);

   456 	~CTestDevVideoCiuPlaySetAndGetSurfaceSupportObserver() {};

   457 	};

   459 //

   461 class CTestDevVideoCiuPlaySurfaceCreated : public CTestDevVideoCiuPlayStep,

   462 										     public MMMFVideoSurfaceObserver

   463 	{

   464 public:

   465 	static CTestDevVideoCiuPlaySurfaceCreated* NewL(const TDesC& aTestName);

   466 	virtual TVerdict DoTestL();

   467 	virtual TVerdict DoTestStepPreambleL();

   469 	//from MMMFVideoSurfaceObserver

   470 	void MmvsoSurfaceCreated();

   471 	void MmvsoSurfaceParametersChanged();

   472 	void MmvsoRemoveSurface();

   474 private:

   475 	CTestDevVideoCiuPlaySurfaceCreated(const TDesC& aTestName);

   476 	~CTestDevVideoCiuPlaySurfaceCreated() {};

   477 private:

   478 	TBool iCallbackReceived;

   479 	};

   482 //

   484 class CTestDevVideoCiuPlaySurfaceParametersChanged : public CTestDevVideoCiuPlayStep,

   485 										     public MMMFVideoSurfaceObserver

   486 	{

   487 public:

   488 	static CTestDevVideoCiuPlaySurfaceParametersChanged* NewL(const TDesC& aTestName);

   489 	virtual TVerdict DoTestL();

   490 	virtual TVerdict DoTestStepPreambleL();

   492 	//from MMMFVideoSurfaceObserver

   493 	void MmvsoSurfaceCreated();

   494 	void MmvsoSurfaceParametersChanged();

   495 	void MmvsoRemoveSurface();

   497 private:

   498 	CTestDevVideoCiuPlaySurfaceParametersChanged(const TDesC& aTestName);

   499 	~CTestDevVideoCiuPlaySurfaceParametersChanged() {};

   500 private:

   501 	TBool iCallbackReceived;

   502 	};

   504 //

   506 class CTestDevVideoCiuRemoveSurface : public CTestDevVideoCiuPlayStep,

   507 									  public MMMFVideoSurfaceObserver

   508 	{

   509 public:

   510 	static CTestDevVideoCiuRemoveSurface* NewL(const TDesC& aTestName);

   511 	virtual TVerdict DoTestL();

   512 	virtual TVerdict DoTestStepPreambleL();

   514 	//from MMMFVideoSurfaceObserver

   515 	void MmvsoSurfaceCreated();

   516 	void MmvsoSurfaceParametersChanged();

   517 	void MmvsoRemoveSurface();

   519 private:

   520 	CTestDevVideoCiuRemoveSurface(const TDesC& aTestName);

   521 	~CTestDevVideoCiuRemoveSurface() {};

   522 private:

   523 	TBool iCallbackReceived;

   524 	};

   526 //

   527 //	Video Client Buffer Support Tests

   528 //

   530 class CTestDevVideoCiuPlayUseClientBuffers : public CTestDevVideoCiuPlayStep

   531 	{

   532 public:

   533 	static CTestDevVideoCiuPlayUseClientBuffers* NewL(const TDesC& aTestName);

   534 	TVerdict DoTestL();

   535 	TVerdict DoTestStepPreambleL();

   536 private:

   537 	CTestDevVideoCiuPlayUseClientBuffers(const TDesC& aTestName);

   538 	~CTestDevVideoCiuPlayUseClientBuffers() {};

   539 	};

   541 //

   543 class CTestDevVideoCiuPlaySupplyBuffer : public CTestDevVideoCiuPlayStep

   544 	{

   545 public:

   546 	static CTestDevVideoCiuPlaySupplyBuffer* NewL(const TDesC& aTestName);

   547 	TVerdict DoTestL();

   548 	TVerdict DoTestStepPreambleL();

   549 private:

   550 	CTestDevVideoCiuPlaySupplyBuffer(const TDesC& aTestName);

   551 	~CTestDevVideoCiuPlaySupplyBuffer() {};

   552 	};

   554 //

   556 class CTestDevVideoCiuPlayReleaseBuffers : public CTestDevVideoCiuPlayStep

   557 	{

   558 public:

   559 	static CTestDevVideoCiuPlayReleaseBuffers* NewL(const TDesC& aTestName);

   560 	TVerdict DoTestL();

   561 	TVerdict DoTestStepPreambleL();

   562 private:

   563 	CTestDevVideoCiuPlayReleaseBuffers(const TDesC& aTestName);

   564 	~CTestDevVideoCiuPlayReleaseBuffers() {};

   565 	};

   567 //

   568 //	Video SurfaceId Custom Interface Tests

   569 //

   571 class CTestDevVideoCiuPlaySurfaceHandleControl : public CTestDevVideoCiuPlayStep

   572 	{

   573 public:

   574 	static CTestDevVideoCiuPlaySurfaceHandleControl* NewL(const TDesC& aTestName);

   575 	virtual TVerdict DoTestL();

   576 	virtual TVerdict DoTestStepPreambleL();

   578 private:

   579 	CTestDevVideoCiuPlaySurfaceHandleControl(const TDesC& aTestName);

   580 	~CTestDevVideoCiuPlaySurfaceHandleControl() {};

   581 	};

   583 class CTestDevVideoCiuPlaySurfaceRedrawBuffer : public CTestDevVideoCiuPlayStep

   584 	{

   585 public:

   586 	static CTestDevVideoCiuPlaySurfaceRedrawBuffer* NewL(const TDesC& aTestName);

   587 	virtual TVerdict DoTestL();

   588 	virtual TVerdict DoTestStepPreambleL();

   590 private:

   591 	CTestDevVideoCiuPlaySurfaceRedrawBuffer(const TDesC& aTestName);

   592 	~CTestDevVideoCiuPlaySurfaceRedrawBuffer() {};

   593 	};

   595 #endif // SYMBIAN_BUILD_GCE

   597 //

   598 //	Video Play Rate Tests

   599 //

   601 class CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities : public CTestDevVideoCiuPlayStep

   602 	{

   603 public:

   604 	static CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities* NewL(const TDesC& aTestName);

   605 	virtual TVerdict DoTestL();

   606 	virtual TVerdict DoTestStepPreambleL();

   607 private:

   608 	CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities(const TDesC& aTestName);

   609 	~CTestDevVideoCiuPlayGetAndSetPlayRateCapabilities() {};

   610 	};

   612 //

   614 class CTestDevVideoCiuPlaySetAndGetPlayRate : public CTestDevVideoCiuPlayStep

   615 	{

   616 public:

   617 	static CTestDevVideoCiuPlaySetAndGetPlayRate* NewL(const TDesC& aTestName);

   618 	virtual TVerdict DoTestL();

   619 	virtual TVerdict DoTestStepPreambleL();

   620 private:

   621 	CTestDevVideoCiuPlaySetAndGetPlayRate(const TDesC& aTestName);

   622 	~CTestDevVideoCiuPlaySetAndGetPlayRate() {};

   623 	};

   625 //

   627 class CTestDevVideoCiuPlayGetAndSetStepFrame : public CTestDevVideoCiuPlayStep

   628 	{

   629 public:

   630 	static CTestDevVideoCiuPlayGetAndSetStepFrame* NewL(const TDesC& aTestName);

   631 	virtual TVerdict DoTestL();

   632 	virtual TVerdict DoTestStepPreambleL();

   633 private:

   634 	CTestDevVideoCiuPlayGetAndSetStepFrame(const TDesC& aTestName);

   635 	~CTestDevVideoCiuPlayGetAndSetStepFrame() {};

   636 	};

   638 //

   640 class CTestDevVideoCiuPlaySetAndGetPlayRateObserver : public CTestDevVideoCiuPlayStep,

   641 													  public MMmfVideoPlayRateObserver

   642 	{

   643 public:

   644 	static CTestDevVideoCiuPlaySetAndGetPlayRateObserver* NewL(const TDesC& aTestName);

   645 	virtual TVerdict DoTestL();

   646 	virtual TVerdict DoTestStepPreambleL();

   648 	//from MMmfVideoPlayRateObserver

   649 	void MmvproStepFrameComplete(TTimeIntervalMicroSeconds aTimestamp);

   650 	void MmvproKeyFrameModeRequest();

   652 private:

   653 	CTestDevVideoCiuPlaySetAndGetPlayRateObserver(const TDesC& aTestName);

   654 	~CTestDevVideoCiuPlaySetAndGetPlayRateObserver() {};

   655 	};

   657 //

   659 class CTestDevVideoCiuPlayStepFrameComplete : public CTestDevVideoCiuPlayStep,

   660 											public MMmfVideoPlayRateObserver

   661 	{

   662 public:

   663 	static CTestDevVideoCiuPlayStepFrameComplete* NewL(const TDesC& aTestName);

   664 	virtual TVerdict DoTestL();

   665 	virtual TVerdict DoTestStepPreambleL();

   667 	//from MMmfVideoPlayRateObserver

   668 	void MmvproStepFrameComplete(TTimeIntervalMicroSeconds aTimestamp);

   669 	void MmvproKeyFrameModeRequest();

   671 private:

   672 	CTestDevVideoCiuPlayStepFrameComplete(const TDesC& aTestName);

   673 	~CTestDevVideoCiuPlayStepFrameComplete() {};

   674 private:

   675 	TBool iCallbackReceived;

   676 	};

   678 //

   680 class CTestDevVideoCiuPlayKeyFrameModeRequest : public CTestDevVideoCiuPlayStep,

   681 												public MMmfVideoPlayRateObserver

   682 	{

   683 public:

   684 	static CTestDevVideoCiuPlayKeyFrameModeRequest* NewL(const TDesC& aTestName);

   685 	virtual TVerdict DoTestL();

   686 	virtual TVerdict DoTestStepPreambleL();

   688 	//from MMmfVideoPlayRateObserver

   689 	void MmvproStepFrameComplete(TTimeIntervalMicroSeconds aTimestamp);

   690 	void MmvproKeyFrameModeRequest();

   692 private:

   693 	CTestDevVideoCiuPlayKeyFrameModeRequest(const TDesC& aTestName);

   694 	~CTestDevVideoCiuPlayKeyFrameModeRequest() {};

   695 private:

   696 	TBool iCallbackReceived;

   697 	};

   699 // Test MMmfVideoHwDeviceTunnel custom interface

   700 class CTestDevVideoCiuHwDeviceTunnel : public CTestDevVideoCiuPlayStep

   701 	{

   702 public:

   703 	static CTestDevVideoCiuHwDeviceTunnel* NewL(const TDesC& aTestName);

   704 	virtual TVerdict DoTestL();

   705 	virtual TVerdict DoTestStepPreambleL();

   707 private:

   708 	CTestDevVideoCiuHwDeviceTunnel(const TDesC& aTestName);

   709 	~CTestDevVideoCiuHwDeviceTunnel() {};

   710 	};

   712 #endif //TESTDEVVIDEOCIUPLAY_H

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