1 /*

     2 * Copyright (c) 2006-2007 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:  Provides static utility functions for SVP

    15 *

    16 */

    17 

    18 

    19 // #include <WlanInternalPSKeys.h>

    20 #include <sysutil.h>

    21 #include <sipprofile.h>

    22  

    23 #include <CommonEngineDomainCRKeys.h> // for accept-language -header

    24 #include <centralrepository.h> // for language code

    25 #include <settingsinternalcrkeys.h> // Settings UIs CR keys

    26 #include <unsafprotocolscrkeys.h>  // Keys for keep-alive value,ipappsrv_dom\nat_settings_api

    27 

    28 #include <mceaudiocodec.h>

    29 #include <mceamrcodec.h>

    30 #include <mceg711codec.h>

    31 #include <mceilbccodec.h>

    32 #include <mcecodec.h>

    33 #include <mcedtmfcodec.h>

    34 #include <mceamrwbcodec.h>

    35 #include <mcertpsource.h>

    36 #include <mcemicsource.h>

    37 #include <mcertpsink.h>

    38 #include <pathinfo.h>

    39 #include <crcseprofileentry.h>

    40 #include <crcseprofileregistry.h>

    41 #include <crcseaudiocodecregistry.h>

    42 #include <crcseaudiocodecentry.h>

    43 

    44 #include "voipeventlog.h"                   // CVoipEventLog

    45 #include "voiperrorentry.h"                 // CVoipErrorEntry

    46 #include "cipapputilsaddressresolver.h"     // CIPAppUtilsAddressResolver

    47 

    48 #include "svputility.h"

    49 #include "svplogger.h"

    50 #include "svpsipconsts.h"

    51 #include "svplanguagetagconsts.h"

    52 #include "svpaudioutility.h"

    53 

    54 // LOCAL CONSTANTS

    55 // Default audio frame size in milliseconds for calculating jitterbuffer size

    56 const TInt32 KJitterBufferFrameSize = 20;

    57 

    58 // Constants for iLBC 20 and 30ms modes

    59 const TUint32 KSvpilbcMode20ms = 20;

    60 const TUint32 KSvpilbcMode30ms = 30;

    61 

    62 

    63 // ---------------------------------------------------------------------------

    64 // CSVPUtility::NewL

    65 // ---------------------------------------------------------------------------

    66 //

    67 CSVPUtility* CSVPUtility::NewL()

    68     {

    69     CSVPUtility* self = new( ELeave ) CSVPUtility();

    70     CleanupStack::PushL( self );

    71     self->ConstructL();

    72     CleanupStack::Pop( self );

    73     return self;

    74     }

    75 

    76 

    77 // ---------------------------------------------------------------------------

    78 // CSVPUtility::ConstructL

    79 // ---------------------------------------------------------------------------

    80 //

    81 void CSVPUtility::ConstructL()

    82     {

    83     SVPDEBUG1("CSVPUtility::ConstructL()");                                                                            

    84     iPreferredCodec = 0;

    85     iRoundIndex = 0;

    86     

    87     // create CVoipEventLog

    88     TRAP_IGNORE( iVoipEventLogger = CVoipEventLog::NewL() );

    89     }

    90 

    91 // ---------------------------------------------------------------------------

    92 // CSVPUtility::CSVPUtility

    93 // ---------------------------------------------------------------------------

    94 //

    95 CSVPUtility::CSVPUtility()

    96     {

    97     SVPDEBUG1("CSVPUtility::CSVPUtility()");

    98     }

    99 

   100 

   101 // ---------------------------------------------------------------------------

   102 // CSVPUtility::~CSVPUtility

   103 // ---------------------------------------------------------------------------

   104 //

   105 CSVPUtility::~CSVPUtility()

   106     {

   107     SVPDEBUG1("CSVPUtility::~CSVPUtility()");

   108     delete iVoipEventLogger;

   109     }

   110 

   111 // ---------------------------------------------------------------------------

   112 // CSVPUtility::SetAudioCodecsMOL

   113 // ---------------------------------------------------------------------------

   114 //

   115 void CSVPUtility::SetAudioCodecsMOL( TUint32 aVoIPProfileId, 

   116                                      CMceAudioStream& aAudioInStream,

   117                                      TInt aKeepAliveValue )

   118     {

   119     SVPDEBUG1("CSVPUtility::SetAudioCodecsMOL: IN");

   120     

   121     RArray< TUint32 > codecIds;

   122     CleanupClosePushL( codecIds );

   123      

   124     // clear codec priority preferrence variable

   125     iPreferredCodec = 0;

   126 

   127     CRCSEProfileEntry* profile = CRCSEProfileEntry::NewLC();

   128     CRCSEAudioCodecEntry* codecprofile = CRCSEAudioCodecEntry::NewLC();

   129     CRCSEProfileRegistry* rCSEProfile = CRCSEProfileRegistry::NewLC();

   130     CRCSEAudioCodecRegistry* rCSEAudioCodec = 

   131                                      CRCSEAudioCodecRegistry::NewLC();

   132     

   133     // Get VoIP profile from RCSE

   134     rCSEProfile->FindL( aVoIPProfileId, *profile );

   135     

   136     // fetch codec id's

   137     GetCodecIdsByVoIPProfileIdL( *profile, codecIds );

   138     TBool capabilitiesSet = EFalse;

   139         

   140     // Set capabilities

   141     for( TInt j = 0; j < codecIds.Count(); j++ )

   142         {

   143         rCSEAudioCodec->FindL( codecIds[ j ], *codecprofile );

   144         if ( !codecprofile->iMediaSubTypeName.CompareF( KAudioCodecCN ) )

   145             {

   146             iCN = ETrue;

   147             }

   148         else

   149             {

   150             SVPDEBUG2("CSVPUtility::SetAudioCodecsMOL: j: %d", j);

   151             MoCallCapabilitiesL( aAudioInStream, 

   152                                  *profile, 

   153                                  *codecprofile );

   154             capabilitiesSet = ETrue;

   155             }

   156         }

   157      

   158     // in Mo case, redundancy is never offered

   159     iRed = EFalse;

   160     

   161     if ( capabilitiesSet )

   162         {

   163         SetDtmfL( *profile, aAudioInStream );

   164         }

   165     

   166     SetMediaQoSL( profile->iMediaQOS, aAudioInStream.Session() );

   167     

   168     // set comfort noise for PCMA/PCMU & ILBC if CN provisioned

   169     // also handles keep alive logics

   170     if ( iCN )

   171         {

   172         SetComfortNoiseL( aAudioInStream );

   173         RemoveUnnecessaryCodecsL( aAudioInStream );

   174         SetCNKeepAliveL( aAudioInStream, aKeepAliveValue ); 

   175         }

   176     else

   177         {

   178         RemoveUnnecessaryCodecsL( aAudioInStream );

   179         SetKeepAliveL( aAudioInStream, aKeepAliveValue ); 

   180         }

   181    

   182     // Check RTCP for actual and bound stream as we do not have knowledge where

   183     // the actual RTP sink is residing

   184     CheckRtcpSettingL( profile->iRTCP, aAudioInStream );

   185     if ( aAudioInStream.BoundStream() )

   186         {

   187         CheckRtcpSettingL( profile->iRTCP, aAudioInStream.BoundStreamL() );

   188         }

   189     

   190     // RCSE objects can be deleted

   191     CleanupStack::PopAndDestroy( 5, &codecIds );

   192 

   193     // Leave if codec information was not found.

   194     if ( !aAudioInStream.Codecs().Count() )

   195         {

   196         SVPDEBUG1("CSVPUtility::SetAudioCodecsMOL KErrNotFound");

   197         User::Leave( KErrNotFound );

   198         }

   199     

   200     SVPDEBUG1("CSVPUtility::SetAudioCodecsMOL: OUT");

   201     }

   202 

   203 // ---------------------------------------------------------------------------

   204 // CSVPUtility::SetKeepAliveL

   205 // ---------------------------------------------------------------------------

   206 //

   207 void CSVPUtility::SetKeepAliveL( CMceAudioStream& aAudioStream,

   208                                  TInt aKeepAliveValue )

   209     {

   210     SVPDEBUG1( "CSVPUtility::SetKeepAliveL In ")

   211     

   212     TInt count = aAudioStream.Codecs().Count();

   213     SVPDEBUG2( "CSVPUtility::SetKeepAliveL Codec count: %d ", count )

   214     

   215     // values should be set to bound stream also

   216     CMceAudioStream& boundStream = 

   217         static_cast< CMceAudioStream& > ( aAudioStream.BoundStreamL() );

   218     

   219     __ASSERT_ALWAYS( &boundStream, User::Leave( KSVPErrCodecMismatch ) );

   220     // Amount of codecs should be the same in audio- and boundstreams

   221     __ASSERT_ALWAYS( count == boundStream.Codecs().Count(),

   222                      User::Leave( KSVPErrCodecMismatch ) );

   223     

   224     TInt maxPl( 0 );

   225     TInt minPl( 0 );

   226     // first check the max payload in the codec set

   227     while ( count-- )

   228         {

   229         minPl = aAudioStream.Codecs()[ count ]->PayloadType();

   230         if ( minPl > maxPl )

   231             {

   232             maxPl = minPl;

   233             }  

   234         }

   235     

   236     count = aAudioStream.Codecs().Count();

   237     // if max pl less than def 120, set 120 as pl

   238     if ( KSVPDefKeepAlivePl > maxPl )

   239         {

   240         while( count-- )

   241             {

   242             SVPDEBUG1( "CSVPUtility::SetKeepAliveL A ")

   243             aAudioStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( KSVPDefKeepAlivePl );

   244             aAudioStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   245             aAudioStream.Codecs()[ count ]->SetKeepAliveTimerL( aKeepAliveValue );

   246             boundStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( KSVPDefKeepAlivePl );

   247             boundStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   248             boundStream.Codecs()[ count ]->SetKeepAliveTimerL( aKeepAliveValue );

   249             }

   250         }

   251     else if ( KSVPDefKeepAlivePlMax > maxPl )

   252         {

   253         while( count-- )

   254             {

   255             SVPDEBUG1( "CSVPUtility::SetKeepAliveL B ")

   256             aAudioStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( maxPl + 1 );

   257             aAudioStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   258             aAudioStream.Codecs()[ count ]->SetKeepAliveTimerL( aKeepAliveValue );

   259             boundStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( maxPl + 1 );

   260             boundStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   261             boundStream.Codecs()[ count ]->SetKeepAliveTimerL( aKeepAliveValue );

   262             }

   263         }

   264     

   265     SVPDEBUG1( "CSVPUtility::SetKeepAliveL Out ")

   266     }

   267 

   268 // ---------------------------------------------------------------------------

   269 // CSVPUtility::SetCNKeepAliveL

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

   271 //

   272 void CSVPUtility::SetCNKeepAliveL( CMceAudioStream& aAudioStream,

   273                                    TInt aKeepAliveValue )

   274     {

   275     SVPDEBUG1( "CSVPUtility::SetCNKeepAliveL In ")

   276     

   277     TInt count = aAudioStream.Codecs().Count();

   278     SVPDEBUG2( "CSVPUtility::SetCNKeepAliveL Codec count: %d ", count )

   279     

   280     TInt mostPreferred = 0; 

   281     // bound stream should be present always

   282     CMceAudioStream& boundStream = 

   283         static_cast< CMceAudioStream& > ( aAudioStream.BoundStreamL() );

   284     

   285     __ASSERT_ALWAYS( &boundStream, User::Leave( KSVPErrCodecMismatch ) );

   286     // Amount of codecs should be the same in audio- and boundstreams

   287     __ASSERT_ALWAYS( count == boundStream.Codecs().Count(),

   288                      User::Leave( KSVPErrCodecMismatch ) );

   289     

   290     // find most preferred codec and set keepalive timer

   291     // value and payload for most preferred codec

   292     while( count-- )

   293         {

   294         const TDesC8& codec = aAudioStream.Codecs()[ count ]->SdpName();

   295          

   296         // handle only real audio codecs

   297         if (  KErrNotFound == codec.Find( KCN ) && KErrNotFound == codec.Find( KTELEVENT )  )

   298             {

   299             if ( 0 == aAudioStream.Codecs()[ count ]->Preference() )

   300                 {

   301                 SVPDEBUG2( "Most preferred codec: %d ", count )

   302                 SVPDEBUG2( "Payload: %d ", aAudioStream.Codecs()[ count ]->PayloadType() )

   303                 aAudioStream.Codecs()[ count ]->SetKeepAliveTimerL( aKeepAliveValue );

   304                 aAudioStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( KSVPCNPayloadType );

   305                 aAudioStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   306                 boundStream.Codecs()[ count ]->SetKeepAliveTimerL( aKeepAliveValue );

   307                 boundStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( KSVPCNPayloadType );

   308                 boundStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   309                 mostPreferred = count;

   310                 }

   311            }

   312         }

   313     

   314     count = aAudioStream.Codecs().Count();

   315     while ( count-- )

   316         {

   317         if ( mostPreferred != count )

   318             {

   319             SVPDEBUG2( "Timer value 0 for codec: %d ", count )

   320             aAudioStream.Codecs()[ count ]->SetKeepAliveTimerL( 0 );

   321             aAudioStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( KSVPCNPayloadType );

   322             aAudioStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   323             boundStream.Codecs()[ count ]->SetKeepAliveTimerL( 0 );

   324             boundStream.Codecs()[ count ]->SetKeepAlivePayloadTypeL( KSVPCNPayloadType );

   325             boundStream.Codecs()[ count ]->SetKeepAliveDataL( KNullDesC8 );

   326             }

   327         }

   328     

   329     SVPDEBUG1( "CSVPUtility::SetCNKeepAliveL Out ")

   330     }

   331 

   332 // ---------------------------------------------------------------------------

   333 // CSVPUtility::IsComfortNoise

   334 // ---------------------------------------------------------------------------

   335 //

   336 TBool CSVPUtility::IsComfortNoise( CMceAudioStream& aStream )

   337     {

   338     SVPDEBUG1( "CSVPUtility::IsComfortNoise In ")

   339     TInt count = aStream.Codecs().Count();

   340     while ( count-- )

   341         {

   342         if ( !aStream.Codecs()[ count ]->SdpName().CompareF( KCN ) )

   343             {

   344             return ETrue;

   345             }

   346         }

   347     return EFalse;

   348     }

   349 

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

   351 // CSVPUtility::SetAudioCodecsForEmergencyL

   352 // ---------------------------------------------------------------------------

   353 //

   354 void CSVPUtility::SetAudioCodecsForEmergencyL( 

   355     CMceAudioStream& aAudioInStream,

   356     TInt aKeepAliveValue, 

   357     TInt32 aVoipProfileId )

   358     {

   359     SVPDEBUG1("CSVPUtility::SetAudioCodecsForEmergencyL() In")

   360         

   361     // clear codec priority preferrence variable

   362     iPreferredCodec = 0;

   363 

   364     // Default profile

   365     CRCSEProfileEntry* profile = CRCSEProfileEntry::NewLC(); // CS:1

   366     

   367     // Set codecs

   368     if ( KErrNotFound == aVoipProfileId )

   369         {

   370         // No VoIP profile, use default profile values

   371         SVPDEBUG1("CSVPUtility::SetAudioCodecsForEmergencyL, no VoIP profile")

   372 

   373         // Create default codecs (PCMA, PCMU, AMR, iLBC, G729) and set 

   374         // capabilities

   375         CRCSEAudioCodecEntry* codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   376         codec->SetDefaultCodecValueSet( KAudioCodecPCMA() );

   377         MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   378         CleanupStack::PopAndDestroy( codec ); // CS:1

   379 

   380         codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   381         codec->SetDefaultCodecValueSet( KAudioCodecPCMU() );

   382         MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   383         CleanupStack::PopAndDestroy( codec ); // CS:1

   384 

   385         codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   386         codec->SetDefaultCodecValueSet( KAudioCodecAMR() );

   387         MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   388         CleanupStack::PopAndDestroy( codec ); // CS:1

   389 

   390         codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   391         codec->SetDefaultCodecValueSet( KAudioCodeciLBC() );

   392         MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   393         CleanupStack::PopAndDestroy( codec ); // CS:1

   394 

   395         codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   396         codec->SetDefaultCodecValueSet( KAudioCodecG729() );

   397         MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   398         CleanupStack::PopAndDestroy( codec ); // CS:1

   399         }

   400     else

   401         {

   402         // VoIP profile exists

   403         SVPDEBUG1("CSVPUtility::SetAudioCodecsForEmergencyL, VoIP profile")

   404         User::LeaveIfError( aVoipProfileId );

   405             

   406         // Get codec IDs from profile

   407         CRCSEProfileRegistry* profileRegistry = 

   408             CRCSEProfileRegistry::NewLC(); // CS:2

   409         profileRegistry->FindL( aVoipProfileId, *profile );

   410         CleanupStack::PopAndDestroy( profileRegistry ); // CS:1

   411         RArray< TUint32 > codecIds;

   412         CleanupClosePushL( codecIds ); // CS:2

   413         GetCodecIdsByVoIPProfileIdL( *profile, codecIds );

   414         

   415         // Set flags

   416         TBool isSetPCMA( EFalse );

   417         TBool isSetPCMU( EFalse );

   418 

   419         // Set capabilities

   420         CRCSEAudioCodecRegistry* codecRegistry = 

   421             CRCSEAudioCodecRegistry::NewLC(); // CS:3

   422         CRCSEAudioCodecEntry* codec = NULL;

   423         for( TInt j = 0; j < codecIds.Count(); j++ )

   424             {

   425             codec = CRCSEAudioCodecEntry::NewLC(); // CS:4

   426             codecRegistry->FindL( codecIds[j], *codec );

   427             MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   428             

   429             // Check G711

   430             if ( !codec->iMediaSubTypeName.CompareF( KAudioCodecPCMA ) )

   431                 {

   432                 isSetPCMA = ETrue;

   433                 }

   434             if ( !codec->iMediaSubTypeName.CompareF( KAudioCodecPCMU ) )

   435                 {

   436                 isSetPCMU = ETrue;

   437                 }

   438             CleanupStack::PopAndDestroy( codec ); // CS:3

   439             }

   440         CleanupStack::PopAndDestroy( codecRegistry ); // CS:2

   441         CleanupStack::PopAndDestroy( &codecIds ); // CS:1

   442         

   443 

   444         // Set G711 default capabilities if not set from profile

   445         if ( !isSetPCMA )

   446             {

   447             codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   448             codec->SetDefaultCodecValueSet( KAudioCodecPCMA() );

   449             MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   450             CleanupStack::PopAndDestroy( codec ); // CS:1

   451             }

   452         if ( !isSetPCMU )

   453             {

   454             codec = CRCSEAudioCodecEntry::NewLC(); // CS:2

   455             codec->SetDefaultCodecValueSet( KAudioCodecPCMU() );

   456             MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

   457             CleanupStack::PopAndDestroy( codec ); // CS:1

   458             }

   459         }

   460     

   461     SetDtmfL( *profile, aAudioInStream );

   462     

   463     SetMediaQoSL( profile->iMediaQOS, aAudioInStream.Session() );

   464     

   465     // in Mo case, redundancy is never offered

   466     iRed = EFalse;

   467     

   468     // Set comfort noise for PCMA/PCMU & ILBC if CN provisioned and keep-alive

   469     if ( iCN )

   470         {

   471         SetComfortNoiseL( aAudioInStream );

   472         RemoveUnnecessaryCodecsL( aAudioInStream );

   473         SetCNKeepAliveL( aAudioInStream, aKeepAliveValue );

   474         }

   475     else

   476         {

   477         RemoveUnnecessaryCodecsL( aAudioInStream );

   478         SetKeepAliveL( aAudioInStream, aKeepAliveValue );

   479         }

   480     

   481     // Check RTCP for actual and bound stream as we do not have knowledge where

   482     // the actual RTP sink is residing

   483     CheckRtcpSettingL( profile->iRTCP, aAudioInStream );

   484     if ( aAudioInStream.BoundStream() )

   485         {

   486         CheckRtcpSettingL( profile->iRTCP, aAudioInStream.BoundStreamL() );

   487         }

   488     

   489     CleanupStack::PopAndDestroy( profile ); // CS:0

   490 

   491     // Leave if codec information was not found.

   492     if ( !aAudioInStream.Codecs().Count() )

   493         {

   494         SVPDEBUG1("CSVPUtility::SetAudioCodecsForEmergencyL KErrNotFound")

   495         User::Leave( KErrNotFound );

   496         }

   497     

   498     SVPDEBUG1("CSVPUtility::SetAudioCodecsForEmergencyL() Out")

   499     }

   500 

   501 // ---------------------------------------------------------------------------

   502 // CSVPUtility::SetComfortNoiseL

   503 // ---------------------------------------------------------------------------

   504 //  

   505 void CSVPUtility::SetComfortNoiseL( CMceAudioStream& aAudioStream )

   506     {

   507     SVPDEBUG1("CSVPUtility::SetComfortNoiseL In");

   508     

   509     // fetch available codecs

   510     const RPointerArray<CMceAudioCodec>& codecs = aAudioStream.Codecs();

   511     

   512     // Comfort Noise must be enabled for bound stream codecs also

   513     CMceAudioStream& boundStream = 

   514         static_cast< CMceAudioStream& > ( aAudioStream.BoundStreamL() ); 

   515    

   516     // fetch bound stream codecs 

   517     const RPointerArray< CMceAudioCodec >& 

   518         boundCodecs = boundStream.Codecs();

   519     

   520     iCN = EFalse;

   521 

   522     for ( TInt z = 0; z < codecs.Count(); z++ )

   523         {

   524         if ( !codecs[ z ]->SdpName().CompareF( KCN ) && !iCN  )

   525             {

   526             SVPDEBUG1("CSVPUtility::SetComfortNoiseL CN found");

   527             // enable CN from main and bound stream

   528             aAudioStream.Codecs()[ z ]->SetStateL( CMceCodec::EEnabled );

   529             boundStream.Codecs()[ z ]->SetStateL( CMceCodec::EEnabled );

   530             // set flag to true, so CN is not removed from media attributes

   531             iCN = ETrue;

   532             

   533             // set also correct priority order for CN => lowest priority

   534             aAudioStream.Codecs()[ z ]->SetPreferenceL( codecs.Count() );

   535             }

   536         } 

   537     if ( iCN )

   538         {

   539         for ( TInt i = 0; i < codecs.Count(); i++ )

   540             {

   541             if( !codecs[ i ]->SdpName().CompareF( KPCMA ) || 

   542                 !codecs[ i ]->SdpName().CompareF( KPCMU ) ||

   543                 !codecs[ i ]->SdpName().CompareF( KILBC ) )

   544                 {

   545                 SVPDEBUG1("CSVPUtility::SetComfortNoiseL Setting VAD");

   546                 codecs[ i ]->EnableVAD( ETrue );

   547                 boundCodecs[ i ]->EnableVAD( ETrue );

   548                 }

   549             } 

   550         }

   551     SVPDEBUG1("CSVPUtility::SetComfortNoiseL Out");

   552     }

   553     

   554 // ---------------------------------------------------------------------------

   555 // CSVPUtility::SetDtmfL

   556 // ---------------------------------------------------------------------------

   557 //

   558 void CSVPUtility::SetDtmfL( const CRCSEProfileEntry& aVoIPProfile, 

   559     CMceAudioStream& aAudioStream )

   560     {

   561     SVPDEBUG3( "CSVPUtility::SetDtmfL IB STATUS: %d OB STATUS: %d",

   562         aVoIPProfile.iInbandDTMF, aVoIPProfile.iOutbandDTMF )

   563     

   564     // If both on, not set or both off, prefer outband.

   565     if ( ( CRCSEAudioCodecEntry::EOn == aVoIPProfile.iInbandDTMF &&

   566            CRCSEAudioCodecEntry::EOn == aVoIPProfile.iOutbandDTMF ) ||

   567          ( CRCSEAudioCodecEntry::EOONotSet == aVoIPProfile.iInbandDTMF &&

   568            CRCSEAudioCodecEntry::EOONotSet == aVoIPProfile.iOutbandDTMF ) ||

   569          ( CRCSEAudioCodecEntry::EOff == aVoIPProfile.iInbandDTMF &&

   570            CRCSEAudioCodecEntry::EOff == aVoIPProfile.iOutbandDTMF ) )

   571         {

   572         SVPDEBUG1( "CSVPUtility::SetDtmfL IB/OB both enabled, not set or off" )

   573         

   574         iTelEv = ETrue;

   575         SetDtmfCodecOrderL( aAudioStream );

   576         }

   577     // Check inband enabled situation

   578     else if ( CRCSEAudioCodecEntry::EOn == aVoIPProfile.iInbandDTMF &&

   579               CRCSEAudioCodecEntry::EOff == aVoIPProfile.iOutbandDTMF )

   580         {

   581         SVPDEBUG1( "CSVPUtility::SetDtmfL OB DTMF OFF, IB DTMF ON" )

   582         

   583         iTelEv = EFalse;

   584         }

   585     // Check outband enabled situation

   586     else if ( CRCSEAudioCodecEntry::EOff == aVoIPProfile.iInbandDTMF &&

   587               CRCSEAudioCodecEntry::EOn == aVoIPProfile.iOutbandDTMF )

   588         {

   589         SVPDEBUG1( "CSVPUtility::SetDtmfL OB DTMF ON, IB DTMF OFF" )

   590         

   591         iTelEv = ETrue;

   592         SetDtmfCodecOrderL( aAudioStream );

   593         }

   594     // else all cases handled above.

   595     }

   596     

   597 //----------------------------------------------------------------------------

   598 // CSVPUtility::GetDTMFMode

   599 //----------------------------------------------------------------------------

   600 //    

   601 TBool CSVPUtility::GetDTMFMode()

   602     {

   603     SVPDEBUG2( "SVPUtility::GetDTMFMode iTelEv: %d", iTelEv )

   604     

   605     return iTelEv; // EFalse: DTMF Inband, ETrue: DTMF Outband

   606     }

   607 

   608 //----------------------------------------------------------------------------

   609 // CSVPUtility::SetDtmfMode

   610 //----------------------------------------------------------------------------

   611 //

   612 void CSVPUtility::SetDtmfMode( TBool aOutbandEnabled )

   613     {

   614     SVPDEBUG2( "SVPUtility::SetDtmfMode aOutbandEnabled: %d",

   615         aOutbandEnabled )

   616     

   617     iTelEv = aOutbandEnabled;

   618     }

   619 

   620 // ---------------------------------------------------------------------------

   621 // CSVPUtility::SetAudioCodecsMTL

   622 // ---------------------------------------------------------------------------

   623 //

   624 void CSVPUtility::SetAudioCodecsMTL( CRCSEProfileEntry& aVoIPProfile, 

   625                                      CMceMediaStream& aAudioStream,

   626                                      TInt aKeepAliveValue,

   627                                      TBool aSessionUpdateOngoing )

   628     {

   629     SVPDEBUG1("CSVPUtility::SetAudioCodecsMTL In")

   630     

   631     RArray< TUint32 > codecIds;

   632     CleanupClosePushL( codecIds );

   633     

   634     GetCodecIdsByVoIPProfileIdL( aVoIPProfile, codecIds );

   635     

   636     // create codec profile

   637     CRCSEAudioCodecEntry* codecprofile = 

   638                                     CRCSEAudioCodecEntry::NewLC();

   639     CRCSEAudioCodecRegistry* rCSEAudioCodec = 

   640                                     CRCSEAudioCodecRegistry::NewLC();

   641     

   642     // clearing the flag for next session 

   643     iCodecMatched = EFalse;  

   644     // Initialize round index variable (for the current session)

   645     iRoundIndex = 0;

   646  

   647     CMceAudioStream& audioStream =

   648         static_cast<CMceAudioStream&>( aAudioStream );

   649         

   650     const RPointerArray< CMceAudioCodec >& supportedCodecs = 

   651         audioStream.Codecs();

   652     

   653     const TInt suppCodecCount = supportedCodecs.Count();

   654     

   655     // loop as many times as needed 

   656     while ( iRoundIndex < suppCodecCount )

   657         {

   658         for ( TInt codecCnt = 0; codecCnt < codecIds.Count(); codecCnt++ )

   659             {

   660             if ( !iCodecMatched )

   661                 {

   662                 rCSEAudioCodec->FindL( codecIds[ codecCnt ], *codecprofile );

   663                 MtCallCapabilitiesL( audioStream, aVoIPProfile, *codecprofile );

   664                 }

   665             }

   666         

   667         if ( iCodecMatched )

   668             {

   669             SVPDEBUG1( "CSVPUtility::SetAudioCodecsMTL RED set" )

   670             SetRedundancyL( audioStream );

   671             SVPDEBUG1( "CSVPUtility::SetAudioCodecsMTL RED set done" )

   672             break;

   673             }

   674         else

   675             {

   676             iRoundIndex++;    

   677             }

   678         }

   679     

   680     if ( !iCodecMatched )

   681         {

   682         User::Leave( KSVPErrCodecMismatch );

   683         }

   684     

   685     SetMediaQoSL( aVoIPProfile.iMediaQOS, aAudioStream.Session() );

   686     

   687     // if outband DTMF offered, it's used even if inband is provisioned

   688     if ( DtmfOBInOffer( audioStream ) )

   689         {

   690         SetDtmfCodecOrderL( audioStream );

   691         iTelEv = ETrue;

   692         }

   693     else

   694         {

   695         SetDtmfL( aVoIPProfile, audioStream );

   696         }

   697     

   698     // set comfort noise if provisioned and offered by caller

   699     for ( TInt codecCnt = 0; codecCnt < codecIds.Count(); codecCnt++ )

   700         {

   701         // fetch codec profile

   702         rCSEAudioCodec->FindL( codecIds[ codecCnt ], *codecprofile );

   703         // set comfort noise

   704         HBufC8* tempSdpName = 

   705             HBufC8::NewLC( codecprofile->iMediaSubTypeName.Length() );

   706         TPtr8 ptr = tempSdpName->Des();

   707         ptr.Copy( codecprofile->iMediaSubTypeName );  

   708         if ( !tempSdpName->CompareF( KCN ) )

   709             {

   710             SVPDEBUG1( "CSVPUtility::SetAudioCodecsMTL - CN Provisioned" )

   711             SetComfortNoiseL( audioStream );    

   712             }

   713 

   714         CleanupStack::PopAndDestroy( tempSdpName );

   715         }

   716     

   717     RemoveUnnecessaryCodecsL( audioStream );

   718     

   719     // CN provisioned and in offer

   720     if ( iCN )

   721         {

   722         SVPDEBUG1( "CSVPUtility::SetAudioCodecsMTL - CN" )

   723         SetCNKeepAliveL( audioStream, aKeepAliveValue );

   724         }

   725     // CN not provisioned or offered

   726     else

   727         {

   728         SVPDEBUG1( "CSVPUtility::SetAudioCodecsMTL - No CN" )

   729         SetKeepAliveL( audioStream, aKeepAliveValue );

   730         }

   731     

   732     // Check RTCP for actual and bound stream as we do not have knowledge where

   733     // the actual RTP sink is residing

   734     CheckRtcpSettingL( aVoIPProfile.iRTCP, aAudioStream, aSessionUpdateOngoing );

   735     if ( aAudioStream.BoundStream() )

   736         {

   737         CheckRtcpSettingL( aVoIPProfile.iRTCP, aAudioStream.BoundStreamL(), aSessionUpdateOngoing );

   738         }

   739     

   740     // RCSE objects can be deleted

   741     CleanupStack::PopAndDestroy( 3, &codecIds );

   742          

   743     SVPDEBUG1( "CSVPUtility::SetAudioCodecsMTL Out" )

   744     }

   745 

   746 // ---------------------------------------------------------------------------

   747 // CSVPUtility::DtmfOBInOffer

   748 // ---------------------------------------------------------------------------

   749 //   

   750 TBool CSVPUtility::DtmfOBInOffer( CMceAudioStream& aAudioStream )

   751 	{

   752 	SVPDEBUG1( "CSVPUtility::DtmfOBInOffer In" )

   753     const RPointerArray< CMceAudioCodec >& supportedCodecs = 

   754         aAudioStream.Codecs();

   755     TInt count = supportedCodecs.Count();

   756     while ( count-- )

   757         {

   758         if ( !supportedCodecs[ count ]->SdpName().CompareF( KTELEVENT ) )

   759             {

   760             SVPDEBUG1( "CSVPUtility::DtmfOBInOffer Outband DTMF in offer" )

   761             return ETrue;    

   762             }

   763         }

   764     return EFalse;

   765 	}

   766 

   767 // ---------------------------------------------------------------------------

   768 // CSVPUtility::RemoveUnnecessaryCodecsL

   769 // ---------------------------------------------------------------------------

   770 //    

   771 void CSVPUtility::RemoveUnnecessaryCodecsL( CMceAudioStream& aAudioInStream )

   772     {

   773     SVPDEBUG1("CSVPUtility::RemoveUnnecessaryCodecs In");

   774     // if codec was not found, remove code from the codec array 

   775     if ( !iAMR )

   776         {

   777         SVPAudioUtility::RemoveCodecL( aAudioInStream, KAMR );

   778         }

   779     if ( !iPCMA )

   780         {

   781         SVPAudioUtility::RemoveCodecL( aAudioInStream, KPCMA );

   782         }

   783     if ( !iPCMU )

   784         {

   785         SVPAudioUtility::RemoveCodecL( aAudioInStream, KPCMU );

   786         }

   787     if ( !iILBC )

   788         {

   789         SVPAudioUtility::RemoveCodecL( aAudioInStream, KILBC );

   790         }

   791     if ( !iG729 )

   792         {

   793         SVPAudioUtility::RemoveCodecL( aAudioInStream, KG729 );

   794         }

   795     if ( !iTelEv )

   796         {

   797         SVPAudioUtility::RemoveCodecL( aAudioInStream, KTELEVENT );

   798         }

   799     if ( !iCN )

   800         {

   801         SVPAudioUtility::RemoveCodecL( aAudioInStream, KCN );

   802         iCN = EFalse;

   803         }

   804     if ( !iRed )

   805         {

   806         SVPAudioUtility::RemoveCodecL( aAudioInStream, KRED );

   807         }

   808     if ( !iAMRWB )

   809         {

   810         SVPAudioUtility::RemoveCodecL( aAudioInStream, KAMRWB );

   811         }

   812     

   813     // clear codec flags for next session

   814     iAMR = EFalse; 

   815     iPCMA = EFalse;

   816     iPCMU = EFalse;

   817     iILBC = EFalse;

   818     iG729 = EFalse;

   819     iRed = EFalse;

   820     iAMRWB = EFalse;

   821     

   822     SVPDEBUG1("CSVPUtility::RemoveUnnecessaryCodecs Out"); 

   823     }

   824     

   825 // ---------------------------------------------------------------------------

   826 // CSVPUtility::GetCodecIdsByVoIPProfileIdL

   827 // ---------------------------------------------------------------------------

   828 //

   829 void CSVPUtility::GetCodecIdsByVoIPProfileIdL( 

   830     const CRCSEProfileEntry& aProfile,

   831     RArray< TUint32 >& aCodecIds ) const

   832     {

   833     SVPDEBUG1("CSVPUtility::GetCodecIdsByVoIPProfileIdL IN");

   834     

   835     aCodecIds.Reset();

   836     

   837     const TInt codCount = aProfile.iPreferredCodecs.Count();

   838     for ( TInt codecCnt = 0; codecCnt < codCount; codecCnt++ )

   839         {

   840         // append codec id's in preference order

   841         aCodecIds.AppendL( aProfile.iPreferredCodecs[ codecCnt ] );

   842         }

   843     

   844     SVPDEBUG1("CSVPUtility::GetCodecIdsByVoIPProfileIdL OUT");

   845     }

   846 

   847 // ---------------------------------------------------------------------------

   848 // CSVPUtility::MtCallCapabilitiesL

   849 // ---------------------------------------------------------------------------

   850 //

   851 void CSVPUtility::MtCallCapabilitiesL( 

   852     CMceAudioStream& aAudioInStream, 

   853     const CRCSEProfileEntry& aVoIPProfile,

   854     const CRCSEAudioCodecEntry& aCodecProfile )

   855     {

   856     SVPDEBUG1( "CSVPUtility::MtCallCapabilitiesL IN" )

   857     

   858     // fetch the codecs mce supports

   859     const RPointerArray< CMceAudioCodec >& supportedCodecs = 

   860         aAudioInStream.Codecs();

   861     

   862     SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL: Supp. codec count: %d",

   863          supportedCodecs.Count() )

   864     

   865     HBufC8* tempSdpName = 

   866         HBufC8::NewLC( aCodecProfile.iMediaSubTypeName.Length() );

   867     

   868     TPtr8 ptr = tempSdpName->Des();

   869     ptr.Copy( aCodecProfile.iMediaSubTypeName );

   870     

   871     // compare offered codec to codec supported by app. 

   872     if ( *tempSdpName != supportedCodecs[ iRoundIndex ]->SdpName() ||

   873          !supportedCodecs[ iRoundIndex ]->SdpName().CompareF( KCN ) ||

   874          !supportedCodecs[ iRoundIndex ]->SdpName().CompareF( KTELEVENT ) ||

   875          !supportedCodecs[ iRoundIndex ]->SdpName().CompareF( KRED ) )

   876         {

   877         SVPDEBUG1( "CSVPUtility::MtCallCapabilitiesL do nothing" )

   878         }

   879     else

   880         {

   881         SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL Mediasubtypename: %S",

   882             &aCodecProfile.iMediaSubTypeName )

   883         SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL - ptime: %d",

   884             aCodecProfile.iPtime )

   885         SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL - maxptime: %d",

   886             aCodecProfile.iMaxptime )

   887         

   888         if ( aVoIPProfile.iStartMediaPort )

   889             {

   890             aAudioInStream.SetLocalMediaPortL( aVoIPProfile.iStartMediaPort );

   891             

   892             SVPDEBUG1( "CSVPUtility::MtCallCapabilitiesL start media port set" )

   893             }

   894 

   895         SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL codec ptime: %u",

   896             supportedCodecs[ iRoundIndex ]->PTime() )

   897         SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL codec maxptime: %u",

   898             supportedCodecs[ iRoundIndex ]->MaxPTime() )

   899         

   900         if ( aCodecProfile.iPtime >= 0 && 

   901              aCodecProfile.iMaxptime < 

   902              supportedCodecs[ iRoundIndex ]->PTime() )

   903             {   

   904             supportedCodecs[ iRoundIndex ]->SetPTime( aCodecProfile.iPtime );

   905             }

   906         

   907         if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodecAMR ) )

   908             {

   909             // No actions taken in MT calls for AMR parameters. We accept

   910             // them as-is for improved IOP.

   911             iAMR = ETrue;

   912             } 

   913         

   914         if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodecPCMA ) )

   915             {

   916             iPCMA = ETrue;

   917             }

   918 

   919         if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodecPCMU ) )

   920             {

   921             iPCMU = ETrue;

   922             }

   923 

   924         if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodeciLBC ) )

   925             {

   926             iILBC = ETrue;

   927             }

   928 

   929         if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodecAMRWB  ) )

   930             {

   931             iAMRWB = ETrue;

   932             } 

   933 

   934         if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodecG729 ) )

   935             {

   936             // AnnexB is not set if it is not in the offer. MO side may not

   937             // support AnnexB so we do not want to enforce it.

   938             iG729 = ETrue;

   939             }

   940         else

   941             {

   942             // set VAD if other than G729 codec case

   943             if ( CRCSEAudioCodecEntry::EOONotSet != aCodecProfile.iVAD )

   944                 {

   945                 SVPDEBUG1( "CSVPUtility::MtCallCapabilitiesL, codec and boundcodec VAD" );

   946                 // Setting VAD for codec

   947                 SetVADL( aAudioInStream, aCodecProfile.iVAD, *tempSdpName ); 

   948 

   949                 // Setting VAD also for bound codec

   950                 CMceAudioStream& boundStream = 

   951                     static_cast< CMceAudioStream& > ( aAudioInStream.BoundStreamL() ); 

   952                 SetVADL( boundStream, aCodecProfile.iVAD, *tempSdpName ); 

   953                 }

   954             }

   955 

   956         // Take the largest jitterbuffer size from settings. NB. this does

   957         // not actually take into account that we have codec spesific

   958         // jitterbuffer sizes and MCE has session level jitterbuffer size.

   959         // So we may end up using wrong jitterbuffer size if codec spesific

   960         // jitterbuffer settings are different amongst each other.

   961         if ( aCodecProfile.iJitterBufferSize > iJitterBufferSize )

   962             {

   963             iJitterBufferSize = aCodecProfile.iJitterBufferSize;

   964             }

   965 

   966         SVPDEBUG2( "CSVPUtility::MtCallCapabilitiesL iJitterBufferSize: %d",

   967             iJitterBufferSize )

   968 

   969         // set codec matched flag to ETrue, codec matched and set up

   970         iCodecMatched = ETrue;

   971         }

   972     

   973     CleanupStack::PopAndDestroy( tempSdpName );

   974     

   975     SVPDEBUG1( "CSVPUtility::MtCallCapabilitiesL OUT" )

   976     }

   977 

   978 // ---------------------------------------------------------------------------

   979 // CSVPUtility::SetRedundancyL

   980 // ---------------------------------------------------------------------------

   981 //

   982 void CSVPUtility::SetRedundancyL( CMceAudioStream& aAudioStream ) 

   983     {

   984     SVPDEBUG1( "CSVPUtility::SetRedundancyL In");

   985     const RPointerArray< CMceAudioCodec >& codecs = aAudioStream.Codecs();

   986     for ( TInt z = 0; z < codecs.Count(); z++ )

   987         {

   988         if ( !codecs[ z ]->SdpName().CompareF( KRED ) )

   989             {

   990             SVPDEBUG1( "CSVPUtility::SetRedundancyL Setting Red pref.");          

   991             // set preference 

   992             aAudioStream.Codecs()[ z ]->

   993                 SetPreferenceL( codecs.Count() );

   994             // set red flag so red media attribute is not removed

   995             iRed = ETrue;

   996             }

   997         }

   998     SVPDEBUG1( "CSVPUtility::SetRedundancyL Out");

   999     }

  1000 // ---------------------------------------------------------------------------

  1001 // CSVPUtility::MoCallCapabilitiesL

  1002 // ---------------------------------------------------------------------------

  1003 //

  1004 void CSVPUtility::MoCallCapabilitiesL( 

  1005                               CMceAudioStream& aAudioInStream, 

  1006                               const CRCSEProfileEntry& aVoIPProfile,

  1007                               const CRCSEAudioCodecEntry& aCodecProfile )

  1008     {

  1009     SVPDEBUG1("CSVPUtility::MoCallCapabilitiesL In")

  1010     

  1011     // fetch the codecs mce supports 

  1012     const RPointerArray< CMceAudioCodec >& supportedCodecs = 

  1013         aAudioInStream.Codecs();

  1014     

  1015     SVPDEBUG2("CSVPUtility::MoCallCapabilitiesL, Supported codec count: %d",

  1016         supportedCodecs.Count() );

  1017     

  1018     HBufC8* tempSdpName = 

  1019         HBufC8::NewLC( aCodecProfile.iMediaSubTypeName.Length() );

  1020         

  1021     SVPDEBUG2("CSVPUtility::MoCallCapabilitiesL Mediasubtypename: %S",

  1022         &aCodecProfile.iMediaSubTypeName );

  1023     

  1024     // go through the array and find Sdp name match

  1025     for ( TInt z = 0; z < supportedCodecs.Count(); z++ )

  1026         {

  1027         TPtr8 ptr = tempSdpName->Des();

  1028         ptr.Copy( aCodecProfile.iMediaSubTypeName );

  1029           

  1030         if ( *tempSdpName == supportedCodecs[ z ]->SdpName() )

  1031             {

  1032             // first setting audio capabilities common for all codecs

  1033             

  1034             // set codec priority order

  1035             SVPDEBUG2("CSVPUtility::MoCallCapabilitiesL Codec order: %d",

  1036                 iPreferredCodec );

  1037             

  1038             supportedCodecs[ z ]->SetPreferenceL( iPreferredCodec++ );

  1039             

  1040             // set media port

  1041             if ( aVoIPProfile.iStartMediaPort )

  1042                 {

  1043                 aAudioInStream.SetLocalMediaPortL( aVoIPProfile.iStartMediaPort );

  1044                 SVPDEBUG1("CSVPUtility::MoCallCapabilitiesL start media port set");

  1045                 }

  1046             

  1047             // set VAD    

  1048             if ( CRCSEAudioCodecEntry::EOONotSet != aCodecProfile.iVAD )

  1049                 {

  1050                 SVPDEBUG1( "CSVPUtility::MoCallCapabilitiesL Setting codec VAD" );

  1051 

  1052                 // Setting VAD for codec

  1053                 SetVADL( aAudioInStream, aCodecProfile.iVAD, *tempSdpName ); 

  1054 

  1055                 SVPDEBUG1( "CSVPUtility::MoCallCapabilitiesL Setting bound VAD" );

  1056                 // Setting VAD also for bound codec

  1057                 CMceAudioStream& boundStream = 

  1058                     static_cast< CMceAudioStream& > ( aAudioInStream.BoundStreamL() ); 

  1059                 SetVADL( boundStream, aCodecProfile.iVAD, *tempSdpName ); 

  1060                 }

  1061             

  1062             // set maxptime

  1063             if ( aCodecProfile.iMaxptime >= 0 ) 

  1064                 {

  1065                 supportedCodecs[ z ]->SetMaxPTime( aCodecProfile.iMaxptime );

  1066                 

  1067                 SVPDEBUG2("CSVPUtility::MoCallCapabilitiesL iMaxptime: %d",

  1068                     aCodecProfile.iMaxptime );

  1069                 }

  1070             

  1071             // set ptime

  1072             if ( aCodecProfile.iPtime >= 0 )     

  1073                 {

  1074                 SVPDEBUG2("CSVPUtility::MoCallCapabilitiesL, PTime: %d",

  1075                     aCodecProfile.iPtime );

  1076                 

  1077                 supportedCodecs[ z ]->SetPTime( aCodecProfile.iPtime );

  1078                 } 

  1079             

  1080             if ( !aCodecProfile.iMediaSubTypeName.CompareF( KAudioCodecAMR ) )

  1081                 {

  1082                 iAMR = ETrue;

  1083                 

  1084                 // AMR specific settings: mode-set, mode-change-period,

  1085                 // mode-change-neighbor and octet alignment vs. bw-efficient

  1086                 // mode

  1087                 SetAMRParameters( aAudioInStream, aCodecProfile, z );

  1088                 if ( CRCSEAudioCodecEntry::EOn == aCodecProfile.iOctetAlign )

  1089                     {

  1090                     // use octet-alignment for MO call

  1091                     supportedCodecs[ z ]->SetCodecMode(

  1092                         EMceOctetAligned );

  1093                     }

  1094                 }

  1095             

  1096             if ( !aCodecProfile.iMediaSubTypeName.

  1097                  CompareF( KAudioCodecPCMA ) )

  1098                 {

  1099                 iPCMA = ETrue;

  1100                 }

  1101             if ( !aCodecProfile.iMediaSubTypeName.

  1102                  CompareF( KAudioCodecPCMU ) )

  1103                 {

  1104                 iPCMU = ETrue;

  1105                 }

  1106             if ( !aCodecProfile.iMediaSubTypeName.

  1107                  CompareF( KAudioCodeciLBC ) )

  1108                 {

  1109                 iILBC = ETrue;

  1110                 // Set mode according to mode-set.

  1111                 if ( aCodecProfile.iModeSet.Count() )

  1112                     {

  1113                     if ( KSvpilbcMode20ms == aCodecProfile.iModeSet[0] )

  1114                         {

  1115                         supportedCodecs[ z ]->SetBitrate(

  1116                             KMceiLBCLevel20Bitrate );

  1117                         }

  1118                     else if( KSvpilbcMode30ms == aCodecProfile.iModeSet[0] )

  1119                         {

  1120                         supportedCodecs[ z ]->SetBitrate(

  1121                             KMceiLBCLevel30Bitrate );

  1122                         }

  1123                     }

  1124                 }

  1125             

  1126             if ( !aCodecProfile.iMediaSubTypeName.

  1127                  CompareF( KAudioCodecG729 ) )

  1128                 {

  1129                 iG729 = ETrue;

  1130                 // set annexb

  1131                 if ( CRCSEAudioCodecEntry::EOn == aCodecProfile.iAnnexb )

  1132                     {

  1133                     supportedCodecs[ z ]->EnableVAD( ETrue );

  1134                     }

  1135                 }