1 /*

     2 * Copyright (c) 2006-2008 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: Audio Stubs -  DevSound adaptation stub body implementation.

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <e32base.h>

    21 #include <mdaaudiotoneplayer.h>

    22 

    23 #include "G711DecoderIntfc.h"

    24 #include "G729DecoderIntfc.h"

    25 #include "IlbcDecoderIntfc.h"

    26 #include "G711EncoderIntfc.h"

    27 #include "G729EncoderIntfc.h"

    28 #include "IlbcEncoderIntfc.h"

    29 #include "ErrorConcealmentIntfc.h"

    30 #include "SpeechEncoderConfig.h"

    31 

    32 #include "AudioInputMessageTypes.h"

    33 #include "AudioOutputMessageTypes.h"

    34 //#include "AudioResourceMessageTypes.h"

    35 

    36 #include "AudioInputCI.h"

    37 #include "AudioOutputCI.h"

    38 #include "G711DecoderIntfcCI.h"

    39 #include "G729DecoderIntfcCI.h"

    40 #include "IlbcDecoderIntfcCI.h"

    41 #include "G711EncoderIntfcCI.h"

    42 #include "G729EncoderIntfcCI.h"

    43 #include "IlbcEncoderIntfcCI.h"

    44 #include "ErrorConcealmentIntfcCI.h"

    45 #include "SpeechEncoderConfigCI.h"

    46 

    47 //#include <AudioResourceCIStub.h>

    48 //#include <AudioEqualizerCI.h>

    49 //#include <EnvironmentalReverbCI.h>

    50 //#include <StereoWideningCI.h>

    51 //#include <BassBoostCI.h>

    52 //#include <SourceDopplerBase.h>

    53 //#include <ListenerDopplerBase.h>

    54 //#include <SourceDopplerCI.h>

    55 //#include <ListenerDopplerCI.h>

    56 //#include <ListenerLocationCI.h>

    57 //#include <SourceLocationCI.h>

    58 //#include <ListenerOrientationCI.h>

    59 //#include <SourceOrientationCI.h>

    60 //#include <DistanceAttenuationCI.h>

    61 //#include <LoudnessCI.h>

    62 

    63 //#include <AddedDevSoundControlCI.h>

    64 //#include <AddedDevSoundControlCIStub.h>

    65 //#include <RestrictedAudioOutputCI.h>

    66 

    67 #include "MmfDevSoundAdaptationBody.h"

    68 #include "MmfHwDeviceStub.h"

    69 #include "TonePlayCompleteTimer.h"

    70 

    71 

    72 // CONSTANTS

    73 #ifdef _DEBUG

    74 #include "e32debug.h"

    75 

    76 #define DEBPRN0(str)                RDebug::Print(str, this)

    77 #define DEBPRN1(str, val1)          RDebug::Print(str, this, val1)

    78 #define DEBPRN2(str, val1, val2)    RDebug::Print(str, this, val1, val2)

    79 #else

    80 #define DEBPRN0(str)

    81 #define DEBPRN1(str, val1)

    82 #define DEBPRN2(str, val1, val2)

    83 #endif //_DEBUG

    84 

    85 

    86 const TUint KMaxVolume = 10;

    87 const TUint KToneSamplingRate = 8000;

    88 const TUint KToneChannels = 2;

    89 // Time to play one note 1/10th of 1/2 a second

    90 const TUint KToneNotePlayTime = 50000;

    91 

    92 // ============================ MEMBER FUNCTIONS ===============================

    93 

    94 // -----------------------------------------------------------------------------

    95 // CMMFDevSoundAdaptation::CBody::CBody

    96 // C++ default constructor can NOT contain any code, that

    97 // might leave.

    98 // -----------------------------------------------------------------------------

    99 //

   100 CMMFDevSoundAdaptation::CBody::CBody()

   101     {

   102     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CBody"));

   103     iMode= EMMFStateIdle;

   104     //Set reasonable default values for DTMF

   105     iDTMFGen.SetToneDurations(250000,50000,250000);

   106     }

   107 

   108 // -----------------------------------------------------------------------------

   109 // CMMFDevSoundAdaptation::CBody::ConstructL

   110 // Symbian 2nd phase constructor can leave.

   111 // assumes that iParent has already been set up properly

   112 // -----------------------------------------------------------------------------

   113 //

   114 void CMMFDevSoundAdaptation::CBody::ConstructL(

   115     RServer2& /*aPolicyServerHandle*/)

   116     {

   117     // Default

   118     // set the default capability

   119     iDeviceCapabilities.iRate = EMMFSampleRate8000Hz;

   120     iDeviceCapabilities.iEncoding = EMMFSoundEncoding16BitPCM;

   121     iDeviceCapabilities.iChannels = EMMFMono;

   122     iDeviceCapabilities.iBufferSize = KBufferLength;

   123 

   124     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::ConstructL:EXIT"));

   125     }

   126 

   127 // -----------------------------------------------------------------------------

   128 // CMMFDevSoundAdaptation::CBody::NewL

   129 // Two-phased constructor.

   130 // -----------------------------------------------------------------------------

   131 //

   132 CMMFDevSoundAdaptation::CBody* CMMFDevSoundAdaptation::CBody::NewL()

   133     {

   134     CMMFDevSoundAdaptation::CBody* self = new (ELeave) CBody;

   135     return self;

   136     }

   137 

   138 

   139 // -----------------------------------------------------------------------------

   140 // CMMFDevSoundAdaptation::CBodye::~CBody

   141 // Destructor

   142 // -----------------------------------------------------------------------------

   143 //

   144 CMMFDevSoundAdaptation::CBody::~CBody()

   145     {

   146     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::~CBody:ENTER"));

   147     delete iToneBuffer1;

   148     delete iToneBuffer2;

   149     delete iDevSoundUtil;

   150     delete iFixedSequences;

   151     delete iCMMFHwDevice;

   152     delete iTonePlayCompleteTimer;

   153     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::~CBody:EXIT"));

   154     }

   155 

   156 

   157 // -----------------------------------------------------------------------------

   158 // CMMFDevSoundAdaptation::CBody::InitializeL

   159 // Initializes CMMFDevSoundProxy object to play and record PCM16 raw audio data

   160 // with sampling rate of 8 KHz.

   161 //

   162 // On completion of Initialization, calls InitializeComplete() on

   163 // aDevSoundObserver.

   164 // (other items were commented in a header).

   165 // -----------------------------------------------------------------------------

   166 //

   167 void CMMFDevSoundAdaptation::CBody::InitializeL(

   168     MDevSoundAdaptationObserver& aDevSoundObserver,

   169     TMMFState aMode)

   170     {

   171     // if no HwDevice id specified, load default null implementation

   172     TUid rawUid = {0};

   173     InitializeL(aDevSoundObserver, rawUid, aMode);

   174     }

   175 

   176 // -----------------------------------------------------------------------------

   177 // CMMFDevSoundAdaptation::CBody::InitializeL

   178 // Initializes DevSound object for the mode aMode for processing audio data

   179 // with hardware device aHWDev.

   180 //

   181 // On completion of Initialization, the observer will be notified via call back

   182 // InitializeComplete().

   183 //

   184 // Leaves on failure.

   185 // (other items were commented in a header).

   186 // -----------------------------------------------------------------------------

   187 //

   188 void CMMFDevSoundAdaptation::CBody::InitializeL(

   189     MDevSoundAdaptationObserver& aDevSoundObserver,

   190     TUid aHWDev,

   191     TMMFState aMode)

   192     {

   193     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::InitializeL:ENTER"));

   194     TInt initError = KErrNone;

   195     iDevSoundObserver = &aDevSoundObserver;

   196 

   197     if (aMode == EMMFStateIdle)

   198         {

   199         User::Leave(KErrNotSupported);

   200         }

   201     iMode= aMode;

   202 

   203 

   204     iDevSoundObserver = &aDevSoundObserver;

   205     iHwDeviceID.iUid = aHWDev.iUid;

   206     if(iCMMFHwDevice)

   207         {

   208         delete iCMMFHwDevice;

   209         iHwDeviceBuffer = NULL; // buffer is deleted by HwDevice delete

   210         }

   211 

   212     iCMMFHwDevice = NULL;

   213     iCMMFHwDevice = CMMFHwDeviceStub::NewL();

   214 

   215     iDevInfo.iHwDeviceObserver = this;

   216     initError = iCMMFHwDevice->Init(iDevInfo);

   217 

   218     iDevSoundObserver->InitializeComplete(initError);

   219 

   220     if (initError)

   221         {

   222         User::Leave(initError);

   223         }

   224     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::InitializeL:EXIT"));

   225     }

   226 

   227 // -----------------------------------------------------------------------------

   228 // CMMFDevSoundAdaptation::CBody::InitializeL

   229 // Initializes DevSound object for the mode aMode for processing audio data

   230 // with hardware device supporting FourCC aDesiredFourCC.

   231 //

   232 // On completion of Initialization, the observer will be notified via call back

   233 // InitializeComplete().

   234 //

   235 // Leaves on failure.

   236 // (other items were commented in a header).

   237 // -----------------------------------------------------------------------------

   238 //

   239 void CMMFDevSoundAdaptation::CBody::InitializeL(

   240     MDevSoundAdaptationObserver& aDevSoundObserver,

   241     TFourCC /*aDesiredFourCC*/,

   242     TMMFState aMode)

   243     {

   244     TUid implUid = {0};

   245     InitializeL(aDevSoundObserver, implUid, aMode);

   246     }

   247 

   248 // -----------------------------------------------------------------------------

   249 // CMMFDevSoundAdaptation::CBody::Capabilities

   250 // Returns the supported Audio settings.

   251 // (other items were commented in a header).

   252 // -----------------------------------------------------------------------------

   253 //

   254 TMMFCapabilities CMMFDevSoundAdaptation::CBody::Capabilities()

   255     {

   256     return iDeviceCapabilities;

   257     }

   258 

   259 // -----------------------------------------------------------------------------

   260 // CMMFDevSoundAdaptation::CBody::Config

   261 // Returns the current audio settings.

   262 // (other items were commented in a header).

   263 // -----------------------------------------------------------------------------

   264 //

   265 TMMFCapabilities CMMFDevSoundAdaptation::CBody::Config() const

   266     {

   267     return iDeviceConfig;

   268     }

   269 

   270 // -----------------------------------------------------------------------------

   271 // CMMFDevSoundAdaptation::CBody::SetConfigL

   272 // Configure CMMFDevSoundProxy object for the settings in aConfig.

   273 // Use this to set sampling rate, Encoding and Mono/Stereo.

   274 // As part of defect 20796, the iRecordFormat has been set under the iPlayFormat,

   275 //  before it was not set at all.

   276 // (other items were commented in a header).

   277 // -----------------------------------------------------------------------------

   278 //

   279 void CMMFDevSoundAdaptation::CBody::SetConfigL(

   280     const TMMFCapabilities& aConfig)

   281     {

   282     iDeviceConfig = aConfig;

   283 

   284     // Fix to WAV recording problem.

   285     // A kludge to init channel number to 'something' in case the device returns 0.

   286     if (!iDeviceConfig.iChannels)

   287         {

   288         iDeviceConfig.iChannels = EMMFMono;

   289         }

   290     }

   291 

   292 // -----------------------------------------------------------------------------

   293 // CMMFDevSoundAdaptation::CBody::MaxVolume

   294 // Returns an integer representing the maximum volume.

   295 // This is the maximum value which can be passed to CMMFDevSoundProxy::SetVolume.

   296 // (other items were commented in a header).

   297 // -----------------------------------------------------------------------------

   298 //

   299 TInt CMMFDevSoundAdaptation::CBody::MaxVolume()

   300     {

   301     return KMaxVolume;

   302     }

   303 

   304 // -----------------------------------------------------------------------------

   305 // CMMFDevSoundAdaptation::CBody::Volume

   306 // Returns an integer representing the current volume.

   307 // (other items were commented in a header).

   308 // -----------------------------------------------------------------------------

   309 //

   310 TInt CMMFDevSoundAdaptation::CBody::Volume()

   311     {

   312     return iVolume;

   313     }

   314 

   315 // -----------------------------------------------------------------------------

   316 // CMMFDevSoundAdaptation::CBody::SetVolume

   317 // Changes the current playback volume to a specified value.

   318 // The volume can be changed before or during playback and is effective

   319 // immediately.

   320 // (other items were commented in a header).

   321 // -----------------------------------------------------------------------------

   322 //

   323 void CMMFDevSoundAdaptation::CBody::SetVolume(

   324     TInt aVolume)

   325     {

   326     // Check and make sure that the volume is in valid range

   327     if (aVolume < 0)

   328         {

   329         aVolume = 0;

   330         }

   331     if (aVolume > MaxVolume())

   332         {

   333         aVolume = MaxVolume();

   334         }

   335     iVolume = aVolume;

   336     }

   337 

   338 // -----------------------------------------------------------------------------

   339 // CMMFDevSoundAdaptation::CBody::MaxGain

   340 // Returns an integer representing the maximum gain.

   341 // This is the maximum value which can be passed to CMMFDevSoundProxy::SetGain.

   342 // (other items were commented in a header).

   343 // -----------------------------------------------------------------------------

   344 //

   345 TInt CMMFDevSoundAdaptation::CBody::MaxGain()

   346     {

   347     return KMaxVolume;//uses iMaxVolume for iMaxGain

   348     }

   349 

   350 // -----------------------------------------------------------------------------

   351 // CMMFDevSoundAdaptation::CBody::Gain

   352 // Returns an integer representing the current gain.

   353 // (other items were commented in a header).

   354 // -----------------------------------------------------------------------------

   355 //

   356 TInt CMMFDevSoundAdaptation::CBody::Gain()

   357     {

   358     return iGain;

   359     }

   360 

   361 // -----------------------------------------------------------------------------

   362 // CMMFDevSoundAdaptation::CBody::SetGain

   363 // Changes the current recording gain to a specified value.

   364 //

   365 // The gain can be changed before or during recording and is effective

   366 // immediately.

   367 // (other items were commented in a header).

   368 // -----------------------------------------------------------------------------

   369 //

   370 void CMMFDevSoundAdaptation::CBody::SetGain(TInt aGain)

   371     {

   372     // make sure it falls with the correct range

   373     if (aGain > MaxGain())

   374         {

   375         aGain = MaxGain();

   376         }

   377     else if (aGain < 0)

   378         {

   379         aGain = 0;

   380         }

   381     iGain = aGain;

   382     }

   383 

   384 // -----------------------------------------------------------------------------

   385 // CMMFDevSoundAdaptation::CBody::GetPlayBalanceL

   386 // Returns the speaker balance set for playing.

   387 // Leaves on failure.

   388 // (other items were commented in a header).

   389 // -----------------------------------------------------------------------------

   390 //

   391 void CMMFDevSoundAdaptation::CBody::GetPlayBalanceL(

   392     TInt& aLeftPercentage,

   393     TInt& aRightPercentage)

   394     {

   395     aLeftPercentage = iLeftPlayBalance;

   396     aRightPercentage = iRightPlayBalance;

   397     }

   398 

   399 // -----------------------------------------------------------------------------

   400 // CMMFDevSoundAdaptation::CBody::SetPlayBalanceL

   401 // Sets the speaker balance for playing.

   402 // The speaker balance can be changed before or during playback and is

   403 // effective immediately.

   404 // (other items were commented in a header).

   405 // -----------------------------------------------------------------------------

   406 //

   407 void CMMFDevSoundAdaptation::CBody::SetPlayBalanceL(

   408     TInt aLeftPercentage,

   409     TInt aRightPercentage)

   410     {

   411     if (aLeftPercentage < 0)

   412         {

   413         aLeftPercentage = 0;

   414         }

   415     else if (aLeftPercentage > 100)

   416         {

   417         aLeftPercentage = 100;

   418         }

   419     if (aRightPercentage < 0)

   420         {

   421         aRightPercentage = 0;

   422         }

   423     else if (aRightPercentage > 100)

   424         {

   425         aRightPercentage = 100;

   426         }

   427     iLeftPlayBalance = aLeftPercentage;

   428     iRightPlayBalance = aRightPercentage;

   429     }

   430 

   431 // -----------------------------------------------------------------------------

   432 // CMMFDevSoundAdaptation::CBody::GetRecordBalanceL

   433 // Returns the microphone gain balance set for recording.

   434 // Leaves on failure.

   435 // (other items were commented in a header).

   436 // -----------------------------------------------------------------------------

   437 //

   438 void CMMFDevSoundAdaptation::CBody::GetRecordBalanceL(

   439     TInt& aLeftPercentage,

   440     TInt& aRightPercentage)

   441     {

   442     aLeftPercentage = iLeftRecordBalance;

   443     aRightPercentage = iRightRecordBalance;

   444     }

   445 

   446 // -----------------------------------------------------------------------------

   447 // CMMFDevSoundAdaptation::CBody::SetRecordBalanceL

   448 // Sets the microphone gain balance for recording.

   449 // The microphone gain balance can be changed before or during recording and

   450 // is effective immediately.

   451 // (other items were commented in a header).

   452 // -----------------------------------------------------------------------------

   453 //

   454 void CMMFDevSoundAdaptation::CBody::SetRecordBalanceL(

   455     TInt aLeftPercentage,

   456     TInt aRightPercentage)

   457     {

   458     if (aLeftPercentage < 0)

   459         {

   460         aLeftPercentage = 0;

   461         }

   462     else if (aLeftPercentage > 100)

   463         {

   464         aLeftPercentage = 100;

   465         }

   466     if (aRightPercentage < 0)

   467         {

   468         aRightPercentage = 0;

   469         }

   470     else if (aRightPercentage > 100)

   471         {

   472         aRightPercentage = 100;

   473         }

   474     iLeftRecordBalance = aLeftPercentage;

   475     iRightRecordBalance = aRightPercentage;

   476     }

   477 

   478 // -----------------------------------------------------------------------------

   479 // CMMFDevSoundAdaptation::CBody::PlayInitL

   480 // Initializes audio device and start play process. This method queries and

   481 // acquires the audio policy before initializing audio device. If there was an

   482 // error during policy initialization, PlayError() method will be called on

   483 // the observer with error code KErrAccessDenied, otherwise BufferToBeFilled()

   484 // method will be called with a buffer reference. After reading data into the

   485 // buffer reference passed, the client should call PlayData() to play data.

   486 //

   487 // The amount of data that can be played is specified in

   488 // CMMFBuffer::RequestSize(). Any data that is read into buffer beyond this

   489 // size will be ignored.

   490 //

   491 // Leaves on failure.

   492 // (other items were commented in a header).

   493 // -----------------------------------------------------------------------------

   494 //

   495 void CMMFDevSoundAdaptation::CBody::PlayInitL()

   496     {

   497     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayInitL"));

   498     if (!iDevSoundObserver)

   499         {

   500         User::Leave(KErrNotReady);

   501         }

   502 

   503     StartPlayDataL();

   504     }

   505 

   506 // -----------------------------------------------------------------------------

   507 // CMMFDevSoundAdaptation::CBody::RecordInitL

   508 // Initializes audio device and start record process. This method queries and

   509 // acquires the audio policy before initializing audio device. If there was an

   510 // error during policy initialization, RecordError() method will be called on

   511 // the observer with error code KErrAccessDenied, otherwise BufferToBeEmptied()

   512 // method will be called with a buffer reference. This buffer contains recorded

   513 // or encoded data. After processing data in the buffer reference passed, the

   514 // client should call RecordData() to continue recording process.

   515 //

   516 // The amount of data that is available is specified in

   517 // CMMFBuffer::RequestSize().

   518 //

   519 // Leaves on failure.

   520 // (other items were commented in a header).

   521 // -----------------------------------------------------------------------------

   522 //

   523 void CMMFDevSoundAdaptation::CBody::RecordInitL()

   524     {

   525     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::RecordInitL"));

   526     if (!iDevSoundObserver)

   527         {

   528         User::Leave(KErrNotReady);

   529         }

   530 

   531     StartRecordDataL();

   532     }

   533 

   534 // -----------------------------------------------------------------------------

   535 // CMMFDevSoundAdaptation::CBody::PlayData

   536 // Plays data in the buffer at the current volume. The client should fill

   537 // the buffer with audio data before calling this method. The Observer gets

   538 // reference to buffer along with callback BufferToBeFilled(). When playing of

   539 // the audio sample is complete, successfully or otherwise, the method

   540 // PlayError() on observer is called.

   541 // (other items were commented in a header).

   542 // -----------------------------------------------------------------------------

   543 //

   544 void CMMFDevSoundAdaptation::CBody::PlayData()

   545     {

   546     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayData"));

   547     ASSERT(iDevSoundObserver);

   548 

   549     if (iMode== EMMFStateIdle)

   550         {

   551         return;

   552         }

   553 

   554     TInt error = KErrNone;

   555 

   556     if(iCMMFHwDevice)

   557         {

   558         if (iPaused)

   559             {

   560             iPaused = EFalse;

   561             //note PlayData does not leave or return an error code so the

   562             //Start() fails we cannot report the error back at this point

   563             if (iCMMFHwDevice->IsActive())

   564                 {

   565                 iCMMFHwDevice->Cancel();

   566                 }

   567             //restart hw device after pause

   568             error = iCMMFHwDevice->Start(EDevDecode, EDevOutFlow);

   569             }

   570        else if(iMode== EMMFStatePlaying)

   571             {

   572             TInt len = iHwDeviceBuffer->Data().Length();

   573             iPlayedBytesCount += len;

   574             if (iHwDeviceBuffer->LastBuffer())

   575                 {

   576                 iLastBufferReceived = ETrue;

   577                 }

   578 

   579             // Pass the data buffer to HwDevice

   580             if (iMode== EMMFStatePlaying)

   581                 {

   582                 error = iCMMFHwDevice->ThisHwBufferFilled(*iHwDeviceBuffer);

   583                 }

   584             }

   585         }

   586     if (error != KErrNone)

   587         {

   588         iDevSoundObserver->PlayError(error);

   589         }

   590     }

   591 

   592 // -----------------------------------------------------------------------------

   593 // CMMFDevSoundAdaptation::CBody::RecordData

   594 // Contine the process of recording. Once the buffer is filled with recorded

   595 // data, the Observer gets reference to buffer along with callback

   596 // BufferToBeEmptied(). After processing the buffer (copying over to a

   597 // different buffer or writing to file) the client should call this

   598 // method to continue recording process.

   599 // (other items were commented in a header).

   600 // -----------------------------------------------------------------------------

   601 //

   602 void CMMFDevSoundAdaptation::CBody::RecordData()

   603     {

   604     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::RecordData"));

   605     ASSERT(iDevSoundObserver);

   606     if(iCMMFHwDevice)

   607         {

   608         if(iMode == EMMFStateRecording)

   609             {

   610             // Fix to WAV recording issue.

   611             // In case of real DevSound adaptation implementation, the

   612             // CMMFSwCodecRecordDataPath sets the last buffer parameter when no

   613             // more data is in the buffer to process. In case of the stub, this

   614             // never gets set as the s/w codec is not involved - we are simply

   615             // copying same fixed 4k block of data over and over again. So, on

   616             // pause or stop we need to indicate to the data path that we no

   617             // longer need processing of data by manually setting last buffer

   618             // parameter and resetting requested data size to 0.

   619             if (iPaused)

   620                 {

   621                 iHwDeviceBuffer->SetLastBuffer(ETrue);

   622                 iHwDeviceBuffer->Data().SetLength(0);

   623                 }

   624             else

   625                 {

   626                 iHwDeviceBuffer->Data().SetLength(iHwDeviceBuffer->RequestSize());

   627                 }

   628 

   629             iCMMFHwDevice->ThisHwBufferEmptied(*iHwDeviceBuffer);

   630             }

   631         }

   632     }

   633 

   634 // -----------------------------------------------------------------------------

   635 // CMMFDevSoundAdaptation::CBody::Stop

   636 // Stops the ongoing operation (Play, Record, TonePlay, Convert)

   637 // (other items were commented in a header).

   638 // -----------------------------------------------------------------------------

   639 //

   640 void CMMFDevSoundAdaptation::CBody::Stop()

   641     {

   642     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::Stop"));

   643 

   644     iPaused = EFalse;

   645 

   646     if (iMode== EMMFStateIdle)

   647         {

   648         return;

   649         }

   650 

   651     // For custom interface

   652 

   653      // Stop the hw device first - this unloads sound drivers

   654     if(iCMMFHwDevice)

   655         {

   656         iCMMFHwDevice->Stop();

   657         }

   658 

   659     if ((iMode== EMMFStateTonePlaying) && (iTonePlayCompleteTimer))

   660         {

   661         iTonePlayCompleteTimer->Cancel();

   662         }

   663 

   664     }

   665 

   666 // -----------------------------------------------------------------------------

   667 // CMMFDevSoundAdaptation::CBody::Pause

   668 // Temporarily Stops the ongoing operation (Play, Record, TonePlay, Convert)

   669 // (other items were commented in a header).

   670 // -----------------------------------------------------------------------------

   671 //

   672 void CMMFDevSoundAdaptation::CBody::Pause()

   673     {

   674     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::Pause"));

   675     iPaused = ETrue;

   676 

   677     if (iMode== EMMFStateIdle)

   678         {

   679         return;

   680         }

   681 

   682     // Pause the HW device first

   683     if(iCMMFHwDevice)

   684         {

   685         iCMMFHwDevice->Pause();

   686         }

   687     }

   688 

   689 // -----------------------------------------------------------------------------

   690 // CMMFDevSoundAdaptation::CBody::SamplesRecorded

   691 // Returns the sample recorded so far.

   692 // (other items were commented in a header).

   693 // -----------------------------------------------------------------------------

   694 //

   695 TInt CMMFDevSoundAdaptation::CBody::SamplesRecorded()

   696     {

   697     TInt samples = 0;

   698     samples = iRecordedBytesCount;

   699     if(NumberOfChannels() > 1)

   700         {

   701         samples /= NumberOfChannels();

   702         }

   703     if(BytesPerAudioSample() > 1)

   704         {

   705         samples /= BytesPerAudioSample();

   706         }

   707     return samples;

   708     }

   709 

   710 // -----------------------------------------------------------------------------

   711 // CMMFDevSoundAdaptation::CBody::SamplesPlayed

   712 // Returns the sample played so far.

   713 // (other items were commented in a header).

   714 // -----------------------------------------------------------------------------

   715 //

   716 TInt CMMFDevSoundAdaptation::CBody::SamplesPlayed()

   717     {

   718     TInt samples = 0;

   719     samples = iPlayedBytesCount;

   720     if(NumberOfChannels() > 1)

   721         {

   722         samples /= NumberOfChannels();

   723         }

   724 

   725     if(BytesPerAudioSample() > 1)

   726         {

   727         samples /= BytesPerAudioSample();

   728         }

   729     return samples; //each sample is 2 bytes

   730     }

   731 

   732 // -----------------------------------------------------------------------------

   733 // CMMFDevSoundAdaptation::CBody::PlayToneL

   734 // Initializes audio device and start playing tone. Tone is played with

   735 // frequency and for duration specified.

   736 //

   737 // Leaves on failure.

   738 // (other items were commented in a header).

   739 // -----------------------------------------------------------------------------

   740 //

   741 void CMMFDevSoundAdaptation::CBody::PlayToneL(

   742     TInt aFrequency,

   743     const TTimeIntervalMicroSeconds& aDuration)

   744     {

   745     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayToneL"));

   746     if (iMode!= EMMFStateTonePlaying)

   747         {

   748         //tone playing only supported in tone play state

   749         User::Leave(KErrNotSupported);

   750         }

   751     // Check whether frequency and duration is valid or not

   752     TInt64 zeroInt64(0);

   753     if ((aFrequency<0) || (aDuration.Int64() < zeroInt64))

   754         {

   755         User::Leave(KErrArgument);

   756         }

   757     if (!iDevSoundObserver)

   758         {

   759         User::Leave(KErrNotReady);

   760         }

   761     iToneGen.SetFrequencyAndDuration(aFrequency,aDuration);

   762 

   763     StartPlayToneL();

   764     }

   765 

   766 // -----------------------------------------------------------------------------

   767 // CMMFDevSoundAdaptation::CBody::PlayDualToneL

   768 // Initializes audio device and start playing a dual tone.

   769 // The tone consists of two sine waves of different frequencies summed together

   770 // Dual Tone is played with specified frequencies and for specified duration.

   771 // (other items were commented in a header).

   772 // -----------------------------------------------------------------------------

   773 //

   774 void CMMFDevSoundAdaptation::CBody::PlayDualToneL(

   775     TInt aFrequencyOne,

   776     TInt aFrequencyTwo,

   777     const TTimeIntervalMicroSeconds& aDuration)

   778     {

   779     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayDualToneL"));

   780 

   781     // Check whether frequencies and duration are valid or not

   782     TInt64 zeroInt64(0);

   783     if ((aFrequencyOne<0) || (aFrequencyTwo<0) ||

   784         (aDuration.Int64() < zeroInt64))

   785         {

   786         User::Leave(KErrArgument);

   787         }

   788     if (!iDevSoundObserver)

   789         {

   790         User::Leave(KErrNotReady);

   791         }

   792     iDualToneGen.SetFrequencyAndDuration(aFrequencyOne,

   793                                          aFrequencyTwo,

   794                                          aDuration);

   795     StartPlayDualToneL();

   796     }

   797 

   798 // -----------------------------------------------------------------------------

   799 // CMMFDevSoundAdaptation::CBody::PlayDTMFStringL

   800 // Initializes audio device and start playing DTMF string aDTMFString.

   801 // Leaves on failure.

   802 // (other items were commented in a header).

   803 // -----------------------------------------------------------------------------

   804 //

   805 void CMMFDevSoundAdaptation::CBody::PlayDTMFStringL(

   806     const TDesC& aDTMFString)

   807     {

   808     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayDTMFStringL"));

   809 

   810     if (!iDevSoundObserver)

   811         {

   812         User::Leave(KErrNotReady);

   813         }

   814     if (iMode!= EMMFStateTonePlaying)

   815         {

   816         //tone playing only supported in tone play state

   817         User::Leave(KErrNotSupported);

   818         }

   819     iDTMFGen.SetString(aDTMFString);

   820     StartPlayDTMFStringL();

   821     }

   822 

   823 // -----------------------------------------------------------------------------

   824 // CMMFDevSoundAdaptation::CBody::PlayToneSequenceL

   825 // Initializes audio device and start playing tone sequence.

   826 //

   827 // Leaves on failure.

   828 // (other items were commented in a header).

   829 // -----------------------------------------------------------------------------

   830 //

   831 void CMMFDevSoundAdaptation::CBody::PlayToneSequenceL(const TDesC8& aData)

   832     {

   833     DEBPRN1(

   834     _L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayToneSequenceL:Length[%d]"),

   835     aData.Length());

   836 

   837     if (!iDevSoundObserver)

   838         {

   839         User::Leave(KErrNotReady);

   840         }

   841     if (iMode!= EMMFStateTonePlaying)

   842         {

   843         //tone playing only supported in tone play state

   844         User::Leave(KErrNotSupported);

   845         }

   846 

   847     InitializeDevSoundUtilL();

   848     // Check whether the sequence is valid or not

   849     if (!iDevSoundUtil->RecognizeSequence(aData))

   850         {

   851         User::Leave(KErrCorrupt);

   852         }

   853 

   854     // For playing Tone sequence, we don't use PCM generator.

   855     // We use a timer instead

   856     // iSequenceGen.SetSequenceData(aData);

   857 

   858     if (!iTonePlayCompleteTimer)

   859         {

   860         iTonePlayCompleteTimer =

   861             CTonePlayCompleteTimer::NewL(*iDevSoundObserver);

   862         }

   863     // Determine the time out based on iRepeatCount and number of notes

   864     // in the sequence

   865     TUint repeats = ((iRepeatCount > 0) ? iRepeatCount : 1);

   866     TTimeIntervalMicroSeconds32 time(KToneNotePlayTime*aData.Length()*repeats);

   867     iTonePlayCompleteTimer->SetTimeOut(time);

   868 

   869     StartPlayToneSequenceL();

   870     }

   871 

   872 // -----------------------------------------------------------------------------

   873 // CMMFDevSoundAdaptation::CBody::PlayFixedSequenceL

   874 // Initializes audio device and start playing the specified pre-defined tone

   875 // sequence.

   876 //

   877 // Leaves on failure.

   878 // (other items were commented in a header).

   879 // -----------------------------------------------------------------------------

   880 //

   881 void CMMFDevSoundAdaptation::CBody::PlayFixedSequenceL(TInt aSequenceNumber)

   882     {

   883     DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::PlayFixedSequenceL"));

   884 

   885     if (!iDevSoundObserver)

   886         {

   887         User::Leave(KErrNotReady);

   888         }

   889     if (iMode!= EMMFStateTonePlaying)

   890         {

   891         //tone playing only supported in tone play state

   892         User::Leave(KErrNotSupported);

   893         }

   894     ASSERT((aSequenceNumber >= 0) &&

   895            (aSequenceNumber < iFixedSequences->Count()));

   896 

   897     iFixedSequence.Set(iFixedSequences->MdcaPoint(aSequenceNumber));

   898     iSequenceGen.SetSequenceData(iFixedSequence);

   899 

   900     StartPlayToneSequenceL();

   901     }

   902 

   903 // -----------------------------------------------------------------------------

   904 // CMMFDevSoundAdaptation::CBody::SetToneRepeats

   905 // Defines the number of times the audio is to be repeated during the tone

   906 // playback operation. A period of silence can follow each playing of tone.

   907 // The tone playing can be repeated indefinitely.

   908 // Supported only during tone playing.

   909 // (other items were commented in a header).

   910 // -----------------------------------------------------------------------------

   911 //

   912 void CMMFDevSoundAdaptation::CBody::SetToneRepeats(

   913     TInt aRepeatCount,

   914     const TTimeIntervalMicroSeconds& aRepeatTrailingSilence)

   915     {

   916     iRepeatCount = aRepeatCount;

   917     iRepeatTrailingSilence = aRepeatTrailingSilence;

   918     }

   919 

   920 // -----------------------------------------------------------------------------

   921 // CMMFDevSoundAdaptation::CBody::SetDTMFLengths

   922 // Defines the duration of tone on, tone off and tone pause to be used during the

   923 // DTMF tone playback operation.

   924 // Supported only during tone playing.

   925 // (other items were commented in a header).

   926 // -----------------------------------------------------------------------------

   927 //

   928 void CMMFDevSoundAdaptation::CBody::SetDTMFLengths(

   929     TTimeIntervalMicroSeconds32& aToneOnLength,

   930     TTimeIntervalMicroSeconds32& aToneOffLength,

   931     TTimeIntervalMicroSeconds32& aPauseLength)

   932     {

   933 

   934     if(aToneOnLength.Int() < KMdaInfiniteDurationDTMFToneOnLength)

   935         {

   936         aToneOnLength = TTimeIntervalMicroSeconds32(0);

   937         }

   938     if(aToneOffLength.Int() < 0)

   939         {

   940         aToneOffLength = TTimeIntervalMicroSeconds32(0);

   941         }

   942     if(aPauseLength.Int() < 0)

   943         {

   944         aPauseLength = TTimeIntervalMicroSeconds32(0);

   945         }

   946 

   947     iDTMFGen.SetToneDurations(aToneOnLength,aToneOffLength,aPauseLength);

   948     }

   949 

   950 // -----------------------------------------------------------------------------

   951 // CMMFDevSoundAdaptation::CBody::SetVolumeRamp

   952 // Defines the period over which the volume level is to rise smoothly from

   953 // nothing to the normal volume level.

   954 // (other items were commented in a header).

   955 // -----------------------------------------------------------------------------

   956 //

   957 void CMMFDevSoundAdaptation::CBody::SetVolumeRamp(

   958     const TTimeIntervalMicroSeconds& aRampDuration)

   959     {

   960     // save ramp duration for tone generator

   961     iRampDuration = aRampDuration;

   962     }

   963 

   964 // -----------------------------------------------------------------------------

   965 // CMMFDevSoundAdaptation::CBody::SetPrioritySettings

   966 // Defines the priority settings that should be used for this instance.

   967 // (other items were commented in a header).

   968 // -----------------------------------------------------------------------------

   969 //

   970 void CMMFDevSoundAdaptation::CBody::SetPrioritySettings(

   971     const TMMFPrioritySettings& /*aPrioritySettings*/)

   972     {

   973     }

   974 

   975 // -----------------------------------------------------------------------------

   976 // CMMFDevSoundAdaptation::CBody::CustomInterface

   977 // @see sounddevice.h

   978 // (other items were commented in a header).

   979 // -----------------------------------------------------------------------------

   980 //

   981 TAny* CMMFDevSoundAdaptation::CBody::CustomInterface(TUid aInterfaceId)

   982     {

   983 // Note: These can only be uncommented when supported by the

   984 //       MessageHandlerFactory and CustomInterfaceProxyFactory stubs.

   985 //       Will result in memory leak if re-enabled without updating of

   986 //       the proxy and message factory stubs.

   987 //

   988     DEBPRN1(

   989     _L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:InterfaceId[0x%x]"),

   990     aInterfaceId);

   991 

   992     if (aInterfaceId == KUidSpeechEncoderConfig)

   993         {

   994         TRAP_IGNORE(iSpeechEncoderConfigCI = CSpeechEncoderConfigCI::NewL());

   995         DEBPRN0(

   996         _L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CSpeechEncoderConfigCI..."));

   997         return iSpeechEncoderConfigCI;

   998         }

   999     else if (aInterfaceId == KUidErrorConcealmentIntfc)

  1000         {

  1001         TRAP_IGNORE(iErrorConcealmentIntfcCI = CErrorConcealmentIntfcCI::NewL());

  1002         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CErrorConcealmentIntfcCI..."));

  1003         return iErrorConcealmentIntfcCI;

  1004         }

  1005     else if (aInterfaceId == KUidG711DecoderIntfc)

  1006         {

  1007         TRAP_IGNORE(iG711DecoderIntfcCI = CG711DecoderIntfcCI::NewL());

  1008         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CG711DecoderIntfcCI..."));

  1009         return iG711DecoderIntfcCI;

  1010         }

  1011     else if (aInterfaceId == KUidG729DecoderIntfc)

  1012         {

  1013         TRAP_IGNORE(iG729DecoderIntfcCI = CG729DecoderIntfcCI::NewL());

  1014         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CG729DecoderIntfcCI..."));

  1015         return iG729DecoderIntfcCI;

  1016         }

  1017     else if (aInterfaceId == KUidIlbcDecoderIntfc)

  1018         {

  1019         TRAP_IGNORE(iIlbcDecoderIntfcCI = CIlbcDecoderIntfcCI::NewL());

  1020         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CIlbcDecoderIntfcCI..."));

  1021         return iIlbcDecoderIntfcCI;

  1022         }

  1023     else if (aInterfaceId == KUidG711EncoderIntfc)

  1024         {

  1025         TRAP_IGNORE(iG711EncoderIntfcCI = CG711EncoderIntfcCI::NewL());

  1026         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CG711EncoderIntfcCI..."));

  1027         return iG711EncoderIntfcCI;

  1028         }

  1029     else if (aInterfaceId == KUidG729EncoderIntfc)

  1030         {

  1031         TRAP_IGNORE(iG729EncoderIntfcCI = CG729EncoderIntfcCI::NewL());

  1032         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CG729EncoderIntfcCI..."));

  1033         return iG729EncoderIntfcCI;

  1034         }

  1035     else if (aInterfaceId == KUidIlbcEncoderIntfc)

  1036         {

  1037         TRAP_IGNORE(iIlbcEncoderIntfcCI = CIlbcEncoderIntfcCI::NewL());

  1038         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CIlbcEncoderIntfcCI..."));

  1039         return iIlbcEncoderIntfcCI;

  1040         }

  1041     else if (aInterfaceId == KUidAudioInput)

  1042         {

  1043         CAudioInputCI* retCI(NULL);

  1044         TRAP_IGNORE(retCI = CAudioInputCI::NewL());

  1045         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CAudioInputCI..."));

  1046         return retCI;

  1047         }

  1048     else if(aInterfaceId == KUidAudioOutput)

  1049         {

  1050         CAudioOutputCI* retCI(NULL);

  1051         TRAP_IGNORE(retCI = CAudioOutputCI::NewL());

  1052         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CAudioOutputCI..."));

  1053         return retCI;

  1054         }/*

  1055     else if (aInterfaceId == KUidSbcEncoderIntfc)

  1056         {

  1057         TRAP_IGNORE(iSbcEncoderIntfcCI = CSbcEncoderIntfcCI::NewL());

  1058         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CSbcEncoderIntfcCI..."));

  1059         return iSbcEncoderIntfcCI;

  1060         }

  1061     else if (aInterfaceId == KUidAudioVibraControl)

  1062         {

  1063         TRAP_IGNORE(iAudioVibraControlCI = CAudioVibraControlCI::NewL());

  1064         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CAudioVibraControlCI..."));

  1065         return iAudioVibraControlCI;

  1066         }

  1067     else if (aInterfaceId == KUidAudioResource)

  1068         {

  1069         CAudioResourceCIStub* retCI(NULL);

  1070         TRAP_IGNORE(retCI = CAudioResourceCIStub::NewL());

  1071         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CAudioResourceCIStub..."));

  1072         return retCI;

  1073         }

  1074     else if (aInterfaceId == KUidAudioEqualizerEffect)

  1075         {

  1076         CAudioEqualizerCI* retCI(NULL);

  1077         TRAP_IGNORE(retCI = CAudioEqualizerCI::NewL());

  1078         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CAudioEqualizerCI..."));

  1079         return retCI;

  1080         }

  1081     else if (aInterfaceId == KUidEnvironmentalReverbEffect)

  1082         {

  1083         CEnvironmentalReverbCI* retCI(NULL);

  1084         TRAP_IGNORE(retCI = CEnvironmentalReverbCI::NewL());

  1085         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CEnvironmentalReverbCI..."));

  1086         return retCI;

  1087         }

  1088     else if (aInterfaceId == KUidStereoWideningEffect)

  1089         {

  1090         CStereoWideningCI* retCI(NULL);

  1091         TRAP_IGNORE(retCI = CStereoWideningCI::NewL());

  1092         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CStereoWideningCI..."));

  1093         return retCI;

  1094         }

  1095     else if (aInterfaceId == KUidBassBoostEffect)

  1096         {

  1097         CBassBoostCI* retCI(NULL);

  1098         TRAP_IGNORE(retCI = CBassBoostCI::NewL());

  1099         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CBassBoostCI..."));

  1100         return retCI;

  1101         }

  1102     else if (aInterfaceId == KUidSourceDopplerEffect)

  1103         {

  1104         CSourceDopplerCI* retCI(NULL);

  1105         TRAP_IGNORE(retCI = CSourceDopplerCI::NewL());

  1106         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CSourceDopplerCI..."));

  1107         return retCI;

  1108         }

  1109     else if (aInterfaceId == KUidListenerDopplerEffect)

  1110         {

  1111         CListenerDopplerCI* retCI(NULL);

  1112         TRAP_IGNORE(retCI = CListenerDopplerCI::NewL());

  1113         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CListenerDopplerCI..."));

  1114         return retCI;

  1115         }

  1116     else if (aInterfaceId == KUidListenerLocationEffect)

  1117         {

  1118         CListenerLocationCI* retCI(NULL);

  1119         TRAP_IGNORE(retCI = CListenerLocationCI::NewL());

  1120         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CListenerLocationCI..."));

  1121         return retCI;

  1122         }

  1123     else if (aInterfaceId == KUidSourceLocationEffect)

  1124         {

  1125         CSourceLocationCI* retCI(NULL);

  1126         TRAP_IGNORE(retCI = CSourceLocationCI::NewL());

  1127         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CSourceLocationCI..."));

  1128         return retCI;

  1129         }

  1130     else if (aInterfaceId == KUidListenerOrientationEffect)

  1131         {

  1132         CListenerOrientationCI* retCI(NULL);

  1133         TRAP_IGNORE(retCI = CListenerOrientationCI::NewL());

  1134         DEBPRN0(_L("CMMFDevSoundAdaptationStub[0x%x]::CBody::CustomInterface:returning CListenerOrientationCI..."));