1 

     2 // Copyright (c) 2001-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 // Header file: Basic  tests.

    16 // 

    17 //

    18 

    19 /**

    20  @file TestConverter.h

    21 */

    22 

    23 

    24 #ifndef TESTCONVERTER_H__

    25 #define TESTCONVERTER_H__

    26 

    27 #include "TSI_MMFACLNT.h"

    28 

    29 //Original duration = 8359176 Us with 92160 bytes of 8bit per sample data + 44 header

    30 //Window start = 2089794 Us, aligned to a frame = 1857596 Us

    31 //Window end = 6269382 Us, aligned to a frame =6315828 Us

    32 //Therefore window = 4179588, aligned to a frames =4458231 Us

    33 

    34 //New file = 4458231/8359176 * 92160 * 16bits(2) + 44 = 98348

    35 const TInt KConverterWindowFileSize = 98348;

    36 

    37 

    38 //Add to KConverterWindowFileSize a full convert of the source file:-

    39 //=92160 * 16bits(2) + KConverterWindowFileSize

    40 const TInt KConverterWindowPlusNormalFileSize = 282668;

    41 

    42 

    43 /**

    44  * Set config destination clip

    45  *

    46  * @class CTestMmfAclntConConfig

    47  *

    48  */

    49 class CTestMmfAclntConConfig : public CTestMmfAclntCodecTest, public MMdaObjectStateChangeObserver 

    50 	{

    51 public:

    52 	CTestMmfAclntConConfig(const TDesC& aTestName, const TTestFormat aFormat, const TBool aNegative);

    53 	static CTestMmfAclntConConfig* NewL(const TDesC& aTestName, const TTestFormat aFormat, const TBool aNegative = EFalse);

    54 	virtual TVerdict DoTestStepL();

    55 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

    56 	virtual TVerdict DoTestStepPreambleL();

    57 	// from MMdaObjectStateChangeObserver

    58 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

    59 

    60 protected:

    61 	virtual void GetKeyName(TDes& aDes);

    62 protected:

    63 	TInt iError;

    64 	TBool iThisIsNegativeTest;

    65 	};

    66 

    67 

    68 /**

    69  * Convert WAV to AU.

    70  *

    71  * @class CTestMmfAclntDoConv

    72  *

    73  */

    74 class CTestMmfAclntDoConv : public CTestMmfAclntStep, public MMdaObjectStateChangeObserver

    75 	{

    76 public:

    77 	enum FormatSpec

    78 	{

    79 	MdaFormatSpec,

    80 	MmfFormatSpec

    81 	};

    82 

    83 

    84 

    85 	CTestMmfAclntDoConv(const TDesC& aTestName, const TDesC& aSectName, 

    86 		const TDesC& aKeyName, const TDesC& aSectName2, 

    87 		const TDesC& aKeyName2, 

    88 		TInt	aBits, FormatSpec aFormat);

    89 	

    90 	//aBits 0  = TMdaPcmWavCodec::E8BitPcm

    91 	//		1  = TMdaPcmWavCodec::E16BitPcm

    92 	//		-1  - UnsupportedCodec (negative test)

    93 	static CTestMmfAclntDoConv* NewL(const TDesC& aTestName, 

    94 		const TDesC& aSectName, const TDesC& aKeyName, 

    95 		const TDesC& aSectName2, const TDesC& aKeyName2, 

    96 		TInt aBits, FormatSpec aFormat);

    97 	virtual TVerdict DoTestStepL();

    98 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

    99 	// from MMdaObjectStateChangeObserver

   100 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

   101 

   102 protected:

   103 	TInt iError;

   104 	CBase* iObject;

   105 	TInt iPreviousState;

   106 	TInt iCurrentState;

   107 	TBuf<KNameBufSize> iSectName;

   108 	TBuf<KNameBufSize> iKeyName;

   109 	TBuf<KNameBufSize> iSectName2;

   110 	TBuf<KNameBufSize> iKeyName2;

   111 

   112 	FormatSpec iFormat;

   113 	TInt	iBits;

   114 	};

   115 

   116 

   117 /**

   118  * Closes an open file then opens a second file

   119  *

   120  * @class CTestMmfAclntConCloseOpen

   121  *

   122  */

   123 class CTestMmfAclntConCloseOpen: public CTestMmfAclntConConfig

   124 	{

   125 public:

   126 	CTestMmfAclntConCloseOpen(const TDesC& aTestName) ;

   127 	~CTestMmfAclntConCloseOpen(){} ;

   128 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   129 	static CTestMmfAclntConCloseOpen* NewL(const TDesC& aTestName);

   130 	};

   131 

   132 /**

   133  * Set convert window. Enquire window. Delete window

   134  *

   135  * @class CTestMmfAclntConWindow

   136  *

   137  */

   138 class CTestMmfAclntConWindow: public CTestMmfAclntConConfig

   139 	{

   140 public:

   141 	CTestMmfAclntConWindow(const TDesC& aTestName) ;

   142 	~CTestMmfAclntConWindow(){} ;

   143 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   144 	static CTestMmfAclntConWindow* NewL(const TDesC& aTestName);

   145 protected:

   146 	TVerdict CheckFileSize(const TDesC& aFilename, const TInt aExpectedSize);

   147 	};

   148 

   149 

   150 /**

   151  * Enquire duration

   152  *

   153  * @class CTestMmfAclntConDuration

   154  *

   155  */

   156 class CTestMmfAclntConDuration: public CTestMmfAclntConConfig

   157 	{

   158 public:

   159 	CTestMmfAclntConDuration(const TDesC& aTestName) ;

   160 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   161 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, 

   162 			TInt aCurrentState, TInt aErrorCode) ;

   163 	static CTestMmfAclntConDuration* NewL(const TDesC& aTestName);

   164 protected:

   165 	virtual void GetKeyName(TDes& aDes);

   166 	};

   167 

   168 /**

   169  * Set position and enquire position

   170  *

   171  * @class CTestMmfAclntConPosition

   172  *

   173  */

   174 class CTestMmfAclntConPosition: public CTestMmfAclntConConfig

   175 	{

   176 public:

   177 	CTestMmfAclntConPosition(const TDesC& aTestName, const TTimeIntervalMicroSeconds aPosition);

   178 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   179 	static CTestMmfAclntConPosition* NewL(const TDesC& aTestName, const	TTimeIntervalMicroSeconds aPosition);

   180 

   181 protected:

   182 	void GetKeyName(TDes& aDes);

   183 private:

   184 	TTimeIntervalMicroSeconds iPosition;

   185 	};

   186 

   187 

   188 /**

   189  * Set config destination clip

   190  *

   191  * @class CTestMmfAclntConQuery

   192  *

   193  */

   194 class CTestMmfAclntConQuery: public CTestMmfAclntConConfig

   195 	{

   196 public:

   197 	CTestMmfAclntConQuery(const TDesC& aTestName);

   198 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   199 	static CTestMmfAclntConQuery* NewL(const TDesC& aTestName);

   200 	TVerdict DoTestStepL();

   201 protected:

   202 	void GetKeyName(TDes& aDes);

   203 	};

   204 

   205 //

   206 // NEGATIVE TESTS

   207 //

   208 

   209 /** 

   210  * Conversion utility - Delete object before conversion operation has completed.

   211  *

   212  * @class CTestMmfAclntDelete

   213  *

   214  */

   215 class CTestMmfAclntDelete : public CTestMmfAclntStep, public MMdaObjectStateChangeObserver

   216 	{

   217 public:

   218 	CTestMmfAclntDelete() ;

   219 	virtual TVerdict DoTestStepL();

   220 	// MMdaObjectStateChangeObserver

   221 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

   222 

   223 private:

   224 	TInt iError;	

   225 	};

   226 

   227 

   228 /** 

   229  * Open new file while audio converter is converting. Open a new audio file.

   230  *

   231  * @class CTestMmfAclntOpenWhileConvert

   232  *

   233  */

   234 class CTestMmfAclntOpenWhileConvert : public CTestMmfAclntConConfig

   235 	{

   236 public:

   237 	CTestMmfAclntOpenWhileConvert(const TDesC& aTestName) ;

   238 	static CTestMmfAclntOpenWhileConvert* NewL(const TDesC& aTestName);

   239 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   240 	} ;

   241 /**

   242  * @class CTestMmfAclntConvertDestBitRate

   243  */

   244 

   245 class CTestMmfAclntConvertDestBitRate : public CTestMmfAclntConConfig

   246 	{

   247 public:

   248 	CTestMmfAclntConvertDestBitRate(const TDesC& aTestName, TBool aNegative) ;

   249         static	CTestMmfAclntConvertDestBitRate* NewL(const TDesC& aTestName, TBool aNegative) ;

   250 	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   251 

   252 protected:

   253 	void GetKeyName(TDes& aDes);

   254 	};

   255 

   256 

   257 /**

   258  * @class CTestMmfAclntConvertDestDataType

   259  */

   260 class CTestMmfAclntConvertDestDataType : public CTestMmfAclntConConfig

   261 	{

   262 public:

   263 	CTestMmfAclntConvertDestDataType(const TDesC& aTestName, TBool aNegative);

   264         static CTestMmfAclntConvertDestDataType* NewL(const TDesC& aTestName, TBool aNegative);

   265 	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   266 protected:

   267 	void GetKeyName(TDes& aDes);

   268 private:

   269 	TFourCC iDataType ;

   270 	} ;

   271 

   272 

   273 /**

   274  * @class CTestMmfAclntConvertDestFormat

   275  */

   276 class CTestMmfAclntConvertDestFormat : public CTestMmfAclntConConfig

   277 	{

   278 public:

   279 	CTestMmfAclntConvertDestFormat(const TDesC& aTestName, TBool aNegative);

   280 	static CTestMmfAclntConvertDestFormat* NewL(const TDesC& aTestName, TBool aNegative);

   281 	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   282 protected:

   283 	void GetKeyName(TDes& aDes);

   284 	};

   285 

   286 

   287 /**

   288  * @class CTestMmfAclntConvertDestSampleRate

   289  */

   290 class CTestMmfAclntConvertDestSampleRate : public CTestMmfAclntConConfig

   291 	{

   292 public:

   293 	CTestMmfAclntConvertDestSampleRate(const TDesC& aTestName, TBool aNegative);

   294 	static CTestMmfAclntConvertDestSampleRate* NewL(const TDesC& aTestName, TBool aNegative);

   295 	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   296 	TVerdict DoTestStepL() ;

   297 

   298 protected:

   299 	void GetKeyName(TDes& aDes);

   300 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState,	TInt aCurrentState,

   301 								TInt aErrorCode) ;

   302 	};

   303 

   304 /**

   305  * @class CTestMmfAclntConvertDestNumberOfChannels

   306  */

   307 class CTestMmfAclntConvertDestNumberOfChannels : public CTestMmfAclntConConfig

   308 	{

   309 public:

   310 	CTestMmfAclntConvertDestNumberOfChannels(const TDesC& aTestName, TBool aNegative);

   311 	static CTestMmfAclntConvertDestNumberOfChannels* NewL(const TDesC& aTestName, TBool aNegative);

   312 	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   313 protected:

   314 	void GetKeyName(TDes& aDes);

   315 	};

   316 

   317 /**

   318  * @class CTestMmfAclntConvertSourceInfo

   319  */

   320 class CTestMmfAclntConvertSourceInfo : public CTestMmfAclntConConfig

   321 	{

   322 public:

   323 	CTestMmfAclntConvertSourceInfo(const TDesC& aTestName, TBool aNegative);

   324 	static CTestMmfAclntConvertSourceInfo* NewL(const TDesC& aTestName, TBool aNegative);

   325 	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   326 protected:

   327 	void GetKeyName(TDes& aDes);

   328 	};

   329 /**

   330  * Audio convert croping.

   331  *

   332  * @class CTestMmfAclntConvertCrop

   333  *

   334  */

   335 class CTestMmfAclntConvertCrop : public CTestMmfAclntConConfig

   336 	{

   337 public:

   338 	CTestMmfAclntConvertCrop(const TDesC& aTestName, const TBool aCropToEnd, TBool aNegative) ;

   339 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   340 	static CTestMmfAclntConvertCrop* NewL(const TDesC& aTestName, const TBool aCropToEnd, TBool aNegative);

   341 	virtual TVerdict DoTestStepL() ;

   342 	virtual TVerdict DoTestStepPostambleL();

   343 	// from MMdaObjectStateChangeObserver

   344 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

   345 private:

   346 	TBool iCropToEnd;

   347 	TPtrC iToFilename;

   348 	TPtrC iToFilename2;

   349 	} ;

   350 

   351 

   352 /**

   353  * Set maximum length of file in bytes and convert

   354  *

   355  * @class CTestMmfAclntConvertLength

   356  *

   357  */

   358 class CTestMmfAclntConvertLength: public CTestMmfAclntConConfig

   359 	{

   360 public:

   361 	CTestMmfAclntConvertLength(const TDesC& aTestName, TBool aNegative) ;

   362 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConvertUtil);

   363 	static CTestMmfAclntConvertLength* NewL(const TDesC& aTestName, TBool aNegative);

   364 	};

   365 

   366 /**

   367  * Set repeats

   368  *

   369  * @class CTestMmfAclntConvertRepeat

   370  *

   371  */

   372 class CTestMmfAclntConvertRepeat : public CTestMmfAclntConConfig

   373 	{

   374 public:

   375 	CTestMmfAclntConvertRepeat(const TDesC& aTestName, TBool aNegative) ;

   376 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConvertUtil);

   377 	static CTestMmfAclntConvertRepeat* NewL(const TDesC& aTestName, TBool aNegative);

   378 	};

   379 

   380 /**

   381  * Audio convert Stoping.

   382  *

   383  * @class CTestMmfAclntConvertStop

   384  *

   385  */

   386 class CTestMmfAclntConvertStop : public CTestMmfAclntConConfig

   387 	{

   388 public:

   389 	CTestMmfAclntConvertStop(const TDesC& aTestName, TBool aNegative) ;

   390 	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

   391 	static CTestMmfAclntConvertStop* NewL(const TDesC& aTestName, TBool aNegative);

   392 	TVerdict DoTestStepL() ;

   393 	// from MMdaObjectStateChangeObserver

   394 	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

   395 	} ;

   396 

   397 /**

   398  * Open a descriptor and convert

   399  *

   400  * @class CTestMmfAclntConvertDes

   401  *

   402  */

   403 class CTestMmfAclntConvertDes : public CTestMmfAclntCodecTest, public MMdaObjectStateChangeObserver, public MMdaAudioPlayerCallback	

   404 	{

   405 public:

   406 	CTestMmfAclntConvertDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat = ENone, const TBool aCreateDes = EFalse) ;

   407 	virtual TVerdict DoTestStepL();

   408 	static CTestMmfAclntConvertDes* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat = ENone, const TBool aCreateDes = EFalse);

   409 	static CTestMmfAclntConvertDes* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat = ENone, const TBool aCreateDes = EFalse);

   410 	virtual TVerdict DoTestStepPreambleL();

   411 	virtual TVerdict DoTestStepPostambleL();

   412 	// from MMdaObjectStateChangeObserver

   413 	virtual void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

   414 	

   415 	// from MMdaAudioPlayerCallback

   416     virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration);

   417     virtual void MapcPlayComplete(TInt aError);

   418 

   419 private:

   420 	HBufC8* iAudio;

   421 	TInt iError;

   422 	TInt iSize;

   423 	TInt iFrameSize;

   424 	TInt iHeaderSize;

   425 	TBool iCreateDes;

   426 	TBuf<32> iSectName;					// Section name for retrieving filename

   427 	TBuf<32> iKeyName;					// Key name for retrieving filename

   428 	TUint iDataLengthSource;			// source data length - not including header

   429 	TUint iSamples;

   430 	TUint iChannels;

   431 	TUint iFileSizeSink;				// expected file size including header

   432 	TTimeIntervalMicroSeconds iDuration;

   433 

   434 	} ;

   435 

   436 /**

   437  * Set Urls

   438  *

   439  * @class CTestMmfAclntConvertUrl

   440  *

   441  */

   442 class CTestMmfAclntConvertUrl : public CTestMmfAclntConConfig

   443 	{

   444 public:

   445 	CTestMmfAclntConvertUrl(const TDesC& aTestName, TBool aNegative) ;

   446 	virtual TVerdict DoTestStepL();

   447 	static CTestMmfAclntConvertUrl* NewL(const TDesC& aTestName, TBool aNegative);

   448 	};

   449 

   450 #endif