/*

* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Provides static utility functions for SVP

*

*/

// #include <WlanInternalPSKeys.h>

#include <sysutil.h>

#include <sipprofile.h>

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

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

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

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

#include <mceaudiocodec.h>

#include <mceamrcodec.h>

#include <mceg711codec.h>

#include <mceilbccodec.h>

#include <mcecodec.h>

#include <mcedtmfcodec.h>

#include <mceamrwbcodec.h>

#include <mcertpsource.h>

#include <mcemicsource.h>

#include <mcertpsink.h>

#include <pathinfo.h>

#include <crcseprofileentry.h>

#include <crcseprofileregistry.h>

#include <crcseaudiocodecregistry.h>

#include <crcseaudiocodecentry.h>

#include "voipeventlog.h"                   // CVoipEventLog

#include "voiperrorentry.h"                 // CVoipErrorEntry

#include "cipapputilsaddressresolver.h"     // CIPAppUtilsAddressResolver

#include "svputility.h"

#include "svplogger.h"

#include "svpsipconsts.h"

#include "svplanguagetagconsts.h"

#include "svpaudioutility.h"

// LOCAL CONSTANTS

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

const TInt32 KJitterBufferFrameSize = 20;

// Constants for iLBC 20 and 30ms modes

const TUint32 KSvpilbcMode20ms = 20;

const TUint32 KSvpilbcMode30ms = 30;

// ---------------------------------------------------------------------------

// CSVPUtility::NewL

// ---------------------------------------------------------------------------

//

CSVPUtility* CSVPUtility::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CSVPUtility::ConstructL

// ---------------------------------------------------------------------------

//

void CSVPUtility::ConstructL()

    {

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

    iPreferredCodec = 0;

    iRoundIndex = 0;

    // create CVoipEventLog

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

    }

// ---------------------------------------------------------------------------

// CSVPUtility::CSVPUtility

// ---------------------------------------------------------------------------

//

CSVPUtility::CSVPUtility()

    {

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

    }

// ---------------------------------------------------------------------------

// CSVPUtility::~CSVPUtility

// ---------------------------------------------------------------------------

//

CSVPUtility::~CSVPUtility()

    {

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

    delete iVoipEventLogger;

    }

// ---------------------------------------------------------------------------

// CSVPUtility::SetAudioCodecsMOL

// ---------------------------------------------------------------------------

//

void CSVPUtility::SetAudioCodecsMOL( TUint32 aVoIPProfileId, 

                                     CMceAudioStream& aAudioInStream,

                                     TInt aKeepAliveValue )

    {

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

    RArray< TUint32 > codecIds;

    CleanupClosePushL( codecIds );

    // clear codec priority preferrence variable

    iPreferredCodec = 0;

    CRCSEProfileEntry* profile = CRCSEProfileEntry::NewLC();

    CRCSEAudioCodecEntry* codecprofile = CRCSEAudioCodecEntry::NewLC();

    CRCSEProfileRegistry* rCSEProfile = CRCSEProfileRegistry::NewLC();

    CRCSEAudioCodecRegistry* rCSEAudioCodec = 

                                     CRCSEAudioCodecRegistry::NewLC();

    // Get VoIP profile from RCSE

    rCSEProfile->FindL( aVoIPProfileId, *profile );

    // fetch codec id's

    GetCodecIdsByVoIPProfileIdL( *profile, codecIds );

    TBool capabilitiesSet = EFalse;

    // Set capabilities

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

        {

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

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

            {

            iCN = ETrue;

            }

        else

            {

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

            MoCallCapabilitiesL( aAudioInStream, 

                                 *profile, 

                                 *codecprofile );

            capabilitiesSet = ETrue;

            }

        }

    // in Mo case, redundancy is never offered

    iRed = EFalse;

    if ( capabilitiesSet )

        {

        SetDtmfL( *profile, aAudioInStream );

        }

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

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

    // also handles keep alive logics

    if ( iCN )

        {

        SetComfortNoiseL( aAudioInStream );

        RemoveUnnecessaryCodecsL( aAudioInStream );

        SetCNKeepAliveL( aAudioInStream, aKeepAliveValue ); 

        }

    else

        {

        RemoveUnnecessaryCodecsL( aAudioInStream );

        SetKeepAliveL( aAudioInStream, aKeepAliveValue ); 

        }

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

    // the actual RTP sink is residing

    CheckRtcpSettingL( profile->iRTCP, aAudioInStream );

    if ( aAudioInStream.BoundStream() )

        {

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

        }

    // RCSE objects can be deleted

    CleanupStack::PopAndDestroy( 5, &codecIds );

    // Leave if codec information was not found.

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

        {

        SVPDEBUG1("CSVPUtility::SetAudioCodecsMOL KErrNotFound");

        User::Leave( KErrNotFound );

        }

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

    }

// ---------------------------------------------------------------------------

// CSVPUtility::SetKeepAliveL

// ---------------------------------------------------------------------------

//

void CSVPUtility::SetKeepAliveL( CMceAudioStream& aAudioStream,

                                 TInt aKeepAliveValue )

    {

    SVPDEBUG1( "CSVPUtility::SetKeepAliveL In ")

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

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

    // values should be set to bound stream also

    CMceAudioStream& boundStream = 

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

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

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

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

                     User::Leave( KSVPErrCodecMismatch ) );

    TInt maxPl( 0 );

    TInt minPl( 0 );

    // first check the max payload in the codec set

    while ( count-- )

        {

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

        if ( minPl > maxPl )

            {

            maxPl = minPl;

            }  

        }

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

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

    if ( KSVPDefKeepAlivePl > maxPl )

        {

        while( count-- )

            {

            SVPDEBUG1( "CSVPUtility::SetKeepAliveL A ")

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

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

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

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

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

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

            }

        }

    else if ( KSVPDefKeepAlivePlMax > maxPl )

        {

        while( count-- )

            {

            SVPDEBUG1( "CSVPUtility::SetKeepAliveL B ")

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

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

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

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

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

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

            }

        }

    SVPDEBUG1( "CSVPUtility::SetKeepAliveL Out ")

    }

// ---------------------------------------------------------------------------

// CSVPUtility::SetCNKeepAliveL

// ---------------------------------------------------------------------------

//

void CSVPUtility::SetCNKeepAliveL( CMceAudioStream& aAudioStream,

                                   TInt aKeepAliveValue )

    {

    SVPDEBUG1( "CSVPUtility::SetCNKeepAliveL In ")

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

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

    TInt mostPreferred = 0; 

    // bound stream should be present always

    CMceAudioStream& boundStream = 

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

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

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

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

                     User::Leave( KSVPErrCodecMismatch ) );

    // find most preferred codec and set keepalive timer

    // value and payload for most preferred codec

    while( count-- )

        {

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

        // handle only real audio codecs

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

            {

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

                {

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

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

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

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

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

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

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

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

                mostPreferred = count;

                }

           }

        }

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

    while ( count-- )

        {

        if ( mostPreferred != count )

            {

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

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

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

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

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

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

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

            }

        }

    SVPDEBUG1( "CSVPUtility::SetCNKeepAliveL Out ")

    }

// ---------------------------------------------------------------------------

// CSVPUtility::IsComfortNoise

// ---------------------------------------------------------------------------

//

TBool CSVPUtility::IsComfortNoise( CMceAudioStream& aStream )

    {

    SVPDEBUG1( "CSVPUtility::IsComfortNoise In ")

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

    while ( count-- )

        {

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

            {

            return ETrue;

            }

        }

    return EFalse;

    }

// ---------------------------------------------------------------------------

// CSVPUtility::SetAudioCodecsForEmergencyL

// ---------------------------------------------------------------------------

//

void CSVPUtility::SetAudioCodecsForEmergencyL( 

    CMceAudioStream& aAudioInStream,

    TInt aKeepAliveValue, 

    TInt32 aVoipProfileId )

    {

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

    // clear codec priority preferrence variable

    iPreferredCodec = 0;

    // Default profile

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

    // Set codecs

    if ( KErrNotFound == aVoipProfileId )

        {

        // No VoIP profile, use default profile values

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

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

        // capabilities

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

        codec->SetDefaultCodecValueSet( KAudioCodecPCMA() );

        MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

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

        codec->SetDefaultCodecValueSet( KAudioCodecPCMU() );

        MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

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

        codec->SetDefaultCodecValueSet( KAudioCodecAMR() );

        MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

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

        codec->SetDefaultCodecValueSet( KAudioCodeciLBC() );

        MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

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

        codec->SetDefaultCodecValueSet( KAudioCodecG729() );

        MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

        }

    else

        {

        // VoIP profile exists

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

        User::LeaveIfError( aVoipProfileId );

        // Get codec IDs from profile

        CRCSEProfileRegistry* profileRegistry = 

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

        profileRegistry->FindL( aVoipProfileId, *profile );

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

        RArray< TUint32 > codecIds;

        CleanupClosePushL( codecIds ); // CS:2

        GetCodecIdsByVoIPProfileIdL( *profile, codecIds );

        // Set flags

        TBool isSetPCMA( EFalse );

        TBool isSetPCMU( EFalse );

        // Set capabilities

        CRCSEAudioCodecRegistry* codecRegistry = 

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

        CRCSEAudioCodecEntry* codec = NULL;

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

            {

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

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

            MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

            // Check G711

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

                {

                isSetPCMA = ETrue;

                }

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

                {

                isSetPCMU = ETrue;

                }

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

            }

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

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

        // Set G711 default capabilities if not set from profile

        if ( !isSetPCMA )

            {

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

            codec->SetDefaultCodecValueSet( KAudioCodecPCMA() );

            MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

            }

        if ( !isSetPCMU )

            {

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

            codec->SetDefaultCodecValueSet( KAudioCodecPCMU() );

            MoCallCapabilitiesL( aAudioInStream, *profile, *codec );

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

            }

        }

    SetDtmfL( *profile, aAudioInStream );

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

    // in Mo case, redundancy is never offered

    iRed = EFalse;

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

    if ( iCN )

        {

        SetComfortNoiseL( aAudioInStream );

        RemoveUnnecessaryCodecsL( aAudioInStream );

        SetCNKeepAliveL( aAudioInStream, aKeepAliveValue );

        }

    else

        {

        RemoveUnnecessaryCodecsL( aAudioInStream );

        SetKeepAliveL( aAudioInStream, aKeepAliveValue );

        }

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

    // the actual RTP sink is residing

    CheckRtcpSettingL( profile->iRTCP, aAudioInStream );

    if ( aAudioInStream.BoundStream() )

        {

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

        }

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

    // Leave if codec information was not found.

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

        {

        SVPDEBUG1("CSVPUtility::SetAudioCodecsForEmergencyL KErrNotFound")

        User::Leave( KErrNotFound );

        }

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

    }

// ---------------------------------------------------------------------------

// CSVPUtility::SetComfortNoiseL

// ---------------------------------------------------------------------------

//  

void CSVPUtility::SetComfortNoiseL( CMceAudioStream& aAudioStream )

    {

    SVPDEBUG1("CSVPUtility::SetComfortNoiseL In");

    // fetch available codecs

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

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

    CMceAudioStream& boundStream = 

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

    // fetch bound stream codecs 

    const RPointerArray< CMceAudioCodec >& 

        boundCodecs = boundStream.Codecs();

    iCN = EFalse;

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

        {

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

            {

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

            // enable CN from main and bound stream

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