1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/mm/mmlibs/mmfw/tsrc/mmfunittest/SbcCodec/TSU_MMF_SbcCodec.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1774 @@
1.4 +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32base.h>
1.20 +#include <f32file.h>
1.21 +#include <s32file.h>
1.22 +#include <mmf/plugin/mmfsbccodecimplementationuids.hrh>
1.23 +
1.24 +#include "TSU_MMF_SbcCodec.h"
1.25 +#include "TSU_MMF_SbcCodecSuite.h"
1.26 +
1.27 +/**
1.28 + * Size of PCM16 wave file header is 44
1.29 + */
1.30 +const TInt KWavFileHeaderSize = 44;
1.31 +/**
1.32 + * The default buffer size
1.33 + */
1.34 +const TUint KDefaultBufferSize = 4096;
1.35 +
1.36 +/**
1.37 + * UID of sbc encoder ECom plugin
1.38 + */
1.39 +const TUid KSbcCodecPluginUid = { KMmfUidCodecPCM16ToSBC };
1.40 +/**
1.41 + * UID of sbc encoder configuration
1.42 + */
1.43 +const TUid KSbcCodecConfigUid = { KMmfUidSBCConfigure };
1.44 +
1.45 +#ifdef __WINS__
1.46 +
1.47 +_LIT(KSourceFileDir, "c:\\mm\\mmf\\testfiles\\sbc\\");
1.48 +_LIT(KOutputFileDir, "c:\\mm\\mmf\\testfiles\\sbc\\");
1.49 +_LIT(KReferenceFileDir, "c:\\mm\\mmf\\ref\\sbc\\");
1.50 +
1.51 +#else
1.52 +
1.53 +/**
1.54 + * armv5 directories
1.55 + * All source and comparison files need to be copied manually onto the flash card.
1.56 + * This code assumes the flash card is represented by drive E: on the target board.
1.57 + */
1.58 +
1.59 +/**
1.60 + * we don't copy all the wave files onto C: as they are too big, leave them on E:
1.61 + */
1.62 +_LIT(KSourceFileDir, "e:\\");
1.63 +/**
1.64 + * This folder keeps all the output files
1.65 + */
1.66 +_LIT(KOutputFileDir, "c:\\sbc\\");
1.67 +/**
1.68 + * This folder keeps all the reference files for comparison
1.69 + */
1.70 +_LIT(KReferenceFileDir, "c:\\sbc\\ref\\");
1.71 +
1.72 +#endif
1.73 +
1.74 +// Test source files names
1.75 +_LIT(KTestWavFile01, "sbc_test_01.wav");
1.76 +_LIT(KTestWavFile02, "sbc_test_02.wav");
1.77 +_LIT(KTestWavFile03, "sbc_test_03.wav");
1.78 +_LIT(KTestWavFile04, "sbc_test_04.wav");
1.79 +_LIT(KTestWavFile05, "sbc_test_05.wav");
1.80 +_LIT(KTestWavFile06, "sbc_test_06.wav");
1.81 +_LIT(KTestWavFile07, "sbc_test_07.wav");
1.82 +_LIT(KTestWavFile08, "sbc_test_08.wav");
1.83 +_LIT(KTestWavFile09, "sbc_test_09.wav");
1.84 +_LIT(KTestWavFile10, "sbc_test_10.wav");
1.85 +
1.86 +_LIT(KTestWavFile11, "sbc_test_11.wav");
1.87 +_LIT(KTestWavFile12, "sbc_test_12.wav");
1.88 +_LIT(KTestWavFile13, "sbc_test_13.wav");
1.89 +_LIT(KTestWavFile14, "sbc_test_14.wav");
1.90 +_LIT(KTestWavFile15, "sbc_test_15.wav");
1.91 +_LIT(KTestWavFile16, "sbc_test_16.wav");
1.92 +_LIT(KTestWavFile17, "sbc_test_17.wav");
1.93 +_LIT(KTestWavFile18, "sbc_test_18.wav");
1.94 +_LIT(KTestWavFile19, "sbc_test_19.wav");
1.95 +_LIT(KTestWavFile20, "sbc_test_20.wav");
1.96 +
1.97 +_LIT(KTestWavFile21, "sbc_test_21.wav");
1.98 +_LIT(KTestWavFile22, "sbc_test_22.wav");
1.99 +_LIT(KTestWavFile23, "sbc_test_23.wav");
1.100 +_LIT(KTestWavFile24, "sbc_test_24.wav");
1.101 +_LIT(KTestWavFile25, "sbc_test_25.wav");
1.102 +_LIT(KTestWavFile26, "sbc_test_26.wav");
1.103 +_LIT(KTestWavFile27, "sbc_test_27.wav");
1.104 +_LIT(KTestWavFile28, "sbc_test_28.wav");
1.105 +
1.106 +// Test reference file name
1.107 +_LIT(KRefSbcFile01, "sbc_test_01.sbc");
1.108 +_LIT(KRefSbcFile02, "sbc_test_02.sbc");
1.109 +_LIT(KRefSbcFile03, "sbc_test_03.sbc");
1.110 +_LIT(KRefSbcFile04, "sbc_test_04.sbc");
1.111 +_LIT(KRefSbcFile05, "sbc_test_05.sbc");
1.112 +_LIT(KRefSbcFile06, "sbc_test_06.sbc");
1.113 +_LIT(KRefSbcFile07, "sbc_test_07.sbc");
1.114 +_LIT(KRefSbcFile08, "sbc_test_08.sbc");
1.115 +_LIT(KRefSbcFile09, "sbc_test_09.sbc");
1.116 +_LIT(KRefSbcFile10, "sbc_test_10.sbc");
1.117 +
1.118 +_LIT(KRefSbcFile11, "sbc_test_11.sbc");
1.119 +_LIT(KRefSbcFile12, "sbc_test_12.sbc");
1.120 +_LIT(KRefSbcFile13, "sbc_test_13.sbc");
1.121 +_LIT(KRefSbcFile14, "sbc_test_14.sbc");
1.122 +_LIT(KRefSbcFile15, "sbc_test_15.sbc");
1.123 +_LIT(KRefSbcFile16, "sbc_test_16.sbc");
1.124 +_LIT(KRefSbcFile17, "sbc_test_17.sbc");
1.125 +_LIT(KRefSbcFile18, "sbc_test_18.sbc");
1.126 +_LIT(KRefSbcFile19, "sbc_test_19.sbc");
1.127 +_LIT(KRefSbcFile20, "sbc_test_20.sbc");
1.128 +
1.129 +_LIT(KRefSbcFile21, "sbc_test_21.sbc");
1.130 +_LIT(KRefSbcFile22, "sbc_test_22.sbc");
1.131 +_LIT(KRefSbcFile23, "sbc_test_23.sbc");
1.132 +_LIT(KRefSbcFile24, "sbc_test_24.sbc");
1.133 +_LIT(KRefSbcFile25, "sbc_test_25.sbc");
1.134 +_LIT(KRefSbcFile26, "sbc_test_26.sbc");
1.135 +_LIT(KRefSbcFile27, "sbc_test_27.sbc");
1.136 +_LIT(KRefSbcFile28, "sbc_test_28.sbc");
1.137 +
1.138 +/**
1.139 + * List of channel mode settings
1.140 + */
1.141 +enum TChannelMode
1.142 + {
1.143 + /**
1.144 + channel mode is Mono
1.145 + */
1.146 + EMono,
1.147 + /**
1.148 + channel mode is Dual Channel
1.149 + */
1.150 + EDual,
1.151 + /**
1.152 + channel mode is Stereo
1.153 + */
1.154 + EStereo,
1.155 + /**
1.156 + channel mode is Joint Stereo
1.157 + */
1.158 + EJoint
1.159 + };
1.160 +
1.161 +/**
1.162 + * List of allocation method settings
1.163 + */
1.164 +enum TAllocMethod
1.165 + {
1.166 + /**
1.167 + allocation method is SNR
1.168 + */
1.169 + ESNR,
1.170 + /**
1.171 + allocation method is Loudness
1.172 + */
1.173 + ELoud
1.174 + };
1.175 +
1.176 +/**
1.177 + * Table of all 28 tests configurations, each row contains the following fields in order
1.178 + * subbands, block length, sampling frequency, channel mode, allocation method, bitpool
1.179 + */
1.180 +const TInt gSbcConfig[28][6] =
1.181 + {
1.182 + // configuration tests (8)
1.183 + { 4, 16, 48000, EMono, ESNR, 18 },
1.184 + { 4, 16, 48000, EDual, ESNR, 16 },
1.185 + { 8, 8, 44100, EMono, ELoud, 32 },
1.186 + { 8, 8, 44100, EJoint, ELoud, 56 },
1.187 + { 8, 4, 32000, EMono, ESNR, 24 },
1.188 + { 8, 4, 32000, EStereo, ESNR, 48 },
1.189 + { 4, 12, 16000, EMono, ELoud, 20 },
1.190 + { 4, 12, 16000, EJoint, ELoud, 42 },
1.191 +
1.192 + // vbr tests (2)
1.193 + { 4, 16, 44100, EMono, ELoud, 15 },
1.194 + { 8, 12, 48000, EJoint, ELoud, 51 },
1.195 +
1.196 + // maximum bit rate tests (8)
1.197 + { 8, 16, 16000, EMono, ELoud, 128 },
1.198 + { 8, 16, 16000, EJoint, ESNR, 249 },
1.199 + { 8, 16, 32000, EMono, ELoud, 76 },
1.200 + { 8, 16, 32000, EJoint, ESNR, 121 },
1.201 + { 8, 16, 44100, EMono, ELoud, 54 },
1.202 + { 8, 16, 44100, EJoint, ESNR, 86 },
1.203 + { 8, 16, 48000, EMono, ELoud, 49 },
1.204 + { 8, 16, 48000, EJoint, ESNR, 78 },
1.205 +
1.206 + // special tests (2)
1.207 + { 8, 16, 48000, EMono, ESNR, 29 },
1.208 + { 8, 16, 44100, EJoint, ESNR, 53 },
1.209 +
1.210 + // typical tests (8)
1.211 + { 8, 16, 44100, EMono, ELoud, 19 },
1.212 + { 8, 16, 48000, EMono, ELoud, 18 },
1.213 + { 8, 16, 44100, EJoint, ELoud, 35 },
1.214 + { 8, 16, 48000, EJoint, ELoud, 33 },
1.215 + { 8, 16, 44100, EMono, ELoud, 31 },
1.216 + { 8, 16, 48000, EMono, ELoud, 29 },
1.217 + { 8, 16, 44100, EJoint, ELoud, 53 },
1.218 + { 8, 16, 48000, EJoint, ELoud, 51 }
1.219 + };
1.220 +
1.221 +/**
1.222 + * This function converts number of subbands into TSBCFrameParameters::TSubbands value
1.223 + * @param "TInt aSubbands"
1.224 + * number of subbands
1.225 + * @return "TSBCFrameParameters::TSubbands"
1.226 + * TSBCFrameParameters::TSubbands value
1.227 + */
1.228 +static inline TSBCFrameParameters::TSubbands GetSubbandsL(TInt aSubbands)
1.229 + {
1.230 + switch (aSubbands)
1.231 + {
1.232 + case 4: return TSBCFrameParameters::E4Subbands;
1.233 + case 8: return TSBCFrameParameters::E8Subbands;
1.234 + }
1.235 + User::Leave(KErrArgument);
1.236 + return TSBCFrameParameters::E4Subbands; // just make the compiler happy
1.237 + }
1.238 +
1.239 +/**
1.240 + * This function converts number of blocks into TSBCFrameParameters::TBlockLength value
1.241 + * @param "TInt aBlocks"
1.242 + * number of blocks
1.243 + * @return "TSBCFrameParameters::TBlockLength"
1.244 + * TSBCFrameParameters::TBlockLength value
1.245 + */
1.246 +static inline TSBCFrameParameters::TBlockLength GetBlockLengthL(TInt aBlocks)
1.247 + {
1.248 + switch (aBlocks)
1.249 + {
1.250 + case 4: return TSBCFrameParameters::E4Blocks;
1.251 + case 8: return TSBCFrameParameters::E8Blocks;
1.252 + case 12: return TSBCFrameParameters::E12Blocks;
1.253 + case 16: return TSBCFrameParameters::E16Blocks;
1.254 + }
1.255 + User::Leave(KErrArgument);
1.256 + return TSBCFrameParameters::E4Blocks; //just make the compiler happy
1.257 + }
1.258 +
1.259 +/**
1.260 + * This function converts sampling frequency value into TSBCFrameParameters::TSamplingFrequency value
1.261 + * @param "TInt aSampFreq"
1.262 + * real sampling frequency value
1.263 + * @return "TSBCFrameParameters::TSamplingFrequency"
1.264 + * TSBCFrameParameters::TSamplingFrequency value
1.265 + */
1.266 +static inline TSBCFrameParameters::TSamplingFrequency GetSampFreqL(TInt aSampFreq)
1.267 + {
1.268 + switch (aSampFreq)
1.269 + {
1.270 + case 16000: return TSBCFrameParameters::E16000Hz;
1.271 + case 32000: return TSBCFrameParameters::E32000Hz;
1.272 + case 44100: return TSBCFrameParameters::E44100Hz;
1.273 + case 48000: return TSBCFrameParameters::E48000Hz;
1.274 + }
1.275 + User::Leave(KErrArgument);
1.276 + return TSBCFrameParameters::E16000Hz; // just make the compiler happy
1.277 + }
1.278 +
1.279 +/**
1.280 + * This function converts ChannelMode enum value into TSBCFrameParameters::TChannelMode value
1.281 + * @param "TInt aChnlMode"
1.282 + * ChannelMode enum value
1.283 + * @return "TSBCFrameParameters::TChannelMode"
1.284 + * TSBCFrameParameters::TChannelMode value
1.285 + */
1.286 +static inline TSBCFrameParameters::TChannelMode GetChannelModeL(TInt aChnlMode)
1.287 + {
1.288 + switch (aChnlMode)
1.289 + {
1.290 + case EMono: return TSBCFrameParameters::EMono;
1.291 + case EDual: return TSBCFrameParameters::EDualChannel;
1.292 + case EStereo: return TSBCFrameParameters::EStereo;
1.293 + case EJoint: return TSBCFrameParameters::EJointStereo;
1.294 + }
1.295 + User::Leave(KErrArgument);
1.296 + return TSBCFrameParameters::EMono; // just make the compiler happy
1.297 + }
1.298 +
1.299 +/**
1.300 + * This function converts AllocMethod enum value into TSBCFrameParameters::TAllocationMethod value
1.301 + * @param "TInt aAllocMthd"
1.302 + * AllocMethod enum value
1.303 + * @return "TSBCFrameParameters::TAllocationMethod"
1.304 + * TSBCFrameParameters::TAllocationMethod value
1.305 + */
1.306 +static inline TSBCFrameParameters::TAllocationMethod GetAllocMethodL(TInt aAllocMthd)
1.307 + {
1.308 + switch (aAllocMthd)
1.309 + {
1.310 + case ESNR: return TSBCFrameParameters::ESNR;
1.311 + case ELoud: return TSBCFrameParameters::ELoudness;
1.312 + }
1.313 + User::Leave(KErrArgument);
1.314 + return TSBCFrameParameters::ESNR;
1.315 + }
1.316 +
1.317 +/**
1.318 + * This function gets the configuration for one test from SbcConfig[28]
1.319 + * @param "TInt aTestNumber"
1.320 + * test number
1.321 + * @return "TSBCFrameParameters"
1.322 + * the sbc frame parameters used to configure sbc codec
1.323 + */
1.324 +static TSBCFrameParameters SbcParametersL(TInt aTestNumber)
1.325 + {
1.326 + if (aTestNumber < 0 || aTestNumber > 28)
1.327 + {
1.328 + User::Leave(KErrArgument);
1.329 + }
1.330 +
1.331 + TSBCFrameParameters param;
1.332 + param.SetSubbands(GetSubbandsL(gSbcConfig[aTestNumber - 1][0]) );
1.333 + param.SetBlockLength(GetBlockLengthL(gSbcConfig[aTestNumber - 1][1]) );
1.334 + param.SetSamplingFrequency(GetSampFreqL(gSbcConfig[aTestNumber - 1][2]) );
1.335 + param.SetChannelMode(GetChannelModeL(gSbcConfig[aTestNumber - 1][3]) );
1.336 + param.SetAllocationMethod(GetAllocMethodL(gSbcConfig[aTestNumber - 1][4]) );
1.337 + param.SetBitpool(static_cast<TUint8>(gSbcConfig[aTestNumber - 1][5]) );
1.338 + return param;
1.339 + }
1.340 +
1.341 +/**
1.342 + * Constructor
1.343 + */
1.344 +CTestStep_MMF_SbcCodec::CTestStep_MMF_SbcCodec()
1.345 + {
1.346 + }
1.347 +
1.348 +/**
1.349 + * Destructor
1.350 + */
1.351 +CTestStep_MMF_SbcCodec::~CTestStep_MMF_SbcCodec()
1.352 + {
1.353 + }
1.354 +
1.355 +/**
1.356 + * This function gets test source file name for one test
1.357 + * @param "TInt aTestNumber"
1.358 + * test number
1.359 + * @return "const TDesC&"
1.360 + * test file name
1.361 + */
1.362 +const TDesC& CTestStep_MMF_SbcCodec::GetTestFileName(TInt aTestNumber)
1.363 + {
1.364 + switch (aTestNumber)
1.365 + {
1.366 + case 1 : return KTestWavFile01;
1.367 + case 2 : return KTestWavFile02;
1.368 + case 3 : return KTestWavFile03;
1.369 + case 4 : return KTestWavFile04;
1.370 + case 5 : return KTestWavFile05;
1.371 + case 6 : return KTestWavFile06;
1.372 + case 7 : return KTestWavFile07;
1.373 + case 8 : return KTestWavFile08;
1.374 + case 9 : return KTestWavFile09;
1.375 + case 10: return KTestWavFile10;
1.376 +
1.377 + case 11: return KTestWavFile11;
1.378 + case 12: return KTestWavFile12;
1.379 + case 13: return KTestWavFile13;
1.380 + case 14: return KTestWavFile14;
1.381 + case 15: return KTestWavFile15;
1.382 + case 16: return KTestWavFile16;
1.383 + case 17: return KTestWavFile17;
1.384 + case 18: return KTestWavFile18;
1.385 + case 19: return KTestWavFile19;
1.386 + case 20: return KTestWavFile20;
1.387 +
1.388 + case 21: return KTestWavFile21;
1.389 + case 22: return KTestWavFile22;
1.390 + case 23: return KTestWavFile23;
1.391 + case 24: return KTestWavFile24;
1.392 + case 25: return KTestWavFile25;
1.393 + case 26: return KTestWavFile26;
1.394 + case 27: return KTestWavFile27;
1.395 + case 28: return KTestWavFile28;
1.396 + }
1.397 + User::Panic(_L("Invalid test number"), KErrArgument);
1.398 + return KTestWavFile01;
1.399 + }
1.400 +
1.401 +/**
1.402 + * This function gets test reference file name for one test
1.403 + * @param "TInt aTestNumber"
1.404 + * test number
1.405 + * @return "const TDesC&"
1.406 + * reference file name
1.407 + */
1.408 +const TDesC& CTestStep_MMF_SbcCodec::GetRefFileName(TInt aTestNumber)
1.409 + {
1.410 + switch (aTestNumber)
1.411 + {
1.412 + case 1 : return KRefSbcFile01;
1.413 + case 2 : return KRefSbcFile02;
1.414 + case 3 : return KRefSbcFile03;
1.415 + case 4 : return KRefSbcFile04;
1.416 + case 5 : return KRefSbcFile05;
1.417 + case 6 : return KRefSbcFile06;
1.418 + case 7 : return KRefSbcFile07;
1.419 + case 8 : return KRefSbcFile08;
1.420 + case 9 : return KRefSbcFile09;
1.421 + case 10: return KRefSbcFile10;
1.422 +
1.423 + case 11: return KRefSbcFile11;
1.424 + case 12: return KRefSbcFile12;
1.425 + case 13: return KRefSbcFile13;
1.426 + case 14: return KRefSbcFile14;
1.427 + case 15: return KRefSbcFile15;
1.428 + case 16: return KRefSbcFile16;
1.429 + case 17: return KRefSbcFile17;
1.430 + case 18: return KRefSbcFile18;
1.431 + case 19: return KRefSbcFile19;
1.432 + case 20: return KRefSbcFile20;
1.433 +
1.434 + case 21: return KRefSbcFile21;
1.435 + case 22: return KRefSbcFile22;
1.436 + case 23: return KRefSbcFile23;
1.437 + case 24: return KRefSbcFile24;
1.438 + case 25: return KRefSbcFile25;
1.439 + case 26: return KRefSbcFile26;
1.440 + case 27: return KRefSbcFile27;
1.441 + case 28: return KRefSbcFile28;
1.442 + }
1.443 + User::Panic(_L("Invalid test number"), KErrArgument);
1.444 + return KRefSbcFile01;
1.445 + }
1.446 +
1.447 +/**
1.448 + * This function reads source out from source file from a specific position
1.449 + and fill the srouce into the source buffer.
1.450 + * @param "const TDesC& aFileName"
1.451 + * the source file name
1.452 + * @param "TDes8& aSrcBuffer"
1.453 + * the source buffer
1.454 + * @param "TInt aFilePos"
1.455 + * the file position
1.456 + * @leave if reading file failed
1.457 + */
1.458 +void CTestStep_MMF_SbcCodec::ReadSourceL(const TDesC& aFileName, TDes8& aSrcBuffer, TInt aFilePos)
1.459 + {
1.460 + TFileName srcFileName(KSourceFileDir);
1.461 + srcFileName.Append(aFileName);
1.462 +
1.463 + // connect to file service
1.464 + RFs fs;
1.465 + User::LeaveIfError(fs.Connect());
1.466 + CleanupClosePushL(fs);
1.467 +
1.468 + RFile srcFile;
1.469 + User::LeaveIfError(srcFile.Open(fs, srcFileName, EFileRead | EFileShareAny) );
1.470 + CleanupClosePushL(srcFile);
1.471 +
1.472 + aFilePos += KWavFileHeaderSize; // skip wave file header
1.473 + User::LeaveIfError(srcFile.Seek(ESeekStart, aFilePos) );
1.474 + User::LeaveIfError(srcFile.Read(aSrcBuffer) );
1.475 +
1.476 + CleanupStack::PopAndDestroy(2);
1.477 + }
1.478 +
1.479 +/**
1.480 + * This function writes destination into destination file from a specific position.
1.481 + * @param "const TDesC& aFileName"
1.482 + * the destination file name
1.483 + * @param "TDes8& aDstBuffer"
1.484 + * the destination buffer
1.485 + * @param "TInt aFilePos"
1.486 + * the file position
1.487 + * @leave if writing file failed
1.488 + */
1.489 +void CTestStep_MMF_SbcCodec::WriteDstToFileL(const TDesC& aFileName, const TDes8& aDstBuffer, TInt aFilePos)
1.490 + {
1.491 + TFileName dstFileName(KOutputFileDir);
1.492 + dstFileName.Append(aFileName);
1.493 +
1.494 + // connect to file service
1.495 + RFs fs;
1.496 + User::LeaveIfError(fs.Connect());
1.497 + CleanupClosePushL(fs);
1.498 +
1.499 + RFile dstFile;
1.500 + TInt err = dstFile.Open(fs, dstFileName, EFileWrite);
1.501 + if (err == KErrNotFound) // file does not exist - create it
1.502 + {
1.503 + err = dstFile.Create(fs, dstFileName, EFileWrite);
1.504 + }
1.505 + if (err != KErrNone)
1.506 + {
1.507 + User::Leave(err);
1.508 + }
1.509 + CleanupClosePushL(dstFile);
1.510 +
1.511 + User::LeaveIfError(dstFile.Seek(ESeekStart, aFilePos) );
1.512 + User::LeaveIfError(dstFile.Write(aDstBuffer) );
1.513 +
1.514 + CleanupStack::PopAndDestroy(2);
1.515 + }
1.516 +
1.517 +/**
1.518 + * This function compares two files to check if they are the same.
1.519 + * @param "const TDesC& aFileName"
1.520 + * the compare and reference files name
1.521 + * @return "TInt"
1.522 + * 0: two files are the same
1.523 + * -1: two files are NOT the same
1.524 + * @leave if reading tow files failed
1.525 + */
1.526 +TInt CTestStep_MMF_SbcCodec::CompareFileL(const TDesC& aFileName)
1.527 + {
1.528 + TFileName cmpFileName(KOutputFileDir);
1.529 + cmpFileName.Append(aFileName);
1.530 +
1.531 + TFileName refFileName(KReferenceFileDir);
1.532 + refFileName.Append(aFileName);
1.533 +
1.534 + // connect to file service
1.535 + RFs fs;
1.536 + User::LeaveIfError(fs.Connect());
1.537 + CleanupClosePushL(fs);
1.538 +
1.539 + RFile cmpFile;
1.540 + User::LeaveIfError(cmpFile.Open(fs, cmpFileName, EFileRead) );
1.541 + CleanupClosePushL(cmpFile);
1.542 +
1.543 + RFile refFile;
1.544 + User::LeaveIfError(refFile.Open(fs, refFileName, EFileRead) );
1.545 + CleanupClosePushL(refFile);
1.546 +
1.547 + TInt cmpFileSize = 0;
1.548 + TInt refFileSize = 0;
1.549 +
1.550 + cmpFile.Size(cmpFileSize);
1.551 + refFile.Size(refFileSize);
1.552 +
1.553 + if (cmpFileSize != refFileSize)
1.554 + {
1.555 + CleanupStack::PopAndDestroy(3); // refFile, cmpFile, fs
1.556 + return -1;
1.557 + }
1.558 +
1.559 + CMMFDataBuffer* cmpFileBuf = CMMFDataBuffer::NewL(KDefaultBufferSize);
1.560 + CleanupStack::PushL(cmpFileBuf);
1.561 + CMMFDataBuffer* refFileBuf = CMMFDataBuffer::NewL(KDefaultBufferSize);
1.562 + CleanupStack::PushL(refFileBuf);
1.563 +
1.564 + TInt result = 0;
1.565 + for (;;)
1.566 + {
1.567 + User::LeaveIfError(cmpFile.Read(cmpFileBuf->Data() ) );
1.568 + if (cmpFileBuf->Data().Length() == 0) // end of file
1.569 + {
1.570 + break;
1.571 + }
1.572 +
1.573 + User::LeaveIfError(refFile.Read(refFileBuf->Data() ) );
1.574 + if (cmpFileBuf->Data() != refFileBuf->Data() )
1.575 + {
1.576 + result = -1;
1.577 + break;
1.578 + }
1.579 +
1.580 + cmpFileBuf->Data().Zero();
1.581 + refFileBuf->Data().Zero();
1.582 + }
1.583 +
1.584 + CleanupStack::PopAndDestroy(5); // refFileBuff, cmpFileBuff, refFile, cmpFile, fs
1.585 + return result;
1.586 + }
1.587 +
1.588 +/**
1.589 + * This function is called by two TestNewL() tests, it calls ProcessL() once
1.590 + * and checks the result.
1.591 + * @param "CMMFCodec* aCodec"
1.592 + * the codec for test
1.593 + * @return "TVerdict"
1.594 + * EPass: at least one byte src processed and one byte of dst generated and no error
1.595 + * EFail: other wise.
1.596 + * @leave if out of memory or ProcessL() leaves
1.597 + */
1.598 +TVerdict CTestStep_MMF_SbcCodec::ProcessOnceForNewL(CMMFCodec* aCodec)
1.599 + {
1.600 + TVerdict testResult = EFail;
1.601 +
1.602 + // create buffers
1.603 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);
1.604 + CleanupStack::PushL(srcBuffer);
1.605 + CMMFDataBuffer* dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);
1.606 + CleanupStack::PushL(dstBuffer);
1.607 +
1.608 + TInt testNumber = 28;
1.609 + TPckgBuf<TSBCFrameParameters> config(SbcParametersL(testNumber) );
1.610 + aCodec->ConfigureL(KSbcCodecConfigUid, config);
1.611 +
1.612 + ReadSourceL(GetTestFileName(testNumber), srcBuffer->Data(), 0);
1.613 +
1.614 + if (srcBuffer->Data().Length() > 0) // end of file
1.615 + {
1.616 + TCodecProcessResult result = aCodec->ProcessL(*srcBuffer, *dstBuffer);
1.617 +
1.618 + if (result.iDstBytesAdded > 0 && result.iSrcBytesProcessed > 0)
1.619 + {
1.620 + testResult = EPass;
1.621 + }
1.622 + }
1.623 + else
1.624 + {
1.625 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::ProcessOnceForNewL no source read") );
1.626 + }
1.627 +
1.628 + CleanupStack::PopAndDestroy(2); // dstBuffer, srcBuffer
1.629 +
1.630 + return testResult;
1.631 +}
1.632 +
1.633 +/**
1.634 + * This function tests codec instantiation by ECom plugin UID.
1.635 + * @param "TUid aCodecUID"
1.636 + * the codec ECom UID
1.637 + * @return "TVerdict"
1.638 + * EPass: ProcessOnceForNewL() passes
1.639 + * EFail: ProcessOnceForNewL() fails
1.640 + * @leave if CMMFCodec::NewL() leaves
1.641 + */
1.642 +TVerdict CTestStep_MMF_SbcCodec::TestNewL(TUid aCodecUID)
1.643 + {
1.644 + //create codec from uid
1.645 + CMMFCodec* codec = NULL;
1.646 + TRAPD(err, codec = CMMFCodec::NewL(aCodecUID) );
1.647 +
1.648 + if (err != KErrNone)
1.649 + {
1.650 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestNewL Leave occurred in NewL, error code %d"), err);
1.651 + return EFail;
1.652 + }
1.653 + if (!codec)
1.654 + {
1.655 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestNewL NewL returned NULL") );
1.656 + return EFail;
1.657 + }
1.658 +
1.659 + CleanupStack::PushL(codec);
1.660 + TVerdict result = ProcessOnceForNewL(codec);
1.661 + CleanupStack::PopAndDestroy(); //codec
1.662 + return result;
1.663 + }
1.664 +
1.665 +/**
1.666 + * This function tests codec instantiation by two FourCC codes.
1.667 + * @param "const TFourCC& aSrcFourCC"
1.668 + * the FourCC code of source media type
1.669 + * @param "const TFourCC& aDstFourCC"
1.670 + * the FourCC code of destination media type
1.671 + * @return "TVerdict"
1.672 + * EPass: ProcessOnceForNewL() passes
1.673 + * EFail: ProcessOnceForNewL() fails
1.674 + * @leave if CMMFCodec::NewL() or ProcessOnceForNewL() leaves
1.675 + */
1.676 +TVerdict CTestStep_MMF_SbcCodec::TestNewL(const TFourCC& aSrcFourCC, const TFourCC& aDstFourCC)
1.677 + {
1.678 + //create codec from uid
1.679 + CMMFCodec* codec = NULL;
1.680 + TRAPD(err, codec = CMMFCodec::NewL(aSrcFourCC, aDstFourCC) );
1.681 +
1.682 + if (err != KErrNone)
1.683 + {
1.684 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestNewL Leave occurred in NewL, error code %d"), err);
1.685 + return EFail;
1.686 + }
1.687 + if (!codec)
1.688 + {
1.689 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestNewL NewL returned NULL") );
1.690 + return EFail;
1.691 + }
1.692 +
1.693 + CleanupStack::PushL(codec);
1.694 + TVerdict result = ProcessOnceForNewL(codec);
1.695 + CleanupStack::PopAndDestroy(); //codec
1.696 + return result;
1.697 + }
1.698 +
1.699 +/**
1.700 + * Performance test
1.701 + * This function tests ProcessL() function, it checks if ProcessL() returns the
1.702 + * correct result with different buffer size settings
1.703 + * @return "TVerdict"
1.704 + * EPass: the results are expected ones.
1.705 + * EFail: otherwise.
1.706 + * @leave if out of memory or ProcessL(), ReadSourceL() leaves
1.707 + */
1.708 +TVerdict CTestStep_MMF_SbcCodec::TestProcessL()
1.709 + {
1.710 + //create codec from uid
1.711 + CMMFCodec* codec = NULL;
1.712 + TRAPD(err, codec = CMMFCodec::NewL(KSbcCodecPluginUid) );
1.713 +
1.714 + if (err != KErrNone)
1.715 + {
1.716 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestProcessL Leave occurred in NewL, error code %d"), err);
1.717 + return EFail;
1.718 + }
1.719 + if (!codec)
1.720 + {
1.721 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL NewL returned NULL") );
1.722 + return EFail;
1.723 + }
1.724 +
1.725 + CleanupStack::PushL(codec);
1.726 +
1.727 + const TInt testNumber = 28;
1.728 +
1.729 + TSBCFrameParameters param = SbcParametersL(testNumber);
1.730 +
1.731 + const TUint sbcFrameLength = param.CalcFrameLength();
1.732 + const TUint pcmFrameSize = sizeof(TInt16) * param.BlockLength() * param.Channels() * param.Subbands();
1.733 +
1.734 + // create src buffer
1.735 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(pcmFrameSize);
1.736 + CleanupStack::PushL(srcBuffer);
1.737 +
1.738 + // dummy buffer, smaller than one frame length
1.739 + CMMFDataBuffer* dummyBuffer = CMMFDataBuffer::NewL(sbcFrameLength - 1);
1.740 + CleanupStack::PushL(dummyBuffer);
1.741 +
1.742 + // create dst buffer
1.743 + CMMFDataBuffer* dstBuffer = CMMFDataBuffer::NewL(sbcFrameLength);
1.744 + CleanupStack::PushL(dstBuffer);
1.745 +
1.746 + ReadSourceL(GetTestFileName(testNumber), srcBuffer->Data(), 0);
1.747 +
1.748 + if (static_cast<TUint>(srcBuffer->Data().Length() ) != pcmFrameSize)
1.749 + {
1.750 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL read source failed") );
1.751 + CleanupStack::PopAndDestroy(3); // dstBuffer, srcBuffer, codec
1.752 + return EFail;
1.753 + }
1.754 +
1.755 + TVerdict testResult = EPass;
1.756 + TCodecProcessResult procResult;
1.757 +
1.758 + /** test ProcessL() without ConfigureL() called, should leave with KErrAbort */
1.759 +
1.760 + TRAP(err, procResult = codec->ProcessL(*srcBuffer, *dstBuffer) );
1.761 +
1.762 + if (err != KErrAbort ||
1.763 + procResult.iSrcBytesProcessed != 0 ||
1.764 + procResult.iDstBytesAdded != 0 ||
1.765 + procResult.iStatus != TCodecProcessResult::EProcessError)
1.766 + {
1.767 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL failed, ProcessL didn't leave with KErrAbort when ConfigureL() is not called") );
1.768 + testResult = EFail;
1.769 + }
1.770 +
1.771 + /** test ProcessL() with small dst buffer size, should leave with KErrArgument */
1.772 +
1.773 + TPckgBuf<TSBCFrameParameters> config(param);
1.774 + codec->ConfigureL(KSbcCodecConfigUid, config);
1.775 +
1.776 + codec->ResetL();
1.777 + TRAP(err, procResult = codec->ProcessL(*srcBuffer, *dummyBuffer) );
1.778 +
1.779 + if (err != KErrArgument ||
1.780 + procResult.iSrcBytesProcessed != 0 ||
1.781 + procResult.iDstBytesAdded != 0 ||
1.782 + procResult.iStatus != TCodecProcessResult::EProcessError)
1.783 + {
1.784 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL failed in ProcessL") );
1.785 + testResult = EFail;
1.786 + }
1.787 +
1.788 + /** test ProcessL() with correct settings, should return EProcessComplete */
1.789 +
1.790 + codec->ResetL();
1.791 + TRAP(err, procResult = codec->ProcessL(*srcBuffer, *dstBuffer) );
1.792 +
1.793 + if (err != KErrNone ||
1.794 + procResult.iSrcBytesProcessed != pcmFrameSize ||
1.795 + procResult.iDstBytesAdded != sbcFrameLength ||
1.796 + procResult.iStatus != TCodecProcessResult::EProcessComplete)
1.797 + {
1.798 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL failed, ProcessL didn't work propertly with correct settings") );
1.799 + testResult = EFail;
1.800 + }
1.801 +
1.802 + /** test ProcessL() with not enough dst buffer remained, should return EProcessIncomplete */
1.803 +
1.804 + // now the remaining dst buffer size is one byte less than one frame length
1.805 + dstBuffer->SetPosition(1);
1.806 +
1.807 + codec->ResetL();
1.808 + TRAP(err, procResult = codec->ProcessL(*srcBuffer, *dstBuffer) );
1.809 +
1.810 + if (err != KErrNone ||
1.811 + procResult.iSrcBytesProcessed != 0 ||
1.812 + procResult.iDstBytesAdded != 0 ||
1.813 + procResult.iStatus != TCodecProcessResult::EProcessIncomplete)
1.814 + {
1.815 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL failed, ProcessL didn't return EProcessIncomplete when there is not enough dst buffer") );
1.816 + testResult = EFail;
1.817 + }
1.818 +
1.819 + /** test ProcessL() with not enough src buffer remained, should return EDstNotFilled */
1.820 +
1.821 + // set this position to an even value as only even number of samples will be cached
1.822 + const TInt srcPos = 2;
1.823 + // the remaining src buffer size is less than one frame, it should be cached,
1.824 + // and return EProcessDstNotFilled
1.825 + srcBuffer->SetPosition(srcPos);
1.826 + // now the remaining dst buffer size is one frame length
1.827 + dstBuffer->SetPosition(0);
1.828 +
1.829 + codec->ResetL();
1.830 + TRAP(err, procResult = codec->ProcessL(*srcBuffer, *dstBuffer) );
1.831 +
1.832 + if (err != KErrNone ||
1.833 + procResult.iSrcBytesProcessed != pcmFrameSize - srcPos ||
1.834 + procResult.iDstBytesAdded != 0 ||
1.835 + procResult.iStatus != TCodecProcessResult::EDstNotFilled)
1.836 + {
1.837 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessL failed, ProcessL didn't return EDstNotFilled when there is not enough src buffer") );
1.838 + testResult = EFail;
1.839 + }
1.840 +
1.841 + CleanupStack::PopAndDestroy(4); // dstBuffer, dummyBuffer, srcBuffer, codec
1.842 + return testResult;
1.843 + }
1.844 +
1.845 +/**
1.846 + * This function tests the whole encoding routine with a specific settings (e.g.
1.847 + * sbc frameparameters, src buffer size, dst buffer size) and compares the result
1.848 + * file with reference file.
1.849 + * @param "TInt aTestNumber"
1.850 + * the test number.
1.851 + * @param "TInt aSrcBufSize"
1.852 + * the source buffer size.
1.853 + * @param "TInt aDstBufSize"
1.854 + * the destination buffer size.
1.855 + * @return "TVerdict"
1.856 + * EPass: encoded file is the same as the reference file.
1.857 + * EFail: encoded file is NOT the same as the reference file.
1.858 + * @leave if out of memory or ProcessL(), ReadSourceL(), WriteDstToFileL() leaves
1.859 + */
1.860 +TVerdict CTestStep_MMF_SbcCodec::TestEncodeL(TInt aTestNumber, TInt aSrcBufSize, TInt aDstBufSize)
1.861 + {
1.862 + //create codec from uid
1.863 + CMMFCodec* codec = NULL;
1.864 + TRAPD(err, codec = CMMFCodec::NewL(KSbcCodecPluginUid) );
1.865 +
1.866 + if (err != KErrNone)
1.867 + {
1.868 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestEncodeL Leave occurred in NewL, error code %d"), err);
1.869 + return EFail;
1.870 + }
1.871 + if (!codec)
1.872 + {
1.873 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestEncodeL NewL returned NULL") );
1.874 + return EFail;
1.875 + }
1.876 +
1.877 + CleanupStack::PushL(codec);
1.878 +
1.879 + // create buffers
1.880 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(aSrcBufSize);
1.881 + CleanupStack::PushL(srcBuffer);
1.882 + CMMFDataBuffer* dstBuffer = CMMFDataBuffer::NewL(aDstBufSize);
1.883 + CleanupStack::PushL(dstBuffer);
1.884 +
1.885 + TPckgBuf<TSBCFrameParameters> config(SbcParametersL(aTestNumber) );
1.886 + codec->ConfigureL(KSbcCodecConfigUid, config);
1.887 +
1.888 + TInt srcFilePos = 0;
1.889 + TInt dstFilePos = 0;
1.890 +
1.891 + for (;;)
1.892 + {
1.893 + ReadSourceL(GetTestFileName(aTestNumber), srcBuffer->Data(), srcFilePos);
1.894 +
1.895 + if (srcBuffer->Data().Length() == 0) // end of file
1.896 + {
1.897 + break;
1.898 + }
1.899 +
1.900 + TCodecProcessResult result = codec->ProcessL(*srcBuffer, *dstBuffer);
1.901 +
1.902 + WriteDstToFileL(GetRefFileName(aTestNumber), dstBuffer->Data(), dstFilePos);
1.903 +
1.904 + srcBuffer->Data().Zero();
1.905 + dstBuffer->Data().Zero();
1.906 +
1.907 + srcFilePos += result.iSrcBytesProcessed;
1.908 + dstFilePos += result.iDstBytesAdded;
1.909 + }
1.910 +
1.911 + TVerdict result = EPass;
1.912 + if (CompareFileL(GetRefFileName(aTestNumber) ) != 0)
1.913 + {
1.914 + result = EFail;
1.915 + }
1.916 +
1.917 + CleanupStack::PopAndDestroy(3); // dstBuffer, srcBuffer, codec
1.918 + return result;
1.919 + }
1.920 +
1.921 +/**
1.922 + * This function tests codec ResetL() function make sure the cach buffer
1.923 + * gets cleared when it gets called. It compares the encoded file with the reference file
1.924 + * @return "TVerdict"
1.925 + * EPass: encoded file is the same as the reference file.
1.926 + * EFail: encoded file is NOT the same as the reference file.
1.927 + * @leave if out of memory or ProcessL(), ReadSourceL(), WriteDstToFileL() leaves
1.928 + */
1.929 +TVerdict CTestStep_MMF_SbcCodec::TestRepositionL()
1.930 + {
1.931 + //create codec from uid
1.932 + CMMFCodec* codec = NULL;
1.933 + TRAPD(err, codec = CMMFCodec::NewL(KSbcCodecPluginUid) );
1.934 +
1.935 + if (err != KErrNone)
1.936 + {
1.937 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestRepositionL Leave occurred in NewL, error code %d"), err);
1.938 + return EFail;
1.939 + }
1.940 + if (!codec)
1.941 + {
1.942 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestRepositionL NewL returned NULL") );
1.943 + return EFail;
1.944 + }
1.945 +
1.946 + CleanupStack::PushL(codec);
1.947 +
1.948 + const TInt testNumber = 28;
1.949 + // this size will make sure some samples will be cached,
1.950 + // also make sure it is an EVEN number
1.951 + const TInt srcBufSize = 4094;
1.952 + const TInt dstBufSize = 2048;
1.953 +
1.954 + // create buffers
1.955 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(srcBufSize);
1.956 + CleanupStack::PushL(srcBuffer);
1.957 + CMMFDataBuffer* dstBuffer = CMMFDataBuffer::NewL(dstBufSize);
1.958 + CleanupStack::PushL(dstBuffer);
1.959 +
1.960 + TSBCFrameParameters param = SbcParametersL(testNumber);
1.961 +
1.962 + TPckgBuf<TSBCFrameParameters> config(param);
1.963 + codec->ConfigureL(KSbcCodecConfigUid, config);
1.964 +
1.965 + const TUint pcmFrameSize = sizeof(TInt16) * param.BlockLength() * param.Channels() * param.Subbands();
1.966 +
1.967 + TInt srcFilePos = 0;
1.968 + TInt dstFilePos = 0;
1.969 +
1.970 + for (;;)
1.971 + {
1.972 + ReadSourceL(GetTestFileName(testNumber), srcBuffer->Data(), srcFilePos);
1.973 +
1.974 + if (srcBuffer->Data().Length() == 0) // end of file
1.975 + {
1.976 + break;
1.977 + }
1.978 +
1.979 + TCodecProcessResult result = codec->ProcessL(*srcBuffer, *dstBuffer);
1.980 +
1.981 + WriteDstToFileL(GetRefFileName(testNumber), dstBuffer->Data(), dstFilePos);
1.982 +
1.983 + // clear up any cached samples
1.984 + codec->ResetL();
1.985 + // the iSrcBytesProcessed includes the encoded src size plus the cached src size,
1.986 + // here set the iSrcBytesProcessed to the encoded src size only as we cleared up
1.987 + // the cached samples
1.988 + result.iSrcBytesProcessed -= srcBuffer->Data().Length() % pcmFrameSize;
1.989 +
1.990 + srcBuffer->Data().Zero();
1.991 + dstBuffer->Data().Zero();
1.992 +
1.993 + // set new src file position, which is the end of encoded src (no cached src)
1.994 + srcFilePos += result.iSrcBytesProcessed;
1.995 + // set new dst file position
1.996 + dstFilePos += result.iDstBytesAdded;
1.997 + }
1.998 +
1.999 + TVerdict result = EPass;
1.1000 + if (CompareFileL(GetRefFileName(testNumber) ) != 0)
1.1001 + {
1.1002 + result = EFail;
1.1003 + }
1.1004 +
1.1005 + CleanupStack::PopAndDestroy(3); // dstBuffer, srcBuffer, codec
1.1006 + return result;
1.1007 + }
1.1008 +
1.1009 +/**
1.1010 + * This test tests changing configuration for the codec. It calls ConfigureL() once to
1.1011 + * encode one sbc bitstream, then changes a different configuration by calling ConfigureL()
1.1012 + * and encode another sbc bitstream.
1.1013 + * @return "TVerdict"
1.1014 + * EPass: if encoded sbc files are the same as the reference files.
1.1015 + * EFail: if not.
1.1016 + * @leave if ReadSourceL(), ProcessL() leaves
1.1017 + */
1.1018 +TVerdict CTestStep_MMF_SbcCodec::TestChangeConfigL()
1.1019 + {
1.1020 + //create codec from uid
1.1021 + CMMFCodec* codec = NULL;
1.1022 + TRAPD(err, codec = CMMFCodec::NewL(KSbcCodecPluginUid) );
1.1023 +
1.1024 + if (err != KErrNone)
1.1025 + {
1.1026 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestChangeConfigL Leave occurred in NewL, error code %d"), err);
1.1027 + return EFail;
1.1028 + }
1.1029 + if (!codec)
1.1030 + {
1.1031 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestChangeConfigL NewL returned NULL") );
1.1032 + return EFail;
1.1033 + }
1.1034 +
1.1035 + CleanupStack::PushL(codec);
1.1036 +
1.1037 + const TInt testNumber[2] = {1, 28};
1.1038 + // this size will make sure some samples will be cached,
1.1039 + // also make sure it is an EVEN number
1.1040 + const TInt srcBufSize = 4094;
1.1041 + const TInt dstBufSize = 2048;
1.1042 +
1.1043 + // create buffers
1.1044 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(srcBufSize);
1.1045 + CleanupStack::PushL(srcBuffer);
1.1046 + CMMFDataBuffer* dstBuffer = CMMFDataBuffer::NewL(dstBufSize);
1.1047 + CleanupStack::PushL(dstBuffer);
1.1048 +
1.1049 + TVerdict result = EPass;
1.1050 + for (TInt test = 0; test < 2; test++)
1.1051 + {
1.1052 + TSBCFrameParameters param = SbcParametersL(testNumber[test]);
1.1053 +
1.1054 + TPckgBuf<TSBCFrameParameters> config(param);
1.1055 + codec->ConfigureL(KSbcCodecConfigUid, config);
1.1056 + codec->ResetL();
1.1057 +
1.1058 + TInt srcFilePos = 0;
1.1059 + TInt dstFilePos = 0;
1.1060 +
1.1061 + for (;;)
1.1062 + {
1.1063 + ReadSourceL(GetTestFileName(testNumber[test]), srcBuffer->Data(), srcFilePos);
1.1064 +
1.1065 + if (srcBuffer->Data().Length() == 0) // end of file
1.1066 + {
1.1067 + break;
1.1068 + }
1.1069 +
1.1070 + TCodecProcessResult result = codec->ProcessL(*srcBuffer, *dstBuffer);
1.1071 +
1.1072 + WriteDstToFileL(GetRefFileName(testNumber[test]), dstBuffer->Data(), dstFilePos);
1.1073 +
1.1074 + srcBuffer->Data().Zero();
1.1075 + dstBuffer->Data().Zero();
1.1076 +
1.1077 + srcFilePos += result.iSrcBytesProcessed;
1.1078 + dstFilePos += result.iDstBytesAdded;
1.1079 + }
1.1080 +
1.1081 + if (CompareFileL(GetRefFileName(testNumber[test]) ) != 0)
1.1082 + {
1.1083 + result = EFail;
1.1084 + }
1.1085 + }
1.1086 +
1.1087 + CleanupStack::PopAndDestroy(3); // dstBuffer, srcBuffer, codec
1.1088 + return result;
1.1089 + }
1.1090 +
1.1091 +/**
1.1092 + * This tests memory scribble for ProcessL(). It creates a buffer size of frame_length + 2,
1.1093 + * the first byte and last byte are used to detect memory scribble,
1.1094 + * the middle frame_length bytes are used for destination buffer. It calls ProcessL() once.
1.1095 + * and checks if the first or last byte value changed to check memory scribble.
1.1096 + * @return "TVerdict"
1.1097 + * EPass: if there is no momery scribble.
1.1098 + * EFail: if there is momery scribble.
1.1099 + * @leave if ReadSourceL(), ProcessL() leaves
1.1100 + */
1.1101 +TVerdict CTestStep_MMF_SbcCodec::TestMemoryScribbleL()
1.1102 + {
1.1103 + //create codec from uid
1.1104 + CMMFCodec* codec = NULL;
1.1105 + TRAPD(err, codec = CMMFCodec::NewL(KSbcCodecPluginUid) );
1.1106 +
1.1107 + if (err != KErrNone)
1.1108 + {
1.1109 + ERR_PRINTF2(_L(">> CTestStep_MMF_SbcCodec::TestMemoryScribbleL Leave occurred in NewL, error code %d"), err);
1.1110 + return EFail;
1.1111 + }
1.1112 + if (!codec)
1.1113 + {
1.1114 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestMemoryScribbleL NewL returned NULL") );
1.1115 + return EFail;
1.1116 + }
1.1117 +
1.1118 + CleanupStack::PushL(codec);
1.1119 +
1.1120 + const TInt testNumber = 28;
1.1121 +
1.1122 + TSBCFrameParameters param = SbcParametersL(testNumber);
1.1123 +
1.1124 + TPckgBuf<TSBCFrameParameters> config(param);
1.1125 + codec->ConfigureL(KSbcCodecConfigUid, config);
1.1126 +
1.1127 + const TUint sbcFrameLength = param.CalcFrameLength();
1.1128 + const TUint pcmFrameSize = sizeof(TInt16) * param.BlockLength() * param.Channels() * param.Subbands();
1.1129 +
1.1130 + // create buffers
1.1131 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(pcmFrameSize);
1.1132 + CleanupStack::PushL(srcBuffer);
1.1133 +
1.1134 + // front and end bytes are used to detect memory scribble
1.1135 + CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(sbcFrameLength + 2);
1.1136 + CleanupStack::PushL(buffer);
1.1137 +
1.1138 + TUint8* firstByte = const_cast<TUint8*>(buffer->Data().Ptr() );
1.1139 + TUint8* lastByte = firstByte + sbcFrameLength + 1;
1.1140 +
1.1141 + const TUint8 initValue = 0xaa; // 10101010
1.1142 +
1.1143 + *firstByte = initValue;
1.1144 + *lastByte = initValue;
1.1145 +
1.1146 + CMMFPtrBuffer* dstBuffer = CMMFPtrBuffer::NewL(TPtr8(firstByte + 1, sbcFrameLength) );
1.1147 + CleanupStack::PushL(dstBuffer);
1.1148 +
1.1149 + ReadSourceL(GetTestFileName(testNumber), srcBuffer->Data(), 0);
1.1150 +
1.1151 + TVerdict testResult = EPass;
1.1152 + if (static_cast<TUint>(srcBuffer->Data().Length() ) == pcmFrameSize)
1.1153 + {
1.1154 + TCodecProcessResult result = codec->ProcessL(*srcBuffer, *dstBuffer);
1.1155 +
1.1156 + if (result.iSrcBytesProcessed != pcmFrameSize ||
1.1157 + result.iDstBytesAdded != sbcFrameLength ||
1.1158 + result.iStatus != TCodecProcessResult::EProcessComplete)
1.1159 + {
1.1160 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestMemoryScribbleL failed in ProcessL") );
1.1161 + testResult = EFail;
1.1162 + }
1.1163 +
1.1164 + if (*firstByte != initValue || *lastByte != initValue ) // memory been scribbled
1.1165 + {
1.1166 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestMemoryScribbleL memory scribble occured") );
1.1167 + testResult = EFail;
1.1168 + }
1.1169 + }
1.1170 + else
1.1171 + {
1.1172 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestMemoryScribbleL read source failed") );
1.1173 + testResult = EFail;
1.1174 + }
1.1175 +
1.1176 + CleanupStack::PopAndDestroy(4); // dstBuffer, buffer, srcBuffer, codec
1.1177 + return testResult;
1.1178 + }
1.1179 +
1.1180 +/**
1.1181 + * This tests all the codec APIs (here we are using TestRepositionL() test as it
1.1182 + * uses all the APIs) and checks if there is any memory leak, it panics if so.
1.1183 + * @return "TVerdict"
1.1184 + * EPass: if there is no momery leak.
1.1185 + * EFail: if there is momery leak.
1.1186 + * @leave if TestRepositionL() leaves
1.1187 + */
1.1188 +TVerdict CTestStep_MMF_SbcCodec::TestMemoryLeakL()
1.1189 + {
1.1190 + __MM_HEAP_MARK;
1.1191 +
1.1192 + TestRepositionL();
1.1193 +
1.1194 + __MM_HEAP_MARKEND;
1.1195 +
1.1196 + return EPass;
1.1197 + }
1.1198 +
1.1199 +/**
1.1200 + * This function tests how NewL deals with a memory allocation failure. This test
1.1201 + * will pass if NewL leaves with the correct error code on every memory allocation.
1.1202 + *
1.1203 + * @return "TVerdict"
1.1204 + * EPass: if the test passes.
1.1205 + * EFail: if the test fails.
1.1206 + */
1.1207 +TVerdict CTestStep_MMF_SbcCodec::TestNewLOutOfMemoryL()
1.1208 + {
1.1209 + TVerdict testResult = EPass;
1.1210 + TInt failCount = 1;
1.1211 +
1.1212 + for (;;)
1.1213 + {
1.1214 + __MM_HEAP_MARK;
1.1215 + __UHEAP_FAILNEXT(failCount);
1.1216 +
1.1217 + CMMFCodec* codec = NULL;
1.1218 + TRAPD(err, codec = CMMFCodec::NewL(KSbcCodecPluginUid) );
1.1219 +
1.1220 + // it should return either KErrNone or KErrNoMemory,
1.1221 + // ideally should only return KErrNone when codec is created.
1.1222 + if (err == KErrNone)
1.1223 + {
1.1224 + TAny *testAlloc = User::Alloc(1);
1.1225 +
1.1226 + delete codec;
1.1227 + if (testAlloc == NULL)
1.1228 + {
1.1229 + break;
1.1230 + }
1.1231 + User::Free(testAlloc);
1.1232 + }
1.1233 + else if (err != KErrNoMemory)
1.1234 + {
1.1235 + delete codec;
1.1236 + testResult = EFail;
1.1237 + break;
1.1238 + }
1.1239 +
1.1240 + failCount++;
1.1241 +
1.1242 + __UHEAP_RESET;
1.1243 + __MM_HEAP_MARKEND;
1.1244 + } // while(1)
1.1245 +
1.1246 + INFO_PRINTF2(_L("NewL out of memory test finished at round %d"), failCount);
1.1247 +
1.1248 + return testResult;
1.1249 + }
1.1250 +
1.1251 +/**
1.1252 + * This function tests how the ProcessL() would deal with a memory allocation failure.
1.1253 + * @return "TVerdict"
1.1254 + * EPass: if the test passes.
1.1255 + * EFail: if the test fails.
1.1256 + * @leave if out of memory or ConfigureL(), ReadSourceL leaves
1.1257 + */
1.1258 +TVerdict CTestStep_MMF_SbcCodec::TestProcessLOutOfMemoryL()
1.1259 + {
1.1260 + __MM_HEAP_MARK;
1.1261 +
1.1262 + CMMFCodec* codec = CMMFCodec::NewL(KSbcCodecPluginUid);
1.1263 + if (!codec)
1.1264 + {
1.1265 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessLOutOfMemoryL returned NULL") );
1.1266 + return EFail;
1.1267 + }
1.1268 +
1.1269 + CleanupStack::PushL(codec);
1.1270 +
1.1271 + const TInt testNumber = 28;
1.1272 + // this size will make sure some samples will be cached,
1.1273 + // also make sure it is an EVEN number
1.1274 + const TInt srcBufSize = 4094;
1.1275 + const TInt dstBufSize = 2048;
1.1276 +
1.1277 + TPckgBuf<TSBCFrameParameters> config(SbcParametersL(testNumber) );
1.1278 + codec->ConfigureL(KSbcCodecConfigUid, config);
1.1279 +
1.1280 + // create buffers
1.1281 + CMMFDataBuffer* srcBuffer = CMMFDataBuffer::NewL(srcBufSize);
1.1282 + CleanupStack::PushL(srcBuffer);
1.1283 + CMMFDataBuffer* dstBuffer = CMMFDataBuffer::NewL(dstBufSize);
1.1284 + CleanupStack::PushL(dstBuffer);
1.1285 +
1.1286 + ReadSourceL(GetTestFileName(testNumber), srcBuffer->Data(), 0);
1.1287 + if (srcBuffer->Data().Length() == 0) // end of file
1.1288 + {
1.1289 + ERR_PRINTF1(_L(">> CTestStep_MMF_SbcCodec::TestProcessLOutOfMemoryL no source read") );
1.1290 + return EFail;
1.1291 + }
1.1292 +
1.1293 + TVerdict testResult = EPass;
1.1294 + TInt failCount = 1;
1.1295 +
1.1296 + for (;;)
1.1297 + {
1.1298 + __UHEAP_FAILNEXT(failCount);
1.1299 +
1.1300 + TCodecProcessResult dummyResult; // don't care about this result
1.1301 + TRAPD(err, dummyResult = codec->ProcessL(*srcBuffer, *dstBuffer) );
1.1302 +
1.1303 + // it should return either KErrNone or KErrNoMemory,
1.1304 + // ideally should only return KErrNone when codec is created.
1.1305 + if (err == KErrNone)
1.1306 + {
1.1307 + // attempt to allocate another cell. If this fails,
1.1308 + // we have tested all of the memory allocs carried out by NewL.
1.1309 + TAny *testAlloc = User::Alloc(1);
1.1310 +
1.1311 + if (testAlloc == NULL)
1.1312 + {
1.1313 + break;
1.1314 + }
1.1315 + User::Free(testAlloc);
1.1316 + }
1.1317 + else if (err != KErrNoMemory)
1.1318 + {
1.1319 + testResult = EFail;
1.1320 + break;
1.1321 + }
1.1322 +
1.1323 + failCount++;
1.1324 +
1.1325 + __UHEAP_RESET;
1.1326 + } // while(1)
1.1327 +
1.1328 + INFO_PRINTF2(_L("ProcessL out of memory test finished at round %d"), failCount);
1.1329 +
1.1330 + CleanupStack::PopAndDestroy(3); // dstBuffer, srcBuffer, codec
1.1331 +
1.1332 + __MM_HEAP_MARKEND;
1.1333 +
1.1334 + return testResult;
1.1335 + }
1.1336 +
1.1337 +//------------------------------------------------------------------
1.1338 +// ** TEST MMF_SBCCODEC STEPS ***
1.1339 +//------------------------------------------------------------------
1.1340 +
1.1341 +/**
1.1342 + * Constructor
1.1343 + */
1.1344 +CTest_MMF_SbcCodec_U_001::CTest_MMF_SbcCodec_U_001()
1.1345 + {
1.1346 + iTestStepName = _L("MM-MMF-SbcCodec-U-001-HP");
1.1347 + }
1.1348 +
1.1349 +/**
1.1350 + * Instantiate a codec with plugin UID
1.1351 + * @test Req. under test REQ2716
1.1352 + */
1.1353 +TVerdict CTest_MMF_SbcCodec_U_001::DoTestStepL()
1.1354 + {
1.1355 + TVerdict testResult = EFail;
1.1356 + TRAPD(err, testResult = TestNewL(KSbcCodecPluginUid) );
1.1357 +
1.1358 + if (err)
1.1359 + {
1.1360 + INFO_PRINTF2(_L("Test left with status %d"), err);
1.1361 + }
1.1362 + return testResult;
1.1363 + }
1.1364 +
1.1365 +/**
1.1366 + * Constructor
1.1367 + */
1.1368 +CTest_MMF_SbcCodec_U_002::CTest_MMF_SbcCodec_U_002()
1.1369 + {
1.1370 + iTestStepName = _L("MM-MMF-SbcCodec-U-002-HP");
1.1371 + }
1.1372 +
1.1373 +/**
1.1374 + * Instantiate a codec with FourCC Codes
1.1375 + * @test Req. under test REQ2716
1.1376 + */
1.1377 +TVerdict CTest_MMF_SbcCodec_U_002::DoTestStepL()
1.1378 + {
1.1379 + TVerdict testResult = EFail;
1.1380 + TRAPD(err, testResult = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodeSBC) );
1.1381 +
1.1382 + if (err)
1.1383 + {
1.1384 + INFO_PRINTF2(_L("Test left with status %d"), err);
1.1385 + }
1.1386 + return testResult;
1.1387 + }
1.1388 +
1.1389 +/**
1.1390 + * Constructor
1.1391 + */
1.1392 +CTest_MMF_SbcCodec_U_010::CTest_MMF_SbcCodec_U_010()
1.1393 + {
1.1394 + iTestStepName = _L("MM-MMF-SbcCodec-U-010-HP");
1.1395 + }
1.1396 +
1.1397 +/**
1.1398 + * ProcessL() test
1.1399 + * This test tests the ProcessL() function with different buffer size settings, and
1.1400 + * check the returned results
1.1401 + * @test Req. under test REQ2716
1.1402 + */
1.1403 +TVerdict CTest_MMF_SbcCodec_U_010::DoTestStepL()
1.1404 + {
1.1405 + TVerdict testResult = EFail;
1.1406 + TRAPD(err, testResult = TestProcessL() );
1.1407 +
1.1408 + if (err)
1.1409 + {
1.1410 + INFO_PRINTF2(_L("Test left with status %d"), err);
1.1411 + }
1.1412 + return testResult;
1.1413 + }
1.1414 +
1.1415 +/**
1.1416 + * Constructor
1.1417 + */
1.1418 +CTest_MMF_SbcCodec_U_011::CTest_MMF_SbcCodec_U_011()
1.1419 + {
1.1420 + iTestStepName = _L("MM-MMF-SbcCodec-U-011-HP");
1.1421 + }
1.1422 +
1.1423 +/**
1.1424 + * Configuration tests
1.1425 + * This test tests if codec supports 8 different settings (see TSS & TP for A2DP spec)
1.1426 + * @test Req. under test REQ2716
1.1427 + */
1.1428 +TVerdict CTest_MMF_SbcCodec_U_011::DoTestStepL()
1.1429 + {
1.1430 + TVerdict testResult = EPass;
1.1431 + TInt srcBufSize = KDefaultBufferSize;
1.1432 + TInt dstBufSize = KDefaultBufferSize >> 1;
1.1433 +
1.1434 + for (TInt testNumber = 1; testNumber <= 8; testNumber++)
1.1435 + {
1.1436 + TVerdict result = EFail;
1.1437 +
1.1438 + TRAPD(err, result = TestEncodeL(testNumber, srcBufSize, dstBufSize) );
1.1439 +
1.1440 + if (err)
1.1441 + {
1.1442 + INFO_PRINTF3(_L("Configuration test %d left with status %d"), testNumber, err);
1.1443 + testResult = EFail;
1.1444 + }
1.1445 + if (result == EFail)
1.1446 + {
1.1447 + INFO_PRINTF2(_L("Configuration test %d failed"), testNumber);
1.1448 + testResult = EFail;
1.1449 + }
1.1450 +
1.1451 + // This is simulating different src buffer size by decreasing the
1.1452 + // src buffer size number each time, it covers sample caching and
1.1453 + // no caching various cases to make sure the codec can handle different
1.1454 + // src buffer size correctly
1.1455 + srcBufSize--;
1.1456 + }
1.1457 + return testResult;
1.1458 + }
1.1459 +
1.1460 +/**
1.1461 + * Constructor
1.1462 + */
1.1463 +CTest_MMF_SbcCodec_U_012::CTest_MMF_SbcCodec_U_012()
1.1464 + {
1.1465 + iTestStepName = _L("MM-MMF-SbcCodec-U-012-HP");
1.1466 + }
1.1467 +
1.1468 +/**
1.1469 + * Maximum Bit Rate tests
1.1470 + * This test tests sbc coded handles 8 different maximum bit rate settings (see TSS & TP for A2DP spec)
1.1471 + * @test Req. under test REQ2716
1.1472 + */
1.1473 +TVerdict CTest_MMF_SbcCodec_U_012::DoTestStepL()
1.1474 + {
1.1475 + TVerdict testResult = EPass;
1.1476 + TInt srcBufSize = KDefaultBufferSize;
1.1477 + TInt dstBufSize = KDefaultBufferSize >> 1;
1.1478 +
1.1479 + for (TInt testNumber = 11; testNumber <= 18; testNumber++)
1.1480 + {
1.1481 + TVerdict result = EFail;
1.1482 + TRAPD(err, result = TestEncodeL(testNumber, srcBufSize, dstBufSize) );
1.1483 +
1.1484 + if (err)
1.1485 + {
1.1486 + INFO_PRINTF3(_L("Max Bit Rate test %d left with status %d"), testNumber, err);
1.1487 + testResult = EFail;
1.1488 + }
1.1489 + if (result == EFail)
1.1490 + {
1.1491 + INFO_PRINTF2(_L("Max Bit Rate test %d failed"), testNumber);
1.1492 + testResult = EFail;
1.1493 + }
1.1494 +
1.1495 + // This is simulating different src buffer size by decreasing the
1.1496 + // src buffer size number each time, it covers sample caching and
1.1497 + // no caching various cases to make sure the codec can handle different
1.1498 + // src buffer size correctly
1.1499 + srcBufSize--;
1.1500 + }
1.1501 + return testResult;
1.1502 + }
1.1503 +
1.1504 +/**
1.1505 + * Constructor
1.1506 + */
1.1507 +CTest_MMF_SbcCodec_U_013::CTest_MMF_SbcCodec_U_013()
1.1508 + {
1.1509 + iTestStepName = _L("MM-MMF-SbcCodec-U-013-HP");
1.1510 + }
1.1511 +
1.1512 +/**
1.1513 + * Special tests
1.1514 + * This test tests sbc codec handles 2 special cases (see TSS & TP for A2DP spec)
1.1515 + * @test Req. under test REQ2716
1.1516 + */
1.1517 +TVerdict CTest_MMF_SbcCodec_U_013::DoTestStepL()
1.1518 + {
1.1519 + TVerdict testResult = EPass;
1.1520 + TInt srcBufSize = KDefaultBufferSize;
1.1521 + TInt dstBufSize = KDefaultBufferSize >> 1;
1.1522 +
1.1523 + for (TInt testNumber = 19; testNumber <= 20; testNumber++)
1.1524 + {
1.1525 + TVerdict result = EFail;
1.1526 + TRAPD(err, result = TestEncodeL(testNumber, srcBufSize, dstBufSize) );
1.1527 +
1.1528 + if (err)
1.1529 + {
1.1530 + INFO_PRINTF3(_L("Special test %d left with status %d"), testNumber, err);
1.1531 + testResult = EFail;
1.1532 + }
1.1533 + if (result == EFail)
1.1534 + {
1.1535 + INFO_PRINTF2(_L("Special test %d failed"), testNumber);
1.1536 + testResult = EFail;
1.1537 + }
1.1538 +
1.1539 + // This is simulating different src buffer size by decreasing the
1.1540 + // src buffer size number each time, it covers sample caching and
1.1541 + // no caching various cases to make sure the codec can handle different
1.1542 + // src buffer size correctly
1.1543 + srcBufSize--;
1.1544 + }
1.1545 + return testResult;
1.1546 + }
1.1547 +
1.1548 +/**
1.1549 + * Constructor
1.1550 + */
1.1551 +CTest_MMF_SbcCodec_U_014::CTest_MMF_SbcCodec_U_014()
1.1552 + {
1.1553 + iTestStepName = _L("MM-MMF-SbcCodec-U-014-HP");
1.1554 + }
1.1555 +
1.1556 +/**
1.1557 + * Typical tests
1.1558 + * This test tests sbc codec handles 8 typical settings (see TSS & TP for A2DP spec) which
1.1559 + * are required in REQ2716, our sbc encoder has to support these settings.
1.1560 + * @test Req. under test REQ2716
1.1561 + */
1.1562 +TVerdict CTest_MMF_SbcCodec_U_014::DoTestStepL()
1.1563 + {
1.1564 + TVerdict testResult = EPass;
1.1565 + TInt srcBufSize = KDefaultBufferSize;
1.1566 + TInt dstBufSize = KDefaultBufferSize >> 1;
1.1567 +
1.1568 + for (TInt testNumber = 21; testNumber <= 28; testNumber++)
1.1569 + {
1.1570 + TVerdict result = EFail;
1.1571 + TRAPD(err, result = TestEncodeL(testNumber, srcBufSize, dstBufSize) );
1.1572 +
1.1573 + if (err)
1.1574 + {
1.1575 + INFO_PRINTF3(_L("Typical test %d left with status %d"), testNumber, err);
1.1576 + testResult = EFail;
1.1577 + }
1.1578 + if (result == EFail)
1.1579 + {
1.1580 + INFO_PRINTF2(_L("Typical test %d failed"), testNumber);
1.1581 + testResult = EFail;
1.1582 + }
1.1583 +
1.1584 + // This is simulating different src buffer size by decreasing the
1.1585 + // src buffer size number each time, it covers sample caching and
1.1586 + // no caching various cases to make sure the codec can handle different
1.1587 + // src buffer size correctly
1.1588 + srcBufSize--;
1.1589 + }
1.1590 + return testResult;
1.1591 + }
1.1592 +
1.1593 +/**
1.1594 + * Constructor
1.1595 + */
1.1596 +CTest_MMF_SbcCodec_U_015::CTest_MMF_SbcCodec_U_015()
1.1597 + {
1.1598 + iTestStepName = _L("MM-MMF-SbcCodec-U-015-HP");
1.1599 + }
1.1600 +
1.1601 +/**
1.1602 + * Reposition tests
1.1603 + * This test tests ResetL() function and audio sample cach issue
1.1604 + * @test Req. under test REQ2716
1.1605 + */
1.1606 +TVerdict CTest_MMF_SbcCodec_U_015::DoTestStepL()
1.1607 + {
1.1608 + TVerdict testResult = EFail;
1.1609 + TRAPD(err, testResult = TestRepositionL() );
1.1610 +
1.1611 + if (err)
1.1612 + {
1.1613 + INFO_PRINTF2(_L("Reposition test left with status %d"), err);
1.1614 + testResult = EFail;
1.1615 + }
1.1616 + else
1.1617 + {
1.1618 + INFO_PRINTF1(_L("Reposition test passes") );
1.1619 + }
1.1620 +
1.1621 + return testResult;
1.1622 + }
1.1623 +
1.1624 +/**
1.1625 + * Constructor
1.1626 + */
1.1627 +CTest_MMF_SbcCodec_U_016::CTest_MMF_SbcCodec_U_016()
1.1628 + {
1.1629 + iTestStepName = _L("MM-MMF-SbcCodec-U-016-HP");
1.1630 + }
1.1631 +
1.1632 +/**
1.1633 + * Change configuration test
1.1634 + * This test tests reconfigure sbc codec by calling ConfigureL() function
1.1635 + * @test Req. under test REQ2716
1.1636 + */
1.1637 +TVerdict CTest_MMF_SbcCodec_U_016::DoTestStepL()
1.1638 + {
1.1639 + TVerdict testResult = EFail;
1.1640 + TRAPD(err, testResult = TestChangeConfigL() );
1.1641 +
1.1642 + if (err)
1.1643 + {
1.1644 + INFO_PRINTF2(_L("Change conguration test left with status %d"), err);
1.1645 + testResult = EFail;
1.1646 + }
1.1647 + else
1.1648 + {
1.1649 + INFO_PRINTF1(_L("Change conguration test passes") );
1.1650 + }
1.1651 +
1.1652 + return testResult;
1.1653 + }
1.1654 +
1.1655 +/**
1.1656 + * Constructor
1.1657 + */
1.1658 +CTest_MMF_SbcCodec_U_021::CTest_MMF_SbcCodec_U_021()
1.1659 + {
1.1660 + iTestStepName = _L("MM-MMF-SbcCodec-U-021-HP");
1.1661 + }
1.1662 +
1.1663 +/**
1.1664 + * Memory Scribble test
1.1665 + * @test Req. under test REQ2716
1.1666 + */
1.1667 +TVerdict CTest_MMF_SbcCodec_U_021::DoTestStepL()
1.1668 + {
1.1669 + TVerdict testResult = EPass;
1.1670 +
1.1671 + TRAPD(err, testResult = TestMemoryScribbleL() );
1.1672 +
1.1673 + if (err)
1.1674 + {
1.1675 + INFO_PRINTF2(_L("Memory scribble test left with status %d"), err);
1.1676 + testResult = EFail;
1.1677 + }
1.1678 + else
1.1679 + {
1.1680 + INFO_PRINTF1(_L("Memory scribble test passes") );
1.1681 + }
1.1682 +
1.1683 + return testResult;
1.1684 + }
1.1685 +
1.1686 +/**
1.1687 + * Constructor
1.1688 + */
1.1689 +CTest_MMF_SbcCodec_U_022::CTest_MMF_SbcCodec_U_022()
1.1690 + {
1.1691 + iTestStepName = _L("MM-MMF-SbcCodec-U-022-HP");
1.1692 + }
1.1693 +
1.1694 +/**
1.1695 + * Memory Leak test
1.1696 + * @test Req. under test REQ2716
1.1697 + */
1.1698 +TVerdict CTest_MMF_SbcCodec_U_022::DoTestStepL()
1.1699 + {
1.1700 + TVerdict testResult = EPass;
1.1701 +
1.1702 + TRAPD(err, testResult = TestMemoryLeakL() );
1.1703 +
1.1704 + if (err)
1.1705 + {
1.1706 + INFO_PRINTF2(_L("Memory leak test left with status %d"), err);
1.1707 + testResult = EFail;
1.1708 + }
1.1709 + else
1.1710 + {
1.1711 + INFO_PRINTF1(_L("Memory leak test passes") );
1.1712 + }
1.1713 +
1.1714 + return testResult;
1.1715 + }
1.1716 +
1.1717 +/**
1.1718 + * Constructor
1.1719 + */
1.1720 +CTest_MMF_SbcCodec_U_023::CTest_MMF_SbcCodec_U_023()
1.1721 + {
1.1722 + iTestStepName = _L("MM-MMF-SbcCodec-U-023-HP");
1.1723 + }
1.1724 +
1.1725 +/**
1.1726 + * Out of Memory test for NewL()
1.1727 + * @test Req. under test REQ2716
1.1728 + */
1.1729 +TVerdict CTest_MMF_SbcCodec_U_023::DoTestStepL()
1.1730 + {
1.1731 + TVerdict testResult = EPass;
1.1732 +
1.1733 + TRAPD(err, testResult = TestNewLOutOfMemoryL() );
1.1734 +
1.1735 + if (err)
1.1736 + {
1.1737 + INFO_PRINTF2(_L("NewL out of memory test left with status %d"), err);
1.1738 + testResult = EFail;
1.1739 + }
1.1740 + else
1.1741 + {
1.1742 + INFO_PRINTF1(_L("NewL out of memory test passes") );
1.1743 + }
1.1744 +
1.1745 + return testResult;
1.1746 + }
1.1747 +
1.1748 +/**
1.1749 + * Constructor
1.1750 + */
1.1751 +CTest_MMF_SbcCodec_U_024::CTest_MMF_SbcCodec_U_024()
1.1752 + {
1.1753 + iTestStepName = _L("MM-MMF-SbcCodec-U-024-HP");
1.1754 + }
1.1755 +
1.1756 +/**
1.1757 + * Out of Memory test for ProcessL()
1.1758 + * @test Req. under test REQ2716
1.1759 + */
1.1760 +TVerdict CTest_MMF_SbcCodec_U_024::DoTestStepL()
1.1761 + {
1.1762 + TVerdict testResult = EPass;
1.1763 +
1.1764 + TRAPD(err, testResult = TestProcessLOutOfMemoryL() );
1.1765 +
1.1766 + if (err)
1.1767 + {
1.1768 + INFO_PRINTF2(_L("ProcessL out of memory test left with status %d"), err);
1.1769 + testResult = EFail;
1.1770 + }
1.1771 + else
1.1772 + {
1.1773 + INFO_PRINTF1(_L("ProcessL out of memory test passes") );
1.1774 + }
1.1775 +
1.1776 + return testResult;
1.1777 + }