1 // Copyright (c) 2002-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 //

    15 

    16 // EPOC includes

    17 #include <e32base.h>

    18 

    19 // Test system includes

    20 #include "TSU_MMF_ACOD.h"

    21 #include "TSU_MMF_ACODSuite.h"

    22 

    23 #include <f32file.h>

    24 #include <s32file.h>

    25 #include <mmf/plugin/mmfcodecimplementationuids.hrh>

    26 

    27 #ifdef __WINS__

    28 //wins directories

    29 _LIT(KSourceFilesDir, "c:\\mm\\mmf\\testfiles\\acod\\");

    30 _LIT(KComparisonFilesDir, "c:\\mm\\mmf\\ref\\acod\\");

    31 #else

    32 /*

    33 arm4 directories

    34 All source and comparison files need to be copied manually onto the flash card.

    35 This code assumes the flash card is represented by drive E: on the target board.

    36 If this is not the case, the KSourceFilesDir and KComparisonFilesDir strings 

    37 need to be changed accordingly.

    38 */

    39 _LIT(KSourceFilesDir, "e:\\");

    40 _LIT(KComparisonFilesDir, "e:\\");

    41 #endif

    42 

    43 //8KHz source files

    44 _LIT(KPCM16SourceFile,"PCM16Source.raw");

    45 _LIT(KPCM16BSourceFile,"PCM16BSource.raw");

    46 _LIT(KPCMU16SourceFile,"PCMU16Source.raw");

    47 _LIT(KPCMU16BSourceFile,"PCMU16BSource.raw");

    48 _LIT(KStereoPCM16SourceFile,"StereoPCM16Source.raw");

    49 _LIT(KPCM8SourceFile,"PCM8Source.raw");

    50 _LIT(KPCMU8SourceFile,"PCMU8Source.raw");

    51 _LIT(KAlawSourceFile,"AlawSource.raw");

    52 _LIT(KMulawSourceFile,"MulawSource.raw");

    53 _LIT(KAdpcmSourceFile,"AdpcmSource.raw");

    54 _LIT(KStereoAdpcmSourceFile,"StereoAdpcmSource.raw");

    55 _LIT(KGSM610SourceFile,"GSM610Source.raw");

    56 

    57 //comparison files

    58 _LIT(KAlawToPCM16ComparisonFile,"AlawToPCM16Comparison.raw");

    59 _LIT(KPCM16ToAlawComparisonFile,"PCM16ToAlawComparison.raw");

    60 _LIT(KPCM8ToPCM16ComparisonFile,"PCM8ToPCM16Comparison.raw");

    61 _LIT(KPCM16ToPCM8ComparisonFile,"PCM16ToPCM8Comparison.raw");

    62 _LIT(KPCM16ToPCM16BComparisonFile,"PCM16ToPCM16BComparison.raw");

    63 _LIT(KPCM16BToPCM16ComparisonFile,"PCM16BToPCM16Comparison.raw");

    64 _LIT(KPCMU16ToPCMU16BComparisonFile,"PCMU16ToPCMU16BComparison.raw");

    65 _LIT(KPCMU16BToPCMU16ComparisonFile,"PCMU16BToPCMU16Comparison.raw");

    66 _LIT(KPCM16ToPCMU16BComparisonFile,"PCM16ToPCMU16BComparison.raw");

    67 _LIT(KPCMU16BToPCM16ComparisonFile,"PCMU16BToPCM16Comparison.raw");

    68 _LIT(KPCM16ToPCMU16ComparisonFile,"PCM16ToPCMU16Comparison.raw");

    69 _LIT(KPCMU16ToPCM16ComparisonFile,"PCMU16ToPCM16Comparison.raw");

    70 _LIT(KPCM16ToPCMU8ComparisonFile,"PCM16ToPCMU8Comparison.raw");

    71 _LIT(KPCMU8ToPCM16ComparisonFile,"PCMU8ToPCM16Comparison.raw");

    72 _LIT(KAdpcmToPCM16ComparisonFile,"AdpcmToPCM16Comparison.raw");

    73 _LIT(KPCM16ToAdpcmComparisonFile,"PCM16ToAdpcmComparison.raw");

    74 _LIT(KMulawToPCM16ComparisonFile,"MulawToPCM16Comparison.raw");

    75 _LIT(KPCM16ToMulawComparisonFile,"PCM16ToMulawComparison.raw");

    76 _LIT(KStereoAdpcmToPCM16ComparisonFile,"StereoAdpcmToPCM16Comparison.raw");

    77 _LIT(KPCM16ToStereoAdpcmComparisonFile,"PCM16ToStereoAdpcmComparison.raw");

    78 _LIT(KGSM610ToPCM16ComparisonFile,"GSM610ToPCM16Comparison.raw");

    79 _LIT(KPCM16ToGSM610ComparisonFile,"PCM16ToGSM610Comparison.raw");

    80 

    81 _LIT(KPreferredSupplierSourceFile,"AAAASource.raw");

    82 _LIT(KPreferredSupplierComparisonFile,"AAAABBBBPrefSuppComparison.raw");

    83 _LIT(KPreferredSupplier,"Preferred Supplier Test Codec 1");

    84 

    85 

    86 const TUint32 KMMFFourCCCodeAAAA = 0x41414141; //"AAAA"

    87 const TUint32 KMMFFourCCCodeBBBB = 0x42424242; //"BBBB"

    88 

    89 CTestStep_MMF_ACOD::CTestStep_MMF_ACOD()

    90 	{

    91 	iExpectedLeaveErrorCode = KErrNone;

    92 	iSingleIteration = EFalse;

    93 	}

    94 

    95 CTestStep_MMF_ACOD::~CTestStep_MMF_ACOD()

    96 	{

    97 	}

    98 

    99 /** @xxxx

   100  * This function gets the correct comparison filename for the codec specified.

   101  * 

   102  * @param	"TInt aCodecUID" 

   103  *			Uid of codec.

   104  *			"TDes& aFilename" 

   105  *			Descriptor to contain the comparison filename string.

   106  */

   107 void CTestStep_MMF_ACOD::GetComparisonFilenameFromCodecUidL(TInt aCodecUID, TDes& aFilename)

   108 	{

   109 	switch(aCodecUID)

   110 		{

   111 		case KMmfUidCodecAlawToPCM16:

   112 			aFilename.Copy(KComparisonFilesDir);

   113 			aFilename.Append(KAlawToPCM16ComparisonFile);

   114 			break;

   115 		case KMmfUidCodecPCM16ToAlaw:

   116 			aFilename.Copy(KComparisonFilesDir);

   117 			aFilename.Append(KPCM16ToAlawComparisonFile);

   118 			break;

   119 		case KMmfUidCodecPCM8ToPCM16:

   120 			aFilename.Copy(KComparisonFilesDir);

   121 			aFilename.Append(KPCM8ToPCM16ComparisonFile);

   122 			break;

   123 		case KMmfUidCodecAudioS16ToPCMS8:

   124 			aFilename.Copy(KComparisonFilesDir);

   125 			aFilename.Append(KPCM16ToPCM8ComparisonFile);

   126 			break;

   127 		//case KMMFUidCodecPCM16SwapEndian:

   128 		case KMMFUidCodecPCM16toPCM16B:

   129 		case KMMFUidCodecPCM16BtoPCM16:

   130 		case KMMFUidCodecPCMU16toPCMU16B:

   131 		case KMMFUidCodecPCMU16BtoPCMU16:

   132 			//This file is used for all swap endian tests other than instantiation.

   133 			//There is no need to test ProcessL for every swap endian combination.

   134 			aFilename.Copy(KComparisonFilesDir);

   135 			aFilename.Append(KPCM16ToPCM16BComparisonFile);

   136 			break;

   137 		case KMmfUidCodecAudioS16ToPCMU16BE:

   138 			aFilename.Copy(KComparisonFilesDir);

   139 			aFilename.Append(KPCM16ToPCMU16BComparisonFile);

   140 			break;

   141 		case KMmfUidCodecAudioU16BEToPCMS16:

   142 			aFilename.Copy(KComparisonFilesDir);

   143 			aFilename.Append(KPCMU16BToPCM16ComparisonFile);

   144 			break;

   145 		case KMmfUidCodecAudioS16ToPCMU16:

   146 			aFilename.Copy(KComparisonFilesDir);

   147 			aFilename.Append(KPCM16ToPCMU16ComparisonFile);

   148 			break;

   149 		case KMmfUidCodecAudioU16ToPCMS16:

   150 			aFilename.Copy(KComparisonFilesDir);

   151 			aFilename.Append(KPCMU16ToPCM16ComparisonFile);

   152 			break;

   153 		case KMmfUidCodecAudioS16ToPCMU8:

   154 			aFilename.Copy(KComparisonFilesDir);

   155 			aFilename.Append(KPCM16ToPCMU8ComparisonFile);

   156 			break;

   157 		case KMmfUidCodecAudioU8ToPCMS16:

   158 			aFilename.Copy(KComparisonFilesDir);

   159 			aFilename.Append(KPCMU8ToPCM16ComparisonFile);

   160 			break;

   161 		case KMmfUidCodecIMAADPCMToPCM16:

   162 			aFilename.Copy(KComparisonFilesDir);

   163 			aFilename.Append(KAdpcmToPCM16ComparisonFile);

   164 			break;

   165 		case KMmfUidCodecPCM16ToIMAADPCM:

   166 			aFilename.Copy(KComparisonFilesDir);

   167 			aFilename.Append(KPCM16ToAdpcmComparisonFile);

   168 			break;

   169 		case KMmfUidCodecMulawToPCM16:

   170 			aFilename.Copy(KComparisonFilesDir);

   171 			aFilename.Append(KMulawToPCM16ComparisonFile);

   172 			break;

   173 		case KMmfUidCodecPCM16ToMulaw:

   174 			aFilename.Copy(KComparisonFilesDir);

   175 			aFilename.Append(KPCM16ToMulawComparisonFile);

   176 			break;

   177 		case KMmfUidCodecIMAADPCMToPCM16Stereo:

   178 			aFilename.Copy(KComparisonFilesDir);

   179 			aFilename.Append(KStereoAdpcmToPCM16ComparisonFile);

   180 			break;

   181 		case KMmfUidCodecPCM16ToIMAADPCMStereo:

   182 			aFilename.Copy(KComparisonFilesDir);

   183 			aFilename.Append(KPCM16ToStereoAdpcmComparisonFile);

   184 			break;

   185 		case KMmfUidCodecGSM610ToPCM16:

   186 			aFilename.Copy(KComparisonFilesDir);

   187 			aFilename.Append(KGSM610ToPCM16ComparisonFile);

   188 			break;

   189 		case KMmfUidCodecPCM16ToGSM610:

   190 			aFilename.Copy(KComparisonFilesDir);

   191 			aFilename.Append(KPCM16ToGSM610ComparisonFile);

   192 			break;

   193 		default:

   194 			User::Leave(KErrNotSupported);

   195 			break;

   196 		}

   197 	}

   198 

   199 /** @xxxx

   200  * This function gets the correct comparison filename for the fourCC codes specified.

   201  * 

   202  * @param	"const TFourCC& aSrcFourCC"

   203  *			Source fourCC code.

   204  *			"const TFourCC& aDstFourCC" 

   205  *			Destination fourCC code.

   206  *			"TDes& aFilename" 

   207  *			Descriptor to contain the comparison filename string.

   208  */

   209 void CTestStep_MMF_ACOD::GetComparisonFilenameFromFourCCL(const TFourCC& aSrcFourCC, const TFourCC& aDstFourCC, TDes& aFilename)

   210 	{

   211 	if (aSrcFourCC == KMMFFourCCCodePCM16)

   212 		{

   213 		if (aDstFourCC == KMMFFourCCCodeALAW)

   214 			{

   215 			aFilename.Copy(KComparisonFilesDir);

   216 			aFilename.Append(KPCM16ToAlawComparisonFile);

   217 			}

   218 		else if (aDstFourCC == KMMFFourCCCodePCM16B)

   219 			{

   220 			aFilename.Copy(KComparisonFilesDir);

   221 			aFilename.Append(KPCM16ToPCM16BComparisonFile);

   222 			}

   223 		else if (aDstFourCC == KMMFFourCCCodePCM8)

   224 			{

   225 			aFilename.Copy(KComparisonFilesDir);

   226 			aFilename.Append(KPCM16ToPCM8ComparisonFile);

   227 			}

   228 		else if (aDstFourCC == KMMFFourCCCodePCMU16B)

   229 			{

   230 			aFilename.Copy(KComparisonFilesDir);

   231 			aFilename.Append(KPCM16ToPCMU16BComparisonFile);

   232 			}

   233 		else if (aDstFourCC == KMMFFourCCCodePCMU16)

   234 			{

   235 			aFilename.Copy(KComparisonFilesDir);

   236 			aFilename.Append(KPCM16ToPCMU16ComparisonFile);

   237 			}

   238 		else if (aDstFourCC == KMMFFourCCCodePCMU8)

   239 			{

   240 			aFilename.Copy(KComparisonFilesDir);

   241 			aFilename.Append(KPCM16ToPCMU8ComparisonFile);

   242 			}

   243 		else if (aDstFourCC == KMMFFourCCCodeIMAD)

   244 			{

   245 			aFilename.Copy(KComparisonFilesDir);

   246 			aFilename.Append(KPCM16ToAdpcmComparisonFile);

   247 			}

   248 		else if (aDstFourCC == KMMFFourCCCodeMuLAW)

   249 			{

   250 			aFilename.Copy(KComparisonFilesDir);

   251 			aFilename.Append(KPCM16ToMulawComparisonFile);

   252 			}

   253 		else if (aDstFourCC == KMMFFourCCCodeIMAS)

   254 			{

   255 			aFilename.Copy(KComparisonFilesDir);

   256 			aFilename.Append(KPCM16ToStereoAdpcmComparisonFile);

   257 			}

   258 		else if (aDstFourCC == KMMFFourCCCodeGSM610)

   259 			{

   260 			aFilename.Copy(KComparisonFilesDir);

   261 			aFilename.Append(KPCM16ToGSM610ComparisonFile);

   262 			}

   263 		}

   264 	else if (aDstFourCC == KMMFFourCCCodePCM16)

   265 		{

   266 		if (aSrcFourCC == KMMFFourCCCodeALAW)

   267 			{

   268 			aFilename.Copy(KComparisonFilesDir);

   269 			aFilename.Append(KAlawToPCM16ComparisonFile);

   270 			}

   271 		if (aSrcFourCC == KMMFFourCCCodePCM8)

   272 			{

   273 			aFilename.Copy(KComparisonFilesDir);

   274 			aFilename.Append(KPCM8ToPCM16ComparisonFile);

   275 			}

   276 		if (aSrcFourCC == KMMFFourCCCodePCM16B)

   277 			{

   278 			aFilename.Copy(KComparisonFilesDir);

   279 			aFilename.Append(KPCM16BToPCM16ComparisonFile);		

   280 			}

   281 		if (aSrcFourCC == KMMFFourCCCodePCMU16B)

   282 			{

   283 			aFilename.Copy(KComparisonFilesDir);

   284 			aFilename.Append(KPCMU16BToPCM16ComparisonFile);

   285 			}

   286 		if (aSrcFourCC == KMMFFourCCCodePCMU16)

   287 			{

   288 			aFilename.Copy(KComparisonFilesDir);

   289 			aFilename.Append(KPCMU16ToPCM16ComparisonFile);

   290 			}

   291 		if (aSrcFourCC == KMMFFourCCCodePCMU8)

   292 			{

   293 			aFilename.Copy(KComparisonFilesDir);

   294 			aFilename.Append(KPCMU8ToPCM16ComparisonFile);

   295 			}

   296 		if (aSrcFourCC == KMMFFourCCCodeIMAD)

   297 			{

   298 			aFilename.Copy(KComparisonFilesDir);

   299 			aFilename.Append(KAdpcmToPCM16ComparisonFile);

   300 			}

   301 		if (aSrcFourCC == KMMFFourCCCodeMuLAW)

   302 			{

   303 			aFilename.Copy(KComparisonFilesDir);

   304 			aFilename.Append(KMulawToPCM16ComparisonFile);

   305 			}

   306 		if (aSrcFourCC == KMMFFourCCCodeIMAS)

   307 			{

   308 			aFilename.Copy(KComparisonFilesDir);

   309 			aFilename.Append(KStereoAdpcmToPCM16ComparisonFile);

   310 			}

   311 		if (aSrcFourCC == KMMFFourCCCodeGSM610)

   312 			{

   313 			aFilename.Copy(KComparisonFilesDir);

   314 			aFilename.Append(KGSM610ToPCM16ComparisonFile);

   315 			}	

   316 		}

   317 	else if	((aSrcFourCC == KMMFFourCCCodePCMU16) && 

   318 			(aDstFourCC == KMMFFourCCCodePCMU16B))

   319 		{

   320 		aFilename.Copy(KComparisonFilesDir);

   321 		aFilename.Append(KPCMU16ToPCMU16BComparisonFile);

   322 		}

   323 	else if	((aSrcFourCC == KMMFFourCCCodePCMU16B) && 

   324 			(aDstFourCC == KMMFFourCCCodePCMU16))	

   325 		{

   326 		aFilename.Copy(KComparisonFilesDir);

   327 		aFilename.Append(KPCMU16BToPCMU16ComparisonFile);

   328 		}

   329 	else

   330 		User::Leave(KErrNotSupported);

   331 	}

   332 

   333 /** @xxxx

   334  * This function gets the correct source filename for the codec specified.

   335  * 

   336  * @param	"TInt aCodecUID" 

   337  *			Uid of codec.

   338  *			"TDes& aFilename" 

   339  *			Descriptor to contain the source filename string.

   340  */

   341 void CTestStep_MMF_ACOD::GetSourceFilenameFromCodecUidL(TInt aCodecUID, TDes& aFilename)

   342 	{

   343 	switch(aCodecUID)

   344 		{

   345 		case KMmfUidCodecAlawToPCM16:

   346 			aFilename.Copy(KSourceFilesDir);

   347 			aFilename.Append(KAlawSourceFile);

   348 			break;

   349 		case KMmfUidCodecPCM16ToAlaw:

   350 			aFilename.Copy(KSourceFilesDir);

   351 			aFilename.Append(KPCM16SourceFile);

   352 			break;

   353 		case KMmfUidCodecPCM8ToPCM16:

   354 			aFilename.Copy(KSourceFilesDir);

   355 			aFilename.Append(KPCM8SourceFile);

   356 			break;

   357 		case KMmfUidCodecAudioS16ToPCMS8:

   358 			aFilename.Copy(KSourceFilesDir);

   359 			aFilename.Append(KPCM16SourceFile);

   360 			break;

   361 		//case KMMFUidCodecPCM16SwapEndian:

   362 		case KMMFUidCodecPCM16toPCM16B:

   363 		case KMMFUidCodecPCM16BtoPCM16:

   364 		case KMMFUidCodecPCMU16toPCMU16B:

   365 		case KMMFUidCodecPCMU16BtoPCMU16:

   366 			//this file is used for all swap endian tests other than instantiation.

   367 			//there is no need to test ProcessL for every swap endian combination.

   368 			aFilename.Copy(KSourceFilesDir);

   369 			aFilename.Append(KPCM16SourceFile);

   370 			break;

   371 		case KMmfUidCodecAudioS16ToPCMU16BE:

   372 			aFilename.Copy(KSourceFilesDir);

   373 			aFilename.Append(KPCM16SourceFile);

   374 			break;

   375 		case KMmfUidCodecAudioU16BEToPCMS16:

   376 			aFilename.Copy(KSourceFilesDir);

   377 			aFilename.Append(KPCMU16BSourceFile);

   378 			break;

   379 		case KMmfUidCodecAudioS16ToPCMU16:

   380 			aFilename.Copy(KSourceFilesDir);

   381 			aFilename.Append(KPCM16SourceFile);

   382 			break;

   383 		case KMmfUidCodecAudioU16ToPCMS16:

   384 			aFilename.Copy(KSourceFilesDir);

   385 			aFilename.Append(KPCMU16SourceFile);

   386 			break;

   387 		case KMmfUidCodecAudioS16ToPCMU8:

   388 			aFilename.Copy(KSourceFilesDir);

   389 			aFilename.Append(KPCM16SourceFile);

   390 			break;

   391 		case KMmfUidCodecAudioU8ToPCMS16:

   392 			aFilename.Copy(KSourceFilesDir);

   393 			aFilename.Append(KPCMU8SourceFile);

   394 			break;

   395 		case KMmfUidCodecIMAADPCMToPCM16:

   396 			aFilename.Copy(KSourceFilesDir);

   397 			aFilename.Append(KAdpcmSourceFile);

   398 			break;

   399 		case KMmfUidCodecPCM16ToIMAADPCM:

   400 			aFilename.Copy(KSourceFilesDir);

   401 			aFilename.Append(KPCM16SourceFile);

   402 			break;

   403 		case KMmfUidCodecMulawToPCM16:

   404 			aFilename.Copy(KSourceFilesDir);

   405 			aFilename.Append(KMulawSourceFile);

   406 			break;

   407 		case KMmfUidCodecPCM16ToMulaw:

   408 			aFilename.Copy(KSourceFilesDir);

   409 			aFilename.Append(KPCM16SourceFile);

   410 			break;

   411 		case KMmfUidCodecIMAADPCMToPCM16Stereo:

   412 			aFilename.Copy(KSourceFilesDir);

   413 			aFilename.Append(KStereoAdpcmSourceFile);

   414 			break;

   415 		case KMmfUidCodecPCM16ToIMAADPCMStereo:

   416 			aFilename.Copy(KSourceFilesDir);

   417 			aFilename.Append(KStereoPCM16SourceFile);

   418 			break;

   419 		case KMmfUidCodecGSM610ToPCM16:

   420 			aFilename.Copy(KSourceFilesDir);

   421 			aFilename.Append(KGSM610SourceFile);

   422 			break;

   423 		case KMmfUidCodecPCM16ToGSM610:

   424 			aFilename.Copy(KSourceFilesDir);

   425 			aFilename.Append(KPCM16SourceFile);

   426 			break;

   427 		default:

   428 			User::Leave(KErrNotSupported);

   429 			break;

   430 		}

   431 	}

   432 

   433 /** @xxxx

   434  * This function gets the correct source filename for the fourCC codes specified.

   435  * 

   436  * @param	"const TFourCC& aSrcFourCC"

   437  *			Source fourCC code.

   438  *			"const TFourCC& aDstFourCC" 

   439  *			Destination fourCC code.

   440  *			"TDes& aFilename"

   441  *			Descriptor to contain the source filename string.

   442  */

   443 void CTestStep_MMF_ACOD::GetSourceFilenameFromFourCCL(const TFourCC& aSrcFourCC, const TFourCC& aDstFourCC, TDes& aFilename)

   444 	{

   445 	aFilename.Copy(KSourceFilesDir);

   446 	if (aSrcFourCC == KMMFFourCCCodePCM16)

   447 		{

   448 		if (aDstFourCC == KMMFFourCCCodeIMAS)

   449 			aFilename.Append(KStereoPCM16SourceFile);

   450 		else

   451 			aFilename.Append(KPCM16SourceFile);

   452 		}

   453 	else if (aSrcFourCC == KMMFFourCCCodeALAW)

   454 			aFilename.Append(KAlawSourceFile);

   455 	else if (aSrcFourCC == KMMFFourCCCodePCM8)

   456 			aFilename.Append(KPCM8SourceFile);

   457 	else if (aSrcFourCC == KMMFFourCCCodePCM16B)

   458 			aFilename.Append(KPCM16BSourceFile);

   459 	else if (aSrcFourCC == KMMFFourCCCodePCMU16B)

   460 			aFilename.Append(KPCMU16BSourceFile);

   461 	else if (aSrcFourCC == KMMFFourCCCodePCMU16)

   462 			aFilename.Append(KPCMU16SourceFile);

   463 	else if (aSrcFourCC == KMMFFourCCCodePCMU8)

   464 			aFilename.Append(KPCMU8SourceFile);

   465 	else if (aSrcFourCC == KMMFFourCCCodeIMAD)

   466 			aFilename.Append(KAdpcmSourceFile);

   467 	else if (aSrcFourCC == KMMFFourCCCodeMuLAW)

   468 			aFilename.Append(KMulawSourceFile);

   469 	else if (aSrcFourCC == KMMFFourCCCodeIMAS)

   470 			aFilename.Append(KStereoAdpcmSourceFile);

   471 	else if (aSrcFourCC == KMMFFourCCCodeGSM610)

   472 			aFilename.Append(KGSM610SourceFile);		

   473 	else

   474 		User::Leave(KErrNotSupported);

   475 	}

   476 

   477 /** @xxxx

   478  * This function checks the data in iOutputDataBuffer against data in a comparison 

   479  * file.

   480  * 

   481  * @param	"const TDesC& aFilename" 

   482  *			Full path of the comparison file to compare against.

   483  *			"TUint aPosition"

   484  *			File position from which to read the comparison data.

   485  * @return	"TBool"

   486  *			ETrue if the output is the same as the comparison data

   487  *			EFalse if the output is different to the comparison data

   488 */

   489 TBool CTestStep_MMF_ACOD::CheckOutputAgainstComparisonFileL(const TDesC& aFilename, TUint aPosition)

   490 	{

   491 	RFs fs;

   492 	User::LeaveIfError(fs.Connect());

   493 	CleanupClosePushL(fs);

   494 

   495 	RFile file;

   496 	User::LeaveIfError(file.Open(fs, aFilename, EFileRead|EFileShareAny));

   497 	CleanupClosePushL(file);

   498 

   499 	RFileReadStream fileReadStream(file, aPosition);

   500 	CleanupClosePushL(fileReadStream);

   501 

   502 	//read data from comparison file into descriptor

   503 	HBufC8* compBuffer = HBufC8::NewL(iOutputDataBuffer->Length());

   504 	CleanupStack::PushL(compBuffer);

   505 	TPtr8 compBufferPtr = compBuffer->Des();

   506 	TRAPD(err, fileReadStream.ReadL(compBufferPtr, iOutputDataBuffer->Length()));

   507 	if ((err != KErrNone) && (err != KErrEof)) User::LeaveIfError(err); //EOF not an error ?

   508 

   509 	//compare destination buffer with comparison descriptor

   510 	TInt result = iOutputDataBuffer->Compare(*compBuffer);

   511 

   512 	if (result != 0)

   513 		INFO_PRINTF3(_L(">> iOutputDataBuffer size is %d, Comparison buffer size is %d"), iOutputDataBuffer->Length(), compBuffer->Length());

   514 

   515 	CleanupStack::PopAndDestroy(4); //compBuffer, fileReadStream, file, fs

   516 

   517 	if (result == 0)

   518 		return ETrue;

   519 	else 	

   520 		return EFalse;

   521 	}

   522 

   523 /** @xxxx

   524  * This function checks the number of source bytes processed against 

   525  * iExpectedSrcBytesProcessed.

   526  * 

   527  * @param	"TUint aCount" 

   528  *			Index in the iExpectedSrcBytesProcessed array to check the value against.

   529  * @return	"TBool"

   530  *			ETrue if the source bytes processed is as expected.

   531  *			EFalse if the source bytes processed is not as expected.

   532  */

   533 TBool CTestStep_MMF_ACOD::CheckSrcBytesProcessedL(TUint aCount)

   534 	{

   535 	if (iCodecProcessResult.iSrcBytesProcessed == iExpectedSrcBytesProcessed[aCount])

   536 		return ETrue;

   537 	else if (STATIC_CAST(TUint, iFileDataLeft) < iExpectedSrcBytesProcessed[aCount])

   538 		{

   539 		INFO_PRINTF4(_L(">> TCodecProcessResult::iSrcBytesProcessed is %d, Not enough source data available in file. iFileDataLeft for LOOP %d is %d"), iCodecProcessResult.iSrcBytesProcessed, aCount, iFileDataLeft);

   540 		if (iCodecProcessResult.iSrcBytesProcessed == STATIC_CAST(TUint, iFileDataLeft))

   541 			return ETrue;

   542 		else 

   543 			return EFalse;

   544 		}

   545 	else 

   546 		{

   547 		INFO_PRINTF4(_L(">> TCodecProcessResult::iSrcBytesProcessed is %d, iExpectedSrcBytesProcessed for LOOP %d is %d"), iCodecProcessResult.iSrcBytesProcessed, aCount, iExpectedSrcBytesProcessed[aCount]);

   548 		return EFalse;

   549 		}

   550 	}

   551 

   552 /** @xxxx

   553  * This function checks the number of destination bytes added against 

   554  * iExpectedDstBytesAdded.

   555  * 

   556  * @param	"TUint aCount" 

   557  *			Index of the iExpectedDstBytesAdded array to check the value against.

   558  * @return	"TBool"

   559  *			ETrue if the dest bytes added is as expected.

   560  *			EFalse if the dest bytes added is not as expected.

   561  */

   562 TBool CTestStep_MMF_ACOD::CheckDstBytesAddedL(TUint aCount)

   563 	{

   564 	if (iCodecProcessResult.iDstBytesAdded == iExpectedDstBytesAdded[aCount])

   565 		return ETrue;

   566 	else if (STATIC_CAST(TUint, iFileDataLeft) < iExpectedSrcBytesProcessed[aCount])

   567 		{

   568 		INFO_PRINTF4(_L(">> TCodecProcessResult::iDstBytesAdded is %d, Not enough source data available in file. iFileDataLeft for LOOP %d is %d"), iCodecProcessResult.iDstBytesAdded, aCount, iFileDataLeft);

   569 		return ETrue;

   570 		}

   571 	else 

   572 		{

   573 		INFO_PRINTF4(_L(">> TCodecProcessResult::iDstBytesAdded is %d, iExpectedDstBytesAdded for LOOP %d is %d"), iCodecProcessResult.iDstBytesAdded, aCount, iExpectedDstBytesAdded[aCount]);

   574 		return EFalse;

   575 		}

   576 	}

   577 

   578 /** @xxxx

   579  * This function checks the length of iOutputDataBuffer against iTotalDstBytesAdded.

   580  * 

   581  * @return	"TBool"

   582  *			ETrue if the values are the same.

   583  *			EFalse if the values are different.

   584  */

   585 TBool CTestStep_MMF_ACOD::CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL()

   586 	{

   587 	if (iOutputDataBuffer->Length() == STATIC_CAST(TInt, iTotalDstBytesAdded))

   588 		return ETrue;

   589 	else 

   590 		{

   591 		INFO_PRINTF3(_L(">> Output Data Buffer Length is %d, iTotalDstBytesAdded is %d"), iOutputDataBuffer->Length(), iTotalDstBytesAdded);

   592 		return EFalse;

   593 		}

   594 	}

   595 

   596 /** @xxxx

   597  * Checks the current return value against iExpectedReturnValue.

   598  * 

   599  * @param	"TUint aCount" 

   600  *			Index of the iExpectedReturnValue array to check the value against.

   601  * @return	"TBool"

   602  *			ETrue if the return value is as expected.

   603  *			EFalse if the return value is not as expected.

   604  */

   605 TBool CTestStep_MMF_ACOD::CheckReturnValueL(TUint aCount)

   606 	{

   607 	if (aCount >= 5)

   608 		User::Leave(KErrArgument);

   609 

   610 	if (iCodecProcessResult.iStatus == iExpectedReturnValue[aCount].iStatus)

   611 		{

   612 		return ETrue;

   613 		}

   614 	else

   615 		{

   616 		INFO_PRINTF4(_L(">> TCodecProcessResult::iStatus is %d, iExpectedReturnValue for LOOP %d is %d"), iCodecProcessResult.iStatus, aCount, iExpectedReturnValue[aCount].iStatus);

   617 		return EFalse;

   618 		}	

   619 	}

   620 

   621 /** @xxxx

   622  * This function fills the source buffer with data from the file specified.

   623  * 

   624  * @param	"CMMFBuffer* aSrcBuffer"

   625  *			Buffer to contain the data read from the source file.

   626  *			"const TDesC& aFileName"

   627  *			Name of source file to use.

   628  *			"TUint aPosition" 

   629  *			Position in the file from which to read the data.

   630  */

   631 void CTestStep_MMF_ACOD::FillSourceBufferFromSourceFileL(CMMFBuffer* aSrcBuffer, const TDesC& aFilename, TUint aPosition)

   632 	{

   633 	RFs fs;

   634 	User::LeaveIfError(fs.Connect());

   635 	CleanupClosePushL(fs);

   636 

   637 	RFile file;

   638 	User::LeaveIfError(file.Open(fs, aFilename, EFileRead|EFileShareAny));

   639 	CleanupClosePushL(file);

   640 

   641 	iFileDataLeft = 0;

   642 	file.Size(iFileDataLeft);

   643 	if (STATIC_CAST(TInt, aPosition) < iFileDataLeft)

   644 		iFileDataLeft -= aPosition;

   645 	else User::Leave(KErrEof);

   646 

   647 	RFileReadStream fileReadStream(file, aPosition);

   648 	CleanupClosePushL(fileReadStream);

   649 

   650 	TInt srcBufferLength = STATIC_CAST(CMMFDataBuffer*, aSrcBuffer)->Data().MaxLength();

   651 

   652 	//read data from source file into source buffer

   653 	if(iFileDataLeft < srcBufferLength)

   654 		fileReadStream.ReadL(STATIC_CAST(CMMFDataBuffer*, aSrcBuffer)->Data(), iFileDataLeft);

   655 	else

   656 		fileReadStream.ReadL(STATIC_CAST(CMMFDataBuffer*, aSrcBuffer)->Data());

   657 	

   658 	CleanupStack::PopAndDestroy(3);  //filereadstream, file, fs

   659 	}

   660 

   661 /** @xxxx

   662  * This function tests the functionality of ProcessL for the codec specified.

   663  * 

   664  * @param	"TUid aCodecUID" 

   665  *			Uid of the codec under test.

   666  *			"TUint aSrcBufferSize" 

   667  *			Size of source buffer to test the codec with.

   668  *			"TUint aDstBufferSize" 

   669  *			Size of destination buffer to test the codec with.

   670  *			"TUint aSrcBufferLength" 

   671  *			Length of source buffer to test the codec with if less than the maxLength. 

   672  *			aSrcBufferLength defaults to zero. It is not used unless a value is 

   673  *			specified. A value should only be specified in cases where the buffer 

   674  *			length is less than the maxlength.

   675  * @return	"TBool"

   676  *			ETrue if the test passes.

   677  *			EFalse if the test fails.

   678  */

   679 TBool CTestStep_MMF_ACOD::TestProcessL(TUid aCodecUID, TUint aSrcBufferSize, TUint aDstBufferSize, TUint aSrcBufferLength)

   680 	{

   681 	//create buffers

   682 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(aSrcBufferSize);

   683 	CleanupStack::PushL(srcBuffer);

   684 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(aDstBufferSize);

   685 	CleanupStack::PushL(dstBuffer);

   686 

   687 	//Fill source buffer with data

   688 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

   689 	TPtr ptrSrcFilename = srcFilename->Des();

   690 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

   691 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

   692 

   693 	//if source buffer has different length to max length, crop data

   694 	if (aSrcBufferLength > 0)

   695 		{

   696 		srcBuffer->Data().SetLength(aSrcBufferLength);

   697 		}

   698 

   699 	//instantiate codec

   700 	CMMFCodec* codec = CMMFCodec::NewL(aCodecUID);

   701 	CleanupStack::PushL(codec);

   702 

   703 	TBool testOK = ETrue;

   704 	TRAPD(err, iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer));

   705 	if (err)

   706 		{

   707 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessL Leave occurred in ProcessL, error code %d"), err);

   708 		testOK = EFalse;

   709 		}

   710 	else

   711 		{

   712 		//copy data to iOutputDataBuffer

   713 		iOutputDataBuffer = HBufC8::NewL(dstBuffer->Data().Length());

   714 		TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

   715 		outputDataBufferPtr.Append(dstBuffer->Data());

   716 

   717 		iTotalDstBytesAdded = iCodecProcessResult.iDstBytesAdded;

   718 		iTotalSrcBytesProcessed = iCodecProcessResult.iSrcBytesProcessed;

   719 

   720 		//investigate results

   721 		HBufC* filename = HBufC::NewLC(KMaxPath);

   722 		TPtr ptrFilename = filename->Des();

   723 		GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

   724 

   725 		if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

   726 			{

   727 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckOutputAgainstComparisonFileL returned EFalse"));

   728 			testOK = EFalse;

   729 			}

   730 		if (!CheckDstBytesAddedL(0))

   731 			{

   732 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckDstBytesAddedL returned EFalse"));

   733 			testOK = EFalse;

   734 			}

   735 		if (!CheckSrcBytesProcessedL(0))

   736 			{

   737 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckSrcBytesProcessedL returned EFalse"));

   738 			testOK = EFalse;

   739 			}

   740 		if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   741 			{

   742 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"));

   743 			testOK = EFalse;

   744 			}

   745 		if (!CheckReturnValueL(0))

   746 			{

   747 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckReturnValue returned EFalse"));

   748 			testOK = EFalse;

   749 			}

   750 

   751 		//clean up memory

   752 		CleanupStack::PopAndDestroy(); //filename

   753 		delete iOutputDataBuffer;

   754 		iOutputDataBuffer = NULL;

   755 		}

   756 

   757 	CleanupStack::PopAndDestroy(4); //codec, srcFilename, dstBuffer, srcBuffer

   758 

   759 	if(!testOK)

   760 		return EFalse;

   761 	else

   762 		return ETrue;

   763 	}

   764 

   765 

   766 /** @xxxx

   767  * This function tests the functionality of ProcessL for the codec specified. 

   768  * It mimics the datapath by calling ProcessL five times in a loop, checking the 

   769  * return value each time and passing in new buffers accordlingly.

   770  *

   771  * @param	"TUid aCodecUID"

   772  *			Uid of the codec under test.

   773  *			"TUint aSrcBufferSize" 

   774  *			Size of source buffers to test the codec with.

   775  *			"TUint aDstBufferSize"

   776  *			Size of destination buffers to test the codec with.

   777  *			"TUint aSrcBufferLength" 

   778  *			Length of source buffer to test the codec with if less than the maxLength. 

   779  *			aSrcBufferLength defaults to zero and is not used unless a value is 

   780  *			specified.A value should only be specified if the buffer length is less

   781  *			than the maxlength.

   782  *	 		"TBool aCheckExpectedBytesProcessed" 

   783  *			Boolean value to determine whether to check the srcBytesProcessed and 

   784  *			dstBytesAdded against their expected values. This defaults to true, 

   785  *			but allows for the tests to be bypassed for non-linear codecs where the 

   786  *			expected values are difficult to determine.

   787  * @return	"TBool"

   788  *			ETrue if the test passes.

   789  *			EFalse if the test fails.

   790  */

   791 TBool CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL(TUid aCodecUID, TUint aSrcBufferSize, TUint aDstBufferSize, TUint aSrcBufferLength, TBool aCheckExpectedBytesProcessed)

   792 	{

   793 	//create buffers

   794 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(aSrcBufferSize);

   795 	CleanupStack::PushL(srcBuffer);

   796 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(aDstBufferSize);

   797 	CleanupStack::PushL(dstBuffer);

   798 

   799 	//read first buffer of data

   800 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

   801 	TPtr ptrSrcFilename = srcFilename->Des();

   802 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

   803 	TRAPD(srcFileError, FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0));

   804 	TBool endOfFile = EFalse;

   805 	if (srcFileError == KErrEof)

   806 		endOfFile = ETrue;

   807 	else if (srcFileError)

   808 		User::Leave(srcFileError);

   809 

   810 

   811 	//if source buffer has different length to max length, crop data

   812 	if (aSrcBufferLength > 0)

   813 		{

   814 		srcBuffer->Data().SetLength(aSrcBufferLength);

   815 		}

   816 

   817 	//instantiate codec

   818 	CMMFCodec* codec = CMMFCodec::NewL(aCodecUID);

   819 	CleanupStack::PushL(codec);

   820 

   821 	TBool testOK = ETrue;

   822 	TRAPD(err, iOutputDataBuffer = HBufC8::NewL(aDstBufferSize*5));

   823 	User::LeaveIfError(err);

   824 	TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

   825 

   826 

   827 	TUint maxIters = 0;

   828 	if(iSingleIteration)

   829 		{

   830 		maxIters = 1;

   831 		}

   832 	else

   833 		{

   834 		maxIters = 5;

   835 		}

   836 

   837 	for (TUint i=0; i</*5*/maxIters; i++)

   838 		{

   839 		TRAPD(err, iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer));

   840 		if (err)

   841 			{

   842 			if (err == iExpectedLeaveErrorCode)

   843 				break;

   844 			else

   845 				{

   846 				ERR_PRINTF3(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d Leave occurred in ProcessL, error code %d"), i, err);

   847 				testOK = EFalse;

   848 				break;

   849 				}

   850 			}

   851 		else if (iExpectedLeaveErrorCode)

   852 				{

   853 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d A leave was expected in ProcessL, but this didn't occur"), i);

   854 				testOK = EFalse;

   855 				break;

   856 				}

   857 

   858 		iTotalDstBytesAdded += iCodecProcessResult.iDstBytesAdded;

   859 		iTotalSrcBytesProcessed += iCodecProcessResult.iSrcBytesProcessed;

   860 

   861 		if (i<4) 

   862 			{

   863 			switch (iCodecProcessResult.iStatus)

   864 				{

   865 				case TCodecProcessResult::EProcessComplete:

   866 					{

   867 					outputDataBufferPtr.Append(dstBuffer->Data());

   868 					dstBuffer->SetPosition(0);

   869 					if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   870 						{

   871 						ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"), i);

   872 						testOK = EFalse;

   873 						}

   874 					srcBuffer->SetPosition(0);

   875 					srcBuffer->NextFrame();

   876 

   877 					if (!endOfFile)

   878 						{

   879 						TRAP(srcFileError, FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, iTotalSrcBytesProcessed));

   880 						if (srcFileError == KErrEof)

   881 							endOfFile = ETrue;

   882 						else if (srcFileError)

   883 							User::Leave(srcFileError);

   884 						}					

   885 					if (aSrcBufferLength > 0)

   886 						srcBuffer->Data().SetLength(aSrcBufferLength);

   887 					break;

   888 					}

   889 				case TCodecProcessResult::EProcessIncomplete:

   890 					{

   891 					outputDataBufferPtr.Append(dstBuffer->Data());

   892 					dstBuffer->SetPosition(0);

   893 					if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   894 						{

   895 						ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"), i);

   896 						testOK = EFalse;

   897 						}

   898 					srcBuffer->SetPosition(iCodecProcessResult.iSrcBytesProcessed + srcBuffer->Position());

   899 					break;

   900 					}

   901 				case TCodecProcessResult::EDstNotFilled:

   902 					{

   903 					dstBuffer->SetPosition(iCodecProcessResult.iDstBytesAdded + dstBuffer->Position());

   904 

   905 					if (!endOfFile)

   906 						{

   907 						TRAP(srcFileError, FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, iTotalSrcBytesProcessed));

   908 						if (srcFileError == KErrEof)

   909 							endOfFile = ETrue;

   910 						else if (srcFileError)

   911 							User::Leave(srcFileError);

   912 						}	

   913 					if (aSrcBufferLength > 0)

   914 						srcBuffer->Data().SetLength(aSrcBufferLength);

   915 					break;

   916 					}	

   917 				default:

   918 					User::Leave(KErrCorrupt); //should never get here

   919 				}

   920 			}

   921 		else //last time

   922 			{

   923 			outputDataBufferPtr.Append(dstBuffer->Data());

   924 			if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   925 				{

   926 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"), i);

   927 				testOK = EFalse;

   928 				}

   929 			}

   930 

   931 		if (!CheckReturnValueL(i))

   932 			{

   933 			ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckReturnValue returned EFalse"), i);

   934 			testOK = EFalse;

   935 			}

   936 		if (aCheckExpectedBytesProcessed)

   937 			{

   938 			if (!CheckDstBytesAddedL(i))

   939 				{

   940 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckDstBytesAddedL returned EFalse"), i);

   941 				testOK = EFalse;

   942 				}

   943 			if (!CheckSrcBytesProcessedL(i))

   944 				{

   945 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckSrcBytesProcessedL returned EFalse"), i);

   946 				testOK = EFalse;

   947 				}

   948 			}

   949 

   950 		if (endOfFile)

   951 			break;

   952 		}

   953 

   954 	if (testOK)

   955 		{

   956 		HBufC* filename = HBufC::NewLC(KMaxPath);

   957 		TPtr ptrFilename = filename->Des();

   958 		GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

   959 

   960 		if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

   961 			{

   962 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL CheckOutputAgainstComparisonFileL returned EFalse"));

   963 			testOK = EFalse;

   964 			}

   965 

   966 		CleanupStack::PopAndDestroy(); //filename

   967 		}

   968 

   969 	//clean up memory

   970 	delete iOutputDataBuffer;

   971 	iOutputDataBuffer = NULL;

   972 	CleanupStack::PopAndDestroy(4); //codec, srcFilename, dstBuffer, srcBuffer

   973 

   974 	if(!testOK)

   975 		return EFalse;

   976 	else

   977 		return ETrue;

   978 	}

   979 

   980 /** @xxxx

   981  * This function tests how the codec handles a reposition. This test is only really 

   982  * relevant to codecs that store data between calls to ProcessL. When a reposition 

   983  * occurs the stored data should be flushed. 

   984  * 

   985  * ProcessL is called 3 times: 

   986  * After the first call the frame number is increased by one; 

   987  * After the second call the output data is checked to ensure that extra data HAS been

   988  *	written to the output buffer; The frame number is set to 5 to mimic a reposition. 

   989  * After the third call the output data is checked to ensure that extra data HAS NOT 

   990  *	been written to the output buffer.

   991  *

   992  * Note: It is important to use buffer sizes that will force the codec to store extra 

   993  * data and return EProcessComplete or EDstNotFilled each time around the loop.

   994  *

   995  * @param	"TUid aCodecUID" 

   996  *			Uid of the codec under test.

   997  *			"TUint aSrcBufferSize"

   998  *			Size of source buffer to test the codec with.

   999  *			"TUint aDstBufferSize"

  1000  *			Size of destination buffer to test the codec with.

  1001  * @return	"TBool"

  1002  *			ETrue if the test passes.

  1003  *			EFalse if the test fails.

  1004  */

  1005 TBool CTestStep_MMF_ACOD::TestRepositionL(TUid aCodecUID, TUint aSrcBufferSize, TUint aDstBufferSize)

  1006 	{

  1007 	//create buffers

  1008 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(aSrcBufferSize);

  1009 	CleanupStack::PushL(srcBuffer);

  1010 

  1011 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(aDstBufferSize);

  1012 	CleanupStack::PushL(dstBuffer);

  1013 

  1014 	//read first buffer of data

  1015 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1016 	TPtr ptrSrcFilename = srcFilename->Des();

  1017 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

  1018 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1019 

  1020 	//instantiate codec

  1021 	CMMFCodec* codec = NULL;

  1022 	TRAPD(err, codec = CMMFCodec::NewL(aCodecUID));

  1023 	if (err)

  1024 		{

  1025 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestRepositionL Leave occurred in NewL, error code %d"), err);

  1026 		return EFalse;

  1027 		}

  1028 	else 

  1029 		{

  1030 		CleanupStack::PushL(codec);

  1031 		}

  1032 

  1033 	TBool testOK = ETrue;

  1034 	iOutputDataBuffer = HBufC8::NewL(aDstBufferSize);

  1035 	TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

  1036 

  1037 	HBufC* filename = HBufC::NewLC(KMaxPath);

  1038 	TPtr ptrFilename = filename->Des();

  1039 	GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

  1040 

  1041 	for (TUint i=0; i<3; i++)

  1042 		{

  1043 		iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer);

  1044 

  1045 		if ((iCodecProcessResult.iStatus == TCodecProcessResult::EProcessComplete) ||

  1046 			(iCodecProcessResult.iStatus == TCodecProcessResult::EDstNotFilled))

  1047 			{

  1048 			switch(i)

  1049 				{

  1050 				case 0:

  1051 					{

  1052 					srcBuffer->SetPosition(0);

  1053 					srcBuffer->SetFrameNumber(5);

  1054 					dstBuffer->SetPosition(0);

  1055 

  1056 					break;

  1057 					}

  1058 				case 1:

  1059 					{

  1060 					srcBuffer->SetPosition(0);

  1061 					srcBuffer->SetFrameNumber(0);

  1062 					dstBuffer->SetPosition(0);

  1063 				

  1064 					outputDataBufferPtr.Copy(dstBuffer->Data());

  1065 					if (CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1066 						{

  1067 						INFO_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestRepositionL CheckOutputAgainstComparisonFileL returned ETrue for LOOP %d."), i);

  1068 						INFO_PRINTF1(_L(">> If the codec stores left over data from the previous call to ProcessL, this may indicate that the test is invalid."));

  1069 						INFO_PRINTF1(_L(">> Try using different buffer sizes."));

  1070 						}

  1071 					break;

  1072 					}

  1073 				case 2:

  1074 					{

  1075 					outputDataBufferPtr.Copy(dstBuffer->Data());

  1076 					if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1077 						{

  1078 						ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestRepositionL CheckOutputAgainstComparisonFileL returned EFalse for LOOP %d"), i);

  1079 						testOK = EFalse;

  1080 						}

  1081 					break;

  1082 					}

  1083 				default: 

  1084 					break;

  1085 				}

  1086 			}

  1087 		else

  1088 			{

  1089 			INFO_PRINTF3(_L(">> CTestStep_MMF_ACOD::TestRepositionL Return code was %d for LOOP %d."), iCodecProcessResult.iStatus, i);

  1090 			INFO_PRINTF1(_L(">> This indicates that the test is invalid. Try using different buffer sizes."));

  1091 			break;

  1092 			}

  1093 		}

  1094 

  1095 	//clean up memory

  1096 	delete iOutputDataBuffer;

  1097 	iOutputDataBuffer = NULL;

  1098 	CleanupStack::PopAndDestroy(5); //filename, codec, srcFilename, dstBuffer, srcBuffer

  1099 

  1100 	if(!testOK)

  1101 		return EFalse;

  1102 	else

  1103 		return ETrue;

  1104 	}

  1105 

  1106 /** @xxxx

  1107  * This function tests codec instantiation by Uid.

  1108  * 

  1109  * @param	"TUid aCodecUID" 

  1110  *			Uid of the codec under test.

  1111  * @return	"TBool"

  1112  *			ETrue if the test passes.

  1113  *			EFalse if the test fails.

  1114  */

  1115 TBool CTestStep_MMF_ACOD::TestNewL(TUid aCodecUID)

  1116 	{

  1117 	//create buffers

  1118 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1119 	CleanupStack::PushL(srcBuffer);

  1120 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1121 	CleanupStack::PushL(dstBuffer);

  1122 

  1123 	//Fill source buffer with data

  1124 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1125 	TPtr ptrSrcFilename = srcFilename->Des();

  1126 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

  1127 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1128 

  1129 	TBool testOK = ETrue;

  1130 	//create codec from uid

  1131 	CMMFCodec* codec = NULL;

  1132 	TRAPD(err, codec = CMMFCodec::NewL(aCodecUID));

  1133 	if (err)

  1134 		{