Symaptic: os/mm/mmapitest/devsoundexthaitest/src/T_CMMFDevSoundData.cpp@260cb5ec6c19

     1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    20 #include "t_cmmfdevsounddata.h"

    22 /*@{*/

    23 //Constants for HwDevice

    24 const TInt KHwDeviceDefaultDataLength = 9;

    25 const TInt KFourCCLength = 4;

    26 //Supported Input Data Types

    27 const TInt KFourCCMaxBitDisplacement = 24;

    28 const TInt K8Bits = 8;

    29 const TInt KTFourCC = 4;

    30 /*@}*/

    32 /*@{*/

    33 //Command literals

    34 _LIT(KCmdNewL,                         "NewL");

    35 _LIT(KCmdNewLLoopL,                    "NewLLoopL");

    36 _LIT(KCmdDestructor,                   "~");

    37 _LIT(KCmdCapabilities,                 "Capabilities");

    38 _LIT(KCmdConfig,                       "Config");

    39 _LIT(KCmdMaxGain,                      "MaxGain");

    40 _LIT(KCmdMaxVolume,                    "MaxVolume");

    41 _LIT(KCmdGetPlayBalanceL,              "GetPlayBalanceL");

    42 _LIT(KCmdGetRecordBalanceL,            "GetRecordBalanceL");

    43 _LIT(KCmdGetSupportedInputDataTypesL,  "GetSupportedInputDataTypesL");

    44 _LIT(KCmdGetSupportedOutputDataTypesL, "GetSupportedOutputDataTypesL");

    45 _LIT(KCmdSamplesPlayed,                "SamplesPlayed");

    46 _LIT(KCmdSamplesRecorded,              "SamplesRecorded");

    47 _LIT(KCmdVolume,                       "Volume");

    48 _LIT(KCmdGain,                         "Gain");

    49 _LIT(KCmdFixedSequenceCount,           "FixedSequenceCount");

    50 _LIT(KCmdFixedSequenceName,            "FixedSequenceName");

    51 _LIT(KCmdSetConfigL,                   "SetConfigL");

    52 _LIT(KCmdSetDTMFLengths,               "SetDTMFLengths");

    53 _LIT(KCmdSetGain,                      "SetGain");

    54 _LIT(KCmdSetPlayBalanceL,              "SetPlayBalanceL");

    55 _LIT(KCmdSetPrioritySettings,          "SetPrioritySettings");

    56 _LIT(KCmdSetRecordBalanceL,            "SetRecordBalanceL");

    57 _LIT(KCmdSetToneRepeats,               "SetToneRepeats");

    58 _LIT(KCmdSetVolume,                    "SetVolume");

    59 _LIT(KCmdSetVolumeRamp,                "SetVolumeRamp");

    60 _LIT(KCmdInitializeL,                  "InitializeL");

    61 _LIT(KCmdPlayDTMFStringL,              "PlayDTMFStringL");

    62 _LIT(KCmdPlayData,                     "PlayData");

    63 _LIT(KCmdPlayDualToneL,                "PlayDualToneL");

    64 _LIT(KCmdPlayInitL,                    "PlayInitL");

    65 _LIT(KCmdPlayToneL,                    "PlayToneL");

    66 _LIT(KCmdPlayToneSequenceL,            "PlayToneSequenceL");

    67 _LIT(KCmdRecordData,                   "RecordData");

    68 _LIT(KCmdRecordInitL,                  "RecordInitL");

    69 _LIT(KCmdStop,                         "Stop");

    70 _LIT(KCmdErrorConceal,                 "ErrorConceal");

    71 _LIT(KCmdSetVolumeLoop,                "SetVolumeLoop");

    72 /*@}*/

    74 /*@{*/

    75 //Utility literals

    76 _LIT(KCmdUtilityReplaceFile,                  "ReplaceFile");

    77 _LIT(KCmdUtilityOpenFile,                     "OpenFile");

    78 _LIT(KCmdUtilityCloseFile,                    "CloseFile");

    79 _LIT(KCmdUtilityFileStartPosition,            "FileStartPosition");

    80 /*@}*/

    82 /*@{*/

    83 //INI Section name literals

    84 _LIT(KGainValue,                       "Gain");

    85 _LIT(KVolumeValue,                     "Volume");

    86 _LIT(KLeftPercentage,                  "LeftPercentage");

    87 _LIT(KRightPercentage,                 "RightPercentage");

    88 _LIT(KSequenceNumber,                  "SequenceNumber");

    89 _LIT(KRate,                            "Rate");

    90 _LIT(KEncoding,                        "Encoding");

    91 _LIT(KChannels,                        "Channels");

    92 _LIT(KBufferSize,                      "BufferSize");

    93 _LIT(KToneOnLength,                    "ToneOnLength");

    94 _LIT(KToneOffLength,                   "ToneOffLength");

    95 _LIT(KPause,                           "Pause");

    96 _LIT(KPauseLength,                     "PauseLength");

    97 _LIT(KPriority,                        "Priority");

    98 _LIT(KPreference,                      "Preference");

    99 _LIT(KPriorityState,                   "PriorityState");

   100 _LIT(KRepeatCount,                     "RepeatCount");

   101 _LIT(KRepeatTrailingSilence,           "RepeatTrailingSilence");

   102 _LIT(KRampDuration,                    "RampDuration");

   103 _LIT(KMode,                            "Mode");

   104 _LIT(KHwDevice,                        "HwDevice");

   105 _LIT(KFourCC,                          "FourCC");

   106 _LIT(KFilename,                        "Filename");

   107 _LIT(KDTMFString,                      "DTMFString");

   108 _LIT(KFrequency,                       "Frequency");

   109 _LIT(KFrequencyOne,                    "FrequencyOne");

   110 _LIT(KFrequencyTwo,                    "FrequencyTwo");

   111 _LIT(KDuration,                        "Duration");

   112 _LIT(KLoop,                            "Loop");

   113 _LIT(KAllowedError,                    "AllowedError");

   114 _LIT(KVolumeList,                      "VolumeList");

   115 _LIT(KVolumeLoop,                      "VolumeLoop");

   116 /*@}*/

   118 /*@{*/

   119 //Literals for iEnumChannels

   120 _LIT(KEMMFStereo, "EMMFStereo");

   121 _LIT(KEMMFMono,   "EMMFMono");

   122 /*@}*/

   124 const CDataWrapperBase::TEnumEntryTable CT_CMMFDevSoundData::iEnumChannels[] =

   125 	{

   126 	{KEMMFMono,   EMMFMono},

   127 	{KEMMFStereo, EMMFStereo}

   128 	};

   130 /*@{*/

   131 //Literals for iEnumSampleRate

   132 _LIT(KEMMFSampleRate8000Hz,  "EMMFSampleRate8000Hz");

   133 _LIT(KEMMFSampleRate11025Hz, "EMMFSampleRate11025Hz");

   134 _LIT(KEMMFSampleRate16000Hz, "EMMFSampleRate16000Hz");

   135 _LIT(KEMMFSampleRate22050Hz, "EMMFSampleRate22050Hz");

   136 _LIT(KEMMFSampleRate32000Hz, "EMMFSampleRate32000Hz");

   137 _LIT(KEMMFSampleRate44100Hz, "EMMFSampleRate44100Hz");

   138 _LIT(KEMMFSampleRate48000Hz, "EMMFSampleRate48000Hz");

   139 _LIT(KEMMFSampleRate88200Hz, "EMMFSampleRate88200Hz");

   140 _LIT(KEMMFSampleRate96000Hz, "EMMFSampleRate96000Hz");

   141 _LIT(KEMMFSampleRate12000Hz, "EMMFSampleRate12000Hz");

   142 _LIT(KEMMFSampleRate24000Hz, "EMMFSampleRate24000Hz");

   143 _LIT(KEMMFSampleRate64000Hz, "EMMFSampleRate64000Hz");

   144 /*@}*/

   146 const CDataWrapperBase::TEnumEntryTable CT_CMMFDevSoundData::iEnumSampleRate[] =

   147 	{

   148 	{KEMMFSampleRate8000Hz,  EMMFSampleRate8000Hz},

   149 	{KEMMFSampleRate11025Hz, EMMFSampleRate11025Hz},

   150 	{KEMMFSampleRate16000Hz, EMMFSampleRate16000Hz},

   151 	{KEMMFSampleRate22050Hz, EMMFSampleRate22050Hz},

   152 	{KEMMFSampleRate32000Hz, EMMFSampleRate32000Hz},

   153 	{KEMMFSampleRate44100Hz, EMMFSampleRate44100Hz},

   154 	{KEMMFSampleRate48000Hz, EMMFSampleRate48000Hz},

   155 	{KEMMFSampleRate88200Hz, EMMFSampleRate88200Hz},

   156 	{KEMMFSampleRate96000Hz, EMMFSampleRate96000Hz},

   157 	{KEMMFSampleRate12000Hz, EMMFSampleRate12000Hz},

   158 	{KEMMFSampleRate24000Hz, EMMFSampleRate24000Hz},

   159 	{KEMMFSampleRate64000Hz, EMMFSampleRate64000Hz}

   160 	};

   162 /*@{*/

   163 //Literal for iEnumMode

   164 _LIT(KEMMFStateIdle,             "EMMFStateIdle");

   165 _LIT(KEMMFStatePlaying,          "EMMFStatePlaying");

   166 _LIT(KEMMFStateTonePlaying,      "EMMFStateTonePlaying");

   167 _LIT(KEMMFStateRecording,        "EMMFStateRecording");

   168 _LIT(KEMMFStatePlayingRecording, "EMMFStatePlayingRecording");

   169 _LIT(KEMMFStateConverting,       "EMMFStateConverting");

   170 /*@}*/

   172 const CDataWrapperBase::TEnumEntryTable CT_CMMFDevSoundData::iEnumMode[] =

   173 	{

   174 	{KEMMFStateIdle,             EMMFStateIdle},

   175 	{KEMMFStatePlaying,          EMMFStatePlaying},

   176 	{KEMMFStateRecording,        EMMFStateRecording},

   177 	{KEMMFStateTonePlaying,      EMMFStateTonePlaying},

   178 	{KEMMFStatePlayingRecording, EMMFStatePlayingRecording},

   179 	{KEMMFStateConverting,       EMMFStateConverting}

   180 	};

   182 /*@{*/

   183 //Literals for iEnumInitializeLType

   184 _LIT(KEInitializeState,          "EInitializeState");

   185 _LIT(KEInitializeHwDeviceMode,   "EInitializeHwDeviceMode");

   186 _LIT(KEInitializeFourCCMode,     "EInitializeFourCCMode");

   187 /*@}*/

   189 enum TMMFInitializeMode

   190 	{

   191 	EInitializeState,

   192 	EInitializeHwDeviceMode,

   193 	EInitializeFourCCMode

   194 	};

   196 const CDataWrapperBase::TEnumEntryTable CT_CMMFDevSoundData::iEnumInitializeLType[] =

   197 	{

   198 	{KEInitializeState,        EInitializeState},

   199 	{KEInitializeHwDeviceMode, EInitializeHwDeviceMode},

   200 	{KEInitializeFourCCMode,   EInitializeFourCCMode}

   201 	};

   203 /**

   204  * Two phase constructor

   205  *

   206  * @leave   system wide error

   207  */

   208 CT_CMMFDevSoundData* CT_CMMFDevSoundData::NewL()

   209 	{

   210 	CT_CMMFDevSoundData* ret = new (ELeave) CT_CMMFDevSoundData();

   211 	CleanupStack::PushL(ret);

   212 	ret->ConstructL();

   213 	CleanupStack::Pop(ret);

   214 	return ret;

   215 	}

   217 /**

   218  * Private constructor. First phase construction

   219  */

   220 CT_CMMFDevSoundData::CT_CMMFDevSoundData()

   221 	:

   222 	iDevSound(NULL),

   223 	iPrioritySettings(),

   224 	iCapabilities(),

   225 	iVolumeValue(0),

   226 	iGainValue(0),

   227 	iLeftPercentage(0),

   228 	iRightPercentage(0),

   229 	iFs(),

   230 	iToneFile(),

   231 	iAudiofile(),

   232 	iBuffer(NULL),

   233 	iLastSample(0),

   234 	iPaused(EFalse),

   235 	iErrorConceal(EFalse),

   236 	iEndFile(EFalse),

   237 	iToneSequence(),

   238 	iInitializeCompleteError(0),

   239 	iToneFinishedError(0),

   240 	iBufferToBeFilledError(0),

   241 	iPlayErrorError(0),

   242 	iBufferToBeEmptiedError(0),

   243 	iRecordErrorError(0),

   244 	iConvertErrorError(0),

   245 	iDeviceMessageError(0),

   246 	iUtilityFourCCToHwDeviceUidLError(0),

   247     iAsyncErrorIndex_initialize(0),

   248     iAsyncErrorIndex_play(0),

   249     iAsyncErrorIndex_record(0),

   250     iAsyncErrorIndex_tone(0)

   252 	{

   253 	}

   255 /**

   256  * Second phase construction

   257  * @internalComponent

   258  * @return  N/A

   259  * @pre     None

   260  * @post    None

   261  * @leave   system wide error

   262  */

   263 void CT_CMMFDevSoundData::ConstructL()

   264 	{

   265 	iFs.Connect();

   266 	}

   268 /**

   269  * Public destructor

   270  */

   271 CT_CMMFDevSoundData::~CT_CMMFDevSoundData()

   272 	{

   273 	iFs.Close();

   274 	DestroyData();

   275 	}

   277 /**

   278  * Helper Destructor

   279  */

   280 void CT_CMMFDevSoundData::DestroyData()

   281 	{

   282 		INFO_PRINTF1(_L("*START* CT_CMMFDevSoundData::DestroyData()"));

   283 	if(iDevSound)

   284 		{

   285 			INFO_PRINTF1(_L("Delete DevSound object."));

   286 		delete iDevSound;

   287 		iDevSound = NULL;

   288 		}

   289 			INFO_PRINTF1(_L("*START* CT_CMMFDevSoundData::DestroyData()"));

   290 	}

   292 /**

   293  * Return a pointer to the object that the data wraps

   294  *

   295  * @return  pointer to the object that the data wraps

   296  */

   297 TAny* CT_CMMFDevSoundData::GetObject()

   298 	{

   299 	return iDevSound;

   300 	}

   302 /**

   303  * Process a command read from the Ini file

   304  * @param aCommand          - The command to process

   305  * @param aSection          - The section get from the *.ini file of the project T_Wlan

   306  * @param aAsyncErrorIndex  - Command index dor async calls to returns errors to

   307  * @return TBool            - ETrue if the command is process

   308  * @leave                   - system wide error

   309  */

   310 TBool CT_CMMFDevSoundData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

   311 	{

   312 	TBool ret = ETrue;

   314 	if (aCommand == KCmdNewL)

   315 		{

   316 		DoCmdNewL();

   317 		}

   318 	else if(aCommand == KCmdNewLLoopL)

   319 		{

   320 		DoCmdNewLLoopL(aSection);

   321 		}

   322 	else if (aCommand == KCmdDestructor)

   323 		{

   324 		DoCmdDestructor();

   325 		}

   326 	else if (aCommand == KCmdUtilityReplaceFile)

   327 		{

   328 		DoCmdUtilityReplaceFile(aSection);

   329 		}

   330 	else if (aCommand == KCmdUtilityOpenFile)

   331 		{

   332 		DoCmdUtilityOpenFile(aSection);

   333 		}

   334 	else if (aCommand == KCmdUtilityCloseFile)

   335 		{

   336 		DoCmdUtilityCloseFile();

   337 		}

   338 	else if (aCommand == KCmdUtilityFileStartPosition)

   339 		{

   340 		DoCmdUtilityFileStartPosition();

   341 		}

   342 	else if (aCommand == KCmdCapabilities)

   343 		{

   344 		DoCmdCapabilities();

   345 		}

   346 	else if (aCommand == KCmdConfig)

   347 		{

   348 		DoCmdConfig();

   349 		}

   350 	else if (aCommand == KCmdMaxGain)

   351 		{

   352 		DoCmdMaxGain(aSection);

   353 		}

   354 	else if (aCommand == KCmdMaxVolume)

   355 		{

   356 		DoCmdMaxVolume(aSection);

   357 		}

   358 	else if (aCommand == KCmdGetPlayBalanceL)

   359 		{

   360 		DoCmdGetPlayBalanceL(aSection);

   361 		}

   362 	else if (aCommand == KCmdGetRecordBalanceL)

   363 		{

   364 		DoCmdGetRecordBalanceL(aSection);

   365 		}

   366 	else if (aCommand == KCmdGetSupportedInputDataTypesL)

   367 		{

   368 		DoCmdGetSupportedInputDataTypesL();

   369 		}

   370 	else if (aCommand == KCmdGetSupportedOutputDataTypesL)

   371 		{

   372 		DoCmdGetSupportedOutputDataTypesL();

   373 		}

   374 	else if (aCommand == KCmdSamplesPlayed)

   375 		{

   376 		DoCmdSamplesPlayed();

   377 		}

   378 	else if (aCommand == KCmdSamplesRecorded)

   379 		{

   380 		DoCmdSamplesRecorded();

   381 		}

   382 	else if (aCommand == KCmdVolume)

   383 		{

   384 		DoCmdVolume(aSection);

   385 		}

   386 	else if (aCommand == KCmdGain)

   387 		{

   388 		DoCmdGain(aSection);

   389 		}

   390 	else if (aCommand == KCmdFixedSequenceCount)

   391 		{

   392 		DoCmdFixedSequenceCount();

   393 		}

   394 	else if (aCommand == KCmdFixedSequenceName)

   395 		{

   396 		DoCmdFixedSequenceName(aSection);

   397 		}

   398 	else if (aCommand == KCmdSetConfigL)

   399 		{

   400 		DoCmdSetConfigL(aSection);

   401 		}

   402 	else if (aCommand == KCmdSetDTMFLengths)

   403 		{

   404 		DoCmdSetDTMFLengths(aSection);

   405 		}

   406 	else if (aCommand == KCmdSetGain)

   407 		{

   408 		DoCmdSetGain(aSection);

   409 		}

   410 	else if (aCommand == KCmdSetPlayBalanceL)

   411 		{

   412 		DoCmdSetPlayBalanceL(aSection);

   413 		}

   414 	else if (aCommand == KCmdSetPrioritySettings)

   415 		{

   416 		DoCmdSetPrioritySettings(aSection);

   417 		}

   418 	else if (aCommand == KCmdSetRecordBalanceL)

   419 		{

   420 		DoCmdSetRecordBalanceL(aSection);

   421 		}

   422 	else if (aCommand == KCmdSetToneRepeats)

   423 		{

   424 		DoCmdSetToneRepeats(aSection);

   425 		}

   426 	else if (aCommand == KCmdSetVolume)

   427 		{

   428 		DoCmdSetVolume(aSection);

   429 		}

   430 	else if (aCommand == KCmdSetVolumeLoop)

   431 		{

   432 		DoCmdSetVolumeLoop(aSection);

   433 		}

   434 	else if (aCommand == KCmdSetVolumeRamp)

   435 		{

   436 		DoCmdSetVolumeRamp(aSection);

   437 		}

   438 	else if (aCommand == KCmdInitializeL)

   439 		{

   440 		DoCmdInitializeL(aSection, aAsyncErrorIndex);

   441 		}

   442 	else if (aCommand == KCmdPlayDTMFStringL)

   443 		{

   444 		DoCmdPlayDTMFStringL(aSection, aAsyncErrorIndex);

   445 		}

   446 	else if (aCommand == KCmdPlayData)

   447 		{

   448 		DoCmdPlayData();

   449 		}

   450 	else if (aCommand == KCmdPlayDualToneL)

   451 		{

   452 		DoCmdPlayDualToneL(aSection);

   453 		}

   454 	else if (aCommand == KCmdPlayInitL)

   455 		{

   456 		DoCmdPlayInitL(aAsyncErrorIndex);

   457 		}

   458 	else if (aCommand == KCmdPlayToneL)

   459 		{

   460 		DoCmdPlayToneL(aSection, aAsyncErrorIndex);

   461 		}

   462 	else if (aCommand == KCmdPlayToneSequenceL)

   463 		{

   464 		DoCmdPlayToneSequenceL(aSection, aAsyncErrorIndex);

   465 		}

   466 	else if (aCommand == KCmdRecordData)

   467 		{

   468 		DoCmdRecordData();

   469 		}

   470 	else if (aCommand == KCmdRecordInitL)

   471 		{

   472 		DoCmdRecordInitL(aAsyncErrorIndex);

   473 		}

   474 	else if (aCommand == KCmdStop)

   475 		{

   476 		DoCmdStop(aSection);

   477 		}

   478 	else if(aCommand == KCmdErrorConceal)

   479 		{

   480 		DoCmdUtilityErrorConceal();

   481 		}

   482 	else

   483 		{

   484 		ERR_PRINTF1(_L("Unknown command."));

   485 		ret=EFalse;

   486 		}

   487 	return ret;

   488 	}

   490 /**

   491  * Handles initialization completion event.

   492  * CMMFDevSound object calls this function when its InitializeL() function

   493  * completes.

   494  * @param  aError - Error code. KErrNone if successful. Other values are possible

   495  *                  indicating a problem initializing CMMFDevSound object.

   496  * @return void

   497  */

   499 void CT_CMMFDevSoundData::InitializeComplete(TInt aError)

   500 	{

   501 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::InitializeComplete"));

   502 	if(KErrNone != aError)

   503 		{

   504 		ERR_PRINTF2(_L("InitializeComplete callback failed with error %d"), aError);

   505         SetAsyncError(iAsyncErrorIndex_initialize, aError);

   506         iAsyncErrorIndex_initialize = 0;

   507 		}

   508 	DecOutstanding();

   509 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::InitializeComplete"));

   510 	}

   512 /**

   513  * It's needed for playing o converting

   514  * @param aBuffer - Buffer into which data should be read. The amount of data that is

   515  *                  needed is specified in CMMFBuffer::RequestSize().

   516  */

   517 void CT_CMMFDevSoundData::BufferToBeFilled(CMMFBuffer* aBuffer)

   518 	{

   519 	if (!aBuffer)

   520 		{

   521 		ERR_PRINTF1(_L("BufferToBeFilled callback received a NULL CMMFBuffer!"));

   522 		SetBlockResult(EFail);

   523 		}

   524 	else

   525 		{

   526 		TBool dataOk = ETrue;

   527 		iBuffer = aBuffer;

   528 		iBuffer->SetLastBuffer(EFalse);

   529 		CMMFDataBuffer* buffer = static_cast <CMMFDataBuffer*> (iBuffer);

   530 		if (iPaused)

   531 			{

   532 			iPaused=EFalse;

   533 			TInt error = iAudiofile.Read(iLastSample,buffer->Data());

   534 			if (error != KErrNone)

   535 				{

   536 				ERR_PRINTF2(_L("ERROR : iFile.Read() failed with %d"), error);

   537 				SetBlockResult(EFail);

   538 				dataOk = EFalse;

   539 				}

   540 			}

   541 		else

   542 			{

   543 			TInt error = iAudiofile.Read(buffer->Data());

   544 			if (error != KErrNone)

   545 				{

   546 				ERR_PRINTF2(_L("ERROR : iFile.Read() failed with %d"), error);

   547 				SetBlockResult(EFail);

   548 				dataOk =EFalse;

   549 				}

   550 			}

   551 		if(dataOk)

   552 			{

   553 			if (buffer->Data().Length() != buffer->RequestSize())

   554 				{

   555 				iBuffer->SetLastBuffer(ETrue);

   556 				}

   557 			if (iErrorConceal)

   558 				{

   559 				iErrorConceal=EFalse;

   560 				buffer->Data().Zero();

   561 				INFO_PRINTF1(_L("buffer->Data().Zero()"));

   562 				}

   563 			PlayData();

   564 			TInt pos=0;

   565 			iLastSample=iAudiofile.Seek(ESeekCurrent ,pos);

   566 			INFO_PRINTF2(_L("Number of samples played so far: %d"), pos);

   567 			iLastSample=pos;

   568 			}

   569 		}

   570 	}

   572 /**

   573 * Handles play completion or cancel event.

   574 *

   575 * CMMFDevSound object calls this function when an attempt to play audio sample

   576 * has completed, successfully or otherwise.

   577 *

   578 *   @param  aError - Error code. The status of playback. KErrUnderflow playing of the

   579 *                    audio sample is complete. KErrAccessDenied the sound device is in

   580 *                    use by another higher priority client.

   581 */

   582 void CT_CMMFDevSoundData::PlayError(TInt aError)

   583 	{

   584 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::PlayError"));

   585 	if (aError == KErrUnderflow)

   586 		{

   587 		ERR_PRINTF2(_L("Playback completed normally with error %d"), aError);

   588 		//iAudiofile.Close();

   589 		}

   590 	else

   591 		{

   592 		ERR_PRINTF2(_L("Playback completed with error %d"), aError);

   593 		SetAsyncError(iAsyncErrorIndex_play,aError);

   594         iAsyncErrorIndex_play = 0;

   595 		}

   596 	DecOutstanding();

   597 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::PlayError"));

   598 	}

   601 /**

   602  *  Handles tone play completion event.

   603  *

   604  *

   605  *  CMMFDevSound object calls this function when an attempt to play tone has

   606  *  completed, successfully or otherwise.

   607  *

   608  *  The following are the play tone functions; PlayToneL(), PlayDMTFStringL(),

   609  *  PlayToneSequenceL(), and PlayFixedSequenceL().

   610  *

   611  *  @param  aError -  Error code. The status of tone playback. KErrUnderflow playing of

   612  *                    the tone is complete. KErrAccessDenied the sound device is in use by

   613  *                    another higher priority client. KErrCancel playing of the audio

   614  *                    sample is stopped by DevSound client another higher priority client.

   615  *

   616  */

   618 void CT_CMMFDevSoundData::ToneFinished(TInt aError)

   619 	{

   620 	ERR_PRINTF1(_L("*START*CT_CMMFDevSoundData::ToneFinished"));

   622 	if (aError == KErrUnderflow)

   623 		{

   624 		ERR_PRINTF2(_L("Tone finished normally with error = %d"), aError);

   625 		}

   626 	else

   627 		{

   628 		ERR_PRINTF2(_L("Tone finished with error %d"), aError);

   629 		SetAsyncError(iAsyncErrorIndex_tone, aError);

   630         iAsyncErrorIndex_tone = 0;

   631 		}

   632 	DecOutstanding();

   633 	iToneFile.Close();

   634 	ERR_PRINTF1(_L("*END*CT_CMMFDevSoundData::ToneFinished"));

   635 	}

   637 /**

   638  * Handles CMMFDevSound object's data request event.

   639  *

   640  * CMMFDevSound object calls this function when the buffer, aBuffer gets filled

   641  * while recording or converting. The observer should notify CMMFDevSound

   642  * object as quickly as possible after data in the buffer is processed by

   643  * calling RecordData(), otherwise the implementation might callback

   644  * the function RecordError() on derived class object with error code KErrOverflow.

   645  *

   646  * @param  aBuffer - Buffer containing processed (recorded or converted) data. The amount

   647  *                   of data that is available is specified in CMMFBuffer::RequestSize().

   648  */

   650 void CT_CMMFDevSoundData::BufferToBeEmptied(CMMFBuffer* aBuffer)

   651 	{

   652 	if (!aBuffer)

   653 		{

   654 		INFO_PRINTF1(_L("BufferToBeEmptied callback received a NULL CMMFBuffer"));

   655 		SetBlockResult(EFail);

   656 		}

   657 	else

   658 		{

   659 		iBuffer = aBuffer;

   660 		CMMFDataBuffer* buffer = static_cast <CMMFDataBuffer*> (iBuffer);

   661 		TInt error = iAudiofile.Write(buffer->Data());

   662 		if(error == KErrNone)

   663 			{

   664 			if (!aBuffer->LastBuffer())

   665 				{

   666 				RecordData();

   667 				}

   668 			else{

   669 				Stop();

   670 				}

   671 			}

   672 		else

   673 			{

   674 			ERR_PRINTF2(_L("iFile.Write() returned the error %d"), error);

   675 			SetBlockResult(EFail);

   676 			}

   677 		}

   678 	}

   680 /**

   681  * Stops the ongoing operation (Play, Record, TonePlay, Convert).

   682  * This function should be synchronous and invoke no callbacks through MDevSoundObserver.

   683  */

   684 void CT_CMMFDevSoundData::Stop()

   685 	{

   686 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::Stop()"));

   687 	iDevSound->Stop();

   689 	DecOutstanding();

   691 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::Stop()"));

   692 	}

   694 /**

   695  * Handles record completion or cancel event.

   696  *

   697  * CMMFDevSound object calls this function when an attempt to record audio sample

   698  * has completed, successfully or otherwise.

   699  *

   700  * @param  aError - Error code. The status of recording. KErrOverflow audio devices

   701  *                  runs out of internal buffer. KErrAccessDenied the sound device is

   702  *                  in use by another higher priority client.

   703  *

   704  */

   706 void CT_CMMFDevSoundData::RecordError(TInt aError)

   707 	{

   708 	ERR_PRINTF1(_L("*START*CT_CMMFDevSoundData::RecordError"));

   709 	ERR_PRINTF2(_L("RecordError callback returned error = %d"), aError);

   710 	SetAsyncError(iAsyncErrorIndex_record, aError);

   711     iAsyncErrorIndex_record = 0;

   712 	//iAudiofile.Close();

   713 	ERR_PRINTF1(_L("*END*CT_CMMFDevSoundData::RecordError"));

   714 	}

   717 /**

   718  * Handles conversion completion or cancel event.

   719  *

   720  * CMMFDevSound object calls this function when an attempt to convert data from

   721  * source format to destination format has completed, successfully or otherwise.

   722  *

   723  * @param  aError - Error code. KErrCancel conversion operation is cancelled. KErrNone

   724  *                  conversion is complete. Other values are possible indicating a

   725  *                  problem converting data.

   726  */

   728 void CT_CMMFDevSoundData::ConvertError(TInt aError)

   729 	{

   730 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::ConvertError"));

   731 	ERR_PRINTF1(_L("Invalid Callback call"));

   732 	if (aError == KErrNone)

   733 		{

   734 		INFO_PRINTF1(_L("Data conversion completed successfully."));

   735 		}

   736 	if (aError == KErrCancel)

   737 		{

   738 		INFO_PRINTF1(_L("Data conversion operation was cancelled."));

   739 		}

   740 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::ConvertError"));

   741 	}

   743 /**

   744  * Handles device event.

   745  *

   746  * CMMFDevSound object calls this function when a message is received from the

   747  * audio hardware device.

   748  *

   749  * @param   aMessageType - Defines the type of message. Used to determine how to

   750  *                         interpret the contents of aMsg.

   751  * @param   aMsg         - Message that is packed in the Descriptor format.

   752  */

   755 void CT_CMMFDevSoundData::DeviceMessage(TUid aMessageType, const TDesC8& aMsg)

   756 	{

   757 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DeviceMessage"));

   758 	INFO_PRINTF2(_L("Message type: %d"), aMessageType.iUid);

   759 	INFO_PRINTF2(_L("Message type: %S"), &aMsg);

   760 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DeviceMessage"));

   761 	}

   764 /**

   765  * Create a new or Replace the existing file

   766  *

   767  */

   768 void CT_CMMFDevSoundData::DoCmdUtilityReplaceFile(const TTEFSectionName& aSection)

   769 	{

   770 	INFO_PRINTF1(_L("*START* CT_CMMFDevSoundData::DoCmdUtilityReplaceFile()"));

   771 	TPtrC fileName;

   772 	TBool dataOk = ETrue;

   773 	if (!GetStringFromConfig(aSection, KFilename, fileName))

   774 		{

   775 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KFilename);

   776 		SetBlockResult(EFail);

   777 		dataOk =EFalse;

   778 		}

   779 	if(dataOk)

   780 		{

   781 		TInt error = iAudiofile.Replace(iFs, fileName, EFileRead);

   782 		if (error != KErrNone)

   783 			{

   784 			ERR_PRINTF2(_L("Could not open input file. Error = %d"), error);

   785 			SetError(error);

   786 			}

   787 		}

   789 	INFO_PRINTF1(_L("*END* CT_CMMFDevSoundData::DoCmdUtilityReplaceFile()"));

   790 	}

   792 /**

   793  * Open a file

   794  */

   795 void CT_CMMFDevSoundData::DoCmdUtilityOpenFile(const TTEFSectionName& aSection)

   796 	{

   798 	INFO_PRINTF1(_L("*START* CT_CMMFDevSoundData::DoCmdUtilityOpenFile()"));

   799 	TPtrC fileName;

   800 	TBool dataOk = ETrue;

   801 	if (!GetStringFromConfig(aSection, KFilename, fileName))

   802 		{

   803 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KFilename);

   804 		SetBlockResult(EFail);

   805 		dataOk =EFalse;

   806 		}

   807 	if(dataOk)

   808 		{

   809 		TInt error = iAudiofile.Open(iFs, fileName, EFileRead);

   810 		if (error != KErrNone)

   811 			{

   812 			ERR_PRINTF2(_L("Could not open input file. Error = %d"), error);

   813 			iFs.Close();

   814 			SetError(error);

   815 			}

   816 		}

   817 	INFO_PRINTF1(_L("*END* CT_CMMFDevSoundData::DoCmdUtilityOpenFile()"));

   818 	}

   820 /**

   821  * Close the opened file

   822  */

   823 void CT_CMMFDevSoundData::DoCmdUtilityCloseFile()

   824 	{

   825 	INFO_PRINTF1(_L("*START* CT_CMMFDevSoundData::DoCmdUtilityCloseFile()"));

   826 	iAudiofile.Close();

   827 	INFO_PRINTF1(_L("*END* CT_CMMFDevSoundData::DoCmdUtilityCloseFile()"));

   828 	}

   830 /**

   831  * Place the the pointer file at the begining

   832  *

   833  */

   834 void CT_CMMFDevSoundData::DoCmdUtilityFileStartPosition()

   835 	{

   836 	INFO_PRINTF1(_L("*START* CT_CMMFDevSoundData::DoCmdUtilityFileStartPosition()"));

   837 	TInt filePosition(0);

   838 	TBool dataOk = ETrue;

   839 	TInt error = iAudiofile.Seek(ESeekStart, filePosition);

   840 	if (error != KErrNone)

   841 		{

   842 		ERR_PRINTF2(_L("Could not set file to the start position. Error = %d"), error);

   843 		SetError(error);

   844 		dataOk =EFalse;

   845 		}

   846 	if(dataOk)

   847 		{

   848 		INFO_PRINTF2(_L("File Position: %d"), filePosition);

   849 		}

   850 	INFO_PRINTF1(_L("*END* CT_CMMFDevSoundData::DoCmdUtilityFileStartPosition()"));

   851 	}

   853 /**

   854  * Creates "n" instance of CMMFDevSound

   855  * @param aSection - Section to read from the ini file

   856  * @return void

   857  */

   858 void CT_CMMFDevSoundData::DoCmdNewLLoopL(const TTEFSectionName&aSection)

   859 	{

   860 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdNewLLoopL"));

   861 	CMMFDevSound* devSound = NULL;

   862 	TBool dataOk = ETrue;

   863 	TInt loop;

   864 	if (!GetIntFromConfig(aSection, KLoop, loop))

   865 		{

   866 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KLoop);

   867 		SetBlockResult(EFail);

   868 		dataOk = EFalse;

   869 		}

   870 	TInt allowedError;

   871 	if ( !GetIntFromConfig(aSection, KAllowedError, allowedError) )

   872 		{

   873 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KAllowedError);

   874 		SetBlockResult(EFail);

   875 		dataOk = EFalse;

   876 		}

   877 	if(dataOk)

   878 		{

   879 		for(TInt i=0; i<loop; i++)

   880 			{

   881 			TRAPD(error,devSound = CMMFDevSound::NewL());

   882 			if(error == KErrNone)

   883 				{

   884 				INFO_PRINTF2(_L("Instance %d of DevSound was created"),i);

   885 				CleanupStack::PushL(devSound);

   886 				iObjectsDevSound.AppendL(devSound);

   887 				CleanupStack::Pop(devSound);

   888 				}

   889 			else if(error == allowedError)

   890 				{

   891 				INFO_PRINTF2(_L(" Allowing Error: %d"), error);

   892 				ERR_PRINTF2(_L(" Could not create CMMFDevSound due to error: %d"), error);

   893 				i = loop;

   894 				}

   895 			else if((error != KErrNone) && (error!=allowedError))

   896 				{

   897 				ERR_PRINTF2(_L("> Could not create CMMFDevSound: %d"), error);

   898 				SetError(error);

   899 				}

   900 			}

   901 		iObjectsDevSound.ResetAndDestroy();

   902 		INFO_PRINTF2(_L("%d DevSound instances were deleted"),loop);

   903 		}

   904 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdNewLLoopL"));

   905 	}

   908 /**

   909  * Create an instance of CMMFDevSound

   910  */

   911 void CT_CMMFDevSoundData::DoCmdNewL()

   912 	{

   913 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdNewL"));

   914 	DestroyData();

   915 	TRAPD(error,iDevSound = CMMFDevSound::NewL());

   916 	if(error!= KErrNone)

   917 		{

   918 		ERR_PRINTF2(_L("> Could not create CMMFDevSound: %d"), error);

   919 		SetError(error);

   920 		}

   921 	else

   922 		{

   923 		iPaused= EFalse;

   924 		iErrorConceal = EFalse;

   925 		}

   926 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdNewL"));

   927 	}

   928 /**

   929  * Destroy an instance of CMMFDevSound

   930  */

   932 void CT_CMMFDevSoundData::DoCmdDestructor()

   933 	{

   934 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdDestroyData"));

   935 	DestroyData();

   936 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdDestroyData"));

   937 	}

   939 /**

   940  * Show the supported Audio settings ie. encoding, sample rates, mono/stereo operation, buffer

   941  * size, etc.

   942  * @param none

   943  * @return none

   944  */

   945 void CT_CMMFDevSoundData::DoCmdCapabilities()

   946 	{

   947 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdCapabilities"));

   948 	iCapabilities = iDevSound->Capabilities();

   949 	INFO_PRINTF5(_L("Supported Audio settings: buffsize=%d, channels=0x%x, encoding=0x%x and rate=0x%x"),

   950 							iCapabilities.iBufferSize,

   951 							iCapabilities.iChannels,

   952 							iCapabilities.iEncoding,

   953 							iCapabilities.iRate);

   954 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdCapabilities"));

   955 	}

   958 /**

   959  * Shows the current device configuration.

   960  * @params none

   961  * @return none

   962  */

   963 void CT_CMMFDevSoundData::DoCmdConfig()

   964 	{

   965 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdConfig"));

   966 	TMMFCapabilities currentConfiguration = iDevSound->Config();

   967 	INFO_PRINTF5(_L("Current device configuration: buffsize=%d, channels=0x%x, encoding=0x%x and rate=0x%x"),

   968 			currentConfiguration.iBufferSize,

   969 			currentConfiguration.iChannels,

   970 			currentConfiguration.iEncoding,

   971 			currentConfiguration.iRate);

   972 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdConfig"));

   973 	}

   976 /**

   977  * Shows an integer representing the maximum gain the device supports.

   978  * This is the maximum value which can be passed to CMMFDevSound::SetGain.

   979  * @param aSection - The section to read the params from the ini file

   980  * @return none

   981  */

   983 void CT_CMMFDevSoundData::DoCmdMaxGain(const TTEFSectionName& aSection)

   984 	{

   985 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdMaxGain"));

   986 	TBool dataOk = ETrue;

   987 	TInt expectedGainValue;

   988 	if (!GetIntFromConfig(aSection, KGainValue, expectedGainValue))

   989 		{

   990 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KGainValue);

   991 		SetBlockResult(EFail);

   992 		dataOk = EFalse;

   993 		}

   994 	if(dataOk)

   995 		{

   996 		iGainValue = iDevSound->MaxGain();

   997 		INFO_PRINTF2(_L("Retrieved maximum gain value: %d"), iGainValue);

   998 		if (expectedGainValue != iGainValue)

   999 			{

  1000 			ERR_PRINTF3(_L("Expected gain value %d is different from retrieved gain value %d"), expectedGainValue, iGainValue);

  1001 			SetBlockResult(EFail);

  1002 			}

  1003 		}

  1004 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdMaxGain"));

  1005 	}

  1007 /**

  1008  * Shows an integer representing the maximum volume device supports.

  1009  * This is the maximum value which can be passed to CMMFDevSound::SetVolume.

  1010  * @param aSection - Section to read params from the ini file

  1011  * @return none

  1012  */

  1014 void CT_CMMFDevSoundData::DoCmdMaxVolume(const TTEFSectionName& aSection)

  1015 	{

  1016 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdMaxVolume"));

  1017 	TBool dataOk = ETrue;

  1018 	TInt expectedVolumeValue;

  1019 	if(!GetIntFromConfig(aSection, KVolumeValue, expectedVolumeValue))

  1020 		{

  1021 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVolumeValue);

  1022 		SetBlockResult(EFail);

  1023 		dataOk = EFalse;

  1024 		}

  1025 	if(dataOk)

  1026 		{

  1027 		iVolumeValue = iDevSound->MaxVolume();

  1028 		INFO_PRINTF2(_L("Retrieved maximum volume value: %d"), iVolumeValue);

  1029 		if(expectedVolumeValue != iVolumeValue)

  1030 			{

  1031 			ERR_PRINTF3(_L("Expected volume value %d is different from retrieved volume value %d"), expectedVolumeValue, iVolumeValue);

  1032 			SetBlockResult(EFail);

  1033 			}

  1034 		}

  1035 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdMaxVolume"));

  1036 	}

  1038 /**

  1039  * Shows the speaker balance set for playing.

  1040  * @param aSection - Section to read params from the ini file

  1041  * @return none

  1042  */

  1044 void CT_CMMFDevSoundData::DoCmdGetPlayBalanceL(const TTEFSectionName& aSection)

  1045 	{

  1046 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdGetPlayBalanceL"));

  1047 	TBool dataOk = ETrue;

  1048 	TInt expectedLeftPercentage;

  1049 	if (!GetIntFromConfig(aSection, KLeftPercentage, expectedLeftPercentage))

  1050 		{

  1051 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KLeftPercentage);

  1052 		SetBlockResult(EFail);

  1053 		dataOk = EFalse;

  1054 		}

  1055 	TInt expectedRightPercentage;

  1056 	if (!GetIntFromConfig(aSection, KRightPercentage, expectedRightPercentage))

  1057 		{

  1058 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KRightPercentage);

  1059 		SetBlockResult(EFail);

  1060 		dataOk = EFalse;

  1061 		}

  1062 	if(dataOk)

  1063 		{

  1064 		TRAPD(error, iDevSound->GetPlayBalanceL(iLeftPercentage, iRightPercentage));

  1065 		if (error != KErrNone)

  1066 			{

  1067 			ERR_PRINTF2(_L("GetPlayBalanceL left with error %d"), error);

  1068 			SetError(error);

  1069 			}

  1070 		else

  1071 			{

  1072 			INFO_PRINTF3(_L("> Retrieved play balance values are left: %d, right:%d"), iLeftPercentage, iRightPercentage);

  1073 			if (expectedLeftPercentage !=iLeftPercentage)

  1074 				{

  1075 				ERR_PRINTF3(_L("Expected left percentage value %d is different from retrieved value %d"), expectedLeftPercentage, iLeftPercentage);

  1076 				SetBlockResult(EFail);

  1077 				}

  1078 			if (expectedRightPercentage !=iRightPercentage)

  1079 				{

  1080 				ERR_PRINTF3(_L("Expected right percentage value %d is different from retrieved value %d"), expectedRightPercentage, iRightPercentage);

  1081 				SetBlockResult(EFail);

  1082 				}

  1083 			}

  1084 		}

  1086 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdGetPlayBalanceL"));

  1087 	}

  1090 /**

  1091  * Shows the microphone gain balance set for recording.

  1092  * @param aSection - Section to read params from the ini file

  1093  * @return none

  1094  */

  1095 void CT_CMMFDevSoundData::DoCmdGetRecordBalanceL(const TTEFSectionName& aSection)

  1096 	{

  1097 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdGetRecordBalanceL"));

  1098 	TBool dataOk = ETrue;

  1099 	TInt expectedLeftPercentage;

  1100 	if(!GetIntFromConfig(aSection, KLeftPercentage, expectedLeftPercentage))

  1101 		{

  1102 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KLeftPercentage);

  1103 		SetBlockResult(EFail);

  1104 		dataOk = EFalse;

  1105 		}

  1106 	TInt expectedRightPercentage;

  1107 	if(!GetIntFromConfig(aSection, KRightPercentage, expectedRightPercentage))

  1108 		{

  1109 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KRightPercentage);

  1110 		SetBlockResult(EFail);

  1111 		dataOk = EFalse;

  1112 		}

  1113 	if(dataOk)

  1114 		{

  1115 		TRAPD(error, iDevSound->GetRecordBalanceL(iLeftPercentage, iRightPercentage));

  1116 		if (error != KErrNone)

  1117 			{

  1118 			ERR_PRINTF2(_L("GetRecordBalanceL left with error %d"), error);

  1119 			SetError(error);

  1120 			}

  1121 		else

  1122 			{

  1123 			INFO_PRINTF3(_L("> Retrieved record balance values are left: %d, right:%d"), iLeftPercentage, iRightPercentage);

  1124 			if(expectedLeftPercentage !=iLeftPercentage)

  1125 				{

  1126 				ERR_PRINTF3(_L("Expected left percentage value %d is different from retrieved value %d"), expectedLeftPercentage, iLeftPercentage);

  1127 				SetBlockResult(EFail);

  1128 				}

  1129 			if(expectedRightPercentage !=iRightPercentage)

  1130 				{

  1131 				ERR_PRINTF3(_L("Expected right ercentage value %d is different from retrieved value %d"), expectedRightPercentage, iRightPercentage);

  1132 				SetBlockResult(EFail);

  1133 				}

  1134 			}

  1136 		}

  1137 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdGetRecordBalanceL"));

  1138 	}

  1140 /**

  1141  * Shows a list of the supported input datatypes that can be sent to DevSound for playing audio.

  1142  * The datatypes returned are those that the DevSound supports given the priority settings passed

  1143  * in aPrioritySettings.

  1144  * @params none

  1145  * @return none

  1146  */

  1147 void CT_CMMFDevSoundData::DoCmdGetSupportedInputDataTypesL()

  1148 	{

  1149 	TUid outputUid= {0x0};

  1150 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdGetSupportedInputDataTypesL"));

  1151 	RArray< TFourCC > supportedDataTypes;

  1152 	TRAPD(error, iDevSound->GetSupportedInputDataTypesL(supportedDataTypes, iPrioritySettings));

  1153 	if (error != KErrNone)

  1154 		{

  1155 		ERR_PRINTF2(_L("GetSupportedInputDataTypesL left with error %d"), error);

  1156 		SetError(error);

  1157 		}

  1158 	else

  1159 		{

  1160 		INFO_PRINTF1(_L("List of the supported input datatypes that can be sent to DevSound for playing audio."));

  1161 		for (TInt i=0; i<supportedDataTypes.Count(); i++)

  1162 			{

  1163 			TFourCC fourCC = supportedDataTypes[i];

  1164 			TBuf<4> name;

  1165 			for(TInt j=0; j<= KFourCCMaxBitDisplacement; j+=K8Bits)

  1166 				{

  1167 				name.Append((TUint8)(fourCC.FourCC() >> j));

  1168 				}

  1169 			INFO_PRINTF3(_L("Supported Input Data types: 0x%x  %S "), fourCC.FourCC(), &name);

  1170 			UtilityFourCCToHwDeviceUidL(name,EDecoder, outputUid);

  1171 			if(outputUid.iUid != 0)

  1172 				{

  1173 				INFO_PRINTF3(_L("\nHwDevice Uid=0x%08x for %S"),outputUid.iUid,&name);

  1174 				}

  1175 			else

  1176 				{

  1177 				INFO_PRINTF1(_L("Not Found"));

  1178 				}

  1179 			}

  1180 		supportedDataTypes.Reset();

  1181 		}

  1182 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdGetSupportedInputDataTypesL"));

  1183 	}

  1185 /**

  1186  * Shows a list of the supported output dataypes that can be received from DevSound for

  1187  * recording audio.  The datatypes returned are those that the DevSound supports given the priority

  1188  * settings passed in aPrioritySettings.

  1189  * @param none

  1190  * @return none

  1191  */

  1192 void CT_CMMFDevSoundData::DoCmdGetSupportedOutputDataTypesL()

  1193 	{

  1194 	TUid outputUid= {0x0};

  1195 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdGetSupportedOutputDataTypesL"));

  1196 	RArray< TFourCC > supportedDataTypes;

  1197 	TRAPD(error, iDevSound->GetSupportedOutputDataTypesL(supportedDataTypes, iPrioritySettings));

  1198 	if (error != KErrNone)

  1199 		{

  1200 		ERR_PRINTF2(_L("GetSupportedOutputDataTypesL left with error %d"), error);

  1201 		SetError(error);

  1202 		}

  1203 	else

  1204 		{

  1205 		INFO_PRINTF1(_L("List of the supported output dataypes that can be received from DevSound for recording audio."));

  1206 		for (TInt i=0; i<supportedDataTypes.Count(); i++)

  1207 			{

  1208 			TFourCC fourCC = supportedDataTypes[i];

  1209 			TBuf<4> name;

  1210 			for(TInt j=0; j<=KFourCCMaxBitDisplacement; j+=K8Bits)

  1211 				{

  1212 				name.Append((TUint8)(fourCC.FourCC() >> j));

  1213 				}

  1214 			INFO_PRINTF3(_L("Supported Output Data types: 0x%x  %S "), fourCC.FourCC(), &name);

  1215 			UtilityFourCCToHwDeviceUidL(name, EEncoder, outputUid);

  1216 			if(outputUid.iUid != 0)

  1217 				{

  1218 				INFO_PRINTF3(_L("\nHwDevice Uid=0x%08x for %S"),outputUid.iUid,&name);

  1219 				}

  1220 			else

  1221 				{

  1222 				INFO_PRINTF1(_L("Not Found"));

  1223 				}

  1224 			}

  1225 		supportedDataTypes.Reset();

  1226 		}

  1227 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdGetSupportedOutputDataTypesL"));

  1228 	}

  1230 /**

  1231  * Shows the number of samples played

  1232  * @param none

  1233  * @return none

  1234  */

  1235 void CT_CMMFDevSoundData::DoCmdSamplesPlayed()

  1236 	{

  1237 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSamplesPlayed"));

  1238 	INFO_PRINTF2(_L("Number of samples played so far: %d"),iDevSound->SamplesPlayed());

  1239 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSamplesPlayed"));

  1240 	}

  1242 /**

  1243  * Shows the number of samples recorded

  1244  * @param none

  1245  * @return none

  1246  */

  1247 void CT_CMMFDevSoundData::DoCmdSamplesRecorded()

  1248 	{

  1249 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSamplesRecorded"));

  1250 	INFO_PRINTF2(_L("Number of samples recorded so far: %d"), iDevSound->SamplesRecorded());

  1251 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSamplesRecorded"));

  1252 	}

  1254 /**

  1255  * Shows an integer representing the current volume.

  1256  * @param aSection - Section to read param from the ini file

  1257  * @return none

  1258  */

  1259 void CT_CMMFDevSoundData::DoCmdVolume(const TTEFSectionName& aSection)

  1260 	{

  1261 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdVolume"));

  1262 	TBool dataOk = ETrue;

  1263 	TInt expectedVolumeValue;

  1264 	if(!GetIntFromConfig(aSection, KVolumeValue, expectedVolumeValue))

  1265 		{

  1266 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVolumeValue);

  1267 		SetBlockResult(EFail);

  1268 		dataOk = EFalse;

  1269 		}

  1270 	if(dataOk)

  1271 		{

  1272 		iVolumeValue = iDevSound->Volume();

  1273 		INFO_PRINTF2(_L("Retrieved volume value: %d"), iVolumeValue);

  1274 		if(expectedVolumeValue != iVolumeValue)

  1275 			{

  1276 			ERR_PRINTF3(_L("Expected volume value %d is different from retrieved volume value %d"), expectedVolumeValue, iVolumeValue);

  1277 			SetBlockResult(EFail);

  1278 			}

  1279 		}

  1280 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdVolume"));

  1281 	}

  1283 /**

  1284  * Shows an integer representing the current gain.

  1285  * @param aSection - Section to read param from the ini file

  1286  * @return none

  1287  */

  1288 void CT_CMMFDevSoundData::DoCmdGain(const TTEFSectionName& aSection)

  1289 	{

  1290 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdGain"));

  1291 	TBool dataOk = ETrue;

  1292 	TInt expectedGainValue;

  1293 	if(!GetIntFromConfig(aSection, KGainValue, expectedGainValue))

  1294 		{

  1295 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KGainValue);

  1296 		SetBlockResult(EFail);

  1297 		dataOk = EFalse;

  1298 		}

  1299 	if(dataOk)

  1300 		{

  1301 		iGainValue = iDevSound->Gain();

  1302 		INFO_PRINTF2(_L("Retrieved gain value: %d"), iGainValue);

  1303 		if(expectedGainValue != iGainValue)

  1304 			{

  1305 			ERR_PRINTF3(_L("Expected gain value %d is different from retrieved gain value %d"), expectedGainValue, iGainValue);

  1306 			SetBlockResult(EFail);

  1307 			}

  1308 		}

  1309 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdGain"));

  1310 	}

  1312 /**

  1313  * Shows the number of available pre-defined tone sequences

  1314  * @param none

  1315  * @return none

  1316  */

  1317 void CT_CMMFDevSoundData::DoCmdFixedSequenceCount()

  1318 	{

  1319 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdFixedSequenceCount"));

  1320 	INFO_PRINTF2(_L("Number of available pre-defined tone sequences: %d"), iDevSound->FixedSequenceCount());

  1321 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdFixedSequenceCount"));

  1322 	}

  1324 /**

  1325  * Shows the name assigned to a specific pre-defined tone sequence.

  1326  * This is the number of the fixed sequence supported by DevSound by default.

  1327  * @param aSection -  Section to read params from the ini file

  1328  * @return none

  1329  */

  1330 void CT_CMMFDevSoundData::DoCmdFixedSequenceName(const TTEFSectionName& aSection)

  1331 	{

  1332 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdFixedSequenceName"));

  1333 	TBool dataOk =ETrue;

  1334 	TInt sequenceNumber;

  1335 	if(!GetIntFromConfig(aSection, KSequenceNumber, sequenceNumber))

  1336 		{

  1337 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KSequenceNumber);

  1338 		SetBlockResult(EFail);

  1339 		dataOk =EFalse;

  1340 		}

  1341 	if(dataOk)

  1342 		{

  1343 		INFO_PRINTF2(_L("Name assigned to a specific pre-defined tone sequence returned: %S"),

  1344 					&iDevSound->FixedSequenceName(sequenceNumber));

  1345 		}

  1346 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdFixedSequenceName"));

  1347 	}

  1350 /**

  1351  * Configure CMMFDevSound object with the settings in aConfig.

  1352  * Use this to set sampling rate, encoding and mono/stereo.

  1353  * @param aSection - Section to read params from the ini file

  1354  * @return none

  1355  */

  1356 void CT_CMMFDevSoundData::DoCmdSetConfigL(const TTEFSectionName& aSection)

  1357 	{

  1358 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetConfigL"));

  1360 	TInt rate;

  1361 	INFO_PRINTF1(_L("To use default values run Capabilities before SetConfigL"));

  1362 	if (!GetEnumFromConfig(aSection, KRate, iEnumSampleRate, rate))

  1363 		{

  1364 		INFO_PRINTF2(_L("Rate value was not overwritten, using default value %d."), iCapabilities.iRate);

  1365 		}

  1366 	else

  1367 		{

  1368 		iCapabilities.iRate = rate;

  1369 		}

  1371 	TInt encoding;

  1372 	if (!GetIntFromConfig(aSection, KEncoding, encoding))

  1373 		{

  1374 		INFO_PRINTF2(_L("Encoding value was not overwritten, using default value %d."), iCapabilities.iEncoding);

  1375 		}

  1376 	else

  1377 		{

  1378 		iCapabilities.iEncoding = encoding;

  1379 		}

  1381 	TInt channels;

  1382 	if (!GetEnumFromConfig(aSection, KChannels, iEnumChannels, channels))

  1383 		{

  1384 		INFO_PRINTF2(_L("Channels value was not overwritten, using default value %d ."), iCapabilities.iChannels);

  1385 		}

  1386 	else

  1387 		{

  1388 		iCapabilities.iChannels = channels;

  1389 		}

  1391 	TInt bufferSize;

  1392 	if (!GetIntFromConfig(aSection, KBufferSize, bufferSize))

  1393 		{

  1394 		INFO_PRINTF2(_L("BufferSize value was not overwritten, using default value %d"), iCapabilities.iBufferSize);

  1395 		}

  1396 	else

  1397 		{

  1398 		iCapabilities.iBufferSize = bufferSize;

  1399 		}

  1400 	TRAPD(error,iDevSound->SetConfigL(iCapabilities))

  1401 	if(error != KErrNone)

  1402 		{

  1403 		ERR_PRINTF2(_L("SetConfigL left with error %d"), error);

  1404 		SetError(error);

  1405 		}

  1406 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetConfigL"));

  1407 	}

  1410 /**

  1411  * Defines the duration of tone on, tone off and tone pause to be used during the

  1412  * DTMF tone playback operation.

  1413  * Supported only during tone playing.

  1414  * @param aSection - Section to read param from the ini file

  1415  * @return none

  1416  */

  1417 void CT_CMMFDevSoundData::DoCmdSetDTMFLengths(const TTEFSectionName& aSection)

  1418 	{

  1419 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetDTMFLengths"));

  1420 	TInt time;

  1421 	TBool dataOk = ETrue;

  1422 	if (!GetIntFromConfig(aSection, KToneOnLength, time))

  1423 		{

  1424 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KToneOnLength);

  1425 		SetBlockResult(EFail);

  1426 		dataOk = EFalse;

  1427 		}

  1428 	TTimeIntervalMicroSeconds32 toneOnLength(time);

  1430 	if (!GetIntFromConfig(aSection, KToneOffLength, time))

  1431 		{

  1432 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KToneOffLength);

  1433 		SetBlockResult(EFail);

  1434 		dataOk = EFalse;

  1435 		}

  1436 	TTimeIntervalMicroSeconds32 toneOffLength(time);

  1438 	if (!GetIntFromConfig(aSection, KPauseLength, time))

  1439 		{

  1440 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KPauseLength);

  1441 		SetBlockResult(EFail);

  1442 		dataOk = EFalse;

  1443 		}

  1444 	TTimeIntervalMicroSeconds32 pauseLength(time);

  1445 	if(dataOk)

  1446 		{

  1447 		iDevSound->SetDTMFLengths(toneOnLength, toneOffLength, pauseLength);

  1448 		}

  1449 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetDTMFLengths"));

  1450 	}

  1453 /**

  1454  * Changes the current recording gain to a specified value.

  1455  * The gain can be changed before or during recording and is effective

  1456  * immediately.

  1457  * @params aSection - Section to read param from the ini file

  1458  */

  1459 void CT_CMMFDevSoundData::DoCmdSetGain(const TTEFSectionName& aSection)

  1460 	{

  1461 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetGain"));

  1462 	TInt gainValue = iGainValue;

  1463 	if(!GetIntFromConfig(aSection, KGainValue, gainValue))

  1464 		{

  1465 		INFO_PRINTF1(_L("The Gain value was not found in the ini file, using default value"));

  1466 		}

  1467 	INFO_PRINTF2(_L("Setting gain value to %d"), gainValue);

  1468 	iDevSound->SetGain(gainValue);

  1469 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetGain"));

  1470 	}

  1472 /**

  1473  * Sets the speaker balance for playing.

  1474  * The speaker balance can be changed before or during playback and is

  1475  * effective immediately.

  1476  * @param aSection - The section to read params from the ini file

  1477  * @return none

  1478  */

  1479 void CT_CMMFDevSoundData::DoCmdSetPlayBalanceL(const TTEFSectionName& aSection)

  1480 	{

  1481 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetPlayBalanceL"));

  1482 	TInt leftPercentage = iLeftPercentage;

  1483 	if(!GetIntFromConfig(aSection, KLeftPercentage, leftPercentage))

  1484 		{

  1485 		INFO_PRINTF1(_L("The Left percentage was not found in the ini file, using default value"));

  1486 		}

  1487 	TInt rightPercentage = iRightPercentage;

  1488 	if(!GetIntFromConfig(aSection, KRightPercentage, rightPercentage))

  1489 		{

  1490 		INFO_PRINTF1(_L("The Right percentage was not found in the ini file, using default value"));

  1491 		}

  1492 	INFO_PRINTF3(_L("Setting play balance to left: %d, right: %d values"), leftPercentage, rightPercentage);

  1493 	TRAPD(error, iDevSound->SetPlayBalanceL(leftPercentage, rightPercentage));

  1494 	if(error != KErrNone)

  1495 		{

  1496 		ERR_PRINTF2(_L("SetPlayBalanceL left with error %d"), error);

  1497 		SetError(error);

  1498 		}

  1499 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetPlayBalanceL"));

  1500 	}

  1502 /**

  1503  * Defines the priority settings that should be used for this instance.

  1504  * @param aSection - Section to read params from the ini file

  1505  * @return none

  1506  */

  1507 void CT_CMMFDevSoundData::DoCmdSetPrioritySettings(const TTEFSectionName& aSection)

  1508 	{

  1509 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetPrioritySettings"));

  1510 	TBool dataOk = ETrue;

  1511 	if(!GetIntFromConfig(aSection, KPriority, iPrioritySettings.iPriority))

  1512 		{

  1513 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KPriority);

  1514 		SetBlockResult(EFail);

  1515 		dataOk = EFalse;

  1516 		}

  1517 	TInt preference;

  1518 	if (!GetHexFromConfig(aSection, KPreference, preference))

  1519 		{

  1520 		ERR_PRINTF2(_L("%S parameter was not found in INI file"), &KPreference);

  1521 		SetBlockResult(EFail);

  1522 		dataOk = EFalse;

  1523 		}

  1524 	iPrioritySettings.iPref = (TMdaPriorityPreference)preference;

  1525 	TInt state;

  1526 	if (!GetEnumFromConfig(aSection, KPriorityState, iEnumMode, state))

  1527 		{

  1528 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KPriorityState);

  1529 		SetBlockResult(EFail);

  1530 		dataOk = EFalse;

  1531 		}

  1532 	iPrioritySettings.iState = (TMMFState)state;

  1533 	if(dataOk)

  1534 		{

  1535 		iDevSound->SetPrioritySettings(iPrioritySettings);

  1536 		}

  1537 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetPrioritySettings"));

  1538 	}

  1540 /**

  1541  * Sets the microphone gain balance for recording.

  1542  * The microphone gain balance can be changed before or during recording and

  1543  * is effective immediately.

  1544  * @param aSection - Section to read params from the ini file

  1545  * @return none

  1546  */

  1547 void CT_CMMFDevSoundData::DoCmdSetRecordBalanceL(const TTEFSectionName& aSection)

  1548 	{

  1549 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetRecordBalanceL"));

  1550 	TInt leftPercentage = iLeftPercentage;

  1551 	if (!GetIntFromConfig(aSection, KLeftPercentage, leftPercentage))

  1552 		{

  1553 		INFO_PRINTF1(_L("The Left value was not found in the ini file, using default value"));

  1554 		}

  1555 	TInt rightPercentage = iRightPercentage;

  1556 	if (!GetIntFromConfig(aSection, KRightPercentage, rightPercentage))

  1557 		{

  1558 		INFO_PRINTF1(_L("The Right value was not found in the ini file, using default value"));

  1559 		}

  1560 	INFO_PRINTF3(_L("Setting record balance to left: %d, right: %d values"), leftPercentage, rightPercentage);

  1561 	TRAPD(error, iDevSound->SetRecordBalanceL(leftPercentage, rightPercentage));

  1562 	if (KErrNone != error)

  1563 		{

  1564 		ERR_PRINTF2(_L("SetRecordBalanceL left with error %d"), error);

  1565 		SetError(error);

  1566 		}

  1567 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetRecordBalanceL"));

  1568 	}

  1570 /**

  1571  * Defines the number of times the audio is to be repeated during the tone

  1572  * playback operation.

  1573  * A period of silence can follow each playing of a tone. The tone playing can

  1574  * be repeated indefinitely.

  1575  * @param aSection - Section to read params from the ini file

  1576  * @return none

  1577  */

  1578 void CT_CMMFDevSoundData::DoCmdSetToneRepeats(const TTEFSectionName& aSection)

  1579 	{

  1580 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetToneRepeats"));

  1581 	TInt repeatCount;

  1582 	TBool dataOk = ETrue;

  1583 	if (!GetIntFromConfig(aSection, KRepeatCount, repeatCount))

  1584 		{

  1585 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KRepeatCount);

  1586 		SetBlockResult(EFail);

  1587 		dataOk = EFalse;

  1588 		}

  1590 	TInt tempValue;

  1591 	if (!GetIntFromConfig(aSection, KRepeatTrailingSilence, tempValue))

  1592 		{

  1593 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KRepeatTrailingSilence);

  1594 		SetBlockResult(EFail);

  1595 		dataOk = EFalse;

  1596 		}

  1597 	TTimeIntervalMicroSeconds repeatTrailingSilence(tempValue);

  1599 	if(dataOk)

  1600 		{

  1601 		iDevSound->SetToneRepeats(repeatCount, repeatTrailingSilence);

  1602 		}

  1603 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetToneRepeats"));

  1604 	}

  1606 /**

  1607  * Defines the period over which the volume level is to rise smoothly from

  1608  * nothing to the normal volume level.

  1609  * The function is only available while the tone is playing.

  1610  * @param aSection - Section to read params from the ini file

  1611  * @return none

  1612  */

  1613 void CT_CMMFDevSoundData::DoCmdSetVolume(const TTEFSectionName& aSection)

  1614 	{

  1615 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetVolume"));

  1616 	TInt volume = iVolumeValue;

  1617 	if(!GetIntFromConfig(aSection, KVolumeValue, volume))

  1618 		{

  1619 		INFO_PRINTF1(_L("The Volume value was not found in the ini file, using default value"));

  1620 		}

  1621 	INFO_PRINTF2(_L("Setting volume value to %d"), volume);

  1622 	iDevSound->SetVolume(volume);

  1623 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetVolume"));

  1624 	}

  1626 /**

  1627  * Defines the loop over which the volume level is to rise smoothly from

  1628  * nothing to the normal volume level.

  1629  * @param aSection - Section to read params from the ini file

  1630  * @return none

  1631  */

  1632 void CT_CMMFDevSoundData::DoCmdSetVolumeLoop(const TTEFSectionName& aSection)

  1633 	{

  1634 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetVolumeLoop"));

  1635 	TInt volLoop;

  1636 	TBool dataOk = ETrue;

  1637 	if (!GetIntFromConfig(aSection, KVolumeLoop, volLoop))

  1638 		{

  1639 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVolumeLoop);

  1640 		SetBlockResult(EFail);

  1641 		dataOk = EFalse;

  1642 		}

  1643 	if(dataOk)

  1644 		{

  1645 		TPtrC parVolume;

  1646 		TInt volumeValue;

  1647 		RPointerArray<HBufC> volumeList;

  1648 		for (TInt i=0; i<volLoop; i++)

  1649 			{

  1650 			if (!GetArrayRectFromConfig(aSection, KVolumeList, volumeList))

  1651 				{

  1652 				ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KVolumeList);

  1653 				volumeList.ResetAndDestroy();

  1654 				SetBlockResult(EFail);

  1655 				dataOk = EFalse;

  1656 				}

  1657 			if(dataOk)

  1658 				{

  1659 				for (TInt j=0; j<volumeList.Count(); j++)

  1660 					{

  1661 					parVolume.Set(*volumeList[j]);

  1662 					TLex lex(parVolume);

  1663 					TInt error = lex.Val(volumeValue);

  1664 					if (error != KErrNone)

  1665 						{

  1666 						ERR_PRINTF2(_L("Obtaining volume value failed with error %d"), error);

  1667 						SetError(error);

  1668 						volumeList.ResetAndDestroy();

  1669 						}

  1670 					else

  1671 						{

  1672 						INFO_PRINTF3(_L("Setting volume number %d in the iteration number %d"), j, i);

  1673 						iDevSound->SetVolume(volumeValue);

  1674 						}

  1675 					}

  1676 				}

  1677 			}

  1678 		volumeList.ResetAndDestroy();

  1679 		}

  1680 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetVolumeLoop"));

  1681 	}

  1683 /**

  1684  * Defines the period over which the volume level is to rise smoothly from

  1685  * nothing to the normal volume level.

  1686  * The function is only available while the tone is playing.

  1687  * @param aSection - Section to read param from the ini file

  1688  * @return none

  1689  */

  1690 void CT_CMMFDevSoundData::DoCmdSetVolumeRamp(const TTEFSectionName& aSection)

  1691 	{

  1692 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdSetVolumeRamp"));

  1693 	TInt tempValue;

  1694 	TBool dataOk = ETrue;

  1695 	if (!GetIntFromConfig(aSection, KRampDuration, tempValue))

  1696 		{

  1697 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KRampDuration);

  1698 		SetBlockResult(EFail);

  1699 		dataOk = EFalse;

  1700 		}

  1701 	TTimeIntervalMicroSeconds rampDuration(tempValue);

  1703 	if(dataOk)

  1704 		{

  1705 		iDevSound->SetVolumeRamp(rampDuration);

  1706 		}

  1707 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdSetVolumeRamp"));

  1708 	}

  1710 /**

  1711  * Initializes DevSound object for the mode aMode for processing audio data

  1712  * with hardware device aHWDev and supporting FourCC.

  1713  * Too Initializes CMMFDevSound object to play and record PCM16 raw audio data

  1714  * with sampling rate of 8 KHz.

  1715  * @param aSection - Section to read params from the ini file

  1716  */

  1717 void CT_CMMFDevSoundData::DoCmdInitializeL(const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

  1718 	{

  1719 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdInitializeL"));

  1720 	TBool dataOk = ETrue;

  1721 	TInt mode;

  1722 	if (!GetEnumFromConfig(aSection, KMode, iEnumMode, mode))

  1723 		{

  1724 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KMode);

  1725 		SetBlockResult(EFail);

  1726 		dataOk = EFalse;

  1727 		}

  1728 	else

  1729 		{

  1730 		TInt hwDeviceInt;

  1731 		if (!GetHexFromConfig(aSection, KHwDevice, hwDeviceInt))

  1732 			{

  1733 			INFO_PRINTF2(_L("%S parameter was not found in INI file"), &KHwDevice);

  1734 			TPtrC fourCCIniString;

  1735 			if (!GetStringFromConfig(aSection, KFourCC, fourCCIniString))

  1736 				{

  1737 				INFO_PRINTF2(_L("%S parameter was not found in INI file"), &KFourCC);

  1738 				if (dataOk)

  1739 					{

  1740 					INFO_PRINTF1(_L("Initializing DevSound with overload: void InitializeL(MDevSoundObserver &aDevSoundObserver, TMMFState aMode)"));

  1741 					TRAPD(error, iDevSound->InitializeL(*this, (TMMFState)mode));

  1742 					if(KErrNone != error)

  1743 						{

  1744 						ERR_PRINTF2(_L("InitializeL(aMDevSoundObserver, mode) left with error %d"), error);

  1745 						SetError(error);

  1746 						}

  1747 					}

  1748 				}

  1749 			else

  1750 				{

  1751 				if (fourCCIniString.Length() > KTFourCC)

  1752 					{

  1753 					ERR_PRINTF2(_L("FourCC obtained from INI file exceeded the valid length in %d"), fourCCIniString.Length());

  1754 					SetBlockResult(EFail);

  1755 					dataOk = EFalse;

  1756 					}

  1757 				if (dataOk)

  1758 					{

  1759 					TBuf<256> fourCCString;

  1760 					fourCCString.Copy(fourCCIniString);

  1761 					while (fourCCString.Length() < KTFourCC)

  1762 						{

  1763 						fourCCString.Insert(0, _L(" "));

  1764 						}

  1765 					TFourCC fourCC;

  1766 					fourCC = TFourCC(fourCCString[3] << 24 | fourCCString[2] << 16 | fourCCString[1] << 8 | fourCCString[0]);

  1767 					INFO_PRINTF1(_L("Initializing DevSound with overload: void InitializeL(MDevSoundObserver &aDevSoundObserver, TFourCC aDesiredFourCC, TMMFState aMode)"));

  1768 					TRAPD(error, iDevSound->InitializeL(*this, fourCC, (TMMFState)mode));

  1769 					if(KErrNone!=error)

  1770 						{

  1771 						ERR_PRINTF2(_L("InitializeL(aMDevSoundObserver, fourCC, mode) left with error %d"), error);

  1772 						ERR_PRINTF2(_L(" %S Not supported in this device"), &fourCCString);

  1773 						SetError(error);

  1774 						}

  1775 					}

  1776 				}

  1777 			}

  1778 		else

  1779 			{

  1780 			if (dataOk)

  1781 				{

  1782 				TUid hwDevice;

  1783 				hwDevice.iUid = hwDeviceInt;

  1784 				INFO_PRINTF1(_L("Initializing DevSound with overload: void InitializeL(MDevSoundObserver &aDevSoundObserver, TUid aHWDev, TMMFState aMode)"));

  1785 				TRAPD(error, iDevSound->InitializeL(*this, hwDevice, (TMMFState)mode));

  1786 				if(KErrNone != error)

  1787 					{

  1788 					ERR_PRINTF2(_L("InitializeL(aMDevSoundObserver, hwDevice, mode) left with error %d"), error);

  1789 					SetError(error);

  1790 					}

  1791 				}

  1792 			}

  1793 		}

  1795 	if (dataOk)

  1796 		{

  1797 		IncOutstanding();

  1798         iAsyncErrorIndex_initialize = aAsyncErrorIndex;

  1799 		}

  1800 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdInitializeL"));

  1801 	}

  1804 /**

  1805  * Initializes the audio device and starts playing the DTMF string aDTMFString.

  1806  * @param aSection - Section to read param from the ini file

  1807  * @return none

  1808  */

  1809 void CT_CMMFDevSoundData::DoCmdPlayDTMFStringL(const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

  1810 	{

  1811 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdPlayDTMFStringL"));

  1812 	TBool dataOk = ETrue;

  1813 	TPtrC dtmfString;

  1814 	if (!GetStringFromConfig(aSection, KDTMFString, dtmfString) )

  1815 		{

  1816 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KDTMFString);

  1817 		SetBlockResult(EFail);

  1818 		dataOk = EFalse;

  1819 		}

  1820 	if(dataOk)

  1821 		{

  1822 		TRAPD( error, iDevSound->PlayDTMFStringL(dtmfString) );

  1823 		if(error != KErrNone)

  1824 			{

  1825 			ERR_PRINTF2(_L("Play DTMF string failed with error: %d "), error);

  1826 			SetError(error);

  1827 			}

  1828 		else

  1829 			{

  1830             iAsyncErrorIndex_tone = aAsyncErrorIndex;

  1831 			IncOutstanding();

  1832 			}

  1833 		}

  1835 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdPlayDTMFStringL"));

  1836 	}

  1838 /**

  1839  * Plays data in the buffer at the current volume.

  1840  * @param

  1841  * @return

  1842  */

  1843 void CT_CMMFDevSoundData::DoCmdPlayData()

  1844 	{

  1845 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdPlayData"));

  1846 	PlayData();

  1847 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdPlayData"));

  1848 	}

  1850 /**

  1851  * Helper for the DoCmdPlayData command

  1852  */

  1853 void CT_CMMFDevSoundData::PlayData()

  1854 	{

  1855 	INFO_PRINTF1(_L("CT_CMMFDevSoundData::PlayData()"));

  1856 	iDevSound->PlayData();

  1857 	}

  1859 /**

  1860  * Initializes audio device and starts playing a dual tone.

  1861  * The generated tone consists of two sine waves of different frequencies summed together.

  1862  * Dual Tone is played with the specified frequencies and for the specified duration.

  1863  * @param aSection - Section to read params from the ini file.

  1864  * @return none

  1865  */

  1866 void CT_CMMFDevSoundData::DoCmdPlayDualToneL(const TTEFSectionName& aSection)

  1867 	{

  1868 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdPlayDualToneL"));

  1869 	TBool dataOk = ETrue;

  1870 	TInt frequencyOne;

  1871 	if (!GetIntFromConfig(aSection, KFrequencyOne, frequencyOne) )

  1872 		{

  1873 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KFrequencyOne);

  1874 		SetBlockResult(EFail);

  1875 		dataOk = EFalse;

  1876 		}

  1878 	TInt frequencyTwo;

  1879 	if (!GetIntFromConfig(aSection, KFrequencyTwo, frequencyTwo) )

  1880 		{

  1881 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KFrequencyTwo);

  1882 		SetBlockResult(EFail);

  1883 		dataOk = EFalse;

  1884 		}

  1886 	TInt duration;

  1887 	if (!GetIntFromConfig(aSection, KDuration, duration) )

  1888 		{

  1889 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KDuration);

  1890 		SetBlockResult(EFail);

  1891 		dataOk = EFalse;

  1892 		}

  1893 	if(dataOk)

  1894 		{

  1895 		TRAPD( error, iDevSound->PlayDualToneL(frequencyOne, frequencyTwo, duration) );

  1896 		if(error != KErrNone)

  1897 			{

  1898 			ERR_PRINTF2(_L("Play dual tone failed with error %d"), error);

  1899 			SetError(error);

  1900 			}

  1901 		else

  1902 			{

  1903 			IncOutstanding();

  1904 			}

  1905 		}

  1907 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdPlayDualToneL"));

  1908 	}

  1911 /**

  1912  * Initializes the audio device and starts the play process.

  1913  *

  1914  * This function queries and acquires the audio policy before initializing audio device. If there was

  1915  * an error during policy initialization, PlayError() function will be called on    the observer with

  1916  * error code KErrAccessDenied, otherwise BufferToBeFilled() function will be called with a buffer

  1917  * reference. After reading data into the buffer reference passed, the client should call PlayData() to play data.

  1918  *

  1919  * The amount of data that can be played is specified in CMMFBuffer::RequestSize(). Any data that is read into

  1920  * buffer beyond this size will be ignored.

  1921  * @param none

  1922  * @return none

  1923  */

  1924 void CT_CMMFDevSoundData::DoCmdPlayInitL(const TInt aAsyncErrorIndex)

  1925 	{

  1926 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdPlayInitL"));

  1927 	TRAPD(error, iDevSound->PlayInitL());

  1928 	if (error != KErrNone)

  1929 		{

  1930 		ERR_PRINTF2(_L("PlayInitL left with error %d"), error);

  1931 		SetError(error);

  1932 		}

  1933 	else

  1934 		{

  1935         iAsyncErrorIndex_play = aAsyncErrorIndex;

  1936 		IncOutstanding();

  1937 		}

  1938 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdPlayInitL"));

  1939 	}

  1941 /**

  1942  * Initializes the audio device and starts playing a tone. The tone is played with the

  1943  * frequency and duration specified.

  1944  * @param aSection - Section to read params from the ini file

  1945  * @return none

  1946  */

  1947 void CT_CMMFDevSoundData::DoCmdPlayToneL(const TTEFSectionName& aSection,  const TInt aAsyncErrorIndex)

  1948 	{

  1949 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdPlayToneL"));

  1950 	TBool dataOk = ETrue;

  1951 	TInt frequency;

  1952 	if (!GetIntFromConfig(aSection, KFrequency, frequency))

  1953 		{

  1954 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KFrequency);

  1955 		SetBlockResult(EFail);

  1956 		dataOk = EFalse;

  1957 		}

  1959 	TInt duration;

  1960 	if (!GetIntFromConfig(aSection, KDuration, duration))

  1961 		{

  1962 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KDuration);

  1963 		SetBlockResult(EFail);

  1964 		dataOk = EFalse;

  1965 		}

  1966 	if(dataOk)

  1967 		{

  1968 		TRAPD(error, iDevSound->PlayToneL(frequency, duration));

  1969 		if (error != KErrNone)

  1970 			{

  1971 			ERR_PRINTF2(_L("Play tone failed with error %d"), error);

  1972 			SetError(error);

  1973 			}

  1974 		else

  1975 			{

  1976             iAsyncErrorIndex_tone = aAsyncErrorIndex;

  1977 			IncOutstanding();

  1978 			}

  1979 		}

  1980 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdPlayToneL"));

  1981 	}

  1983 /**

  1984  * Initializes the audio device and starts playing a tone sequence.

  1985  * @param aSection - Section to read param from the ini file

  1986  * @return none

  1987  */

  1988 void CT_CMMFDevSoundData::DoCmdPlayToneSequenceL(const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

  1989 	{

  1990 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdPlayToneSequenceL"));

  1991 	TBool dataOk = ETrue;

  1992 	TPtrC toneFileParameter;

  1993 	if (!GetStringFromConfig(aSection, KFilename, toneFileParameter))

  1994 		{

  1995 		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KFilename);

  1996 		SetBlockResult(EFail);

  1997 		dataOk = EFalse;

  1998 		}

  1999 	if(dataOk)

  2000 		{

  2001 		TInt error = iToneFile.Open(iFs, toneFileParameter, EFileRead);

  2002 		if (error != KErrNone)

  2003 			{

  2004 			ERR_PRINTF2(_L("Open file failed with error %d"), error);

  2005 			SetError(EFail);

  2006 			}

  2007 		else

  2008 			{

  2009 			error = iToneFile.Read(iToneSequence);

  2010 			if (error != KErrNone)

  2011 				{

  2012 				ERR_PRINTF2(_L("Read file failed with error %d"), error);

  2013 				SetError(EFail);

  2014 				}

  2015 			else

  2016 				{

  2017 				TRAP(error, iDevSound->PlayToneSequenceL(iToneSequence));

  2018 				if (error != KErrNone)

  2019 					{

  2020 					ERR_PRINTF2(_L("Play tone sequence failed with error %d"), error);

  2021 					SetError(error);

  2022 					}

  2023 				else

  2024 					{

  2025                     iAsyncErrorIndex_tone = aAsyncErrorIndex;

  2026 					IncOutstanding();

  2027 					}

  2028 				}

  2029 			}

  2030 		}

  2031 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdPlayToneSequenceL"));

  2032 	}

  2034 /**

  2035  * Contine the process of recording.

  2036  *

  2037  * Once the buffer is filled with recorded  data, the Observer gets a reference to the buffer along

  2038  * with the callback function BufferToBeEmptied(). After processing the buffer (copying over to a

  2039  * different buffer or writing to file) the client should call this function to continue the

  2040  * recording process.

  2041  * @param none

  2042  * @return none

  2043  */

  2044 void CT_CMMFDevSoundData::DoCmdRecordData()

  2045 	{

  2046 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdRecordData"));

  2047 	RecordData();

  2048 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdRecordData"));

  2049 	}

  2051 /**

  2052  * Helper method to DoCmdRecordData command

  2053  */

  2054 void CT_CMMFDevSoundData::RecordData()

  2055 	{

  2056 	iDevSound->RecordData();

  2057 	}

  2059 /**

  2060  * Initializes audio device and starts the recording process.

  2061  *

  2062  * This command queries and acquires the audio policy before initializing audio device. If there

  2063  * was an error during policy initialization, RecordError() function will be called on the observer

  2064  * with error code KErrAccessDenied, otherwise BufferToBeEmptied()  function will be called with a

  2065  * buffer reference. This buffer contains recorded  or encoded data. After processing data in the

  2066  * buffer reference passed, the client should call RecordData() to continue recording process.

  2067  *

  2068  * The amount of data that is available is specified in CMMFBuffer::RequestSize().

  2069  * @param none

  2070  * @return none

  2071  */

  2072 void CT_CMMFDevSoundData::DoCmdRecordInitL(const TInt aAsyncErrorIndex)

  2073 	{

  2074 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdRecordInitL"));

  2075     iAsyncErrorIndex_record = aAsyncErrorIndex;

  2076 	TRAPD(error, iDevSound->RecordInitL());

  2077 	if (error != KErrNone)

  2078 		{

  2079 		ERR_PRINTF2(_L("RecordInitL left with error %d"), error);

  2080 		SetError(error);

  2081 		}

  2082 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdRecordInitL"));

  2083 	}

  2086 /**

  2087  * Conceal an error

  2088  * @param none

  2089  * @return none

  2090  */

  2091 void CT_CMMFDevSoundData::DoCmdUtilityErrorConceal()

  2092 	{

  2093 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdErrorConceal"));

  2094 	iErrorConceal=ETrue;

  2095 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdErrorConceal"));

  2096 	}

  2098 /**

  2099  * Stop an audio file

  2100  * @param none

  2101  * @return none

  2102  */

  2103 void CT_CMMFDevSoundData::DoCmdStop(const TTEFSectionName& aSection)

  2104 	{

  2105 	INFO_PRINTF1(_L("*START*CT_CMMFDevSoundData::DoCmdStop"));

  2106 	TBool pause;

  2107 	if(!GetBoolFromConfig(aSection,KPause,pause))

  2108 		{

  2109 		INFO_PRINTF1(_L("The DoCmdStop command will be execute"));

  2110 		pause = EFalse;

  2111 		}

  2112 	iPaused=pause;

  2113 	if(iPaused)

  2114 		{

  2115 		INFO_PRINTF1(_L("a Pause was required"));

  2116 		}

  2117 	Stop();

  2118 	INFO_PRINTF1(_L("*END*CT_CMMFDevSoundData::DoCmdStop"));

  2119 	}

  2124 /**

  2125  * Utility for get the HwDevice for play and recording

  2126  */

  2128 void CT_CMMFDevSoundData::UtilityFourCCToHwDeviceUidL(const TDesC& aFourCC, THwDeviceType aType, TUid& aHwDeviceUid)

  2129 	{

  2130 	TPtrC8 fourCCPtr(0,0);

  2131 	TPtrC8 fourCCP16Ptr(0,0);

  2132 	RImplInfoPtrArray impArray;

  2133 	CleanupResetAndDestroyPushL(impArray);

  2134 	REComSession::ListImplementationsL(TUid::Uid(KMmfUidPluginInterfaceHwDevice), impArray);

  2135 	TBuf<KHwDeviceDefaultDataLength> datatype;

  2136 	for(TInt i = 0; i < impArray.Count(); ++i)

  2137 		{

  2138 		CImplementationInformation& entry = *(impArray[i]);

  2139 		// Validate lenght

  2140 		if (entry.DataType().Length() == KHwDeviceDefaultDataLength)

  2141 			{

  2142 			INFO_PRINTF2(_L("Implementation UID=0x%08x"),entry.ImplementationUid());

  2143 			datatype.Copy(entry.DataType());

  2144 			INFO_PRINTF2(_L("Default data (fourCCs)=%S"), &datatype);

  2145 			// Extract FourCC

  2146 			if(aType == EDecoder)

  2147 				{

  2148 				fourCCPtr.Set(entry.DataType().Left(KFourCCLength));

  2149 				fourCCP16Ptr.Set(entry.DataType().Right(KFourCCLength));

  2150 				}

  2151 			else if (aType == EEncoder)

  2152 				{

  2153 				fourCCPtr.Set(entry.DataType().Right(KFourCCLength));

  2154 				fourCCP16Ptr.Set(entry.DataType().Left(KFourCCLength));

  2155 				}

  2156 			// Compare FourCC

  2157 			TBuf16<4> foundFourCC;

  2158 			foundFourCC.Copy(fourCCPtr);

  2159 			if(aFourCC.CompareF(foundFourCC) == 0)

  2160 				{

  2161 				aHwDeviceUid = entry.ImplementationUid();

  2162 				break;

  2163 				}

  2164 			}

  2165 		}

  2166 	CleanupStack::PopAndDestroy(&impArray);

  2167 	REComSession::FinalClose();

  2168 	}

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