MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/mm/mmlibs/mmfw/tsrc/mmfintegrationtest/vclntavi/inc/testvideoplayer.h
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2005-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: Video Player Tests.

    15 // 

    16 //

    17 

    18 #ifndef __TESTVIDEOPLAYER_H__

    19 #define __TESTVIDEOPLAYER_H__

    20 

    21 #include "tsi_mmf_vclntavi_stepbase.h"

    22 #include "u32hal.h"

    23 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    24 #include <mmf/common/mmfvideoenums.h>

    25 #endif

    26 

    27 

    28 /**

    29  * Load and initialise a video file.

    30  *

    31  * RTestVclntPlayAviFile

    32  *

    33  */

    34 class RTestVclntPlayAviFile : public RTestVclntAviPlayerStep

    35     {

    36 public:

    37     RTestVclntPlayAviFile(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay);

    38     static RTestVclntPlayAviFile* NewL(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay);

    39     static RTestVclntPlayAviFile* NewLC(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay);

    40     virtual TVerdict DoTestStepL();

    41     virtual TVerdict DoTestL(CVideoPlayerUtility* aVideo);

    42     virtual void FsmL(TVclntTestPlayEvents aEventCode);

    43     virtual TVerdict SetCacheSize();

    44 protected:

    45     const TBool iPlay;

    46     TTimeIntervalMicroSeconds iDuration;

    47     };

    48 

    49 

    50 /**

    51  * Load and initialise an video descriptor.

    52  *

    53  * RTestVclntPlayAviDes

    54  *

    55  */

    56 class RTestVclntPlayAviDes : public RTestVclntAviPlayerStep

    57     {

    58 public:

    59     RTestVclntPlayAviDes(const TDesC& aTestName,const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay) ;

    60     static RTestVclntPlayAviDes* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay);

    61     static RTestVclntPlayAviDes* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError,const TBool aPlay);

    62     virtual TVerdict DoTestStepL();

    63     virtual TVerdict DoTestStepPreambleL();

    64     virtual TVerdict DoTestStepPostambleL();

    65     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

    66     virtual void FsmL(TVclntTestPlayEvents aEventCode);

    67 protected:

    68     HBufC8* iVideo;                        // Buffer for holding video descriptor data

    69     TTimeIntervalMicroSeconds iDuration;// Stores duration of video

    70     const TBool iPlay;                    // Does this test require playing the video

    71     } ;

    72 

    73 /**

    74  * Open video from a URL and play.

    75  *

    76  * RTestVclntPlayAviUrl

    77  *

    78  */

    79  

    80 class RTestVclntPlayAviUrl : public RTestVclntAviPlayerStep

    81     {

    82 public:

    83     RTestVclntPlayAviUrl(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay);

    84     static RTestVclntPlayAviUrl* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay);

    85     static RTestVclntPlayAviUrl* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TBool aPlay);

    86     virtual TVerdict DoTestStepL();

    87     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

    88     virtual void FsmL(TVclntTestPlayEvents aEventCode);

    89 protected:

    90     TTimeIntervalMicroSeconds iDuration;// Stores duration of video

    91     const TBool iPlay;                    // Does this test require playing the video

    92     };

    93 

    94 /**

    95  * Set and enquire framerate

    96  *

    97  * RTestVclntEnqFrameRate

    98  *

    99  */

   100 class RTestVclntEnqFrameRate : public RTestVclntPlayAviFile

   101     {

   102 public:

   103     static RTestVclntEnqFrameRate* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aFrameRate);

   104     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   105 

   106 private:

   107     RTestVclntEnqFrameRate(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aFrameRate);

   108 

   109 private:

   110     TReal32 iFrameRate;

   111     };

   112 

   113 

   114 /**

   115  * set position and play form this position.

   116  * 

   117  * RTestVclntPosition

   118  *

   119  */

   120 class RTestVclntPosition : public RTestVclntPlayAviFile

   121     {

   122 public:

   123     static RTestVclntPosition* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aPosition);

   124     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   125 private:

   126     RTestVclntPosition(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aPosition);

   127 

   128 private:

   129     TTimeIntervalMicroSeconds iPosition;

   130     };

   131 

   132 /**

   133  * Video priority

   134  * 

   135  * RTestVclntPriority

   136  *

   137  */

   138 class RTestVclntPriority : public RTestVclntPlayAviFile

   139     {

   140 public:

   141     static RTestVclntPriority* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aPriority);

   142     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   143 private:

   144     RTestVclntPriority(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aPriority);

   145 

   146 private:

   147     TInt iPriority;

   148     };

   149 

   150 

   151 /**

   152  * Video duration

   153  * 

   154  * RTestVclntDuration

   155  *

   156  */

   157 class RTestVclntDuration : public RTestVclntPlayAviFile

   158     {

   159 public:

   160     static RTestVclntDuration* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aDuration);

   161     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   162     virtual TVerdict SetCacheSize();

   163 private:

   164     RTestVclntDuration(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aDuration);

   165     SVMCacheInfo iCurrentCacheSize;

   166     TVerdict CheckCacheError(TInt aError);

   167     };

   168 

   169 

   170 /**

   171  * Video Volume

   172  * 

   173  * RTestVclntVolume

   174  *

   175  */

   176 class RTestVclntVolume : public RTestVclntPlayAviFile

   177     {

   178 public:

   179     static RTestVclntVolume* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aVolume);

   180     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   181 private:

   182     RTestVclntVolume(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aVolume);

   183 

   184 private:

   185     TInt iVolume;

   186     };

   187 

   188 

   189 /**

   190  * Video open, close and then open again.

   191  * 

   192  * RTestVclntCloseOpen

   193  *

   194  */

   195 class RTestVclntCloseOpen : public RTestVclntPlayAviFile

   196     {

   197 public:

   198     static RTestVclntCloseOpen* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   199     virtual TVerdict DoTestStepL();

   200     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   201 private:

   202     RTestVclntCloseOpen(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   203     TInt iOpenCount;

   204     };

   205 

   206 

   207 

   208 /**

   209  * Video pause.

   210  * 

   211  * RTestVclntPause

   212  *

   213  */

   214 class RTestVclntPause : public RTestVclntPlayAviFile

   215     {

   216 public:

   217     static RTestVclntPause* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   218     virtual TVerdict DoTestStepL();

   219     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   220 private:

   221     RTestVclntPause(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   222     TUint iPlayerDuration;

   223     TUint iActualDuration;

   224     };

   225 

   226 

   227 /**

   228  * Video pause.

   229  * 

   230  * RTestVclntBalance

   231  *

   232  */

   233 class RTestVclntBalance : public RTestVclntPlayAviFile

   234     {

   235 public:

   236     static RTestVclntBalance* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aBalance);

   237     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   238 private:

   239     RTestVclntBalance(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aBalance);

   240 

   241 private:

   242     TInt iBalance;

   243     };

   244 

   245 

   246 

   247 /**

   248  * Video set play window and delete play window.

   249  * 

   250  * RTestVclntPlayWindow

   251  *

   252  */

   253 class RTestVclntPlayWindow : public RTestVclntPlayAviFile

   254     {

   255 public:

   256     static RTestVclntPlayWindow* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aStart, const TTimeIntervalMicroSeconds aEnd);

   257     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   258 private:

   259     RTestVclntPlayWindow(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TTimeIntervalMicroSeconds aStart, const TTimeIntervalMicroSeconds aEnd);

   260 

   261 private:

   262     TTimeIntervalMicroSeconds iStart;

   263     TTimeIntervalMicroSeconds iEnd;

   264     };

   265 

   266 

   267 /**

   268  * Video get meta data.

   269  * 

   270  * RTestVclntMeta

   271  *

   272  */

   273 class RTestVclntMeta : public RTestVclntPlayAviFile

   274     {

   275 public:

   276     static RTestVclntMeta* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   277     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   278 private:

   279     RTestVclntMeta(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   280 

   281 private:

   282     TTimeIntervalMicroSeconds iStart;

   283     TTimeIntervalMicroSeconds iEnd;

   284     };

   285 

   286 

   287 /**

   288  * Video get framesize.

   289  * 

   290  * RTestVclntFrameSize

   291  *

   292  */

   293 class RTestVclntFrameSize : public RTestVclntPlayAviFile

   294     {

   295 public:

   296     static RTestVclntFrameSize* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   297     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   298 private:

   299     RTestVclntFrameSize(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   300 private:

   301     TSize iFrameSize;

   302     };

   303 

   304 

   305 /**

   306  * Video get mime type.

   307  * 

   308  * RTestVclntMimeType

   309  *

   310  */

   311 class RTestVclntMimeType : public RTestVclntPlayAviFile

   312     {

   313 public:

   314     static RTestVclntMimeType* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   315     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   316 private:

   317     RTestVclntMimeType(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   318     };

   319 

   320 

   321 /**

   322  * Video player scale values test.

   323  * 

   324  * RTestVclntScale

   325  *

   326  */

   327 class RTestVclntScale : public RTestVclntPlayAviFile

   328     {

   329 public:

   330     static RTestVclntScale* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   331     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   332 private:

   333     RTestVclntScale(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   334     };

   335     

   336 /**

   337  * Crop test for video

   338  * 

   339  * RTestVclntCrop

   340  *

   341  */

   342 class RTestVclntCrop : public RTestVclntPlayAviFile

   343     {

   344 public:

   345     static RTestVclntCrop* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   346     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   347 private:

   348     RTestVclntCrop(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   349     };

   350 

   351 #ifdef SYMBIAN_BUILD_GCE

   352 

   353 /**

   354 Auto scale test for video

   355 */

   356 

   357 class RTestVclntAutoScale : public RTestVclntPlayAviFile

   358 	{

   359 public:

   360 	static RTestVclntAutoScale* NewL(const TDesC& aTestName);

   361     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   362 private:

   363     RTestVclntAutoScale(const TDesC& aTestName);	

   364 	};

   365 

   366 #endif // SYMBIAN_BUILD_GCE

   367 

   368 /**

   369  * Frame test for video.

   370  * 

   371  * RTestVclntGetFrame

   372  *

   373  */

   374 class RTestVclntGetFrame : public RTestVclntPlayAviFile

   375     {

   376 public:

   377     static RTestVclntGetFrame* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, TBool aUseIntentAPI);

   378     virtual TVerdict DoTestStepL();

   379     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   380 protected:

   381     virtual void MvpuoFrameReady(CFbsBitmap& aFrame,TInt aError);

   382 private:

   383     RTestVclntGetFrame(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, TBool aUseIntentAPI);

   384     TBool iUseIntentAPI;

   385     };

   386 

   387 

   388 /**

   389  * Video rebuffering.

   390  * 

   391  * RTestVclntRebuffering

   392  *

   393  */

   394 class RTestVclntRebuffering : public RTestVclntPlayAviFile, public MVideoLoadingObserver

   395     {

   396 public:

   397     static RTestVclntRebuffering* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   398     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   399     void MvloLoadingStarted();

   400     void MvloLoadingComplete();

   401 private:

   402     RTestVclntRebuffering(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   403     };

   404 

   405 /**

   406  * Video get framesize.

   407  * 

   408  * RTestVclntRepeat

   409  *

   410  */

   411 class RTestVclntRepeat : public RTestVclntPlayAviFile

   412     {

   413 public:

   414     static RTestVclntRepeat* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aRepeat);

   415     virtual TVerdict DoTestL(CVideoPlayerUtility* aPlayer);

   416 private:

   417     RTestVclntRepeat(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError, const TInt aRepeat);

   418 private:

   419     TInt iRepeat;

   420     };

   421 

   422 

   423 

   424 /**

   425  * Video Delete object while playing

   426  * 

   427  * RTestVclntDelete

   428  *

   429  */

   430 class RTestVclntDelete : public RTestVclntPlayAviFile

   431     {

   432 public:

   433     static RTestVclntDelete* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   434     virtual TVerdict DoTestStepL();

   435     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   436 private:

   437     RTestVclntDelete(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, TInt aExpectedError);

   438     };

   439 

   440 /**

   441  * Play Video file

   442  * 

   443  * RTestVclntPlayAviFileHandle

   444  *

   445  */

   446 class RTestVclntPlayAviFileHandle : public RTestVclntAviPlayerStep

   447     {

   448 public:

   449     RTestVclntPlayAviFileHandle(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, const TBool aAlloc);

   450     static RTestVclntPlayAviFileHandle* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, const TBool aAlloc);

   451     static RTestVclntPlayAviFileHandle* NewLC(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError, const TBool aAlloc);

   452     virtual TVerdict DoTestStepL();

   453     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   454 	virtual TInt SetCacheSize();

   455 	virtual TInt CheckCacheError(TInt aError);

   456 

   457 protected:

   458     TVerdict PerformTestStepL();

   459     const TBool iAlloc;                        // Is this test an Alloc test

   460     TTimeIntervalMicroSeconds iDuration;    // Stores duration of video

   461     RFs iFs;

   462     RFile iFile;

   463     TBool iIsOpen;

   464     };

   465     

   466 /**

   467 

   468 RTestVideoPlayCapabilityVelocity

   469 

   470 */

   471 class RTestVideoPlayCapabilityVelocity: public RTestVclntAviPlayerStep

   472     {

   473 public:

   474 	RTestVideoPlayCapabilityVelocity(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   475     static RTestVideoPlayCapabilityVelocity* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   476     virtual TVerdict DoTestStepL();

   477     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   478 protected:

   479 	TVideoPlayRateCapabilities iVideoPlayRateCapabilities;

   480 	TInt iPlayVelocity;

   481     RFs iFs;

   482     RFile iFile;

   483     };

   484 

   485 /**

   486 

   487 RTestVideoPlayStepFrame

   488 

   489 */

   490 class RTestVideoPlayStepFrame: public RTestVclntAviPlayerStep

   491     {

   492 public:

   493 	RTestVideoPlayStepFrame(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   494     static RTestVideoPlayStepFrame* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   495     virtual TVerdict DoTestStepL();

   496     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   497     static TInt TimerCallback(TAny* aPtr);

   498 protected:

   499 	TVideoPlayRateCapabilities iVideoPlayRateCapabilities;

   500 	CPeriodic* iTimer;

   501 	TInt iPlayVelocity;

   502     RFs iFs;

   503     RFile iFile;

   504     };

   505     

   506 /**

   507 

   508 RTestVideoPlayCapabilityVelocity

   509 

   510 */

   511 class RTestVideoPlayAudVidEnable: public RTestVclntAviPlayerStep

   512     {

   513 public:

   514 	RTestVideoPlayAudVidEnable(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   515     static RTestVideoPlayAudVidEnable* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   516     virtual TVerdict DoTestStepL();

   517     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   518 protected:

   519 	TInt iPlayVelocity;

   520     RFs iFs;

   521     RFile iFile;

   522     };

   523 

   524 /**

   525 

   526 RTestVideoPlayAutoScale

   527 

   528 */

   529 class RTestVideoPlayAutoScale: public RTestVclntAviPlayerStep

   530     {

   531 public:

   532 	RTestVideoPlayAutoScale(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   533     static RTestVideoPlayAutoScale* NewL(const TDesC& aTestName, const TDesC& aSectName, const TDesC& aKeyName, TInt aExpectedError);

   534     virtual TVerdict DoTestStepL();

   535     virtual void FsmL(TVclntTestPlayEvents aEventCode);

   536 protected:

   537 	TInt iPlayVelocity;

   538     RFs iFs;

   539     RFile iFile;

   540     };

   541 

   542 #endif //__TESTVIDEOPLAYER_H__
Symaptic